/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: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

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
 
30
from datetime import timedelta
29
31
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
 
                    )
 
32
import locale
 
33
import ntpath
36
34
import posixpath
 
35
import select
 
36
# We need to import both shutil and rmtree as we export the later on posix
 
37
# and need the former on windows
37
38
import shutil
38
 
from shutil import (
39
 
    rmtree,
40
 
    )
 
39
from shutil import rmtree
41
40
import socket
42
41
import subprocess
 
42
# We need to import both tempfile and mkdtemp as we export the later on posix
 
43
# and need the former on windows
43
44
import tempfile
44
 
from tempfile import (
45
 
    mkdtemp,
46
 
    )
 
45
from tempfile import mkdtemp
47
46
import unicodedata
48
47
 
49
 
from bzrlib import (
50
 
    cache_utf8,
 
48
from breezy import (
 
49
    config,
51
50
    errors,
52
51
    trace,
53
52
    win32utils,
54
53
    )
 
54
from breezy.i18n import gettext
55
55
""")
56
56
 
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
 
57
from .sixish import (
 
58
    PY3,
 
59
    text_type,
 
60
    )
 
61
 
 
62
from hashlib import (
 
63
    md5,
 
64
    sha1 as sha,
 
65
    )
 
66
 
 
67
 
 
68
import breezy
 
69
from . import _fs_enc
78
70
 
79
71
 
80
72
# Cross platform wall-clock time functionality with decent resolution.
98
90
 
99
91
 
100
92
def get_unicode_argv():
 
93
    if PY3:
 
94
        return sys.argv[1:]
101
95
    try:
102
96
        user_encoding = get_user_encoding()
103
97
        return [a.decode(user_encoding) for a in sys.argv[1:]]
104
98
    except UnicodeDecodeError:
105
 
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
106
 
                                                            "encoding." % a))
 
99
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
 
100
            "application locale.").format(a, user_encoding))
107
101
 
108
102
 
109
103
def make_readonly(filename):
110
104
    """Make a filename read-only."""
111
105
    mod = os.lstat(filename).st_mode
112
106
    if not stat.S_ISLNK(mod):
113
 
        mod = mod & 0777555
114
 
        os.chmod(filename, mod)
 
107
        mod = mod & 0o777555
 
108
        chmod_if_possible(filename, mod)
115
109
 
116
110
 
117
111
def make_writable(filename):
118
112
    mod = os.lstat(filename).st_mode
119
113
    if not stat.S_ISLNK(mod):
120
 
        mod = mod | 0200
121
 
        os.chmod(filename, mod)
 
114
        mod = mod | 0o200
 
115
        chmod_if_possible(filename, mod)
 
116
 
 
117
 
 
118
def chmod_if_possible(filename, mode):
 
119
    # Set file mode if that can be safely done.
 
120
    # Sometimes even on unix the filesystem won't allow it - see
 
121
    # https://bugs.launchpad.net/bzr/+bug/606537
 
122
    try:
 
123
        # It is probably faster to just do the chmod, rather than
 
124
        # doing a stat, and then trying to compare
 
125
        os.chmod(filename, mode)
 
126
    except (IOError, OSError) as e:
 
127
        # Permission/access denied seems to commonly happen on smbfs; there's
 
128
        # probably no point warning about it.
 
129
        # <https://bugs.launchpad.net/bzr/+bug/606537>
 
130
        if getattr(e, 'errno') in (errno.EPERM, errno.EACCES):
 
131
            trace.mutter("ignore error on chmod of %r: %r" % (
 
132
                filename, e))
 
133
            return
 
134
        raise
122
135
 
123
136
 
124
137
def minimum_path_selection(paths):
199
212
            stat = getattr(os, 'lstat', os.stat)
200
213
            stat(f)
201
214
            return True
202
 
        except OSError, e:
 
215
        except OSError as e:
203
216
            if e.errno == errno.ENOENT:
204
217
                return False;
205
218
            else:
206
 
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
 
219
                raise errors.BzrError(gettext("lstat/stat of ({0!r}): {1!r}").format(f, e))
207
220
 
208
221
 
209
222
def fancy_rename(old, new, rename_func, unlink_func):
233
246
    file_existed = False
234
247
    try:
235
248
        rename_func(new, tmp_name)
236
 
    except (errors.NoSuchFile,), e:
 
249
    except (errors.NoSuchFile,) as e:
237
250
        pass
238
 
    except IOError, e:
 
251
    except IOError as e:
239
252
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
240
253
        # function raises an IOError with errno is None when a rename fails.
241
254
        # This then gets caught here.
242
255
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
243
256
            raise
244
 
    except Exception, e:
 
257
    except Exception as e:
245
258
        if (getattr(e, 'errno', None) is None
246
259
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
247
260
            raise
248
261
    else:
249
262
        file_existed = True
250
263
 
251
 
    failure_exc = None
252
264
    success = False
253
265
    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)
265
 
                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
 
266
        # This may throw an exception, in which case success will
 
267
        # not be set.
 
268
        rename_func(old, new)
 
269
        success = True
 
270
    except (IOError, OSError) as e:
 
271
        # source and target may be aliases of each other (e.g. on a
 
272
        # case-insensitive filesystem), so we may have accidentally renamed
 
273
        # source by when we tried to rename target
 
274
        if (file_existed and e.errno in (None, errno.ENOENT)
 
275
            and old.lower() == new.lower()):
 
276
            # source and target are the same file on a case-insensitive
 
277
            # filesystem, so we don't generate an exception
 
278
            pass
 
279
        else:
 
280
            raise
269
281
    finally:
270
282
        if file_existed:
271
283
            # If the file used to exist, rename it back into place
274
286
                unlink_func(tmp_name)
275
287
            else:
276
288
                rename_func(tmp_name, new)
277
 
    if failure_exc is not None:
278
 
        raise failure_exc[0], failure_exc[1], failure_exc[2]
279
289
 
280
290
 
281
291
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
282
292
# choke on a Unicode string containing a relative path if
283
293
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
284
294
# string.
285
 
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
286
295
def _posix_abspath(path):
287
296
    # jam 20060426 rather than encoding to fsencoding
288
297
    # copy posixpath.abspath, but use os.getcwdu instead
289
298
    if not posixpath.isabs(path):
290
299
        path = posixpath.join(getcwd(), path)
291
 
    return posixpath.normpath(path)
 
300
    return _posix_normpath(path)
292
301
 
293
302
 
294
303
def _posix_realpath(path):
295
304
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
296
305
 
297
306
 
 
307
def _posix_normpath(path):
 
308
    path = posixpath.normpath(path)
 
309
    # Bug 861008: posixpath.normpath() returns a path normalized according to
 
310
    # the POSIX standard, which stipulates (for compatibility reasons) that two
 
311
    # leading slashes must not be simplified to one, and only if there are 3 or
 
312
    # more should they be simplified as one. So we treat the leading 2 slashes
 
313
    # as a special case here by simply removing the first slash, as we consider
 
314
    # that breaking POSIX compatibility for this obscure feature is acceptable.
 
315
    # This is not a paranoid precaution, as we notably get paths like this when
 
316
    # the repo is hosted at the root of the filesystem, i.e. in "/".    
 
317
    if path.startswith('//'):
 
318
        path = path[1:]
 
319
    return path
 
320
 
 
321
 
 
322
def _posix_path_from_environ(key):
 
323
    """Get unicode path from `key` in environment or None if not present
 
324
 
 
325
    Note that posix systems use arbitrary byte strings for filesystem objects,
 
326
    so a path that raises BadFilenameEncoding here may still be accessible.
 
327
    """
 
328
    val = os.environ.get(key, None)
 
329
    if PY3 or val is None:
 
330
        return val
 
331
    try:
 
332
        return val.decode(_fs_enc)
 
333
    except UnicodeDecodeError:
 
334
        # GZ 2011-12-12:Ideally want to include `key` in the exception message
 
335
        raise errors.BadFilenameEncoding(val, _fs_enc)
 
336
 
 
337
 
 
338
def _posix_get_home_dir():
 
339
    """Get the home directory of the current user as a unicode path"""
 
340
    path = posixpath.expanduser("~")
 
341
    try:
 
342
        return path.decode(_fs_enc)
 
343
    except AttributeError:
 
344
        return path
 
345
    except UnicodeDecodeError:
 
346
        raise errors.BadFilenameEncoding(path, _fs_enc)
 
347
 
 
348
 
 
349
def _posix_getuser_unicode():
 
350
    """Get username from environment or password database as unicode"""
 
351
    name = getpass.getuser()
 
352
    if PY3:
 
353
        return name
 
354
    user_encoding = get_user_encoding()
 
355
    try:
 
356
        return name.decode(user_encoding)
 
357
    except UnicodeDecodeError:
 
358
        raise errors.BzrError("Encoding of username %r is unsupported by %s "
 
359
            "application locale." % (name, user_encoding))
 
360
 
 
361
 
298
362
def _win32_fixdrive(path):
299
363
    """Force drive letters to be consistent.
300
364
 
304
368
    running python.exe under cmd.exe return capital C:\\
305
369
    running win32 python inside a cygwin shell returns lowercase c:\\
306
370
    """
307
 
    drive, path = _nt_splitdrive(path)
 
371
    drive, path = ntpath.splitdrive(path)
308
372
    return drive.upper() + path
309
373
 
310
374
 
311
375
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('\\', '/'))
 
376
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
 
377
    return _win32_fixdrive(ntpath.abspath(unicode(path)).replace('\\', '/'))
341
378
 
342
379
 
343
380
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('\\', '/'))
 
381
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
 
382
    return _win32_fixdrive(ntpath.realpath(unicode(path)).replace('\\', '/'))
346
383
 
347
384
 
348
385
def _win32_pathjoin(*args):
349
 
    return _nt_join(*args).replace('\\', '/')
 
386
    return ntpath.join(*args).replace('\\', '/')
350
387
 
351
388
 
352
389
def _win32_normpath(path):
353
 
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
 
390
    return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))
354
391
 
355
392
 
356
393
def _win32_getcwd():
357
 
    return _win32_fixdrive(os.getcwdu().replace('\\', '/'))
 
394
    return _win32_fixdrive(_getcwd().replace('\\', '/'))
358
395
 
359
396
 
360
397
def _win32_mkdtemp(*args, **kwargs):
361
398
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
362
399
 
363
400
 
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
401
def _win32_rename(old, new):
373
402
    """We expect to be able to atomically replace 'new' with old.
374
403
 
376
405
    and then deleted.
377
406
    """
378
407
    try:
379
 
        fancy_rename(old, new, rename_func=_wrapped_rename, unlink_func=os.unlink)
380
 
    except OSError, e:
 
408
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
409
    except OSError as e:
381
410
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
382
411
            # If we try to rename a non-existant file onto cwd, we get
383
412
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT
387
416
        raise
388
417
 
389
418
 
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
419
def _mac_getcwd():
401
 
    return unicodedata.normalize('NFC', os.getcwdu())
402
 
 
 
420
    return unicodedata.normalize('NFC', _getcwd())
 
421
 
 
422
 
 
423
def _rename_wrap_exception(rename_func):
 
424
    """Adds extra information to any exceptions that come from rename().
 
425
 
 
426
    The exception has an updated message and 'old_filename' and 'new_filename'
 
427
    attributes.
 
428
    """
 
429
 
 
430
    def _rename_wrapper(old, new):
 
431
        try:
 
432
            rename_func(old, new)
 
433
        except OSError as e:
 
434
            detailed_error = OSError(e.errno, e.strerror +
 
435
                                " [occurred when renaming '%s' to '%s']" %
 
436
                                (old, new))
 
437
            detailed_error.old_filename = old
 
438
            detailed_error.new_filename = new
 
439
            raise detailed_error
 
440
 
 
441
    return _rename_wrapper
 
442
 
 
443
 
 
444
if sys.version_info > (3,):
 
445
    _getcwd = os.getcwd
 
446
else:
 
447
    _getcwd = os.getcwdu
 
448
 
 
449
 
 
450
# Default rename wraps os.rename()
 
451
rename = _rename_wrap_exception(os.rename)
403
452
 
404
453
# Default is to just use the python builtins, but these can be rebound on
405
454
# particular platforms.
406
455
abspath = _posix_abspath
407
456
realpath = _posix_realpath
408
457
pathjoin = os.path.join
409
 
normpath = os.path.normpath
410
 
rename = _wrapped_rename # overridden below on win32
411
 
getcwd = os.getcwdu
 
458
normpath = _posix_normpath
 
459
path_from_environ = _posix_path_from_environ
 
460
_get_home_dir = _posix_get_home_dir
 
461
getuser_unicode = _posix_getuser_unicode
 
462
getcwd = _getcwd
412
463
dirname = os.path.dirname
413
464
basename = os.path.basename
414
465
split = os.path.split
415
466
splitext = os.path.splitext
416
 
# These were already imported into local scope
 
467
# These were already lazily imported into local scope
417
468
# mkdtemp = tempfile.mkdtemp
418
469
# rmtree = shutil.rmtree
 
470
lstat = os.lstat
 
471
fstat = os.fstat
 
472
 
 
473
def wrap_stat(st):
 
474
    return st
 
475
 
419
476
 
420
477
MIN_ABS_PATHLENGTH = 1
421
478
 
422
479
 
423
480
if sys.platform == 'win32':
424
 
    if win32utils.winver == 'Windows 98':
425
 
        abspath = _win98_abspath
426
 
    else:
427
 
        abspath = _win32_abspath
 
481
    abspath = _win32_abspath
428
482
    realpath = _win32_realpath
429
483
    pathjoin = _win32_pathjoin
430
484
    normpath = _win32_normpath
431
485
    getcwd = _win32_getcwd
432
486
    mkdtemp = _win32_mkdtemp
433
 
    rename = _win32_rename
 
487
    rename = _rename_wrap_exception(_win32_rename)
 
488
    try:
 
489
        from . import _walkdirs_win32
 
490
    except ImportError:
 
491
        pass
 
492
    else:
 
493
        lstat = _walkdirs_win32.lstat
 
494
        fstat = _walkdirs_win32.fstat
 
495
        wrap_stat = _walkdirs_win32.wrap_stat
434
496
 
435
497
    MIN_ABS_PATHLENGTH = 3
436
498
 
454
516
    f = win32utils.get_unicode_argv     # special function or None
455
517
    if f is not None:
456
518
        get_unicode_argv = f
 
519
    path_from_environ = win32utils.get_environ_unicode
 
520
    _get_home_dir = win32utils.get_home_location
 
521
    getuser_unicode = win32utils.get_user_name
457
522
 
458
523
elif sys.platform == 'darwin':
459
524
    getcwd = _mac_getcwd
460
525
 
461
526
 
462
 
def get_terminal_encoding():
 
527
def get_terminal_encoding(trace=False):
463
528
    """Find the best encoding for printing to the screen.
464
529
 
465
530
    This attempts to check both sys.stdout and sys.stdin to see
471
536
 
472
537
    On my standard US Windows XP, the preferred encoding is
473
538
    cp1252, but the console is cp437
 
539
 
 
540
    :param trace: If True trace the selected encoding via mutter().
474
541
    """
475
 
    from bzrlib.trace import mutter
 
542
    from .trace import mutter
476
543
    output_encoding = getattr(sys.stdout, 'encoding', None)
477
544
    if not output_encoding:
478
545
        input_encoding = getattr(sys.stdin, 'encoding', None)
479
546
        if not input_encoding:
480
547
            output_encoding = get_user_encoding()
481
 
            mutter('encoding stdout as osutils.get_user_encoding() %r',
 
548
            if trace:
 
549
                mutter('encoding stdout as osutils.get_user_encoding() %r',
482
550
                   output_encoding)
483
551
        else:
484
552
            output_encoding = input_encoding
485
 
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
 
553
            if trace:
 
554
                mutter('encoding stdout as sys.stdin encoding %r',
 
555
                    output_encoding)
486
556
    else:
487
 
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
557
        if trace:
 
558
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
488
559
    if output_encoding == 'cp0':
489
560
        # invalid encoding (cp0 means 'no codepage' on Windows)
490
561
        output_encoding = get_user_encoding()
491
 
        mutter('cp0 is invalid encoding.'
 
562
        if trace:
 
563
            mutter('cp0 is invalid encoding.'
492
564
               ' encoding stdout as osutils.get_user_encoding() %r',
493
565
               output_encoding)
494
566
    # check encoding
495
567
    try:
496
568
        codecs.lookup(output_encoding)
497
569
    except LookupError:
498
 
        sys.stderr.write('bzr: warning:'
 
570
        sys.stderr.write('brz: warning:'
499
571
                         ' unknown terminal encoding %s.\n'
500
572
                         '  Using encoding %s instead.\n'
501
573
                         % (output_encoding, get_user_encoding())
520
592
def isdir(f):
521
593
    """True if f is an accessible directory."""
522
594
    try:
523
 
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
595
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
524
596
    except OSError:
525
597
        return False
526
598
 
528
600
def isfile(f):
529
601
    """True if f is a regular file."""
530
602
    try:
531
 
        return S_ISREG(os.lstat(f)[ST_MODE])
 
603
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
532
604
    except OSError:
533
605
        return False
534
606
 
535
607
def islink(f):
536
608
    """True if f is a symlink."""
537
609
    try:
538
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
610
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
539
611
    except OSError:
540
612
        return False
541
613
 
638
710
    # drives).
639
711
    if not segment_size:
640
712
        segment_size = 5242880 # 5MB
641
 
    segments = range(len(bytes) / segment_size + 1)
 
713
    offsets = range(0, len(bytes), segment_size)
 
714
    view = memoryview(bytes)
642
715
    write = file_handle.write
643
 
    for segment_index in segments:
644
 
        segment = buffer(bytes, segment_index * segment_size, segment_size)
645
 
        write(segment)
 
716
    for offset in offsets:
 
717
        write(view[offset:offset+segment_size])
646
718
 
647
719
 
648
720
def file_iterator(input_file, readsize=32768):
703
775
def sha_strings(strings, _factory=sha):
704
776
    """Return the sha-1 of concatenation of strings"""
705
777
    s = _factory()
706
 
    map(s.update, strings)
 
778
    for string in strings:
 
779
        s.update(string)
707
780
    return s.hexdigest()
708
781
 
709
782
 
729
802
            return True
730
803
 
731
804
 
 
805
def gmtime(seconds=None):
 
806
    """Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.
 
807
    GMT). When 'seconds' is not passed in, convert the current time instead.
 
