~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Ian Clatworthy
  • Date: 2009-01-19 02:24:15 UTC
  • mto: This revision was merged to the branch mainline in revision 3944.
  • Revision ID: ian.clatworthy@canonical.com-20090119022415-mo0mcfeiexfktgwt
apply jam's log --short fix (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
20
"""
21
21
 
22
22
import os
 
23
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
 
24
import sys
 
25
 
 
26
from bzrlib.lazy_import import lazy_import
 
27
lazy_import(globals(), """
 
28
import errno
23
29
import shutil
24
 
import sys
25
 
from stat import ST_MODE, S_ISDIR, ST_SIZE
26
 
import tempfile
27
30
 
28
 
from bzrlib.osutils import (abspath, realpath, normpath, pathjoin, rename, 
29
 
                            check_legal_path, rmtree)
30
 
from bzrlib.symbol_versioning import warn
 
31
from bzrlib import (
 
32
    atomicfile,
 
33
    osutils,
 
34
    urlutils,
 
35
    symbol_versioning,
 
36
    transport,
 
37
    )
31
38
from bzrlib.trace import mutter
 
39
from bzrlib.transport import LateReadError
 
40
""")
 
41
 
32
42
from bzrlib.transport import Transport, Server
33
 
import bzrlib.urlutils as urlutils
 
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
34
47
 
35
48
 
36
49
class LocalTransport(Transport):
39
52
    def __init__(self, base):
40
53
        """Set the base path where files will be stored."""
41
54
        if not base.startswith('file://'):
42
 
            warn("Instantiating LocalTransport with a filesystem path"
 
55
            symbol_versioning.warn(
 
56
                "Instantiating LocalTransport with a filesystem path"
43
57
                " is deprecated as of bzr 0.8."
44
58
                " Please use bzrlib.transport.get_transport()"
45
59
                " or pass in a file:// url.",
49
63
            base = urlutils.local_path_to_url(base)
50
64
        if base[-1] != '/':
51
65
            base = base + '/'
 
66
 
 
67
        # Special case : windows has no "root", but does have
 
68
        # multiple lettered drives inside it. #240910
 
69
        if sys.platform == 'win32' and base == 'file:///':
 
70
            base = ''
 
71
            self._local_base = ''
 
72
            super(LocalTransport, self).__init__(base)
 
73
            return
 
74
            
52
75
        super(LocalTransport, self).__init__(base)
53
76
        self._local_base = urlutils.local_path_from_url(base)
54
77
 
55
 
    def should_cache(self):
56
 
        return False
57
 
 
58
78
    def clone(self, offset=None):
59
79
        """Return a new LocalTransport with root at self.base + offset
60
80
        Because the local filesystem does not require a connection, 
63
83
        if offset is None:
64
84
            return LocalTransport(self.base)
65
85
        else:
66
 
            return LocalTransport(self.abspath(offset))
 
86
            abspath = self.abspath(offset)
 
87
            if abspath == 'file://':
 
88
                # fix upwalk for UNC path
 
89
                # when clone from //HOST/path updir recursively
 
90
                # we should stop at least at //HOST part
 
91
                abspath = self.base
 
92
            return LocalTransport(abspath)
67
93
 
68
94
    def _abspath(self, relative_reference):
69
95
        """Return a path for use in os calls.
79
105
    def abspath(self, relpath):
80
106
        """Return the full url to the given relative URL."""
81
107
        # TODO: url escape the result. RBC 20060523.
82
 
        assert isinstance(relpath, basestring), (type(relpath), relpath)
83
108
        # jam 20060426 Using normpath on the real path, because that ensures
84
109
        #       proper handling of stuff like
85
 
        path = normpath(pathjoin(self._local_base, urlutils.unescape(relpath)))
 
110
        path = osutils.normpath(osutils.pathjoin(
 
111
                    self._local_base, urlutils.unescape(relpath)))
 
112
        # on windows, our _local_base may or may not have a drive specified
 
113
        # (ie, it may be "/" or "c:/foo").
 
114
        # If 'relpath' is '/' we *always* get back an abspath without
 
115
        # the drive letter - but if our transport already has a drive letter,
 
116
        # we want our abspaths to have a drive letter too - so handle that
 
117
        # here.
 
118
        if (sys.platform == "win32" and self._local_base[1:2] == ":"
 
119
            and path == '/'):
 
120
            path = self._local_base[:3]
 
121
 
86
122
        return urlutils.local_path_to_url(path)
87
123
 
88
124
    def local_abspath(self, relpath):
91
127
        This function only exists for the LocalTransport, since it is
92
128
        the only one that has direct local access.
93
129
        This is mostly for stuff like WorkingTree which needs to know
94
 
        the local working directory.
95
 
        
 
130
        the local working directory.  The returned path will always contain
 
131
        forward slashes as the path separator, regardless of the platform.
 
132
 
96
133
        This function is quite expensive: it calls realpath which resolves
97
134
        symlinks.
98
135
        """
