← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
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
12
12
#
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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Transport for the local filesystem.
18
18
 
33
33
    osutils,
34
34
    urlutils,
35
35
    symbol_versioning,
36
 
    transport,
37
36
    )
38
37
from bzrlib.trace import mutter
39
 
from bzrlib.transport import LateReadError
40
38
""")
41
39
 
42
 
from bzrlib import transport
43
 
 
44
 
 
45
 
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY | osutils.O_NOINHERIT
46
 
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY | osutils.O_NOINHERIT
47
 
 
48
 
 
49
 
class LocalTransport(transport.Transport):
 
40
from bzrlib.transport import Transport, Server
 
41
 
 
42
 
 
43
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY
 
44
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY
 
45
 
 
46
 
 
47
class LocalTransport(Transport):
50
48
    """This is the transport agent for local filesystem access."""
51
49
 
52
50
    def __init__(self, base):
63
61
            base = urlutils.local_path_to_url(base)
64
62
        if base[-1] != '/':
65
63
            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
64
        super(LocalTransport, self).__init__(base)
76
65
        self._local_base = urlutils.local_path_from_url(base)
77
66
 
 
67
    def should_cache(self):
 
68
        return False
 
69
 
78
70
    def clone(self, offset=None):
79
71
        """Return a new LocalTransport with root at self.base + offset
80
 
        Because the local filesystem does not require a connection,
 
72
        Because the local filesystem does not require a connection, 
81
73
        we can just return a new object.
82
74
        """
83
75
        if offset is None:
99
91
         - relative_reference is url escaped.
100
92
        """
101
93
        if relative_reference in ('.', ''):
102
 
            # _local_base normally has a trailing slash; strip it so that stat
103
 
            # on a transport pointing to a symlink reads the link not the
104
 
            # referent but be careful of / and c:\
105
 
            return osutils.split(self._local_base)[0]
 
94
            return self._local_base
106
95
        return self._local_base + urlutils.unescape(relative_reference)
107
96
 
108
97
    def abspath(self, relpath):
109
98
        """Return the full url to the given relative URL."""
110
99
        # TODO: url escape the result. RBC 20060523.
 
100
        assert isinstance(relpath, basestring), (type(relpath), relpath)
111
101
        # jam 20060426 Using normpath on the real path, because that ensures
112
102
        #       proper handling of stuff like
113
103
        path = osutils.normpath(osutils.pathjoin(
114
104
                    self._local_base, urlutils.unescape(relpath)))
115
 
        # on windows, our _local_base may or may not have a drive specified
116
 
        # (ie, it may be "/" or "c:/foo").
117
 
        # If 'relpath' is '/' we *always* get back an abspath without
118
 
        # the drive letter - but if our transport already has a drive letter,
119
 
        # we want our abspaths to have a drive letter too - so handle that
120
 
        # here.
121
 
        if (sys.platform == "win32" and self._local_base[1:2] == ":"
122
 
            and path == '/'):
123
 
            path = self._local_base[:3]
124
 
 
125
105
        return urlutils.local_path_to_url(path)
126
106
 
127
107
    def local_abspath(self, relpath):
130
110
        This function only exists for the LocalTransport, since it is
131
111
        the only one that has direct local access.
132
112
        This is mostly for stuff like WorkingTree which needs to know
133
 
        the local working directory.  The returned path will always contain
134
 
        forward slashes as the path separator, regardless of the platform.
135
 
 
 
113
        the local working directory.
 
114
        
136
115
        This function is quite expensive: it calls realpath which resolves
137
116
        symlinks.
138
117
        """
147
126
            abspath = u'.'
148
127
 
149
128
        return urlutils.file_relpath(
150
 
            urlutils.strip_trailing_slash(self.base),
 
129
            urlutils.strip_trailing_slash(self.base), 
151
130
            urlutils.strip_trailing_slash(abspath))
152
131
 
153
132
    def has(self, relpath):
158
137
 
159
138
        :param relpath: The relative path to the file
160
139
        """
