← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: v.ladeuil+lp at free
  • Date: 2007-05-15 17:40:32 UTC
  • mto: (2485.8.44 bzr.connection.sharing)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070515174032-qzdkangpv29l9e7g
Add a test that check that init connect only once. It fails.

* __init__.py:
(test_suite): Register the new test class.

* test_init.py: 
(InstrumentedTransport): A transport that can track connections.
(TransportHooks): Transport specific hooks.
(TestInit): Iniit command behavior tests.

* ftp.py:
(FtpTransport.__init__): Mark place that need fixing regarding
transport connection sharing

* builtins.py:
(cmd_init.run): Mark places that need fixing regarding transport
connection sharing.

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
 
        handle = osutils.open_file(abspath, 'wb')
334
 
        handle.truncate()
335
 
        if mode is not None:
336
 
            self._check_mode_and_size(abspath, handle.fileno(), mode)
337
 
        transport._file_streams[self.abspath(relpath)] = handle
338
 
        return transport.FileFileStream(self, relpath, handle)
339
 
 
340
301
    def _get_append_file(self, relpath, mode=None):
341
302
        """Call os.open() for the given relpath"""
342
303
        file_abspath = self._abspath(relpath)
374
335
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
375
336
        try:
376
337
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
377
 
            if bytes:
378
 
                os.write(fd, bytes)
 
338
            os.write(fd, bytes)
379
339
        finally:
380
340
            os.close(fd)
381
341
        return result
401
361
 
402
362
    def rename(self, rel_from, rel_to):
403
363
        path_from = self._abspath(rel_from)
404
 
        path_to = self._abspath(rel_to)
405
364
        try:
406
 
            # *don't* call bzrlib.osutils.rename, because we want to
407
 
            # detect conflicting names on rename, and osutils.rename tries to
408
 
            # mask cross-platform differences there
409
 
            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))
410
368
        except (IOError, OSError),e:
411
369
            # TODO: What about path_to?
412
370
            self._translate_error(e, path_from)
432
390
        except (IOError, OSError),e:
433
391
            self._translate_error(e, path)
434
392
 
435
 
    def external_url(self):
436
 
        """See bzrlib.transport.Transport.external_url."""
437
 
        # File URL's are externally usable.
438
 
        return self.base
439
 
 
440
393
    def copy_to(self, relpaths, other, mode=None, pb=None):
441
394
        """Copy a set of entries from self into another Transport.
442
395
 
485
438
        path = relpath
486
439
        try:
487
440
            path = self._abspath(relpath)
488
 
            return os.lstat(path)
 
441
            return os.stat(path)
489
442
        except (IOError, OSError),e:
490
443
            self._translate_error(e, path)
491
444
 
519
472
        except (IOError, OSError),e:
520
473
            self._translate_error(e, path)
521
474
 
522
 
    if osutils.host_os_dereferences_symlinks():
523
 
        def readlink(self, relpath):
524
 
            """See Transport.readlink."""
525
 
            return osutils.readlink(self._abspath(relpath))
526
 
 
527
 
    if osutils.hardlinks_good():
528
 
        def hardlink(self, source, link_name):
529
 
            """See Transport.link."""
530
 
            try:
531
 
                os.link(self._abspath(source), self._abspath(link_name))
532
 
            except (IOError, OSError), e:
533
 
                self._translate_error(e, source)
534
 
 
535
 
    if osutils.has_symlinks():
536
 
        def symlink(self, source, link_name):
537
 
            """See Transport.symlink."""
538
 
            abs_link_dirpath = urlutils.dirname(self.abspath(link_name))
539
 
            source_rel = urlutils.file_relpath(
540
 
                urlutils.strip_trailing_slash(abs_link_dirpath),
541
 
                urlutils.strip_trailing_slash(self.abspath(source))
542
 
            )
543
 
 
544
 
            try:
545
 
                os.symlink(source_rel, self._abspath(link_name))
546
 
            except (IOError, OSError), e:
547
 
                self._translate_error(e, source_rel)
548
 
 
549
475
    def _can_roundtrip_unix_modebits(self):
550
476
        if sys.platform == 'win32':
551
477
            # anyone else?
564
490
        self._local_base = urlutils._win32_local_path_from_url(base)
565
491
 
566
492
    def abspath(self, relpath):
 
493
        assert isinstance(relpath, basestring), (type(relpath), relpath)
567
494
        path = osutils.normpath(osutils.pathjoin(
568
495
                    self._local_base, urlutils.unescape(relpath)))
569
496
        return urlutils._win32_local_path_to_url(path)
570
497
 
571
498
    def clone(self, offset=None):
572
499
        """Return a new LocalTransport with root at self.base + offset
573
 
        Because the local filesystem does not require a connection,
 
500
        Because the local filesystem does not require a connection, 
574
501
        we can just return a new object.
575
502
        """
576
503
        if offset is None:
585
512
            return EmulatedWin32LocalTransport(abspath)
586
513
 
587
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 setUp(self):
 
523
        """Setup the server to service requests.
 
524
        
 
525
        :param decorated_transport: ignored by this implementation.
 
526
        """
 
527
 
 
528
    def get_url(self):
 
529
        """See Transport.Server.get_url."""
 
530
        return urlutils.local_path_to_url('')
 
531
 
 
532
 
588
533
def get_test_permutations():
589
534
    """Return the permutations to be used in testing."""
590
 
    from bzrlib.tests import test_server
591
 
    return [(LocalTransport, test_server.LocalURLServer),]
 
535
    return [
 
536
            (LocalTransport, LocalURLServer),
 
537
            ]