← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

Show diffs side-by-side

added added

removed removed

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