← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Ian Clatworthy
  • Date: 2007-08-13 14:33:10 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070813143310-twhj4la0qnupvze8
Added Quick Start Summary

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
1
 
# Copyright (C) 2005-2011 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
 
20
20
"""
21
21
 
22
22
import os
23
 
from stat import ST_MODE, S_ISDIR, S_IMODE
 
23
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
24
24
import sys
25
25
 
26
26
from bzrlib.lazy_import import lazy_import
34
34
    urlutils,
35
35
    symbol_versioning,
36
36
    )
 
37
from bzrlib.trace import mutter
37
38
from bzrlib.transport import LateReadError
38
39
""")
39
40
 
40
 
from bzrlib import transport
41
 
 
42
 
 
43
 
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY | osutils.O_NOINHERIT
44
 
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY | osutils.O_NOINHERIT
45
 
 
46
 
 
47
 
class LocalTransport(transport.Transport):
 
41
from bzrlib.transport import Transport, Server
 
42
 
 
43
 
 
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
 
46
 
 
47
 
 
48
class LocalTransport(Transport):
48
49
    """This is the transport agent for local filesystem access."""
49
50
 
50
51
    def __init__(self, base):
61
62
            base = urlutils.local_path_to_url(base)
62
63
        if base[-1] != '/':
63
64
            base = base + '/'
64
 
 
65
 
        # Special case : windows has no "root", but does have
66
 
        # multiple lettered drives inside it. #240910
67
 
        if sys.platform == 'win32' and base == 'file:///':
68
 
            base = ''
69
 
            self._local_base = ''
70
 
            super(LocalTransport, self).__init__(base)
71
 
            return
72
 
 
73
65
        super(LocalTransport, self).__init__(base)
74
66
        self._local_base = urlutils.local_path_from_url(base)
75
 
        if self._local_base[-1] != '/':
76
 
            self._local_base = self._local_base + '/'
 
67
 
 
68
    def should_cache(self):
 
69
        return False
77
70
 
78
71
    def clone(self, offset=None):
79
72
        """Return a new LocalTransport with root at self.base + offset
80
 
        Because the local filesystem does not require a connection,
 
73
        Because the local filesystem does not require a connection, 
81
74
        we can just return a new object.
82
75
        """
83
76
        if offset is None:
99
92
         - relative_reference is url escaped.
100
93
        """
101
94
        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]
 
95
            return self._local_base
106
96
        return self._local_base + urlutils.unescape(relative_reference)
107
97
 
108
98
    def abspath(self, relpath):
109
99
        """Return the full url to the given relative URL."""
110
100
        # TODO: url escape the result. RBC 20060523.
 
101
        assert isinstance(relpath, basestring), (type(relpath), relpath)
111
102
        # jam 20060426 Using normpath on the real path, because that ensures
112
103
        #       proper handling of stuff like
113
104
        path = osutils.normpath(osutils.pathjoin(
114
105
                    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
106
        return urlutils.local_path_to_url(path)
126
107
 
127
108
    def local_abspath(self, relpath):
130
111
        This function only exists for the LocalTransport, since it is
131
112
        the only one that has direct local access.
132
113
        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
 
 
 
114
        the local working directory.
 
115
        
136
116
        This function is quite expensive: it calls realpath which resolves
137
117
        symlinks.
138
118
        """
158
138
 
159
139
        :param relpath: The relative path to the file
160
140
        """
161
 
        canonical_url = self.abspath(relpath)
162
 
        if canonical_url in transport._file_streams:
163
 
            transport._file_streams[canonical_url].flush()
164
141
        try:
165
142
            path = self._abspath(relpath)
166
 
            return osutils.open_file(path, 'rb')
 
143
            return open(path, 'rb')
167
144
        except (IOError, OSError),e:
168
145
            if e.errno == errno.EISDIR:
169
146
                return LateReadError(relpath)
174
151
 
175
152
        :param relpath: Location to put the contents, relative to base.
176
153
        :param f:       File-like object.
177
 
        :param mode: The mode for the newly created file,
 
154
        :param mode: The mode for the newly created file, 
178
155
                     None means just use the default
179
156
        """
180
157
 
186
163
        except (IOError, OSError),e:
187
164
            self._translate_error(e, path)
188
165
        try:
189
 
            length = self._pump(f, fp)
 
166
            self._pump(f, fp)
190
167
            fp.commit()
191
168
        finally:
192
169
            fp.close()
193
 
        return length
194
170
 
195
171
    def put_bytes(self, relpath, bytes, mode=None):
