/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

  • Committer: Jelmer Vernooij
  • Date: 2020-01-31 02:56:40 UTC
  • mto: (7290.42.5 work)
  • mto: This revision was merged to the branch mainline in revision 7476.
  • Revision ID: jelmer@jelmer.uk-20200131025640-njh60c73nvr551x8
Drop Serializer.write_revision.

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:
451
520
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
452
521
        return shutil.rmtree(path, ignore_errors, onerror)
453
522
 
454
 
    f = win32utils.get_unicode_argv     # special function or None
455
 
    if f is not None:
456
 
        get_unicode_argv = f
 
523
    get_unicode_argv = getattr(win32utils, 'get_unicode_argv', get_unicode_argv)
 
524
    path_from_environ = win32utils.get_environ_unicode
 
525
    _get_home_dir = win32utils.get_home_location
 
526
    getuser_unicode = win32utils.get_user_name
457
527
 
458
528
elif sys.platform == 'darwin':
459
529
    getcwd = _mac_getcwd
460
530
 
461
531
 
462
 
def get_terminal_encoding():
 
532
def get_terminal_encoding(trace=False):
463
533
    """Find the best encoding for printing to the screen.
464
534
 
465
535
    This attempts to check both sys.stdout and sys.stdin to see
471
541
 
472
542
    On my standard US Windows XP, the preferred encoding is
473
543
    cp1252, but the console is cp437
 
544
 
 
545
    :param trace: If True trace the selected encoding via mutter().
474
546
    """
475
 
    from bzrlib.trace import mutter
 
547
    from .trace import mutter
476
548
    output_encoding = getattr(sys.stdout, 'encoding', None)
477
549
    if not output_encoding:
478
550
        input_encoding = getattr(sys.stdin, 'encoding', None)
479
551
        if not input_encoding:
480
552
            output_encoding = get_user_encoding()
481
 
            mutter('encoding stdout as osutils.get_user_encoding() %r',
482
 
                   output_encoding)
 
553
            if trace:
 
554
                mutter('encoding stdout as osutils.get_user_encoding() %r',
 
555
                       output_encoding)
483
556
        else:
484
557
            output_encoding = input_encoding
485
 
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
 
558
            if trace:
 
559
                mutter('encoding stdout as sys.stdin encoding %r',
 
560
                       output_encoding)
486
561
    else:
487
 
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
562
        if trace:
 
563
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
488
564
    if output_encoding == 'cp0':
489
565
        # invalid encoding (cp0 means 'no codepage' on Windows)
490
566
        output_encoding = get_user_encoding()
491
 
        mutter('cp0 is invalid encoding.'
492
 
               ' encoding stdout as osutils.get_user_encoding() %r',
493
 
               output_encoding)
 
567
        if trace:
 
568
            mutter('cp0 is invalid encoding.'
 
569
                   ' encoding stdout as osutils.get_user_encoding() %r',
 
570
                   output_encoding)
494
571
    # check encoding
495
572
    try:
496
573
        codecs.lookup(output_encoding)
497
574
    except LookupError:
498
 
        sys.stderr.write('bzr: warning:'
 
575
        sys.stderr.write('brz: warning:'
499
576
                         ' unknown terminal encoding %s.\n'
500
577
                         '  Using encoding %s instead.\n'
501
578
                         % (output_encoding, get_user_encoding())
502
 
                        )
 
579
                         )
503
580
        output_encoding = get_user_encoding()
504
581
 
505
582
    return output_encoding
510
587
        F = realpath
511
588
    else:
512
589
        F = abspath
513
 
    [p,e] = os.path.split(f)
 
590
    [p, e] = os.path.split(f)
514
591
    if e == "" or e == "." or e == "..":
515
592
        return F(f)
516
593
    else:
520
597
def isdir(f):
521
598
    """True if f is an accessible directory."""
522
599
    try:
523
 
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
600
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
524
601
    except OSError:
525
602
        return False
526
603
 
528
605
def isfile(f):
529
606
    """True if f is a regular file."""
530
607
    try:
531
 
        return S_ISREG(os.lstat(f)[ST_MODE])
 
608
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
532
609
    except OSError:
533
610
        return False
534
611
 
 
612
 
535
613
def islink(f):
536
614
    """True if f is a symlink."""
537
615
    try:
538
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
616
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
539
617
    except OSError:
540
618
        return False
541
619
 
 
620
 
542
621
def is_inside(dir, fname):
543
622
    """True if fname is inside dir.
544
623
 
554
633
    if dir == fname:
555
634
        return True
556
635
 
557
 
    if dir == '':
 
636
    if dir in ('', b''):
558
637
        return True
559
638
 
560
 
    if dir[-1] != '/':
561
 
        dir += '/'
 
639
    if isinstance(dir, bytes):
 
640
        if not dir.endswith(b'/'):
 
641
            dir += b'/'
 
642
    else:
 
643
        if not dir.endswith('/'):
 
644
            dir += '/'
562
645
 
563
646
    return fname.startswith(dir)
564
647
 
637
720
    # writes fail on some platforms (e.g. Windows with SMB  mounted
638
721
    # drives).
639
722
    if not segment_size:
640
 
        segment_size = 5242880 # 5MB
641
 
    segments = range(len(bytes) / segment_size + 1)
 
723
        segment_size = 5242880  # 5MB
 
724
    offsets = range(0, len(bytes), segment_size)
 
725
    view = memoryview(bytes)
642
726
    write = file_handle.write
643
 
    for segment_index in segments:
644
 
        segment = buffer(bytes, segment_index * segment_size, segment_size)
645
 
        write(segment)
 
727
    for offset in offsets:
 
728
        write(view[offset:offset + segment_size])
646
729
 
647
730
 
648
731
def file_iterator(input_file, readsize=32768):
653
736
        yield b
654
737
 
655
738
 
 
739
# GZ 2017-09-16: Makes sense in general for hexdigest() result to be text, but
 
740
# used as bytes through most interfaces so encode with this wrapper.
 
741
if PY3:
 
742
    def _hexdigest(hashobj):
 
743
        return hashobj.hexdigest().encode()
 
744
else:
 
745
    def _hexdigest(hashobj):
 
746
        return hashobj.hexdigest()
 
747
 
 
748
 
656
749
def sha_file(f):
657
750
    """Calculate the hexdigest of an open file.
658
751
 
659
752
    The file cursor should be already at the start.
660
753
    """
661
754
    s = sha()
662
 
    BUFSIZE = 128<<10
 
755
    BUFSIZE = 128 << 10
663
756
    while True:
664
757
        b = f.read(BUFSIZE)
665
758
        if not b:
666
759
            break
667
760
        s.update(b)
668
 
    return s.hexdigest()
 
761
    return _hexdigest(s)
669
762
 
670
763
 
671
764
def size_sha_file(f):
676
769
    """
677
770
    size = 0
678
771
    s = sha()
679
 
    BUFSIZE = 128<<10
 
772
    BUFSIZE = 128 << 10
680
773
    while True:
681
774
        b = f.read(BUFSIZE)
682
775
        if not b:
683
776
            break
684
777
        size += len(b)
685
778
        s.update(b)
686
 
    return size, s.hexdigest()
 
779
    return size, _hexdigest(s)
687
780
 
688
781
 
689
782
def sha_file_by_name(fname):
692
785
    f = os.open(fname, os.O_RDONLY | O_BINARY | O_NOINHERIT)
693
786
    try:
694
787
        while True:
695
 
            b = os.read(f, 1<<16)
 
788
            b = os.read(f, 1 << 16)
696
789
            if not b:
697
 
                return s.hexdigest()
 
790
                return _hexdigest(s)
698
791
            s.update(b)
699
792
    finally:
700
793
        os.close(f)
703
796
def sha_strings(strings, _factory=sha):
704
797
    """Return the sha-1 of concatenation of strings"""
705
798
    s = _factory()
706
 
    map(s.update, strings)
707
 
    return s.hexdigest()
 
