~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-01 13:53:24 UTC
  • mfrom: (4990.1.2 rm-obsolete)
  • Revision ID: pqm@pqm.ubuntu.com-20100201135324-cuhuolr97guf5xjp
(Jelmer) Remove obsolete (and broken) biobench and history2revfiles
        tools.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
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.
 
7
#
 
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.
 
12
#
 
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Transport for the local filesystem.
 
18
 
 
19
This is a fairly thin wrapper on regular file IO.
 
20
"""
 
21
 
 
22
import os
 
23
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
 
24
import sys
 
25
 
 
26
from bzrlib.lazy_import import lazy_import
 
27
lazy_import(globals(), """
 
28
import errno
 
29
import shutil
 
30
 
 
31
from bzrlib import (
 
32
    atomicfile,
 
33
    osutils,
 
34
    urlutils,
 
35
    symbol_versioning,
 
36
    transport,
 
37
    )
 
38
from bzrlib.trace import mutter
 
39
from bzrlib.transport import LateReadError
 
40
""")
 
41
 
 
42
from bzrlib.transport import Transport, Server
 
43
 
 
44
 
 
45
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY
 
46
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY
 
47
 
 
48
 
 
49
class LocalTransport(Transport):
 
50
    """This is the transport agent for local filesystem access."""
 
51
 
 
52
    def __init__(self, base):
 
53
        """Set the base path where files will be stored."""
 
54
        if not base.startswith('file://'):
 
55
            symbol_versioning.warn(
 
56
                "Instantiating LocalTransport with a filesystem path"
 
57
                " is deprecated as of bzr 0.8."
 
58
                " Please use bzrlib.transport.get_transport()"
 
59
                " or pass in a file:// url.",
 
60
                 DeprecationWarning,
 
61
                 stacklevel=2
 
62
                 )
 
63
            base = urlutils.local_path_to_url(base)
 
64
        if base[-1] != '/':
 
65
            base = base + '/'
 
66
 
 
67
        # Special case : windows has no "root", but does have
 
68
        # multiple lettered drives inside it. #240910
 
69
        if sys.platform == 'win32' and base == 'file:///':
 
70
            base = ''
 
71
            self._local_base = ''
 
72
            super(LocalTransport, self).__init__(base)
 
73
            return
 
74
 
 
75
        super(LocalTransport, self).__init__(base)
 
76
        self._local_base = urlutils.local_path_from_url(base)
 
77
 
 
78
    def clone(self, offset=None):
 
79
        """Return a new LocalTransport with root at self.base + offset
 
80
        Because the local filesystem does not require a connection,
 
81
        we can just return a new object.
 
82
        """
 
83
        if offset is None:
 
84
            return LocalTransport(self.base)
 
85
        else:
 
86
            abspath = self.abspath(offset)
 
87
            if abspath == 'file://':
 
88
                # fix upwalk for UNC path
 
89
                # when clone from //HOST/path updir recursively
 
90
                # we should stop at least at //HOST part
 
91
                abspath = self.base
 
92
            return LocalTransport(abspath)
 
93
 
 
94
    def _abspath(self, relative_reference):
 
95
        """Return a path for use in os calls.
 
96
 
 
97
        Several assumptions are made:
 
98
         - relative_reference does not contain '..'
 
99
         - relative_reference is url escaped.
 
100
        """
 
101
        if relative_reference in ('.', ''):
 
102
            return self._local_base
 
103
        return self._local_base + urlutils.unescape(relative_reference)
 
104
 
 
105
    def abspath(self, relpath):
 
106
        """Return the full url to the given relative URL."""
 
107
        # TODO: url escape the result. RBC 20060523.
 
108
        # jam 20060426 Using normpath on the real path, because that ensures
 
109
        #       proper handling of stuff like
 
110
        path = osutils.normpath(osutils.pathjoin(
 
111
                    self._local_base, urlutils.unescape(relpath)))
 
112
        # on windows, our _local_base may or may not have a drive specified
 
113
        # (ie, it may be "/" or "c:/foo").
 
114
        # If 'relpath' is '/' we *always* get back an abspath without
 
115
        # the drive letter - but if our transport already has a drive letter,
 
116
        # we want our abspaths to have a drive letter too - so handle that
 
117
        # here.
 
118
        if (sys.platform == "win32" and self._local_base[1:2] == ":"
 
119
            and path == '/'):
 
120
            path = self._local_base[:3]
 
121
 
 
122
        return urlutils.local_path_to_url(path)
 
123
 
 
124
    def local_abspath(self, relpath):
 
125
        """Transform the given relative path URL into the actual path on disk
 
