/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/osutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-04-24 10:31:28 UTC
  • mfrom: (1684.1.2 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060424103128-a637f56a7c529bad
(mbp) tutorial improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Bazaar-NG -- distributed version control
 
2
#
 
3
# Copyright (C) 2005 by Canonical Ltd
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
12
14
#
13
15
# You should have received a copy of the GNU General Public License
14
16
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
from __future__ import absolute_import
18
 
 
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 
 
19
from shutil import copyfile
 
20
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
 
21
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
 
22
from cStringIO import StringIO
19
23
import errno
20
24
import os
21
25
import re
22
 
import stat
 
26
import sha
 
27
import string
23
28
import sys
24
29
import time
25
 
import codecs
26
 
 
27
 
from .lazy_import import lazy_import
28
 
lazy_import(globals(), """
29
 
from datetime import datetime
30
 
import getpass
31
 
import locale
32
 
import ntpath
33
 
import posixpath
34
 
import select
35
 
# We need to import both shutil and rmtree as we export the later on posix
36
 
# and need the former on windows
37
 
import shutil
38
 
from shutil import rmtree
39
 
import socket
40
 
import subprocess
41
 
# We need to import both tempfile and mkdtemp as we export the later on posix
42
 
# and need the former on windows
 
30
import types
43
31
import tempfile
44
 
from tempfile import mkdtemp
45
 
import unicodedata
46
 
 
47
 
from breezy import (
48
 
    config,
49
 
    trace,
50
 
    win32utils,
51
 
    )
52
 
from breezy.i18n import gettext
53
 
""")
54
 
 
55
 
from .sixish import (
56
 
    PY3,
57
 
    text_type,
58
 
    )
59
 
 
60
 
from hashlib import (
61
 
    md5,
62
 
    sha1 as sha,
63
 
    )
64
 
 
65
 
 
66
 
import breezy
67
 
from . import (
68
 
    _fs_enc,
69
 
    errors,
70
 
    )
71
 
 
72
 
 
73
 
# On win32, O_BINARY is used to indicate the file should
74
 
# be opened in binary mode, rather than text mode.
75
 
# On other platforms, O_BINARY doesn't exist, because
76
 
# they always open in binary mode, so it is okay to
77
 
# OR with 0 on those platforms.
78
 
# O_NOINHERIT and O_TEXT exists only on win32 too.
79
 
O_BINARY = getattr(os, 'O_BINARY', 0)
80
 
O_TEXT = getattr(os, 'O_TEXT', 0)
81
 
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
82
 
 
83
 
 
84
 
class UnsupportedTimezoneFormat(errors.BzrError):
85
 
 
86
 
    _fmt = ('Unsupported timezone format "%(timezone)s", '
87
 
            'options are "utc", "original", "local".')
88
 
 
89
 
    def __init__(self, timezone):
90
 
        self.timezone = timezone
91
 
 
92
 
 
93
 
def get_unicode_argv():
94
 
    if PY3:
95
 
        return sys.argv[1:]
96
 
    try:
97
 
        user_encoding = get_user_encoding()
98
 
        return [a.decode(user_encoding) for a in sys.argv[1:]]
99
 
    except UnicodeDecodeError:
100
 
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
101
 
                                      "application locale.").format(a, user_encoding))
 
32
 
 
33
import bzrlib
 
34
from bzrlib.errors import (BzrError,
 
35
                           BzrBadParameterNotUnicode,
 
36
                           NoSuchFile,
 
37
                           PathNotChild,
 
38
                           IllegalPath,
 
39
                           )
 
40
from bzrlib.trace import mutter
102
41
 
103
42
 
104
43
def make_readonly(filename):
105
44
    """Make a filename read-only."""
106
 
    mod = os.lstat(filename).st_mode
107
 
    if not stat.S_ISLNK(mod):
108
 
        mod = mod & 0o777555
109
 
        chmod_if_possible(filename, mod)
 
45
    mod = os.stat(filename).st_mode
 
46
    mod = mod & 0777555
 
47
    os.chmod(filename, mod)
110
48
 
111
49
 
112
50
def make_writable(filename):
113
 
    mod = os.lstat(filename).st_mode
114
 
    if not stat.S_ISLNK(mod):
115
 
        mod = mod | 0o200
116
 
        chmod_if_possible(filename, mod)
117
 
 
118
 
 
119
 
def chmod_if_possible(filename, mode):
120
 
    # Set file mode if that can be safely done.
121
 
    # Sometimes even on unix the filesystem won't allow it - see
122
 
    # https://bugs.launchpad.net/bzr/+bug/606537
123
 
    try:
124
 
        # It is probably faster to just do the chmod, rather than
125
 
        # doing a stat, and then trying to compare
126
 
        os.chmod(filename, mode)
127
 
    except (IOError, OSError) as e:
128
 
        # Permission/access denied seems to commonly happen on smbfs; there's
129
 
        # probably no point warning about it.
130
 
        # <https://bugs.launchpad.net/bzr/+bug/606537>
131
 
        if getattr(e, 'errno') in (errno.EPERM, errno.EACCES):
132
 
            trace.mutter("ignore error on chmod of %r: %r" % (
133
 
                filename, e))
134
 
            return
135
 
        raise
136
 
 
137
 
 
138
 
def minimum_path_selection(paths):
139
 
    """Return the smallset subset of paths which are outside paths.
140
 
 
141
 
    :param paths: A container (and hence not None) of paths.
142
 
    :return: A set of paths sufficient to include everything in paths via
143
 
        is_inside, drawn from the paths parameter.
144
 
    """
145
 
    if len(paths) < 2:
146
 
        return set(paths)
147
 
 
148
 
    def sort_key(path):
149
 
        if isinstance(path, bytes):
150
 
            return path.split(b'/')
151
 
        else:
152
 
            return path.split('/')
153
 
    sorted_paths = sorted(list(paths), key=sort_key)
154
 
 
155
 
    search_paths = [sorted_paths[0]]
156
 
    for path in sorted_paths[1:]:
157
 
        if not is_inside(search_paths[-1], path):
158
 
            # This path is unique, add it
159
 
            search_paths.append(path)
160
 
 
161
 
    return set(search_paths)
 
51
    mod = os.stat(filename).st_mode
 
52
    mod = mod | 0200
 
53
    os.chmod(filename, mod)
162
54
 
163
55
 
164
56
_QUOTE_RE = None
171
63
    Windows."""
172
64
    # TODO: I'm not really sure this is the best format either.x
173
65
    global _QUOTE_RE
174
 
    if _QUOTE_RE is None:
 
66
    if _QUOTE_RE == None:
175
67
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
176
 
 
 
68
        
177
69
    if _QUOTE_RE.search(f):
178
70
        return '"' + f + '"'
179
71
    else:
180
72
        return f
181
73
 
182
74
 
183
 
_directory_kind = 'directory'
184
 
 
185
 
 
186
 
def get_umask():
187
 
    """Return the current umask"""
188
 
    # Assume that people aren't messing with the umask while running
189
 
    # XXX: This is not thread safe, but there is no way to get the
190
 
    #      umask without setting it
191
 
    umask = os.umask(0)
192
 
    os.umask(umask)
193
 
    return umask
194
 
 
195
 
 
196
 
_kind_marker_map = {
197
 
    "file": "",
198
 
    _directory_kind: "/",
199
 
    "symlink": "@",
200
 
    'tree-reference': '+',
201
 
}
 
75
def file_kind(f):
 
76
    mode = os.lstat(f)[ST_MODE]
 
77
    if S_ISREG(mode):
 
78
        return 'file'
 
79
    elif S_ISDIR(mode):
 
80
        return 'directory'
 
81
    elif S_ISLNK(mode):
 
82
        return 'symlink'
 
83
    elif S_ISCHR(mode):
 
84
        return 'chardev'
 
85
    elif S_ISBLK(mode):
 
86
        return 'block'
 
87
    elif S_ISFIFO(mode):
 
88
        return 'fifo'
 
89
    elif S_ISSOCK(mode):
 
90
        return 'socket'
 
91
    else:
 
92
        return 'unknown'
202
93
 
203
94
 
204
95
def kind_marker(kind):
 
96
    if kind == 'file':
 
97
        return ''
 
98
    elif kind == 'directory':
 
99
        return '/'
 
100
    elif kind == 'symlink':
 
101
        return '@'
 
102
    else:
 
103
        raise BzrError('invalid file kind %r' % kind)
 
104
 
 
105
def lexists(f):
 
106
    if hasattr(os.path, 'lexists'):
 
107
        return os.path.lexists(f)
205
108
    try:
206
 
        return _kind_marker_map[kind]
207
 
    except KeyError:
208
 
        # Slightly faster than using .get(, '') when the common case is that
209
 
        # kind will be found
210
 
        return ''
211
 
 
212
 
 
213
 
lexists = getattr(os.path, 'lexists', None)
214
 
if lexists is None:
215
 
    def lexists(f):
216
 
        try:
217
 
            stat = getattr(os, 'lstat', os.stat)
218
 
            stat(f)
219
 
            return True
220
 
        except OSError as e:
221
 
            if e.errno == errno.ENOENT:
222
 
                return False
223
 
            else:
224
 
                raise errors.BzrError(
225
 
                    gettext("lstat/stat of ({0!r}): {1!r}").format(f, e))
226
 
 
 
109
        if hasattr(os, 'lstat'):
 
110
            os.lstat(f)
 
111
        else:
 
112
            os.stat(f)
 
113
        return True
 
114
    except OSError,e:
 
115
        if e.errno == errno.ENOENT:
 
116
            return False;
 
117
        else:
 
118
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
227
119
 
228
120
def fancy_rename(old, new, rename_func, unlink_func):
229
121
    """A fancy rename, when you don't have atomic rename.
230
 
 
 
122
    
231
123
    :param old: The old path, to rename from
232
124
    :param new: The new path, to rename to
233
125
    :param rename_func: The potentially non-atomic rename function
234
 
    :param unlink_func: A way to delete the target file if the full rename
235
 
        succeeds
 
126
    :param unlink_func: A way to delete the target file if the full rename succeeds
236
127
    """
 
128
 
237
129
    # sftp rename doesn't allow overwriting, so play tricks:
 
130
    import random
238
131
    base = os.path.basename(new)
239
132
    dirname = os.path.dirname(new)
240
 
    # callers use different encodings for the paths so the following MUST
241
 
    # respect that. We rely on python upcasting to unicode if new is unicode
242
 
    # and keeping a str if not.
243
 
    tmp_name = 'tmp.%s.%.9f.%d.%s' % (base, time.time(),
244
 
                                      os.getpid(), rand_chars(10))
 
133
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
245
134
    tmp_name = pathjoin(dirname, tmp_name)
246
135
 
247
136
    # Rename the file out of the way, but keep track if it didn't exist
252
141
    file_existed = False
253
142
    try:
254
143
        rename_func(new, tmp_name)
255
 
    except (errors.NoSuchFile,):
 
144
    except (NoSuchFile,), e:
256
145
        pass
257
 
    except IOError as e:
 
146
    except IOError, e:
258
147
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
259
 
        # function raises an IOError with errno is None when a rename fails.
 
148
        # function raises an IOError with errno == None when a rename fails.
260
149
        # This then gets caught here.
261
150
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
262
151
            raise
263
 
    except Exception as e:
264
 
        if (getattr(e, 'errno', None) is None
265
 
                or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
152
    except Exception, e:
 
153
        if (not hasattr(e, 'errno') 
 
154
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
266
155
            raise
267
156
    else:
268
157
        file_existed = True
273
162
        # not be set.
274
163
        rename_func(old, new)
275
164
        success = True
276
 
    except (IOError, OSError) as e:
277
 
        # source and target may be aliases of each other (e.g. on a
278
 
        # case-insensitive filesystem), so we may have accidentally renamed
279
 
        # source by when we tried to rename target
280
 
        if (file_existed and e.errno in (None, errno.ENOENT)
281
 
                and old.lower() == new.lower()):
282
 
            # source and target are the same file on a case-insensitive
283
 
            # filesystem, so we don't generate an exception
284
 
            pass
285
 
        else:
286
 
            raise
287
165
    finally:
288
166
        if file_existed:
289
167
            # If the file used to exist, rename it back into place
293
171
            else:
294
172
                rename_func(tmp_name, new)
295
173
 
296
 
 
297
 
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
298
 
# choke on a Unicode string containing a relative path if
299
 
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
300
 
# string.
301
 
def _posix_abspath(path):
302
 
    # jam 20060426 rather than encoding to fsencoding
303
 
    # copy posixpath.abspath, but use os.getcwdu instead
304
 
    if not posixpath.isabs(path):
305
 
        path = posixpath.join(getcwd(), path)
306
 
    return _posix_normpath(path)
307
 
 
308
 
 
309
 
def _posix_realpath(path):
310
 
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
311
 
 
312
 
 
313
 
def _posix_normpath(path):
314
 
    path = posixpath.normpath(path)
315
 
    # Bug 861008: posixpath.normpath() returns a path normalized according to
316
 
    # the POSIX standard, which stipulates (for compatibility reasons) that two
317
 
    # leading slashes must not be simplified to one, and only if there are 3 or
318
 
    # more should they be simplified as one. So we treat the leading 2 slashes
319
 
    # as a special case here by simply removing the first slash, as we consider
320
 
    # that breaking POSIX compatibility for this obscure feature is acceptable.
321
 
    # This is not a paranoid precaution, as we notably get paths like this when
322
 
    # the repo is hosted at the root of the filesystem, i.e. in "/".
323
 
    if path.startswith('//'):
324
 
        path = path[1:]
325
 
    return path
326
 
 
327
 
 
328
 
def _posix_path_from_environ(key):
329
 
    """Get unicode path from `key` in environment or None if not present
330
 
 
331
 
    Note that posix systems use arbitrary byte strings for filesystem objects,
332
 
    so a path that raises BadFilenameEncoding here may still be accessible.
333
 
    """
334
 
    val = os.environ.get(key, None)
335
 
    if PY3 or val is None:
336
 
        return val
337
 
    try:
338
 
        return val.decode(_fs_enc)
339
 
    except UnicodeDecodeError:
340
 
        # GZ 2011-12-12:Ideally want to include `key` in the exception message
341
 
        raise errors.BadFilenameEncoding(val, _fs_enc)
342
 
 
343
 
 
344
 
def _posix_get_home_dir():
345
 
    """Get the home directory of the current user as a unicode path"""
346
 
    path = posixpath.expanduser("~")
347
 
    try:
348
 
        return path.decode(_fs_enc)
349
 
    except AttributeError:
350
 
        return path
351
 
    except UnicodeDecodeError:
352
 
        raise errors.BadFilenameEncoding(path, _fs_enc)
353
 
 
354
 
 
355
 
def _posix_getuser_unicode():
356
 
    """Get username from environment or password database as unicode"""
357
 
    name = getpass.getuser()
358
 
    if PY3:
359
 
        return name
360
 
    user_encoding = get_user_encoding()
361
 
    try:
362
 
        return name.decode(user_encoding)
363
 
    except UnicodeDecodeError:
364
 
        raise errors.BzrError("Encoding of username %r is unsupported by %s "
365
 
                              "application locale." % (name, user_encoding))
366
 
 
367
 
 
368
 
def _win32_fixdrive(path):
369
 
    """Force drive letters to be consistent.
