← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Wouter van Heyst
  • Date: 2006-06-07 16:05:27 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: larstiq@larstiq.dyndns.org-20060607160527-2b3649154d0e2e84
more code cleanup

Show diffs side-by-side

added added

removed removed

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