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

s/follow_tree_references/recurse_nested/g

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/osutils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
 
19
import errno
17
20
import os
18
21
import re
19
22
import stat
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
21
23
import sys
22
24
import time
23
25
import codecs
24
26
 
25
 
from bzrlib.lazy_import import lazy_import
 
27
from .lazy_import import lazy_import
26
28
lazy_import(globals(), """
27
29
from datetime import datetime
28
 
import errno
29
30
import getpass
30
 
from ntpath import (abspath as _nt_abspath,
31
 
                    join as _nt_join,
32
 
                    normpath as _nt_normpath,
33
 
                    realpath as _nt_realpath,
34
 
                    splitdrive as _nt_splitdrive,
35
 
                    )
 
31
import locale
 
32
import ntpath
36
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
37
import shutil
38
 
from shutil import (
39
 
    rmtree,
40
 
    )
 
38
from shutil import rmtree
41
39
import socket
42
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
43
43
import tempfile
44
 
from tempfile import (
45
 
    mkdtemp,
46
 
    )
 
44
from tempfile import mkdtemp
47
45
import unicodedata
48
46
 
49
 
from bzrlib import (
50
 
    cache_utf8,
51
 
    errors,
 
47
from breezy import (
 
48
    config,
52
49
    trace,
53
50
    win32utils,
54
51
    )
 
52
from breezy.i18n import gettext
55
53
""")
56
54
 
57
 
from bzrlib.symbol_versioning import (
58
 
    deprecated_function,
59
 
    deprecated_in,
60
 
    )
61
 
 
62
 
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
63
 
# of 2.5
64
 
if sys.version_info < (2, 5):
65
 
    import md5 as _mod_md5
66
 
    md5 = _mod_md5.new
67
 
    import sha as _mod_sha
68
 
    sha = _mod_sha.new
69
 
else:
70
 
    from hashlib import (
71
 
        md5,
72
 
        sha1 as sha,
73
 
        )
74
 
 
75
 
 
76
 
import bzrlib
77
 
from bzrlib import symbol_versioning
78
 
 
79
 
 
80
 
# Cross platform wall-clock time functionality with decent resolution.
81
 
# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``
82
 
# only has a resolution of ~15ms. Note that ``time.clock()`` is not
83
 
# synchronized with ``time.time()``, this is only meant to be used to find
84
 
# delta times by subtracting from another call to this function.
85
 
timer_func = time.time
86
 
if sys.platform == 'win32':
87
 
    timer_func = time.clock
 
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
 
88
72
 
89
73
# On win32, O_BINARY is used to indicate the file should
90
74
# be opened in binary mode, rather than text mode.
97
81
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
98
82
 
99
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
 
100
93
def get_unicode_argv():
 
94
    if PY3:
 
95
        return sys.argv[1:]
101
96
    try:
102
97
        user_encoding = get_user_encoding()
103
98
        return [a.decode(user_encoding) for a in sys.argv[1:]]
104
99
    except UnicodeDecodeError:
105
 
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
106
 
                                                            "encoding." % a))
 
100
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
 
101
                                      "application locale.").format(a, user_encoding))
107
102
 
108
103
 
109
104
def make_readonly(filename):
110
105
    """Make a filename read-only."""
111
106
    mod = os.lstat(filename).st_mode
112
107
    if not stat.S_ISLNK(mod):
113
 
        mod = mod & 0777555
114
 
        os.chmod(filename, mod)
 
108
        mod = mod & 0o777555
 
109
        chmod_if_possible(filename, mod)
115
110
 
116
111
 
117
112
def make_writable(filename):
118
113
    mod = os.lstat(filename).st_mode
119
114
    if not stat.S_ISLNK(mod):
120
 
        mod = mod | 0200
121
 
        os.chmod(filename, 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
122
136
 
123
137
 
124
138
def minimum_path_selection(paths):
132
146
        return set(paths)
133
147
 
134
148
    def sort_key(path):
135
 
        return path.split('/')
 
149
        if isinstance(path, bytes):
 
150
            return path.split(b'/')
 
151
        else:
 
152
            return path.split('/')
136
153
    sorted_paths = sorted(list(paths), key=sort_key)
137
154
 
138
155
    search_paths = [sorted_paths[0]]
165
182
 
166
183
_directory_kind = 'directory'
167
184
 
 
185
 
168
186
def get_umask():
169
187
    """Return the current umask"""
170
188
    # Assume that people aren't messing with the umask while running
199
217
            stat = getattr(os, 'lstat', os.stat)
200
218
            stat(f)
201
219
            return True
202
 
        except OSError, e:
 
220
        except OSError as e:
203
221
            if e.errno == errno.ENOENT:
204
 
                return False;
 
222
                return False
205
223
            else:
206
 
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
 
224
                raise errors.BzrError(
 
225
                    gettext("lstat/stat of ({0!r}): {1!r}").format(f, e))
207
226
 
208
227
 
209
228
def fancy_rename(old, new, rename_func, unlink_func):
233
252
    file_existed = False
234
253
    try:
235
254
        rename_func(new, tmp_name)
236
 
    except (errors.NoSuchFile,), e:
 
255
    except (errors.NoSuchFile,):
237
256
        pass
238
 
    except IOError, e:
 
257
    except IOError as e:
239
258
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
240
259
        # function raises an IOError with errno is None when a rename fails.
241
260
        # This then gets caught here.
242
261
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
243
262
            raise
244
 
    except Exception, e:
 
263
    except Exception as e:
245
264
        if (getattr(e, 'errno', None) is None
246
 
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
265
                or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
247
266
            raise
248
267
    else:
249
268
        file_existed = True
250
269
 
251
 
    failure_exc = None
252
270
    success = False
253
271
    try:
254
 
        try:
255
 
            # This may throw an exception, in which case success will
256
 
            # not be set.
257
 
            rename_func(old, new)
258
 
            success = True
259
 
        except (IOError, OSError), e:
260
 
            # source and target may be aliases of each other (e.g. on a
261
 
            # case-insensitive filesystem), so we may have accidentally renamed
262
 
            # source by when we tried to rename target
263
 
            failure_exc = sys.exc_info()
264
 
            if (file_existed and e.errno in (None, errno.ENOENT)
 
272
        # This may throw an exception, in which case success will
 
273
        # not be set.
 
274
        rename_func(old, new)
 
275
        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)
265
281
                and old.lower() == new.lower()):
266
 
                # source and target are the same file on a case-insensitive
267
 
                # filesystem, so we don't generate an exception
268
 
                failure_exc = None
 
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
269
287
    finally:
270
288
        if file_existed:
271
289
            # If the file used to exist, rename it back into place
274
292
                unlink_func(tmp_name)
275
293
            else:
276
294
                rename_func(tmp_name, new)
277
 
    if failure_exc is not None:
278
 
        raise failure_exc[0], failure_exc[1], failure_exc[2]
279
295
 
280
296
 
281
297
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
282
298
# choke on a Unicode string containing a relative path if
283
299
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
284
300
# string.
285
 
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
286
301
def _posix_abspath(path):
287
302
    # jam 20060426 rather than encoding to fsencoding
288
303
    # copy posixpath.abspath, but use os.getcwdu instead
289
304
    if not posixpath.isabs(path):
290
305
        path = posixpath.join(getcwd(), path)
291
 
    return posixpath.normpath(path)
 
306
    return _posix_normpath(path)
292
307
 
293
308
 
294
309
def _posix_realpath(path):
295
310
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
296
311
 
297
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
 
298
368
def _win32_fixdrive(path):
299
369
    """Force drive letters to be consistent.
300
370
 
304
374
    running python.exe under cmd.exe return capital C:\\
305
375
    running win32 python inside a cygwin shell returns lowercase c:\\
306
376
    """
307
 
    drive, path = _nt_splitdrive(path)
 
377
    drive, path = ntpath.splitdrive(path)
308
378
    return drive.upper() + path
309
379
 
310
380
 
311
381
def _win32_abspath(path):
312
 
    # Real _nt_abspath doesn't have a problem with a unicode cwd
313
 
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
314
 
 
315
 
 
316
 
def _win98_abspath(path):
317
 
    """Return the absolute version of a path.
318
 
    Windows 98 safe implementation (python reimplementation
319
 
    of Win32 API function GetFullPathNameW)
320
 
    """
321
 
    # Corner cases:
322
 
    #   C:\path     => C:/path
323
 
    #   C:/path     => C:/path
324
 
    #   \\HOST\path => //HOST/path
325
 
    #   //HOST/path => //HOST/path
326
 
    #   path        => C:/cwd/path
327
 
    #   /path       => C:/path
328
 
    path = unicode(path)
329
 
    # check for absolute path
330
 
    drive = _nt_splitdrive(path)[0]
331
 
    if drive == '' and path[:2] not in('//','\\\\'):
332
 
        cwd = os.getcwdu()
333
 
        # we cannot simply os.path.join cwd and path
334
 
        # because os.path.join('C:','/path') produce '/path'
335
 
        # and this is incorrect
336
 
        if path[:1] in ('/','\\'):
337
 
            cwd = _nt_splitdrive(cwd)[0]
338
 
            path = path[1:]
339
 
        path = cwd + '\\' + path
340
 
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
 
382
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
 
383
    return _win32_fixdrive(ntpath.abspath(path).replace('\\', '/'))
341
384
 
342
385
 
343
386
def _win32_realpath(path):
344
 
    # Real _nt_realpath doesn't have a problem with a unicode cwd
345
 
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
 
387
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
 
388
    return _win32_fixdrive(ntpath.realpath(path).replace('\\', '/'))
346
389
 
347
390
 
348
391
def _win32_pathjoin(*args):
349
 
    return _nt_join(*args).replace('\\', '/')
 
392
    return ntpath.join(*args).replace('\\', '/')
350
393
 
351
394
 
352
395
def _win32_normpath(path):
353
 
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
 
396
    return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
354
397
 
355
398
 
356
399
def _win32_getcwd():
357
 
    return _win32_fixdrive(os.getcwdu().replace('\\', '/'))
 
400
    return _win32_fixdrive(_getcwd().replace('\\', '/'))
358
401
 
359
402
 
360
403
def _win32_mkdtemp(*args, **kwargs):
361
404
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
362
405
 
363
406
 
364
 
def _add_rename_error_details(e, old, new):
365
 
    new_e = OSError(e.errno, "failed to rename %s to %s: %s"
366
 
        % (old, new, e.strerror))
367
 
    new_e.filename = old
368
 
    new_e.to_filename = new
369
 
    return new_e
370
 
 
371
 
 
372
407
def _win32_rename(old, new):
373
408
    """We expect to be able to atomically replace 'new' with old.
374
409
 
376
411
    and then deleted.
377
412
    """
378
413
    try:
379
 
        fancy_rename(old, new, rename_func=_wrapped_rename, unlink_func=os.unlink)
380
 
    except OSError, e:
 
414
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
415
    except OSError as e:
381
416
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
382
417
            # If we try to rename a non-existant file onto cwd, we get
383
418
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT
387
422
        raise
388
423
 
389
424
 
390
 
def _wrapped_rename(old, new):
391
 
    """Rename a file or directory"""
392
 
    try:
393
 
        os.rename(old, new)
394
 
    except (IOError, OSError), e:
395
 
        # this is eventually called by all rename-like functions, so should 
396
 
        # catch all of them
397
 
        raise _add_rename_error_details(e, old, new)
398
 
 
399
 
 
400
425
def _mac_getcwd():
401
 
    return unicodedata.normalize('NFC', os.getcwdu())
402
 
 
 
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)
403
458
 
