/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/transport/local.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
25
25
from stat import ST_MODE, S_ISDIR, S_IMODE
26
26
import sys
27
27
 
28
 
from bzrlib.lazy_import import lazy_import
 
28
from ..lazy_import import lazy_import
29
29
lazy_import(globals(), """
30
30
import errno
31
31
import shutil
32
32
 
33
 
from bzrlib import (
 
33
from breezy import (
34
34
    atomicfile,
35
35
    osutils,
36
36
    urlutils,
37
37
    symbol_versioning,
38
38
    )
39
 
from bzrlib.transport import LateReadError
 
39
from breezy.transport import LateReadError
40
40
""")
41
41
 
42
 
from bzrlib import transport
 
42
from .. import transport
43
43
 
44
44
 
45
45
_append_flags = os.O_CREAT | os.O_APPEND | os.O_WRONLY | osutils.O_BINARY | osutils.O_NOINHERIT
51
51
 
52
52
    def __init__(self, base):
53
53
        """Set the base path where files will be stored."""
54
 
        if not base.startswith('file://'):
 
54
        if not base.startswith(b'file://'):
55
55
            raise AssertionError("not a file:// url: %r" % base)
56
 
        if base[-1] != '/':
57
 
            base = base + '/'
 
56
        if base[-1] != b'/':
 
57
            base = base + b'/'
58
58
 
59
59
        # Special case : windows has no "root", but does have
60
60
        # multiple lettered drives inside it. #240910
61
 
        if sys.platform == 'win32' and base == 'file:///':
62
 
            base = ''
 
61
        if sys.platform == 'win32' and base == b'file:///':
 
62
            base = b''
63
63
            self._local_base = ''
64
64
            super(LocalTransport, self).__init__(base)
65
65
            return
156
156
        try:
157
157
            path = self._abspath(relpath)
158
158
            return osutils.open_file(path, 'rb')
159
 
        except (IOError, OSError),e:
 
159
        except (IOError, OSError) as e:
160
160
            if e.errno == errno.EISDIR:
161
161
                return LateReadError(relpath)
162
162
            self._translate_error(e, path)
175
175
            path = self._abspath(relpath)
176
176
            osutils.check_legal_path(path)
177
177
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
178
 
        except (IOError, OSError),e:
 
178
        except (IOError, OSError) as e:
179
179
            self._translate_error(e, path)
180
180
        try:
181
181
            length = self._pump(f, fp)
198
198
            path = self._abspath(relpath)
199
199
            osutils.check_legal_path(path)
200
200
            fp = atomicfile.AtomicFile(path, 'wb', new_mode=mode)
201
 
        except (IOError, OSError),e:
 
201
        except (IOError, OSError) as e:
202
202
            self._translate_error(e, path)
203
203
        try:
204
204
            if bytes:
225
225
        abspath = self._abspath(relpath)
226
226
        if mode is None:
227
227
            # os.open() will automatically use the umask
228
 
            local_mode = 0666
 
228
            local_mode = 0o666
229
229
        else:
230
230
            local_mode = mode
231
231
        try:
232
232
            fd = os.open(abspath, _put_non_atomic_flags, local_mode)
233
 
        except (IOError, OSError),e:
 
233
        except (IOError, OSError) as e:
234
234
            # We couldn't create the file, maybe we need to create
235
235
            # the parent directory, and try again