107
144
            abspath = u'.'
108
145
 
109
146
        return urlutils.file_relpath(
110
 
            urlutils.strip_trailing_slash(self.base), 
 
147
            urlutils.strip_trailing_slash(self.base),
111
148
            urlutils.strip_trailing_slash(abspath))
112
149
 
113
150
    def has(self, relpath):
118
155
 
119
156
        :param relpath: The relative path to the file
120
157
        """
 
158
        canonical_url = self.abspath(relpath)
 
159
        if canonical_url in transport._file_streams:
 
160
            transport._file_streams[canonical_url].flush()
121
161
        try:
122
162
            path = self._abspath(relpath)
123
163
            return open(path, 'rb')
124
164
        except (IOError, OSError),e:
125
 
            self._translate_error(e, path)
126
 
 
127
 
    def put(self, relpath, f, mode=None):
128
 
        """Copy the file-like or string object into the location.
129
 
 
130
 
        :param relpath: Location to put the contents, relative to base.
131
 
        :param f:       File-like or string object.
132
 
        """
133
 
        from bzrlib.atomicfile import AtomicFile
134
 
 
135
 
        path = relpath
136
 
        try:
137
 
            path = self._abspath(relpath)
138
 
            check_legal_path(path)
139
 
            fp = AtomicFile(path, 'wb', new_mode=mode)
140
 
        except (IOError, OSError),e:
141
 
            self._translate_error(e, path)
142
 
        try:
143
 
            self._pump(f, fp)
144
 
            fp.commit()
145
 
        finally:
146
 
            fp.close()
 
165
            if e.errno == errno.EISDIR:
 
166
                return LateReadError(relpath)
 
167
            self._translate_error(e, path)
 
168
 
 
169
    def put_file(self, relpath, f, mode=None):
 
170
        """Copy the file-like object into the location.
 
171
 
 
172
        :param relpath: Location to put the contents, relative to base.
 
173
        :param f:       File-like object.
 
174
        :param mode: The mode for the newly created file, 
 
175
                     None means just use the default
 
176
        """
 
177
 
 
178
        path = relpath
 
179
        try:
 
180
            path = self._abspath(relpath)
 
181
            osutils.check_legal_path(path)
 
182
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
 
183
        except (IOError, OSError),e:
 
184
            self._translate_error(e, path)
 
185
        try:
 
186
            length = self._pump(f, fp)
 
187
            fp.commit()
 
188
        finally:
 
189
            fp.close()
 
190
        return length
 
191
 
 
192
    def put_bytes(self, relpath, bytes, mode=None):
 
193
        """Copy the string into the location.
 
194
 
 
195
        :param relpath: Location to put the contents, relative to base.
 
196
        :param bytes:   String
 
197
        """
 
198
 
 
199
        path = relpath
 
200
        try:
 
201
            path = self._abspath(relpath)
 
202
            osutils.check_legal_path(path)
 
203
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
 
204
        except (IOError, OSError),e:
 
205
            self._translate_error(e, path)
 
206
        try:
 
207
            fp.write(bytes)
 
208
            fp.commit()
 
209
        finally:
 
210
            fp.close()
 
211
 
 
212
    def _put_non_atomic_helper(self, relpath, writer,
 
213
                               mode=None,
 
214
                               create_parent_dir=False,
 
215
                               dir_mode=None):
 
216
        """Common functionality information for the put_*_non_atomic.
 