808
    Handy replacement for time.gmtime() buggy on Windows and 32-bit platforms.
 
809
    """
 
810
    if seconds is None:
 
811
        seconds = time.time()
 
812
    return (datetime(1970, 1, 1) + timedelta(seconds=seconds)).timetuple()
 
813
 
 
814
 
732
815
def local_time_offset(t=None):
733
816
    """Return offset of local zone from GMT, either at present or at time t."""
734
817
    if t is None:
774
857
    """
775
858
    if offset is None:
776
859
        offset = 0
777
 
    tt = time.gmtime(t + offset)
 
860
    tt = gmtime(t + offset)
778
861
    date_fmt = _default_format_by_weekday_num[tt[6]]
779
862
    date_str = time.strftime(date_fmt, tt)
780
863
    offset_str = _cache.get(offset, None)
799
882
    (date_fmt, tt, offset_str) = \
800
883
               _format_date(t, offset, timezone, date_fmt, show_offset)
801
884
    date_str = time.strftime(date_fmt, tt)
802
 
    if not isinstance(date_str, unicode):
 
885
    if not isinstance(date_str, text_type):
803
886
        date_str = date_str.decode(get_user_encoding(), 'replace')
804
887
    return date_str + offset_str
805
888
 
806
889
 
807
890
def _format_date(t, offset, timezone, date_fmt, show_offset):
808
891
    if timezone == 'utc':