370
 
 
371
 
    win32 is inconsistent whether it returns lower or upper case
372
 
    and even if it was consistent the user might type the other
373
 
    so we force it to uppercase
374
 
    running python.exe under cmd.exe return capital C:\\
375
 
    running win32 python inside a cygwin shell returns lowercase c:\\
376
 
    """
377
 
    drive, path = ntpath.splitdrive(path)
378
 
    return drive.upper() + path
379
 
 
380
 
 
381
 
def _win32_abspath(path):
382
 
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
383
 
    return _win32_fixdrive(ntpath.abspath(path).replace('\\', '/'))
384
 
 
385
 
 
386
 
def _win32_realpath(path):
387
 
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
388
 
    return _win32_fixdrive(ntpath.realpath(path).replace('\\', '/'))
389
 
 
390
 
 
391
 
def _win32_pathjoin(*args):
392
 
    return ntpath.join(*args).replace('\\', '/')
393
 
 
394
 
 
395
 
def _win32_normpath(path):
396
 
    return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
397
 
 
398
 
 
399
 
def _win32_getcwd():
400
 
    return _win32_fixdrive(_getcwd().replace('\\', '/'))
401
 
 
402
 
 
403
 
def _win32_mkdtemp(*args, **kwargs):
404
 
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
405
 
 
406
 
 
407
 
def _win32_rename(old, new):
408
 
    """We expect to be able to atomically replace 'new' with old.
409
 
 
410
 
    On win32, if new exists, it must be moved out of the way first,
411
 
    and then deleted.
412
 
    """
413
 
    try:
414
 
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
415
 
    except OSError as e:
416
 
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
417
 
            # If we try to rename a non-existant file onto cwd, we get
418
 
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT
419
 
            # if the old path doesn't exist, sometimes we get EACCES
420
 
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
421
 
            os.lstat(old)
422
 
        raise
423
 
 
424
 
 
425
 
def _mac_getcwd():
426
 
    return unicodedata.normalize('NFC', _getcwd())
427
 
 
428
 
 
429
 
def _rename_wrap_exception(rename_func):
430
 
    """Adds extra information to any exceptions that come from rename().
431
 
 
432
 
    The exception has an updated message and 'old_filename' and 'new_filename'
433
 
    attributes.
434
 
    """
435
 
 
436
 
    def _rename_wrapper(old, new):
437
 
        try:
438
 
            rename_func(old, new)
439
 
        except OSError as e:
440
 
            detailed_error = OSError(e.errno, e.strerror +
441
 
                                     " [occurred when renaming '%s' to '%s']" %
442
 
                                     (old, new))
443
 
            detailed_error.old_filename = old
444
 
            detailed_error.new_filename = new
445
 
            raise detailed_error
446
 
 
447
 
    return _rename_wrapper
448
 
 
449
 
 
450
 
if sys.version_info > (3,):
451
 
    _getcwd = os.getcwd
452
 
else:
453
 
    _getcwd = os.getcwdu
454
 
 
455
 
 
456
 
# Default rename wraps os.rename()
457
 
rename = _rename_wrap_exception(os.rename)
458
 
 
459
 
# Default is to just use the python builtins, but these can be rebound on
460
 
# particular platforms.
461
 
abspath = _posix_abspath
462
 
realpath = _posix_realpath
 
174
# Default is to just use the python builtins
 
175
abspath = os.path.abspath
 
176
realpath = os.path.realpath
463
177
pathjoin = os.path.join
464
 
normpath = _posix_normpath
465
 
path_from_environ = _posix_path_from_environ
466
 
_get_home_dir = _posix_get_home_dir
467
 
getuser_unicode = _posix_getuser_unicode
468
 
getcwd = _getcwd
 
178
normpath = os.path.normpath
 
179
getcwd = os.getcwdu
 
180
mkdtemp = tempfile.mkdtemp
 
181
rename = os.rename
469
182
dirname = os.path.dirname
470
183
basename = os.path.basename
471
 
split = os.path.split
472
 
splitext = os.path.splitext
473
 
# These were already lazily imported into local scope
474
 
# mkdtemp = tempfile.mkdtemp
475
 
# rmtree = shutil.rmtree
476
 
lstat = os.lstat
477
 
fstat = os.fstat
478
 
 
479
 
 
480
 
def wrap_stat(st):
481
 
    return st
482
 
 
483
184
 
484
185
MIN_ABS_PATHLENGTH = 1
485
186
 
 
187
if os.name == "posix":
 
188
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
189
    # choke on a Unicode string containing a relative path if
 
190
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
191
    # string.
 
192
    _fs_enc = sys.getfilesystemencoding()
 
193
    def abspath(path):
 
194
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
 
195
 
 
196
    def realpath(path):
 
197
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
486
198
 
487
199
if sys.platform == 'win32':
488
 
    abspath = _win32_abspath
489
 
    realpath = _win32_realpath
490
 
    pathjoin = _win32_pathjoin
491
 
    normpath = _win32_normpath
492
 
    getcwd = _win32_getcwd
493
 
    mkdtemp = _win32_mkdtemp
494
 
    rename = _rename_wrap_exception(_win32_rename)
495
 
    try:
496
 
        from . import _walkdirs_win32
497
 
    except ImportError:
498
 
        pass
499
 
    else:
500
 
        lstat = _walkdirs_win32.lstat
501
 
        fstat = _walkdirs_win32.fstat
502
 
        wrap_stat = _walkdirs_win32.wrap_stat
 
200
    # We need to use the Unicode-aware os.path.abspath and
 
201
    # os.path.realpath on Windows systems.
 
202
    def abspath(path):
 
203
        return os.path.abspath(path).replace('\\', '/')
 
204
 
 
205
    def realpath(path):
 
206
        return os.path.realpath(path).replace('\\', '/')
 
207
 
 
208
    def pathjoin(*args):
 
209
        return os.path.join(*args).replace('\\', '/')
 
210
 
 
211
    def normpath(path):
 
212
        return os.path.normpath(path).replace('\\', '/')
 
213
 
 
214
    def getcwd():
 
215
        return os.getcwdu().replace('\\', '/')
 
216
 
 
217
    def mkdtemp(*args, **kwargs):
 
218
        return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
 
219
 
 
220
    def rename(old, new):
 
221
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
503
222
 
504
223
    MIN_ABS_PATHLENGTH = 3
505
224
 
506
 
    def _win32_delete_readonly(function, path, excinfo):
507
 
        """Error handler for shutil.rmtree function [for win32]
508
 
        Helps to remove files and dirs marked as read-only.
509
 
        """
510
 
        exception = excinfo[1]
511
 
        if function in (os.remove, os.rmdir) \
512
 
                and isinstance(exception, OSError) \
513
 
                and exception.errno == errno.EACCES:
514
 
            make_writable(path)
515
 
            function(path)
516
 
        else:
517
 
            raise
518
 
 
519
 
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
520
 
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
521
 
        return shutil.rmtree(path, ignore_errors, onerror)
522
 
 
523
 
    get_unicode_argv = getattr(win32utils, 'get_unicode_argv', get_unicode_argv)
524
 
    path_from_environ = win32utils.get_environ_unicode
525
 
    _get_home_dir = win32utils.get_home_location
526
 
    getuser_unicode = win32utils.get_user_name
527
 
 
528
 
elif sys.platform == 'darwin':
529
 
    getcwd = _mac_getcwd
530
 
 
531
 
 
532
 
def get_terminal_encoding(trace=False):
533
 
    """Find the best encoding for printing to the screen.
534
 
 
535
 
    This attempts to check both sys.stdout and sys.stdin to see
536
 
    what encoding they are in, and if that fails it falls back to
537
 
    osutils.get_user_encoding().
538
 
    The problem is that on Windows, locale.getpreferredencoding()
539
 
    is not the same encoding as that used by the console:
540
 
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
541
 
 
542
 
    On my standard US Windows XP, the preferred encoding is
543
 
    cp1252, but the console is cp437
544
 
 
545
 
    :param trace: If True trace the selected encoding via mutter().
546
 
    """
547
 
    from .trace import mutter
548
 
    output_encoding = getattr(sys.stdout, 'encoding', None)
549
 
    if not output_encoding:
550
 
        input_encoding = getattr(sys.stdin, 'encoding', None)
551
 
        if not input_encoding:
552
 
            output_encoding = get_user_encoding()
553
 
            if trace:
554
 
                mutter('encoding stdout as osutils.get_user_encoding() %r',
555
 
                       output_encoding)
556
 
        else:
557
 
            output_encoding = input_encoding
558
 
            if trace:
559
 
                mutter('encoding stdout as sys.stdin encoding %r',
560
 
                       output_encoding)
561
 
    else:
562
 
        if trace:
563
 
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
564
 
    if output_encoding == 'cp0':
565
 
        # invalid encoding (cp0 means 'no codepage' on Windows)
566
 
        output_encoding = get_user_encoding()
567
 
        if trace:
568
 
            mutter('cp0 is invalid encoding.'
569
 
                   ' encoding stdout as osutils.get_user_encoding() %r',
570
 
                   output_encoding)
571
 
    # check encoding
572
 
    try:
573
 
        codecs.lookup(output_encoding)
574
 
    except LookupError:
575
 
        sys.stderr.write('brz: warning:'
576
 
                         ' unknown terminal encoding %s.\n'
577
 
                         '  Using encoding %s instead.\n'
578
 
                         % (output_encoding, get_user_encoding())
579
 
                         )
580
 
        output_encoding = get_user_encoding()
581
 
 
582
 
    return output_encoding
583
 
 
584
 
 
585
225
def normalizepath(f):
586
 
    if getattr(os.path, 'realpath', None) is not None:
 
226
    if hasattr(os.path, 'realpath'):
587
227
        F = realpath
588
228
    else:
589
229
        F = abspath
590
 
    [p, e] = os.path.split(f)
 
230
    [p,e] = os.path.split(f)
591
231
    if e == "" or e == "." or e == "..":
592
232
        return F(f)
593
233
    else:
594
234
        return pathjoin(F(p), e)
595
235
 
596
236
 
 
237
def backup_file(fn):
 
238
    """Copy a file to a backup.
 
239
 
 
240
    Backups are named in GNU-style, with a ~ suffix.
 
241
 
 
242
    If the file is already a backup, it's not copied.
 
243
    """
 
244
    if fn[-1] == '~':
 
245
        return
 
246
    bfn = fn + '~'
 
247
 
 
248
    if has_symlinks() and os.path.islink(fn):
 
249
        target = os.readlink(fn)
 
250
        os.symlink(target, bfn)
 
251
        return
 
252
    inf = file(fn, 'rb')
 
253
    try:
 
254
        content = inf.read()
 
255
    finally:
 
256
        inf.close()
 
257
    
 
258
    outf = file(bfn, 'wb')
 
259
    try:
 
260
        outf.write(content)
 
261
    finally:
 
262
        outf.close()
 
263
 
 
264
 
597
265
def isdir(f):
598
266
    """True if f is an accessible directory."""
599
267
    try:
600
 
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
 
268
        return S_ISDIR(os.lstat(f)[ST_MODE])
601
269
    except OSError:
602
270
        return False
603
271
 
605
273
def isfile(f):
606
274
    """True if f is a regular file."""
607
275
    try:
608
 
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
 
276
        return S_ISREG(os.lstat(f)[ST_MODE])
609
277
    except OSError:
610
278
        return False
611
279
 
612
 
 
613
280
def islink(f):
614
281
    """True if f is a symlink."""
615
282
    try:
616
 
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
 
283
        return S_ISLNK(os.lstat(f)[ST_MODE])
617
284
    except OSError:
618
285
        return False
619
286
 
620
 
 
621
287
def is_inside(dir, fname):
622
288
    """True if fname is inside dir.
623
 
 
 
289
    
624
290
    The parameters should typically be passed to osutils.normpath first, so
625
291
    that . and .. and repeated slashes are eliminated, and the separators
626
292
    are canonical for the platform.
627
 
 
628
 
    The empty string as a dir name is taken as top-of-tree and matches
 
293
    
 
294
    The empty string as a dir name is taken as top-of-tree and matches 
629
295
    everything.
 
296
    
 
297
    >>> is_inside('src', pathjoin('src', 'foo.c'))
 
298
    True
 
299
    >>> is_inside('src', 'srccontrol')
 
300
    False
 
301
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
 
302
    True
 
303
    >>> is_inside('foo.c', 'foo.c')
 
304
    True
 
305
    >>> is_inside('foo.c', '')
 
306
    False
 
307
    >>> is_inside('', 'foo.c')
 
308
    True
630
309
    """
631
 
    # XXX: Most callers of this can actually do something smarter by
 
310
    # XXX: Most callers of this can actually do something smarter by 
632
311
    # looking at the inventory
633
312
    if dir == fname:
634
313
        return True
635
 
 
636
 
    if dir in ('', b''):
 
314
    
 
315
    if dir == '':
637
316
        return True
638
317
 
639
 
    if isinstance(dir, bytes):
640
 
        if not dir.endswith(b'/'):
641
 
            dir += b'/'
642
 
    else:
643
 
        if not dir.endswith('/'):
644
 
            dir += '/'
 
318
    if dir[-1] != '/':
 
319
        dir += '/'
645
320
 
646
321
    return fname.startswith(dir)
647
322
 
651
326
    for dirname in dir_list:
652
327
        if is_inside(dirname, fname):
653
328
            return True
654
 
    return False
655
 
 
656
 
 
657
 
def is_inside_or_parent_of_any(dir_list, fname):
658
 
    """True if fname is a child or a parent of any of the given files."""
659
 
    for dirname in dir_list:
660
 
        if is_inside(dirname, fname) or is_inside(fname, dirname):
661
 
            return True
662
 
    return False
663
 
 
664
 
 
665
 
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768,
666
 
             report_activity=None, direction='read'):
667
 
    """Copy contents of one file to another.
668
 
 
669
 
    The read_length can either be -1 to read to end-of-file (EOF) or
670
 
    it can specify the maximum number of bytes to read.
671
 
 
672
 
    The buff_size represents the maximum size for each read operation
673
 
    performed on from_file.
