/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Vincent Ladeuil
  • Date: 2016-02-07 18:23:13 UTC
  • mto: (6615.3.1 2.7)
  • mto: This revision was merged to the branch mainline in revision 6620.
  • Revision ID: v.ladeuil+lp@free.fr-20160207182313-jwz7z3vj4mpyjn7y
Ensure http://pad.lv/1323805 won't come back.

Since the 2.6.0 release pypi policy changed and release tarballs can't be
hosted on launchpad anymore, they have to be uploaded to
http://pypi.python.org/pypi


This fixes setup.py sdist to generate the right tarball with nearly the same
content as the one produced for 2.7.0.

Such a tarball have been uploaded to pypi properly signed and tested for
installation in venv.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2016 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
19
19
This is a fairly thin wrapper on regular file IO.
20
20
"""
21
21
 
 
22
from __future__ import absolute_import
 
23
 
22
24
import os
23
 
from stat import ST_MODE, S_ISDIR, ST_SIZE, S_IMODE
 
25
from stat import ST_MODE, S_ISDIR, S_IMODE
24
26
import sys
25
27
 
26
28
from bzrlib.lazy_import import lazy_import
33
35
    osutils,
34
36
    urlutils,
35
37
    symbol_versioning,
36
 
    transport,
37
38
    )
38
 
from bzrlib.trace import mutter
39
39
from bzrlib.transport import LateReadError
40
40
""")
41
41
 
52
52
    def __init__(self, base):
53
53
        """Set the base path where files will be stored."""
54
54
        if not base.startswith('file://'):
55
 
            symbol_versioning.warn(
56
 
                "Instantiating LocalTransport with a filesystem path"
57
 
                " is deprecated as of bzr 0.8."
58
 
                " Please use bzrlib.transport.get_transport()"
59
 
                " or pass in a file:// url.",
60
 
                 DeprecationWarning,
61
 
                 stacklevel=2
62
 
                 )
63
 
            base = urlutils.local_path_to_url(base)
 
55
            raise AssertionError("not a file:// url: %r" % base)
64
56
        if base[-1] != '/':
65
57
            base = base + '/'
66
58
 
74
66
 
75
67
        super(LocalTransport, self).__init__(base)
76
68
        self._local_base = urlutils.local_path_from_url(base)
 
69
        if self._local_base[-1] != '/':
 
70
            self._local_base = self._local_base + '/'
77
71
 
78
72
    def clone(self, offset=None):
79
73
        """Return a new LocalTransport with root at self.base + offset
99
93
         - relative_reference is url escaped.
100
94
        """
101
95
        if relative_reference in ('.', ''):
102
 
            return self._local_base
 
96
            # _local_base normally has a trailing slash; strip it so that stat
 
97
            # on a transport pointing to a symlink reads the link not the
 
98
            # referent but be careful of / and c:\
 
99
            return osutils.split(self._local_base)[0]
103
100
        return self._local_base + urlutils.unescape(relative_reference)
104
101
 
105
102
    def abspath(self, relpath):
143
140
        if abspath is None:
144
141
            abspath = u'.'
145
142
 
146
 
        return urlutils.file_relpath(
147
 
            urlutils.strip_trailing_slash(self.base),
148
 
            urlutils.strip_trailing_slash(abspath))
 
143
        return urlutils.file_relpath(self.base, abspath)
149
144
 
150
145
    def has(self, relpath):
151
146
        return os.access(self._abspath(relpath), os.F_OK)
189
184
            fp.close()
190
185
        return length
191
186
 
192
 
    def put_bytes(self, relpath, bytes, mode=None):
 
187
    def put_bytes(self, relpath, raw_bytes, mode=None):
193
188
        """Copy the string into the location.
194
189
 
195
190
        :param relpath: Location to put the contents, relative to base.
196
 
        :param bytes:   String
 
191
        :param raw_bytes:   String
197
192
        """
198
 
 
 
193
        if not isinstance(raw_bytes, str):
 
194
            raise TypeError(
 
195
                'raw_bytes must be a plain string, not %s' % type(raw_bytes))
199
196
        path = relpath
200
197
        try:
201
198
            path = self._abspath(relpath)
205
202
            self._translate_error(e, path)
206
203
        try:
207
204
            if bytes:
208
 
                fp.write(bytes)
 
205
                fp.write(raw_bytes)
209
206
            fp.commit()