799
    for string in strings:
 
800
        s.update(string)
 
801
    return _hexdigest(s)
708
802
 
709
803
 
710
804
def sha_string(f, _factory=sha):
711
 
    return _factory(f).hexdigest()
 
805
    # GZ 2017-09-16: Dodgy if factory is ever not sha, probably shouldn't be.
 
806
    return _hexdigest(_factory(f))
712
807
 
713
808
 
714
809
def fingerprint_file(f):
715
810
    b = f.read()
716
811
    return {'size': len(b),
717
 
            'sha1': sha(b).hexdigest()}
 
812
            'sha1': _hexdigest(sha(b))}
718
813
 
719
814
 
720
815
def compare_files(a, b):
725
820
        bi = b.read(BUFSIZE)
726
821
        if ai != bi:
727
822
            return False
728
 
        if ai == '':
 
823
        if not ai:
729
824
            return True
730
825
 
731
826
 
736
831
    offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
737
832
    return offset.days * 86400 + offset.seconds
738
833
 
 
834
 
739
835
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
740
836
_default_format_by_weekday_num = [wd + " %Y-%m-%d %H:%M:%S" for wd in weekdays]
741
837
 
753
849
    :param show_offset: Whether to append the timezone.
754
850
    """
755
851
    (date_fmt, tt, offset_str) = \
756
 
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
852
        _format_date(t, offset, timezone, date_fmt, show_offset)
757
853
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
758
854
    date_str = time.strftime(date_fmt, tt)
759
855
    return date_str + offset_str
764
860
 
765
861
 
766
862
def format_date_with_offset_in_original_timezone(t, offset=0,
767
 
    _cache=_offset_cache):
 
863
                                                 _cache=_offset_cache):
768
864
    """Return a formatted date string in the original timezone.
769
865
 
770
866
    This routine may be faster then format_date.
797
893
    :param show_offset: Whether to append the timezone.
798
894
    """
799
895
    (date_fmt, tt, offset_str) = \
800
 
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
896
        _format_date(t, offset, timezone, date_fmt, show_offset)
801
897
    date_str = time.strftime(date_fmt, tt)
802
 
    if not isinstance(date_str, unicode):
 
898
    if not isinstance(date_str, text_type):
803
899
        date_str = date_str.decode(get_user_encoding(), 'replace')
804
900
    return date_str + offset_str
805
901
 
816
912
        tt = time.localtime(t)
817
913
        offset = local_time_offset(t)
818
914
    else:
819
 
        raise errors.UnsupportedTimezoneFormat(timezone)
 
915
        raise UnsupportedTimezoneFormat(timezone)
820
916
    if date_fmt is None:
821
917
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
822
918
    if show_offset:
846
942
        delta = -delta
847
943
 
848
944
    seconds = delta
849
 
    if seconds < 90: # print seconds up to 90 seconds
 
945
    if seconds < 90:  # print seconds up to 90 seconds
850
946
        if seconds == 1:
851
947
            return '%d second %s' % (seconds, direction,)
852
948
        else:
858
954
        plural_seconds = ''
859
955
    else:
860
956
        plural_seconds = 's'
861
 
    if minutes < 90: # print minutes, seconds up to 90 minutes
 
957
    if minutes < 90:  # print minutes, seconds up to 90 minutes
862
958
        if minutes == 1:
863
959
            return '%d minute, %d second%s %s' % (
864
 
                    minutes, seconds, plural_seconds, direction)
 
960
                minutes, seconds, plural_seconds, direction)
865
961
        else:
866
962
            return '%d minutes, %d second%s %s' % (
867
 
                    minutes, seconds, plural_seconds, direction)
 
963
                minutes, seconds, plural_seconds, direction)
868
964
 
869
965
    hours = int(minutes / 60)
870
966
    minutes -= 60 * hours
879
975
    return '%d hours, %d minute%s %s' % (hours, minutes,
880
976
                                         plural_minutes, direction)
881
977
 
 
978
 
882
979
def filesize(f):
883
980
    """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
 
981
    return os.fstat(f.fileno())[stat.ST_SIZE]
 
982
 
 
983
 
 
984
# Alias os.urandom to support platforms (which?) without /dev/urandom and
 
985
# override if it doesn't work. Avoid checking on windows where there is
 
986
# significant initialisation cost that can be avoided for some bzr calls.
 
987
 
 
988
rand_bytes = os.urandom
 
989
 
 
990
if rand_bytes.__module__ != "nt":
896
991
    try:
897
 
        rand_bytes = file('/dev/urandom', 'rb').read
898
 
    # Otherwise, use this hack as a last resort
899
 
    except (IOError, OSError):
 
992
        rand_bytes(1)
 
993
    except NotImplementedError:
900
994
        # not well seeded, but better than nothing
901
995
        def rand_bytes(n):
902
996
            import random
908
1002
 
909
1003
 
910
1004
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
 
1005
 
 
1006
 
911
1007
def rand_chars(num):
912
1008
    """Return a random string of num alphanumeric characters
913
1009
 
916
1012
    """
917
1013
    s = ''
918
1014
    for raw_byte in rand_bytes(num):
919
 
        s += ALNUM[ord(raw_byte) % 36]
 
1015
        if not PY3:
 
1016
            s += ALNUM[ord(raw_byte) % 36]
 
1017
        else:
 
1018
            s += ALNUM[raw_byte % 36]
920
1019
    return s
921
1020
 
922
1021
 
923
 
## TODO: We could later have path objects that remember their list
924
 
## decomposition (might be too tricksy though.)
 
1022
# TODO: We could later have path objects that remember their list
 
1023
# decomposition (might be too tricksy though.)
925
1024
 
926
1025
def splitpath(p):
927
1026
    """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)
 
1027
    if os.path.sep == '\\':
 
1028
        # split on either delimiter because people might use either on
 
1029
        # Windows
 
1030
        if isinstance(p, bytes):
 
1031
            ps = re.split(b'[\\\\/]', p)
 
1032
        else:
 
1033
            ps = re.split(r'[\\/]', p)
 
1034
    else:
 
1035
        if isinstance(p, bytes):
 
1036
            ps = p.split(b'/')
 
1037
        else:
 
1038
            ps = p.split('/')
931
1039
 
932
1040
    rps = []
933
1041
    for f in ps:
934
 
        if f == '..':
935
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
936
 
        elif (f == '.') or (f == ''):
 
1042
        if f in ('..', b'..'):
 
1043
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
1044
        elif f in ('.', '', b'.', b''):
937
1045
            pass
938
1046
        else:
939
1047
            rps.append(f)
943
1051
def joinpath(p):
944
1052
    for f in p:
945
1053
        if (f == '..') or (f is None) or (f == ''):
946
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
1054
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
947
1055
    return pathjoin(*p)
948
1056
 
949
1057
 
950
1058
def parent_directories(filename):
951
1059
    """Return the list of parent directories, deepest first.
952
 
    
 
1060
 
953
1061
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
954
1062
    """
955
1063
    parents = []
971
1079
    implementation should be loaded instead::
972
1080
 
973
1081
    >>> try:
974
 
    >>>     import bzrlib._fictional_extension_pyx
 
1082
    >>>     import breezy._fictional_extension_pyx
975
1083
    >>> except ImportError, e:
976
 
    >>>     bzrlib.osutils.failed_to_load_extension(e)
977
 
    >>>     import bzrlib._fictional_extension_py
 
1084
    >>>     breezy.osutils.failed_to_load_extension(e)
 
1085
    >>>     import breezy._fictional_extension_py
978
1086
    """
979
1087
    # NB: This docstring is just an example, not a doctest, because doctest
980
1088
    # currently can't cope with the use of lazy imports in this namespace --
981
1089
    # mbp 20090729
982
 
    
 
1090
 
983
1091
    # This currently doesn't report the failure at the time it occurs, because
984
1092
    # they tend to happen very early in startup when we can't check config
985
1093
    # files etc, and also we want to report all failures but not spam the user
