/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« 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-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
66
 
 
67
    def should_cache(self):
 
68
        return False
 
69
 
76
70
    def clone(self, offset=None):
77
71
        """Return a new LocalTransport with root at self.base + offset
78
 
        Because the local filesystem does not require a connection,
 
72
        Because the local filesystem does not require a connection, 
79
73
        we can just return a new object.
80
74
        """
81
75
        if offset is None:
97
91
         - relative_reference is url escaped.
98
92
        """
99
93
        if relative_reference in ('.', ''):
100
 
            # _local_base normally has a trailing slash; strip it so that stat
101
 
            # on a transport pointing to a symlink reads the link not the
102
 
            # referent but be careful of / and c:\
103
 
            return osutils.split(self._local_base)[0]
 
94
            return self._local_base
104
95
        return self._local_base + urlutils.unescape(relative_reference)
105
96
 
106
97
    def abspath(self, relpath):
107
98
        """Return the full url to the given relative URL."""
108
99
        # TODO: url escape the result. RBC 20060523.
 
100
        assert isinstance(relpath, basestring), (type(relpath), relpath)
109
101
        # jam 20060426 Using normpath on the real path, because that ensures
110
102
        #       proper handling of stuff like
111
103
        path = osutils.normpath(osutils.pathjoin(
112
104
                    self._local_base, urlutils.unescape(relpath)))
113
 
        # on windows, our _local_base may or may not have a drive specified
114
 
        # (ie, it may be "/" or "c:/foo").
115
 
        # If 'relpath' is '/' we *always* get back an abspath without
116
 
        # the drive letter - but if our transport already has a drive letter,
117
 
        # we want our abspaths to have a drive letter too - so handle that
118
 
        # here.
119
 
        if (sys.platform == "win32" and self._local_base[1:2] == ":"
120
 
            and path == '/'):
121
 
            path = self._local_base[:3]
122
 
 
123
105
        return urlutils.local_path_to_url(path)
124
106
 
125
107
    def local_abspath(self, relpath):
128
110
        This function only exists for the LocalTransport, since it is
129
111
        the only one that has direct local access.
130
112
        This is mostly for stuff like WorkingTree which needs to know
131
 
        the local working directory.  The returned path will always contain
132
 
        forward slashes as the path separator, regardless of the platform.
133
 
 
 
113
        the local working directory.
 
114
        
134
115
        This function is quite expensive: it calls realpath which resolves
135
116
        symlinks.
136
117
        """
145
126
            abspath = u'.'
146
127
 
147
128
        return urlutils.file_relpath(
148
 
            urlutils.strip_trailing_slash(self.base),
 
129
            urlutils.strip_trailing_slash(self.base), 
149
130
            urlutils.strip_trailing_slash(abspath))
150
131
 
151
132
    def has(self, relpath):
156
137
 
157
138
        :param relpath: The relative path to the file
158
139
        """
159
 
        canonical_url = self.abspath(relpath)
160
 
        if canonical_url in transport._file_streams:
161
 
            transport._file_streams[canonical_url].flush()
162
140
        try:
163
141
            path = self._abspath(relpath)
164
 
            return osutils.open_file(path, 'rb')
 
142
            return open(path, 'rb')
165
143
        except (IOError, OSError),e:
166
 
            if e.errno == errno.EISDIR:
167
 
                return LateReadError(relpath)
168
144
            self._translate_error(e, path)
169
145
 
170
146
    def put_file(self, relpath, f, mode=None):
172
148
 
173
149
        :param relpath: Location to put the contents, relative to base.
174
150
        :param f:       File-like object.
175
 
        :param mode: The mode for the newly created file,
 
151
        :param mode: The mode for the newly created file, 
176
152
                     None means just use the default
177
153
        """
178
154
 
184
160
        except (IOError, OSError),e:
185
161
            self._translate_error(e, path)
186
162
        try:
187
 
            length = self._pump(f, fp)
 
163
            self._pump(f, fp)
188
164
            fp.commit()
189
165
        finally:
190
166
            fp.close()
191
 
        return length
192
167
 
193
168
    def put_bytes(self, relpath, bytes, mode=None):