674
 
 
675
 
    :param report_activity: Call this as bytes are read, see
676
 
        Transport._report_activity
677
 
    :param direction: Will be passed to report_activity
678
 
 
679
 
    :return: The number of bytes copied.
680
 
    """
681
 
    length = 0
682
 
    if read_length >= 0:
683
 
        # read specified number of bytes
684
 
 
685
 
        while read_length > 0:
686
 
            num_bytes_to_read = min(read_length, buff_size)
687
 
 
688
 
            block = from_file.read(num_bytes_to_read)
689
 
            if not block:
690
 
                # EOF reached
691
 
                break
692
 
            if report_activity is not None:
693
 
                report_activity(len(block), direction)
694
 
            to_file.write(block)
695
 
 
696
 
            actual_bytes_read = len(block)
697
 
            read_length -= actual_bytes_read
698
 
            length += actual_bytes_read
699
329
    else:
700
 
        # read to EOF
701
 
        while True:
702
 
            block = from_file.read(buff_size)
703
 
            if not block:
704
 
                # EOF reached
705
 
                break
706
 
            if report_activity is not None:
707
 
                report_activity(len(block), direction)
708
 
            to_file.write(block)
709
 
            length += len(block)
710
 
    return length
711
 
 
712
 
 
713
 
def pump_string_file(bytes, file_handle, segment_size=None):
714
 
    """Write bytes to file_handle in many smaller writes.
715
 
 
716
 
    :param bytes: The string to write.
717
 
    :param file_handle: The file to write to.
718
 
    """
719
 
    # Write data in chunks rather than all at once, because very large
720
 
    # writes fail on some platforms (e.g. Windows with SMB  mounted
721
 
    # drives).
722
 
    if not segment_size:
723
 
        segment_size = 5242880  # 5MB
724
 
    offsets = range(0, len(bytes), segment_size)
725
 
    view = memoryview(bytes)
726
 
    write = file_handle.write
727
 
    for offset in offsets:
728
 
        write(view[offset:offset + segment_size])
 
330
        return False
 
331
 
 
332
 
 
333
def pumpfile(fromfile, tofile):
 
334
    """Copy contents of one file to another."""
 
335
    BUFSIZE = 32768
 
336
    while True:
 
337
        b = fromfile.read(BUFSIZE)
 
338
        if not b:
 
339
            break
 
340
        tofile.write(b)
729
341
 
730
342
 
731
343
def file_iterator(input_file, readsize=32768):
736
348
        yield b
737
349
 
738
350
 
739
 
# GZ 2017-09-16: Makes sense in general for hexdigest() result to be text, but
740
 
# used as bytes through most interfaces so encode with this wrapper.
741
 
if PY3:
742
 
    def _hexdigest(hashobj):
743
 
        return hashobj.hexdigest().encode()
744
 
else:
745
 
    def _hexdigest(hashobj):
746
 
        return hashobj.hexdigest()
747
 
 
748
 
 
749
351
def sha_file(f):
750
 
    """Calculate the hexdigest of an open file.
751
 
 
752
 
    The file cursor should be already at the start.
753
 
    """
754
 
    s = sha()
755
 
    BUFSIZE = 128 << 10
756
 
    while True:
757
 
        b = f.read(BUFSIZE)
758
 
        if not b:
759
 
            break
760
 
        s.update(b)
761
 
    return _hexdigest(s)
762
 
 
763
 
 
764
 
def size_sha_file(f):
765
 
    """Calculate the size and hexdigest of an open file.
766
 
 
767
 
    The file cursor should be already at the start and
768
 
    the caller is responsible for closing the file afterwards.
769
 
    """
770
 
    size = 0
771
 
    s = sha()
772
 
    BUFSIZE = 128 << 10
773
 
    while True:
774
 
        b = f.read(BUFSIZE)
775
 
        if not b:
776
 
            break
777
 
        size += len(b)
778
 
        s.update(b)
779
 
    return size, _hexdigest(s)
780
 
 
781
 
 
782
 
def sha_file_by_name(fname):
783
 
    """Calculate the SHA1 of a file by reading the full text"""
784
 
    s = sha()
785
 
    f = os.open(fname, os.O_RDONLY | O_BINARY | O_NOINHERIT)
786
 
    try:
787
 
        while True:
788
 
            b = os.read(f, 1 << 16)
789
 
            if not b:
790
 
                return _hexdigest(s)
791
 
            s.update(b)
792
 
    finally:
793
 
        os.close(f)
794
 
 
795
 
 
796
 
def sha_strings(strings, _factory=sha):
 
352
    if hasattr(f, 'tell'):
 
353
        assert f.tell() == 0
 
354
    s = sha.new()
 
355
    BUFSIZE = 128<<10
 
356
    while True:
 
357
        b = f.read(BUFSIZE)
 
358
        if not b:
 
359
            break
 
360
        s.update(b)
 
361
    return s.hexdigest()
 
362
 
 
363
 
 
364
 
 
365
def sha_strings(strings):
797
366
    """Return the sha-1 of concatenation of strings"""
798
 
    s = _factory()
799
 
    for string in strings:
800
 
        s.update(string)
801
 
    return _hexdigest(s)
802
 
 
803
 
 
804
 
def sha_string(f, _factory=sha):
805
 
    # GZ 2017-09-16: Dodgy if factory is ever not sha, probably shouldn't be.
806
 
    return _hexdigest(_factory(f))
 
367
    s = sha.new()
 
368
    map(s.update, strings)
 
369
    return s.hexdigest()
 
370
 
 
371
 
 
372
def sha_string(f):
 
373
    s = sha.new()
 
374
    s.update(f)
 
375
    return s.hexdigest()
807
376
 
808
377
 
809
378
def fingerprint_file(f):
 
379
    s = sha.new()
810
380
    b = f.read()
811
 
    return {'size': len(b),
812
 
            'sha1': _hexdigest(sha(b))}
 
381
    s.update(b)
 
382
    size = len(b)
 
383
    return {'size': size,
 
384
            'sha1': s.hexdigest()}
813
385
 
814
386
 
815
387
def compare_files(a, b):
820
392
        bi = b.read(BUFSIZE)
821
393
        if ai != bi:
822
394
            return False
823
 
        if not ai:
 
395
        if ai == '':
824
396
            return True
825
397
 
826
398
 
827
399
def local_time_offset(t=None):
828
400
    """Return offset of local zone from GMT, either at present or at time t."""
829
 
    if t is None:
 
401
    # python2.3 localtime() can't take None
 
402
    if t == None:
830
403
        t = time.time()
831
 
    offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
832
 
    return offset.days * 86400 + offset.seconds
833
 
 
834
 
 
835
 
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
836
 
_default_format_by_weekday_num = [wd + " %Y-%m-%d %H:%M:%S" for wd in weekdays]
837
 
 
838
 
 
839
 
def format_date(t, offset=0, timezone='original', date_fmt=None,
 
404
        
 
405
    if time.localtime(t).tm_isdst and time.daylight:
 
406
        return -time.altzone
 
407
    else:
 
408
        return -time.timezone
 
409
 
 
410
    
 
411
def format_date(t, offset=0, timezone='original', date_fmt=None, 
840
412
                show_offset=True):
841
 
    """Return a formatted date string.
842
 
 
843
 
    :param t: Seconds since the epoch.
844
 
    :param offset: Timezone offset in seconds east of utc.
845
 
    :param timezone: How to display the time: 'utc', 'original' for the
846
 
         timezone specified by offset, or 'local' for the process's current
847
 
         timezone.
848
 
    :param date_fmt: strftime format.
849
 
    :param show_offset: Whether to append the timezone.
850
 
    """
851
 
    (date_fmt, tt, offset_str) = \
852
 
        _format_date(t, offset, timezone, date_fmt, show_offset)
853
 
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
854
 
    date_str = time.strftime(date_fmt, tt)
855
 
    return date_str + offset_str
856
 
 
857
 
 
858
 
# Cache of formatted offset strings
859
 
_offset_cache = {}
860
 
 
861
 
 
862
 
def format_date_with_offset_in_original_timezone(t, offset=0,
863
 
                                                 _cache=_offset_cache):
864
 
    """Return a formatted date string in the original timezone.
865
 
 
866
 
    This routine may be faster then format_date.
867
 
 
868
 
    :param t: Seconds since the epoch.
869
 
    :param offset: Timezone offset in seconds east of utc.
870
 
    """
871
 
    if offset is None:
872
 
        offset = 0
873
 
    tt = time.gmtime(t + offset)
874
 
    date_fmt = _default_format_by_weekday_num[tt[6]]
875
 
    date_str = time.strftime(date_fmt, tt)
876
 
    offset_str = _cache.get(offset, None)
877
 
    if offset_str is None:
878
 
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
879
 
        _cache[offset] = offset_str
880
 
    return date_str + offset_str
881
 
 
882
 
 
883
 
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
884
 
                      show_offset=True):
885
 
    """Return an unicode date string formatted according to the current locale.
886
 
 
887
 
    :param t: Seconds since the epoch.
888
 
    :param offset: Timezone offset in seconds east of utc.
889
 
    :param timezone: How to display the time: 'utc', 'original' for the
890
 
         timezone specified by offset, or 'local' for the process's current
891
 
         timezone.
892
 
    :param date_fmt: strftime format.
893
 
    :param show_offset: Whether to append the timezone.
894
 
    """
895
 
    (date_fmt, tt, offset_str) = \
896
 
        _format_date(t, offset, timezone, date_fmt, show_offset)
897
 
    date_str = time.strftime(date_fmt, tt)
898
 
    if not isinstance(date_str, text_type):
899
 
        date_str = date_str.decode(get_user_encoding(), 'replace')
900
 
    return date_str + offset_str
901
 
 
902
 
 
903
 
def _format_date(t, offset, timezone, date_fmt, show_offset):
 
413
    ## TODO: Perhaps a global option to use either universal or local time?
 
414
    ## Or perhaps just let people set $TZ?
 
415
    assert isinstance(t, float)
 
416
    
904
417
    if timezone == 'utc':
905
418
        tt = time.gmtime(t)
906
419
        offset = 0
907
420
    elif timezone == 'original':
908
 
        if offset is None:
 
421
        if offset == None:
909
422
            offset = 0
910
423
        tt = time.gmtime(t + offset)
911
424
    elif timezone == 'local':
912
425
        tt = time.localtime(t)
913
426
        offset = local_time_offset(t)
914
427
    else:
915
 
        raise UnsupportedTimezoneFormat(timezone)
 
428
        raise BzrError("unsupported timezone format %r" % timezone,
 
429
                       ['options are "utc", "original", "local"'])
916
430
    if date_fmt is None:
917
431
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
918
432
    if show_offset:
919
433
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
920
434
    else:
921
435
        offset_str = ''
922
 
    return (date_fmt, tt, offset_str)
 
436
    return (time.strftime(date_fmt, tt) +  offset_str)
923
437
 
924
438
 
925
439
def compact_date(when):
926
440
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
927
 
 
928
 
 
929
 
def format_delta(delta):
930
 
    """Get a nice looking string for a time delta.
931
 
 
932
 
    :param delta: The time difference in seconds, can be positive or negative.
933
 
        positive indicates time in the past, negative indicates time in the
934
 
        future. (usually time.time() - stored_time)
935
 
    :return: String formatted to show approximate resolution
936
 
    """
937
 
    delta = int(delta)
938
 
    if delta >= 0:
939
 
        direction = 'ago'
940
 
    else:
941
 
        direction = 'in the future'
942
 
        delta = -delta
943
 
 
944
 
    seconds = delta
945
 
    if seconds < 90:  # print seconds up to 90 seconds
946
 
        if seconds == 1:
947
 
            return '%d second %s' % (seconds, direction,)
948
 
        else:
949
 
            return '%d seconds %s' % (seconds, direction)
950
 
 
951
 
    minutes = int(seconds / 60)
952
 
    seconds -= 60 * minutes
953
 
    if seconds == 1:
954
 
        plural_seconds = ''
955
 
    else:
956
 
        plural_seconds = 's'
957
 
    if minutes < 90:  # print minutes, seconds up to 90 minutes
958
 
        if minutes == 1:
959
 
            return '%d minute, %d second%s %s' % (
960
 
                minutes, seconds, plural_seconds, direction)
961
 
        else:
962
 
            return '%d minutes, %d second%s %s' % (
963
 
                minutes, seconds, plural_seconds, direction)
964
 
 
965
 
    hours = int(minutes / 60)
966
 
    minutes -= 60 * hours
967
 
    if minutes == 1:
968
 
        plural_minutes = ''
969
 
    else:
970
 
        plural_minutes = 's'
971
 
 
972
 
    if hours == 1:
973
 
        return '%d hour, %d minute%s %s' % (hours, minutes,
974
 
                                            plural_minutes, direction)
975
 
    return '%d hours, %d minute%s %s' % (hours, minutes,
976
 
                                         plural_minutes, direction)
 
441
    
977
442
 
978
443
 
979
444
def filesize(f):
980
445
    """Return size of given open file."""
981
 
    return os.fstat(f.fileno())[stat.ST_SIZE]
982
 
 
983
 
 
984
 
# Alias os.urandom to support platforms (which?) without /dev/urandom and
985
 
# override if it doesn't work. Avoid checking on windows where there is
986
 
# significant initialisation cost that can be avoided for some bzr calls.
987
 
 
988
 
rand_bytes = os.urandom
989
 
 
990
 
if rand_bytes.__module__ != "nt":
991
 
    try:
992
 
        rand_bytes(1)
993
 
    except NotImplementedError:
 
446
    return os.fstat(f.fileno())[ST_SIZE]
 
447
 
 
448
 
 
449
# Define rand_bytes based on platform.
 
450
try:
 
451
    # Python 2.4 and later have os.urandom,
 
452
    # but it doesn't work on some arches
 
453
    os.urandom(1)
 
454
    rand_bytes = os.urandom
 
455
except (NotImplementedError, AttributeError):
 
456
    # If python doesn't have os.urandom, or it doesn't work,
 
457
    # then try to first pull random data from /dev/urandom
 
458
    if os.path.exists("/dev/urandom"):
 
459
        rand_bytes = file('/dev/urandom', 'rb').read
 
460
    # Otherwise, use this hack as a last resort
 
461
    else:
994
462
        # not well seeded, but better than nothing
995
463
        def rand_bytes(n):
996
464
            import random
1002
470
 
1003
471
 
1004
472
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
1005
 
 
1006
 
 
1007
473
def rand_chars(num):
1008
474
    """Return a random string of num alphanumeric characters
1009
 
 
1010
 
    The result only contains lowercase chars because it may be used on
 
475
    
 
476
    The result only contains lowercase chars because it may be used on 