404
459
# Default is to just use the python builtins, but these can be rebound on
405
460
# particular platforms.
406
461
abspath = _posix_abspath
407
462
realpath = _posix_realpath
408
463
pathjoin = os.path.join
409
 
normpath = os.path.normpath
410
 
rename = _wrapped_rename # overridden below on win32
411
 
getcwd = os.getcwdu
 
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
412
469
dirname = os.path.dirname
413
470
basename = os.path.basename
414
471
split = os.path.split
415
472
splitext = os.path.splitext
416
 
# These were already imported into local scope
 
473
# These were already lazily imported into local scope
417
474
# mkdtemp = tempfile.mkdtemp
418
475
# rmtree = shutil.rmtree
 
476
lstat = os.lstat
 
477
fstat = os.fstat
 
478
 
 
479
 
 
480
def wrap_stat(st):
 
481
    return st
 
482
 
419
483
 
420
484
MIN_ABS_PATHLENGTH = 1
421
485
 
422
486
 
423
487
if sys.platform == 'win32':
424
 
    if win32utils.winver == 'Windows 98':
425
 
        abspath = _win98_abspath
426
 
    else:
427
 
        abspath = _win32_abspath
 
488
    abspath = _win32_abspath
428
489
    realpath = _win32_realpath
429
490
    pathjoin = _win32_pathjoin
430
491
    normpath = _win32_normpath
431
492
    getcwd = _win32_getcwd
432
493
    mkdtemp = _win32_mkdtemp
433
 
    rename = _win32_rename
 
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
434
503
 
435
504
    MIN_ABS_PATHLENGTH = 3
436
505
 
440
509
        """
441
510
        exception = excinfo[1]
442
511
        if function in (os.remove, os.rmdir) \
443
 
            and isinstance(exception, OSError) \
444
 
            and exception.errno == errno.EACCES:
 
512
                and isinstance(exception, OSError) \
 
513
                and exception.errno == errno.EACCES:
445
514
            make_writable(path)
446
515
            function(path)
447
516
        else:
454
523
    f = win32utils.get_unicode_argv     # special function or None
455
524
    if f is not None:
456
525
        get_unicode_argv = f
 
526
    path_from_environ = win32utils.get_environ_unicode
 
527
    _get_home_dir = win32utils.get_home_location
 
528
    getuser_unicode = win32utils.get_user_name
457
529
 
458
530
elif sys.platform == 'darwin':
459
531
    getcwd = _mac_getcwd
460
532
 
461
533
 
462
 
def get_terminal_encoding():
 
534
def get_terminal_encoding(trace=False):
463
535
    """Find the best encoding for printing to the screen.
464
536
 
465
537
    This attempts to check both sys.stdout and sys.stdin to see
471
543
 
472
544
    On my standard US Windows XP, the preferred encoding is
473
545
    cp1252, but the console is cp437
 
546
 
 
547
    :param trace: If True trace the selected encoding via mutter().
474
548
    """
475
 
    from bzrlib.trace import mutter
 
549
    from .trace import mutter
476
550
    output_encoding = getattr(sys.stdout, 'encoding', None)
477
551
    if not output_encoding:
478
552
        input_encoding = getattr(sys.stdin, 'encoding', None)
479
553
        if not input_encoding:
480
554
            output_encoding = get_user_encoding()
481
 
            mutter('encoding stdout as osutils.get_user_encoding() %r',
482
 
                   output_encoding)
 
555
            if trace:
 
556
                mutter('encoding stdout as osutils.get_user_encoding() %r',
 
557
                       output_encoding)
483
558
        else:
484
559
            output_encoding = input_encoding
485
 
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
 
560
            if trace:
 
561
                mutter('encoding stdout as sys.stdin encoding %r',
 
562
                       output_encoding)
486
563
    else:
487
 
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
564
        if trace:
 
565
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
488
566
    if output_encoding == 'cp0':
489
567
        # invalid encoding (cp0 means 'no codepage' on Windows)
490
568
        output_encoding = get_user_encoding()
491
 
        mutter('cp0 is invalid encoding.'
492
 
               ' encoding stdout as osutils.get_user_encoding() %r',
493
 
               output_encoding)
 
569
        if trace:
 
570
            mutter('cp0 is invalid encoding.'
 
571
                   ' encoding stdout as osutils.get_user_encoding() %r',
 
572
                   output_encoding)
494
573
    # check encoding
495
574
    try:
496
575
        codecs.lookup(output_encoding)
497
576
    except LookupError:
498
 
        sys.stderr.write('bzr: warning:'
 
577
        sys.stderr.write('brz: warning:'
499
578
                         ' unknown terminal encoding %s.\n'
500
579
                         '  Using encoding %s instead.\n'
501
580
                         % (output_encoding, get_user_encoding())
502
 
                        )
 
581
                         )
503
582
        output_encoding = get_user_encoding()
504
583
 
505
584
    return output_encoding
510
589
        F = realpath
511
590
    else:
512
591
        F = abspath
513
 
    [p,e] = os.path.split(f)
 
592
    [p, e] = os.path.split(f)
514
593
    if e == "" or e == "." or e == "..":
515
594
        return F(f)
516
595
    else:
520
599
def isdir(f):
521
600
    """True if f is an accessible directory."""
522
601
    try:
523
 
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
602
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
524
603
    except OSError:
525
604
        return False
526
605
 
528
607
def isfile(f):
529
608
    """True if f is a regular file."""
530
609
    try:
531
 
        return S_ISREG(os.lstat(f)[ST_MODE])
 
610
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
532
611
    except OSError:
533
612
        return False
534
613
 
 
614
 
535
615
def islink(f):
536
616
    """True if f is a symlink."""
537
617
    try:
538
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
618
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
539
619
    except OSError:
540
620
        return False
541
621
 
 
622
 
542
623
def is_inside(dir, fname):
543
624
    """True if fname is inside dir.
544
625
 
554
635
    if dir == fname:
555
636
        return True
556
637
 
557
 
    if dir == '':
 
638
    if dir in ('', b''):
558
639
        return True
559
640
 
560
 
    if dir[-1] != '/':
561
 
        dir += '/'
 
641
    if isinstance(dir, bytes):
 
642
        if not dir.endswith(b'/'):
 
643
            dir += b'/'
 
644
    else:
 
645
        if not dir.endswith('/'):
 
646
            dir += '/'
562
647
 
563
648
    return fname.startswith(dir)
564
649
 
637
722
    # writes fail on some platforms (e.g. Windows with SMB  mounted
638
723
    # drives).
639
724
    if not segment_size:
640
 
        segment_size = 5242880 # 5MB
641
 
    segments = range(len(bytes) / segment_size + 1)
 
725
        segment_size = 5242880  # 5MB
 
726
    offsets = range(0, len(bytes), segment_size)
 
727
    view = memoryview(bytes)
642
728
    write = file_handle.write
643
 
    for segment_index in segments:
644
 
        segment = buffer(bytes, segment_index * segment_size, segment_size)
645
 
        write(segment)
 
729
    for offset in offsets:
 
730
        write(view[offset:offset + segment_size])
646
731
 
647
732
 
648
733
def file_iterator(input_file, readsize=32768):
653
738
        yield b
654
739
 
655
740
 
 
741
# GZ 2017-09-16: Makes sense in general for hexdigest() result to be text, but
 
742
# used as bytes through most interfaces so encode with this wrapper.
 
743
if PY3:
 
744
    def _hexdigest(hashobj):
 
745
        return hashobj.hexdigest().encode()
 
746
else:
 
747
    def _hexdigest(hashobj):
 
748
        return hashobj.hexdigest()
 
749
 
 
750
 
656
751
def sha_file(f):
657
752
    """Calculate the hexdigest of an open file.
658
753
 
659
754
    The file cursor should be already at the start.
660
755
    """
661
756
    s = sha()
662
 
    BUFSIZE = 128<<10
 
757
    BUFSIZE = 128 << 10
663
758
    while True:
664
759
        b = f.read(BUFSIZE)
665
760
        if not b:
666
761
            break
667
762
        s.update(b)
668
 
    return s.hexdigest()
 
763
    return _hexdigest(s)
669
764
 
670
765
 
671
766
def size_sha_file(f):
676
771
    """
677
772
    size = 0
678
773
    s = sha()
679
 
    BUFSIZE = 128<<10
 
774
    BUFSIZE = 128 << 10
680
775
    while True:
681
776
        b = f.read(BUFSIZE)
682
777
        if not b:
683
778
            break
684
779
        size += len(b)
685
780
        s.update(b)
686
 
    return size, s.hexdigest()
 
781
    return size, _hexdigest(s)
687
782
 
688
783
 
689
784
def sha_file_by_name(fname):
692
787
    f = os.open(fname, os.O_RDONLY | O_BINARY | O_NOINHERIT)
693
788
    try:
694
789
        while True:
695
 
            b = os.read(f, 1<<16)
 
790
            b = os.read(f, 1 << 16)
696
791
            if not b:
697
 
                return s.hexdigest()
 
792
                return _hexdigest(s)
698
793
            s.update(b)
699
794
    finally:
700
795
        os.close(f)
703
798
def sha_strings(strings, _factory=sha):
704
799
    """Return the sha-1 of concatenation of strings"""
705
800
    s = _factory()
706
 
    map(s.update, strings)
707
 
    return s.hexdigest()
 
801
    for string in strings:
 
802
        s.update(string)
 
803
    return _hexdigest(s)
708
804
 
709
805
 
710
806
def sha_string(f, _factory=sha):
711
 
    return _factory(f).hexdigest()
 
807
    # GZ 2017-09-16: Dodgy if factory is ever not sha, probably shouldn't be.
 
808
    return _hexdigest(_factory(f))
712
809
 
713
810
 
714
811
def fingerprint_file(f):
715
812
    b = f.read()
716
813
    return {'size': len(b),
717
 
            'sha1': sha(b).hexdigest()}
 
814
            'sha1': _hexdigest(sha(b))}
718
815
 
719
816
 
720
817
def compare_files(a, b):
725
822
        bi = b.read(BUFSIZE)
726
823
        if ai != bi:
727
824
            return False
728
 
        if ai == '':
 
825
        if not ai:
729
826
            return True
730
827
 
731
828
 
736
833
    offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
737
834
    return offset.days * 86400 + offset.seconds
738
835
 
 
836
 
739
837
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
740
838
_default_format_by_weekday_num = [wd + " %Y-%m-%d %H:%M:%S" for wd in weekdays]
741
839
 
753
851
    :param show_offset: Whether to append the timezone.
754
852
    """
755
853
    (date_fmt, tt, offset_str) = \
756
 
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
854
        _format_date(t, offset, timezone, date_fmt, show_offset)
