← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Jelmer Vernooij
  • Date: 2008-07-07 21:54:04 UTC
  • mto: This revision was merged to the branch mainline in revision 3533.
  • Revision ID: jelmer@samba.org-20080707215404-09t83ot6mv02jr6w
Move functionality to add ignores to the ignore file into a separate function.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
1
 
# Copyright (C) 2005-2012, 2016 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
 
19
19
This is a fairly thin wrapper on regular file IO.
20
20
"""
21
21
 
22
 
from __future__ import absolute_import
23
 
 
24
22
import os
25
 
from stat import ST_MODE, S_ISDIR, S_IMODE
 
23
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
26
24
import sys
27
25
 
28
26
from bzrlib.lazy_import import lazy_import
35
33
    osutils,
36
34
    urlutils,
37
35
    symbol_versioning,
 
36
    transport,
38
37
    )
 
38
from bzrlib.trace import mutter
39
39
from bzrlib.transport import LateReadError
40
40
""")
41
41
 
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):
 
42
from bzrlib.transport import Transport, Server
 
43
 
 
44
 
 
45
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY
 
46
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY
 
47
 
 
48
 
 
49
class LocalTransport(Transport):
50
50
    """This is the transport agent for local filesystem access."""
51
51
 
52
52
    def __init__(self, base):
53
53
        """Set the base path where files will be stored."""
54
54
        if not base.startswith('file://'):
55
 
            raise AssertionError("not a file:// url: %r" % base)
 
55
            symbol_versioning.warn(
 
56
                "Instantiating LocalTransport with a filesystem path"
 
57
                " is deprecated as of bzr 0.8."
 
58
                " Please use bzrlib.transport.get_transport()"
 
59
                " or pass in a file:// url.",
 
60
                 DeprecationWarning,
 
61
                 stacklevel=2
 
62
                 )
 
63
            base = urlutils.local_path_to_url(base)
56
64
        if base[-1] != '/':
57
65
            base = base + '/'
58
 
 
59
 
        # Special case : windows has no "root", but does have
60
 
        # multiple lettered drives inside it. #240910
61
 
        if sys.platform == 'win32' and base == 'file:///':
62
 
            base = ''
63
 
            self._local_base = ''
64
 
            super(LocalTransport, self).__init__(base)
65
 
            return
66
 
 
67
66
        super(LocalTransport, self).__init__(base)
68
67
        self._local_base = urlutils.local_path_from_url(base)
69
 
        if self._local_base[-1] != '/':
70
 
            self._local_base = self._local_base + '/'
71
68
 
72
69
    def clone(self, offset=None):
73
70
        """Return a new LocalTransport with root at self.base + offset
74
 
        Because the local filesystem does not require a connection,
 
71
        Because the local filesystem does not require a connection, 
75
72
        we can just return a new object.
76
73
        """
77
74
        if offset is None:
93
90
         - relative_reference is url escaped.
94
91
        """
95
92
        if relative_reference in ('.', ''):
96
 
            # _local_base normally has a trailing slash; strip it so that stat
97
 
            # on a transport pointing to a symlink reads the link not the
98
 
            # referent but be careful of / and c:\
99
 
            return osutils.split(self._local_base)[0]
 
93
            return self._local_base
100
94
        return self._local_base + urlutils.unescape(relative_reference)
101
95
 
102
96
    def abspath(self, relpath):
106
100
        #       proper handling of stuff like
107
101
        path = osutils.normpath(osutils.pathjoin(
108
102
                    self._local_base, urlutils.unescape(relpath)))
109
 
        # on windows, our _local_base may or may not have a drive specified
110
 
        # (ie, it may be "/" or "c:/foo").
111
 
        # If 'relpath' is '/' we *always* get back an abspath without
112
 
        # the drive letter - but if our transport already has a drive letter,
113
 
        # we want our abspaths to have a drive letter too - so handle that
114
 
        # here.
115
 
        if (sys.platform == "win32" and self._local_base[1:2] == ":"
116
 
            and path == '/'):
117
 
            path = self._local_base[:3]
118
 
 
119
103
        return urlutils.local_path_to_url(path)
120
104
 
121
105
    def local_abspath(self, relpath):
124
108
        This function only exists for the LocalTransport, since it is
125
109
        the only one that has direct local access.
126
110
        This is mostly for stuff like WorkingTree which needs to know
127
 
        the local working directory.  The returned path will always contain
128
 
        forward slashes as the path separator, regardless of the platform.
129
 
 
 
111
        the local working directory.
 
112
        
130
113
        This function is quite expensive: it calls realpath which resolves
131
114
        symlinks.
132
115
        """
140
123
        if abspath is None:
141
124
            abspath = u'.'