1011
477
    case-insensitive filesystems.
1012
478
    """
1013
479
    s = ''
1014
480
    for raw_byte in rand_bytes(num):
1015
 
        if not PY3:
1016
 
            s += ALNUM[ord(raw_byte) % 36]
1017
 
        else:
1018
 
            s += ALNUM[raw_byte % 36]
 
481
        s += ALNUM[ord(raw_byte) % 36]
1019
482
    return s
1020
483
 
1021
484
 
1022
 
# TODO: We could later have path objects that remember their list
1023
 
# decomposition (might be too tricksy though.)
 
485
## TODO: We could later have path objects that remember their list
 
486
## decomposition (might be too tricksy though.)
1024
487
 
1025
488
def splitpath(p):
1026
 
    """Turn string into list of parts."""
1027
 
    use_bytes = isinstance(p, bytes)
1028
 
    if os.path.sep == '\\':
1029
 
        # split on either delimiter because people might use either on
1030
 
        # Windows
1031
 
        if use_bytes:
1032
 
            ps = re.split(b'[\\\\/]', p)
1033
 
        else:
1034
 
            ps = re.split(r'[\\/]', p)
1035
 
    else:
1036
 
        if use_bytes:
1037
 
            ps = p.split(b'/')
1038
 
        else:
1039
 
            ps = p.split('/')
1040
 
 
1041
 
    if use_bytes:
1042
 
        parent_dir = b'..'
1043
 
        current_empty_dir = (b'.', b'')
1044
 
    else:
1045
 
        parent_dir = '..'
1046
 
        current_empty_dir = ('.', '')
 
489
    """Turn string into list of parts.
 
490
 
 
491
    >>> splitpath('a')
 
492
    ['a']
 
493
    >>> splitpath('a/b')
 
494
    ['a', 'b']
 
495
    >>> splitpath('a/./b')
 
496
    ['a', 'b']
 
497
    >>> splitpath('a/.b')
 
498
    ['a', '.b']
 
499
    >>> splitpath('a/../b')
 
500
    Traceback (most recent call last):
 
501
    ...
 
502
    BzrError: sorry, '..' not allowed in path
 
503
    """
 
504
    assert isinstance(p, types.StringTypes)
 
505
 
 
506
    # split on either delimiter because people might use either on
 
507
    # Windows
 
508
    ps = re.split(r'[\\/]', p)
1047
509
 
1048
510
    rps = []
1049
511
    for f in ps:
1050
 
        if f == parent_dir:
1051
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
1052
 
        elif f in current_empty_dir:
 
512
        if f == '..':
 
513
            raise BzrError("sorry, %r not allowed in path" % f)
 
514
        elif (f == '.') or (f == ''):
1053
515
            pass
1054
516
        else:
1055
517
            rps.append(f)
1056
518
    return rps
1057
519
 
1058
 
 
1059
520
def joinpath(p):
 
521
    assert isinstance(p, list)
1060
522
    for f in p:
1061
 
        if (f == '..') or (f is None) or (f == ''):
1062
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
523
        if (f == '..') or (f == None) or (f == ''):
 
524
            raise BzrError("sorry, %r not allowed in path" % f)
1063
525
    return pathjoin(*p)
1064
526
 
1065
527
 
1066
 
def parent_directories(filename):
1067
 
    """Return the list of parent directories, deepest first.
1068
 
 
1069
 
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
1070
 
    """
1071
 
    parents = []
1072
 
    parts = splitpath(dirname(filename))
1073
 
    while parts:
1074
 
        parents.append(joinpath(parts))
1075
 
        parts.pop()
1076
 
    return parents
1077
 
 
1078
 
 
1079
 
_extension_load_failures = []
1080
 
 
1081
 
 
1082
 
def failed_to_load_extension(exception):
1083
 
    """Handle failing to load a binary extension.
1084
 
 
1085
 
    This should be called from the ImportError block guarding the attempt to
1086
 
    import the native extension.  If this function returns, the pure-Python
1087
 
    implementation should be loaded instead::
1088
 
 
1089
 
    >>> try:
1090
 
    >>>     import breezy._fictional_extension_pyx
1091
 
    >>> except ImportError, e:
1092
 
    >>>     breezy.osutils.failed_to_load_extension(e)
1093
 
    >>>     import breezy._fictional_extension_py
1094
 
    """
1095
 
    # NB: This docstring is just an example, not a doctest, because doctest
1096
 
    # currently can't cope with the use of lazy imports in this namespace --
1097
 
    # mbp 20090729
1098
 
 
1099
 
    # This currently doesn't report the failure at the time it occurs, because
1100
 
    # they tend to happen very early in startup when we can't check config
1101
 
    # files etc, and also we want to report all failures but not spam the user
1102
 
    # with 10 warnings.
1103
 
    exception_str = str(exception)
1104
 
    if exception_str not in _extension_load_failures:
1105
 
        trace.mutter("failed to load compiled extension: %s" % exception_str)
1106
 
        _extension_load_failures.append(exception_str)
1107
 
 
1108
 
 
1109
 
def report_extension_load_failures():
1110
 
    if not _extension_load_failures:
1111
 
        return
1112
 
    if config.GlobalConfig().suppress_warning('missing_extensions'):
1113
 
        return
1114
 
    # the warnings framework should by default show this only once
1115
 
    from .trace import warning
1116
 
    warning(
1117
 
        "brz: warning: some compiled extensions could not be loaded; "
1118
 
        "see ``brz help missing-extensions``")
1119
 
    # we no longer show the specific missing extensions here, because it makes
1120
 
    # the message too long and scary - see
1121
 
    # https://bugs.launchpad.net/bzr/+bug/430529
1122
 
 
1123
 
 
1124
 
try:
1125
 
    from ._chunks_to_lines_pyx import chunks_to_lines
1126
 
except ImportError as e:
1127
 
    failed_to_load_extension(e)
1128
 
    from ._chunks_to_lines_py import chunks_to_lines
1129
 
 
 
528
def appendpath(p1, p2):
 
529
    if p1 == '':
 
530
        return p2
 
531
    else:
 
532
        return pathjoin(p1, p2)
 
533
    
1130
534
 
1131
535
def split_lines(s):
1132
536
    """Split s into lines, but without removing the newline characters."""
1133
 
    # Trivially convert a fulltext into a 'chunked' representation, and let
1134
 
    # chunks_to_lines do the heavy lifting.
1135
 
    if isinstance(s, bytes):
1136
 
        # chunks_to_lines only supports 8-bit strings
1137
 
        return chunks_to_lines([s])
1138
 
    else:
1139
 
        return _split_lines(s)
1140
 
 
1141
 
 
1142
 
def _split_lines(s):
1143
 
    """Split s into lines, but without removing the newline characters.
1144
 
 
1145
 
    This supports Unicode or plain string objects.
1146
 
    """
1147
 
    nl = b'\n' if isinstance(s, bytes) else u'\n'
1148
 
    lines = s.split(nl)
1149
 
    result = [line + nl for line in lines[:-1]]
 
537
    lines = s.split('\n')
 
538
    result = [line + '\n' for line in lines[:-1]]
1150
539
    if lines[-1]:
1151
540
        result.append(lines[-1])
1152
541
    return result
1159
548
def link_or_copy(src, dest):
1160
549
    """Hardlink a file, or copy it if it can't be hardlinked."""
1161
550
    if not hardlinks_good():
1162
 
        shutil.copyfile(src, dest)
 
551
        copyfile(src, dest)
1163
552
        return
1164
553
    try:
1165
554
        os.link(src, dest)
1166
 
    except (OSError, IOError) as e:
 
555
    except (OSError, IOError), e:
1167
556
        if e.errno != errno.EXDEV:
1168
557
            raise
1169
 
        shutil.copyfile(src, dest)
1170
 
 
1171
 
 
1172
 
def delete_any(path):
1173
 
    """Delete a file, symlink or directory.
1174
 
 
1175
 
    Will delete even if readonly.
1176
 
    """
 
558
        copyfile(src, dest)
 
559
 
 
560
def delete_any(full_path):
 
561
    """Delete a file or directory."""
1177
562
    try:
1178
 
        _delete_file_or_dir(path)
1179
 
    except (OSError, IOError) as e:
1180
 
        if e.errno in (errno.EPERM, errno.EACCES):
1181
 
            # make writable and try again
1182
 
            try:
1183
 
                make_writable(path)
1184
 
            except (OSError, IOError):
1185
 
                pass
1186
 
            _delete_file_or_dir(path)
1187
 
        else:
 
563
        os.unlink(full_path)
 
564
    except OSError, e:
 
565
    # We may be renaming a dangling inventory id
 
566
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
1188
567
            raise
1189
 
 
1190
 
 
1191
 
def _delete_file_or_dir(path):
1192
 
    # Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
1193
 
    # Forgiveness than Permission (EAFP) because:
1194
 
    # - root can damage a solaris file system by using unlink,
1195
 
    # - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
1196
 
    #   EACCES, OSX: EPERM) when invoked on a directory.
1197
 
    if isdir(path):  # Takes care of symlinks
1198
 
        os.rmdir(path)
1199
 
    else:
1200
 
        os.unlink(path)
 
568
        os.rmdir(full_path)
1201
569
 
1202
570
 
1203
571
def has_symlinks():
1204
 
    if getattr(os, 'symlink', None) is not None:
1205
 
        return True
1206
 
    else:
1207
 
        return False
1208
 
 
1209
 
 
1210
 
def has_hardlinks():
1211
 
    if getattr(os, 'link', None) is not None:
1212
 
        return True
1213
 
    else:
1214
 
        return False
1215
 
 
1216
 
 
1217
 
def host_os_dereferences_symlinks():
1218
 
    return (has_symlinks()
1219
 
            and sys.platform not in ('cygwin', 'win32'))
1220
 
 
1221
 
 
1222
 
def readlink(abspath):
1223
 
    """Return a string representing the path to which the symbolic link points.
1224
 
 
1225
 
    :param abspath: The link absolute unicode path.
1226
 
 
1227
 
    This his guaranteed to return the symbolic link in unicode in all python
1228
 
    versions.
1229
 
    """
1230
 
    link = abspath.encode(_fs_enc)
1231
 
    target = os.readlink(link)
1232
 
    target = target.decode(_fs_enc)
1233
 
    return target
1234
 
 
 
572
    if hasattr(os, 'symlink'):
 
573
        return True
 
574
    else:
 
575
        return False
 
576
        
1235
577
 
1236
578
def contains_whitespace(s):
1237
579
    """True if there are any whitespace characters in s."""
1238
 
    # string.whitespace can include '\xa0' in certain locales, because it is
1239
 
    # considered "non-breaking-space" as part of ISO-8859-1. But it
1240
 
    # 1) Isn't a breaking whitespace
1241
 
    # 2) Isn't one of ' \t\r\n' which are characters we sometimes use as
1242
 
    #    separators
1243
 
    # 3) '\xa0' isn't unicode safe since it is >128.
1244
 
 
1245
 
    if isinstance(s, str):
1246
 
        ws = ' \t\n\r\v\f'
1247
 
    else:
1248
 
        ws = (b' ', b'\t', b'\n', b'\r', b'\v', b'\f')
1249
 
    for ch in ws:
 
580
    for ch in string.whitespace:
1250
581
        if ch in s:
1251
582
            return True
1252
583
    else:
1263
594
 
1264
595
 
1265
596
def relpath(base, path):
1266
 
    """Return path relative to base, or raise PathNotChild exception.
 
597
    """Return path relative to base, or raise exception.
1267
598
 
1268
599
    The path may be either an absolute path or a path relative to the
1269
600
    current working directory.
1271
602
    os.path.commonprefix (python2.4) has a bad bug that it works just
1272
603
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
1273
604
    avoids that problem.
1274
 
 
1275
 
    NOTE: `base` should not have a trailing slash otherwise you'll get
1276
 
    PathNotChild exceptions regardless of `path`.
1277
605
    """
1278
606
 
1279
 
    if len(base) < MIN_ABS_PATHLENGTH:
1280
 
        # must have space for e.g. a drive letter
1281
 
        raise ValueError(gettext('%r is too short to calculate a relative path')
1282
 
                         % (base,))
1283
 
 
 
607
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
 
608
        ' exceed the platform minimum length (which is %d)' % 
 
609
        MIN_ABS_PATHLENGTH)
1284
610
    rp = abspath(path)
1285
611
 
1286
612
    s = []
1287
613
    head = rp
1288
 
    while True:
1289
 
        if len(head) <= len(base) and head != base:
1290
 
            raise errors.PathNotChild(rp, base)
 
614
    while len(head) >= len(base):
1291
615
        if head == base:
1292
616
            break
1293
 
        head, tail = split(head)
 
617
        head, tail = os.path.split(head)
1294
618
        if tail:
1295
 
            s.append(tail)
 
619
            s.insert(0, tail)
 
620
    else:
 
621
        # XXX This should raise a NotChildPath exception, as its not tied
 
622
        # to branch anymore.
 
623
        raise PathNotChild(rp, base)
1296
624
 
1297
625
    if s:
1298
 
        return pathjoin(*reversed(s))
 
626
        return pathjoin(*s)
1299
627
    else:
1300
628
        return ''
1301
629
 
1302
630
 
1303
 
def _cicp_canonical_relpath(base, path):
1304
 
    """Return the canonical path relative to base.
1305
 
 
1306
 
    Like relpath, but on case-insensitive-case-preserving file-systems, this
1307
 
    will return the relpath as stored on the file-system rather than in the
1308
 
    case specified in the input string, for all existing portions of the path.
1309
 
 
1310
 
    This will cause O(N) behaviour if called for every path in a tree; if you
1311
 
    have a number of paths to convert, you should use canonical_relpaths().