757
855
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
758
856
    date_str = time.strftime(date_fmt, tt)
759
857
    return date_str + offset_str
764
862
 
765
863
 
766
864
def format_date_with_offset_in_original_timezone(t, offset=0,
767
 
    _cache=_offset_cache):
 
865
                                                 _cache=_offset_cache):
768
866
    """Return a formatted date string in the original timezone.
769
867
 
770
868
    This routine may be faster then format_date.
797
895
    :param show_offset: Whether to append the timezone.
798
896
    """
799
897
    (date_fmt, tt, offset_str) = \
800
 
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
898
        _format_date(t, offset, timezone, date_fmt, show_offset)
801
899
    date_str = time.strftime(date_fmt, tt)
802
 
    if not isinstance(date_str, unicode):
 
900
    if not isinstance(date_str, text_type):
803
901
        date_str = date_str.decode(get_user_encoding(), 'replace')
804
902
    return date_str + offset_str
805
903
 
816
914
        tt = time.localtime(t)
817
915
        offset = local_time_offset(t)
818
916
    else:
819
 
        raise errors.UnsupportedTimezoneFormat(timezone)
 
917
        raise UnsupportedTimezoneFormat(timezone)
820
918
    if date_fmt is None:
821
919
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
822
920
    if show_offset:
846
944
        delta = -delta
847
945
 
848
946
    seconds = delta
849
 
    if seconds < 90: # print seconds up to 90 seconds
 
947
    if seconds < 90:  # print seconds up to 90 seconds
850
948
        if seconds == 1:
851
949
            return '%d second %s' % (seconds, direction,)
852
950
        else:
858
956
        plural_seconds = ''
859
957
    else:
860
958
        plural_seconds = 's'
861
 
    if minutes < 90: # print minutes, seconds up to 90 minutes
 
959
    if minutes < 90:  # print minutes, seconds up to 90 minutes
862
960
        if minutes == 1:
863
961
            return '%d minute, %d second%s %s' % (
864
 
                    minutes, seconds, plural_seconds, direction)
 
962
                minutes, seconds, plural_seconds, direction)
865
963
        else:
866
964
            return '%d minutes, %d second%s %s' % (
867
 
                    minutes, seconds, plural_seconds, direction)
 
965
                minutes, seconds, plural_seconds, direction)
868
966
 
869
967
    hours = int(minutes / 60)
870
968
    minutes -= 60 * hours
879
977
    return '%d hours, %d minute%s %s' % (hours, minutes,
880
978
                                         plural_minutes, direction)
881
979
 
 
980
 
882
981
def filesize(f):
883
982
    """Return size of given open file."""
884
 
    return os.fstat(f.fileno())[ST_SIZE]
885
 
 
886
 
 
887
 
# Define rand_bytes based on platform.
888
 
try:
889
 
    # Python 2.4 and later have os.urandom,
890
 
    # but it doesn't work on some arches
891
 
    os.urandom(1)
892
 
    rand_bytes = os.urandom
893
 
except (NotImplementedError, AttributeError):
894
 
    # If python doesn't have os.urandom, or it doesn't work,
895
 
    # then try to first pull random data from /dev/urandom
 
983
    return os.fstat(f.fileno())[stat.ST_SIZE]
 
984
 
 
985
 
 
986
# Alias os.urandom to support platforms (which?) without /dev/urandom and
 
987
# override if it doesn't work. Avoid checking on windows where there is
 
988
# significant initialisation cost that can be avoided for some bzr calls.
 
989
 
 
990
rand_bytes = os.urandom
 
991
 
 
992
if rand_bytes.__module__ != "nt":
896
993
    try:
897
 
        rand_bytes = file('/dev/urandom', 'rb').read
898
 
    # Otherwise, use this hack as a last resort
899
 
    except (IOError, OSError):
 
994
        rand_bytes(1)
 
995
    except NotImplementedError:
900
996
        # not well seeded, but better than nothing
901
997
        def rand_bytes(n):
902
998
            import random
908
1004
 
909
1005
 
910
1006
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
 
1007
 
 
1008
 
911
1009
def rand_chars(num):
912
1010
    """Return a random string of num alphanumeric characters
913
1011
 
916
1014
    """
917
1015
    s = ''
918
1016
    for raw_byte in rand_bytes(num):
919
 
        s += ALNUM[ord(raw_byte) % 36]
 
1017
        if not PY3:
 
1018
            s += ALNUM[ord(raw_byte) % 36]
 
1019
        else:
 
1020
            s += ALNUM[raw_byte % 36]
920
1021
    return s
921
1022
 
922
1023
 
923
 
## TODO: We could later have path objects that remember their list
924
 
## decomposition (might be too tricksy though.)
 
1024
# TODO: We could later have path objects that remember their list
 
1025
# decomposition (might be too tricksy though.)
925
1026
 
926
1027
def splitpath(p):
927
1028
    """Turn string into list of parts."""
928
 
    # split on either delimiter because people might use either on
929
 
    # Windows
930
 
    ps = re.split(r'[\\/]', p)
 
1029
    use_bytes = isinstance(p, bytes)
 
1030
    if os.path.sep == '\\':
 
1031
        # split on either delimiter because people might use either on
 
1032
        # Windows
 
1033
        if use_bytes:
 
1034
            ps = re.split(b'[\\\\/]', p)
 
1035
        else:
 
1036
            ps = re.split(r'[\\/]', p)
 
1037
    else:
 
1038
        if use_bytes:
 
1039
            ps = p.split(b'/')
 
1040
        else:
 
1041
            ps = p.split('/')
 
1042
 
 
1043
    if use_bytes:
 
1044
        parent_dir = b'..'
 
1045
        current_empty_dir = (b'.', b'')
 
1046
    else:
 
1047
        parent_dir = '..'
 
1048
        current_empty_dir = ('.', '')
931
1049
 
932
1050
    rps = []
933
1051
    for f in ps:
934
 
        if f == '..':
935
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
936
 
        elif (f == '.') or (f == ''):
 
1052
        if f == parent_dir:
 
1053
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
1054
        elif f in current_empty_dir:
937
1055
            pass
938
1056
        else:
939
1057
            rps.append(f)
943
1061
def joinpath(p):
944
1062
    for f in p:
945
1063
        if (f == '..') or (f is None) or (f == ''):
946
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
1064
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
947
1065
    return pathjoin(*p)
948
1066
 
949
1067
 
950
1068
def parent_directories(filename):
951
1069
    """Return the list of parent directories, deepest first.
952
 
    
 
1070
 
953
1071
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
954
1072
    """
955
1073
    parents = []
971
1089
    implementation should be loaded instead::
972
1090
 
973
1091
    >>> try:
974
 
    >>>     import bzrlib._fictional_extension_pyx
 
1092
    >>>     import breezy._fictional_extension_pyx
975
1093
    >>> except ImportError, e:
976
 
    >>>     bzrlib.osutils.failed_to_load_extension(e)
977
 
    >>>     import bzrlib._fictional_extension_py
 
1094
    >>>     breezy.osutils.failed_to_load_extension(e)
 
1095
    >>>     import breezy._fictional_extension_py
978
1096
    """
979
1097
    # NB: This docstring is just an example, not a doctest, because doctest
980
1098
    # currently can't cope with the use of lazy imports in this namespace --
981
1099
    # mbp 20090729
982
 
    
 
1100
 
983
1101
    # This currently doesn't report the failure at the time it occurs, because
984
1102
    # they tend to happen very early in startup when we can't check config
985
1103
    # files etc, and also we want to report all failures but not spam the user
986
1104
    # with 10 warnings.
987
 
    from bzrlib import trace
988
1105
    exception_str = str(exception)
989
1106
    if exception_str not in _extension_load_failures:
990
1107
        trace.mutter("failed to load compiled extension: %s" % exception_str)
994
1111
def report_extension_load_failures():
995
1112
    if not _extension_load_failures:
996
1113
        return
997
 
    from bzrlib.config import GlobalConfig
998
 
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
 
1114
    if config.GlobalConfig().suppress_warning('missing_extensions'):
999
1115
        return
1000
1116
    # the warnings framework should by default show this only once
1001
 
    from bzrlib.trace import warning
 
1117
    from .trace import warning
1002
1118
    warning(
1003
 
        "bzr: warning: some compiled extensions could not be loaded; "
1004
 
        "see <https://answers.launchpad.net/bzr/+faq/703>")
 
1119
        "brz: warning: some compiled extensions could not be loaded; "
 
1120
        "see ``brz help missing-extensions``")
1005
1121
    # we no longer show the specific missing extensions here, because it makes
1006
1122
    # the message too long and scary - see
1007
1123
    # https://bugs.launchpad.net/bzr/+bug/430529
1008
1124
 
1009
1125
 
1010
1126
try:
1011
 
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1012
 
except ImportError, e:
 
1127
    from ._chunks_to_lines_pyx import chunks_to_lines
 
1128
except ImportError as e:
1013
1129
    failed_to_load_extension(e)
1014
 
    from bzrlib._chunks_to_lines_py import chunks_to_lines
 
1130
    from ._chunks_to_lines_py import chunks_to_lines
1015
1131
 
1016
1132
 
1017
1133
def split_lines(s):
1018
1134
    """Split s into lines, but without removing the newline characters."""
1019
1135
    # Trivially convert a fulltext into a 'chunked' representation, and let
1020
1136
    # chunks_to_lines do the heavy lifting.
1021
 
    if isinstance(s, str):
 
1137
    if isinstance(s, bytes):
1022
1138
        # chunks_to_lines only supports 8-bit strings
1023
1139
        return chunks_to_lines([s])
1024
1140
    else:
1030
1146
 
1031
1147
    This supports Unicode or plain string objects.
1032
1148
    """
1033
 
    lines = s.split('\n')
1034
 
    result = [line + '\n' for line in lines[:-1]]
 
1149
    nl = b'\n' if isinstance(s, bytes) else u'\n'
 
1150
    lines = s.split(nl)
 
1151
    result = [line + nl for line in lines[:-1]]
1035
1152
    if lines[-1]:
1036
1153
        result.append(lines[-1])
1037
1154
    return result
1048
1165
        return
1049
1166
    try:
1050
1167
        os.link(src, dest)
1051
 
    except (OSError, IOError), e:
 
1168
    except (OSError, IOError) as e:
1052
1169
        if e.errno != errno.EXDEV:
1053
1170
            raise
1054
1171
        shutil.copyfile(src, dest)
1055
1172
 
1056
1173
 
1057
1174
def delete_any(path):
1058
 
    """Delete a file, symlink or directory.  
1059
 
    
 
1175
    """Delete a file, symlink or directory.
 
1176
 
1060
1177
    Will delete even if readonly.