126
 
 
127
        This function only exists for the LocalTransport, since it is
 
128
        the only one that has direct local access.
 
129
        This is mostly for stuff like WorkingTree which needs to know
 
130
        the local working directory.  The returned path will always contain
 
131
        forward slashes as the path separator, regardless of the platform.
 
132
 
 
133
        This function is quite expensive: it calls realpath which resolves
 
134
        symlinks.
 
135
        """
 
136
        absurl = self.abspath(relpath)
 
137
        # mutter(u'relpath %s => base: %s, absurl %s', relpath, self.base, absurl)
 
138
        return urlutils.local_path_from_url(absurl)
 
139
 
 
140
    def relpath(self, abspath):
 
141
        """Return the local path portion from a given absolute path.
 
142
        """
 
143
        if abspath is None:
 
144
            abspath = u'.'
 
145
 
 
146
        return urlutils.file_relpath(
 
147
            urlutils.strip_trailing_slash(self.base),
 
148
            urlutils.strip_trailing_slash(abspath))
 
149
 
 
150
    def has(self, relpath):
 
151
        return os.access(self._abspath(relpath), os.F_OK)
 
152
 
 
153
    def get(self, relpath):
 
154
        """Get the file at the given relative path.
 
155
 
 
156
        :param relpath: The relative path to the file
 
157
        """
 
158
        canonical_url = self.abspath(relpath)
 
159
        if canonical_url in transport._file_streams:
 
160
            transport._file_streams[canonical_url].flush()
 
161
        try:
 
162
            path = self._abspath(relpath)
 
163
            return open(path, 'rb')
 
164
        except (IOError, OSError),e:
 
165
            if e.errno == errno.EISDIR:
 
166
                return LateReadError(relpath)
 
167
            self._translate_error(e, path)
 
168
 
 
169
    def put_file(self, relpath, f, mode=None):
 
170
        """Copy the file-like object into the location.
 
171
 
 
172
        :param relpath: Location to put the contents, relative to base.
 
173
        :param f:       File-like object.
 
174
        :param mode: The mode for the newly created file,
 
175
                     None means just use the default
 
176
        """
 
177
 
 
178
        path = relpath
 
179
        try:
 
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)
 
185
        try:
 
186
            length = self._pump(f, fp)
 
187
            fp.commit()
 
188
        finally:
 
189
            fp.close()
 
190
        return length
 
191
 
 
192
    def put_bytes(self, relpath, bytes, mode=None):
 
193
        """Copy the string into the location.
 
194
 
 
195
        :param relpath: Location to put the contents, relative to base.
 
196
        :param bytes:   String
 
197
        """
 
198
 
 
199
        path = relpath
 
200
        try:
 
201
            path = self._abspath(relpath)
 
202
            osutils.check_legal_path(path)
 
203
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
 
204
        except (IOError, OSError),e:
 
205
            self._translate_error(e, path)
 
206
        try:
 
207
            if bytes:
 
208
                fp.write(bytes)
 
209
            fp.commit()
 
210
        finally:
 
211
            fp.close()
 
212
 
 
213
    def _put_non_atomic_helper(self, relpath, writer,
 
214
                               mode=None,
 
215
                               create_parent_dir=False,
 
216
                               dir_mode=None):
 
217
        """Common functionality information for the put_*_non_atomic.
 
218
 
 
219
        This tracks all the create_parent_dir stuff.
 
220
 
 
221
        :param relpath: the path we are putting to.
 
222
        :param writer: A function that takes an os level file descriptor
 
223
            and writes whatever data it needs to write there.
 
224
        :param mode: The final file mode.
 
225
        :param create_parent_dir: Should we be creating the parent directory
 
226
            if it doesn't exist?
 