236
236
            if (not create_parent_dir
244
244
            # file again
245
245
            try:
246
246
                fd = os.open(abspath, _put_non_atomic_flags, local_mode)
247
 
            except (IOError, OSError), e:
 
247
            except (IOError, OSError) as e:
248
248
                self._translate_error(e, relpath)
249
249
        try:
250
250
            st = os.fstat(fd)
305
305
        """Create a real directory, filtering through mode"""
306
306
        if mode is None:
307
307
            # os.mkdir() will filter through umask
308
 
            local_mode = 0777
 
308
            local_mode = 0o777
309
309
        else:
310
310
            local_mode = mode
311
311
        try:
312
312
            os.mkdir(abspath, local_mode)
313
 
        except (IOError, OSError),e:
 
313
        except (IOError, OSError) as e:
314
314
            self._translate_error(e, abspath)
315
315
        if mode is not None:
316
316
            try:
317
317
                osutils.chmod_if_possible(abspath, mode)
318
 
            except (IOError, OSError), e:
 
318
            except (IOError, OSError) as e:
319
319
                self._translate_error(e, abspath)
320
320
 
321
321
    def mkdir(self, relpath, mode=None):
327
327
        abspath = self._abspath(relpath)
328
328
        try:
329
329
            handle = osutils.open_file(abspath, 'wb')
330
 
        except (IOError, OSError),e:
 
330
        except (IOError, OSError) as e:
331
331
            self._translate_error(e, abspath)
332
332
        handle.truncate()
333
333
        if mode is not None:
340
340
        file_abspath = self._abspath(relpath)
341
341
        if mode is None:
342
342
            # os.open() will automatically use the umask
343
 
            local_mode = 0666
 
343
            local_mode = 0o666
344
344
        else:
345
345
            local_mode = mode
346
346
        try:
347
347
            return file_abspath, os.open(file_abspath, _append_flags, local_mode)
348
 
        except (IOError, OSError),e:
 
348
        except (IOError, OSError) as e:
349
349
            self._translate_error(e, relpath)
350
350
 
351
351
    def _check_mode_and_size(self, file_abspath, fd, mode=None):
393
393
        path_to = self._abspath(rel_to)
394
394
        try:
395
395
            shutil.copy(path_from, path_to)
396
 
        except (IOError, OSError),e:
 
396
        except (IOError, OSError) as e:
397
397
            # TODO: What about path_to?
398
398
            self._translate_error(e, path_from)
399
399
 
401
401
        path_from = self._abspath(rel_from)
402
402
        path_to = self._abspath(rel_to)
403
403
        try:
404
 
            # *don't* call bzrlib.osutils.rename, because we want to
 
404
            # *don't* call breezy.osutils.rename, because we want to
405
405
            # detect conflicting names on rename, and osutils.rename tries to
406
406
            # mask cross-platform differences there
407
407
            os.rename(path_from, path_to)
408
 
        except (IOError, OSError),e:
 
408
        except (IOError, OSError) as e:
409
409
            # TODO: What about path_to?
410
410
            self._translate_error(e, path_from)
411
411
 
417
417
        try:
418
418
            # this version will delete the destination if necessary
419
419
            osutils.rename(path_from, path_to)
420
 
        except (IOError, OSError),e:
 
420
        except (IOError, OSError) as e:
421
421
            # TODO: What about path_to?
422
422
            self._translate_error(e, path_from)
423
423
 
427
427
        try:
428
428
            path = self._abspath(relpath)
429
429
            os.remove(path)
430
 
        except (IOError, OSError),e:
 
430
        except (IOError, OSError) as e:
431
431
            self._translate_error(e, path)
432
432
 
433
433
    def external_url(self):
434
 
        """See bzrlib.transport.Transport.external_url."""
 
434
        """See breezy.transport.Transport.external_url."""
435
435
        # File URL's are externally usable.
436
436
        return self.base
437
437
 
454
454
                    shutil.copy(mypath, otherpath)
455
455
                    if mode is not None:
456
456
                        osutils.chmod_if_possible(otherpath, mode)
457
 
                except (IOError, OSError),e:
 
457
                except (IOError, OSError) as e:
458
458
                    self._translate_error(e, path)
459
459
                count += 1
460
460
            return count
473
473
        path = self._abspath(relpath)
474
474
        try:
475
475
            entries = os.listdir(path)
476
 
        except (IOError, OSError), e:
 
476
        except (IOError, OSError) as e:
477
477
            self._translate_error(e, path)
478
478
        return [urlutils.escape(entry) for entry in entries]
479
479
 
484
484
        try:
485
485
            path = self._abspath(relpath)
486
486
            return os.lstat(path)
487
 
        except (IOError, OSError),e:
 
487
        except (IOError, OSError) as e:
488
488
            self._translate_error(e, path)
489
489
 
490
490
    def lock_read(self, relpath):
491
491
        """Lock the given file for shared (read) access.
492
492
        :return: A lock object, which should be passed to Transport.unlock()
493
493
        """
494
 
        from bzrlib.lock import ReadLock
 
494
        from breezy.lock import ReadLock
495
495
        path = relpath
496
496
        try:
497
497
            path = self._abspath(relpath)
498
498
            return ReadLock(path)
499
 
        except (IOError, OSError), e:
 
499
        except (IOError, OSError) as e:
500
500
            self._translate_error(e, path)
501
501
 
502
502
    def lock_write(self, relpath):
505
505
 
506
506
        :return: A lock object, which should be passed to Transport.unlock()
507
507
        """
508
 
        from bzrlib.lock import WriteLock
 
508
        from breezy.lock import WriteLock
509
509
        return WriteLock(self._abspath(relpath))
510
510
 
511
511
    def rmdir(self, relpath):
514
514
        try:
515
515
            path = self._abspath(relpath)
516
516
            os.rmdir(path)
517
 
        except (IOError, OSError),e:
 
517
        except (IOError, OSError) as e:
518
518
            self._translate_error(e, path)
519
519
 
520
520
    if osutils.host_os_dereferences_symlinks():
527
527
            """See Transport.link."""
528
528
            try:
529
529
                os.link(self._abspath(source), self._abspath(link_name))
530
 
            except (IOError, OSError), e:
 
530
            except (IOError, OSError) as e:
531
531
                self._translate_error(e, source)
532
532
 
533
533
    if osutils.has_symlinks():
539
539
 
540
540
            try:
541
541
                os.symlink(source_rel, self._abspath(link_name))
542
 
            except (IOError, OSError), e:
 
542
            except (IOError, OSError) as e:
543
543
                self._translate_error(e, source_rel)
544
544
 
545
545
    def _can_roundtrip_unix_modebits(self):
583
583
 
584
584
def get_test_permutations():
585
585
    """Return the permutations to be used in testing."""
586
 
    from bzrlib.tests import test_server
 
586
    from ..tests import test_server
587
587
    return [(LocalTransport, test_server.LocalURLServer),]