← 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-09-21 20:21:36 UTC
  • mto: (2027.1.2 revert-subpath-56549)
  • mto: This revision was merged to the branch mainline in revision 2031.
  • Revision ID: abentley@panoramicfeedback.com-20060921202136-e5a8deaadfa00021
Added test for preserving file mode

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