1061
1178
    """
1062
1179
    try:
1063
 
       _delete_file_or_dir(path)
1064
 
    except (OSError, IOError), e:
 
1180
        _delete_file_or_dir(path)
 
1181
    except (OSError, IOError) as e:
1065
1182
        if e.errno in (errno.EPERM, errno.EACCES):
1066
1183
            # make writable and try again
1067
1184
            try:
1079
1196
    # - root can damage a solaris file system by using unlink,
1080
1197
    # - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
1081
1198
    #   EACCES, OSX: EPERM) when invoked on a directory.
1082
 
    if isdir(path): # Takes care of symlinks
 
1199
    if isdir(path):  # Takes care of symlinks
1083
1200
        os.rmdir(path)
1084
1201
    else:
1085
1202
        os.unlink(path)
1127
1244
    #    separators
1128
1245
    # 3) '\xa0' isn't unicode safe since it is >128.
1129
1246
 
1130
 
    # This should *not* be a unicode set of characters in case the source
1131
 
    # string is not a Unicode string. We can auto-up-cast the characters since
1132
 
    # they are ascii, but we don't want to auto-up-cast the string in case it
1133
 
    # is utf-8
1134
 
    for ch in ' \t\n\r\v\f':
 
1247
    if isinstance(s, str):
 
1248
        ws = ' \t\n\r\v\f'
 
1249
    else:
 
1250
        ws = (b' ', b'\t', b'\n', b'\r', b'\v', b'\f')
 
1251
    for ch in ws:
1135
1252
        if ch in s:
1136
1253
            return True
1137
1254
    else:
1163
1280
 
1164
1281
    if len(base) < MIN_ABS_PATHLENGTH:
1165
1282
        # must have space for e.g. a drive letter
1166
 
        raise ValueError('%r is too short to calculate a relative path'
1167
 
            % (base,))
 
1283
        raise ValueError(gettext('%r is too short to calculate a relative path')
 
1284
                         % (base,))
1168
1285
 
1169
1286
    rp = abspath(path)
1170
1287
 
1215
1332
        lbit = bit.lower()
1216
1333
        try:
1217
1334
            next_entries = _listdir(current)
1218
 
        except OSError: # enoent, eperm, etc
 
1335
        except OSError:  # enoent, eperm, etc
1219
1336
            # We can't find this in the filesystem, so just append the
1220
1337
            # remaining bits.
1221
1338
            current = pathjoin(current, bit, *list(bit_iter))
1232
1349
            break
1233
1350
    return current[len(abs_base):].lstrip('/')
1234
1351
 
 
1352
 
1235
1353
# XXX - TODO - we need better detection/integration of case-insensitive
1236
1354
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
1237
1355
# filesystems), for example, so could probably benefit from the same basic
1242
1360
else:
1243
1361
    canonical_relpath = relpath
1244
1362
 
 
1363
 
1245
1364
def canonical_relpaths(base, paths):
1246
1365
    """Create an iterable to canonicalize a sequence of relative paths.
1247
1366
 
1251
1370
    # but for now, we haven't optimized...
1252
1371
    return [canonical_relpath(base, p) for p in paths]
1253
1372
 
 
1373
 
 
1374
def decode_filename(filename):
 
1375
    """Decode the filename using the filesystem encoding
 
1376
 
 
1377
    If it is unicode, it is returned.
 
1378
    Otherwise it is decoded from the the filesystem's encoding. If decoding
 
1379
    fails, a errors.BadFilenameEncoding exception is raised.
 
1380
    """
 
1381
    if isinstance(filename, text_type):
 
1382
        return filename
 
1383
    try:
 
1384
        return filename.decode(_fs_enc)
 
1385
    except UnicodeDecodeError:
 
1386
        raise errors.BadFilenameEncoding(filename, _fs_enc)
 
1387
 
 
1388
 
1254
1389
def safe_unicode(unicode_or_utf8_string):
1255
1390
    """Coerce unicode_or_utf8_string into unicode.
1256
1391
 
1258
1393
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
1259
1394
    wrapped in a BzrBadParameterNotUnicode exception.
1260
1395
    """
1261
 
    if isinstance(unicode_or_utf8_string, unicode):
 
1396
    if isinstance(unicode_or_utf8_string, text_type):
1262
1397
        return unicode_or_utf8_string
1263
1398
    try:
1264
1399
        return unicode_or_utf8_string.decode('utf8')
1272
1407
    If it is a str, it is returned.
1273
1408
    If it is Unicode, it is encoded into a utf-8 string.
1274
1409
    """
1275
 
    if isinstance(unicode_or_utf8_string, str):
 
1410
    if isinstance(unicode_or_utf8_string, bytes):
1276
1411
        # TODO: jam 20070209 This is overkill, and probably has an impact on
1277
1412
        #       performance if we are dealing with lots of apis that want a
1278
1413
        #       utf-8 revision id
1285
1420
    return unicode_or_utf8_string.encode('utf-8')
1286
1421
 
1287
1422
 
1288
 
_revision_id_warning = ('Unicode revision ids were deprecated in bzr 0.15.'
1289
 
                        ' Revision id generators should be creating utf8'
1290
 
                        ' revision ids.')
1291
 
 
1292
 
 
1293
 
def safe_revision_id(unicode_or_utf8_string, warn=True):
 
1423
def safe_revision_id(unicode_or_utf8_string):
1294
1424
    """Revision ids should now be utf8, but at one point they were unicode.
1295
1425
 
1296
1426
    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be
1297
1427
        utf8 or None).
1298
 
    :param warn: Functions that are sanitizing user data can set warn=False
1299
1428
    :return: None or a utf8 revision id.
1300
1429
    """
1301
1430
    if (unicode_or_utf8_string is None
1302
 
        or unicode_or_utf8_string.__class__ == str):
 
1431
            or unicode_or_utf8_string.__class__ == bytes):
1303
1432
        return unicode_or_utf8_string
1304
 
    if warn:
1305
 
        symbol_versioning.warn(_revision_id_warning, DeprecationWarning,
1306
 
                               stacklevel=2)
1307
 
    return cache_utf8.encode(unicode_or_utf8_string)
1308
 
 
1309
 
 
1310
 
_file_id_warning = ('Unicode file ids were deprecated in bzr 0.15. File id'
1311
 
                    ' generators should be creating utf8 file ids.')
1312
 
 
1313
 
 
1314
 
def safe_file_id(unicode_or_utf8_string, warn=True):
 
1433
    raise TypeError('Unicode revision ids are no longer supported. '
 
1434
                    'Revision id generators should be creating utf8 revision '
 
1435
                    'ids.')
 
1436
 
 
1437
 
 
1438
def safe_file_id(unicode_or_utf8_string):
1315
1439
    """File ids should now be utf8, but at one point they were unicode.
1316
1440
 
1317
1441
    This is the same as safe_utf8, except it uses the cached encode functions
1319
1443
 
1320
1444
    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be
1321
1445
        utf8 or None).
1322
 
    :param warn: Functions that are sanitizing user data can set warn=False
1323
1446
    :return: None or a utf8 file id.
1324
1447
    """
1325
1448
    if (unicode_or_utf8_string is None
1326
 
        or unicode_or_utf8_string.__class__ == str):
 
1449
            or unicode_or_utf8_string.__class__ == bytes):
1327
1450
        return unicode_or_utf8_string
1328
 
    if warn:
1329
 
        symbol_versioning.warn(_file_id_warning, DeprecationWarning,
1330
 
                               stacklevel=2)
1331
 
    return cache_utf8.encode(unicode_or_utf8_string)
 
1451
    raise TypeError('Unicode file ids are no longer supported. '
 
1452
                    'File id generators should be creating utf8 file ids.')
1332
1453
 
1333
1454
 
1334
1455
_platform_normalizes_filenames = False
1339
1460
def normalizes_filenames():
1340
1461
    """Return True if this platform normalizes unicode filenames.
1341
1462
 
1342
 
    Mac OSX does, Windows/Linux do not.
 
1463
    Only Mac OSX.
1343
1464
    """
1344
1465
    return _platform_normalizes_filenames
1345
1466
 
1350
1471
    On platforms where the system normalizes filenames (Mac OSX),
1351
1472
    you can access a file by any path which will normalize correctly.
1352
1473
    On platforms where the system does not normalize filenames
1353
 
    (Windows, Linux), you have to access a file by its exact path.
 
1474
    (everything else), you have to access a file by its exact path.
1354
1475
 
1355
1476
    Internally, bzr only supports NFC normalization, since that is
1356
1477
    the standard for XML documents.
1359
1480
    can be accessed by that path.
1360
1481
    """
1361
1482
 
1362
 
    return unicodedata.normalize('NFC', unicode(path)), True
 
1483
    if isinstance(path, bytes):
 
1484
        path = path.decode(sys.getfilesystemencoding())
 
1485
    return unicodedata.normalize('NFC', path), True
1363
1486
 
1364
1487
 
1365
1488
def _inaccessible_normalized_filename(path):
1366
1489
    __doc__ = _accessible_normalized_filename.__doc__
1367
1490
 
1368
 
    normalized = unicodedata.normalize('NFC', unicode(path))
 
1491
    if isinstance(path, bytes):
 
1492
        path = path.decode(sys.getfilesystemencoding())
 
1493
    normalized = unicodedata.normalize('NFC', path)
1369
1494
    return normalized, normalized == path
1370
1495
 
1371
1496
 
1394
1519
    except AttributeError:
1395
1520
        # siginterrupt doesn't exist on this platform, or for this version
1396
1521
        # of Python.
1397
 
        siginterrupt = lambda signum, flag: None
 
1522
        def siginterrupt(signum, flag): return None
1398
1523
    if restart_syscall:
1399
1524
        def sig_handler(*args):
1400
1525
            # Python resets the siginterrupt flag when a signal is
1418
1543
terminal_width() returns None.
1419
1544
"""
1420
1545
 
 
1546
# Keep some state so that terminal_width can detect if _terminal_size has
 
1547
# returned a different size since the process started.  See docstring and
 
1548
# comments of terminal_width for details.
 
1549
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
 
1550
_terminal_size_state = 'no_data'
 
1551
_first_terminal_size = None
 
1552
 
1421
1553
 
1422
1554
def terminal_width():
1423
1555
    """Return terminal width.
1425
1557
    None is returned if the width can't established precisely.
1426
1558
 
1427
1559
    The rules are:
1428
 
    - if BZR_COLUMNS is set, returns its value
 
1560
    - if BRZ_COLUMNS is set, returns its value
1429
1561
    - if there is no controlling terminal, returns None
 
1562
    - query the OS, if the queried size has changed since the last query,
 
1563
      return its value,
1430
1564
    - if COLUMNS is set, returns its value,
 