809
 
        tt = time.gmtime(t)
 
892
        tt = gmtime(t)
810
893
        offset = 0
811
894
    elif timezone == 'original':
812
895
        if offset is None:
813
896
            offset = 0
814
 
        tt = time.gmtime(t + offset)
 
897
        tt = gmtime(t + offset)
815
898
    elif timezone == 'local':
816
899
        tt = time.localtime(t)
817
900
        offset = local_time_offset(t)
827
910
 
828
911
 
829
912
def compact_date(when):
830
 
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
 
913
    return time.strftime('%Y%m%d%H%M%S', gmtime(when))
831
914
 
832
915
 
833
916
def format_delta(delta):
881
964
 
882
965
def filesize(f):
883
966
    """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
 
967
    return os.fstat(f.fileno())[stat.ST_SIZE]
 
968
 
 
969
 
 
970
# Alias os.urandom to support platforms (which?) without /dev/urandom and 
 
971
# override if it doesn't work. Avoid checking on windows where there is
 
972
# significant initialisation cost that can be avoided for some bzr calls.
 
973
 
 
974
rand_bytes = os.urandom
 
975
 
 
976
if rand_bytes.__module__ != "nt":
896
977
    try:
897
 
        rand_bytes = file('/dev/urandom', 'rb').read
898
 
    # Otherwise, use this hack as a last resort
899
 
    except (IOError, OSError):
 
978
        rand_bytes(1)
 
979
    except NotImplementedError:
900
980
        # not well seeded, but better than nothing
901
981
        def rand_bytes(n):
902
982
            import random
916
996
    """
917
997
    s = ''
918
998
    for raw_byte in rand_bytes(num):
919
 
        s += ALNUM[ord(raw_byte) % 36]
 
999
        if not PY3:
 
1000
            s += ALNUM[ord(raw_byte) % 36]
 
1001
        else:
 
1002
            s += ALNUM[raw_byte % 36]
920
1003
    return s
921
1004
 
922
1005
 
932
1015
    rps = []
933
1016
    for f in ps:
934
1017
        if f == '..':
935
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
1018
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
936
1019
        elif (f == '.') or (f == ''):
937
1020
            pass
938
1021
        else:
943
1026
def joinpath(p):
944
1027
    for f in p:
945
1028
        if (f == '..') or (f is None) or (f == ''):
946
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
1029
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
947
1030
    return pathjoin(*p)
948
1031
 
949
1032
 
950
1033
def parent_directories(filename):
951
1034
    """Return the list of parent directories, deepest first.
952
 
    
 
1035
 
953
1036
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
954
1037
    """
955
1038
    parents = []
971
1054
    implementation should be loaded instead::
972
1055
 
973
1056
    >>> try:
974
 
    >>>     import bzrlib._fictional_extension_pyx
 
