← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: John Arbash Meinel
  • Date: 2007-08-14 19:29:56 UTC
  • mto: This revision was merged to the branch mainline in revision 2698.
  • Revision ID: john@arbash-meinel.com-20070814192956-34h336i5q3m34ods
Switch bzr.dev to 0.91 development

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
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
16
16
 
17
17
"""Transport for the local filesystem.
18
18
 
19
 
This is a fairly thin wrapper on regular file IO."""
 
19
This is a fairly thin wrapper on regular file IO.
 
20
"""
20
21
 
21
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
22
29
import shutil
23
 
from stat import ST_MODE, S_ISDIR, ST_SIZE
24
 
import tempfile
25
 
import urllib
26
30
 
 
31
from bzrlib import (
 
32
    atomicfile,
 
33
    osutils,
 
34
    urlutils,
 
35
    symbol_versioning,
 
36
    )
27
37
from bzrlib.trace import mutter
28
 
from bzrlib.transport import Transport
29
 
from bzrlib.osutils import abspath, realpath, normpath, pathjoin, rename
 
38
from bzrlib.transport import LateReadError
 
39
""")
 
40
 
 
41
from bzrlib.transport import Transport, Server
 
42
 
 
43
 
 
44
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY
 
45
_put_non_atomic_flags = os.O_CREAT | os.O_TRUNC | os.O_WRONLY | osutils.O_BINARY
30
46
 
31
47
 
32
48
class LocalTransport(Transport):
34
50
 
35
51
    def __init__(self, base):
36
52
        """Set the base path where files will be stored."""
37
 
        if base.startswith('file://'):
38
 
            base = base[7:]
39
 
        # realpath is incompatible with symlinks. When we traverse
40
 
        # up we might be able to normpath stuff. RBC 20051003
41
 
        super(LocalTransport, self).__init__(normpath(abspath(base)))
 
53
        if not base.startswith('file://'):
 
54
            symbol_versioning.warn(
 
55
                "Instantiating LocalTransport with a filesystem path"
 
56
                " is deprecated as of bzr 0.8."
 
57
                " Please use bzrlib.transport.get_transport()"
 
58
                " or pass in a file:// url.",
 
59
                 DeprecationWarning,
 
60
                 stacklevel=2
 
61
                 )
 
62
            base = urlutils.local_path_to_url(base)
 
63
        if base[-1] != '/':
 
64
            base = base + '/'
 
65
        super(LocalTransport, self).__init__(base)
 
66
        self._local_base = urlutils.local_path_from_url(base)
42
67
 
43
68
    def should_cache(self):
44
69
        return False
51
76
        if offset is None:
52
77
            return LocalTransport(self.base)
53
78
        else:
54
 
            return LocalTransport(self.abspath(offset))
 
79
            abspath = self.abspath(offset)
 
80
            if abspath == 'file://':
 
81
                # fix upwalk for UNC path
 
82
                # when clone from //HOST/path updir recursively
 
83
                # we should stop at least at //HOST part
 
84
                abspath = self.base
 
85
            return LocalTransport(abspath)
 
86
 
 
87
    def _abspath(self, relative_reference):
 
88
        """Return a path for use in os calls.
 
89
 
 
90
        Several assumptions are made:
 
91
         - relative_reference does not contain '..'
 
92
         - relative_reference is url escaped.
 
93
        """
 
94
        if relative_reference in ('.', ''):
 
95
            return self._local_base
 
96
        return self._local_base + urlutils.unescape(relative_reference)
55
97
 
56
98
    def abspath(self, relpath):
57
 
        """Return the full url to the given relative URL.
58
 
        This can be supplied with a string or a list
59
 
        """
 
99
        """Return the full url to the given relative URL."""
 
100
        # TODO: url escape the result. RBC 20060523.
60
101
        assert isinstance(relpath, basestring), (type(relpath), relpath)
61
 
        return pathjoin(self.base, urllib.unquote(relpath))
 