1565
    - if the OS has a value (even though it's never changed), return its value.
1431
1566
 
1432
1567
    From there, we need to query the OS to get the size of the controlling
1433
1568
    terminal.
1434
1569
 
1435
 
    Unices:
 
1570
    On Unices we query the OS by:
1436
1571
    - get termios.TIOCGWINSZ
1437
1572
    - if an error occurs or a negative value is obtained, returns None
1438
1573
 
1439
 
    Windows:
1440
 
    
 
1574
    On Windows we query the OS by:
1441
1575
    - win32utils.get_console_size() decides,
1442
1576
    - returns None on error (provided default value)
1443
1577
    """
 
1578
    # Note to implementors: if changing the rules for determining the width,
 
1579
    # make sure you've considered the behaviour in these cases:
 
1580
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
 
1581
    #  - brz log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
 
1582
    #    0,0.
 
1583
    #  - (add more interesting cases here, if you find any)
 
1584
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
 
1585
    # but we don't want to register a signal handler because it is impossible
 
1586
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
 
1587
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
 
1588
    # time so we can notice if the reported size has changed, which should have
 
1589
    # a similar effect.
1444
1590
 
1445
 
    # If BZR_COLUMNS is set, take it, user is always right
 
1591
    # If BRZ_COLUMNS is set, take it, user is always right
 
1592
    # Except if they specified 0 in which case, impose no limit here
1446
1593
    try:
1447
 
        return int(os.environ['BZR_COLUMNS'])
 
1594
        width = int(os.environ['BRZ_COLUMNS'])
1448
1595
    except (KeyError, ValueError):
1449
 
        pass
 
1596
        width = None
 
1597
    if width is not None:
 
1598
        if width > 0:
 
1599
            return width
 
1600
        else:
 
1601
            return None
1450
1602
 
1451
1603
    isatty = getattr(sys.stdout, 'isatty', None)
1452
 
    if  isatty is None or not isatty():
1453
 
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
 
1604
    if isatty is None or not isatty():
 
1605
        # Don't guess, setting BRZ_COLUMNS is the recommended way to override.
1454
1606
        return None
1455
1607
 
1456
 
    # If COLUMNS is set, take it, the terminal knows better (even inside a
1457
 
    # given terminal, the application can decide to set COLUMNS to a lower
1458
 
    # value (splitted screen) or a bigger value (scroll bars))
 
1608
    # Query the OS
 
1609
    width, height = os_size = _terminal_size(None, None)
 
1610
    global _first_terminal_size, _terminal_size_state
 
1611
    if _terminal_size_state == 'no_data':
 
1612
        _first_terminal_size = os_size
 
1613
        _terminal_size_state = 'unchanged'
 
1614
    elif (_terminal_size_state == 'unchanged' and
 
1615
          _first_terminal_size != os_size):
 
1616
        _terminal_size_state = 'changed'
 
1617
 
 
1618
    # If the OS claims to know how wide the terminal is, and this value has
 
1619
    # ever changed, use that.
 
1620
    if _terminal_size_state == 'changed':
 
1621
        if width is not None and width > 0:
 
1622
            return width
 
1623
 
 
1624
    # If COLUMNS is set, use it.
1459
1625
    try:
1460
1626
        return int(os.environ['COLUMNS'])
1461
1627
    except (KeyError, ValueError):
1462
1628
        pass
1463
1629
 
1464
 
    width, height = _terminal_size(None, None)
1465
 
    if width <= 0:
1466
 
        # Consider invalid values as meaning no width
1467
 
        return None
 
1630
    # Finally, use an unchanged size from the OS, if we have one.
 
1631
    if _terminal_size_state == 'unchanged':
 
1632
        if width is not None and width > 0:
 
1633
            return width
1468
1634
 
1469
 
    return width
 
1635
    # The width could not be determined.
 
1636
    return None
1470
1637
 
1471
1638
 
1472
1639
def _win32_terminal_size(width, height):
1473
 
    width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
 
1640
    width, height = win32utils.get_console_size(
 
1641
        defaultx=width, defaulty=height)
1474
1642
    return width, height
1475
1643
 
1476
1644
 
1477
1645
def _ioctl_terminal_size(width, height):
1478
1646
    try:
1479
 
        import struct, fcntl, termios
 
1647
        import struct
 
1648
        import fcntl
 
1649
        import termios
1480
1650
        s = struct.pack('HHHH', 0, 0, 0, 0)
1481
1651
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1482
1652
        height, width = struct.unpack('HHHH', x)[0:2]
1484
1654
        pass
1485
1655
    return width, height
1486
1656
 
 
1657
 
1487
1658
_terminal_size = None
1488
1659
"""Returns the terminal size as (width, height).
1489
1660
 
1499
1670
    _terminal_size = _ioctl_terminal_size
1500
1671
 
1501
1672
 
1502
 
def _terminal_size_changed(signum, frame):
1503
 
    """Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
1504
 
    width, height = _terminal_size(None, None)
1505
 
    if width is not None:
1506
 
        os.environ['COLUMNS'] = str(width)
1507
 
 
1508
 
 
1509
 
_registered_sigwinch = False
1510
 
def watch_sigwinch():
1511
 
    """Register for SIGWINCH, once and only once.
1512
 
 
1513
 
    Do nothing if the signal module is not available.
1514
 
    """
1515
 
    global _registered_sigwinch
1516
 
    if not _registered_sigwinch:
1517
 
        try:
1518
 
            import signal
1519
 
            if getattr(signal, "SIGWINCH", None) is not None:
1520
 
                set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
1521
 
        except ImportError:
1522
 
            # python doesn't provide signal support, nothing we can do about it
1523
 
            pass
1524
 
        _registered_sigwinch = True
1525
 
 
1526
 
 
1527
 
def supports_executable():
1528
 
    return sys.platform != "win32"
 
1673
def supports_executable(path):
 
1674
    """Return if filesystem at path supports executable bit.
 
1675
 
 
1676
    :param path: Path for which to check the file system
 
1677
    :return: boolean indicating whether executable bit can be stored/relied upon
 
1678
    """
 
1679
    if sys.platform == 'win32':
 
1680
        return False
 
1681
    try:
 
1682
        fs_type = get_fs_type(path)
 
1683
    except errors.DependencyNotPresent as e:
 
1684
        trace.mutter('Unable to get fs type for %r: %s', path, e)
 
1685
    else:
 
1686
        if fs_type in ('vfat', 'ntfs'):
 
1687
            # filesystems known to not support executable bit
 
1688
            return False
 
1689
    return True
 
1690
 
 
1691
 
 
1692
def supports_symlinks(path):
 
1693
    """Return if the filesystem at path supports the creation of symbolic links.
 
1694
 
 
1695
    """
 
1696
    if not has_symlinks():
 
1697
        return False
 
1698
    try:
 
1699
        fs_type = get_fs_type(path)
 
1700
    except errors.DependencyNotPresent as e:
 
1701
        trace.mutter('Unable to get fs type for %r: %s', path, e)
 
1702
    else:
 
1703
        if fs_type in ('vfat', 'ntfs'):
 
1704
            # filesystems known to not support symlinks
 
1705
            return False
 
1706
    return True
1529
1707
 
1530
1708
 
1531
1709
def supports_posix_readonly():
1554
1732
        if orig_val is not None:
1555
1733
            del os.environ[env_variable]
1556
1734
    else:
1557
 
        if isinstance(value, unicode):
 
1735
        if not PY3 and isinstance(value, text_type):
1558
1736
            value = value.encode(get_user_encoding())
1559
1737
        os.environ[env_variable] = value
1560
1738
    return orig_val
1574
1752
        raise errors.IllegalPath(path)
1575
1753
 
1576
1754
 
1577
 
_WIN32_ERROR_DIRECTORY = 267 # Similar to errno.ENOTDIR
 
1755
_WIN32_ERROR_DIRECTORY = 267  # Similar to errno.ENOTDIR
 
1756
 
1578
1757
 
1579
1758
def _is_error_enotdir(e):
1580
1759
    """Check if this exception represents ENOTDIR.
1592
1771
    :return: True if this represents an ENOTDIR error. False otherwise.
1593
1772
    """
1594
1773
    en = getattr(e, 'errno', None)
1595
 
    if (en == errno.ENOTDIR
1596
 
        or (sys.platform == 'win32'
1597
 
            and (en == _WIN32_ERROR_DIRECTORY
1598
 
                 or (en == errno.EINVAL
1599
 
                     and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
1600
 
        ))):
 
1774
    if (en == errno.ENOTDIR or
 
1775
        (sys.platform == 'win32' and
 
1776
            (en == _WIN32_ERROR_DIRECTORY or
 
1777
             (en == errno.EINVAL
 
1778
              and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
 
1779
             ))):
1601
1780
        return True
1602
1781
    return False
1603
1782
 
1630
1809
        rooted higher up.
1631
1810
    :return: an iterator over the dirs.
1632
1811
    """
1633
 
    #TODO there is a bit of a smell where the results of the directory-
 
1812
    # TODO there is a bit of a smell where the results of the directory-
1634
1813
    # summary in this, and the path from the root, may not agree
1635
1814
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
1636
1815
    # potentially confusing output. We should make this more robust - but
1652
1831
        dirblock = []
1653
1832
        append = dirblock.append
1654
1833
        try:
1655
 
            names = sorted(_listdir(top))
1656
 
        except OSError, e:
 
1834
            names = sorted(map(decode_filename, _listdir(top)))
 
1835
        except OSError as e:
1657
1836
            if not _is_error_enotdir(e):
1658
1837
                raise
1659
1838
        else:
1712
1891
    """
1713
1892
    global _selected_dir_reader
1714
1893
    if _selected_dir_reader is None:
1715
 
        fs_encoding = _fs_enc.upper()
1716
 
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
1717
 
            # Win98 doesn't have unicode apis like FindFirstFileW
1718
 
            # TODO: We possibly could support Win98 by falling back to the
1719
 
            #       original FindFirstFile, and using TCHAR instead of WCHAR,
1720
 
            #       but that gets a bit tricky, and requires custom compiling
1721
 
            #       for win98 anyway.
 
1894
        if sys.platform == "win32":
1722
1895
            try:
1723
 
                from bzrlib._walkdirs_win32 import Win32ReadDir
 
1896
                from ._walkdirs_win32 import Win32ReadDir
1724
1897
                _selected_dir_reader = Win32ReadDir()
1725
1898
            except ImportError:
1726
1899
                pass
1727
 
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1728
 
            # ANSI_X3.4-1968 is a form of ASCII
 
1900
        elif _fs_enc in ('utf-8', 'ascii'):
1729
1901
            try:
1730
 
                from bzrlib._readdir_pyx import UTF8DirReader
 
1902
                from ._readdir_pyx import UTF8DirReader
1731
1903
                _selected_dir_reader = UTF8DirReader()
1732
 
            except ImportError, e:
 
1904
            except ImportError as e:
1733
1905
                failed_to_load_extension(e)
1734
1906
                pass
1735
1907
 
1780
1952
        See DirReader.read_dir for details.
1781
1953
        """
1782
1954
        _utf8_encode = self._utf8_encode
 
1955
 
 
1956
        def _fs_decode(s): return s.decode(_fs_enc)
 
1957
 
 
1958
        def _fs_encode(s): return s.encode(_fs_enc)
1783
1959
        _lstat = os.lstat
1784
1960
        _listdir = os.listdir
1785
1961
        _kind_from_mode = file_kind_from_stat_mode
1786
1962
 
1787
1963
        if prefix:
1788
 
            relprefix = prefix + '/'
 
1964
            relprefix = prefix + b'/'
1789
1965
        else:
1790
 
            relprefix = ''
1791
 
        top_slash = top + u'/'
 
1966
            relprefix = b''
 
1967
        top_slash = top + '/'
1792
1968
 
1793
1969
        dirblock = []
1794
1970
        append = dirblock.append
1795
 
        for name in sorted(_listdir(top)):
 
1971
        for name_native in _listdir(top.encode('utf-8')):
1796
1972
            try:
1797
 
                name_utf8 = _utf8_encode(name)[0]
 
1973
                name = _fs_decode(name_native)
1798
1974
            except UnicodeDecodeError:
1799
1975
                raise errors.BadFilenameEncoding(
1800
 
                    _utf8_encode(relprefix)[0] + name, _fs_enc)
 
1976
                    relprefix + name_native, _fs_enc)
 