1057
    >>>     import breezy._fictional_extension_pyx
975
1058
    >>> except ImportError, e:
976
 
    >>>     bzrlib.osutils.failed_to_load_extension(e)
977
 
    >>>     import bzrlib._fictional_extension_py
 
1059
    >>>     breezy.osutils.failed_to_load_extension(e)
 
1060
    >>>     import breezy._fictional_extension_py
978
1061
    """
979
1062
    # NB: This docstring is just an example, not a doctest, because doctest
980
1063
    # currently can't cope with the use of lazy imports in this namespace --
981
1064
    # mbp 20090729
982
 
    
 
1065
 
983
1066
    # This currently doesn't report the failure at the time it occurs, because
984
1067
    # they tend to happen very early in startup when we can't check config
985
1068
    # files etc, and also we want to report all failures but not spam the user
986
1069
    # with 10 warnings.
987
 
    from bzrlib import trace
988
1070
    exception_str = str(exception)
989
1071
    if exception_str not in _extension_load_failures:
990
1072
        trace.mutter("failed to load compiled extension: %s" % exception_str)
994
1076
def report_extension_load_failures():
995
1077
    if not _extension_load_failures:
996
1078
        return
997
 
    from bzrlib.config import GlobalConfig
998
 
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
 
1079
    if config.GlobalConfig().suppress_warning('missing_extensions'):
999
1080
        return
1000
1081
    # the warnings framework should by default show this only once
1001
 
    from bzrlib.trace import warning
 
1082
    from .trace import warning
1002
1083
    warning(
1003
 
        "bzr: warning: some compiled extensions could not be loaded; "
1004
 
        "see <https://answers.launchpad.net/bzr/+faq/703>")
 
1084
        "brz: warning: some compiled extensions could not be loaded; "
 
1085
        "see ``brz help missing-extensions``")
1005
1086
    # we no longer show the specific missing extensions here, because it makes
1006
1087
    # the message too long and scary - see
1007
1088
    # https://bugs.launchpad.net/bzr/+bug/430529
1008
1089
 
1009
1090
 
1010
1091
try:
1011
 
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1012
 
except ImportError, e:
 
1092
    from ._chunks_to_lines_pyx import chunks_to_lines
 
1093
except ImportError as e:
1013
1094
    failed_to_load_extension(e)
1014
 
    from bzrlib._chunks_to_lines_py import chunks_to_lines
 
1095
    from ._chunks_to_lines_py import chunks_to_lines
1015
1096
 
1016
1097
 
1017
1098
def split_lines(s):
1030
1111
 
1031
1112
    This supports Unicode or plain string objects.
1032
1113
    """
1033
 
    lines = s.split('\n')
1034
 
    result = [line + '\n' for line in lines[:-1]]
 
1114
    nl = b'\n' if isinstance(s, bytes) else u'\n'
 
1115
    lines = s.split(nl)
 
1116
    result = [line + nl for line in lines[:-1]]
1035
1117
    if lines[-1]:
1036
1118
        result.append(lines[-1])
1037
1119
    return result
1048
1130
        return
1049
1131
    try:
1050
1132
        os.link(src, dest)
1051
 
    except (OSError, IOError), e:
 
1133
    except (OSError, IOError) as e:
1052
1134
        if e.errno != errno.EXDEV:
1053
1135
            raise
1054
1136
        shutil.copyfile(src, dest)
1055
1137
 
1056
1138
 
1057
1139
def delete_any(path):
1058
 
    """Delete a file, symlink or directory.  
1059
 
    
 
1140
    """Delete a file, symlink or directory.
 
1141
 
1060
1142
    Will delete even if readonly.
1061
1143
    """
1062
1144
    try:
1063
1145
       _delete_file_or_dir(path)
1064
 
    except (OSError, IOError), e:
 
1146
    except (OSError, IOError) as e:
1065
1147
        if e.errno in (errno.EPERM, errno.EACCES):
1066
1148
            # make writable and try again
1067
1149
            try:
1127
1209
    #    separators
1128
1210
    # 3) '\xa0' isn't unicode safe since it is >128.
1129
1211
 
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':
 
1212
    if isinstance(s, str):
 
1213
        ws = ' \t\n\r\v\f'
 
1214
    else:
 
1215
        ws = (b' ', b'\t', b'\n', b'\r', b'\v', b'\f')
 
1216
    for ch in ws:
1135
1217
        if ch in s:
1136
1218
            return True
1137
1219
    else:
1163
1245
 
1164
1246
    if len(base) < MIN_ABS_PATHLENGTH:
1165
1247
        # must have space for e.g. a drive letter
1166
 
        raise ValueError('%r is too short to calculate a relative path'
 
1248
        raise ValueError(gettext('%r is too short to calculate a relative path')
1167
1249
            % (base,))
1168
1250
 
1169
1251
    rp = abspath(path)
1251
1333
    # but for now, we haven't optimized...
1252
1334
    return [canonical_relpath(base, p) for p in paths]
1253
1335
 
 
1336
 
 
1337
def decode_filename(filename):
 
1338
    """Decode the filename using the filesystem encoding
 
1339
 
 
1340
    If it is unicode, it is returned.
 
1341
    Otherwise it is decoded from the the filesystem's encoding. If decoding
 
1342
    fails, a errors.BadFilenameEncoding exception is raised.
 
1343
    """
 
1344
    if isinstance(filename, text_type):
 
1345
        return filename
 
1346
    try:
 
1347
        return filename.decode(_fs_enc)
 
1348
    except UnicodeDecodeError:
 
1349
        raise errors.BadFilenameEncoding(filename, _fs_enc)
 
1350
 
 
1351
 
1254
1352
def safe_unicode(unicode_or_utf8_string):
1255
1353
    """Coerce unicode_or_utf8_string into unicode.
1256
1354
 
1258
1356
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
1259
1357
    wrapped in a BzrBadParameterNotUnicode exception.
1260
1358
    """
1261
 
    if isinstance(unicode_or_utf8_string, unicode):
 
1359
    if isinstance(unicode_or_utf8_string, text_type):
1262
1360
        return unicode_or_utf8_string
1263
1361
    try:
1264
1362
        return unicode_or_utf8_string.decode('utf8')
1272
1370
    If it is a str, it is returned.
1273
1371
    If it is Unicode, it is encoded into a utf-8 string.
1274
1372
    """
1275
 
    if isinstance(unicode_or_utf8_string, str):
 
1373
    if isinstance(unicode_or_utf8_string, bytes):
1276
1374
        # TODO: jam 20070209 This is overkill, and probably has an impact on
1277
1375
        #       performance if we are dealing with lots of apis that want a
1278
1376
        #       utf-8 revision id
1285
1383
    return unicode_or_utf8_string.encode('utf-8')
1286
1384
 
1287
1385
 
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):
 
1386
def safe_revision_id(unicode_or_utf8_string):
1294
1387
    """Revision ids should now be utf8, but at one point they were unicode.
1295
1388
 
1296
1389
    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be
1297
1390
        utf8 or None).
1298
 
    :param warn: Functions that are sanitizing user data can set warn=False
1299
1391
    :return: None or a utf8 revision id.
1300
1392
    """
1301
1393
    if (unicode_or_utf8_string is None
1302
 
        or unicode_or_utf8_string.__class__ == str):
 
1394
        or unicode_or_utf8_string.__class__ == bytes):
1303
1395
        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):
 
1396
    raise TypeError('Unicode revision ids are no longer supported. '
 
1397
                    'Revision id generators should be creating utf8 revision '
 
1398
                    'ids.')
 