142
125
 
143
 
        return urlutils.file_relpath(self.base, abspath)
 
126
        return urlutils.file_relpath(
 
127
            urlutils.strip_trailing_slash(self.base),
 
128
            urlutils.strip_trailing_slash(abspath))
144
129
 
145
130
    def has(self, relpath):
146
131
        return os.access(self._abspath(relpath), os.F_OK)
155
140
            transport._file_streams[canonical_url].flush()
156
141
        try:
157
142
            path = self._abspath(relpath)
158
 
            return osutils.open_file(path, 'rb')
 
143
            return open(path, 'rb')
159
144
        except (IOError, OSError),e:
160
145
            if e.errno == errno.EISDIR:
161
146
                return LateReadError(relpath)
166
151
 
167
152
        :param relpath: Location to put the contents, relative to base.
168
153
        :param f:       File-like object.
169
 
        :param mode: The mode for the newly created file,
 
154
        :param mode: The mode for the newly created file, 
170
155
                     None means just use the default
171
156
        """
172
157
 
184
169
            fp.close()
185
170
        return length
186
171
 
187
 
    def put_bytes(self, relpath, raw_bytes, mode=None):
 
172
    def put_bytes(self, relpath, bytes, mode=None):
188
173
        """Copy the string into the location.
189
174
 
190
175
        :param relpath: Location to put the contents, relative to base.
191
 
        :param raw_bytes:   String
 
176
        :param bytes:   String
