~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Aaron Bentley
  • Date: 2007-06-11 14:59:52 UTC
  • mto: (2520.5.2 bzr.mpbundle)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070611145952-cwt4480gphdhen6l
Get installation started

Show diffs side-by-side

added added

removed removed

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