1
1
# Copyright (C) 2005, 2006 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""Transport for the local filesystem.
19
This is a fairly thin wrapper on regular file IO.
19
This is a fairly thin wrapper on regular file IO."""
23
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
26
from bzrlib.lazy_import import lazy_import
27
lazy_import(globals(), """
23
from stat import ST_MODE, S_ISDIR, ST_SIZE
37
27
from bzrlib.trace import mutter
38
from bzrlib.transport import LateReadError
41
28
from bzrlib.transport import Transport, Server
44
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY
45
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY
29
from bzrlib.osutils import abspath, realpath, normpath, pathjoin, rename
48
32
class LocalTransport(Transport):
51
35
def __init__(self, base):
52
36
"""Set the base path where files will be stored."""
53
if not base.startswith('file://'):
54
symbol_versioning.warn(
55
"Instantiating LocalTransport with a filesystem path"
56
" is deprecated as of bzr 0.8."
57
" Please use bzrlib.transport.get_transport()"
58
" or pass in a file:// url.",
62
base = urlutils.local_path_to_url(base)
37
if base.startswith('file://'):
38
base = base[len('file://'):]
39
# realpath is incompatible with symlinks. When we traverse
40
# up we might be able to normpath stuff. RBC 20051003
41
base = normpath(abspath(base))
63
42
if base[-1] != '/':
65
44
super(LocalTransport, self).__init__(base)
66
self._local_base = urlutils.local_path_from_url(base)
68
46
def should_cache(self):
77
55
return LocalTransport(self.base)
79
abspath = self.abspath(offset)
80
if abspath == 'file://':
81
# fix upwalk for UNC path
82
# when clone from //HOST/path updir recursively
83
# we should stop at least at //HOST part
85
return LocalTransport(abspath)
87
def _abspath(self, relative_reference):
88
"""Return a path for use in os calls.
90
Several assumptions are made:
91
- relative_reference does not contain '..'
92
- relative_reference is url escaped.
94
if relative_reference in ('.', ''):
95
return self._local_base
96
return self._local_base + urlutils.unescape(relative_reference)
57
return LocalTransport(self.abspath(offset))
98
59
def abspath(self, relpath):
99
"""Return the full url to the given relative URL."""
100
# TODO: url escape the result. RBC 20060523.
60
"""Return the full url to the given relative URL.
61
This can be supplied with a string or a list
101
63
assert isinstance(relpath, basestring), (type(relpath), relpath)
102
# jam 20060426 Using normpath on the real path, because that ensures
103
# proper handling of stuff like
104
path = osutils.normpath(osutils.pathjoin(
105
self._local_base, urlutils.unescape(relpath)))
106
return urlutils.local_path_to_url(path)
108
def local_abspath(self, relpath):
109
"""Transform the given relative path URL into the actual path on disk
111
This function only exists for the LocalTransport, since it is
112
the only one that has direct local access.
113
This is mostly for stuff like WorkingTree which needs to know
114
the local working directory.
116
This function is quite expensive: it calls realpath which resolves
119
absurl = self.abspath(relpath)
120
# mutter(u'relpath %s => base: %s, absurl %s', relpath, self.base, absurl)
121
return urlutils.local_path_from_url(absurl)
64
return pathjoin(self.base, urllib.unquote(relpath))
123
66
def relpath(self, abspath):
124
67
"""Return the local path portion from a given absolute path.
69
from bzrlib.osutils import relpath
126
70
if abspath is None:
129
return urlutils.file_relpath(
130
urlutils.strip_trailing_slash(self.base),
131
urlutils.strip_trailing_slash(abspath))
72
if abspath.endswith('/'):
73
abspath = abspath[:-1]
74
return relpath(self.base[:-1], abspath)
133
76
def has(self, relpath):
134
return os.access(self._abspath(relpath), os.F_OK)
77
return os.access(self.abspath(relpath), os.F_OK)
136
79
def get(self, relpath):
137
80
"""Get the file at the given relative path.
139
82
:param relpath: The relative path to the file
142
path = self._abspath(relpath)
85
path = self.abspath(relpath)
143
86
return open(path, 'rb')
144
87
except (IOError, OSError),e:
145
if e.errno == errno.EISDIR:
146
return LateReadError(relpath)
147
88
self._translate_error(e, path)
149
def put_file(self, relpath, f, mode=None):
150
"""Copy the file-like object into the location.
90
def put(self, relpath, f, mode=None):
91
"""Copy the file-like or string object into the location.
152
93
:param relpath: Location to put the contents, relative to base.
153
:param f: File-like object.
154
:param mode: The mode for the newly created file,
155
None means just use the default
94
:param f: File-like or string object.
96
from bzrlib.atomicfile import AtomicFile
160
path = self._abspath(relpath)
161
osutils.check_legal_path(path)
162
fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
100
path = self.abspath(relpath)
101
fp = AtomicFile(path, 'wb', new_mode=mode)
163
102
except (IOError, OSError),e:
164
103
self._translate_error(e, path)
171
def put_bytes(self, relpath, bytes, mode=None):
172
"""Copy the string into the location.
174
:param relpath: Location to put the contents, relative to base.
180
path = self._abspath(relpath)
181
osutils.check_legal_path(path)
182
fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
183
except (IOError, OSError),e:
184
self._translate_error(e, path)
191
def _put_non_atomic_helper(self, relpath, writer,
193
create_parent_dir=False,
195
"""Common functionality information for the put_*_non_atomic.
197
This tracks all the create_parent_dir stuff.
199
:param relpath: the path we are putting to.
200
:param writer: A function that takes an os level file descriptor
201
and writes whatever data it needs to write there.
202
:param mode: The final file mode.
203
:param create_parent_dir: Should we be creating the parent directory
206
abspath = self._abspath(relpath)
208
# os.open() will automatically use the umask
213
fd = os.open(abspath, _put_non_atomic_flags, local_mode)
214
except (IOError, OSError),e:
215
# We couldn't create the file, maybe we need to create
216
# the parent directory, and try again
217
if (not create_parent_dir
218
or e.errno not in (errno.ENOENT,errno.ENOTDIR)):
219
self._translate_error(e, relpath)
220
parent_dir = os.path.dirname(abspath)
222
self._translate_error(e, relpath)
223
self._mkdir(parent_dir, mode=dir_mode)
224
# We created the parent directory, lets try to open the
227
fd = os.open(abspath, _put_non_atomic_flags, local_mode)
228
except (IOError, OSError), e:
229
self._translate_error(e, relpath)
232
if mode is not None and mode != S_IMODE(st.st_mode):
233
# Because of umask, we may still need to chmod the file.
234
# But in the general case, we won't have to
235
os.chmod(abspath, mode)
240
def put_file_non_atomic(self, relpath, f, mode=None,
241
create_parent_dir=False,
243
"""Copy the file-like object into the target location.
245
This function is not strictly safe to use. It is only meant to
246
be used when you already know that the target does not exist.
247
It is not safe, because it will open and truncate the remote
248
file. So there may be a time when the file has invalid contents.
250
:param relpath: The remote location to put the contents.
251
:param f: File-like object.
252
:param mode: Possible access permissions for new file.
253
None means do not set remote permissions.
254
:param create_parent_dir: If we cannot create the target file because
255
the parent directory does not exist, go ahead and
256
create it, and then try again.
259
self._pump_to_fd(f, fd)
260
self._put_non_atomic_helper(relpath, writer, mode=mode,
261
create_parent_dir=create_parent_dir,
264
def put_bytes_non_atomic(self, relpath, bytes, mode=None,
265
create_parent_dir=False, dir_mode=None):
268
self._put_non_atomic_helper(relpath, writer, mode=mode,
269
create_parent_dir=create_parent_dir,
272
110
def iter_files_recursive(self):
273
111
"""Iter the relative paths of files in the transports sub-tree."""
274
112
queue = list(self.list_dir(u'.'))
284
def _mkdir(self, abspath, mode=None):
285
"""Create a real directory, filtering through mode"""
287
# os.mkdir() will filter through umask
292
os.mkdir(abspath, local_mode)
294
# It is probably faster to just do the chmod, rather than
295
# doing a stat, and then trying to compare
296
os.chmod(abspath, mode)
297
except (IOError, OSError),e:
298
self._translate_error(e, abspath)
300
122
def mkdir(self, relpath, mode=None):
301
123
"""Create a directory at the given path."""
302
self._mkdir(self._abspath(relpath), mode=mode)
126
path = self.abspath(relpath)
130
except (IOError, OSError),e:
131
self._translate_error(e, path)
304
def _get_append_file(self, relpath, mode=None):
305
"""Call os.open() for the given relpath"""
306
file_abspath = self._abspath(relpath)
308
# os.open() will automatically use the umask
133
def append(self, relpath, f):
134
"""Append the text in the file-like object into the final
313
return file_abspath, os.open(file_abspath, _append_flags, local_mode)
138
fp = open(self.abspath(relpath), 'ab')
314
139
except (IOError, OSError),e:
315
140
self._translate_error(e, relpath)
317
def _check_mode_and_size(self, file_abspath, fd, mode=None):
318
"""Check the mode of the file, and return the current size"""
320
if mode is not None and mode != S_IMODE(st.st_mode):
321
# Because of umask, we may still need to chmod the file.
322
# But in the general case, we won't have to
323
os.chmod(file_abspath, mode)
326
def append_file(self, relpath, f, mode=None):
327
"""Append the text in the file-like object into the final location."""
328
file_abspath, fd = self._get_append_file(relpath, mode=mode)
330
result = self._check_mode_and_size(file_abspath, fd, mode=mode)
331
self._pump_to_fd(f, fd)
336
def append_bytes(self, relpath, bytes, mode=None):
337
"""Append the text in the string into the final location."""
338
file_abspath, fd = self._get_append_file(relpath, mode=mode)
340
result = self._check_mode_and_size(file_abspath, fd, mode=mode)
346
def _pump_to_fd(self, fromfile, to_fd):
347
"""Copy contents of one file to another."""
350
b = fromfile.read(BUFSIZE)
355
145
def copy(self, rel_from, rel_to):
356
146
"""Copy the item at rel_from to the location at rel_to"""
357
path_from = self._abspath(rel_from)
358
path_to = self._abspath(rel_to)
148
path_from = self.abspath(rel_from)
149
path_to = self.abspath(rel_to)
360
151
shutil.copy(path_from, path_to)
361
152
except (IOError, OSError),e:
363
154
self._translate_error(e, path_from)
365
156
def rename(self, rel_from, rel_to):
366
path_from = self._abspath(rel_from)
157
path_from = self.abspath(rel_from)
368
159
# *don't* call bzrlib.osutils.rename, because we want to
369
160
# detect errors on rename
370
os.rename(path_from, self._abspath(rel_to))
161
os.rename(path_from, self.abspath(rel_to))
371
162
except (IOError, OSError),e:
372
163
# TODO: What about path_to?
373
164
self._translate_error(e, path_from)
375
166
def move(self, rel_from, rel_to):
376
167
"""Move the item at rel_from to the location at rel_to"""
377
path_from = self._abspath(rel_from)
378
path_to = self._abspath(rel_to)
168
path_from = self.abspath(rel_from)
169
path_to = self.abspath(rel_to)
381
172
# this version will delete the destination if necessary
382
osutils.rename(path_from, path_to)
173
rename(path_from, path_to)
383
174
except (IOError, OSError),e:
384
175
# TODO: What about path_to?
385
176
self._translate_error(e, path_from)
402
194
# Both from & to are on the local filesystem
403
195
# Unfortunately, I can't think of anything faster than just
404
196
# copying them across, one by one :(
405
199
total = self._get_total(relpaths)
407
201
for path in relpaths:
408
202
self._update_pb(pb, 'copy-to', count, total)
410
mypath = self._abspath(path)
411
otherpath = other._abspath(path)
204
mypath = self.abspath(path)
205
otherpath = other.abspath(path)
412
206
shutil.copy(mypath, otherpath)
413
207
if mode is not None:
414
208
os.chmod(otherpath, mode)
428
222
WARNING: many transports do not support this, so trying avoid using
429
223
it if at all possible.
431
path = self._abspath(relpath)
225
path = self.abspath(relpath)
433
entries = os.listdir(path)
227
return [urllib.quote(entry) for entry in os.listdir(path)]
434
228
except (IOError, OSError), e:
435
229
self._translate_error(e, path)
436
return [urlutils.escape(entry) for entry in entries]
438
231
def stat(self, relpath):
439
232
"""Return the stat information for a file.
443
path = self._abspath(relpath)
236
path = self.abspath(relpath)
444
237
return os.stat(path)
445
238
except (IOError, OSError),e:
446
239
self._translate_error(e, path)
464
257
:return: A lock object, which should be passed to Transport.unlock()
466
259
from bzrlib.lock import WriteLock
467
return WriteLock(self._abspath(relpath))
260
return WriteLock(self.abspath(relpath))
469
262
def rmdir(self, relpath):
470
263
"""See Transport.rmdir."""
473
path = self._abspath(relpath)
266
path = self.abspath(relpath)
475
268
except (IOError, OSError),e:
476
269
self._translate_error(e, path)
478
def _can_roundtrip_unix_modebits(self):
479
if sys.platform == 'win32':
486
class EmulatedWin32LocalTransport(LocalTransport):
487
"""Special transport for testing Win32 [UNC] paths on non-windows"""
489
def __init__(self, base):
492
super(LocalTransport, self).__init__(base)
493
self._local_base = urlutils._win32_local_path_from_url(base)
495
def abspath(self, relpath):
496
assert isinstance(relpath, basestring), (type(relpath), relpath)
497
path = osutils.normpath(osutils.pathjoin(
498
self._local_base, urlutils.unescape(relpath)))
499
return urlutils._win32_local_path_to_url(path)
501
def clone(self, offset=None):
502
"""Return a new LocalTransport with root at self.base + offset
503
Because the local filesystem does not require a connection,
504
we can just return a new object.
507
return EmulatedWin32LocalTransport(self.base)
509
abspath = self.abspath(offset)
510
if abspath == 'file://':
511
# fix upwalk for UNC path
512
# when clone from //HOST/path updir recursively
513
# we should stop at least at //HOST part
515
return EmulatedWin32LocalTransport(abspath)
518
class LocalURLServer(Server):
519
"""A pretend server for local transports, using file:// urls.
272
class ScratchTransport(LocalTransport):
273
"""A transport that works in a temporary dir and cleans up after itself.
521
Of course no actual server is required to access the local filesystem, so
522
this just exists to tell the test code how to get to it.
275
The dir only exists for the lifetime of the Python object.
276
Obviously you should not put anything precious in it.
526
"""Setup the server to service requests.
528
:param decorated_transport: ignored by this implementation.
532
"""See Transport.Server.get_url."""
533
return urlutils.local_path_to_url('')
279
def __init__(self, base=None):
281
base = tempfile.mkdtemp()
282
super(ScratchTransport, self).__init__(base)
285
shutil.rmtree(self.base, ignore_errors=True)
286
mutter("%r destroyed" % self)
289
class LocalRelpathServer(Server):
290
"""A pretend server for local transports, using relpaths."""
293
"""See Transport.Server.get_url."""
297
class LocalAbspathServer(Server):
298
"""A pretend server for local transports, using absolute paths."""
301
"""See Transport.Server.get_url."""
302
return os.path.abspath("")
305
class LocalURLServer(Server):
306
"""A pretend server for local transports, using file:// urls."""
309
"""See Transport.Server.get_url."""
310
# FIXME: \ to / on windows
311
return "file://%s" % os.path.abspath("")
536
314
def get_test_permutations():
537
315
"""Return the permutations to be used in testing."""
316
return [(LocalTransport, LocalRelpathServer),
317
(LocalTransport, LocalAbspathServer),
539
318
(LocalTransport, LocalURLServer),
added
removed
bzrlib/transport/local.py