227
        """
 
228
        abspath = self._abspath(relpath)
 
229
        if mode is None:
 
230
            # os.open() will automatically use the umask
 
231
            local_mode = 0666
 
232
        else:
 
233
            local_mode = mode
 
234
        try:
 
235
            fd = os.open(abspath, _put_non_atomic_flags, local_mode)
 
236
        except (IOError, OSError),e:
 
237
            # We couldn't create the file, maybe we need to create
 
238
            # the parent directory, and try again
 
239
            if (not create_parent_dir
 
240
                or e.errno not in (errno.ENOENT,errno.ENOTDIR)):
 
241
                self._translate_error(e, relpath)
 
242
            parent_dir = os.path.dirname(abspath)
 
243
            if not parent_dir:
 
244
                self._translate_error(e, relpath)
 
245
            self._mkdir(parent_dir, mode=dir_mode)
 
246
            # We created the parent directory, lets try to open the
 
247
            # file again
 
248
            try:
 
249
                fd = os.open(abspath, _put_non_atomic_flags, local_mode)
 
250
            except (IOError, OSError), e:
 
251
                self._translate_error(e, relpath)
 
252
        try:
 
253
            st = os.fstat(fd)
 
254
            if mode is not None and mode != S_IMODE(st.st_mode):
 
255
                # Because of umask, we may still need to chmod the file.
 
256
                # But in the general case, we won't have to
 
257
                os.chmod(abspath, mode)
 
258
            writer(fd)
 
259
        finally:
 
260
            os.close(fd)
 
261
 
 
262
    def put_file_non_atomic(self, relpath, f, mode=None,
 
263
                            create_parent_dir=False,
 
264
                            dir_mode=None):
 
265
        """Copy the file-like object into the target location.
 
266
 
 
267
        This function is not strictly safe to use. It is only meant to
 
268
        be used when you already know that the target does not exist.
 
269
        It is not safe, because it will open and truncate the remote
 
270
        file. So there may be a time when the file has invalid contents.
 
271
 
 
272
        :param relpath: The remote location to put the contents.
 
273
        :param f:       File-like object.
 
274
        :param mode:    Possible access permissions for new file.
 
275
                        None means do not set remote permissions.
 
276
        :param create_parent_dir: If we cannot create the target file because
 
277
                        the parent directory does not exist, go ahead and
 
278
                        create it, and then try again.
 
