summaryrefslogtreecommitdiffstats
path: root/BuildManager/fileutil.py
blob: aeba0eb935e9c08e0ce32221c557f25acf90df1d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
# This module was originally part of distutils.
from BuildManager import *
import os

__all__ = ["copy_file", "move_file"]

# for generating verbose output in 'copy_file()'
_copy_action = { None:   'copying',
                 'hard': 'hard linking',
                 'sym':  'symbolically linking' }


def _copy_file_contents (src, dst, buffer_size=16*1024):
    """Copy the file 'src' to 'dst'; both must be filenames.  Any error
    opening either file, reading from 'src', or writing to 'dst', raises
    BuildManagerFileError.  Data is read/written in chunks of 'buffer_size'
    bytes (default 16k).  No attempt is made to handle anything apart from
    regular files.
    """
    # Stolen from shutil module in the standard library, but with
    # custom error-handling added.

    fsrc = None
    fdst = None
    try:
        try:
            fsrc = open(src, 'rb')
        except os.error as xxx_todo_changeme2:
            (errno, errstr) = xxx_todo_changeme2.args
            raise Error("could not open %s: %s" % (src, errstr))
        
        try:
            fdst = open(dst, 'wb')
        except os.error as xxx_todo_changeme3:
            (errno, errstr) = xxx_todo_changeme3.args
            raise Error("could not create %s: %s" % (dst, errstr))
        
        while 1:
            try:
                buf = fsrc.read(buffer_size)
            except os.error as xxx_todo_changeme:
                (errno, errstr) = xxx_todo_changeme.args
                raise Error("could not read from %s: %s" % (src, errstr))
            
            if not buf:
                break

            try:
                fdst.write(buf)
            except os.error as xxx_todo_changeme1:
                (errno, errstr) = xxx_todo_changeme1.args
                raise Error("could not write to %s: %s" % (dst, errstr))
            
    finally:
        if fdst:
            fdst.close()
        if fsrc:
            fsrc.close()

def copy_file (src, dst, preserve_mode=1, preserve_times=1, link=None,
               dryrun=False):

    """Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is
    copied there with the same name; otherwise, it must be a filename.  (If
    the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode'
    is true (the default), the file's mode (type and permission bits, or
    whatever is analogous on the current platform) is copied.  If
    'preserve_times' is true (the default), the last-modified and
    last-access times are copied as well. 

    'link' allows you to make hard links (os.link) or symbolic links
    (os.symlink) instead of copying: set it to "hard" or "sym"; if it is
    None (the default), files are copied.  Don't set 'link' on systems that
    don't support it: 'copy_file()' doesn't check if hard or symbolic
    linking is available.

    Under Mac OS, uses the native file copy function in macostools; on
    other systems, uses '_copy_file_contents()' to copy file contents.

    Return a tuple (dest_name, copied): 'dest_name' is the actual name of
    the output file, and 'copied' is true if the file was copied (or would
    have been copied, if 'dryrun' true).
    """
    from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE

    if not os.path.isfile(src):
        raise Error("can't copy '%s': " \
                     "doesn't exist or not a regular file" % src)

    if os.path.isdir(dst):
        dir = dst
        dst = os.path.join(dst, os.path.basename(src))
    else:
        dir = os.path.dirname(dst)

    try:
        action = _copy_action[link]
    except KeyError:
        raise ValueError("invalid value '%s' for 'link' argument" % link)
    if os.path.basename(dst) == os.path.basename(src):
        logger.info("%s %s to %s" % (action, src, dir))
    else:
        logger.info("%s %s to %s" % (action, src, dst))
            
    if dryrun:
        return (dst, 1)

    # If linking (hard or symbolic), use the appropriate system call
    # (Unix only, of course, but that's the caller's responsibility)
    if link == 'hard':
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            os.link(src, dst)
    elif link == 'sym':
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            os.symlink(src, dst)

    # Otherwise (not linking), copy the file contents and
    # (optionally) copy the times and mode.
    else:
        _copy_file_contents(src, dst)
        if preserve_mode or preserve_times:
            st = os.stat(src)
            if preserve_times:
                os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
            if preserve_mode:
                os.chmod(dst, S_IMODE(st[ST_MODE]))

    return (dst, 1)

def move_file (src, dst, dryrun=False):

    """Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will
    be moved into it with the same name; otherwise, 'src' is just renamed
    to 'dst'.  Return the new full name of the file.

    Handles cross-device moves on Unix using 'copy_file()'.  What about
    other systems???
    """
    from os.path import exists, isfile, isdir, basename, dirname
    import errno
    
    logger.info("moving %s to %s" % (src, dst))

    if dryrun:
        return dst

    if not isfile(src):
        raise Error("can't move %s: not a regular file" % src)

    if isdir(dst):
        dst = os.path.join(dst, basename(src))
    elif exists(dst):
        raise Error("can't move %s: destination %s already exists" % \
                     (src, dst))

    if not isdir(dirname(dst)):
        raise Error("can't move %s: destination %s not a valid path" % \
                     (src, dst))

    copy_it = 0
    try:
        os.rename(src, dst)
    except os.error as xxx_todo_changeme5:
        (num, msg) = xxx_todo_changeme5.args
        if num == errno.EXDEV:
            copy_it = 1
        else:
            raise Error("couldn't move %s to %s: %s" % (src, dst, msg))

    if copy_it:
        copy_file(src, dst)
        try:
            os.unlink(src)
        except os.error as xxx_todo_changeme4:
            (num, msg) = xxx_todo_changeme4.args
            try:
                os.unlink(dst)
            except os.error:
                pass
            raise Error("couldn't move %s to %s by copy/delete: " \
                         "delete %s failed: %s" % (src, dst, src, msg))

    return dst

def write_file (filename, contents):
    """Create a file with the specified name and write 'contents' (a
    sequence of strings without line terminators) to it.
    """
    f = open(filename, "w")
    for line in contents:
        f.write(line + "\n")
    f.close()