986
1094
    # with 10 warnings.
987
 
    from bzrlib import trace
988
1095
    exception_str = str(exception)
989
1096
    if exception_str not in _extension_load_failures:
990
1097
        trace.mutter("failed to load compiled extension: %s" % exception_str)
994
1101
def report_extension_load_failures():
995
1102
    if not _extension_load_failures:
996
1103
        return
997
 
    from bzrlib.config import GlobalConfig
998
 
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
 
1104
    if config.GlobalConfig().suppress_warning('missing_extensions'):
999
1105
        return
1000
1106
    # the warnings framework should by default show this only once
1001
 
    from bzrlib.trace import warning
 
1107
    from .trace import warning
1002
1108
    warning(
1003
 
        "bzr: warning: some compiled extensions could not be loaded; "
1004
 
        "see <https://answers.launchpad.net/bzr/+faq/703>")
 
1109
        "brz: warning: some compiled extensions could not be loaded; "
 
1110
        "see ``brz help missing-extensions``")
1005
1111
    # we no longer show the specific missing extensions here, because it makes
1006
1112
    # the message too long and scary - see
1007
1113
    # https://bugs.launchpad.net/bzr/+bug/430529
1008
1114
 
1009
1115
 
1010
1116
try:
1011
 
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1012
 
except ImportError, e:
 
1117
    from ._chunks_to_lines_pyx import chunks_to_lines
 
1118
except ImportError as e:
1013
1119
    failed_to_load_extension(e)
1014
 
    from bzrlib._chunks_to_lines_py import chunks_to_lines
 
1120
    from ._chunks_to_lines_py import chunks_to_lines
1015
1121
 
1016
1122
 
1017
1123
def split_lines(s):
1018
1124
    """Split s into lines, but without removing the newline characters."""
1019
1125
    # Trivially convert a fulltext into a 'chunked' representation, and let
1020
1126
    # chunks_to_lines do the heavy lifting.
1021
 
    if isinstance(s, str):
 
1127
    if isinstance(s, bytes):
1022
1128
        # chunks_to_lines only supports 8-bit strings
1023
1129
        return chunks_to_lines([s])
1024
1130
    else:
1030
1136
 
1031
1137
    This supports Unicode or plain string objects.
1032
1138
    """
1033
 
    lines = s.split('\n')
1034
 
    result = [line + '\n' for line in lines[:-1]]
 
1139
    nl = b'\n' if isinstance(s, bytes) else u'\n'
 
1140
    lines = s.split(nl)
 
1141
    result = [line + nl for line in lines[:-1]]
1035
1142
    if lines[-1]:
1036
1143
        result.append(lines[-1])
1037
1144
    return result
1048
1155
        return
1049
1156
    try:
1050
1157
        os.link(src, dest)
1051
 
    except (OSError, IOError), e:
 
1158
    except (OSError, IOError) as e:
1052
1159
        if e.errno != errno.EXDEV:
1053
1160
            raise
1054
1161
        shutil.copyfile(src, dest)
1055
1162
 
1056
1163
 
1057
1164
def delete_any(path):
1058
 
    """Delete a file, symlink or directory.  
1059
 
    
 
1165
    """Delete a file, symlink or directory.
 
1166
 
1060
1167
    Will delete even if readonly.
1061
1168
    """
1062
1169
    try:
1063
 
       _delete_file_or_dir(path)
1064
 
    except (OSError, IOError), e:
 
1170
        _delete_file_or_dir(path)
 
1171
    except (OSError, IOError) as e:
1065
1172
        if e.errno in (errno.EPERM, errno.EACCES):
1066
1173
            # make writable and try again
1067
1174
            try:
1079
1186
    # - root can damage a solaris file system by using unlink,
1080
1187
    # - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
1081
1188
    #   EACCES, OSX: EPERM) when invoked on a directory.
1082
 
    if isdir(path): # Takes care of symlinks
 
1189
    if isdir(path):  # Takes care of symlinks
1083
1190
        os.rmdir(path)
1084
1191
    else:
1085
1192
        os.unlink(path)
1127
1234
    #    separators
1128
1235
    # 3) '\xa0' isn't unicode safe since it is >128.
1129
1236
 
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':
 
1237
    if isinstance(s, str):
 
1238
        ws = ' \t\n\r\v\f'
 
1239
    else:
 
1240
        ws = (b' ', b'\t', b'\n', b'\r', b'\v', b'\f')
 
1241
    for ch in ws:
1135
1242
        if ch in s:
1136
1243
            return True
1137
1244
    else:
1163
1270
 
1164
1271
    if len(base) < MIN_ABS_PATHLENGTH:
1165
1272
        # must have space for e.g. a drive letter
1166
 
        raise ValueError('%r is too short to calculate a relative path'
1167
 
            % (base,))
 
1273
        raise ValueError(gettext('%r is too short to calculate a relative path')
 
1274
                         % (base,))
1168
1275
 
1169
1276
    rp = abspath(path)
1170
1277
 
1215
1322
        lbit = bit.lower()
1216
1323
        try:
1217
1324
            next_entries = _listdir(current)
1218
 
        except OSError: # enoent, eperm, etc
 
1325
        except OSError:  # enoent, eperm, etc
1219
1326
            # We can't find this in the filesystem, so just append the
1220
1327
            # remaining bits.
1221
1328
            current = pathjoin(current, bit, *list(bit_iter))
1232
1339
            break
1233
1340
    return current[len(abs_base):].lstrip('/')
1234
1341
 
 
1342
 
1235
1343
# XXX - TODO - we need better detection/integration of case-insensitive
1236
1344
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
1237
1345
# filesystems), for example, so could probably benefit from the same basic
1242
1350
else:
1243
1351
    canonical_relpath = relpath
1244
1352
 
 
1353
 
1245
1354
def canonical_relpaths(base, paths):
1246
1355
    """Create an iterable to canonicalize a sequence of relative paths.
1247
1356
 
1251
1360
    # but for now, we haven't optimized...
1252
1361
    return [canonical_relpath(base, p) for p in paths]
1253
1362
 
 
1363
 
 
1364
def decode_filename(filename):
 
1365
    """Decode the filename using the filesystem encoding
 
1366
 
 
1367
    If it is unicode, it is returned.
 
1368
    Otherwise it is decoded from the the filesystem's encoding. If decoding
 
1369
    fails, a errors.BadFilenameEncoding exception is raised.
 
1370
    """
 
1371
    if isinstance(filename, text_type):
 
1372
        return filename
 
1373
    try:
 
1374
        return filename.decode(_fs_enc)
 
1375
    except UnicodeDecodeError:
 
1376
        raise errors.BadFilenameEncoding(filename, _fs_enc)
 
1377
 
 
1378
 
1254
1379
def safe_unicode(unicode_or_utf8_string):
1255
1380
    """Coerce unicode_or_utf8_string into unicode.
1256
1381
 
1258
1383
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
1259
1384
    wrapped in a BzrBadParameterNotUnicode exception.
1260
1385
    """
1261
 
    if isinstance(unicode_or_utf8_string, unicode):
 
1386
    if isinstance(unicode_or_utf8_string, text_type):
1262
1387
        return unicode_or_utf8_string
1263
1388
    try:
1264
1389
        return unicode_or_utf8_string.decode('utf8')
1272
1397
    If it is a str, it is returned.
1273
1398
    If it is Unicode, it is encoded into a utf-8 string.
1274
1399
    """
1275
 
    if isinstance(unicode_or_utf8_string, str):
 
1400
    if isinstance(unicode_or_utf8_string, bytes):
1276
1401
        # TODO: jam 20070209 This is overkill, and probably has an impact on
1277
1402
        #       performance if we are dealing with lots of apis that want a
1278
1403
        #       utf-8 revision id
1285
1410
    return unicode_or_utf8_string.encode('utf-8')
1286
1411
 
1287
1412
 
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):
 