279
        """
 
280
        def writer(fd):
 
281
            self._pump_to_fd(f, fd)
 
282
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
283
                                    create_parent_dir=create_parent_dir,
 
284
                                    dir_mode=dir_mode)
 
285
 
 
286
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
 
287
                             create_parent_dir=False, dir_mode=None):
 
288
        def writer(fd):
 
289
            if bytes:
 
290
                os.write(fd, bytes)
 
291
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
292
                                    create_parent_dir=create_parent_dir,
 
293
                                    dir_mode=dir_mode)
 
294
 
 
295
    def iter_files_recursive(self):
 
296
        """Iter the relative paths of files in the transports sub-tree."""
 
297
        queue = list(self.list_dir(u'.'))
 
298
        while queue:
 
299
            relpath = queue.pop(0)
 
300
            st = self.stat(relpath)
 
301
            if S_ISDIR(st[ST_MODE]):
 
302
                for i, basename in enumerate(self.list_dir(relpath)):
 
303
                    queue.insert(i, relpath+'/'+basename)
 
304
            else:
 
305
                yield relpath
 
306
 
 
307
    def _mkdir(self, abspath, mode=None):
 
308
        """Create a real directory, filtering through mode"""
 
309
        if mode is None:
 
310
            # os.mkdir() will filter through umask
 
311
            local_mode = 0777
 
312
        else:
 
313
            local_mode = mode
 
314
        try:
 
315
            os.mkdir(abspath, local_mode)
 
316
            if mode is not None:
 
317
                # It is probably faster to just do the chmod, rather than
 
318
                # doing a stat, and then trying to compare
 
319
                os.chmod(abspath, mode)
 
320
        except (IOError, OSError),e:
 
321
            self._translate_error(e, abspath)
 
322
 
 
323
    def mkdir(self, relpath, mode=None):
 
324
        """Create a directory at the given path."""
 
325
        self._mkdir(self._abspath(relpath), mode=mode)
 
326
 
 
327
    def open_write_stream(self, relpath, mode=None):
 
328
        """See Transport.open_write_stream."""
 
329
        # initialise the file
 
330
        self.put_bytes_non_atomic(relpath, "", mode=mode)
 
331
        abspath = self._abspath(relpath)
 
332
        handle = open(abspath, 'wb')
 
333
        if mode is not None:
 
334
            self._check_mode_and_size(abspath, handle.fileno(), mode)
 
335
        transport._file_streams[self.abspath(relpath)] = handle
 
336
        return transport.FileFileStream(self, relpath, handle)
 
337
 
 
338
    def _get_append_file(self, relpath, mode=None):
 
339
        """Call os.open() for the given relpath"""
 
340
        file_abspath = self._abspath(relpath)
 
341
        if mode is None:
 
342
            # os.open() will automatically use the umask
 
343
            local_mode = 0666
 
344
        else:
 
345
            local_mode = mode
 
346
        try:
 
347
            return file_abspath, os.open(file_abspath, _append_flags, local_mode)
 
348
        except (IOError, OSError),e:
 
349
            self._translate_error(e, relpath)
 
350
 
 
351
    def _check_mode_and_size(self, file_abspath, fd, mode=None):
 
352
        """Check the mode of the file, and return the current size"""
 
353
        st = os.fstat(fd)
 
354
        if mode is not None and mode != S_IMODE(st.st_mode):
 
355
            # Because of umask, we may still need to chmod the file.
 
356
            # But in the general case, we won't have to
 
357
            os.chmod(file_abspath, mode)
 
358
        return st.st_size
 
359
 
 
360
    def append_file(self, relpath, f, mode=None):
 
361
        """Append the text in the file-like object into the final location."""
 
362
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
 
363
        try:
 
364
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
 
365
            self._pump_to_fd(f, fd)
 
366
        finally:
 
367
            os.close(fd)
 
368
        return result
 
369
 
 
370
    def append_bytes(self, relpath, bytes, mode=None):
 
371
        """Append the text in the string into the final location."""
 
372
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
 
373
        try:
 
374
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
 
375
            if bytes:
 
376
                os.write(fd, bytes)
 
377
        finally:
 
378
            os.close(fd)
 
379
        return result
 
380
 
 
381
    def _pump_to_fd(self, fromfile, to_fd):
 
382
        """Copy contents of one file to another."""
 
383
        BUFSIZE = 32768
 
384
        while True:
 
385
            b = fromfile.read(BUFSIZE)
 
386
            if not b:
 
387
                break
 
388
            os.write(to_fd, b)
 
389
 
 
390
    def copy(self, rel_from, rel_to):
 
391
        """Copy the item at rel_from to the location at rel_to"""
 
392
        path_from = self._abspath(rel_from)
 
393
        path_to = self._abspath(rel_to)
 
394
        try:
 
395
            shutil.copy(path_from, path_to)
 
396
        except (IOError, OSError),e:
 
397
            # TODO: What about path_to?
 
398
            self._translate_error(e, path_from)
 
399
 
 
400
    def rename(self, rel_from, rel_to):
 
401
        path_from = self._abspath(rel_from)
 
402
        try:
 
403
            # *don't* call bzrlib.osutils.rename, because we want to
 
404
            # detect errors on rename
 
405
            os.rename(path_from, self._abspath(rel_to))
 
406
        except (IOError, OSError),e:
 
407
            # TODO: What about path_to?
 
408
            self._translate_error(e, path_from)
 
409
 
 
410
    def move(self, rel_from, rel_to):
 
411
        """Move the item at rel_from to the location at rel_to"""
 
412
        path_from = self._abspath(rel_from)
 
413
        path_to = self._abspath(rel_to)
 
414
 
 
415
        try:
 
416
            # this version will delete the destination if necessary
 
417
            osutils.rename(path_from, path_to)
 
418
        except (IOError, OSError),e:
 
419
            # TODO: What about path_to?
 
420
            self._translate_error(e, path_from)
 
421
 
 
422
    def delete(self, relpath):
 
423
        """Delete the item at relpath"""
 
424
        path = relpath
 
425
        try:
 
426
            path = self._abspath(relpath)
 
427
            os.remove(path)
 
428
        except (IOError, OSError),e:
 
429
            self._translate_error(e, path)
 
430
 
 
431
    def external_url(self):
 
432
        """See bzrlib.transport.Transport.external_url."""
 
433
        # File URL's are externally usable.
 
434
        return self.base
 
435
 
 
436
    def copy_to(self, relpaths, other, mode=None, pb=None):
 
437
        """Copy a set of entries from self into another Transport.
 
438
 
 
439
        :param relpaths: A list/generator of entries to be copied.
 
440
        """
 
441
        if isinstance(other, LocalTransport):
 
442
            # Both from & to are on the local filesystem
 
443
            # Unfortunately, I can't think of anything faster than just
 
444
            # copying them across, one by one :(
 
445
            total = self._get_total(relpaths)
 
446
            count = 0
 
447
            for path in relpaths:
 
448
                self._update_pb(pb, 'copy-to', count, total)
 
449
                try:
 
450
                    mypath = self._abspath(path)
 
451
                    otherpath = other._abspath(path)
 
452
                    shutil.copy(mypath, otherpath)
 
453
                    if mode is not None:
 
454
                        os.chmod(otherpath, mode)
 
455
                except (IOError, OSError),e:
 
456
                    self._translate_error(e, path)
 
457
                count += 1
 
458
            return count
 
459
        else:
 
460
            return super(LocalTransport, self).copy_to(relpaths, other, mode=mode, pb=pb)
 
461
 
 
462
    def listable(self):
 
463
        """See Transport.listable."""
 
464
        return True
 
465
 
 
466
    def list_dir(self, relpath):
 
467
        """Return a list of all files at the given location.
 