1312
 
    """
1313
 
    # TODO: it should be possible to optimize this for Windows by using the
1314
 
    # win32 API FindFiles function to look for the specified name - but using
1315
 
    # os.listdir() still gives us the correct, platform agnostic semantics in
1316
 
    # the short term.
1317
 
 
1318
 
    rel = relpath(base, path)
1319
 
    # '.' will have been turned into ''
1320
 
    if not rel:
1321
 
        return rel
1322
 
 
1323
 
    abs_base = abspath(base)
1324
 
    current = abs_base
1325
 
    _listdir = os.listdir
1326
 
 
1327
 
    # use an explicit iterator so we can easily consume the rest on early exit.
1328
 
    bit_iter = iter(rel.split('/'))
1329
 
    for bit in bit_iter:
1330
 
        lbit = bit.lower()
1331
 
        try:
1332
 
            next_entries = _listdir(current)
1333
 
        except OSError:  # enoent, eperm, etc
1334
 
            # We can't find this in the filesystem, so just append the
1335
 
            # remaining bits.
1336
 
            current = pathjoin(current, bit, *list(bit_iter))
1337
 
            break
1338
 
        for look in next_entries:
1339
 
            if lbit == look.lower():
1340
 
                current = pathjoin(current, look)
1341
 
                break
1342
 
        else:
1343
 
            # got to the end, nothing matched, so we just return the
1344
 
            # non-existing bits as they were specified (the filename may be
1345
 
            # the target of a move, for example).
1346
 
            current = pathjoin(current, bit, *list(bit_iter))
1347
 
            break
1348
 
    return current[len(abs_base):].lstrip('/')
1349
 
 
1350
 
 
1351
 
# XXX - TODO - we need better detection/integration of case-insensitive
1352
 
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
1353
 
# filesystems), for example, so could probably benefit from the same basic
1354
 
# support there.  For now though, only Windows and OSX get that support, and
1355
 
# they get it for *all* file-systems!
1356
 
if sys.platform in ('win32', 'darwin'):
1357
 
    canonical_relpath = _cicp_canonical_relpath
1358
 
else:
1359
 
    canonical_relpath = relpath
1360
 
 
1361
 
 
1362
 
def canonical_relpaths(base, paths):
1363
 
    """Create an iterable to canonicalize a sequence of relative paths.
1364
 
 
1365
 
    The intent is for this implementation to use a cache, vastly speeding
1366
 
    up multiple transformations in the same directory.
1367
 
    """
1368
 
    # but for now, we haven't optimized...
1369
 
    return [canonical_relpath(base, p) for p in paths]
1370
 
 
1371
 
 
1372
 
def decode_filename(filename):
1373
 
    """Decode the filename using the filesystem encoding
1374
 
 
1375
 
    If it is unicode, it is returned.
1376
 
    Otherwise it is decoded from the the filesystem's encoding. If decoding
1377
 
    fails, a errors.BadFilenameEncoding exception is raised.
1378
 
    """
1379
 
    if isinstance(filename, text_type):
1380
 
        return filename
1381
 
    try:
1382
 
        return filename.decode(_fs_enc)
1383
 
    except UnicodeDecodeError:
1384
 
        raise errors.BadFilenameEncoding(filename, _fs_enc)
1385
 
 
1386
 
 
1387
631
def safe_unicode(unicode_or_utf8_string):
1388
632
    """Coerce unicode_or_utf8_string into unicode.
1389
633
 
1390
634
    If it is unicode, it is returned.
1391
 
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
1392
 
    wrapped in a BzrBadParameterNotUnicode exception.
 
635
    Otherwise it is decoded from utf-8. If a decoding error
 
636
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
 
637
    as a BzrBadParameter exception.
1393
638
    """
1394
 
    if isinstance(unicode_or_utf8_string, text_type):
 
639
    if isinstance(unicode_or_utf8_string, unicode):
1395
640
        return unicode_or_utf8_string
1396
641
    try:
1397
642
        return unicode_or_utf8_string.decode('utf8')
1398
643
    except UnicodeDecodeError:
1399
 
        raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
1400
 
 
1401
 
 
1402
 
def safe_utf8(unicode_or_utf8_string):
1403
 
    """Coerce unicode_or_utf8_string to a utf8 string.
1404
 
 
1405
 
    If it is a str, it is returned.
1406
 
    If it is Unicode, it is encoded into a utf-8 string.
1407
 
    """
1408
 
    if isinstance(unicode_or_utf8_string, bytes):
1409
 
        # TODO: jam 20070209 This is overkill, and probably has an impact on
1410
 
        #       performance if we are dealing with lots of apis that want a
1411
 
        #       utf-8 revision id
1412
 
        try:
1413
 
            # Make sure it is a valid utf-8 string
1414
 
            unicode_or_utf8_string.decode('utf-8')
1415
 
        except UnicodeDecodeError:
1416
 
            raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
1417
 
        return unicode_or_utf8_string
1418
 
    return unicode_or_utf8_string.encode('utf-8')
1419
 
 
1420
 
 
1421
 
def safe_revision_id(unicode_or_utf8_string):
1422
 
    """Revision ids should now be utf8, but at one point they were unicode.
1423
 
 
1424
 
    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be
1425
 
        utf8 or None).
1426
 
    :return: None or a utf8 revision id.
1427
 
    """
1428
 
    if (unicode_or_utf8_string is None
1429
 
            or unicode_or_utf8_string.__class__ == bytes):
1430
 
        return unicode_or_utf8_string
1431
 
    raise TypeError('Unicode revision ids are no longer supported. '
1432
 
                    'Revision id generators should be creating utf8 revision '
1433
 
                    'ids.')
1434
 
 
1435
 
 
1436
 
def safe_file_id(unicode_or_utf8_string):
1437
 
    """File ids should now be utf8, but at one point they were unicode.
1438
 
 
1439
 
    This is the same as safe_utf8, except it uses the cached encode functions
1440
 
    to save a little bit of performance.
1441
 
 
1442
 
    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be
1443
 
        utf8 or None).
1444
 
    :return: None or a utf8 file id.
1445
 
    """
1446
 
    if (unicode_or_utf8_string is None
1447
 
            or unicode_or_utf8_string.__class__ == bytes):
1448
 
        return unicode_or_utf8_string
1449
 
    raise TypeError('Unicode file ids are no longer supported. '
1450
 
                    'File id generators should be creating utf8 file ids.')
1451
 
 
1452
 
 
1453
 
_platform_normalizes_filenames = False
1454
 
if sys.platform == 'darwin':
1455
 
    _platform_normalizes_filenames = True
1456
 
 
1457
 
 
1458
 
def normalizes_filenames():
1459
 
    """Return True if this platform normalizes unicode filenames.
1460
 
 
1461
 
    Only Mac OSX.
1462
 
    """
1463
 
    return _platform_normalizes_filenames
1464
 
 
1465
 
 
1466
 
def _accessible_normalized_filename(path):
1467
 
    """Get the unicode normalized path, and if you can access the file.
1468
 
 
1469
 
    On platforms where the system normalizes filenames (Mac OSX),
1470
 
    you can access a file by any path which will normalize correctly.
1471
 
    On platforms where the system does not normalize filenames
1472
 
    (everything else), you have to access a file by its exact path.
1473
 
 
1474
 
    Internally, bzr only supports NFC normalization, since that is
1475
 
    the standard for XML documents.
1476
 
 
1477
 
    So return the normalized path, and a flag indicating if the file
1478
 
    can be accessed by that path.
1479
 
    """
1480
 
 
1481
 
    if isinstance(path, bytes):
1482
 
        path = path.decode(sys.getfilesystemencoding())
1483
 
    return unicodedata.normalize('NFC', path), True
1484
 
 
1485
 
 
1486
 
def _inaccessible_normalized_filename(path):
1487
 
    __doc__ = _accessible_normalized_filename.__doc__
1488
 
 
1489
 
    if isinstance(path, bytes):
1490
 
        path = path.decode(sys.getfilesystemencoding())
1491
 
    normalized = unicodedata.normalize('NFC', path)
1492
 
    return normalized, normalized == path
1493
 
 
1494
 
 
1495
 
if _platform_normalizes_filenames:
1496
 
    normalized_filename = _accessible_normalized_filename
1497
 
else:
1498
 
    normalized_filename = _inaccessible_normalized_filename
1499
 
 
1500
 
 
1501
 
def set_signal_handler(signum, handler, restart_syscall=True):
1502
 
    """A wrapper for signal.signal that also calls siginterrupt(signum, False)
1503
 
    on platforms that support that.
1504
 
 
1505
 
    :param restart_syscall: if set, allow syscalls interrupted by a signal to
1506
 
        automatically restart (by calling `signal.siginterrupt(signum,
1507
 
        False)`).  May be ignored if the feature is not available on this
1508
 
        platform or Python version.
1509
 
    """
1510
 
    try:
1511
 
        import signal
1512
 
        siginterrupt = signal.siginterrupt
1513
 
    except ImportError:
1514
 
        # This python implementation doesn't provide signal support, hence no
1515
 
        # handler exists
1516
 
        return None
1517
 
    except AttributeError:
1518
 
        # siginterrupt doesn't exist on this platform, or for this version
1519
 
        # of Python.
1520
 
        def siginterrupt(signum, flag): return None
1521
 
    if restart_syscall:
1522
 
        def sig_handler(*args):
1523
 
            # Python resets the siginterrupt flag when a signal is
1524
 
            # received.  <http://bugs.python.org/issue8354>
1525
 
            # As a workaround for some cases, set it back the way we want it.
1526
 
            siginterrupt(signum, False)
1527
 
            # Now run the handler function passed to set_signal_handler.
1528
 
            handler(*args)
1529
 
    else:
1530
 
        sig_handler = handler
1531
 
    old_handler = signal.signal(signum, sig_handler)
1532
 
    if restart_syscall:
1533
 
        siginterrupt(signum, False)
1534
 
    return old_handler
1535
 
 
1536
 
 
1537
 
default_terminal_width = 80
1538
 
"""The default terminal width for ttys.
1539
 
 
1540
 
This is defined so that higher levels can share a common fallback value when
1541
 
terminal_width() returns None.
1542
 
"""
1543
 
 
1544
 
# Keep some state so that terminal_width can detect if _terminal_size has
1545
 
# returned a different size since the process started.  See docstring and
1546
 
# comments of terminal_width for details.
1547
 
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
1548
 
_terminal_size_state = 'no_data'
1549
 
_first_terminal_size = None
 
644
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
1550
645
 
1551
646
 
1552
647
def terminal_width():
1553
 
    """Return terminal width.
1554
 
 
1555
 
    None is returned if the width can't established precisely.
1556
 
 
1557
 
    The rules are:
1558
 
    - if BRZ_COLUMNS is set, returns its value
1559
 
    - if there is no controlling terminal, returns None
1560
 
    - query the OS, if the queried size has changed since the last query,
1561
 
      return its value,
1562
 
    - if COLUMNS is set, returns its value,
1563
 
    - if the OS has a value (even though it's never changed), return its value.
1564
 
 
1565
 
    From there, we need to query the OS to get the size of the controlling
1566
 
    terminal.
1567
 
 
1568
 
    On Unices we query the OS by:
1569
 
    - get termios.TIOCGWINSZ
1570
 
    - if an error occurs or a negative value is obtained, returns None
1571
 
 
1572
 
    On Windows we query the OS by:
1573
 
    - win32utils.get_console_size() decides,
1574
 
    - returns None on error (provided default value)
1575
 
    """
1576
 
    # Note to implementors: if changing the rules for determining the width,
1577
 
    # make sure you've considered the behaviour in these cases:
1578
 
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
1579
 
    #  - brz log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
1580
 
    #    0,0.
1581
 
    #  - (add more interesting cases here, if you find any)
1582
 
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
1583
 
    # but we don't want to register a signal handler because it is impossible
1584
 
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
1585
 
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
1586
 
    # time so we can notice if the reported size has changed, which should have
1587
 
    # a similar effect.
1588
 
 
1589
 
    # If BRZ_COLUMNS is set, take it, user is always right
1590
 
    # Except if they specified 0 in which case, impose no limit here
1591
 
    try:
1592
 
        width = int(os.environ['BRZ_COLUMNS'])
1593
 
    except (KeyError, ValueError):
1594
 
        width = None
1595
 
    if width is not None:
1596
 
        if width > 0:
1597
 
            return width
1598
 
        else:
1599
 
            return None
1600
 
 
1601
 
    isatty = getattr(sys.stdout, 'isatty', None)
1602
 
    if isatty is None or not isatty():
1603
 
        # Don't guess, setting BRZ_COLUMNS is the recommended way to override.
1604
 
        return None
1605
 
 
1606
 
    # Query the OS
1607
 
    width, height = os_size = _terminal_size(None, None)
1608
 
    global _first_terminal_size, _terminal_size_state
1609
 
    if _terminal_size_state == 'no_data':
1610
 
        _first_terminal_size = os_size
1611
 
        _terminal_size_state = 'unchanged'
1612
 
    elif (_terminal_size_state == 'unchanged' and
1613
 
          _first_terminal_size != os_size):
1614
 
        _terminal_size_state = 'changed'
1615
 
 
1616
 
    # If the OS claims to know how wide the terminal is, and this value has
1617
 
    # ever changed, use that.
1618
 
    if _terminal_size_state == 'changed':
1619
 
        if width is not None and width > 0:
1620
 
            return width
1621
 
 
1622
 
    # If COLUMNS is set, use it.
 
648
    """Return estimated terminal width."""
 
649
 
 
650
    # TODO: Do something smart on Windows?
 
651
 
 
652
    # TODO: Is there anything that gets a better update when the window
 
653
    # is resized while the program is running? We could use the Python termcap
 
654
    # library.
1623
655
    try:
1624
656
        return int(os.environ['COLUMNS'])
1625
 
    except (KeyError, ValueError):
1626
 
        pass
1627
 
 
1628
 
    # Finally, use an unchanged size from the OS, if we have one.
1629
 
    if _terminal_size_state == 'unchanged':
1630
 
        if width is not None and width > 0:
1631
 
            return width
1632
 
 
1633
 
    # The width could not be determined.
1634
 
    return None
1635
 
 
1636
 
 
1637
 
def _win32_terminal_size(width, height):
1638
 
    width, height = win32utils.get_console_size(
1639
 
        defaultx=width, defaulty=height)
1640
 
    return width, height
1641
 
 
1642
 
 
1643
 
def _ioctl_terminal_size(width, height):
1644
 
    try:
1645
 
        import struct
1646
 
        import fcntl
1647
 
        import termios
1648
 
        s = struct.pack('HHHH', 0, 0, 0, 0)
1649
 
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1650
 
        height, width = struct.unpack('HHHH', x)[0:2]
1651
 
    except (IOError, AttributeError):
1652
 
        pass
1653
 
    return width, height
1654
 
 
1655
 
 
1656
 
_terminal_size = None
1657
 
"""Returns the terminal size as (width, height).
1658
 
 
1659
 
:param width: Default value for width.
1660
 
:param height: Default value for height.
1661
 
 
1662
 
This is defined specifically for each OS and query the size of the controlling
1663
 
terminal. If any error occurs, the provided default values should be returned.
1664
 
"""
1665
 
if sys.platform == 'win32':
1666
 
    _terminal_size = _win32_terminal_size
1667
 
else:
1668
 
    _terminal_size = _ioctl_terminal_size
1669
 
 
1670
 
 
1671
 
def supports_executable(path):
1672
 
    """Return if filesystem at path supports executable bit.
1673
 
 
1674
 
    :param path: Path for which to check the file system
1675
 
    :return: boolean indicating whether executable bit can be stored/relied upon
1676
 
    """
1677
 
    if sys.platform == 'win32':
1678
 
        return False
1679
 
    try:
1680
 
        fs_type = get_fs_type(path)
1681
 
    except errors.DependencyNotPresent as e:
1682
 
        trace.mutter('Unable to get fs type for %r: %s', path, e)
1683
 
    else:
1684
 
        if fs_type in ('vfat', 'ntfs'):
1685
 
            # filesystems known to not support executable bit
1686
 
            return False
1687
 
    return True
1688
 
 
1689
 
 
1690
 
def supports_symlinks(path):
1691
 
    """Return if the filesystem at path supports the creation of symbolic links.
1692
 
 
1693
 
    """
1694
 
    if not has_symlinks():
1695
 
        return False
1696
 
    try:
1697
 
        fs_type = get_fs_type(path)
1698
 
    except errors.DependencyNotPresent as e:
1699
 
        trace.mutter('Unable to get fs type for %r: %s', path, e)
1700
 
    else:
1701
 
        if fs_type in ('vfat', 'ntfs'):
1702
 
            # filesystems known to not support symlinks
1703
 
            return False
1704
 
    return True
1705
 
 
1706
 
 
1707
 
def supports_posix_readonly():
1708
 
    """Return True if 'readonly' has POSIX semantics, False otherwise.
1709
 
 
1710
 
    Notably, a win32 readonly file cannot be deleted, unlike POSIX where the
1711
 
    directory controls creation/deletion, etc.
1712
 
 
1713
 
    And under win32, readonly means that the directory itself cannot be
1714
 
    deleted.  The contents of a readonly directory can be changed, unlike POSIX
1715
 
    where files in readonly directories cannot be added, deleted or renamed.
1716
 
    """
 
657
    except (IndexError, KeyError, ValueError):
 
658
        return 80
 
659
 
 
660
def supports_executable():
1717
661
    return sys.platform != "win32"
1718
662
 
1719
663
 
1720
 
def set_or_unset_env(env_variable, value):
1721
 
    """Modify the environment, setting or removing the env_variable.
1722
 
 
1723
 
    :param env_variable: The environment variable in question
1724
 
    :param value: The value to set the environment to. If None, then
1725
 
        the variable will be removed.
1726
 
    :return: The original value of the environment variable.
 
664
def strip_trailing_slash(path):
 
665
    """Strip trailing slash, except for root paths.
 
666
    The definition of 'root path' is platform-dependent.
1727
667
    """
1728
 
    orig_val = os.environ.get(env_variable)
1729
 
    if value is None:
1730
 
        if orig_val is not None:
1731
 
            del os.environ[env_variable]
 
668
    if len(path) != MIN_ABS_PATHLENGTH and path[-1] == '/':
 
669
        return path[:-1]
1732
670
    else:
1733
 
        if not PY3 and isinstance(value, text_type):
1734
 
            value = value.encode(get_user_encoding())
1735
 
        os.environ[env_variable] = value
1736
 
    return orig_val
 
671
        return path
1737
672
 
1738
673
 
1739
674
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
1740
675
 
1741
676
 
1742
677
def check_legal_path(path):
1743
 
    """Check whether the supplied path is legal.
 
678
    """Check whether the supplied path is legal.  
1744
679
    This is only required on Windows, so we don't test on other platforms
1745
680
    right now.
1746
681
    """
1747
682
    if sys.platform != "win32":
1748
683
        return
1749
684
    if _validWin32PathRE.match(path) is None:
1750
 
        raise errors.IllegalPath(path)
1751
 
 
1752
 
 
1753
 
_WIN32_ERROR_DIRECTORY = 267  # Similar to errno.ENOTDIR
1754
 
 
1755
 
 
1756
 
def _is_error_enotdir(e):
1757
 
    """Check if this exception represents ENOTDIR.
1758
 
 
1759
 
    Unfortunately, python is very inconsistent about the exception
1760
 
    here. The cases are:
1761
 
      1) Linux, Mac OSX all versions seem to set errno == ENOTDIR