1977
            name_utf8 = _utf8_encode(name)[0]
1801
1978
            abspath = top_slash + name
1802
1979
            statvalue = _lstat(abspath)
1803
1980
            kind = _kind_from_mode(statvalue.st_mode)
1804
1981
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
1805
 
        return dirblock
 
1982
        return sorted(dirblock)
1806
1983
 
1807
1984
 
1808
1985
def copy_tree(from_path, to_path, handlers={}):
1833
2010
        link_to = os.readlink(source)
1834
2011
        os.symlink(link_to, dest)
1835
2012
 
1836
 
    real_handlers = {'file':shutil.copy2,
1837
 
                     'symlink':copy_link,
1838
 
                     'directory':copy_dir,
1839
 
                    }
 
2013
    real_handlers = {'file': shutil.copy2,
 
2014
                     'symlink': copy_link,
 
2015
                     'directory': copy_dir,
 
2016
                     }
1840
2017
    real_handlers.update(handlers)
1841
2018
 
1842
2019
    if not os.path.exists(to_path):
1857
2034
    if chown is None:
1858
2035
        return
1859
2036
 
1860
 
    if src == None:
 
2037
    if src is None:
1861
2038
        src = os.path.dirname(dst)
1862
2039
        if src == '':
1863
2040
            src = '.'
1865
2042
    try:
1866
2043
        s = os.stat(src)
1867
2044
        chown(dst, s.st_uid, s.st_gid)
1868
 
    except OSError, e:
1869
 
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
 
2045
    except OSError:
 
2046
        trace.warning(
 
2047
            'Unable to copy ownership from "%s" to "%s". '
 
2048
            'You may want to set it manually.', src, dst)
 
2049
        trace.log_exception_quietly()
1870
2050
 
1871
2051
 
1872
2052
def path_prefix_key(path):
1874
2054
 
1875
2055
    This can be used to sort paths in the same way that walkdirs does.
1876
2056
    """
1877
 
    return (dirname(path) , path)
 
2057
    return (dirname(path), path)
1878
2058
 
1879
2059
 
1880
2060
def compare_paths_prefix_order(path_a, path_b):
1881
2061
    """Compare path_a and path_b to generate the same order walkdirs uses."""
1882
2062
    key_a = path_prefix_key(path_a)
1883
2063
    key_b = path_prefix_key(path_b)
1884
 
    return cmp(key_a, key_b)
 
2064
    return (key_a > key_b) - (key_a < key_b)
1885
2065
 
1886
2066
 
1887
2067
_cached_user_encoding = None
1888
2068
 
1889
2069
 
1890
 
def get_user_encoding(use_cache=True):
 
2070
def get_user_encoding():
1891
2071
    """Find out what the preferred user encoding is.
1892
2072
 
1893
2073
    This is generally the encoding that is used for command line parameters
1894
2074
    and file contents. This may be different from the terminal encoding
1895
2075
    or the filesystem encoding.
1896
2076
 
1897
 
    :param  use_cache:  Enable cache for detected encoding.
1898
 
                        (This parameter is turned on by default,
1899
 
                        and required only for selftesting)
1900
 
 
1901
2077
    :return: A string defining the preferred user encoding
1902
2078
    """
1903
2079
    global _cached_user_encoding
1904
 
    if _cached_user_encoding is not None and use_cache:
 
2080
    if _cached_user_encoding is not None:
1905
2081
        return _cached_user_encoding
1906
2082
 
1907
 
    if sys.platform == 'darwin':
1908
 
        # python locale.getpreferredencoding() always return
1909
 
        # 'mac-roman' on darwin. That's a lie.
1910
 
        sys.platform = 'posix'
1911
 
        try:
1912
 
            if os.environ.get('LANG', None) is None:
1913
 
                # If LANG is not set, we end up with 'ascii', which is bad
1914
 
                # ('mac-roman' is more than ascii), so we set a default which
1915
 
                # will give us UTF-8 (which appears to work in all cases on
1916
 
                # OSX). Users are still free to override LANG of course, as
1917
 
                # long as it give us something meaningful. This work-around
1918
 
                # *may* not be needed with python 3k and/or OSX 10.5, but will
1919
 
                # work with them too -- vila 20080908
1920
 
                os.environ['LANG'] = 'en_US.UTF-8'
1921
 
            import locale
1922
 
        finally:
1923
 
            sys.platform = 'darwin'
 
2083
    if os.name == 'posix' and getattr(locale, 'CODESET', None) is not None:
 
2084
        # Use the existing locale settings and call nl_langinfo directly
 
2085
        # rather than going through getpreferredencoding. This avoids
 
2086
        # <http://bugs.python.org/issue6202> on OSX Python 2.6 and the
 
2087
        # possibility of the setlocale call throwing an error.
 
2088
        user_encoding = locale.nl_langinfo(locale.CODESET)
1924
2089
    else:
1925
 
        import locale
 
2090
        # GZ 2011-12-19: On windows could call GetACP directly instead.
 
2091
        user_encoding = locale.getpreferredencoding(False)
1926
2092
 
1927
2093
    try:
1928
 
        user_encoding = locale.getpreferredencoding()
1929
 
    except locale.Error, e:
1930
 
        sys.stderr.write('bzr: warning: %s\n'
1931
 
                         '  Could not determine what text encoding to use.\n'
1932
 
                         '  This error usually means your Python interpreter\n'
1933
 
                         '  doesn\'t support the locale set by $LANG (%s)\n'
1934
 
                         "  Continuing with ascii encoding.\n"
1935
 
                         % (e, os.environ.get('LANG')))
1936
 
        user_encoding = 'ascii'
1937
 
 
1938
 
    # Windows returns 'cp0' to indicate there is no code page. So we'll just
1939
 
    # treat that as ASCII, and not support printing unicode characters to the
1940
 
    # console.
1941
 
    #
1942
 
    # For python scripts run under vim, we get '', so also treat that as ASCII
1943
 
    if user_encoding in (None, 'cp0', ''):
1944
 
        user_encoding = 'ascii'
1945
 
    else:
1946
 
        # check encoding
1947
 
        try:
1948
 
            codecs.lookup(user_encoding)
1949
 
        except LookupError:
1950
 
            sys.stderr.write('bzr: warning:'
 
2094
        user_encoding = codecs.lookup(user_encoding).name
 
2095
    except LookupError:
 
2096
        if user_encoding not in ("", "cp0"):
 
2097
            sys.stderr.write('brz: warning:'
1951
2098
                             ' unknown encoding %s.'
1952
2099
                             ' Continuing with ascii encoding.\n'
1953
2100
                             % user_encoding
1954
 
                            )
1955
 
            user_encoding = 'ascii'
1956
 
 
1957
 
    if use_cache:
1958
 
        _cached_user_encoding = user_encoding
1959
 
 
 
2101
                             )
 
2102
        user_encoding = 'ascii'
 
2103
    else:
 
2104
        # Get 'ascii' when setlocale has not been called or LANG=C or unset.
 
2105
        if user_encoding == 'ascii':
 
2106
            if sys.platform == 'darwin':
 
2107
                # OSX is special-cased in Python to have a UTF-8 filesystem
 
2108
                # encoding and previously had LANG set here if not present.
 
2109
                user_encoding = 'utf-8'
 
2110
            # GZ 2011-12-19: Maybe UTF-8 should be the default in this case
 
2111
            #                for some other posix platforms as well.
 
2112
 
 
2113
    _cached_user_encoding = user_encoding
1960
2114
    return user_encoding
1961
2115
 
1962
2116
 
 
2117
def get_diff_header_encoding():
 
2118
    return get_terminal_encoding()
 
2119
 
 
2120
 
1963
2121
def get_host_name():
1964
2122
    """Return the current unicode host name.
1965
2123
 
1967
2125
    behaves inconsistently on different platforms.
1968
2126
    """
1969
2127
    if sys.platform == "win32":
1970
 
        import win32utils
1971
2128
        return win32utils.get_host_name()
1972
2129
    else:
1973
2130
        import socket
 
2131
        if PY3:
 
2132
            return socket.gethostname()
1974
2133
        return socket.gethostname().decode(get_user_encoding())
1975
2134
 
1976
2135
 
1980
2139
# data at once.
1981
2140
MAX_SOCKET_CHUNK = 64 * 1024
1982
2141
 
 
2142
_end_of_stream_errors = [errno.ECONNRESET, errno.EPIPE, errno.EINVAL]
 
2143
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
 
2144
    _eno = getattr(errno, _eno, None)
 
2145
    if _eno is not None:
 
2146
        _end_of_stream_errors.append(_eno)
 
2147
del _eno
 
2148
 
 
2149
 
1983
2150
def read_bytes_from_socket(sock, report_activity=None,
1984
 
        max_read_size=MAX_SOCKET_CHUNK):
 
2151
                           max_read_size=MAX_SOCKET_CHUNK):
1985
2152
    """Read up to max_read_size of bytes from sock and notify of progress.
1986
2153
 
1987
2154
    Translates "Connection reset by peer" into file-like EOF (return an
1988
2155
    empty string rather than raise an error), and repeats the recv if
1989
2156
    interrupted by a signal.
1990
2157
    """
1991
 
    while 1:
 
2158
    while True:
1992
2159
        try:
1993
 
            bytes = sock.recv(max_read_size)
1994
 
        except socket.error, e:
 
2160
            data = sock.recv(max_read_size)
 
2161
        except socket.error as e:
1995
2162
            eno = e.args[0]
1996
 
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
 
2163
            if eno in _end_of_stream_errors:
1997
2164
                # The connection was closed by the other side.  Callers expect
1998
2165
                # an empty string to signal end-of-stream.
1999
 
                return ""
 
2166
                return b""
2000
2167
            elif eno == errno.EINTR:
2001
2168
                # Retry the interrupted recv.
2002
2169
                continue
2003
2170
            raise
2004
2171
        else:
2005
2172
            if report_activity is not None:
2006
 
                report_activity(len(bytes), 'read')
2007
 
            return bytes
 
2173
                report_activity(len(data), 'read')
 
2174
            return data
2008
2175
 
2009
2176
 
2010
2177
def recv_all(socket, count):
2017
2184
 
2018
2185
    This isn't optimized and is intended mostly for use in testing.
2019
2186
    """
2020
 
    b = ''
 
2187
    b = b''
2021
2188
    while len(b) < count:
2022
2189
        new = read_bytes_from_socket(socket, None, count - len(b))
2023
 
        if new == '':
2024
 
            break # eof
 
2190
        if new == b'':
 
2191
            break  # eof
2025
2192
        b += new
2026
2193
    return b
2027
2194
 
2028
2195
 