217
 
 
218
        This tracks all the create_parent_dir stuff.
 
219
 
 
220
        :param relpath: the path we are putting to.
 
221
        :param writer: A function that takes an os level file descriptor
 
222
            and writes whatever data it needs to write there.
 
223
        :param mode: The final file mode.
 
224
        :param create_parent_dir: Should we be creating the parent directory
 
225
            if it doesn't exist?
 
226
        """
 
227
        abspath = self._abspath(relpath)
 
228
        if mode is None:
 
229
            # os.open() will automatically use the umask
 
230
            local_mode = 0666
 
231
        else:
 
232
            local_mode = mode
 
233
        try:
 
234
            fd = os.open(abspath, _put_non_atomic_flags, local_mode)
 
235
        except (IOError, OSError),e:
 
236
            # We couldn't create the file, maybe we need to create
 
237
            # the parent directory, and try again
 
238
            if (not create_parent_dir
 
239
                or e.errno not in (errno.ENOENT,errno.ENOTDIR)):
 
240
                self._translate_error(e, relpath)
 
241
            parent_dir = os.path.dirname(abspath)
 
242
            if not parent_dir:
 
243
                self._translate_error(e, relpath)
 
244
            self._mkdir(parent_dir, mode=dir_mode)
 
245
            # We created the parent directory, lets try to open the
 
246
            # file again
 
247
            try:
 
248
                fd = os.open(abspath, _put_non_atomic_flags, local_mode)
 
249
            except (IOError, OSError), e:
 
250
                self._translate_error(e, relpath)
 
251
        try:
 
252
            st = os.fstat(fd)
 
253
            if mode is not None and mode != S_IMODE(st.st_mode):
 
254
                # Because of umask, we may still need to chmod the file.
 
255
                # But in the general case, we won't have to
 
256
                os.chmod(abspath, mode)
 
257
            writer(fd)
 
258
        finally:
 
259
            os.close(fd)
 
260
 
 
261
    def put_file_non_atomic(self, relpath, f, mode=None,
 
262
                            create_parent_dir=False,
 
263
                            dir_mode=None):
 
264
        """Copy the file-like object into the target location.
 
265
 
 
266
        This function is not strictly safe to use. It is only meant to
 
267
        be used when you already know that the target does not exist.
 
268
        It is not safe, because it will open and truncate the remote
 
269
        file. So there may be a time when the file has invalid contents.
 
270
 
 
271
        :param relpath: The remote location to put the contents.
 
272
        :param f:       File-like object.
 
273
        :param mode:    Possible access permissions for new file.
 
274
                        None means do not set remote permissions.
 
275
        :param create_parent_dir: If we cannot create the target file because
 
276
                        the parent directory does not exist, go ahead and
 
277
                        create it, and then try again.
 