1762
 
      2) Windows, Python2.4, uses errno == ERROR_DIRECTORY (267)
1763
 
         which is the windows error code.
1764
 
      3) Windows, Python2.5 uses errno == EINVAL and
1765
 
         winerror == ERROR_DIRECTORY
1766
 
 
1767
 
    :param e: An Exception object (expected to be OSError with an errno
1768
 
        attribute, but we should be able to cope with anything)
1769
 
    :return: True if this represents an ENOTDIR error. False otherwise.
1770
 
    """
1771
 
    en = getattr(e, 'errno', None)
1772
 
    if (en == errno.ENOTDIR or
1773
 
        (sys.platform == 'win32' and
1774
 
            (en == _WIN32_ERROR_DIRECTORY or
1775
 
             (en == errno.EINVAL
1776
 
              and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
1777
 
             ))):
1778
 
        return True
1779
 
    return False
1780
 
 
1781
 
 
1782
 
def walkdirs(top, prefix=""):
1783
 
    """Yield data about all the directories in a tree.
1784
 
 
1785
 
    This yields all the data about the contents of a directory at a time.
1786
 
    After each directory has been yielded, if the caller has mutated the list
1787
 
    to exclude some directories, they are then not descended into.
1788
 
 
1789
 
    The data yielded is of the form:
1790
 
    ((directory-relpath, directory-path-from-top),
1791
 
    [(relpath, basename, kind, lstat, path-from-top), ...]),
1792
 
     - directory-relpath is the relative path of the directory being returned
1793
 
       with respect to top. prefix is prepended to this.
1794
 
     - directory-path-from-root is the path including top for this directory.
1795
 
       It is suitable for use with os functions.
1796
 
     - relpath is the relative path within the subtree being walked.
1797
 
     - basename is the basename of the path
1798
 
     - kind is the kind of the file now. If unknown then the file is not
1799
 
       present within the tree - but it may be recorded as versioned. See
1800
 
       versioned_kind.
1801
 
     - lstat is the stat data *if* the file was statted.
1802
 
     - planned, not implemented:
1803
 
       path_from_tree_root is the path from the root of the tree.
1804
 
 
1805
 
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This
1806
 
        allows one to walk a subtree but get paths that are relative to a tree
1807
 
        rooted higher up.
1808
 
    :return: an iterator over the dirs.
1809
 
    """
1810
 
    # TODO there is a bit of a smell where the results of the directory-
1811
 
    # summary in this, and the path from the root, may not agree
1812
 
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
1813
 
    # potentially confusing output. We should make this more robust - but
1814
 
    # not at a speed cost. RBC 20060731
1815
 
    _lstat = os.lstat
1816
 
    _directory = _directory_kind
1817
 
    _listdir = os.listdir
1818
 
    _kind_from_mode = file_kind_from_stat_mode
1819
 
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
1820
 
    while pending:
1821
 
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1822
 
        relroot, _, _, _, top = pending.pop()
1823
 
        if relroot:
1824
 
            relprefix = relroot + u'/'
1825
 
        else:
1826
 
            relprefix = ''
1827
 
        top_slash = top + u'/'
1828
 
 
1829
 
        dirblock = []
1830
 
        append = dirblock.append
1831
 
        try:
1832
 
            names = sorted(map(decode_filename, _listdir(top)))
1833
 
        except OSError as e:
1834
 
            if not _is_error_enotdir(e):
1835
 
                raise
1836
 
        else:
1837
 
            for name in names:
1838
 
                abspath = top_slash + name
1839
 
                statvalue = _lstat(abspath)
1840
 
                kind = _kind_from_mode(statvalue.st_mode)
1841
 
                append((relprefix + name, name, kind, statvalue, abspath))
1842
 
        yield (relroot, top), dirblock
1843
 
 
1844
 
        # push the user specified dirs from dirblock
1845
 
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1846
 
 
1847
 
 
1848
 
class DirReader(object):
1849
 
    """An interface for reading directories."""
1850
 
 
1851
 
    def top_prefix_to_starting_dir(self, top, prefix=""):
1852
 
        """Converts top and prefix to a starting dir entry
1853
 
 
1854
 
        :param top: A utf8 path
1855
 
        :param prefix: An optional utf8 path to prefix output relative paths
1856
 
            with.
1857
 
        :return: A tuple starting with prefix, and ending with the native
1858
 
            encoding of top.
1859
 
        """
1860
 
        raise NotImplementedError(self.top_prefix_to_starting_dir)
1861
 
 
1862
 
    def read_dir(self, prefix, top):
1863
 
        """Read a specific dir.
1864
 
 
1865
 
        :param prefix: A utf8 prefix to be preprended to the path basenames.
1866
 
        :param top: A natively encoded path to read.
1867
 
        :return: A list of the directories contents. Each item contains:
1868
 
            (utf8_relpath, utf8_name, kind, lstatvalue, native_abspath)
1869
 
        """
1870
 
        raise NotImplementedError(self.read_dir)
1871
 
 
1872
 
 
1873
 
_selected_dir_reader = None
1874
 
 
1875
 
 
1876
 
def _walkdirs_utf8(top, prefix=""):
1877
 
    """Yield data about all the directories in a tree.
1878
 
 
1879
 
    This yields the same information as walkdirs() only each entry is yielded
1880
 
    in utf-8. On platforms which have a filesystem encoding of utf8 the paths
1881
 
    are returned as exact byte-strings.
1882
 
 
1883
 
    :return: yields a tuple of (dir_info, [file_info])
1884
 
        dir_info is (utf8_relpath, path-from-top)
1885
 
        file_info is (utf8_relpath, utf8_name, kind, lstat, path-from-top)
1886
 
        if top is an absolute path, path-from-top is also an absolute path.
1887
 
        path-from-top might be unicode or utf8, but it is the correct path to
1888
 
        pass to os functions to affect the file in question. (such as os.lstat)
1889
 
    """
1890
 
    global _selected_dir_reader
1891
 
    if _selected_dir_reader is None:
1892
 
        if sys.platform == "win32":
1893
 
            try:
1894
 
                from ._walkdirs_win32 import Win32ReadDir
1895
 
                _selected_dir_reader = Win32ReadDir()
1896
 
            except ImportError:
1897
 
                pass
1898
 
        elif _fs_enc in ('utf-8', 'ascii'):
1899
 
            try:
1900
 
                from ._readdir_pyx import UTF8DirReader
1901
 
                _selected_dir_reader = UTF8DirReader()
1902
 
            except ImportError as e:
1903
 
                failed_to_load_extension(e)
1904
 
                pass
1905
 
 
1906
 
    if _selected_dir_reader is None:
1907
 
        # Fallback to the python version
1908
 
        _selected_dir_reader = UnicodeDirReader()
1909
 
 
1910
 
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1911
 
    # But we don't actually uses 1-3 in pending, so set them to None
1912
 
    pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
1913
 
    read_dir = _selected_dir_reader.read_dir
1914
 
    _directory = _directory_kind
1915
 
    while pending:
1916
 
        relroot, _, _, _, top = pending[-1].pop()
1917
 
        if not pending[-1]:
1918
 
            pending.pop()
1919
 
        dirblock = sorted(read_dir(relroot, top))
1920
 
        yield (relroot, top), dirblock
1921
 
        # push the user specified dirs from dirblock
1922
 
        next = [d for d in reversed(dirblock) if d[2] == _directory]
1923
 
        if next:
1924
 
            pending.append(next)
1925
 
 
1926
 
 
1927
 
class UnicodeDirReader(DirReader):
1928
 
    """A dir reader for non-utf8 file systems, which transcodes."""
1929
 
 
1930
 
    __slots__ = ['_utf8_encode']
1931
 
 
1932
 
    def __init__(self):
1933
 
        self._utf8_encode = codecs.getencoder('utf8')
1934
 
 
1935
 
    def top_prefix_to_starting_dir(self, top, prefix=""):
1936
 
        """See DirReader.top_prefix_to_starting_dir."""
1937
 
        return (safe_utf8(prefix), None, None, None, safe_unicode(top))
1938
 
 
1939
 
    def read_dir(self, prefix, top):
1940
 
        """Read a single directory from a non-utf8 file system.
1941
 
 
1942
 
        top, and the abspath element in the output are unicode, all other paths
1943
 
        are utf8. Local disk IO is done via unicode calls to listdir etc.
1944
 
 
1945
 
        This is currently the fallback code path when the filesystem encoding is
1946
 
        not UTF-8. It may be better to implement an alternative so that we can
1947
 
        safely handle paths that are not properly decodable in the current
1948
 
        encoding.
1949
 
 
1950
 
        See DirReader.read_dir for details.
1951
 
        """
1952
 
        _utf8_encode = self._utf8_encode
1953
 
 
1954
 
        def _fs_decode(s): return s.decode(_fs_enc)
1955
 
 
1956
 
        def _fs_encode(s): return s.encode(_fs_enc)
1957
 
        _lstat = os.lstat
1958
 
        _listdir = os.listdir
1959
 
        _kind_from_mode = file_kind_from_stat_mode
1960
 
 
1961
 
        if prefix:
1962
 
            relprefix = prefix + b'/'
1963
 
        else:
1964
 
            relprefix = b''
1965
 
        top_slash = top + '/'
1966
 
 
1967
 
        dirblock = []
1968
 
        append = dirblock.append
1969
 
        for name_native in _listdir(top.encode('utf-8')):
1970
 
            try:
1971
 
                name = _fs_decode(name_native)
1972
 
            except UnicodeDecodeError:
1973
 
                raise errors.BadFilenameEncoding(
1974
 
                    relprefix + name_native, _fs_enc)
1975
 
            name_utf8 = _utf8_encode(name)[0]
1976
 
            abspath = top_slash + name
1977
 
            statvalue = _lstat(abspath)
1978
 
            kind = _kind_from_mode(statvalue.st_mode)
1979
 
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
1980
 
        return sorted(dirblock)
1981
 
 
1982
 
 
1983
 
def copy_tree(from_path, to_path, handlers={}):
1984
 
    """Copy all of the entries in from_path into to_path.
1985
 
 
1986
 
    :param from_path: The base directory to copy.
1987
 
    :param to_path: The target directory. If it does not exist, it will
1988
 
        be created.
1989
 
    :param handlers: A dictionary of functions, which takes a source and
1990
 
        destinations for files, directories, etc.
1991
 
        It is keyed on the file kind, such as 'directory', 'symlink', or 'file'
1992
 
        'file', 'directory', and 'symlink' should always exist.
1993
 
        If they are missing, they will be replaced with 'os.mkdir()',
1994
 
        'os.readlink() + os.symlink()', and 'shutil.copy2()', respectively.