2029
2196
def send_all(sock, bytes, report_activity=None):
2030
2197
    """Send all bytes on a socket.
2031
 
 
 
2198
 
2032
2199
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2033
2200
    some platforms, and catches EINTR which may be thrown if the send is
2034
2201
    interrupted by a signal.
2035
2202
 
2036
2203
    This is preferred to socket.sendall(), because it avoids portability bugs
2037
2204
    and provides activity reporting.
2038
 
 
 
2205
 
2039
2206
    :param report_activity: Call this as bytes are read, see
2040
2207
        Transport._report_activity
2041
2208
    """
2042
2209
    sent_total = 0
2043
2210
    byte_count = len(bytes)
 
2211
    view = memoryview(bytes)
2044
2212
    while sent_total < byte_count:
2045
2213
        try:
2046
 
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2047
 
        except socket.error, e:
 
2214
            sent = sock.send(view[sent_total:sent_total + MAX_SOCKET_CHUNK])
 
2215
        except (socket.error, IOError) as e:
 
2216
            if e.args[0] in _end_of_stream_errors:
 
2217
                raise errors.ConnectionReset(
 
2218
                    "Error trying to write to socket", e)
2048
2219
            if e.args[0] != errno.EINTR:
2049
2220
                raise
2050
2221
        else:
 
2222
            if sent == 0:
 
2223
                raise errors.ConnectionReset('Sending to %s returned 0 bytes'
 
2224
                                             % (sock,))
2051
2225
            sent_total += sent
2052
 
            report_activity(sent, 'write')
 
2226
            if report_activity is not None:
 
2227
                report_activity(sent, 'write')
 
2228
 
 
2229
 
 
2230
def connect_socket(address):
 
2231
    # Slight variation of the socket.create_connection() function (provided by
 
2232
    # python-2.6) that can fail if getaddrinfo returns an empty list. We also
 
2233
    # provide it for previous python versions. Also, we don't use the timeout
 
2234
    # parameter (provided by the python implementation) so we don't implement
 
2235
    # it either).
 
2236
    err = socket.error('getaddrinfo returns an empty list')
 
2237
    host, port = address
 
2238
    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
 
2239
        af, socktype, proto, canonname, sa = res
 
2240
        sock = None
 
2241
        try:
 
2242
            sock = socket.socket(af, socktype, proto)
 
2243
            sock.connect(sa)
 
2244
            return sock
 
2245
 
 
2246
        except socket.error as e:
 
2247
            err = e
 
2248
            # 'err' is now the most recent error
 
2249
            if sock is not None:
 
2250
                sock.close()
 
2251
    raise err
2053
2252
 
2054
2253
 
2055
2254
def dereference_path(path):
2074
2273
def resource_string(package, resource_name):
2075
2274
    """Load a resource from a package and return it as a string.
2076
2275
 
2077
 
    Note: Only packages that start with bzrlib are currently supported.
 
2276
    Note: Only packages that start with breezy are currently supported.
2078
2277
 
2079
2278
    This is designed to be a lightweight implementation of resource
2080
2279
    loading in a way which is API compatible with the same API from
2083
2282
    If and when pkg_resources becomes a standard library, this routine
2084
2283
    can delegate to it.
2085
2284
    """
2086
 
    # Check package name is within bzrlib
2087
 
    if package == "bzrlib":
 
2285
    # Check package name is within breezy
 
2286
    if package == "breezy":
2088
2287
        resource_relpath = resource_name
2089
 
    elif package.startswith("bzrlib."):
2090
 
        package = package[len("bzrlib."):].replace('.', os.sep)
 
2288
    elif package.startswith("breezy."):
 
2289
        package = package[len("breezy."):].replace('.', os.sep)
2091
2290
        resource_relpath = pathjoin(package, resource_name)
2092
2291
    else:
2093
 
        raise errors.BzrError('resource package %s not in bzrlib' % package)
 
2292
        raise errors.BzrError('resource package %s not in breezy' % package)
2094
2293
 
2095
2294
    # Map the resource to a file and read its contents
2096
 
    base = dirname(bzrlib.__file__)
 
2295
    base = dirname(breezy.__file__)
2097
2296
    if getattr(sys, 'frozen', None):    # bzr.exe
2098
2297
        base = abspath(pathjoin(base, '..', '..'))
2099
 
    filename = pathjoin(base, resource_relpath)
2100
 
    return open(filename, 'rU').read()
 
2298
    with open(pathjoin(base, resource_relpath), "rt") as f:
 
2299
        return f.read()
2101
2300
 
2102
2301
 
2103
2302
def file_kind_from_stat_mode_thunk(mode):
2104
2303
    global file_kind_from_stat_mode
2105
2304
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
2106
2305
        try:
2107
 
            from bzrlib._readdir_pyx import UTF8DirReader
 
2306
            from ._readdir_pyx import UTF8DirReader
2108
2307
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
2109
 
        except ImportError, e:
 
2308
        except ImportError:
2110
2309
            # This is one time where we won't warn that an extension failed to
2111
2310
            # load. The extension is never available on Windows anyway.
2112
 
            from bzrlib._readdir_py import (
 
2311
            from ._readdir_py import (
2113
2312
                _kind_from_mode as file_kind_from_stat_mode
2114
2313
                )
2115
2314
    return file_kind_from_stat_mode(mode)
 
2315
 
 
2316
 
2116
2317
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2117
2318
 
2118
2319
 
2119
 
def file_kind(f, _lstat=os.lstat):
 
2320
def file_stat(f, _lstat=os.lstat):
2120
2321
    try:
2121
 
        return file_kind_from_stat_mode(_lstat(f).st_mode)
2122
 
    except OSError, e:
 
2322
        # XXX cache?
 
2323
        return _lstat(f)
 
2324
    except OSError as e:
2123
2325
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2124
2326
            raise errors.NoSuchFile(f)
2125
2327
        raise
2126
2328
 
2127
2329
 
 
2330
def file_kind(f, _lstat=os.lstat):
 
2331
    stat_value = file_stat(f, _lstat)
 
2332
    return file_kind_from_stat_mode(stat_value.st_mode)
 
2333
 
 
2334
 
2128
2335
def until_no_eintr(f, *a, **kw):
2129
2336
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2130
 
    
 
2337
 
2131
2338
    WARNING: you must be certain that it is safe to retry the call repeatedly
2132
2339
    if EINTR does occur.  This is typically only true for low-level operations
2133
2340
    like os.read.  If in any doubt, don't use this.
2135
2342
    Keep in mind that this is not a complete solution to EINTR.  There is
2136
2343
    probably code in the Python standard library and other dependencies that
2137
2344
    may encounter EINTR if a signal arrives (and there is signal handler for
2138
 
    that signal).  So this function can reduce the impact for IO that bzrlib
 
2345
    that signal).  So this function can reduce the impact for IO that breezy
2139
2346
    directly controls, but it is not a complete solution.
2140
2347
    """
2141
2348
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
2142
2349
    while True:
2143
2350
        try:
2144
2351
            return f(*a, **kw)
2145
 
        except (IOError, OSError), e:
 
2352
        except (IOError, OSError) as e:
2146
2353
            if e.errno == errno.EINTR:
2147
2354
                continue
2148
2355
            raise
2149
2356
 
2150
2357
 
2151
 
def re_compile_checked(re_string, flags=0, where=""):
2152
 
    """Return a compiled re, or raise a sensible error.
2153
 
 
2154
 
    This should only be used when compiling user-supplied REs.
2155
 
 
2156
 
    :param re_string: Text form of regular expression.
2157
 
    :param flags: eg re.IGNORECASE
2158
 
    :param where: Message explaining to the user the context where
2159
 
        it occurred, eg 'log search filter'.
2160
 
    """
2161
 
    # from https://bugs.launchpad.net/bzr/+bug/251352
2162
 
    try:
2163
 
        re_obj = re.compile(re_string, flags)
2164
 
        re_obj.search("")
2165
 
        return re_obj
2166
 
    except re.error, e:
2167
 
        if where:
2168
 
            where = ' in ' + where
2169
 
        # despite the name 'error' is a type
2170
 
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
2171
 
            % (where, re_string, e))
2172
 
 
2173
 
 
2174
2358
if sys.platform == "win32":
2175
 
    import msvcrt
2176
2359
    def getchar():
 
2360
        import msvcrt
2177
2361
        return msvcrt.getch()
2178
2362
else:
2179
 
    import tty
2180
 
    import termios
2181
2363
    def getchar():
 
2364
        import tty
 
2365
        import termios
2182
2366
        fd = sys.stdin.fileno()
2183
2367
        settings = termios.tcgetattr(fd)
2184
2368
        try:
2188
2372
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2189
2373
        return ch
2190
2374
 
2191
 
 
2192
 
if sys.platform == 'linux2':
 
2375
if sys.platform.startswith('linux'):
2193
2376
    def _local_concurrency():
2194
 
        concurrency = None
2195
 
        prefix = 'processor'
2196
 
        for line in file('/proc/cpuinfo', 'rb'):
2197
 
            if line.startswith(prefix):
2198
 
                concurrency = int(line[line.find(':')+1:]) + 1
2199
 
        return concurrency
 
2377
        try:
 
2378
            return os.sysconf('SC_NPROCESSORS_ONLN')
 
2379
        except (ValueError, OSError, AttributeError):
 
2380
            return None
2200
2381
elif sys.platform == 'darwin':
2201
2382
    def _local_concurrency():
2202
2383
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2203
2384
                                stdout=subprocess.PIPE).communicate()[0]
2204
 
elif sys.platform[0:7] == 'freebsd':
 
2385
elif "bsd" in sys.platform:
2205
2386
    def _local_concurrency():
2206
2387
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2207
2388
                                stdout=subprocess.PIPE).communicate()[0]
2208
2389
elif sys.platform == 'sunos5':
2209
2390
    def _local_concurrency():
2210
 
        return subprocess.Popen(['psrinfo', '-p',],
 
2391
        return subprocess.Popen(['psrinfo', '-p', ],
2211
2392
                                stdout=subprocess.PIPE).communicate()[0]
2212
2393
elif sys.platform == "win32":
2213
2394
    def _local_concurrency():
2221
2402
 
2222
2403
_cached_local_concurrency = None
2223
2404
 
 
2405
 
2224
2406
def local_concurrency(use_cache=True):
2225
2407
    """Return how many processes can be run concurrently.
2226
2408
 
2232
2414
    if _cached_local_concurrency is not None and use_cache:
2233
2415
        return _cached_local_concurrency
2234
2416
 
2235
 
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
 
2417
    concurrency = os.environ.get('BRZ_CONCURRENCY', None)
2236
2418
    if concurrency is None:
 
2419
        import multiprocessing
2237
2420
        try:
2238
 
            concurrency = _local_concurrency()
2239
 
        except (OSError, IOError):
2240
 
            pass
 
2421
            concurrency = multiprocessing.cpu_count()
 
2422
        except NotImplementedError:
 
2423
            # multiprocessing.cpu_count() isn't implemented on all platforms
 
2424
            try:
 
2425
                concurrency = _local_concurrency()
 
2426
            except (OSError, IOError):
 
2427
                pass