102
        # jam 20060426 Using normpath on the real path, because that ensures
 
103
        #       proper handling of stuff like
 
104
        path = osutils.normpath(osutils.pathjoin(
 
105
                    self._local_base, urlutils.unescape(relpath)))
 
106
        return urlutils.local_path_to_url(path)
 
107
 
 
108
    def local_abspath(self, relpath):
 
109
        """Transform the given relative path URL into the actual path on disk
 
110
 
 
111
        This function only exists for the LocalTransport, since it is
 
112
        the only one that has direct local access.
 
113
        This is mostly for stuff like WorkingTree which needs to know
 
114
        the local working directory.
 
115
        
 
116
        This function is quite expensive: it calls realpath which resolves
 
117
        symlinks.
 
118
        """
 
119
        absurl = self.abspath(relpath)
 
120
        # mutter(u'relpath %s => base: %s, absurl %s', relpath, self.base, absurl)
 
121
        return urlutils.local_path_from_url(absurl)
62
122
 
63
123
    def relpath(self, abspath):
64
124
        """Return the local path portion from a given absolute path.
65
125
        """
66
 
        from bzrlib.osutils import relpath
67
126
        if abspath is None:
68
127
            abspath = u'.'
69
 
        return relpath(self.base, abspath)
 
128
 
 
129
        return urlutils.file_relpath(
 
130
            urlutils.strip_trailing_slash(self.base),
 
131
            urlutils.strip_trailing_slash(abspath))
70
132
 
71
133
    def has(self, relpath):
72
 
        return os.access(self.abspath(relpath), os.F_OK)
 
134
        return os.access(self._abspath(relpath), os.F_OK)
73
135
 
74
136
    def get(self, relpath):
75
137
        """Get the file at the given relative path.
77
139
        :param relpath: The relative path to the file
78
140
        """
79
141
        try:
80
 
            path = self.abspath(relpath)
 
142
            path = self._abspath(relpath)
81
143
            return open(path, 'rb')
82
144
        except (IOError, OSError),e:
 
145
            if e.errno == errno.EISDIR:
 
146
                return LateReadError(relpath)
83
147
            self._translate_error(e, path)
84
148
 
85
 
    def put(self, relpath, f, mode=None):
86
 
        """Copy the file-like or string object into the location.
 
149
    def put_file(self, relpath, f, mode=None):
 
150
        """Copy the file-like object into the location.
87
151
 
88
152
        :param relpath: Location to put the contents, relative to base.
89
 
        :param f:       File-like or string object.
 
153
        :param f:       File-like object.
 
154
        :param mode: The mode for the newly created file, 
 
155
                     None means just use the default
90
156
        """
91
 
        from bzrlib.atomicfile import AtomicFile
92
157
 
93
158
        path = relpath
94
159
        try:
95
 
            path = self.abspath(relpath)
96
 
            fp = AtomicFile(path, 'wb', new_mode=mode)
 
160
            path = self._abspath(relpath)
 
161
            osutils.check_legal_path(path)
 
162
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
97
163
        except (IOError, OSError),e:
98
164
            self._translate_error(e, path)
99
165
        try:
102
168
        finally:
103
169
            fp.close()
104
170
 
 
171
    def put_bytes(self, relpath, bytes, mode=None):
 
172
        """Copy the string into the location.
 
173
 
 
174
        :param relpath: Location to put the contents, relative to base.
 
175
        :param bytes:   String
 
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
            fp.write(bytes)
 
187
            fp.commit()
 
188
        finally:
 
189
            fp.close()
 
190
 
 
191
    def _put_non_atomic_helper(self, relpath, writer,
 
192
                               mode=None,
 
193
                               create_parent_dir=False,
 
194
                               dir_mode=None):
 