1995
 
    """
1996
 
    # Now, just copy the existing cached tree to the new location
1997
 
    # We use a cheap trick here.
1998
 
    # Absolute paths are prefixed with the first parameter
1999
 
    # relative paths are prefixed with the second.
2000
 
    # So we can get both the source and target returned
2001
 
    # without any extra work.
2002
 
 
2003
 
    def copy_dir(source, dest):
2004
 
        os.mkdir(dest)
2005
 
 
2006
 
    def copy_link(source, dest):
2007
 
        """Copy the contents of a symlink"""
2008
 
        link_to = os.readlink(source)
2009
 
        os.symlink(link_to, dest)
2010
 
 
2011
 
    real_handlers = {'file': shutil.copy2,
2012
 
                     'symlink': copy_link,
2013
 
                     'directory': copy_dir,
2014
 
                     }
2015
 
    real_handlers.update(handlers)
2016
 
 
2017
 
    if not os.path.exists(to_path):
2018
 
        real_handlers['directory'](from_path, to_path)
2019
 
 
2020
 
    for dir_info, entries in walkdirs(from_path, prefix=to_path):
2021
 
        for relpath, name, kind, st, abspath in entries:
2022
 
            real_handlers[kind](abspath, relpath)
2023
 
 
2024
 
 
2025
 
def copy_ownership_from_path(dst, src=None):
2026
 
    """Copy usr/grp ownership from src file/dir to dst file/dir.
2027
 
 
2028
 
    If src is None, the containing directory is used as source. If chown
2029
 
    fails, the error is ignored and a warning is printed.
2030
 
    """
2031
 
    chown = getattr(os, 'chown', None)
2032
 
    if chown is None:
2033
 
        return
2034
 
 
2035
 
    if src is None:
2036
 
        src = os.path.dirname(dst)
2037
 
        if src == '':
2038
 
            src = '.'
2039
 
 
2040
 
    try:
2041
 
        s = os.stat(src)
2042
 
        chown(dst, s.st_uid, s.st_gid)
2043
 
    except OSError:
2044
 
        trace.warning(
2045
 
            'Unable to copy ownership from "%s" to "%s". '
2046
 
            'You may want to set it manually.', src, dst)
2047
 
        trace.log_exception_quietly()
2048
 
 
2049
 
 
2050
 
def path_prefix_key(path):
2051
 
    """Generate a prefix-order path key for path.
2052
 
 
2053
 
    This can be used to sort paths in the same way that walkdirs does.
2054
 
    """
2055
 
    return (dirname(path), path)
2056
 
 
2057
 
 
2058
 
def compare_paths_prefix_order(path_a, path_b):
2059
 
    """Compare path_a and path_b to generate the same order walkdirs uses."""
2060
 
    key_a = path_prefix_key(path_a)
2061
 
    key_b = path_prefix_key(path_b)
2062
 
    return (key_a > key_b) - (key_a < key_b)
2063
 
 
2064
 
 
2065
 
_cached_user_encoding = None
2066
 
 
2067
 
 
2068
 
def get_user_encoding():
2069
 
    """Find out what the preferred user encoding is.
2070
 
 
2071
 
    This is generally the encoding that is used for command line parameters
2072
 
    and file contents. This may be different from the terminal encoding
2073
 
    or the filesystem encoding.
2074
 
 
2075
 
    :return: A string defining the preferred user encoding
2076
 
    """
2077
 
    global _cached_user_encoding
2078
 
    if _cached_user_encoding is not None:
2079
 
        return _cached_user_encoding
2080
 
 
2081
 
    if os.name == 'posix' and getattr(locale, 'CODESET', None) is not None:
2082
 
        # Use the existing locale settings and call nl_langinfo directly
2083
 
        # rather than going through getpreferredencoding. This avoids
2084
 
        # <http://bugs.python.org/issue6202> on OSX Python 2.6 and the
2085
 
        # possibility of the setlocale call throwing an error.
2086
 
        user_encoding = locale.nl_langinfo(locale.CODESET)
2087
 
    else:
2088
 
        # GZ 2011-12-19: On windows could call GetACP directly instead.
2089
 
        user_encoding = locale.getpreferredencoding(False)
2090
 
 
2091
 
    try:
2092
 
        user_encoding = codecs.lookup(user_encoding).name
2093
 
    except LookupError:
2094
 
        if user_encoding not in ("", "cp0"):
2095
 
            sys.stderr.write('brz: warning:'
2096
 
                             ' unknown encoding %s.'
2097
 
                             ' Continuing with ascii encoding.\n'
2098
 
                             % user_encoding
2099
 
                             )
2100
 
        user_encoding = 'ascii'
2101
 
    else:
2102
 
        # Get 'ascii' when setlocale has not been called or LANG=C or unset.
2103
 
        if user_encoding == 'ascii':
2104
 
            if sys.platform == 'darwin':
2105
 
                # OSX is special-cased in Python to have a UTF-8 filesystem
2106
 
                # encoding and previously had LANG set here if not present.
2107
 
                user_encoding = 'utf-8'
2108
 
            # GZ 2011-12-19: Maybe UTF-8 should be the default in this case
2109
 
            #                for some other posix platforms as well.
2110
 
 
2111
 
    _cached_user_encoding = user_encoding
2112
 
    return user_encoding
2113
 
 
2114
 
 
2115
 
def get_diff_header_encoding():
2116
 
    return get_terminal_encoding()
2117
 
 
2118
 
 
2119
 
def get_host_name():
2120
 
    """Return the current unicode host name.
2121
 
 
2122
 
    This is meant to be used in place of socket.gethostname() because that
2123
 
    behaves inconsistently on different platforms.
2124
 
    """
2125
 
    if sys.platform == "win32":
2126
 
        return win32utils.get_host_name()
2127
 
    else:
2128
 
        import socket
2129
 
        if PY3:
2130
 
            return socket.gethostname()
2131
 
        return socket.gethostname().decode(get_user_encoding())
2132
 
 
2133
 
 
2134
 
# We must not read/write any more than 64k at a time from/to a socket so we
2135
 
# don't risk "no buffer space available" errors on some platforms.  Windows in
2136
 
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
2137
 
# data at once.
2138
 
MAX_SOCKET_CHUNK = 64 * 1024
2139
 
 
2140
 
_end_of_stream_errors = [errno.ECONNRESET, errno.EPIPE, errno.EINVAL]
2141
 
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
2142
 
    _eno = getattr(errno, _eno, None)
2143
 
    if _eno is not None:
2144
 
        _end_of_stream_errors.append(_eno)
2145
 
del _eno
2146
 
 
2147
 
 
2148
 
def read_bytes_from_socket(sock, report_activity=None,
2149
 
                           max_read_size=MAX_SOCKET_CHUNK):
2150
 
    """Read up to max_read_size of bytes from sock and notify of progress.
2151
 
 
2152
 
    Translates "Connection reset by peer" into file-like EOF (return an
2153
 
    empty string rather than raise an error), and repeats the recv if
2154
 
    interrupted by a signal.
2155
 
    """
2156
 
    while True:
2157
 
        try:
2158
 
            data = sock.recv(max_read_size)
2159
 
        except socket.error as e:
2160
 
            eno = e.args[0]
2161
 
            if eno in _end_of_stream_errors:
2162
 
                # The connection was closed by the other side.  Callers expect
2163
 
                # an empty string to signal end-of-stream.
2164
 
                return b""
2165
 
            elif eno == errno.EINTR:
2166
 
                # Retry the interrupted recv.
2167
 
                continue
2168
 
            raise
2169
 
        else:
2170
 
            if report_activity is not None:
2171
 
                report_activity(len(data), 'read')
2172
 
            return data
2173
 
 
2174
 
 
2175
 
def recv_all(socket, count):
2176
 
    """Receive an exact number of bytes.
2177
 
 
2178
 
    Regular Socket.recv() may return less than the requested number of bytes,
2179
 
    depending on what's in the OS buffer.  MSG_WAITALL is not available
2180
 
    on all platforms, but this should work everywhere.  This will return
2181
 
    less than the requested amount if the remote end closes.
2182
 
 
2183
 
    This isn't optimized and is intended mostly for use in testing.
2184
 
    """
2185
 
    b = b''
2186
 
    while len(b) < count:
2187
 
        new = read_bytes_from_socket(socket, None, count - len(b))
2188
 
        if new == b'':
2189
 
            break  # eof
2190
 
        b += new
2191
 
    return b
2192
 
 
2193
 
 
2194
 
def send_all(sock, bytes, report_activity=None):
2195
 
    """Send all bytes on a socket.
2196
 
 
2197
 
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2198
 
    some platforms, and catches EINTR which may be thrown if the send is
2199
 
    interrupted by a signal.
2200
 
 
2201
 
    This is preferred to socket.sendall(), because it avoids portability bugs
2202
 
    and provides activity reporting.
2203
 
 
2204
 
    :param report_activity: Call this as bytes are read, see
2205
 
        Transport._report_activity
2206
 
    """
2207
 
    sent_total = 0
2208
 
    byte_count = len(bytes)
2209
 
    view = memoryview(bytes)
2210
 
    while sent_total < byte_count:
2211
 
        try:
2212
 
            sent = sock.send(view[sent_total:sent_total + MAX_SOCKET_CHUNK])
2213
 
        except (socket.error, IOError) as e:
2214
 
            if e.args[0] in _end_of_stream_errors:
2215
 
                raise errors.ConnectionReset(
2216
 
                    "Error trying to write to socket", e)
2217
 
            if e.args[0] != errno.EINTR:
2218
 
                raise
2219
 
        else:
2220
 
            if sent == 0:
2221
 
                raise errors.ConnectionReset('Sending to %s returned 0 bytes'
2222
 
                                             % (sock,))
2223
 
            sent_total += sent
2224
 
            if report_activity is not None:
2225
 
                report_activity(sent, 'write')
2226
 
 
2227
 
 
2228
 
def connect_socket(address):
2229
 
    # Slight variation of the socket.create_connection() function (provided by
2230
 
    # python-2.6) that can fail if getaddrinfo returns an empty list. We also
2231
 
    # provide it for previous python versions. Also, we don't use the timeout
2232
 
    # parameter (provided by the python implementation) so we don't implement
2233
 
    # it either).
2234
 
    err = socket.error('getaddrinfo returns an empty list')
2235
 
    host, port = address
2236
 
    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
2237
 
        af, socktype, proto, canonname, sa = res
2238
 
        sock = None
2239
 
        try:
2240
 
            sock = socket.socket(af, socktype, proto)
2241
 
            sock.connect(sa)
2242
 
            return sock
2243
 
 
2244
 
        except socket.error as e:
2245
 
            err = e
2246
 
            # 'err' is now the most recent error
2247
 
            if sock is not None:
2248
 
                sock.close()
2249
 
    raise err
2250
 
 
2251
 
 
2252
 
def dereference_path(path):
2253
 
    """Determine the real path to a file.
2254
 
 
2255
 
    All parent elements are dereferenced.  But the file itself is not
2256
 
    dereferenced.
2257
 
    :param path: The original path.  May be absolute or relative.
2258
 
    :return: the real path *to* the file
2259
 
    """
2260
 
    parent, base = os.path.split(path)
2261
 
    # The pathjoin for '.' is a workaround for Python bug #1213894.
2262
 
    # (initial path components aren't dereferenced)
2263
 
    return pathjoin(realpath(pathjoin('.', parent)), base)
2264
 
 
2265
 
 
2266
 
def supports_mapi():
2267
 
    """Return True if we can use MAPI to launch a mail client."""
2268
 
    return sys.platform == "win32"
2269
 
 
2270
 
 
2271
 
def resource_string(package, resource_name):
2272
 
    """Load a resource from a package and return it as a string.
2273
 
 
2274
 
    Note: Only packages that start with breezy are currently supported.
2275
 
 
2276
 
    This is designed to be a lightweight implementation of resource
2277
 
    loading in a way which is API compatible with the same API from
2278
 
    pkg_resources. See
2279
 
    http://peak.telecommunity.com/DevCenter/PkgResources#basic-resource-access.
2280
 
    If and when pkg_resources becomes a standard library, this routine
2281
 
    can delegate to it.
2282
 
    """
2283
 
    # Check package name is within breezy
2284
 
    if package == "breezy":
2285
 
        resource_relpath = resource_name
2286
 
    elif package.startswith("breezy."):
2287
 
        package = package[len("breezy."):].replace('.', os.sep)
2288
 
        resource_relpath = pathjoin(package, resource_name)
2289
 
    else:
2290
 
        raise errors.BzrError('resource package %s not in breezy' % package)
2291
 
 
2292
 
    # Map the resource to a file and read its contents
2293
 
    base = dirname(breezy.__file__)
2294
 
    if getattr(sys, 'frozen', None):    # bzr.exe
2295
 
        base = abspath(pathjoin(base, '..', '..'))
2296
 
    with open(pathjoin(base, resource_relpath), "rt") as f:
2297
 
        return f.read()
2298
 
 
2299
 
 
2300
 
def file_kind_from_stat_mode_thunk(mode):
2301
 
    global file_kind_from_stat_mode
2302
 
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
2303
 
        try:
2304
 
            from ._readdir_pyx import UTF8DirReader
2305
 
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
2306
 
        except ImportError:
2307
 
            # This is one time where we won't warn that an extension failed to
2308
 
            # load. The extension is never available on Windows anyway.
2309
 
            from ._readdir_py import (
2310
 
                _kind_from_mode as file_kind_from_stat_mode
2311
 
                )
2312
 
    return file_kind_from_stat_mode(mode)
2313
 
 
2314
 
 
2315
 
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2316
 
 
2317
 
 
2318
 
def file_stat(f, _lstat=os.lstat):
2319
 
    try:
2320
 
        # XXX cache?
2321
 
        return _lstat(f)
2322
 
    except OSError as e:
2323
 
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2324
 
            raise errors.NoSuchFile(f)
2325
 
        raise
2326
 
 
2327
 
 
2328
 
def file_kind(f, _lstat=os.lstat):
2329
 
    stat_value = file_stat(f, _lstat)
2330
 
    return file_kind_from_stat_mode(stat_value.st_mode)
2331
 
 
2332
 
 
2333
 
def until_no_eintr(f, *a, **kw):
2334
 
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2335
 
 
2336
 
    WARNING: you must be certain that it is safe to retry the call repeatedly
2337
 
    if EINTR does occur.  This is typically only true for low-level operations
2338
 
    like os.read.  If in any doubt, don't use this.
2339
 
 
2340
 
    Keep in mind that this is not a complete solution to EINTR.  There is
2341
 
    probably code in the Python standard library and other dependencies that
2342
 
    may encounter EINTR if a signal arrives (and there is signal handler for
2343
 
    that signal).  So this function can reduce the impact for IO that breezy
2344
 
    directly controls, but it is not a complete solution.
2345
 
    """
2346
 
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
2347
 
    while True:
2348
 
        try:
2349
 
            return f(*a, **kw)
2350
 
        except (IOError, OSError) as e:
2351
 
            if e.errno == errno.EINTR:
2352
 
                continue
2353
 
            raise
2354
 
 
2355
 
 
2356
 
if sys.platform == "win32":
2357
 
    def getchar():
2358
 
        import msvcrt
2359
 
        return msvcrt.getch()
2360
 
else:
2361
 
    def getchar():
2362
 
        import tty
2363
 
        import termios
2364
 
        fd = sys.stdin.fileno()
2365
 
        settings = termios.tcgetattr(fd)
2366
 
        try:
2367
 
            tty.setraw(fd)
2368
 
            ch = sys.stdin.read(1)
2369
 
        finally:
2370
 
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2371
 
        return ch
2372
 
 
2373
 
if sys.platform.startswith('linux'):
2374
 
    def _local_concurrency():
2375
 
        try:
2376
 
            return os.sysconf('SC_NPROCESSORS_ONLN')
2377
 
        except (ValueError, OSError, AttributeError):
2378
 
            return None
2379
 
elif sys.platform == 'darwin':
2380
 
    def _local_concurrency():
2381
 
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2382
 
                                stdout=subprocess.PIPE).communicate()[0]
2383
 
elif "bsd" in sys.platform:
2384
 
    def _local_concurrency():
2385
 
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2386
 
                                stdout=subprocess.PIPE).communicate()[0]
2387
 
elif sys.platform == 'sunos5':
2388
 
    def _local_concurrency():
2389
 
        return subprocess.Popen(['psrinfo', '-p', ],
2390
 
                                stdout=subprocess.PIPE).communicate()[0]
2391
 
elif sys.platform == "win32":
2392
 
    def _local_concurrency():
2393
 
        # This appears to return the number of cores.
2394
 
        return os.environ.get('NUMBER_OF_PROCESSORS')
2395
 
else:
2396
 
    def _local_concurrency():
2397
 
        # Who knows ?
2398
 
        return None
2399
 
 
2400
 
 
2401
 
_cached_local_concurrency = None
2402
 
 
2403
 
 
2404
 
def local_concurrency(use_cache=True):
2405
 
    """Return how many processes can be run concurrently.
2406
 
 
2407
 
    Rely on platform specific implementations and default to 1 (one) if
2408
 
    anything goes wrong.
2409
 
    """
2410
 
    global _cached_local_concurrency
2411
 
 
2412
 
    if _cached_local_concurrency is not None and use_cache:
2413
 
        return _cached_local_concurrency
2414
 
 
2415
 
    concurrency = os.environ.get('BRZ_CONCURRENCY', None)
2416
 
    if concurrency is None:
2417
 
        import multiprocessing
2418
 
        try:
2419
 
            concurrency = multiprocessing.cpu_count()
2420
 
        except NotImplementedError:
2421
 
            # multiprocessing.cpu_count() isn't implemented on all platforms
2422
 
            try:
2423
 
                concurrency = _local_concurrency()
2424
 
            except (OSError, IOError):
2425
 
                pass
2426
 
    try:
2427
 
        concurrency = int(concurrency)
2428
 
    except (TypeError, ValueError):
2429
 
        concurrency = 1
2430
 
    if use_cache:
2431
 
        _cached_local_concurrency = concurrency
2432
 
    return concurrency
2433
 
 
2434
 
 
2435
 
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
2436
 
    """A stream writer that doesn't decode str arguments."""
2437
 
 
2438
 
    def __init__(self, encode, stream, errors='strict'):
2439
 
        codecs.StreamWriter.__init__(self, stream, errors)
2440
 
        self.encode = encode
2441
 
 
2442
 
    def write(self, object):
2443
 
        if isinstance(object, str):
2444
 
            self.stream.write(object)
2445
 
        else:
2446
 
            data, _ = self.encode(object, self.errors)
2447
 
            self.stream.write(data)
2448
 
 
2449
 
 
2450
 
if sys.platform == 'win32':
2451
 
    def open_file(filename, mode='r', bufsize=-1):
2452
 
        """This function is used to override the ``open`` builtin.
2453
 
 
2454
 
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2455
 
        child processes.  Deleting or renaming a closed file opened with this
2456
 
        function is not blocking child processes.
2457
 
        """
2458
 
        writing = 'w' in mode
2459
 
        appending = 'a' in mode
2460
 
        updating = '+' in mode
2461
 
        binary = 'b' in mode
2462
 
 
2463
 
        flags = O_NOINHERIT
2464
 
        # see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
2465
 
        # for flags for each modes.
2466
 
        if binary:
2467
 
            flags |= O_BINARY
2468
 
        else:
2469
 
            flags |= O_TEXT
2470
 
 
2471
 
        if writing:
2472
 
            if updating:
2473
 
                flags |= os.O_RDWR
2474
 
            else:
2475
 
                flags |= os.O_WRONLY
2476
 
            flags |= os.O_CREAT | os.O_TRUNC
2477
 
        elif appending:
2478
 
            if updating:
2479
 
                flags |= os.O_RDWR
2480
 
            else:
2481
 
                flags |= os.O_WRONLY
2482
 
            flags |= os.O_CREAT | os.O_APPEND
2483
 
        else:  # reading
2484
 
            if updating:
2485
 
                flags |= os.O_RDWR
2486
 
            else:
2487
 
                flags |= os.O_RDONLY
2488
 
 
2489
 
        return os.fdopen(os.open(filename, flags), mode, bufsize)
2490
 
else:
2491
 
    open_file = open
2492
 
 
2493
 
 
2494
 
def available_backup_name(base, exists):
2495
 
    """Find a non-existing backup file name.
2496
 
 
2497
 
    This will *not* create anything, this only return a 'free' entry.  This
2498
 
    should be used for checking names in a directory below a locked
2499
 
    tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
2500
 
    Leap) and generally discouraged.
2501
 
 
2502
 
    :param base: The base name.
2503
 
 
2504
 
    :param exists: A callable returning True if the path parameter exists.
2505
 
    """
2506
 
    counter = 1
2507
 
    name = "%s.~%d~" % (base, counter)
2508
 
    while exists(name):
2509
 
        counter += 1
2510
 
        name = "%s.~%d~" % (base, counter)
2511
 
    return name
2512
 
 
2513
 
 
2514
 
def set_fd_cloexec(fd):
2515
 
    """Set a Unix file descriptor's FD_CLOEXEC flag.  Do nothing if platform
2516
 
    support for this is not available.
2517
 
    """
2518
 
    try:
2519
 
        import fcntl
2520
 
        old = fcntl.fcntl(fd, fcntl.F_GETFD)
2521
 
        fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
2522
 
    except (ImportError, AttributeError):
2523
 
        # Either the fcntl module or specific constants are not present
2524
 
        pass
2525
 
 
2526
 
 
2527
 
def find_executable_on_path(name):
2528
 
    """Finds an executable on the PATH.
2529
 
 
2530
 
    On Windows, this will try to append each extension in the PATHEXT
2531
 
    environment variable to the name, if it cannot be found with the name
2532
 
    as given.
2533
 
 
2534
 
    :param name: The base name of the executable.
2535
 
    :return: The path to the executable found or None.
2536
 
    """
2537
 
    if sys.platform == 'win32':
2538
 
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
2539
 
        exts = [ext.lower() for ext in exts]
2540
 
        base, ext = os.path.splitext(name)
2541
 
        if ext != '':
2542
 
            if ext.lower() not in exts:
2543
 
                return None
2544
 
            name = base
2545
 
            exts = [ext]
2546
 
    else:
2547
 
        exts = ['']
2548
 
    path = os.environ.get('PATH')
2549
 
    if path is not None:
2550
 
        path = path.split(os.pathsep)
2551
 
        for ext in exts:
2552
 
            for d in path:
2553
 
                f = os.path.join(d, name) + ext
2554
 
                if os.access(f, os.X_OK):
2555
 
                    return f
2556
 
    if sys.platform == 'win32':
2557
 
        app_path = win32utils.get_app_path(name)
2558
 
        if app_path != name:
2559
 
            return app_path
2560
 
    return None
2561
 
 
2562
 
 
2563
 
def _posix_is_local_pid_dead(pid):
2564
 
    """True if pid doesn't correspond to live process on this machine"""
2565
 
    try:
2566
 
        # Special meaning of unix kill: just check if it's there.
2567
 
        os.kill(pid, 0)
2568
 
    except OSError as e:
2569
 
        if e.errno == errno.ESRCH:
2570
 
            # On this machine, and really not found: as sure as we can be
2571
 
            # that it's dead.
2572
 
            return True
2573
 
        elif e.errno == errno.EPERM:
2574
 
            # exists, though not ours
2575
 
            return False
2576
 
        else:
2577
 
            trace.mutter("os.kill(%d, 0) failed: %s" % (pid, e))
2578
 
            # Don't really know.
2579
 
            return False
2580
 
    else:
2581
 
        # Exists and our process: not dead.
2582
 
        return False
2583
 
 
2584
 
 
2585
 
if sys.platform == "win32":
2586
 
    is_local_pid_dead = win32utils.is_local_pid_dead
2587
 
else:
2588
 
    is_local_pid_dead = _posix_is_local_pid_dead
2589
 
 
2590
 
_maybe_ignored = ['EAGAIN', 'EINTR', 'ENOTSUP', 'EOPNOTSUPP', 'EACCES']
2591
 
_fdatasync_ignored = [getattr(errno, name) for name in _maybe_ignored
2592
 
                      if getattr(errno, name, None) is not None]
2593
 
 
2594
 
 
2595
 
def fdatasync(fileno):
2596
 
    """Flush file contents to disk if possible.
2597
 
 
2598
 
    :param fileno: Integer OS file handle.
2599
 
    :raises TransportNotPossible: If flushing to disk is not possible.
2600
 
    """
2601
 
    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))
2602
 
    if fn is not None:
2603
 
        try:
2604
 
            fn(fileno)
2605
 
        except IOError as e:
2606
 
            # See bug #1075108, on some platforms fdatasync exists, but can
2607
 
            # raise ENOTSUP. However, we are calling fdatasync to be helpful
2608
 
            # and reduce the chance of corruption-on-powerloss situations. It
2609
 
            # is not a mandatory call, so it is ok to suppress failures.
2610
 
            trace.mutter("ignoring error calling fdatasync: %s" % (e,))
2611
 
            if getattr(e, 'errno', None) not in _fdatasync_ignored:
2612
 
                raise
2613
 
 
2614
 
 
2615
 
def ensure_empty_directory_exists(path, exception_class):
2616
 
    """Make sure a local directory exists and is empty.
2617
 
 
2618
 
    If it does not exist, it is created.  If it exists and is not empty, an
2619
 
    instance of exception_class is raised.
2620
 
    """
2621
 
    try:
2622
 
        os.mkdir(path)
2623
 
    except OSError as e:
2624
 
        if e.errno != errno.EEXIST:
2625
 
            raise
2626
 
        if os.listdir(path) != []:
2627
 
            raise exception_class(path)
2628
 
 
2629
 
 
2630
 
def is_environment_error(evalue):
2631
 
    """True if exception instance is due to a process environment issue
2632
 
 
2633
 
    This includes OSError and IOError, but also other errors that come from
2634
 
    the operating system or core libraries but are not subclasses of those.
2635
 
    """
2636
 
    if isinstance(evalue, (EnvironmentError, select.error)):
2637
 
        return True
2638
 
    if sys.platform == "win32" and win32utils._is_pywintypes_error(evalue):
2639
 
        return True
2640
 
    return False
2641
 
 
2642
 
 
2643
 
def read_mtab(path):
2644
 
    """Read an fstab-style file and extract mountpoint+filesystem information.
2645
 
 
2646
 
    :param path: Path to read from
2647
 
    :yield: Tuples with mountpoints (as bytestrings) and filesystem names
2648
 
    """
2649
 
    with open(path, 'rb') as f:
2650
 
        for line in f:
2651
 
            if line.startswith(b'#'):
2652
 
                continue
2653
 
            cols = line.split()
2654
 
            if len(cols) < 3:
2655
 
                continue
2656
 
            yield cols[1], cols[2].decode('ascii', 'replace')
2657
 
 
2658
 
 
2659
 
MTAB_PATH = '/etc/mtab'
2660
 
 
2661
 
class FilesystemFinder(object):
2662
 
    """Find the filesystem for a particular path."""
2663
 
 
2664
 
    def __init__(self, mountpoints):
2665
 
        def key(x):
2666
 
            return len(x[0])
2667
 
        self._mountpoints = sorted(mountpoints, key=key, reverse=True)
2668
 
 
2669
 
    @classmethod
2670
 
    def from_mtab(cls):
2671
 
        """Create a FilesystemFinder from an mtab-style file.
2672
 
 
2673
 
        Note that this will silenty ignore mtab if it doesn't exist or can not
2674
 
        be opened.
2675
 
        """
2676
 
        # TODO(jelmer): Use inotify to be notified when /etc/mtab changes and
2677
 
        # we need to re-read it.
2678
 
        try:
2679
 
            return cls(read_mtab(MTAB_PATH))
2680
 
        except EnvironmentError as e:
2681
 
            trace.mutter('Unable to read mtab: %s', e)
2682
 
            return cls([])
2683
 
 
2684
 
    def find(self, path):
2685
 
        """Find the filesystem used by a particular path.
2686
 
 
2687
 
        :param path: Path to find (bytestring or text type)
2688
 
        :return: Filesystem name (as text type) or None, if the filesystem is
2689
 
            unknown.
2690
 
        """
2691
 
        for mountpoint, filesystem in self._mountpoints:
2692
 
            if is_inside(mountpoint, path):
2693
 
                return filesystem
2694
 
        return None
2695
 
 
2696
 
 
2697
 
_FILESYSTEM_FINDER = None
2698
 
 
2699
 
 
2700
 
def get_fs_type(path):
2701
 
    """Return the filesystem type for the partition a path is in.
2702
 
 
2703
 
    :param path: Path to search filesystem type for
2704
 
    :return: A FS type, as string. E.g. "ext2"
2705
 
    """
2706
 
    global _FILESYSTEM_FINDER
2707
 
    if _FILESYSTEM_FINDER is None:
2708
 
        _FILESYSTEM_FINDER = FilesystemFinder.from_mtab()
2709
 
 
2710
 
    if not isinstance(path, bytes):
2711
 
        path = path.encode(_fs_enc)
2712
 
 
2713
 
    return _FILESYSTEM_FINDER.find(path)
2714
 
 
2715
 
 
2716
 
if PY3:
2717
 
    perf_counter = time.perf_counter
2718
 
else:
2719
 
    perf_counter = time.clock
 
685
        raise IllegalPath(path)