2241
2428
    try:
2242
2429
        concurrency = int(concurrency)
2243
2430
    except (TypeError, ValueError):
2244
2431
        concurrency = 1
2245
2432
    if use_cache:
2246
 
        _cached_concurrency = concurrency
 
2433
        _cached_local_concurrency = concurrency
2247
2434
    return concurrency
2248
2435
 
2249
2436
 
2255
2442
        self.encode = encode
2256
2443
 
2257
2444
    def write(self, object):
2258
 
        if type(object) is str:
 
2445
        if isinstance(object, str):
2259
2446
            self.stream.write(object)
2260
2447
        else:
2261
2448
            data, _ = self.encode(object, self.errors)
2262
2449
            self.stream.write(data)
2263
2450
 
 
2451
 
2264
2452
if sys.platform == 'win32':
2265
2453
    def open_file(filename, mode='r', bufsize=-1):
2266
2454
        """This function is used to override the ``open`` builtin.
2267
 
        
 
2455
 
2268
2456
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2269
2457
        child processes.  Deleting or renaming a closed file opened with this
2270
2458
        function is not blocking child processes.
2294
2482
            else:
2295
2483
                flags |= os.O_WRONLY
2296
2484
            flags |= os.O_CREAT | os.O_APPEND
2297
 
        else: #reading
 
2485
        else:  # reading
2298
2486
            if updating:
2299
2487
                flags |= os.O_RDWR
2300
2488
            else:
2305
2493
    open_file = open
2306
2494
 
2307
2495
 
2308
 
def getuser_unicode():
2309
 
    """Return the username as unicode.
2310
 
    """
2311
 
    try:
2312
 
        user_encoding = get_user_encoding()
2313
 
        username = getpass.getuser().decode(user_encoding)
2314
 
    except UnicodeDecodeError:
2315
 
        raise errors.BzrError("Can't decode username as %s." % \
2316
 
                user_encoding)
2317
 
    return username
 
2496
def available_backup_name(base, exists):
 
2497
    """Find a non-existing backup file name.
 
2498
 
 
2499
    This will *not* create anything, this only return a 'free' entry.  This
 
2500
    should be used for checking names in a directory below a locked
 
2501
    tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
 
2502
    Leap) and generally discouraged.
 
2503
 
 
2504
    :param base: The base name.
 
2505
 
 
2506
    :param exists: A callable returning True if the path parameter exists.
 
2507
    """
 
2508
    counter = 1
 
2509
    name = "%s.~%d~" % (base, counter)
 
2510
    while exists(name):
 
2511
        counter += 1
 
2512
        name = "%s.~%d~" % (base, counter)
 
2513
    return name
 
2514
 
 
2515
 
 
2516
def set_fd_cloexec(fd):
 
2517
    """Set a Unix file descriptor's FD_CLOEXEC flag.  Do nothing if platform
 
2518
    support for this is not available.
 
2519
    """
 
2520
    try:
 
2521
        import fcntl
 
2522
        old = fcntl.fcntl(fd, fcntl.F_GETFD)
 
2523
        fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
 
2524
    except (ImportError, AttributeError):
 
2525
        # Either the fcntl module or specific constants are not present
 
2526
        pass
 
2527
 
 
2528
 
 
2529
def find_executable_on_path(name):
 
2530
    """Finds an executable on the PATH.
 
2531
 
 
2532
    On Windows, this will try to append each extension in the PATHEXT
 
2533
    environment variable to the name, if it cannot be found with the name
 
2534
    as given.
 
2535
 
 
2536
    :param name: The base name of the executable.
 
2537
    :return: The path to the executable found or None.
 
2538
    """
 
2539
    if sys.platform == 'win32':
 
2540
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
 
2541
        exts = [ext.lower() for ext in exts]
 
2542
        base, ext = os.path.splitext(name)
 
2543
        if ext != '':
 
2544
            if ext.lower() not in exts:
 
2545
                return None
 
2546
            name = base
 
2547
            exts = [ext]
 
2548
    else:
 
2549
        exts = ['']
 
2550
    path = os.environ.get('PATH')
 
2551
    if path is not None:
 
2552
        path = path.split(os.pathsep)
 
2553
        for ext in exts:
 
2554
            for d in path:
 
2555
                f = os.path.join(d, name) + ext
 
2556
                if os.access(f, os.X_OK):
 
2557
                    return f
 
2558
    if sys.platform == 'win32':
 
2559
        app_path = win32utils.get_app_path(name)
 
2560
        if app_path != name:
 
2561
            return app_path
 
2562
    return None
 
2563
 
 
2564
 
 
2565
def _posix_is_local_pid_dead(pid):
 
2566
    """True if pid doesn't correspond to live process on this machine"""
 
2567
    try:
 
2568
        # Special meaning of unix kill: just check if it's there.
 
2569
        os.kill(pid, 0)
 
2570
    except OSError as e:
 
2571
        if e.errno == errno.ESRCH:
 
2572
            # On this machine, and really not found: as sure as we can be
 
2573
            # that it's dead.
 
2574
            return True
 
2575
        elif e.errno == errno.EPERM:
 
2576
            # exists, though not ours
 
2577
            return False
 
2578
        else:
 
2579
            trace.mutter("os.kill(%d, 0) failed: %s" % (pid, e))
 
2580
            # Don't really know.
 
2581
            return False
 
2582
    else:
 
2583
        # Exists and our process: not dead.
 
2584
        return False
 
2585
 
 
2586
 
 
2587
if sys.platform == "win32":
 
2588
    is_local_pid_dead = win32utils.is_local_pid_dead
 
2589
else:
 
2590
    is_local_pid_dead = _posix_is_local_pid_dead
 
2591
 
 
2592
_maybe_ignored = ['EAGAIN', 'EINTR', 'ENOTSUP', 'EOPNOTSUPP', 'EACCES']
 
2593
_fdatasync_ignored = [getattr(errno, name) for name in _maybe_ignored
 
2594
                      if getattr(errno, name, None) is not None]
 
2595
 
 
2596
 
 
2597
def fdatasync(fileno):
 
2598
    """Flush file contents to disk if possible.
 
2599
 
 
2600
    :param fileno: Integer OS file handle.
 
2601
    :raises TransportNotPossible: If flushing to disk is not possible.
 
2602
    """
 
2603
    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))
 
2604
    if fn is not None:
 
2605
        try:
 
2606
            fn(fileno)
 
2607
        except IOError as e:
 
2608
            # See bug #1075108, on some platforms fdatasync exists, but can
 
2609
            # raise ENOTSUP. However, we are calling fdatasync to be helpful
 
2610
            # and reduce the chance of corruption-on-powerloss situations. It
 
2611
            # is not a mandatory call, so it is ok to suppress failures.
 
2612
            trace.mutter("ignoring error calling fdatasync: %s" % (e,))
 
2613
            if getattr(e, 'errno', None) not in _fdatasync_ignored:
 
2614
                raise
 
2615
 
 
2616
 
 
2617
def ensure_empty_directory_exists(path, exception_class):
 
2618
    """Make sure a local directory exists and is empty.
 
2619
 
 
2620
    If it does not exist, it is created.  If it exists and is not empty, an
 
2621
    instance of exception_class is raised.
 
2622
    """
 
2623
    try:
 
2624
        os.mkdir(path)
 
2625
    except OSError as e:
 
2626
        if e.errno != errno.EEXIST:
 
2627
            raise
 
2628
        if os.listdir(path) != []:
 
2629
            raise exception_class(path)
 
2630
 
 
2631
 
 
2632
def is_environment_error(evalue):
 
2633
    """True if exception instance is due to a process environment issue
 
2634
 
 
2635
    This includes OSError and IOError, but also other errors that come from
 
2636
    the operating system or core libraries but are not subclasses of those.
 
2637
    """
 
2638
    if isinstance(evalue, (EnvironmentError, select.error)):
 
2639
        return True
 
2640
    if sys.platform == "win32" and win32utils._is_pywintypes_error(evalue):
 
2641
        return True
 
2642
    return False
 
2643
 
 
2644
 
 
2645
def read_mtab(path):
 
2646
    """Read an fstab-style file and extract mountpoint+filesystem information.
 
2647
 
 
2648
    :param path: Path to read from
 
2649
    :yield: Tuples with mountpoints (as bytestrings) and filesystem names
 
2650
    """
 
2651
    with open(path, 'rb') as f:
 
2652
        for line in f:
 
2653
            if line.startswith(b'#'):
 
2654
                continue
 
2655
            cols = line.split()
 
2656
            if len(cols) < 3:
 
2657
                continue
 
2658
            yield cols[1], cols[2].decode('ascii', 'replace')
 
2659
 
 
2660
 
 
2661
MTAB_PATH = '/etc/mtab'
 
2662
 
 
2663
class FilesystemFinder(object):
 
2664
    """Find the filesystem for a particular path."""
 
2665
 
 
2666
    def __init__(self, mountpoints):
 
2667
        def key(x):
 
2668
            return len(x[0])
 
2669
        self._mountpoints = sorted(mountpoints, key=key, reverse=True)
 
2670
 
 
2671
    @classmethod
 
2672
    def from_mtab(cls):
 
2673
        """Create a FilesystemFinder from an mtab-style file.
 
2674
 
 
2675
        Note that this will silenty ignore mtab if it doesn't exist or can not
 
2676
        be opened.
 
2677
        """
 
2678
        # TODO(jelmer): Use inotify to be notified when /etc/mtab changes and
 
2679
        # we need to re-read it.
 
2680
        try:
 
2681
            return cls(read_mtab(MTAB_PATH))
 
2682
        except EnvironmentError as e:
 
2683
            trace.mutter('Unable to read mtab: %s', e)
 
2684
            return cls([])
 
2685
 
 
2686
    def find(self, path):
 
2687
        """Find the filesystem used by a particular path.
 
2688
 
 
2689
        :param path: Path to find (bytestring or text type)
 
2690
        :return: Filesystem name (as text type) or None, if the filesystem is
 
2691
            unknown.
 
2692
        """
 
2693
        for mountpoint, filesystem in self._mountpoints:
 
2694
            if is_inside(mountpoint, path):
 
2695
                return filesystem
 
2696
        return None
 
2697
 
 
2698
 
 
2699
_FILESYSTEM_FINDER = None
 
2700
 
 
2701
 
 
2702
def get_fs_type(path):
 
2703
    """Return the filesystem type for the partition a path is in.
 
2704
 
 
2705
    :param path: Path to search filesystem type for
 
2706
    :return: A FS type, as string. E.g. "ext2"
 
2707
    """
 
2708
    global _FILESYSTEM_FINDER
 
2709
    if _FILESYSTEM_FINDER is None:
 
2710
        _FILESYSTEM_FINDER = FilesystemFinder.from_mtab()
 
2711
 
 
2712
    if not isinstance(path, bytes):
 
2713
        path = path.encode(_fs_enc)
 
2714
 
 
2715
    return _FILESYSTEM_FINDER.find(path)
 
2716
 
 
2717
 
 
2718
if PY3:
 
2719
    perf_counter = time.perf_counter
 
2720
else:
 
2721
    perf_counter = time.clock