195
        """Common functionality information for the put_*_non_atomic.
 
196
 
 
197
        This tracks all the create_parent_dir stuff.
 
198
 
 
199
        :param relpath: the path we are putting to.
 
200
        :param writer: A function that takes an os level file descriptor
 
201
            and writes whatever data it needs to write there.
 
202
        :param mode: The final file mode.
 
203
        :param create_parent_dir: Should we be creating the parent directory
 
204
            if it doesn't exist?
 
205
        """
 
206
        abspath = self._abspath(relpath)
 
207
        if mode is None:
 
208
            # os.open() will automatically use the umask
 
209
            local_mode = 0666
 
210
        else:
 
211
            local_mode = mode
 
212
        try:
 
213
            fd = os.open(abspath, _put_non_atomic_flags, local_mode)
 
214
        except (IOError, OSError),e:
 
215
            # We couldn't create the file, maybe we need to create
 
216
            # the parent directory, and try again
 
217
            if (not create_parent_dir
 
218
                or e.errno not in (errno.ENOENT,errno.ENOTDIR)):
 
219
                self._translate_error(e, relpath)
 
220
            parent_dir = os.path.dirname(abspath)
 
221
            if not parent_dir:
 
222
                self._translate_error(e, relpath)
 
223
            self._mkdir(parent_dir, mode=dir_mode)
 
224
            # We created the parent directory, lets try to open the
 
225
            # file again
 
226
            try:
 
227
                fd = os.open(abspath, _put_non_atomic_flags, local_mode)
 
228
            except (IOError, OSError), e:
 
229
                self._translate_error(e, relpath)
 
230
        try:
 
231
            st = os.fstat(fd)
 
232
            if mode is not None and mode != S_IMODE(st.st_mode):
 
233
                # Because of umask, we may still need to chmod the file.
 
234
                # But in the general case, we won't have to
 
235
                os.chmod(abspath, mode)
 
236
            writer(fd)
 
237
        finally:
 
238
            os.close(fd)
 
239
 
 
240
    def put_file_non_atomic(self, relpath, f, mode=None,
 
241
                            create_parent_dir=False,
 
242
                            dir_mode=None):
 
243
        """Copy the file-like object into the target location.
 
244
 
 
245
        This function is not strictly safe to use. It is only meant to
 
246
        be used when you already know that the target does not exist.
 
247
        It is not safe, because it will open and truncate the remote
 
248
        file. So there may be a time when the file has invalid contents.
 
249
 
 
250
        :param relpath: The remote location to put the contents.
 
251
        :param f:       File-like object.
 
252
        :param mode:    Possible access permissions for new file.
 
253
                        None means do not set remote permissions.
 
254
        :param create_parent_dir: If we cannot create the target file because
 
255
                        the parent directory does not exist, go ahead and
 
256
                        create it, and then try again.
 
257
        """
 
258
        def writer(fd):
 
259
            self._pump_to_fd(f, fd)
 
260
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
261
                                    create_parent_dir=create_parent_dir,
 
262
                                    dir_mode=dir_mode)
 
263
 
 
264
    def put_bytes_non_atomic(self, relpath, bytes, mode=None,
 
265
                             create_parent_dir=False, dir_mode=None):
 
266
        def writer(fd):
 
267
            os.write(fd, bytes)
 
268
        self._put_non_atomic_helper(relpath, writer, mode=mode,
 
269
                                    create_parent_dir=create_parent_dir,
 
270
                                    dir_mode=dir_mode)
 
271
 
105
272
    def iter_files_recursive(self):
106
273
        """Iter the relative paths of files in the transports sub-tree."""
107
274
        queue = list(self.list_dir(u'.'))
108
275
        while queue:
109
 
            relpath = urllib.quote(queue.pop(0))
 
276
            relpath = queue.pop(0)
110
277
            st = self.stat(relpath)
111
278
            if S_ISDIR(st[ST_MODE]):
112
279
                for i, basename in enumerate(self.list_dir(relpath)):
114
281
            else:
115
282
                yield relpath