1413
def safe_revision_id(unicode_or_utf8_string):
1294
1414
    """Revision ids should now be utf8, but at one point they were unicode.
1295
1415
 
1296
1416
    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be
1297
1417
        utf8 or None).
1298
 
    :param warn: Functions that are sanitizing user data can set warn=False
1299
1418
    :return: None or a utf8 revision id.
1300
1419
    """
1301
1420
    if (unicode_or_utf8_string is None
1302
 
        or unicode_or_utf8_string.__class__ == str):
 
1421
            or unicode_or_utf8_string.__class__ == bytes):
1303
1422
        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):
 
1423
    raise TypeError('Unicode revision ids are no longer supported. '
 
1424
                    'Revision id generators should be creating utf8 revision '
 
1425
                    'ids.')
 
1426
 
 
1427
 
 
1428
def safe_file_id(unicode_or_utf8_string):
1315
1429
    """File ids should now be utf8, but at one point they were unicode.
1316
1430
 
1317
1431
    This is the same as safe_utf8, except it uses the cached encode functions
1319
1433
 
1320
1434
    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be
1321
1435
        utf8 or None).
1322
 
    :param warn: Functions that are sanitizing user data can set warn=False
1323
1436
    :return: None or a utf8 file id.
1324
1437
    """
1325
1438
    if (unicode_or_utf8_string is None
1326
 
        or unicode_or_utf8_string.__class__ == str):
 
1439
            or unicode_or_utf8_string.__class__ == bytes):
1327
1440
        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)
 
1441
    raise TypeError('Unicode file ids are no longer supported. '
 
1442
                    'File id generators should be creating utf8 file ids.')
1332
1443
 
1333
1444
 
1334
1445
_platform_normalizes_filenames = False
1339
1450
def normalizes_filenames():
1340
1451
    """Return True if this platform normalizes unicode filenames.
1341
1452
 
1342
 
    Mac OSX does, Windows/Linux do not.
 
1453
    Only Mac OSX.
1343
1454
    """
1344
1455
    return _platform_normalizes_filenames
1345
1456
 
1350
1461
    On platforms where the system normalizes filenames (Mac OSX),
1351
1462
    you can access a file by any path which will normalize correctly.
1352
1463
    On platforms where the system does not normalize filenames
1353
 
    (Windows, Linux), you have to access a file by its exact path.
 
1464
    (everything else), you have to access a file by its exact path.
1354
1465
 
1355
1466
    Internally, bzr only supports NFC normalization, since that is
1356
1467
    the standard for XML documents.
1359
1470
    can be accessed by that path.
1360
1471
    """
1361
1472
 
1362
 
    return unicodedata.normalize('NFC', unicode(path)), True
 
1473
    if isinstance(path, bytes):
 
1474
        path = path.decode(sys.getfilesystemencoding())
 
1475
    return unicodedata.normalize('NFC', path), True
1363
1476
 
1364
1477
 
1365
1478
def _inaccessible_normalized_filename(path):
1366
1479
    __doc__ = _accessible_normalized_filename.__doc__
1367
1480
 
1368
 
    normalized = unicodedata.normalize('NFC', unicode(path))
 
1481
    if isinstance(path, bytes):
 
1482
        path = path.decode(sys.getfilesystemencoding())
 
1483
    normalized = unicodedata.normalize('NFC', path)
1369
1484
    return normalized, normalized == path
1370
1485
 
1371
1486
 
1394
1509
    except AttributeError:
1395
1510
        # siginterrupt doesn't exist on this platform, or for this version
1396
1511
        # of Python.
1397
 
        siginterrupt = lambda signum, flag: None
 
1512
        def siginterrupt(signum, flag): return None
1398
1513
    if restart_syscall:
1399
1514
        def sig_handler(*args):
1400
1515
            # Python resets the siginterrupt flag when a signal is
1418
1533
terminal_width() returns None.
1419
1534
"""
1420
1535
 
 
1536
# Keep some state so that terminal_width can detect if _terminal_size has
 
1537
# returned a different size since the process started.  See docstring and
 
1538
# comments of terminal_width for details.
 
1539
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
 
1540
_terminal_size_state = 'no_data'
 
1541
_first_terminal_size = None
 
1542
 
1421
1543
 
1422
1544
def terminal_width():
1423
1545
    """Return terminal width.
1425
1547
    None is returned if the width can't established precisely.
1426
1548
 
1427
1549
    The rules are:
1428
 
    - if BZR_COLUMNS is set, returns its value
 
1550
    - if BRZ_COLUMNS is set, returns its value
1429
1551
    - if there is no controlling terminal, returns None
 
1552
    - query the OS, if the queried size has changed since the last query,
 
1553
      return its value,
1430
1554
    - if COLUMNS is set, returns its value,
 
1555
    - if the OS has a value (even though it's never changed), return its value.
1431
1556
 
1432
1557
    From there, we need to query the OS to get the size of the controlling
1433
1558
    terminal.
1434
1559
 
1435
 
    Unices:
 
1560
    On Unices we query the OS by:
1436
1561
    - get termios.TIOCGWINSZ
1437
1562
    - if an error occurs or a negative value is obtained, returns None
1438
1563
 
1439
 
    Windows:
1440
 
    
 
1564
    On Windows we query the OS by:
1441
1565
    - win32utils.get_console_size() decides,
1442
1566
    - returns None on error (provided default value)
1443
1567
    """
 
1568
    # Note to implementors: if changing the rules for determining the width,
 
1569
    # make sure you've considered the behaviour in these cases:
 
1570
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
 
1571
    #  - brz log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
 
1572
    #    0,0.
 
1573
    #  - (add more interesting cases here, if you find any)
 
1574
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
 
1575
    # but we don't want to register a signal handler because it is impossible
 
1576
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
 
1577
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
 
1578
    # time so we can notice if the reported size has changed, which should have
 
1579
    # a similar effect.
1444
1580
 
1445
 
    # If BZR_COLUMNS is set, take it, user is always right
 
1581
    # If BRZ_COLUMNS is set, take it, user is always right
 
1582
    # Except if they specified 0 in which case, impose no limit here
1446
1583
    try:
1447
 
        return int(os.environ['BZR_COLUMNS'])
 
1584
        width = int(os.environ['BRZ_COLUMNS'])
1448
1585
    except (KeyError, ValueError):
1449
 
        pass
 
1586
        width = None
 
1587
    if width is not None:
 
1588
        if width > 0:
 
1589
            return width
 
1590
        else:
 
1591
            return None
1450
1592
 
1451
1593
    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.
 
1594
    if isatty is None or not isatty():
 
1595
        # Don't guess, setting BRZ_COLUMNS is the recommended way to override.
1454
1596
        return None
1455
1597
 
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))
 
1598
    # Query the OS
 
1599
    width, height = os_size = _terminal_size(None, None)
 
1600
    global _first_terminal_size, _terminal_size_state
 
1601
    if _terminal_size_state == 'no_data':
 
1602
        _first_terminal_size = os_size
 
1603
        _terminal_size_state = 'unchanged'
 
1604
    elif (_terminal_size_state == 'unchanged' and
 
1605
          _first_terminal_size != os_size):
 
1606
        _terminal_size_state = 'changed'
 
1607
 
 
1608
    # If the OS claims to know how wide the terminal is, and this value has
 
1609
    # ever changed, use that.
 
1610
    if _terminal_size_state == 'changed':
 
1611
        if width is not None and width > 0:
 
1612
            return width
 
1613
 
 
1614
    # If COLUMNS is set, use it.
1459
1615
    try:
1460
1616
        return int(os.environ['COLUMNS'])
1461
1617
    except (KeyError, ValueError):
1462
1618
        pass
1463
1619
 
1464
 
    width, height = _terminal_size(None, None)
1465
 
    if width <= 0:
1466
 
        # Consider invalid values as meaning no width
1467
 
        return None
 
1620
    # Finally, use an unchanged size from the OS, if we have one.
 
1621
    if _terminal_size_state == 'unchanged':
 