1399
 
 
1400
 
 
1401
def safe_file_id(unicode_or_utf8_string):
1315
1402
    """File ids should now be utf8, but at one point they were unicode.
1316
1403
 
1317
1404
    This is the same as safe_utf8, except it uses the cached encode functions
1319
1406
 
1320
1407
    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be
1321
1408
        utf8 or None).
1322
 
    :param warn: Functions that are sanitizing user data can set warn=False
1323
1409
    :return: None or a utf8 file id.
1324
1410
    """
1325
1411
    if (unicode_or_utf8_string is None
1326
 
        or unicode_or_utf8_string.__class__ == str):
 
1412
        or unicode_or_utf8_string.__class__ == bytes):
1327
1413
        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)
 
1414
    raise TypeError('Unicode file ids are no longer supported. '
 
1415
                    'File id generators should be creating utf8 file ids.')
1332
1416
 
1333
1417
 
1334
1418
_platform_normalizes_filenames = False
1339
1423
def normalizes_filenames():
1340
1424
    """Return True if this platform normalizes unicode filenames.
1341
1425
 
1342
 
    Mac OSX does, Windows/Linux do not.
 
1426
    Only Mac OSX.
1343
1427
    """
1344
1428
    return _platform_normalizes_filenames
1345
1429
 
1350
1434
    On platforms where the system normalizes filenames (Mac OSX),
1351
1435
    you can access a file by any path which will normalize correctly.
1352
1436
    On platforms where the system does not normalize filenames
1353
 
    (Windows, Linux), you have to access a file by its exact path.
 
1437
    (everything else), you have to access a file by its exact path.
1354
1438
 
1355
1439
    Internally, bzr only supports NFC normalization, since that is
1356
1440
    the standard for XML documents.
1359
1443
    can be accessed by that path.
1360
1444
    """
1361
1445
 
1362
 
    return unicodedata.normalize('NFC', unicode(path)), True
 
1446
    return unicodedata.normalize('NFC', text_type(path)), True
1363
1447
 
1364
1448
 
1365
1449
def _inaccessible_normalized_filename(path):
1366
1450
    __doc__ = _accessible_normalized_filename.__doc__
1367
1451
 
1368
 
    normalized = unicodedata.normalize('NFC', unicode(path))
 
1452
    normalized = unicodedata.normalize('NFC', text_type(path))
1369
1453
    return normalized, normalized == path
1370
1454
 
1371
1455
 
1418
1502
terminal_width() returns None.
1419
1503
"""
1420
1504
 
 
1505
# Keep some state so that terminal_width can detect if _terminal_size has
 
1506
# returned a different size since the process started.  See docstring and
 
1507
# comments of terminal_width for details.
 
1508
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
 
1509
_terminal_size_state = 'no_data'
 
1510
_first_terminal_size = None
1421
1511
 
1422
1512
def terminal_width():
1423
1513
    """Return terminal width.
1425
1515
    None is returned if the width can't established precisely.
1426
1516
 
1427
1517
    The rules are:
1428
 
    - if BZR_COLUMNS is set, returns its value
 
1518
    - if BRZ_COLUMNS is set, returns its value
1429
1519
    - if there is no controlling terminal, returns None
 
1520
    - query the OS, if the queried size has changed since the last query,
 
1521
      return its value,
1430
1522
    - if COLUMNS is set, returns its value,
 
1523
    - if the OS has a value (even though it's never changed), return its value.
1431
1524
 
1432
1525
    From there, we need to query the OS to get the size of the controlling
1433
1526
    terminal.
1434
1527
 
1435
 
    Unices:
 
1528
    On Unices we query the OS by:
1436
1529
    - get termios.TIOCGWINSZ
1437
1530
    - if an error occurs or a negative value is obtained, returns None
1438
1531
 
1439
 
    Windows:
1440
 
    
 
1532
    On Windows we query the OS by:
1441
1533
    - win32utils.get_console_size() decides,
1442
1534
    - returns None on error (provided default value)
1443
1535
    """
 
1536
    # Note to implementors: if changing the rules for determining the width,
 
1537
    # make sure you've considered the behaviour in these cases:
 
1538
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
 
1539
    #  - brz log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
 
1540
    #    0,0.
 
1541
    #  - (add more interesting cases here, if you find any)
 
1542
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
 
1543
    # but we don't want to register a signal handler because it is impossible
 
1544
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
 
1545
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
 
1546
    # time so we can notice if the reported size has changed, which should have
 
1547
    # a similar effect.
1444
1548
 
1445
 
    # If BZR_COLUMNS is set, take it, user is always right
 
1549
    # If BRZ_COLUMNS is set, take it, user is always right
 
1550
    # Except if they specified 0 in which case, impose no limit here
1446
1551
    try:
1447
 
        return int(os.environ['BZR_COLUMNS'])
 
1552
        width = int(os.environ['BRZ_COLUMNS'])
1448
1553
    except (KeyError, ValueError):
1449
 
        pass
 
1554
        width = None
 
1555
    if width is not None:
 
1556
        if width > 0:
 
1557
            return width
 
1558
        else:
 
1559
            return None
1450
1560
 
1451
1561
    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.
 
1562
    if isatty is None or not isatty():
 
1563
        # Don't guess, setting BRZ_COLUMNS is the recommended way to override.
1454
1564
        return None
1455
1565
 
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))
 
1566
    # Query the OS
 
1567
    width, height = os_size = _terminal_size(None, None)
 
1568
    global _first_terminal_size, _terminal_size_state
 
1569
    if _terminal_size_state == 'no_data':
 
1570
        _first_terminal_size = os_size
 
1571
        _terminal_size_state = 'unchanged'
 
1572
    elif (_terminal_size_state == 'unchanged' and
 
1573
          _first_terminal_size != os_size):
 
1574
        _terminal_size_state = 'changed'
 
1575
 
 
1576
    # If the OS claims to know how wide the terminal is, and this value has
 
1577
    # ever changed, use that.
 
1578
    if _terminal_size_state == 'changed':
 
1579
        if width is not None and width > 0:
 
1580
            return width
 
1581
 
 
1582
    # If COLUMNS is set, use it.
1459
1583
    try:
1460
1584
        return int(os.environ['COLUMNS'])
1461
1585
    except (KeyError, ValueError):
1462
1586
        pass
1463
1587
 
1464
 
    width, height = _terminal_size(None, None)
1465
 
    if width <= 0:
1466
 
        # Consider invalid values as meaning no width
1467
 
        return None
 
1588
    # Finally, use an unchanged size from the OS, if we have one.
 
1589
    if _terminal_size_state == 'unchanged':
 
1590
        if width is not None and width > 0:
 
1591
            return width
1468
1592
 
1469
 
    return width
 
1593
    # The width could not be determined.
 
1594
    return None
1470
1595
 
1471
1596
 
1472
1597
def _win32_terminal_size(width, height):
1499
1624
    _terminal_size = _ioctl_terminal_size
1500
1625
 
1501
1626
 
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
1627
def supports_executable():
1528
1628
    return sys.platform != "win32"
1529
1629
 
1554
1654
        if orig_val is not None:
1555
1655
            del os.environ[env_variable]
1556
1656
    else:
1557
 
        if isinstance(value, unicode):
 
1657
        if not PY3 and isinstance(value, text_type):
1558
1658
            value = value.encode(get_user_encoding())
1559
1659
        os.environ[env_variable] = value
1560
1660
    return orig_val
1652
1752
        dirblock = []
1653
1753
        append = dirblock.append
1654
1754
        try:
1655
 
            names = sorted(_listdir(top))
1656
 
        except OSError, e:
 
1755
            names = sorted(map(decode_filename, _listdir(top)))
 
1756
        except OSError as e:
1657
1757
            if not _is_error_enotdir(e):
1658
1758
                raise
1659
1759
        else:
1712
1812
    """
1713
1813
    global _selected_dir_reader
1714
1814
    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.
 
1815
        if sys.platform == "win32":
1722
1816
            try:
1723
 
                from bzrlib._walkdirs_win32 import Win32ReadDir
 
1817
                from ._walkdirs_win32 import Win32ReadDir
1724
1818
                _selected_dir_reader = Win32ReadDir()
1725
1819
            except ImportError:
1726
1820
                pass
1727
 
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1728
 
            # ANSI_X3.4-1968 is a form of ASCII
 
1821
        elif _fs_enc in ('utf-8', 'ascii'):
1729
1822
            try:
1730
 
                from bzrlib._readdir_pyx import UTF8DirReader
 
1823
                from ._readdir_pyx import UTF8DirReader
1731
1824
                _selected_dir_reader = UTF8DirReader()
1732
 
            except ImportError, e:
 
1825
            except ImportError as e:
1733
1826
                failed_to_load_extension(e)
1734
1827
                pass
1735
1828
 
1785
1878
        _kind_from_mode = file_kind_from_stat_mode
1786
1879
 
1787
1880
        if prefix:
1788
 
            relprefix = prefix + '/'
 
1881
            relprefix = prefix + b'/'
1789
1882
        else:
1790
 
            relprefix = ''
1791
 
        top_slash = top + u'/'
 
1883
            relprefix = b''
 
1884
        top_slash = top + '/'
1792
1885
 
1793
1886
        dirblock = []
1794
1887
        append = dirblock.append
1865
1958
    try:
1866
1959
        s = os.stat(src)
1867
1960
        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))
 
1961
    except OSError as e:
 
1962
        trace.warning(
 
1963
            'Unable to copy ownership from "%s" to "%s". '
 
1964
            'You may want to set it manually.', src, dst)
 
1965
        trace.log_exception_quietly()
1870
1966
 
1871
1967
 
1872
1968
def path_prefix_key(path):
1887
1983
_cached_user_encoding = None
1888
1984
 
1889
1985
 
1890
 
def get_user_encoding(use_cache=True):
 
1986
def get_user_encoding():
1891
1987
    """Find out what the preferred user encoding is.
1892
1988
 
1893
1989
    This is generally the encoding that is used for command line parameters
1894
1990
    and file contents. This may be different from the terminal encoding
1895
1991
    or the filesystem encoding.
1896
1992
 
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
1993
    :return: A string defining the preferred user encoding
1902
1994
    """
1903
1995
    global _cached_user_encoding
1904
 
    if _cached_user_encoding is not None and use_cache:
 
1996
    if _cached_user_encoding is not None:
1905
1997
        return _cached_user_encoding
1906
1998
 
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'
 
1999
    if os.name == 'posix' and getattr(locale, 'CODESET', None) is not None:
 
2000
        # Use the existing locale settings and call nl_langinfo directly
 
2001
        # rather than going through getpreferredencoding. This avoids
 
2002
        # <http://bugs.python.org/issue6202> on OSX Python 2.6 and the
 
2003
        # possibility of the setlocale call throwing an error.
 
2004
        user_encoding = locale.nl_langinfo(locale.CODESET)
1924
2005
    else:
1925
 
        import locale
 
2006
        # GZ 2011-12-19: On windows could call GetACP directly instead.
 
2007
        user_encoding = locale.getpreferredencoding(False)
1926
2008
 
1927
2009
    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:'
 
2010
        user_encoding = codecs.lookup(user_encoding).name
 
2011
    except LookupError:
 
2012
        if user_encoding not in ("", "cp0"):
 
2013
            sys.stderr.write('brz: warning:'
1951
2014
                             ' unknown encoding %s.'
1952
2015
                             ' Continuing with ascii encoding.\n'
1953
2016
                             % user_encoding
1954
2017
                            )
1955
 
            user_encoding = 'ascii'
1956
 
 
1957
 
    if use_cache:
1958
 
        _cached_user_encoding = user_encoding
1959
 
 
 
2018
        user_encoding = 'ascii'
 
2019
    else:
 
2020
        # Get 'ascii' when setlocale has not been called or LANG=C or unset.
 
2021
        if user_encoding == 'ascii':
 
2022
            if sys.platform == 'darwin':
 
2023
                # OSX is special-cased in Python to have a UTF-8 filesystem
 
2024
                # encoding and previously had LANG set here if not present.
 
2025
                user_encoding = 'utf-8'
 
2026
            # GZ 2011-12-19: Maybe UTF-8 should be the default in this case
 
2027
            #                for some other posix platforms as well.
 
2028
 
 
2029
    _cached_user_encoding = user_encoding
1960
2030
    return user_encoding
1961
2031
 
1962
2032
 
 
2033
def get_diff_header_encoding():
 
2034
    return get_terminal_encoding()
 
2035
 
 
2036
 
1963
2037
def get_host_name():
1964
2038
    """Return the current unicode host name.
1965
2039
 
1967
2041
    behaves inconsistently on different platforms.
1968
2042
    """
1969
2043
    if sys.platform == "win32":
1970
 
        import win32utils
1971
2044
        return win32utils.get_host_name()
1972
2045
    else:
1973
2046
        import socket
 
2047
        if PY3:
 
2048
            return socket.gethostname()
1974
2049
        return socket.gethostname().decode(get_user_encoding())
1975
2050
 
1976
2051
 
1980
2055
# data at once.
1981
2056
MAX_SOCKET_CHUNK = 64 * 1024
1982
2057
 
 
2058
_end_of_stream_errors = [errno.ECONNRESET, errno.EPIPE, errno.EINVAL]
 
2059
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
 
2060
    _eno = getattr(errno, _eno, None)
 
2061
    if _eno is not None:
 
2062
        _end_of_stream_errors.append(_eno)
 
2063
del _eno
 
2064
 
 
2065
 
1983
2066
def read_bytes_from_socket(sock, report_activity=None,
1984
2067
        max_read_size=MAX_SOCKET_CHUNK):
1985
2068
    """Read up to max_read_size of bytes from sock and notify of progress.
1988
2071
    empty string rather than raise an error), and repeats the recv if
1989
2072
    interrupted by a signal.
1990
2073
    """
1991
 
    while 1:
 
2074
    while True:
1992
2075
        try:
1993
2076
            bytes = sock.recv(max_read_size)
1994
 
        except socket.error, e:
 
2077
        except socket.error as e:
1995
2078
            eno = e.args[0]
1996
 
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
 
2079
            if eno in _end_of_stream_errors:
1997
2080
                # The connection was closed by the other side.  Callers expect
1998
2081
                # an empty string to signal end-of-stream.
1999
2082
                return ""
2028
2111
 
2029
2112
def send_all(sock, bytes, report_activity=None):
2030
2113
    """Send all bytes on a socket.
2031
 
 
 
2114
 
2032
2115
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2033
2116
    some platforms, and catches EINTR which may be thrown if the send is
2034
2117
    interrupted by a signal.
2035
2118
 
2036
2119
    This is preferred to socket.sendall(), because it avoids portability bugs
2037
2120
    and provides activity reporting.
2038
 
 
 
2121
 
2039
2122
    :param report_activity: Call this as bytes are read, see
2040
2123
        Transport._report_activity
