1
# Copyright (C) 2005, 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Transport for the local filesystem.
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(), """
37
from bzrlib.trace import mutter
38
from bzrlib.transport import LateReadError
41
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
48
class LocalTransport(Transport):
49
"""This is the transport agent for local filesystem access."""
51
def __init__(self, base):
52
"""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)
65
super(LocalTransport, self).__init__(base)
66
self._local_base = urlutils.local_path_from_url(base)
68
def should_cache(self):
71
def clone(self, offset=None):
72
"""Return a new LocalTransport with root at self.base + offset
73
Because the local filesystem does not require a connection,
74
we can just return a new object.
77
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)
98
def abspath(self, relpath):
99
"""Return the full url to the given relative URL."""
100
# TODO: url escape the result. RBC 20060523.
101
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)
123
def relpath(self, abspath):
124
"""Return the local path portion from a given absolute path.
129
return urlutils.file_relpath(
130
urlutils.strip_trailing_slash(self.base),
131
urlutils.strip_trailing_slash(abspath))
133
def has(self, relpath):
134
return os.access(self._abspath(relpath), os.F_OK)
136
def get(self, relpath):
137
"""Get the file at the given relative path.
139
:param relpath: The relative path to the file
142
path = self._abspath(relpath)
143
return open(path, 'rb')
144
except (IOError, OSError),e:
145
if e.errno == errno.EISDIR:
146
return LateReadError(relpath)
147
self._translate_error(e, path)
149
def put_file(self, relpath, f, mode=None):
150
"""Copy the file-like object into the location.
152
: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
160
path = self._abspath(relpath)
161
osutils.check_legal_path(path)
162
fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
163
except (IOError, OSError),e:
164
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
def iter_files_recursive(self):
273
"""Iter the relative paths of files in the transports sub-tree."""
274
queue = list(self.list_dir(u'.'))
276
relpath = queue.pop(0)
277
st = self.stat(relpath)
278
if S_ISDIR(st[ST_MODE]):
279
for i, basename in enumerate(self.list_dir(relpath)):
280
queue.insert(i, relpath+'/'+basename)
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
def mkdir(self, relpath, mode=None):
301
"""Create a directory at the given path."""
302
self._mkdir(self._abspath(relpath), mode=mode)
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
313
return file_abspath, os.open(file_abspath, _append_flags, local_mode)
314
except (IOError, OSError),e:
315
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
def copy(self, rel_from, rel_to):
356
"""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)
360
shutil.copy(path_from, path_to)
361
except (IOError, OSError),e:
362
# TODO: What about path_to?
363
self._translate_error(e, path_from)
365
def rename(self, rel_from, rel_to):
366
path_from = self._abspath(rel_from)
368
# *don't* call bzrlib.osutils.rename, because we want to
369
# detect errors on rename
370
os.rename(path_from, self._abspath(rel_to))
371
except (IOError, OSError),e:
372
# TODO: What about path_to?
373
self._translate_error(e, path_from)
375
def move(self, rel_from, rel_to):
376
"""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)
381
# this version will delete the destination if necessary
382
osutils.rename(path_from, path_to)
383
except (IOError, OSError),e:
384
# TODO: What about path_to?
385
self._translate_error(e, path_from)
387
def delete(self, relpath):
388
"""Delete the item at relpath"""
391
path = self._abspath(relpath)
393
except (IOError, OSError),e:
394
self._translate_error(e, path)
396
def copy_to(self, relpaths, other, mode=None, pb=None):
397
"""Copy a set of entries from self into another Transport.
399
:param relpaths: A list/generator of entries to be copied.
401
if isinstance(other, LocalTransport):
402
# Both from & to are on the local filesystem
403
# Unfortunately, I can't think of anything faster than just
404
# copying them across, one by one :(
405
total = self._get_total(relpaths)
407
for path in relpaths:
408
self._update_pb(pb, 'copy-to', count, total)
410
mypath = self._abspath(path)
411
otherpath = other._abspath(path)
412
shutil.copy(mypath, otherpath)
414
os.chmod(otherpath, mode)
415
except (IOError, OSError),e:
416
self._translate_error(e, path)
420
return super(LocalTransport, self).copy_to(relpaths, other, mode=mode, pb=pb)
423
"""See Transport.listable."""
426
def list_dir(self, relpath):
427
"""Return a list of all files at the given location.
428
WARNING: many transports do not support this, so trying avoid using
429
it if at all possible.
431
path = self._abspath(relpath)
433
entries = os.listdir(path)
434
except (IOError, OSError), e:
435
self._translate_error(e, path)
436
return [urlutils.escape(entry) for entry in entries]
438
def stat(self, relpath):
439
"""Return the stat information for a file.
443
path = self._abspath(relpath)
445
except (IOError, OSError),e:
446
self._translate_error(e, path)
448
def lock_read(self, relpath):
449
"""Lock the given file for shared (read) access.
450
:return: A lock object, which should be passed to Transport.unlock()
452
from bzrlib.lock import ReadLock
455
path = self._abspath(relpath)
456
return ReadLock(path)
457
except (IOError, OSError), e:
458
self._translate_error(e, path)
460
def lock_write(self, relpath):
461
"""Lock the given file for exclusive (write) access.
462
WARNING: many transports do not support this, so trying avoid using it
464
:return: A lock object, which should be passed to Transport.unlock()
466
from bzrlib.lock import WriteLock
467
return WriteLock(self._abspath(relpath))
469
def rmdir(self, relpath):
470
"""See Transport.rmdir."""
473
path = self._abspath(relpath)
475
except (IOError, OSError),e:
476
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.
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.
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('')
536
def get_test_permutations():
537
"""Return the permutations to be used in testing."""
539
(LocalTransport, LocalURLServer),
added
removed
bzrlib/transport/local.py