1622
        if width is not None and width > 0:
 
1623
            return width
1468
1624
 
1469
 
    return width
 
1625
    # The width could not be determined.
 
1626
    return None
1470
1627
 
1471
1628
 
1472
1629
def _win32_terminal_size(width, height):
1473
 
    width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
 
1630
    width, height = win32utils.get_console_size(
 
1631
        defaultx=width, defaulty=height)
1474
1632
    return width, height
1475
1633
 
1476
1634
 
1477
1635
def _ioctl_terminal_size(width, height):
1478
1636
    try:
1479
 
        import struct, fcntl, termios
 
1637
        import struct
 
1638
        import fcntl
 
1639
        import termios
1480
1640
        s = struct.pack('HHHH', 0, 0, 0, 0)
1481
1641
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1482
1642
        height, width = struct.unpack('HHHH', x)[0:2]
1484
1644
        pass
1485
1645
    return width, height
1486
1646
 
 
1647
 
1487
1648
_terminal_size = None
1488
1649
"""Returns the terminal size as (width, height).
1489
1650
 
1499
1660
    _terminal_size = _ioctl_terminal_size
1500
1661
 
1501
1662
 
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
1663
def supports_executable():
1528
1664
    return sys.platform != "win32"
1529
1665
 
1554
1690
        if orig_val is not None:
1555
1691
            del os.environ[env_variable]
1556
1692
    else:
1557
 
        if isinstance(value, unicode):
 
1693
        if not PY3 and isinstance(value, text_type):
1558
1694
            value = value.encode(get_user_encoding())
1559
1695
        os.environ[env_variable] = value
1560
1696
    return orig_val
1574
1710
        raise errors.IllegalPath(path)
1575
1711
 
1576
1712
 
1577
 
_WIN32_ERROR_DIRECTORY = 267 # Similar to errno.ENOTDIR
 
1713
_WIN32_ERROR_DIRECTORY = 267  # Similar to errno.ENOTDIR
 
1714
 
1578
1715
 
1579
1716
def _is_error_enotdir(e):
1580
1717
    """Check if this exception represents ENOTDIR.
1592
1729
    :return: True if this represents an ENOTDIR error. False otherwise.
1593
1730
    """
1594
1731
    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
 
        ))):
 
1732
    if (en == errno.ENOTDIR or
 
1733
        (sys.platform == 'win32' and
 
1734
            (en == _WIN32_ERROR_DIRECTORY or
 
1735
             (en == errno.EINVAL
 
1736
              and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
 
1737
             ))):
1601
1738
        return True
1602
1739
    return False
1603
1740
 
1630
1767
        rooted higher up.
1631
1768
    :return: an iterator over the dirs.
1632
1769
    """
1633
 
    #TODO there is a bit of a smell where the results of the directory-
 
1770
    # TODO there is a bit of a smell where the results of the directory-
1634
1771
    # summary in this, and the path from the root, may not agree
1635
1772
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
1636
1773
    # potentially confusing output. We should make this more robust - but
1652
1789
        dirblock = []
1653
1790
        append = dirblock.append
1654
1791
        try:
1655
 
            names = sorted(_listdir(top))
1656
 
        except OSError, e:
 
1792
            names = sorted(map(decode_filename, _listdir(top)))
 
1793
        except OSError as e:
1657
1794
            if not _is_error_enotdir(e):
1658
1795
                raise
1659
1796
        else:
1712
1849
    """
1713
1850
    global _selected_dir_reader
1714
1851
    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.
 
1852
        if sys.platform == "win32":
1722
1853
            try:
1723
 
                from bzrlib._walkdirs_win32 import Win32ReadDir
 
1854
                from ._walkdirs_win32 import Win32ReadDir
1724
1855
                _selected_dir_reader = Win32ReadDir()
1725
1856
            except ImportError:
1726
1857
                pass
1727
 
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1728
 
            # ANSI_X3.4-1968 is a form of ASCII
 
1858
        elif _fs_enc in ('utf-8', 'ascii'):
1729
1859
            try:
1730
 
                from bzrlib._readdir_pyx import UTF8DirReader
 
1860
                from ._readdir_pyx import UTF8DirReader
1731
1861
                _selected_dir_reader = UTF8DirReader()
1732
 
            except ImportError, e:
 
1862
            except ImportError as e:
1733
1863
                failed_to_load_extension(e)
1734
1864
                pass
1735
1865
 
1780
1910
        See DirReader.read_dir for details.
1781
1911
        """
1782
1912
        _utf8_encode = self._utf8_encode
 
1913
 
 
1914
        def _fs_decode(s): return s.decode(_fs_enc)
 
1915
 
 
1916
        def _fs_encode(s): return s.encode(_fs_enc)
1783
1917
        _lstat = os.lstat
1784
1918
        _listdir = os.listdir
1785
1919
        _kind_from_mode = file_kind_from_stat_mode
1786
1920
 
1787
1921
        if prefix:
1788
 
            relprefix = prefix + '/'
 
1922
            relprefix = prefix + b'/'
1789
1923
        else:
1790
 
            relprefix = ''
1791
 
        top_slash = top + u'/'
 
1924
            relprefix = b''
 
1925
        top_slash = top + '/'
1792
1926
 
1793
1927
        dirblock = []
1794
1928
        append = dirblock.append
1795
 
        for name in sorted(_listdir(top)):
 
1929
        for name_native in _listdir(top.encode('utf-8')):
1796
1930
            try:
1797
 
                name_utf8 = _utf8_encode(name)[0]
 
1931
                name = _fs_decode(name_native)
1798
1932
            except UnicodeDecodeError:
1799
1933
                raise errors.BadFilenameEncoding(
1800
 
                    _utf8_encode(relprefix)[0] + name, _fs_enc)
 
1934
                    relprefix + name_native, _fs_enc)
 
1935
            name_utf8 = _utf8_encode(name)[0]
1801
1936
            abspath = top_slash + name
1802
1937
            statvalue = _lstat(abspath)
1803
1938
            kind = _kind_from_mode(statvalue.st_mode)
1804
1939
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
1805
 
        return dirblock
 
1940
        return sorted(dirblock)
1806
1941
 
1807
1942
 
1808
1943
def copy_tree(from_path, to_path, handlers={}):
1833
1968
        link_to = os.readlink(source)
1834
1969
        os.symlink(link_to, dest)
1835
1970
 
1836
 
    real_handlers = {'file':shutil.copy2,
1837
 
                     'symlink':copy_link,
1838
 
                     'directory':copy_dir,
1839
 
                    }
 
1971
    real_handlers = {'file': shutil.copy2,
 
1972
                     'symlink': copy_link,
 
1973
                     'directory': copy_dir,
 
1974
                     }
1840
1975
    real_handlers.update(handlers)
1841
1976
 
1842
1977
    if not os.path.exists(to_path):
1857
1992
    if chown is None:
1858
1993
        return
1859
1994
 
1860
 
    if src == None:
 
1995
    if src is None:
1861
1996
        src = os.path.dirname(dst)
1862
1997
        if src == '':
1863
1998
            src = '.'
1865
2000
    try:
1866
2001
        s = os.stat(src)
1867
2002
        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))
 
2003
    except OSError:
 
2004
        trace.warning(
 
2005
            'Unable to copy ownership from "%s" to "%s". '
 
2006
            'You may want to set it manually.', src, dst)
 
2007
        trace.log_exception_quietly()
1870
2008
 
1871
2009
 
1872
2010
def path_prefix_key(path):
1874
2012
 
1875
2013
    This can be used to sort paths in the same way that walkdirs does.