196
172
        """Copy the string into the location.
207
183
        except (IOError, OSError),e:
208
184
            self._translate_error(e, path)
209
185
        try:
210
 
            if bytes:
211
 
                fp.write(bytes)
 
186
            fp.write(bytes)
212
187
            fp.commit()
213
188
        finally:
214
189
            fp.close()
289
264
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
290
265
                             create_parent_dir=False, dir_mode=None):
291
266
        def writer(fd):
292
 
            if bytes:
293
 
                os.write(fd, bytes)
 
267
            os.write(fd, bytes)
294
268
        self._put_non_atomic_helper(relpath, writer, mode=mode,
295
269
                                    create_parent_dir=create_parent_dir,
296
270
                                    dir_mode=dir_mode)
327
301
        """Create a directory at the given path."""
328
302
        self._mkdir(self._abspath(relpath), mode=mode)
329
303
 
330
 
    def open_write_stream(self, relpath, mode=None):
331
 
        """See Transport.open_write_stream."""
332
 
        abspath = self._abspath(relpath)
333
 
        try:
334
 
            handle = osutils.open_file(abspath, 'wb')
335
 
        except (IOError, OSError),e:
336
 
            self._translate_error(e, abspath)
337
 
        handle.truncate()
338
 
        if mode is not None:
339
 
            self._check_mode_and_size(abspath, handle.fileno(), mode)
340
 
        transport._file_streams[self.abspath(relpath)] = handle
341
 
        return transport.FileFileStream(self, relpath, handle)
342
 
 
343
304
    def _get_append_file(self, relpath, mode=None):
344
305
        """Call os.open() for the given relpath"""
345
306
        file_abspath = self._abspath(relpath)
377
338
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
378
339
        try:
379
340
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
380
 
            if bytes:
381
 
                os.write(fd, bytes)
 
341
            os.write(fd, bytes)
382
342
        finally:
383
343
            os.close(fd)
384
344
        return result
404
364
 
405
365
    def rename(self, rel_from, rel_to):
406
366
        path_from = self._abspath(rel_from)
407
 
        path_to = self._abspath(rel_to)
408
367
        try:
409
 
            # *don't* call bzrlib.osutils.rename, because we want to
410
 
            # detect conflicting names on rename, and osutils.rename tries to
411
 
            # mask cross-platform differences there
412
 
            os.rename(path_from, path_to)
 
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))
413
371
        except (IOError, OSError),e:
414
372
            # TODO: What about path_to?
415
373
            self._translate_error(e, path_from)
488
446
        path = relpath
489
447
        try:
490
448
            path = self._abspath(relpath)
491
 
            return os.lstat(path)
 
449
            return os.stat(path)
492
450
        except (IOError, OSError),e:
493
451
            self._translate_error(e, path)
494
452
 
522
480
        except (IOError, OSError),e:
523
481
            self._translate_error(e, path)
524
482
 
525
 
    if osutils.host_os_dereferences_symlinks():
526
 
        def readlink(self, relpath):
527
 
            """See Transport.readlink."""
528
 
            return osutils.readlink(self._abspath(relpath))
529
 
 
530
 
    if osutils.hardlinks_good():
531
 
        def hardlink(self, source, link_name):
532
 
            """See Transport.link."""
533
 
            try:
534
 
                os.link(self._abspath(source), self._abspath(link_name))
535
 
            except (IOError, OSError), e:
536
 
                self._translate_error(e, source)
537
 
 
538
 
    if osutils.has_symlinks():
539
 
        def symlink(self, source, link_name):
540
 
            """See Transport.symlink."""
541
 
            abs_link_dirpath = urlutils.dirname(self.abspath(link_name))
542
 
            source_rel = urlutils.file_relpath(
543
 
                urlutils.strip_trailing_slash(abs_link_dirpath),
544
 
                urlutils.strip_trailing_slash(self.abspath(source))
545
 
            )
546
 
 
547
 
            try:
548
 
                os.symlink(source_rel, self._abspath(link_name))
549
 
            except (IOError, OSError), e:
550
 
                self._translate_error(e, source_rel)
551
 
 
552
483
    def _can_roundtrip_unix_modebits(self):
553
484
        if sys.platform == 'win32':
554
485
            # anyone else?
567
498
        self._local_base = urlutils._win32_local_path_from_url(base)
568
499
 
569
500
    def abspath(self, relpath):
 
501
        assert isinstance(relpath, basestring), (type(relpath), relpath)
570
502
        path = osutils.normpath(osutils.pathjoin(
571
503
                    self._local_base, urlutils.unescape(relpath)))
572
504
        return urlutils._win32_local_path_to_url(path)
573
505
 
574
506
    def clone(self, offset=None):
575
507
        """Return a new LocalTransport with root at self.base + offset
576
 
        Because the local filesystem does not require a connection,
 
508
        Because the local filesystem does not require a connection, 
577
509
        we can just return a new object.
578
510
        """
579
511
        if offset is None:
588
520
            return EmulatedWin32LocalTransport(abspath)
589
521
 
590
522
 
 
523
class LocalURLServer(Server):
 
524
    """A pretend server for local transports, using file:// urls.
 
525
    
 
526
    Of course no actual server is required to access the local filesystem, so
 
527
    this just exists to tell the test code how to get to it.
 
528
    """
 
529
 
 
530
    def setUp(self):
 
531
        """Setup the server to service requests.
 
532
        
 
533
        :param decorated_transport: ignored by this implementation.
 
534
        """
 
535
 
 
536
    def get_url(self):
 
537
        """See Transport.Server.get_url."""
 
538
        return urlutils.local_path_to_url('')
 
539
 
 
540
 
591
541
def get_test_permutations():
592
542
    """Return the permutations to be used in testing."""
593
 
    from bzrlib.tests import test_server
594
 
    return [(LocalTransport, test_server.LocalURLServer),]
 
543
    return [
 
544
            (LocalTransport, LocalURLServer),
 
545
            ]