194
169
        """Copy the string into the location.
205
180
        except (IOError, OSError),e:
206
181
            self._translate_error(e, path)
207
182
        try:
208
 
            if bytes:
209
 
                fp.write(bytes)
 
183
            fp.write(bytes)
210
184
            fp.commit()
211
185
        finally:
212
186
            fp.close()
287
261
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
288
262
                             create_parent_dir=False, dir_mode=None):
289
263
        def writer(fd):
290
 
            if bytes:
291
 
                os.write(fd, bytes)
 
264
            os.write(fd, bytes)
292
265
        self._put_non_atomic_helper(relpath, writer, mode=mode,
293
266
                                    create_parent_dir=create_parent_dir,
294
267
                                    dir_mode=dir_mode)
325
298
        """Create a directory at the given path."""
326
299
        self._mkdir(self._abspath(relpath), mode=mode)
327
300
 
328
 
    def open_write_stream(self, relpath, mode=None):
329
 
        """See Transport.open_write_stream."""
330
 
        # initialise the file
331
 
        self.put_bytes_non_atomic(relpath, "", mode=mode)
332
 
        abspath = self._abspath(relpath)
333
 
        handle = osutils.open_file(abspath, 'wb')
334
 
        if mode is not None:
335
 
            self._check_mode_and_size(abspath, handle.fileno(), mode)
336
 
        transport._file_streams[self.abspath(relpath)] = handle
337
 
        return transport.FileFileStream(self, relpath, handle)
338
 
 
339
301
    def _get_append_file(self, relpath, mode=None):
340
302
        """Call os.open() for the given relpath"""
341
303
        file_abspath = self._abspath(relpath)
373
335
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
374
336
        try:
375
337
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
376
 
            if bytes:
377
 
                os.write(fd, bytes)
 
338
            os.write(fd, bytes)
378
339
        finally:
379
340
            os.close(fd)
380
341
        return result
400
361
 
401
362
    def rename(self, rel_from, rel_to):
402
363
        path_from = self._abspath(rel_from)
403
 
        path_to = self._abspath(rel_to)
404
364
        try:
405
 
            # *don't* call bzrlib.osutils.rename, because we want to
406
 
            # detect conflicting names on rename, and osutils.rename tries to
407
 
            # mask cross-platform differences there
408
 
            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))
409
368
        except (IOError, OSError),e:
410
369
            # TODO: What about path_to?
411
370
            self._translate_error(e, path_from)
431
390
        except (IOError, OSError),e:
432
391
            self._translate_error(e, path)
433
392
 
434
 
    def external_url(self):
435
 
        """See bzrlib.transport.Transport.external_url."""
436
 
        # File URL's are externally usable.
437
 
        return self.base
438
 
 
439
393
    def copy_to(self, relpaths, other, mode=None, pb=None):
440
394
        """Copy a set of entries from self into another Transport.
441
395
 
484
438
        path = relpath
485
439
        try:
486
440
            path = self._abspath(relpath)
487
 
            return os.lstat(path)
 
441
            return os.stat(path)
488
442
        except (IOError, OSError),e:
489
443
            self._translate_error(e, path)
490
444
 
518
472
        except (IOError, OSError),e:
519
473
            self._translate_error(e, path)
520
474
 
521
 
    if osutils.host_os_dereferences_symlinks():
522
 
        def readlink(self, relpath):
523
 
            """See Transport.readlink."""
524
 
            return osutils.readlink(self._abspath(relpath))
525
 
 
526
 
    if osutils.hardlinks_good():
527
 
        def hardlink(self, source, link_name):
528
 
            """See Transport.link."""
529
 
            try:
530
 
                os.link(self._abspath(source), self._abspath(link_name))
531
 
            except (IOError, OSError), e:
532
 
                self._translate_error(e, source)
533
 
 
534
 
    if osutils.has_symlinks():
535
 
        def symlink(self, source, link_name):
536
 
            """See Transport.symlink."""
537
 
            abs_link_dirpath = urlutils.dirname(self.abspath(link_name))
538
 
            source_rel = urlutils.file_relpath(
539
 
                urlutils.strip_trailing_slash(abs_link_dirpath),
540
 
                urlutils.strip_trailing_slash(self.abspath(source))
541
 
            )
542
 
 
543
 
            try:
544
 
                os.symlink(source_rel, self._abspath(link_name))
545
 
            except (IOError, OSError), e:
546
 
                self._translate_error(e, source_rel)
547
 
 
548
475
    def _can_roundtrip_unix_modebits(self):
549
476
        if sys.platform == 'win32':
550
477
            # anyone else?
563
490
        self._local_base = urlutils._win32_local_path_from_url(base)
564
491
 
565
492
    def abspath(self, relpath):
 
493
        assert isinstance(relpath, basestring), (type(relpath), relpath)
566
494
        path = osutils.normpath(osutils.pathjoin(
567
495
                    self._local_base, urlutils.unescape(relpath)))
568
496
        return urlutils._win32_local_path_to_url(path)
569
497
 
570
498
    def clone(self, offset=None):
571
499
        """Return a new LocalTransport with root at self.base + offset
572
 
        Because the local filesystem does not require a connection,
 
500
        Because the local filesystem does not require a connection, 
573
501
        we can just return a new object.
574
502
        """
575
503
        if offset is None:
584
512
            return EmulatedWin32LocalTransport(abspath)
585
513
 
586
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
 
587
527
def get_test_permutations():
588
528
    """Return the permutations to be used in testing."""
589
 
    from bzrlib.tests import test_server
590
 
    return [(LocalTransport, test_server.LocalURLServer),]
 
529
    return [
 
530
            (LocalTransport, LocalURLServer),
 
531
            ]