1876
2014
    """
1877
 
    return (dirname(path) , path)
 
2015
    return (dirname(path), path)
1878
2016
 
1879
2017
 
1880
2018
def compare_paths_prefix_order(path_a, path_b):
1881
2019
    """Compare path_a and path_b to generate the same order walkdirs uses."""
1882
2020
    key_a = path_prefix_key(path_a)
1883
2021
    key_b = path_prefix_key(path_b)
1884
 
    return cmp(key_a, key_b)
 
2022
    return (key_a > key_b) - (key_a < key_b)
1885
2023
 
1886
2024
 
1887
2025
_cached_user_encoding = None
1888
2026
 
1889
2027
 
1890
 
def get_user_encoding(use_cache=True):
 
2028
def get_user_encoding():
1891
2029
    """Find out what the preferred user encoding is.
1892
2030
 
1893
2031
    This is generally the encoding that is used for command line parameters
1894
2032
    and file contents. This may be different from the terminal encoding
1895
2033
    or the filesystem encoding.
1896
2034
 
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
2035
    :return: A string defining the preferred user encoding
1902
2036
    """
1903
2037
    global _cached_user_encoding
1904
 
    if _cached_user_encoding is not None and use_cache:
 
2038
    if _cached_user_encoding is not None:
1905
2039
        return _cached_user_encoding
1906
2040
 
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'
 
2041
    if os.name == 'posix' and getattr(locale, 'CODESET', None) is not None:
 
2042
        # Use the existing locale settings and call nl_langinfo directly
 
2043
        # rather than going through getpreferredencoding. This avoids
 
2044
        # <http://bugs.python.org/issue6202> on OSX Python 2.6 and the
 
2045
        # possibility of the setlocale call throwing an error.
 
2046
        user_encoding = locale.nl_langinfo(locale.CODESET)
1924
2047
    else:
1925
 
        import locale
 
2048
        # GZ 2011-12-19: On windows could call GetACP directly instead.
 
2049
        user_encoding = locale.getpreferredencoding(False)
1926
2050
 
1927
2051
    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:'
 
2052
        user_encoding = codecs.lookup(user_encoding).name
 
2053
    except LookupError:
 
2054
        if user_encoding not in ("", "cp0"):
 
2055
            sys.stderr.write('brz: warning:'
1951
2056
                             ' unknown encoding %s.'
1952
2057
                             ' Continuing with ascii encoding.\n'
1953
2058
                             % user_encoding
1954
 
                            )
1955
 
            user_encoding = 'ascii'
1956
 
 
1957
 
    if use_cache:
1958
 
        _cached_user_encoding = user_encoding
1959
 
 
 
2059
                             )
 
2060
        user_encoding = 'ascii'
 
2061
    else:
 
2062
        # Get 'ascii' when setlocale has not been called or LANG=C or unset.
 
2063
        if user_encoding == 'ascii':
 
2064
            if sys.platform == 'darwin':
 
2065
                # OSX is special-cased in Python to have a UTF-8 filesystem
 
2066
                # encoding and previously had LANG set here if not present.
 
2067
                user_encoding = 'utf-8'
 
2068
            # GZ 2011-12-19: Maybe UTF-8 should be the default in this case
 
2069
            #                for some other posix platforms as well.
 
2070
 
 
2071
    _cached_user_encoding = user_encoding
1960
2072
    return user_encoding
1961
2073
 
1962
2074
 
 
2075
def get_diff_header_encoding():
 
2076
    return get_terminal_encoding()
 
2077
 
 
2078
 
1963
2079
def get_host_name():
1964
2080
    """Return the current unicode host name.
1965
2081
 
1967
2083
    behaves inconsistently on different platforms.
1968
2084
    """
1969
2085
    if sys.platform == "win32":
1970
 
        import win32utils
1971
2086
        return win32utils.get_host_name()
1972
2087
    else:
1973
2088
        import socket
 
2089
        if PY3:
 
2090
            return socket.gethostname()
1974
2091
        return socket.gethostname().decode(get_user_encoding())
1975
2092
 
1976
2093
 
1980
2097
# data at once.
1981
2098
MAX_SOCKET_CHUNK = 64 * 1024
1982
2099
 
 
2100
_end_of_stream_errors = [errno.ECONNRESET, errno.EPIPE, errno.EINVAL]
 
2101
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
 
2102
    _eno = getattr(errno, _eno, None)
 
2103
    if _eno is not None:
 
2104
        _end_of_stream_errors.append(_eno)
 
2105
del _eno
 
2106
 
 
2107
 
1983
2108
def read_bytes_from_socket(sock, report_activity=None,
1984
 
        max_read_size=MAX_SOCKET_CHUNK):
 
2109
                           max_read_size=MAX_SOCKET_CHUNK):
1985
2110
    """Read up to max_read_size of bytes from sock and notify of progress.
1986
2111
 
1987
2112
    Translates "Connection reset by peer" into file-like EOF (return an
1988
2113
    empty string rather than raise an error), and repeats the recv if
1989
2114
    interrupted by a signal.
1990
2115
    """
1991
 
    while 1:
 
2116
    while True:
1992
2117
        try:
1993
 
            bytes = sock.recv(max_read_size)
1994
 
        except socket.error, e:
 
2118
            data = sock.recv(max_read_size)
 
2119
        except socket.error as e:
1995
2120
            eno = e.args[0]
1996
 
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
 
2121
            if eno in _end_of_stream_errors:
1997
2122
                # The connection was closed by the other side.  Callers expect
1998
2123
                # an empty string to signal end-of-stream.
1999
 
                return ""
 
2124
                return b""
2000
2125
            elif eno == errno.EINTR:
2001
2126
                # Retry the interrupted recv.
2002
2127
                continue
2003
2128
            raise
2004
2129
        else:
2005
2130
            if report_activity is not None:
2006
 
                report_activity(len(bytes), 'read')
2007
 
            return bytes
 
2131
                report_activity(len(data), 'read')
 
2132
            return data
2008
2133
 
2009
2134
 
2010
2135
def recv_all(socket, count):
2017
2142
 
2018
2143
    This isn't optimized and is intended mostly for use in testing.
2019
2144
    """
2020
 
    b = ''
 
2145
    b = b''
2021
2146
    while len(b) < count:
2022
2147
        new = read_bytes_from_socket(socket, None, count - len(b))
2023
 
        if new == '':
2024
 
            break # eof
 
2148
        if new == b'':
 
2149
            break  # eof
2025
2150
        b += new
2026
2151
    return b
2027
2152
 
2028
2153
 
2029
2154
def send_all(sock, bytes, report_activity=None):
2030
2155
    """Send all bytes on a socket.
2031
 
 
 
2156
 
2032
2157
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2033
2158
    some platforms, and catches EINTR which may be thrown if the send is
2034
2159
    interrupted by a signal.
2035
2160
 
2036
2161
    This is preferred to socket.sendall(), because it avoids portability bugs
2037
2162
    and provides activity reporting.
2038
 
 
 
2163
 
2039
2164
    :param report_activity: Call this as bytes are read, see
2040
2165
        Transport._report_activity
2041
2166
    """
2042
2167
    sent_total = 0
2043
2168
    byte_count = len(bytes)
 
2169
    view = memoryview(bytes)
2044
2170
    while sent_total < byte_count:
2045
2171
        try:
2046
 
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2047
 
        except socket.error, e:
 
2172
            sent = sock.send(view[sent_total:sent_total + MAX_SOCKET_CHUNK])
 
2173
        except (socket.error, IOError) as e:
 
2174
            if e.args[0] in _end_of_stream_errors:
 
2175
                raise errors.ConnectionReset(
 
2176
                    "Error trying to write to socket", e)
2048
2177
            if e.args[0] != errno.EINTR:
2049
2178
                raise
2050
2179
        else:
 
2180
            if sent == 0:
 
2181
                raise errors.ConnectionReset('Sending to %s returned 0 bytes'
 
2182
                                             % (sock,))
2051
2183
            sent_total += sent
2052
 
            report_activity(sent, 'write')
 
2184
            if report_activity is not None:
 
2185
                report_activity(sent, 'write')
 
2186
 
 
2187
 
 
2188
def connect_socket(address):
 
2189
    # Slight variation of the socket.create_connection() function (provided by
 