192
177
        """
193
 
        if not isinstance(raw_bytes, str):
194
 
            raise TypeError(
195
 
                'raw_bytes must be a plain string, not %s' % type(raw_bytes))
 
178
 
196
179
        path = relpath
197
180
        try:
198
181
            path = self._abspath(relpath)
201
184
        except (IOError, OSError),e:
202
185
            self._translate_error(e, path)
203
186
        try:
204
 
            if bytes:
205
 
                fp.write(raw_bytes)
 
187
            fp.write(bytes)
206
188
            fp.commit()
207
189
        finally:
208
190
            fp.close()
251
233
            if mode is not None and mode != S_IMODE(st.st_mode):
252
234
                # Because of umask, we may still need to chmod the file.
253
235
                # But in the general case, we won't have to
254
 
                osutils.chmod_if_possible(abspath, mode)
 
236
                os.chmod(abspath, mode)
255
237
            writer(fd)
256
238
        finally:
257
239
            os.close(fd)
283
265
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
284
266
                             create_parent_dir=False, dir_mode=None):
285
267
        def writer(fd):
286
 
            if bytes:
287
 
                os.write(fd, bytes)
 
268
            os.write(fd, bytes)
288
269
        self._put_non_atomic_helper(relpath, writer, mode=mode,
289
270
                                    create_parent_dir=create_parent_dir,
290
271
                                    dir_mode=dir_mode)
310
291
            local_mode = mode
311
292
        try:
312
293
            os.mkdir(abspath, local_mode)
 
294
            if mode is not None:
 
295
                # It is probably faster to just do the chmod, rather than
 
296
                # doing a stat, and then trying to compare
 
297
                os.chmod(abspath, mode)
313
298
        except (IOError, OSError),e:
314
299
            self._translate_error(e, abspath)
315
 
        if mode is not None:
316
 
            try:
317
 
                osutils.chmod_if_possible(abspath, mode)
318
 
            except (IOError, OSError), e:
319
 
                self._translate_error(e, abspath)
320
300
 
321
301
    def mkdir(self, relpath, mode=None):
322
302
        """Create a directory at the given path."""
324
304
 
325
305
    def open_write_stream(self, relpath, mode=None):
326
306
        """See Transport.open_write_stream."""
 
307
        # initialise the file
 
308
        self.put_bytes_non_atomic(relpath, "", mode=mode)
327
309
        abspath = self._abspath(relpath)
328
 
        try:
329
 
            handle = osutils.open_file(abspath, 'wb')
330
 
        except (IOError, OSError),e:
331
 
            self._translate_error(e, abspath)
332
 
        handle.truncate()
 
310
        handle = open(abspath, 'wb')
333
311
        if mode is not None:
334
312
            self._check_mode_and_size(abspath, handle.fileno(), mode)
335
313
        transport._file_streams[self.abspath(relpath)] = handle
354
332
        if mode is not None and mode != S_IMODE(st.st_mode):
355
333
            # Because of umask, we may still need to chmod the file.
356
334
            # But in the general case, we won't have to
357
 
            osutils.chmod_if_possible(file_abspath, mode)
 
335
            os.chmod(file_abspath, mode)
358
336
        return st.st_size
359
337
 
360
338
    def append_file(self, relpath, f, mode=None):
372
350
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
373
351
        try:
374
352
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
375
 
            if bytes:
376
 
                os.write(fd, bytes)
 
353
            os.write(fd, bytes)
377
354
        finally:
378
355
            os.close(fd)
379
356
        return result
399
376
 
400
377
    def rename(self, rel_from, rel_to):
401
378
        path_from = self._abspath(rel_from)
402
 
        path_to = self._abspath(rel_to)
403
379
        try:
404
 
            # *don't* call bzrlib.osutils.rename, because we want to
405
 
            # detect conflicting names on rename, and osutils.rename tries to
406
 
            # mask cross-platform differences there
407
 
            os.rename(path_from, path_to)
 
380
            # *don't* call bzrlib.osutils.rename, because we want to 
 
381
            # detect errors on rename
 
382
            os.rename(path_from, self._abspath(rel_to))
408
383
        except (IOError, OSError),e:
409
384
            # TODO: What about path_to?
410
385
            self._translate_error(e, path_from)
453
428
                    otherpath = other._abspath(path)
454
429
                    shutil.copy(mypath, otherpath)
455
430
                    if mode is not None:
456
 
                        osutils.chmod_if_possible(otherpath, mode)
 
431
                        os.chmod(otherpath, mode)
457
432
                except (IOError, OSError),e:
458
433
                    self._translate_error(e, path)
459
434
                count += 1
483
458
        path = relpath
484
459
        try:
485
460
            path = self._abspath(relpath)
486
 
            return os.lstat(path)
 
461
            return os.stat(path)
487
462
        except (IOError, OSError),e:
488
463
            self._translate_error(e, path)
489
464
 
517
492
        except (IOError, OSError),e:
518
493
            self._translate_error(e, path)
519
494
 
520
 
    if osutils.host_os_dereferences_symlinks():
521
 
        def readlink(self, relpath):
522
 
            """See Transport.readlink."""
523
 
            return osutils.readlink(self._abspath(relpath))
524
 
 
525
 
    if osutils.hardlinks_good():
526
 
        def hardlink(self, source, link_name):
527
 
            """See Transport.link."""
528
 
            try:
529
 
                os.link(self._abspath(source), self._abspath(link_name))
530
 
            except (IOError, OSError), e:
531
 
                self._translate_error(e, source)
532
 
 
533
 
    if osutils.has_symlinks():
534
 
        def symlink(self, source, link_name):
535
 
            """See Transport.symlink."""
536
 
            abs_link_dirpath = urlutils.dirname(self.abspath(link_name))
537
 
            source_rel = urlutils.file_relpath(
538
 
                abs_link_dirpath, self.abspath(source))
539
 
 
540
 
            try:
541
 
                os.symlink(source_rel, self._abspath(link_name))
542
 
            except (IOError, OSError), e:
543
 
                self._translate_error(e, source_rel)
544
 
 
545
495
    def _can_roundtrip_unix_modebits(self):
546
496
        if sys.platform == 'win32':
547
497
            # anyone else?
560
510
        self._local_base = urlutils._win32_local_path_from_url(base)
561
511
 
562
512
    def abspath(self, relpath):
563
 
        path = osutils._win32_normpath(osutils.pathjoin(
 
513
        path = osutils.normpath(osutils.pathjoin(
564
514
                    self._local_base, urlutils.unescape(relpath)))
565
515
        return urlutils._win32_local_path_to_url(path)
566
516
 
567
517
    def clone(self, offset=None):
568
518
        """Return a new LocalTransport with root at self.base + offset
569
 
        Because the local filesystem does not require a connection,
 
519
        Because the local filesystem does not require a connection, 
570
520
        we can just return a new object.
571
521
        """
572
522
        if offset is None:
581
531
            return EmulatedWin32LocalTransport(abspath)
582
532
 
583
533
 
 
534
class LocalURLServer(Server):
 
535
    """A pretend server for local transports, using file:// urls.
 
536
    
 
537
    Of course no actual server is required to access the local filesystem, so
 
538
    this just exists to tell the test code how to get to it.
 
539
    """
 
540
 
 
541
    def setUp(self):
 
542
        """Setup the server to service requests.
 
543
        
 
544
        :param decorated_transport: ignored by this implementation.
 
545
        """
 
546
 
 
547
    def get_url(self):
 
548
        """See Transport.Server.get_url."""
 
549
        return urlutils.local_path_to_url('')
 
550
 
 
551
 
584
552
def get_test_permutations():
585
553
    """Return the permutations to be used in testing."""
586
 
    from bzrlib.tests import test_server
587
 
    return [(LocalTransport, test_server.LocalURLServer),]
 
554
    return [
 
555
            (LocalTransport, LocalURLServer),
 
556
            ]