161
 
        canonical_url = self.abspath(relpath)
162
 
        if canonical_url in transport._file_streams:
163
 
            transport._file_streams[canonical_url].flush()
164
140
        try:
165
141
            path = self._abspath(relpath)
166
 
            return osutils.open_file(path, 'rb')
 
142
            return open(path, 'rb')
167
143
        except (IOError, OSError),e:
168
 
            if e.errno == errno.EISDIR:
169
 
                return LateReadError(relpath)
170
144
            self._translate_error(e, path)
171
145
 
172
146
    def put_file(self, relpath, f, mode=None):
174
148
 
175
149
        :param relpath: Location to put the contents, relative to base.
176
150
        :param f:       File-like object.
177
 
        :param mode: The mode for the newly created file,
 
151
        :param mode: The mode for the newly created file, 
178
152
                     None means just use the default
179
153
        """
180
154
 
186
160
        except (IOError, OSError),e:
187
161
            self._translate_error(e, path)
188
162
        try:
189
 
            length = self._pump(f, fp)
 
163
            self._pump(f, fp)
190
164
            fp.commit()
191
165
        finally:
192
166
            fp.close()
193
 
        return length
194
167
 
195
168
    def put_bytes(self, relpath, bytes, mode=None):
196
169
        """Copy the string into the location.
207
180
        except (IOError, OSError),e:
208
181
            self._translate_error(e, path)
209
182
        try:
210
 
            if bytes:
211
 
                fp.write(bytes)
 
183
            fp.write(bytes)
212
184
            fp.commit()
213
185
        finally:
214
186
            fp.close()
289
261
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
290
262
                             create_parent_dir=False, dir_mode=None):
291
263
        def writer(fd):
292
 
            if bytes:
293
 
                os.write(fd, bytes)
 
264
            os.write(fd, bytes)
294
265
        self._put_non_atomic_helper(relpath, writer, mode=mode,
295
266
                                    create_parent_dir=create_parent_dir,
296
267
                                    dir_mode=dir_mode)
327
298
        """Create a directory at the given path."""
328
299
        self._mkdir(self._abspath(relpath), mode=mode)
329
300
 
330
 
    def open_write_stream(self, relpath, mode=None):
331
 
        """See Transport.open_write_stream."""
332
 
        # initialise the file
333
 
        self.put_bytes_non_atomic(relpath, "", mode=mode)
334
 
        abspath = self._abspath(relpath)
335
 
        handle = osutils.open_file(abspath, 'wb')
336
 
        if mode is not None:
337
 
            self._check_mode_and_size(abspath, handle.fileno(), mode)
338
 
        transport._file_streams[self.abspath(relpath)] = handle
339
 
        return transport.FileFileStream(self, relpath, handle)
340
 
 
341
301
    def _get_append_file(self, relpath, mode=None):
342
302
        """Call os.open() for the given relpath"""
343
303
        file_abspath = self._abspath(relpath)
375
335
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
376
336
        try:
377
337
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
378
 
            if bytes:
379
 
                os.write(fd, bytes)
 
338
            os.write(fd, bytes)
380
339
        finally:
381
340
            os.close(fd)
382
341
        return result
402
361
 
403
362
    def rename(self, rel_from, rel_to):
404
363
        path_from = self._abspath(rel_from)
405
 
        path_to = self._abspath(rel_to)
406
364
        try:
407
 
            # *don't* call bzrlib.osutils.rename, because we want to
408
 
            # detect conflicting names on rename, and osutils.rename tries to
409
 
            # mask cross-platform differences there
410
 
            os.rename(path_from, path_to)
 
365
            # *don't* call bzrlib.osutils.rename, because we want to 
 
366
            # detect errors on rename
 
367
            os.rename(path_from, self._abspath(rel_to))