468
        WARNING: many transports do not support this, so trying avoid using
 
469
        it if at all possible.
 
470
        """
 
471
        path = self._abspath(relpath)
 
472
        try:
 
473
            entries = os.listdir(path)
 
474
        except (IOError, OSError), e:
 
475
            self._translate_error(e, path)
 
476
        return [urlutils.escape(entry) for entry in entries]
 
477
 
 
478
    def stat(self, relpath):
 
479
        """Return the stat information for a file.
 
480
        """
 
481
        path = relpath
 
482
        try:
 
483
            path = self._abspath(relpath)
 
484
            return os.stat(path)
 
485
        except (IOError, OSError),e:
 
486
            self._translate_error(e, path)
 
487
 
 
488
    def lock_read(self, relpath):
 
489
        """Lock the given file for shared (read) access.
 
490
        :return: A lock object, which should be passed to Transport.unlock()
 
491
        """
 
492
        from bzrlib.lock import ReadLock
 
493
        path = relpath
 
494
        try:
 
495
            path = self._abspath(relpath)
 
496
            return ReadLock(path)
 
497
        except (IOError, OSError), e:
 
498
            self._translate_error(e, path)
 
499
 
 
500
    def lock_write(self, relpath):
 
501
        """Lock the given file for exclusive (write) access.
 
502
        WARNING: many transports do not support this, so trying avoid using it
 
503
 
 
504
        :return: A lock object, which should be passed to Transport.unlock()
 
505
        """
 
506
        from bzrlib.lock import WriteLock
 
507
        return WriteLock(self._abspath(relpath))
 
508
 
 
509
    def rmdir(self, relpath):
 
510
        """See Transport.rmdir."""
 
511
        path = relpath
 
512
        try:
 
513
            path = self._abspath(relpath)
 
514
            os.rmdir(path)
 
515
        except (IOError, OSError),e:
 
516
            self._translate_error(e, path)
 
517
 
 
518
    def _can_roundtrip_unix_modebits(self):
 
519
        if sys.platform == 'win32':
 
520
            # anyone else?
 
521
            return False
 
522
        else:
 
523
            return True
 
524
 
 
525
 
 
526
class EmulatedWin32LocalTransport(LocalTransport):
 
527
    """Special transport for testing Win32 [UNC] paths on non-windows"""
 
528
 
 
529
    def __init__(self, base):
 
530
        if base[-1] != '/':
 
531
            base = base + '/'
 
532
        super(LocalTransport, self).__init__(base)
 
533
        self._local_base = urlutils._win32_local_path_from_url(base)
 
534
 
 
535
    def abspath(self, relpath):
 
536
        path = osutils.normpath(osutils.pathjoin(
 
537
                    self._local_base, urlutils.unescape(relpath)))
 
538
        return urlutils._win32_local_path_to_url(path)
 
539
 
 
540
    def clone(self, offset=None):
 
541
        """Return a new LocalTransport with root at self.base + offset
 
542
        Because the local filesystem does not require a connection,
 
543
        we can just return a new object.
 
544
        """
 
545
        if offset is None:
 
546
            return EmulatedWin32LocalTransport(self.base)
 
547
        else:
 
548
            abspath = self.abspath(offset)
 
549
            if abspath == 'file://':
 
550
                # fix upwalk for UNC path
 
551
                # when clone from //HOST/path updir recursively
 
552
                # we should stop at least at //HOST part
 
553
                abspath = self.base
 
554
            return EmulatedWin32LocalTransport(abspath)
 
555
 
 
556
 
 
557
class LocalURLServer(Server):
 
558
    """A pretend server for local transports, using file:// urls.
 
559
 
 
560
    Of course no actual server is required to access the local filesystem, so
 
561
    this just exists to tell the test code how to get to it.
 
562
    """
 
563
 
 
564
    def start_server(self):
 
565
        pass
 
566
 
 
567
    def get_url(self):
 
568
        """See Transport.Server.get_url."""
 
569
        return urlutils.local_path_to_url('')
 
570
 
 
571
 
 
572
def get_test_permutations():
 
573
    """Return the permutations to be used in testing."""
 
574
    return [
 
575
            (LocalTransport, LocalURLServer),
 
576
            ]