← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Aaron Bentley
  • Date: 2006-11-10 01:55:55 UTC
  • mto: This revision was merged to the branch mainline in revision 2127.
  • Revision ID: aaron.bentley@utoronto.ca-20061110015555-f48202744b630209
Ignore html docs (both kinds)

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