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()
|