116
283
 
 
284
    def _mkdir(self, abspath, mode=None):
 
285
        """Create a real directory, filtering through mode"""
 
286
        if mode is None:
 
287
            # os.mkdir() will filter through umask
 
288
            local_mode = 0777
 
289
        else:
 
290
            local_mode = mode
 
291
        try:
 
292
            os.mkdir(abspath, local_mode)
 
293
            if mode is not None:
 
294
                # It is probably faster to just do the chmod, rather than
 
295
                # doing a stat, and then trying to compare
 
296
                os.chmod(abspath, mode)
 
297
        except (IOError, OSError),e:
 
298
            self._translate_error(e, abspath)
 
299
 
117
300
    def mkdir(self, relpath, mode=None):
118
301
        """Create a directory at the given path."""
119
 
        path = relpath
 
302
        self._mkdir(self._abspath(relpath), mode=mode)
 
303
 
 
304
    def _get_append_file(self, relpath, mode=None):
 
305
        """Call os.open() for the given relpath"""
 
306
        file_abspath = self._abspath(relpath)
 
307
        if mode is None:
 
308
            # os.open() will automatically use the umask
 
309
            local_mode = 0666
 
310
        else:
 
311
            local_mode = mode
120
312
        try:
121
 
            path = self.abspath(relpath)
122
 
            os.mkdir(path)
123
 
            if mode is not None:
124
 
                os.chmod(path, mode)
 
313
            return file_abspath, os.open(file_abspath, _append_flags, local_mode)
125
314
        except (IOError, OSError),e:
126
 
            self._translate_error(e, path)
127
 
 
128
 
    def append(self, relpath, f):
129
 
        """Append the text in the file-like object into the final
130
 
        location.
131
 
        """
132
 
        fp = open(self.abspath(relpath), 'ab')
133
 
        self._pump(f, fp)
 
315
            self._translate_error(e, relpath)
 
316
 
 
317
    def _check_mode_and_size(self, file_abspath, fd, mode=None):
 
318
        """Check the mode of the file, and return the current size"""
 
319
        st = os.fstat(fd)
 
320
        if mode is not None and mode != S_IMODE(st.st_mode):
 
321
            # Because of umask, we may still need to chmod the file.
 
322
            # But in the general case, we won't have to
 
323
            os.chmod(file_abspath, mode)
 
324
        return st.st_size
 
325
 
 
326
    def append_file(self, relpath, f, mode=None):
 
327
        """Append the text in the file-like object into the final location."""
 
328
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
 
329
        try:
 
330
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
 
331
            self._pump_to_fd(f, fd)
 
332
        finally:
 
333
            os.close(fd)
 
334
        return result
 
335
 
 
336
    def append_bytes(self, relpath, bytes, mode=None):
 
337
        """Append the text in the string into the final location."""
 
338
        file_abspath, fd = self._get_append_file(relpath, mode=mode)
 
339
        try:
 
340
            result = self._check_mode_and_size(file_abspath, fd, mode=mode)
 
341
            os.write(fd, bytes)
 
342
        finally:
 
343
            os.close(fd)
 
344
        return result
 
345
 
 
346
    def _pump_to_fd(self, fromfile, to_fd):
 
347
        """Copy contents of one file to another."""
 
348
        BUFSIZE = 32768
 
349
        while True:
 
350
            b = fromfile.read(BUFSIZE)
 
351
            if not b:
 
352
                break
 
353
            os.write(to_fd, b)
134
354
 
135
355
    def copy(self, rel_from, rel_to):
136
356
        """Copy the item at rel_from to the location at rel_to"""
137
 
        import shutil
138
 
        path_from = self.abspath(rel_from)
139
 
        path_to = self.abspath(rel_to)
 
357
        path_from = self._abspath(rel_from)
 
358
        path_to = self._abspath(rel_to)
140
359
        try:
141
360
            shutil.copy(path_from, path_to)
142
361
        except (IOError, OSError),e:
143
362
            # TODO: What about path_to?
144
363
            self._translate_error(e, path_from)
145
364
 
 
365
    def rename(self, rel_from, rel_to):
 
366
        path_from = self._abspath(rel_from)
 
367
        try:
 
368
            # *don't* call bzrlib.osutils.rename, because we want to 
 
369
            # detect errors on rename
 
370
            os.rename(path_from, self._abspath(rel_to))
 
371
        except (IOError, OSError),e:
 
372
            # TODO: What about path_to?
 
373
            self._translate_error(e, path_from)
 
374
 
146
375
    def move(self, rel_from, rel_to):
147
376
        """Move the item at rel_from to the location at rel_to"""
148
 
        path_from = self.abspath(rel_from)
149
 
        path_to = self.abspath(rel_to)
 
377
        path_from = self._abspath(rel_from)
 
378
        path_to = self._abspath(rel_to)
150
379
 
151
380
        try:
152
 
            rename(path_from, path_to)
 
381
            # this version will delete the destination if necessary
 
382
            osutils.rename(path_from, path_to)
153
383
        except (IOError, OSError),e:
154
384
            # TODO: What about path_to?
155
385
            self._translate_error(e, path_from)
158
388
        """Delete the item at relpath"""
159
389
        path = relpath
160
390
        try:
161
 
            path = self.abspath(relpath)
 
391
            path = self._abspath(relpath)
162
392
            os.remove(path)
163
393
        except (IOError, OSError),e:
164
 
            # TODO: What about path_to?
165
394
            self._translate_error(e, path)
166
395
 
 
396
    def external_url(self):
 
397
        """See bzrlib.transport.Transport.external_url."""
 
398
        # File URL's are externally usable.
 
399
        return self.base
 
400
 
167
401
    def copy_to(self, relpaths, other, mode=None, pb=None):
168
402
        """Copy a set of entries from self into another Transport.
169
403
 
173
407
            # Both from & to are on the local filesystem
174
408
            # Unfortunately, I can't think of anything faster than just
175
409
            # copying them across, one by one :(
176
 
            import shutil
177
 
 
178
410
            total = self._get_total(relpaths)
179
411
            count = 0
180
412
            for path in relpaths:
181
413
                self._update_pb(pb, 'copy-to', count, total)
182
414
                try:
183
 
                    mypath = self.abspath(path)
184
 
                    otherpath = other.abspath(path)
 
415
                    mypath = self._abspath(path)
 
416
                    otherpath = other._abspath(path)
185
417
                    shutil.copy(mypath, otherpath)
186
418
                    if mode is not None:
187
419
                        os.chmod(otherpath, mode)
201
433
        WARNING: many transports do not support this, so trying avoid using
202
434
        it if at all possible.
203
435
        """
204
 
        path = relpath
 
436
        path = self._abspath(relpath)
205
437
        try:
206
 
            path = self.abspath(relpath)
207
 
            return os.listdir(path)
208
 
        except (IOError, OSError),e:
 
438
            entries = os.listdir(path)
 
439
        except (IOError, OSError), e:
209
440
            self._translate_error(e, path)
 
441
        return [urlutils.escape(entry) for entry in entries]
210
442
 
211
443
    def stat(self, relpath):
212
444
        """Return the stat information for a file.
213
445
        """
214
446
        path = relpath
215
447
        try:
216
 
            path = self.abspath(relpath)
 
448
            path = self._abspath(relpath)
217
449
            return os.stat(path)
218
450
        except (IOError, OSError),e:
219
451
            self._translate_error(e, path)
223
455
        :return: A lock object, which should be passed to Transport.unlock()
224
456
        """
225
457
        from bzrlib.lock import ReadLock
226
 
        return ReadLock(self.abspath(relpath))
 
458
        path = relpath
 
459
        try:
 
460
            path = self._abspath(relpath)
 
461
            return ReadLock(path)
 
462
        except (IOError, OSError), e:
 
463
            self._translate_error(e, path)
227
464
 
228
465
    def lock_write(self, relpath):
229
466
        """Lock the given file for exclusive (write) access.
