← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/local.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/local.py
1
 
# Copyright (C) 2005-2011 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
25
from stat import ST_MODE, S_ISDIR, S_IMODE
24
26
import sys
50
52
    def __init__(self, base):
51
53
        """Set the base path where files will be stored."""
52
54
        if not base.startswith('file://'):
53
 
            symbol_versioning.warn(
54
 
                "Instantiating LocalTransport with a filesystem path"
55
 
                " is deprecated as of bzr 0.8."
56
 
                " Please use bzrlib.transport.get_transport()"
57
 
                " or pass in a file:// url.",
58
 
                 DeprecationWarning,
59
 
                 stacklevel=2
60
 
                 )
61
 
            base = urlutils.local_path_to_url(base)
 
55
            raise AssertionError("not a file:// url: %r" % base)
62
56
        if base[-1] != '/':
63
57
            base = base + '/'
64
58
 
146
140
        if abspath is None:
147
141
            abspath = u'.'
148
142
 
149
 
        return urlutils.file_relpath(
150
 
            urlutils.strip_trailing_slash(self.base),
151
 
            urlutils.strip_trailing_slash(abspath))
 
143
        return urlutils.file_relpath(self.base, abspath)
152
144
 
153
145
    def has(self, relpath):
154
146
        return os.access(self._abspath(relpath), os.F_OK)
192
184
            fp.close()
193
185
        return length
194
186
 
195
 
    def put_bytes(self, relpath, bytes, mode=None):
 
187
    def put_bytes(self, relpath, raw_bytes, mode=None):
196
188
        """Copy the string into the location.
197
189
 
198
190
        :param relpath: Location to put the contents, relative to base.
199
 
        :param bytes:   String
 
191
        :param raw_bytes:   String
200
192
        """
201
 
 
 
193
        if not isinstance(raw_bytes, str):
 
194
            raise TypeError(
 
195
                'raw_bytes must be a plain string, not %s' % type(raw_bytes))
202
196
        path = relpath
203
197
        try:
204
198
            path = self._abspath(relpath)
208
202
            self._translate_error(e, path)
209
203
        try:
210
204
            if bytes:
211
 
                fp.write(bytes)
 
205
                fp.write(raw_bytes)
212
206
            fp.commit()
213
207
        finally:
214
208
            fp.close()
257
251
            if mode is not None and mode != S_IMODE(st.st_mode):
258
252
                # Because of umask, we may still need to chmod the file.
259
253
                # But in the general case, we won't have to
260
 
                os.chmod(abspath, mode)
 
254
                osutils.chmod_if_possible(abspath, mode)
261
255
            writer(fd)
262
256
        finally:
263
257
            os.close(fd)
316
310
            local_mode = mode
317
311
        try:
318
312
            os.mkdir(abspath, local_mode)
319
 
            if mode is not None:
320
 
                # It is probably faster to just do the chmod, rather than
321
 
                # doing a stat, and then trying to compare
322
 
                os.chmod(abspath, mode)
323
313
        except (IOError, OSError),e:
324
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)
325
320
 
326
321
    def mkdir(self, relpath, mode=None):
327
322
        """Create a directory at the given path."""
359
354
        if mode is not None and mode != S_IMODE(st.st_mode):
360
355
            # Because of umask, we may still need to chmod the file.
361
356
            # But in the general case, we won't have to
362
 
            os.chmod(file_abspath, mode)
 
357
            osutils.chmod_if_possible(file_abspath, mode)
363
358
        return st.st_size
364
359
 
365
360
    def append_file(self, relpath, f, mode=None):
458
453
                    otherpath = other._abspath(path)
459
454
                    shutil.copy(mypath, otherpath)
460
455
                    if mode is not None:
461
 
                        os.chmod(otherpath, mode)
 
456
                        osutils.chmod_if_possible(otherpath, mode)
462
457
                except (IOError, OSError),e:
463
458
                    self._translate_error(e, path)
464
459
                count += 1
540
535
            """See Transport.symlink."""
541
536
            abs_link_dirpath = urlutils.dirname(self.abspath(link_name))
542
537
            source_rel = urlutils.file_relpath(
543
 
                urlutils.strip_trailing_slash(abs_link_dirpath),
544
 
                urlutils.strip_trailing_slash(self.abspath(source))
545
 
            )
 
538
                abs_link_dirpath, self.abspath(source))
546
539
 
547
540
            try:
548
541
                os.symlink(source_rel, self._abspath(link_name))
567
560
        self._local_base = urlutils._win32_local_path_from_url(base)
568
561
 
569
562
    def abspath(self, relpath):
570
 
        path = osutils.normpath(osutils.pathjoin(
 
563
        path = osutils._win32_normpath(osutils.pathjoin(
571
564
                    self._local_base, urlutils.unescape(relpath)))
572
565
        return urlutils._win32_local_path_to_url(path)
573
566