411
368
        except (IOError, OSError),e:
412
369
            # TODO: What about path_to?
413
370
            self._translate_error(e, path_from)
433
390
        except (IOError, OSError),e:
434
391
            self._translate_error(e, path)
435
392
 
436
 
    def external_url(self):
437
 
        """See bzrlib.transport.Transport.external_url."""
438
 
        # File URL's are externally usable.
439
 
        return self.base
440
 
 
441
393
    def copy_to(self, relpaths, other, mode=None, pb=None):
442
394
        """Copy a set of entries from self into another Transport.
443
395
 
486
438
        path = relpath
487
439
        try:
488
440
            path = self._abspath(relpath)
489
 
            return os.lstat(path)
 
441
            return os.stat(path)
490
442
        except (IOError, OSError),e:
491
443
            self._translate_error(e, path)
492
444
 
520
472
        except (IOError, OSError),e:
521
473
            self._translate_error(e, path)
522
474
 
523
 
    if osutils.host_os_dereferences_symlinks():
524
 
        def readlink(self, relpath):
525
 
            """See Transport.readlink."""
526
 
            return osutils.readlink(self._abspath(relpath))
527
 
 
528
 
    if osutils.hardlinks_good():
529
 
        def hardlink(self, source, link_name):
530
 
            """See Transport.link."""
531
 
            try:
532
 
                os.link(self._abspath(source), self._abspath(link_name))
533
 
            except (IOError, OSError), e:
534
 
                self._translate_error(e, source)
535
 
 
536
 
    if osutils.has_symlinks():
537
 
        def symlink(self, source, link_name):
538
 
            """See Transport.symlink."""
539
 
            abs_link_dirpath = urlutils.dirname(self.abspath(link_name))
540
 
            source_rel = urlutils.file_relpath(
541
 
                urlutils.strip_trailing_slash(abs_link_dirpath),
542
 
                urlutils.strip_trailing_slash(self.abspath(source))
543
 
            )
544
 
 
545
 
            try:
546
 
                os.symlink(source_rel, self._abspath(link_name))
547
 
            except (IOError, OSError), e:
548
 
                self._translate_error(e, source_rel)
549
 
 
550
475
    def _can_roundtrip_unix_modebits(self):
551
476
        if sys.platform == 'win32':
552
477
            # anyone else?
565
490
        self._local_base = urlutils._win32_local_path_from_url(base)
566
491
 
567
492
    def abspath(self, relpath):
 
493
        assert isinstance(relpath, basestring), (type(relpath), relpath)
568
494
        path = osutils.normpath(osutils.pathjoin(
569
495
                    self._local_base, urlutils.unescape(relpath)))
570
496
        return urlutils._win32_local_path_to_url(path)
571
497
 
572
498
    def clone(self, offset=None):
573
499
        """Return a new LocalTransport with root at self.base + offset
574
 
        Because the local filesystem does not require a connection,
 
500
        Because the local filesystem does not require a connection, 
575
501
        we can just return a new object.
576
502
        """
577
503
        if offset is None:
586
512
            return EmulatedWin32LocalTransport(abspath)
587
513
 
588
514
 
 
515
class LocalURLServer(Server):
 
516
    """A pretend server for local transports, using file:// urls.
 
517
    
 
518
    Of course no actual server is required to access the local filesystem, so
 
519
    this just exists to tell the test code how to get to it.
 
520
    """
 
521
 
 
522
    def get_url(self):
 
523
        """See Transport.Server.get_url."""
 
524
        return urlutils.local_path_to_url('')
 
525
 
 
526
 
589
527
def get_test_permutations():
590
528
    """Return the permutations to be used in testing."""
591
 
    from bzrlib.tests import test_server
592
 
    return [(LocalTransport, test_server.LocalURLServer),]
 
529
    return [
 
530
            (LocalTransport, LocalURLServer),
 
531
            ]