232
469
        :return: A lock object, which should be passed to Transport.unlock()
233
470
        """
234
471
        from bzrlib.lock import WriteLock
235
 
        return WriteLock(self.abspath(relpath))
236
 
 
237
 
 
238
 
class ScratchTransport(LocalTransport):
239
 
    """A transport that works in a temporary dir and cleans up after itself.
 
472
        return WriteLock(self._abspath(relpath))
 
473
 
 
474
    def rmdir(self, relpath):
 
475
        """See Transport.rmdir."""
 
476
        path = relpath
 
477
        try:
 
478
            path = self._abspath(relpath)
 
479
            os.rmdir(path)
 
480
        except (IOError, OSError),e:
 
481
            self._translate_error(e, path)
 
482
 
 
483
    def _can_roundtrip_unix_modebits(self):
 
484
        if sys.platform == 'win32':
 
485
            # anyone else?
 
486
            return False
 
487
        else:
 
488
            return True
 
489
 
 
490
 
 
491
class EmulatedWin32LocalTransport(LocalTransport):
 
492
    """Special transport for testing Win32 [UNC] paths on non-windows"""
 
493
 
 
494
    def __init__(self, base):
 
495
        if base[-1] != '/':
 
496
            base = base + '/'
 
497
        super(LocalTransport, self).__init__(base)
 
498
        self._local_base = urlutils._win32_local_path_from_url(base)
 
499
 
 
500
    def abspath(self, relpath):
 
501
        assert isinstance(relpath, basestring), (type(relpath), relpath)
 
502
        path = osutils.normpath(osutils.pathjoin(
 
503
                    self._local_base, urlutils.unescape(relpath)))
 
504
        return urlutils._win32_local_path_to_url(path)
 
505
 
 
506
    def clone(self, offset=None):
 
507
        """Return a new LocalTransport with root at self.base + offset
 
508
        Because the local filesystem does not require a connection, 
 
509
        we can just return a new object.
 
510
        """
 
511
        if offset is None:
 
512
            return EmulatedWin32LocalTransport(self.base)
 
513
        else:
 
514
            abspath = self.abspath(offset)
 
515
            if abspath == 'file://':
 
516
                # fix upwalk for UNC path
 
517
                # when clone from //HOST/path updir recursively
 
518
                # we should stop at least at //HOST part
 
519
                abspath = self.base
 
520
            return EmulatedWin32LocalTransport(abspath)
 
521
 
 
522
 
 
523
class LocalURLServer(Server):
 
524
    """A pretend server for local transports, using file:// urls.
240
525
    
241
 
    The dir only exists for the lifetime of the Python object.
242
 
    Obviously you should not put anything precious in it.
 
526
    Of course no actual server is required to access the local filesystem, so
 
527
    this just exists to tell the test code how to get to it.
243
528
    """
244
529
 
245
 
    def __init__(self, base=None):
246
 
        if base is None:
247
 
            base = tempfile.mkdtemp()
248
 
        super(ScratchTransport, self).__init__(base)
249
 
 
250
 
    def __del__(self):
251
 
        shutil.rmtree(self.base, ignore_errors=True)
252
 
        mutter("%r destroyed" % self)
 
530
    def setUp(self):
 
531
        """Setup the server to service requests.
 
532
        
 
533
        :param decorated_transport: ignored by this implementation.
 
534
        """
 
535
 
 
536
    def get_url(self):
 
537
        """See Transport.Server.get_url."""
 
538
        return urlutils.local_path_to_url('')
 
539
 
 
540
 
 
541
def get_test_permutations():
 
542
    """Return the permutations to be used in testing."""
 
543
    return [
 
544
            (LocalTransport, LocalURLServer),
 
545
            ]