210
207
        finally:
211
208
            fp.close()
254
251
            if mode is not None and mode != S_IMODE(st.st_mode):
255
252
                # Because of umask, we may still need to chmod the file.
256
253
                # But in the general case, we won't have to
257
 
                os.chmod(abspath, mode)
 
254
                osutils.chmod_if_possible(abspath, mode)
258
255
            writer(fd)
259
256
        finally:
260
257
            os.close(fd)
313
310
            local_mode = mode
314
311
        try:
315
312
            os.mkdir(abspath, local_mode)
316
 
            if mode is not None:
317
 
                # It is probably faster to just do the chmod, rather than
318
 
                # doing a stat, and then trying to compare
319
 
                os.chmod(abspath, mode)
320
313
        except (IOError, OSError),e:
321
314
            self._translate_error(e, abspath)
 
315
        if mode is not None:
 
316
            try:
 
317
                osutils.chmod_if_possible(abspath, mode)
 
318
            except (IOError, OSError), e:
 
319
                self._translate_error(e, abspath)
322
320
 
323
321
    def mkdir(self, relpath, mode=None):
324
322
        """Create a directory at the given path."""
326
324
 
327
325
    def open_write_stream(self, relpath, mode=None):
328
326
        """See Transport.open_write_stream."""
329
 
        # initialise the file
330
 
        self.put_bytes_non_atomic(relpath, "", mode=mode)
331
327
        abspath = self._abspath(relpath)
332
 
        handle = osutils.open_file(abspath, 'wb')
 
328
        try:
 
329
            handle = osutils.open_file(abspath, 'wb')
 
330
        except (IOError, OSError),e:
 
331
            self._translate_error(e, abspath)
 
332
        handle.truncate()
333
333
        if mode is not None:
334
334
            self._check_mode_and_size(abspath, handle.fileno(), mode)
335
335
        transport._file_streams[self.abspath(relpath)] = handle
354
354
        if mode is not None and mode != S_IMODE(st.st_mode):
355
355
            # Because of umask, we may still need to chmod the file.
356
356
            # But in the general case, we won't have to
357
 
            os.chmod(file_abspath, mode)
 
357
            osutils.chmod_if_possible(file_abspath, mode)
358
358
        return st.st_size
359
359
 
360
360
    def append_file(self, relpath, f, mode=None):
403
403
        try:
404
404
            # *don't* call bzrlib.osutils.rename, because we want to
405
405
            # detect conflicting names on rename, and osutils.rename tries to
406
 
            # mask cross-platform differences there; however we do update the
407
 
            # exception to include the filenames
 
406
            # mask cross-platform differences there
408
407
            os.rename(path_from, path_to)
409
408
        except (IOError, OSError),e:
410
409
            # TODO: What about path_to?
411
 
            self._translate_error(
412
 
                osutils._add_rename_error_details(e, path_from, path_to),
413
 
                path_from)
 
410
            self._translate_error(e, path_from)
414
411
 
415
412
    def move(self, rel_from, rel_to):
416
413
        """Move the item at rel_from to the location at rel_to"""
456
453
                    otherpath = other._abspath(path)
457
454
                    shutil.copy(mypath, otherpath)
458
455
                    if mode is not None:
459
 
                        os.chmod(otherpath, mode)
 
456
                        osutils.chmod_if_possible(otherpath, mode)
460
457
                except (IOError, OSError),e:
461
458
                    self._translate_error(e, path)
462
459
                count += 1
538
535
            """See Transport.symlink."""
539
536
            abs_link_dirpath = urlutils.dirname(self.abspath(link_name))
540
537
            source_rel = urlutils.file_relpath(
541
 
                urlutils.strip_trailing_slash(abs_link_dirpath),
542
 
                urlutils.strip_trailing_slash(self.abspath(source))
543
 
            )
 
538
                abs_link_dirpath, self.abspath(source))
544
539
 
545
540
            try:
546
541
                os.symlink(source_rel, self._abspath(link_name))
565
560
        self._local_base = urlutils._win32_local_path_from_url(base)
566
561
 
567
562
    def abspath(self, relpath):
568
 
        path = osutils.normpath(osutils.pathjoin(
 
563
        path = osutils._win32_normpath(osutils.pathjoin(
569
564
                    self._local_base, urlutils.unescape(relpath)))
570
565
        return urlutils._win32_local_path_to_url(path)
571
566