2190
    # python-2.6) that can fail if getaddrinfo returns an empty list. We also
 
2191
    # provide it for previous python versions. Also, we don't use the timeout
 
2192
    # parameter (provided by the python implementation) so we don't implement
 
2193
    # it either).
 
2194
    err = socket.error('getaddrinfo returns an empty list')
 
2195
    host, port = address
 
2196
    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
 
2197
        af, socktype, proto, canonname, sa = res
 
2198
        sock = None
 
2199
        try:
 
2200
            sock = socket.socket(af, socktype, proto)
 
2201
            sock.connect(sa)
 
2202
            return sock
 
2203
 
 
2204
        except socket.error as e:
 
2205
            err = e
 
2206
            # 'err' is now the most recent error
 
2207
            if sock is not None:
 
2208
                sock.close()
 
2209
    raise err
2053
2210
 
2054
2211
 
2055
2212
def dereference_path(path):
2074
2231
def resource_string(package, resource_name):
2075
2232
    """Load a resource from a package and return it as a string.
2076
2233
 
2077
 
    Note: Only packages that start with bzrlib are currently supported.
 
2234
    Note: Only packages that start with breezy are currently supported.
2078
2235
 
2079
2236
    This is designed to be a lightweight implementation of resource
2080
2237
    loading in a way which is API compatible with the same API from
2083
2240
    If and when pkg_resources becomes a standard library, this routine
2084
2241
    can delegate to it.
2085
2242
    """
2086
 
    # Check package name is within bzrlib
2087
 
    if package == "bzrlib":
 
2243
    # Check package name is within breezy
 
2244
    if package == "breezy":
2088
2245
        resource_relpath = resource_name
2089
 
    elif package.startswith("bzrlib."):
2090
 
        package = package[len("bzrlib."):].replace('.', os.sep)
 
2246
    elif package.startswith("breezy."):
 
2247
        package = package[len("breezy."):].replace('.', os.sep)
2091
2248
        resource_relpath = pathjoin(package, resource_name)
2092
2249
    else:
2093
 
        raise errors.BzrError('resource package %s not in bzrlib' % package)
 
2250
        raise errors.BzrError('resource package %s not in breezy' % package)
2094
2251
 
2095
2252
    # Map the resource to a file and read its contents
2096
 
    base = dirname(bzrlib.__file__)
 
2253
    base = dirname(breezy.__file__)
2097
2254
    if getattr(sys, 'frozen', None):    # bzr.exe
2098
2255
        base = abspath(pathjoin(base, '..', '..'))
2099
 
    filename = pathjoin(base, resource_relpath)
2100
 
    return open(filename, 'rU').read()
 
2256
    with open(pathjoin(base, resource_relpath), "rt") as f:
 
2257
        return f.read()
2101
2258
 
2102
2259
 
2103
2260
def file_kind_from_stat_mode_thunk(mode):
2104
2261
    global file_kind_from_stat_mode
2105
2262
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
2106
2263
        try:
2107
 
            from bzrlib._readdir_pyx import UTF8DirReader
 
2264
            from ._readdir_pyx import UTF8DirReader
2108
2265
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
2109
 
        except ImportError, e:
 
2266
        except ImportError:
2110
2267
            # This is one time where we won't warn that an extension failed to
2111
2268
            # load. The extension is never available on Windows anyway.
2112
 
            from bzrlib._readdir_py import (
 
2269
            from ._readdir_py import (
2113
2270
                _kind_from_mode as file_kind_from_stat_mode
2114
2271
                )
2115
2272
    return file_kind_from_stat_mode(mode)
 
2273
 
 
2274
 
2116
2275
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2117
2276
 
2118
2277
 
2119
 
def file_kind(f, _lstat=os.lstat):
 
2278
def file_stat(f, _lstat=os.lstat):
2120
2279
    try:
2121
 
        return file_kind_from_stat_mode(_lstat(f).st_mode)
2122
 
    except OSError, e:
 
2280
        # XXX cache?
 
2281
        return _lstat(f)
 
2282
    except OSError as e:
2123
2283
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2124
2284
            raise errors.NoSuchFile(f)
2125
2285
        raise
2126
2286
 
2127
2287
 
 
2288
def file_kind(f, _lstat=os.lstat):
 
2289
    stat_value = file_stat(f, _lstat)
 
2290
    return file_kind_from_stat_mode(stat_value.st_mode)
 
2291
 
 
2292
 
2128
2293
def until_no_eintr(f, *a, **kw):
2129
2294
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2130
 
    
 
2295
 
2131
2296
    WARNING: you must be certain that it is safe to retry the call repeatedly
2132
2297
    if EINTR does occur.  This is typically only true for low-level operations
2133
2298
    like os.read.  If in any doubt, don't use this.
2135
2300
    Keep in mind that this is not a complete solution to EINTR.  There is
2136
2301
    probably code in the Python standard library and other dependencies that
2137
2302
    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
 
2303
    that signal).  So this function can reduce the impact for IO that breezy
2139
2304
    directly controls, but it is not a complete solution.
2140
2305
    """
2141
2306
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
2142
2307
    while True:
2143
2308
        try:
2144
2309
            return f(*a, **kw)
2145
 
        except (IOError, OSError), e:
 
2310
        except (IOError, OSError) as e:
2146
2311
            if e.errno == errno.EINTR:
2147
2312
                continue
2148
2313
            raise
2149
2314
 
2150
2315
 
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
2316
if sys.platform == "win32":
2175
 
    import msvcrt
2176
2317
    def getchar():
 
2318
        import msvcrt
2177
2319
        return msvcrt.getch()
2178
2320
else:
2179
 
    import tty
2180
 
    import termios
2181
2321
    def getchar():
 
2322
        import tty
 
2323
        import termios
2182
2324
        fd = sys.stdin.fileno()
2183
2325
        settings = termios.tcgetattr(fd)
2184
2326
        try:
2188
2330
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2189
2331
        return ch
2190
2332
 
2191
 
 
2192
 
if sys.platform == 'linux2':
 
2333
if sys.platform.startswith('linux'):
2193
2334
    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
 
2335
        try:
 
2336
            return os.sysconf('SC_NPROCESSORS_ONLN')
 
2337
        except (ValueError, OSError, AttributeError):
 
2338
            return None
2200
2339
elif sys.platform == 'darwin':
2201
2340
    def _local_concurrency():
2202
2341
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2203
2342
                                stdout=subprocess.PIPE).communicate()[0]
2204
 
elif sys.platform[0:7] == 'freebsd':
 
2343
elif "bsd" in sys.platform:
2205
2344
    def _local_concurrency():
2206
2345
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2207
2346
                                stdout=subprocess.PIPE).communicate()[0]
2208
2347
elif sys.platform == 'sunos5':
2209
2348
    def _local_concurrency():
2210
 
        return subprocess.Popen(['psrinfo', '-p',],
 
2349
        return subprocess.Popen(['psrinfo', '-p', ],
2211
2350
                                stdout=subprocess.PIPE).communicate()[0]
2212
2351
elif sys.platform == "win32":
2213
2352
    def _local_concurrency():
2221
2360
 
2222
2361
_cached_local_concurrency = None
2223
2362
 
 
2363
 
2224
2364
def local_concurrency(use_cache=True):
2225
2365
    """Return how many processes can be run concurrently.
2226
2366
 
2232
2372
    if _cached_local_concurrency is not None and use_cache:
2233
2373
        return _cached_local_concurrency
2234
2374
 
2235
 
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
 
2375
    concurrency = os.environ.get('BRZ_CONCURRENCY', None)
2236
2376
    if concurrency is None:
 
2377
        import multiprocessing
2237
2378
        try:
2238
 
            concurrency = _local_concurrency()
2239
 
        except (OSError, IOError):
2240
 
            pass
 
2379
            concurrency = multiprocessing.cpu_count()
 
2380
        except NotImplementedError:
 
2381
            # multiprocessing.cpu_count() isn't implemented on all platforms
 