2041
2124
    """
2042
2125
    sent_total = 0
2043
2126
    byte_count = len(bytes)
 
2127
    view = memoryview(bytes)
2044
2128
    while sent_total < byte_count:
2045
2129
        try:
2046
 
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2047
 
        except socket.error, e:
 
2130
            sent = sock.send(view[sent_total:sent_total+MAX_SOCKET_CHUNK])
 
2131
        except (socket.error, IOError) as e:
 
2132
            if e.args[0] in _end_of_stream_errors:
 
2133
                raise errors.ConnectionReset(
 
2134
                    "Error trying to write to socket", e)
2048
2135
            if e.args[0] != errno.EINTR:
2049
2136
                raise
2050
2137
        else:
 
2138
            if sent == 0:
 
2139
                raise errors.ConnectionReset('Sending to %s returned 0 bytes'
 
2140
                                             % (sock,))
2051
2141
            sent_total += sent
2052
 
            report_activity(sent, 'write')
 
2142
            if report_activity is not None:
 
2143
                report_activity(sent, 'write')
 
2144
 
 
2145
 
 
2146
def connect_socket(address):
 
2147
    # Slight variation of the socket.create_connection() function (provided by
 
2148
    # python-2.6) that can fail if getaddrinfo returns an empty list. We also
 
2149
    # provide it for previous python versions. Also, we don't use the timeout
 
2150
    # parameter (provided by the python implementation) so we don't implement
 
2151
    # it either).
 
2152
    err = socket.error('getaddrinfo returns an empty list')
 
2153
    host, port = address
 
2154
    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
 
2155
        af, socktype, proto, canonname, sa = res
 
2156
        sock = None
 
2157
        try:
 
2158
            sock = socket.socket(af, socktype, proto)
 
2159
            sock.connect(sa)
 
2160
            return sock
 
2161
 
 
2162
        except socket.error as err:
 
2163
            # 'err' is now the most recent error
 
2164
            if sock is not None:
 
2165
                sock.close()
 
2166
    raise err
2053
2167
 
2054
2168
 
2055
2169
def dereference_path(path):
2074
2188
def resource_string(package, resource_name):
2075
2189
    """Load a resource from a package and return it as a string.
2076
2190
 
2077
 
    Note: Only packages that start with bzrlib are currently supported.
 
2191
    Note: Only packages that start with breezy are currently supported.
2078
2192
 
2079
2193
    This is designed to be a lightweight implementation of resource
2080
2194
    loading in a way which is API compatible with the same API from
2083
2197
    If and when pkg_resources becomes a standard library, this routine
2084
2198
    can delegate to it.
2085
2199
    """
2086
 
    # Check package name is within bzrlib
2087
 
    if package == "bzrlib":
 
2200
    # Check package name is within breezy
 
2201
    if package == "breezy":
2088
2202
        resource_relpath = resource_name
2089
 
    elif package.startswith("bzrlib."):
2090
 
        package = package[len("bzrlib."):].replace('.', os.sep)
 
2203
    elif package.startswith("breezy."):
 
2204
        package = package[len("breezy."):].replace('.', os.sep)
2091
2205
        resource_relpath = pathjoin(package, resource_name)
2092
2206
    else:
2093
 
        raise errors.BzrError('resource package %s not in bzrlib' % package)
 
2207
        raise errors.BzrError('resource package %s not in breezy' % package)
2094
2208
 
2095
2209
    # Map the resource to a file and read its contents
2096
 
    base = dirname(bzrlib.__file__)
 
2210
    base = dirname(breezy.__file__)
2097
2211
    if getattr(sys, 'frozen', None):    # bzr.exe
2098
2212
        base = abspath(pathjoin(base, '..', '..'))
2099
 
    filename = pathjoin(base, resource_relpath)
2100
 
    return open(filename, 'rU').read()
2101
 
 
 
2213
    f = file(pathjoin(base, resource_relpath), "rU")
 
2214
    try:
 
2215
        return f.read()
 
2216
    finally:
 
2217
        f.close()
2102
2218
 
2103
2219
def file_kind_from_stat_mode_thunk(mode):
2104
2220
    global file_kind_from_stat_mode
2105
2221
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
2106
2222
        try:
2107
 
            from bzrlib._readdir_pyx import UTF8DirReader
 
2223
            from ._readdir_pyx import UTF8DirReader
2108
2224
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
2109
 
        except ImportError, e:
 
2225
        except ImportError as e:
2110
2226
            # This is one time where we won't warn that an extension failed to
2111
2227
            # load. The extension is never available on Windows anyway.
2112
 
            from bzrlib._readdir_py import (
 
2228
            from ._readdir_py import (
2113
2229
                _kind_from_mode as file_kind_from_stat_mode
2114
2230
                )
2115
2231
    return file_kind_from_stat_mode(mode)
2116
2232
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2117
2233
 
2118
 
 
2119
 
def file_kind(f, _lstat=os.lstat):
 
2234
def file_stat(f, _lstat=os.lstat):
2120
2235
    try:
2121
 
        return file_kind_from_stat_mode(_lstat(f).st_mode)
2122
 
    except OSError, e:
 
2236
        # XXX cache?
 
2237
        return _lstat(f)
 
2238
    except OSError as e:
2123
2239
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2124
2240
            raise errors.NoSuchFile(f)
2125
2241
        raise
2126
2242
 
 
2243
def file_kind(f, _lstat=os.lstat):
 
2244
    stat_value = file_stat(f, _lstat)
 
2245
    return file_kind_from_stat_mode(stat_value.st_mode)
2127
2246
 
2128
2247
def until_no_eintr(f, *a, **kw):
2129
2248
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2130
 
    
 
2249
 
2131
2250
    WARNING: you must be certain that it is safe to retry the call repeatedly
2132
2251
    if EINTR does occur.  This is typically only true for low-level operations
2133
2252
    like os.read.  If in any doubt, don't use this.
2135
2254
    Keep in mind that this is not a complete solution to EINTR.  There is
2136
2255
    probably code in the Python standard library and other dependencies that
2137
2256
    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
 
2257
    that signal).  So this function can reduce the impact for IO that breezy
2139
2258
    directly controls, but it is not a complete solution.
2140
2259
    """
2141
2260
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
2142
2261
    while True:
2143
2262
        try:
2144
2263
            return f(*a, **kw)
2145
 
        except (IOError, OSError), e:
 
2264
        except (IOError, OSError) as e:
2146
2265
            if e.errno == errno.EINTR:
2147
2266
                continue
2148
2267
            raise
2149
2268
 
2150
2269
 
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
2270
if sys.platform == "win32":
2175
 
    import msvcrt
2176
2271
    def getchar():
 
2272
        import msvcrt
2177
2273
        return msvcrt.getch()
2178
2274
else:
2179
 
    import tty
2180
 
    import termios
2181
2275
    def getchar():
 
2276
        import tty
 
2277
        import termios
2182
2278
        fd = sys.stdin.fileno()
2183
2279
        settings = termios.tcgetattr(fd)
2184
2280
        try:
2188
2284
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2189
2285
        return ch
2190
2286
 
2191
 
 
2192
 
if sys.platform == 'linux2':
 
2287
if sys.platform.startswith('linux'):
2193
2288
    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
 
2289
        try:
 
2290
            return os.sysconf('SC_NPROCESSORS_ONLN')
 
2291
        except (ValueError, OSError, AttributeError):
 
2292
            return None
2200
2293
elif sys.platform == 'darwin':
2201
2294
    def _local_concurrency():
2202
2295
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2203
2296
                                stdout=subprocess.PIPE).communicate()[0]
2204
 
elif sys.platform[0:7] == 'freebsd':
 
2297
elif "bsd" in sys.platform:
2205
2298
    def _local_concurrency():
2206
2299
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2207
2300
                                stdout=subprocess.PIPE).communicate()[0]
2232
2325
    if _cached_local_concurrency is not None and use_cache:
2233
2326
        return _cached_local_concurrency
2234
2327
 
2235
 
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
 
2328
    concurrency = os.environ.get('BRZ_CONCURRENCY', None)
2236
2329
    if concurrency is None:
 
2330
        import multiprocessing
2237
2331
        try:
2238
 
            concurrency = _local_concurrency()
2239
 
        except (OSError, IOError):
2240
 
            pass
 
2332
            concurrency = multiprocessing.cpu_count()
 
2333
        except NotImplementedError:
 
2334
            # multiprocessing.cpu_count() isn't implemented on all platforms
 
2335
            try:
 
2336
                concurrency = _local_concurrency()
 
2337
            except (OSError, IOError):
 
2338
                pass
2241
2339
    try:
2242
2340
        concurrency = int(concurrency)
2243
2341
    except (TypeError, ValueError):
2255
2353
        self.encode = encode
2256
2354
 
2257
2355
    def write(self, object):
2258
 
        if type(object) is str:
 
2356
        if isinstance(object, str):
2259
2357
            self.stream.write(object)
2260
2358
        else:
2261
2359
            data, _ = self.encode(object, self.errors)
2264
2362
if sys.platform == 'win32':
2265
2363
    def open_file(filename, mode='r', bufsize=-1):
2266
2364
        """This function is used to override the ``open`` builtin.
2267
 
        
 
2365
 
2268
2366
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2269
2367
        child processes.  Deleting or renaming a closed file opened with this
2270
2368
        function is not blocking child processes.
2305
2403
    open_file = open
2306
2404
 
2307
2405
 
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
 
2406
def available_backup_name(base, exists):
 
2407
    """Find a non-existing backup file name.
 
2408
 
 
2409
    This will *not* create anything, this only return a 'free' entry.  This
 
2410
    should be used for checking names in a directory below a locked
 
2411
    tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
 
2412
    Leap) and generally discouraged.
 
2413
 
 
2414
    :param base: The base name.
 
2415
 
 
2416
    :param exists: A callable returning True if the path parameter exists.
 
2417
    """
 
2418
    counter = 1
 
2419
    name = "%s.~%d~" % (base, counter)
 
2420
    while exists(name):
 
2421
        counter += 1
 
2422
        name = "%s.~%d~" % (base, counter)
 
2423
    return name
 
2424
 
 
2425
 
 
2426
def set_fd_cloexec(fd):
 
2427
    """Set a Unix file descriptor's FD_CLOEXEC flag.  Do nothing if platform
 
2428
    support for this is not available.
 
2429
    """
 
2430
    try:
 
2431
        import fcntl
 
2432
        old = fcntl.fcntl(fd, fcntl.F_GETFD)
 
2433
        fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
 
2434
    except (ImportError, AttributeError):
 
2435
        # Either the fcntl module or specific constants are not present
 
2436
        pass
 
2437
 
 
2438
 
 
2439
def find_executable_on_path(name):
 
2440
    """Finds an executable on the PATH.
 
2441
    
 
2442
    On Windows, this will try to append each extension in the PATHEXT
 
2443
    environment variable to the name, if it cannot be found with the name
 
2444
    as given.
 
2445
    
 
2446
    :param name: The base name of the executable.
 
2447
    :return: The path to the executable found or None.
 
2448
    """
 
2449
    if sys.platform == 'win32':
 
2450
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
 
2451
        exts = [ext.lower() for ext in exts]
 
2452
        base, ext = os.path.splitext(name)
 
2453
        if ext != '':
 
2454
            if ext.lower() not in exts:
 
2455
                return None
 
2456
            name = base
 
2457
            exts = [ext]
 
2458
    else:
 
2459
        exts = ['']
 
2460
    path = os.environ.get('PATH')
 
2461
    if path is not None:
 
2462
        path = path.split(os.pathsep)
 
2463
        for ext in exts:
 
2464
            for d in path:
 
2465
                f = os.path.join(d, name) + ext
 
2466
                if os.access(f, os.X_OK):
 
2467
                    return f
 
2468
    if sys.platform == 'win32':
 
2469
        app_path = win32utils.get_app_path(name)
 
2470
        if app_path != name:
 
2471
            return app_path
 
2472
    return None
 
2473
 
 
2474
 
 
2475
def _posix_is_local_pid_dead(pid):
 
2476
    """True if pid doesn't correspond to live process on this machine"""
 
2477
    try:
 
2478
        # Special meaning of unix kill: just check if it's there.
 
2479
        os.kill(pid, 0)
 
2480
    except OSError as e:
 
2481
        if e.errno == errno.ESRCH:
 
2482
            # On this machine, and really not found: as sure as we can be
 
2483
            # that it's dead.
 
2484
            return True
 
2485
        elif e.errno == errno.EPERM:
 
2486
            # exists, though not ours
 
2487
            return False
 
2488
        else:
 
2489
            mutter("os.kill(%d, 0) failed: %s" % (pid, e))
 
2490
            # Don't really know.
 
2491
            return False
 
2492
    else:
 
2493
        # Exists and our process: not dead.
 
2494
        return False
 
2495
 
 
2496
if sys.platform == "win32":
 
2497
    is_local_pid_dead = win32utils.is_local_pid_dead
 
2498
else:
 
2499
    is_local_pid_dead = _posix_is_local_pid_dead
 
2500
 
 
2501
_maybe_ignored = ['EAGAIN', 'EINTR', 'ENOTSUP', 'EOPNOTSUPP', 'EACCES']
 
2502
_fdatasync_ignored = [getattr(errno, name) for name in _maybe_ignored
 
2503
                      if getattr(errno, name, None) is not None]
 
2504
 
 
2505
 
 
2506
def fdatasync(fileno):
 
2507
    """Flush file contents to disk if possible.
 
2508
    
 
2509
    :param fileno: Integer OS file handle.
 
2510
    :raises TransportNotPossible: If flushing to disk is not possible.
 
2511
    """
 
2512
    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))
 
2513
    if fn is not None:
 
2514
        try:
 
2515
            fn(fileno)
 
2516
        except IOError as e:
 
2517
            # See bug #1075108, on some platforms fdatasync exists, but can
 
2518
            # raise ENOTSUP. However, we are calling fdatasync to be helpful
 
2519
            # and reduce the chance of corruption-on-powerloss situations. It
 
2520
            # is not a mandatory call, so it is ok to suppress failures.
 
2521
            trace.mutter("ignoring error calling fdatasync: %s" % (e,))
 
2522
            if getattr(e, 'errno', None) not in _fdatasync_ignored:
 
2523
                raise
 
2524
 
 
2525
 
 
2526
def ensure_empty_directory_exists(path, exception_class):
 
2527
    """Make sure a local directory exists and is empty.
 
2528
    
 
2529
    If it does not exist, it is created.  If it exists and is not empty, an
 
2530
    instance of exception_class is raised.
 
2531
    """
 
2532
    try:
 
2533
        os.mkdir(path)
 
2534
    except OSError as e:
 
2535
        if e.errno != errno.EEXIST:
 
2536
            raise
 
2537
        if os.listdir(path) != []:
 
2538
            raise exception_class(path)
 
2539
 
 
2540
 
 
2541
def is_environment_error(evalue):
 
2542
    """True if exception instance is due to a process environment issue
 
2543
 
 
2544
    This includes OSError and IOError, but also other errors that come from
 
2545
    the operating system or core libraries but are not subclasses of those.
 
2546
    """
 
2547
    if isinstance(evalue, (EnvironmentError, select.error)):
 
2548
        return True
 
2549
    if sys.platform == "win32" and win32utils._is_pywintypes_error(evalue):
 
2550
        return True
 
2551
    return False