← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Aaron Bentley
  • Date: 2007-03-11 16:16:00 UTC
  • mto: (2323.6.9 0.15-integration)
  • mto: This revision was merged to the branch mainline in revision 2342.
  • Revision ID: aaron.bentley@utoronto.ca-20070311161600-hvtsmkf3d2z72562
Allow leading junk before merge directive header

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.transport import LateReadError
 
37
from bzrlib.trace import mutter
38
38
""")
39
39
 
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):
 
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):
48
48
    """This is the transport agent for local filesystem access."""
49
49
 
50
50
    def __init__(self, base):
61
61
            base = urlutils.local_path_to_url(base)
62
62
        if base[-1] != '/':
63
63
            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
64
        super(LocalTransport, self).__init__(base)
74
65
        self._local_base = urlutils.local_path_from_url(base)
75
 
        if self._local_base[-1] != '/':
76
 
            self._local_base = self._local_base + '/'
 
66
 
 
67
    def should_cache(self):
 
68
        return False
77
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
 
        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
301
    def _get_append_file(self, relpath, mode=None):
344
302
        """Call os.open() for the given relpath"""
345
303
        file_abspath = self._abspath(relpath)
377
335
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
378
336
        try:
379
337
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
380
 
            if bytes:
381
 
                os.write(fd, bytes)
 
338
            os.write(fd, bytes)
382
339
        finally:
383
340
            os.close(fd)
384
341
        return result
404
361
 
405
362
    def rename(self, rel_from, rel_to):
406
363
        path_from = self._abspath(rel_from)
407
 
        path_to = self._abspath(rel_to)
408
364
        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)
 
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))
413
368
        except (IOError, OSError),e:
414
369
            # TODO: What about path_to?
415
370
            self._translate_error(e, path_from)
435
390
        except (IOError, OSError),e:
436
391
            self._translate_error(e, path)
437
392
 
438
 
    def external_url(self):
439
 
        """See bzrlib.transport.Transport.external_url."""
440
 
        # File URL's are externally usable.
441
 
        return self.base
442
 
 
443
393
    def copy_to(self, relpaths, other, mode=None, pb=None):
444
394
        """Copy a set of entries from self into another Transport.
445
395
 
488
438
        path = relpath
489
439
        try:
490
440
            path = self._abspath(relpath)
491
 
            return os.lstat(path)
 
441
            return os.stat(path)
492
442
        except (IOError, OSError),e:
493
443
            self._translate_error(e, path)
494
444
 
522
472
        except (IOError, OSError),e:
523
473
            self._translate_error(e, path)
524
474
 
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
475
    def _can_roundtrip_unix_modebits(self):
553
476
        if sys.platform == 'win32':
554
477
            # anyone else?
567
490
        self._local_base = urlutils._win32_local_path_from_url(base)
568
491
 
569
492
    def abspath(self, relpath):
 
493
        assert isinstance(relpath, basestring), (type(relpath), relpath)
570
494
        path = osutils.normpath(osutils.pathjoin(
571
495
                    self._local_base, urlutils.unescape(relpath)))
572
496
        return urlutils._win32_local_path_to_url(path)
573
497
 
574
498
    def clone(self, offset=None):
575
499
        """Return a new LocalTransport with root at self.base + offset
576
 
        Because the local filesystem does not require a connection,
 
500
        Because the local filesystem does not require a connection, 
577
501
        we can just return a new object.
578
502
        """
579
503
        if offset is None:
588
512
            return EmulatedWin32LocalTransport(abspath)
589
513
 
590
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
 
591
527
def get_test_permutations():
592
528
    """Return the permutations to be used in testing."""
593
 
    from bzrlib.tests import test_server
594
 
    return [(LocalTransport, test_server.LocalURLServer),]
 
529
    return [
 
530
            (LocalTransport, LocalURLServer),
 
531
            ]