2382
            try:
 
2383
                concurrency = _local_concurrency()
 
2384
            except (OSError, IOError):
 
2385
                pass
2241
2386
    try:
2242
2387
        concurrency = int(concurrency)
2243
2388
    except (TypeError, ValueError):
2244
2389
        concurrency = 1
2245
2390
    if use_cache:
2246
 
        _cached_concurrency = concurrency
 
2391
        _cached_local_concurrency = concurrency
2247
2392
    return concurrency
2248
2393
 
2249
2394
 
2255
2400
        self.encode = encode
2256
2401
 
2257
2402
    def write(self, object):
2258
 
        if type(object) is str:
 
2403
        if isinstance(object, str):
2259
2404
            self.stream.write(object)
2260
2405
        else:
2261
2406
            data, _ = self.encode(object, self.errors)
2262
2407
            self.stream.write(data)
2263
2408
 
 
2409
 
2264
2410
if sys.platform == 'win32':
2265
2411
    def open_file(filename, mode='r', bufsize=-1):
2266
2412
        """This function is used to override the ``open`` builtin.
2267
 
        
 
2413
 
2268
2414
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2269
2415
        child processes.  Deleting or renaming a closed file opened with this
2270
2416
        function is not blocking child processes.
2294
2440
            else:
2295
2441
                flags |= os.O_WRONLY
2296
2442
            flags |= os.O_CREAT | os.O_APPEND
2297
 
        else: #reading
 
2443
        else:  # reading
2298
2444
            if updating:
2299
2445
                flags |= os.O_RDWR
2300
2446
            else:
2305
2451
    open_file = open
2306
2452
 
2307
2453
 
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
 
2454
def available_backup_name(base, exists):
 
2455
    """Find a non-existing backup file name.
 
2456
 
 
2457
    This will *not* create anything, this only return a 'free' entry.  This
 
2458
    should be used for checking names in a directory below a locked
 
2459
    tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
 
2460
    Leap) and generally discouraged.
 
2461
 
 
2462
    :param base: The base name.
 
2463
 
 
2464
    :param exists: A callable returning True if the path parameter exists.
 
2465
    """
 
2466
    counter = 1
 
2467
    name = "%s.~%d~" % (base, counter)
 
2468
    while exists(name):
 
2469
        counter += 1
 
2470
        name = "%s.~%d~" % (base, counter)
 
2471
    return name
 
2472
 
 
2473
 
 
2474
def set_fd_cloexec(fd):
 
2475
    """Set a Unix file descriptor's FD_CLOEXEC flag.  Do nothing if platform
 
2476
    support for this is not available.
 
2477
    """
 
2478
    try:
 
2479
        import fcntl
 
2480
        old = fcntl.fcntl(fd, fcntl.F_GETFD)
 
2481
        fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
 
2482
    except (ImportError, AttributeError):
 
2483
        # Either the fcntl module or specific constants are not present
 
2484
        pass
 
2485
 
 
2486
 
 
2487
def find_executable_on_path(name):
 
2488
    """Finds an executable on the PATH.
 
2489
 
 
2490
    On Windows, this will try to append each extension in the PATHEXT
 
2491
    environment variable to the name, if it cannot be found with the name
 
2492
    as given.
 
2493
 
 
2494
    :param name: The base name of the executable.
 
2495
    :return: The path to the executable found or None.
 
2496
    """
 
2497
    if sys.platform == 'win32':
 
2498
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
 
2499
        exts = [ext.lower() for ext in exts]
 
2500
        base, ext = os.path.splitext(name)
 
2501
        if ext != '':
 
2502
            if ext.lower() not in exts:
 
2503
                return None
 
2504
            name = base
 
2505
            exts = [ext]
 
2506
    else:
 
2507
        exts = ['']
 
2508
    path = os.environ.get('PATH')
 
2509
    if path is not None:
 
2510
        path = path.split(os.pathsep)
 
2511
        for ext in exts:
 
2512
            for d in path:
 
2513
                f = os.path.join(d, name) + ext
 
2514
                if os.access(f, os.X_OK):
 
2515
                    return f
 
2516
    if sys.platform == 'win32':
 
2517
        app_path = win32utils.get_app_path(name)
 
2518
        if app_path != name:
 
2519
            return app_path
 
2520
    return None
 
2521
 
 
2522
 
 
2523
def _posix_is_local_pid_dead(pid):
 
2524
    """True if pid doesn't correspond to live process on this machine"""
 
2525
    try:
 
2526
        # Special meaning of unix kill: just check if it's there.
 
2527
        os.kill(pid, 0)
 
2528
    except OSError as e:
 
2529
        if e.errno == errno.ESRCH:
 
2530
            # On this machine, and really not found: as sure as we can be
 
2531
            # that it's dead.
 
2532
            return True
 
2533
        elif e.errno == errno.EPERM:
 
2534
            # exists, though not ours
 
2535
            return False
 
2536
        else:
 
2537
            trace.mutter("os.kill(%d, 0) failed: %s" % (pid, e))
 
2538
            # Don't really know.
 
2539
            return False
 
2540
    else:
 
2541
        # Exists and our process: not dead.
 
2542
        return False
 
2543
 
 
2544
 
 
2545
if sys.platform == "win32":
 
2546
    is_local_pid_dead = win32utils.is_local_pid_dead
 
2547
else:
 
2548
    is_local_pid_dead = _posix_is_local_pid_dead
 
2549
 
 
2550
_maybe_ignored = ['EAGAIN', 'EINTR', 'ENOTSUP', 'EOPNOTSUPP', 'EACCES']
 
2551
_fdatasync_ignored = [getattr(errno, name) for name in _maybe_ignored
 
2552
                      if getattr(errno, name, None) is not None]
 
2553
 
 
2554
 
 
2555
def fdatasync(fileno):
 
2556
    """Flush file contents to disk if possible.
 
2557
 
 
2558
    :param fileno: Integer OS file handle.
 
2559
    :raises TransportNotPossible: If flushing to disk is not possible.
 
2560
    """
 
2561
    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))
 
2562
    if fn is not None:
 
2563
        try:
 
2564
            fn(fileno)
 
2565
        except IOError as e:
 
2566
            # See bug #1075108, on some platforms fdatasync exists, but can
 
2567
            # raise ENOTSUP. However, we are calling fdatasync to be helpful
 
2568
            # and reduce the chance of corruption-on-powerloss situations. It
 
2569
            # is not a mandatory call, so it is ok to suppress failures.
 
2570
            trace.mutter("ignoring error calling fdatasync: %s" % (e,))
 
2571
            if getattr(e, 'errno', None) not in _fdatasync_ignored:
 
2572
                raise
 
2573
 
 
2574
 
 
2575
def ensure_empty_directory_exists(path, exception_class):
 
2576
    """Make sure a local directory exists and is empty.
 
2577
 
 
2578
    If it does not exist, it is created.  If it exists and is not empty, an
 
2579
    instance of exception_class is raised.
 
2580
    """
 
2581
    try:
 
2582
        os.mkdir(path)
 
2583
    except OSError as e:
 
2584
        if e.errno != errno.EEXIST:
 
2585
            raise
 
2586
        if os.listdir(path) != []:
 
2587
            raise exception_class(path)
 
2588
 
 
2589
 
 
2590
def is_environment_error(evalue):
 
2591
    """True if exception instance is due to a process environment issue
 
2592
 
 
2593
    This includes OSError and IOError, but also other errors that come from
 
2594
    the operating system or core libraries but are not subclasses of those.
 
2595
    """
 
2596
    if isinstance(evalue, (EnvironmentError, select.error)):
 
2597
        return True
 
2598
    if sys.platform == "win32" and win32utils._is_pywintypes_error(evalue):
 
2599
        return True
 
2600
    return False
 
2601
 
 
2602
 
 
2603
if PY3:
 
2604
    perf_counter = time.perf_counter
 
2605
else:
 
2606
    perf_counter = time.clock