278
        """
 
279
        def writer(fd):
 
280
            self._pump_to_fd(f, fd)
 
281
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
282
                                    create_parent_dir=create_parent_dir,
 
283
                                    dir_mode=dir_mode)
 
284
 
 
285
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
 
286
                             create_parent_dir=False, dir_mode=None):
 
287
        def writer(fd):
 
288
            os.write(fd, bytes)
 
289
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
290
                                    create_parent_dir=create_parent_dir,
 
291
                                    dir_mode=dir_mode)
147
292
 
148
293
    def iter_files_recursive(self):
149
294
        """Iter the relative paths of files in the transports sub-tree."""
157
302
            else:
158
303
                yield relpath
159
304
 
 
305
    def _mkdir(self, abspath, mode=None):
 
306
        """Create a real directory, filtering through mode"""
 
307
        if mode is None:
 
308
            # os.mkdir() will filter through umask
 
309
            local_mode = 0777
 
310
        else:
 
311
            local_mode = mode
 
312
        try:
 
313
            os.mkdir(abspath, local_mode)
 
314
            if mode is not None:
 
315
                # It is probably faster to just do the chmod, rather than
 
316
                # doing a stat, and then trying to compare
 
317
                os.chmod(abspath, mode)
 
318
        except (IOError, OSError),e:
 
319
            self._translate_error(e, abspath)
 
320
 
160
321
    def mkdir(self, relpath, mode=None):
161
322
        """Create a directory at the given path."""
162
 
        path = relpath
 
323
        self._mkdir(self._abspath(relpath), mode=mode)
 
324
 
 
325
    def open_write_stream(self, relpath, mode=None):
 
326
        """See Transport.open_write_stream."""
 
327
        # initialise the file
 
328
        self.put_bytes_non_atomic(relpath, "", mode=mode)
 
329
        abspath = self._abspath(relpath)
 
330
        handle = open(abspath, 'wb')
 
331
        if mode is not None:
 
332
            self._check_mode_and_size(abspath, handle.fileno(), mode)
 
333
        transport._file_streams[self.abspath(relpath)] = handle
 
334
        return transport.FileFileStream(self, relpath, handle)
 
335
 
 
336
    def _get_append_file(self, relpath, mode=None):
 
337
        """Call os.open() for the given relpath"""
 
338
        file_abspath = self._abspath(relpath)
 
339
        if mode is None:
 
340
            # os.open() will automatically use the umask
 
341
            local_mode = 0666
 
342
        else:
 
343
            local_mode = mode
163
344
        try:
164
 
            path = self._abspath(relpath)
165
 
            os.mkdir(path)
166
 
            if mode is not None:
167
 
                os.chmod(path, mode)
 
345
            return file_abspath, os.open(file_abspath, _append_flags, local_mode)
168
346
        except (IOError, OSError),e:
169
 
            self._translate_error(e, path)
170
 
 
171
 
    def append(self, relpath, f, mode=None):
 
347
            self._translate_error(e, relpath)
 
348
 
 
349
    def _check_mode_and_size(self, file_abspath, fd, mode=None):
 
350
        """Check the mode of the file, and return the current size"""
 
351
        st = os.fstat(fd)
 
352
        if mode is not None and mode != S_IMODE(st.st_mode):
 
353
            # Because of umask, we may still need to chmod the file.
 
354
            # But in the general case, we won't have to
 
355
            os.chmod(file_abspath, mode)
 
356
        return st.st_size
 
357
 
 
358
    def append_file(self, relpath, f, mode=None):
172
359
        """Append the text in the file-like object into the final location."""
173
 
        abspath = self._abspath(relpath)
174
 
        try:
175
 
            fp = open(abspath, 'ab')
176
 
            # FIXME should we really be chmodding every time ? RBC 20060523
177
 
            if mode is not None:
178
 
                os.chmod(abspath, mode)
179
 
        except (IOError, OSError),e:
180
 
            self._translate_error(e, relpath)
181
 
        # win32 workaround (tell on an unwritten file returns 0)
182
 
        fp.seek(0, 2)
183
 
        result = fp.tell()
184
 
        self._pump(f, fp)
185
 
        return result
 
360
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
 
361
        try:
 
362
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
 
363
            self._pump_to_fd(f, fd)
 
364
        finally:
 
365
            os.close(fd)
 
366
        return result
 
367
 
 
368
    def append_bytes(self, relpath, bytes, mode=None):
 
369
        """Append the text in the string into the final location."""
 
370
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
 
371
        try:
 
372
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
 
373
            os.write(fd, bytes)
 
374
        finally:
 
375
            os.close(fd)
 
376
        return result
 
377
 
 
378
    def _pump_to_fd(self, fromfile, to_fd):
 
379
        """Copy contents of one file to another."""
 
380
        BUFSIZE = 32768
 
381
        while True:
 
382
            b = fromfile.read(BUFSIZE)
 
383
            if not b:
 
384
                break
 
385
            os.write(to_fd, b)
186
386
 
187
387
    def copy(self, rel_from, rel_to):
188
388
        """Copy the item at rel_from to the location at rel_to"""
211
411
 
212
412
        try:
213
413
            # this version will delete the destination if necessary
214
 
            rename(path_from, path_to)
 
414
            osutils.rename(path_from, path_to)
215
415
        except (IOError, OSError),e:
216
416
            # TODO: What about path_to?
217
417
            self._translate_error(e, path_from)
225
425
        except (IOError, OSError),e:
226
426
            self._translate_error(e, path)
227
427
 
 
428
    def external_url(self):
 
429
        """See bzrlib.transport.Transport.external_url."""
 
430
        # File URL's are externally usable.
 
431
        return self.base
 
432
 
228
433
    def copy_to(self, relpaths, other, mode=None, pb=None):
229
434
        """Copy a set of entries from self into another Transport.
230
435
 
262
467
        """
263
468
        path = self._abspath(relpath)
264
469
        try:
265
 
            return [urlutils.escape(entry) for entry in os.listdir(path)]
 
470
            entries = os.listdir(path)
266
471
        except (IOError, OSError), e:
267
472
            self._translate_error(e, path)
 
473
        return [urlutils.escape(entry) for entry in entries]
268
474
 
269
475
    def stat(self, relpath):
270
476
        """Return the stat information for a file.
314
520
            return True
315
521
 
316
522
 
317
 
class ScratchTransport(LocalTransport):
318
 
    """A transport that works in a temporary dir and cleans up after itself.
 
523
class EmulatedWin32LocalTransport(LocalTransport):
 
524
    """Special transport for testing Win32 [UNC] paths on non-windows"""
 
525
 
 
526
    def __init__(self, base):
 
527
        if base[-1] != '/':
 
528
            base = base + '/'
 
529
        super(LocalTransport, self).__init__(base)
 
530
        self._local_base = urlutils._win32_local_path_from_url(base)
 
531
 
 
532
    def abspath(self, relpath):
 
533
        path = osutils.normpath(osutils.pathjoin(
 
534
                    self._local_base, urlutils.unescape(relpath)))
 
535
        return urlutils._win32_local_path_to_url(path)
 
536
 
 
537
    def clone(self, offset=None):
 
538
        """Return a new LocalTransport with root at self.base + offset
 
539
        Because the local filesystem does not require a connection, 
 
540
        we can just return a new object.
 
541
        """
 
542
        if offset is None:
 
543
            return EmulatedWin32LocalTransport(self.base)
 
544
        else:
 
545
            abspath = self.abspath(offset)
 
546
            if abspath == 'file://':
 
547
                # fix upwalk for UNC path
 
548
                # when clone from //HOST/path updir recursively
 
549
                # we should stop at least at //HOST part
 
550
                abspath = self.base
 
551
            return EmulatedWin32LocalTransport(abspath)
 
552
 
 
553
 
 
554
class LocalURLServer(Server):
 
555
    """A pretend server for local transports, using file:// urls.
319
556
    
320
 
    The dir only exists for the lifetime of the Python object.
321
 
    Obviously you should not put anything precious in it.
 
557
    Of course no actual server is required to access the local filesystem, so
 
558
    this just exists to tell the test code how to get to it.
322
559
    """
323
560
 
324
 
    def __init__(self, base=None):
325
 
        if base is None:
326
 
            base = tempfile.mkdtemp()
327
 
        super(ScratchTransport, self).__init__(base)
328
 
 
329
 
    def __del__(self):
330
 
        rmtree(self.base, ignore_errors=True)
331
 
        mutter("%r destroyed" % self)
332
 
 
333
 
 
334
 
class LocalRelpathServer(Server):
335
 
    """A pretend server for local transports, using relpaths."""
336
 
 
337
 
    def get_url(self):
338
 
        """See Transport.Server.get_url."""
339
 
        return "."
340
 
 
341
 
 
342
 
class LocalAbspathServer(Server):
343
 
    """A pretend server for local transports, using absolute paths."""
344
 
 
345
 
    def get_url(self):
346
 
        """See Transport.Server.get_url."""
347
 
        return os.path.abspath("")
348
 
 
349
 
 
350
 
class LocalURLServer(Server):
351
 
    """A pretend server for local transports, using file:// urls."""
 
561
    def setUp(self):
 
562
        """Setup the server to service requests.
 
563
        
 
564
        :param decorated_transport: ignored by this implementation.
 
565
        """
352
566
 
353
567
    def get_url(self):
354
568
        """See Transport.Server.get_url."""
357
571
 
358
572
def get_test_permutations():
359
573
    """Return the permutations to be used in testing."""
360
 
    return [(LocalTransport, LocalRelpathServer),
361
 
            (LocalTransport, LocalAbspathServer),
 
574
    return [
362
575
            (LocalTransport, LocalURLServer),
363
576
            ]