← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Ian Clatworthy
  • Date: 2009-01-19 02:24:15 UTC
  • mto: This revision was merged to the branch mainline in revision 3944.
  • Revision ID: ian.clatworthy@canonical.com-20090119022415-mo0mcfeiexfktgwt
apply jam's log --short fix (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
 
# Bazaar-NG -- distributed version control
2
 
#
3
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
16
14
# along with this program; if not, write to the Free Software
17
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
19
 
from cStringIO import StringIO
20
 
import errno
21
17
import os
22
 
from os import listdir
23
18
import re
24
 
import sha
25
 
import shutil
26
 
from shutil import copyfile
27
19
import stat
28
20
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
29
21
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
30
 
import string
31
22
import sys
32
23
import time
33
 
import types
34
 
import tempfile
35
 
import unicodedata
 
24
 
 
25
from bzrlib.lazy_import import lazy_import
 
26
lazy_import(globals(), """
 
27
import codecs
 
28
from datetime import datetime
 
29
import errno
36
30
from ntpath import (abspath as _nt_abspath,
37
31
                    join as _nt_join,
38
32
                    normpath as _nt_normpath,
39
33
                    realpath as _nt_realpath,
 
34
                    splitdrive as _nt_splitdrive,
40
35
                    )
 
36
import posixpath
 
37
import shutil
 
38
from shutil import (
 
39
    rmtree,
 
40
    )
 
41
import tempfile
 
42
from tempfile import (
 
43
    mkdtemp,
 
44
    )
 
45
import unicodedata
 
46
 
 
47
from bzrlib import (
 
48
    cache_utf8,
 
49
    errors,
 
50
    win32utils,
 
51
    )
 
52
""")
 
53
 
 
54
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
 
55
# of 2.5
 
56
if sys.version_info < (2, 5):
 
57
    import md5 as _mod_md5
 
58
    md5 = _mod_md5.new
 
59
    import sha as _mod_sha
 
60
    sha = _mod_sha.new
 
61
else:
 
62
    from hashlib import (
 
63
        md5,
 
64
        sha1 as sha,
 
65
        )
 
66
 
41
67
 
42
68
import bzrlib
43
 
from bzrlib.errors import (BzrError,
44
 
                           BzrBadParameterNotUnicode,
45
 
                           NoSuchFile,
46
 
                           PathNotChild,
47
 
                           IllegalPath,
48
 
                           )
49
 
from bzrlib.symbol_versioning import *
50
 
from bzrlib.trace import mutter
51
 
import bzrlib.win32console
 
69
from bzrlib import symbol_versioning
 
70
 
 
71
 
 
72
# On win32, O_BINARY is used to indicate the file should
 
73
# be opened in binary mode, rather than text mode.
 
74
# On other platforms, O_BINARY doesn't exist, because
 
75
# they always open in binary mode, so it is okay to
 
76
# OR with 0 on those platforms
 
77
O_BINARY = getattr(os, 'O_BINARY', 0)
52
78
 
53
79
 
54
80
def make_readonly(filename):
55
81
    """Make a filename read-only."""
56
 
    mod = os.stat(filename).st_mode
57
 
    mod = mod & 0777555
58
 
    os.chmod(filename, mod)
 
82
    mod = os.lstat(filename).st_mode
 
83
    if not stat.S_ISLNK(mod):
 
84
        mod = mod & 0777555
 
85
        os.chmod(filename, mod)
59
86
 
60
87
 
61
88
def make_writable(filename):
62
 
    mod = os.stat(filename).st_mode
63
 
    mod = mod | 0200
64
 
    os.chmod(filename, mod)
 
89
    mod = os.lstat(filename).st_mode
 
90
    if not stat.S_ISLNK(mod):
 
91
        mod = mod | 0200
 
92
        os.chmod(filename, mod)
 
93
 
 
94
 
 
95
def minimum_path_selection(paths):
 
96
    """Return the smallset subset of paths which are outside paths.
 
97
 
 
98
    :param paths: A container (and hence not None) of paths.
 
99
    :return: A set of paths sufficient to include everything in paths via
 
100
        is_inside_any, drawn from the paths parameter.
 
101
    """
 
102
    search_paths = set()
 
103
    paths = set(paths)
 
104
    for path in paths:
 
105
        other_paths = paths.difference([path])
 
106
        if not is_inside_any(other_paths, path):
 
107
            # this is a top level path, we must check it.
 
108
            search_paths.add(path)
 
109
    return search_paths
65
110
 
66
111
 
67
112
_QUOTE_RE = None
74
119
    Windows."""
75
120
    # TODO: I'm not really sure this is the best format either.x
76
121
    global _QUOTE_RE
77
 
    if _QUOTE_RE == None:
 
122
    if _QUOTE_RE is None:
78
123
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
79
124
        
80
125
    if _QUOTE_RE.search(f):
85
130
 
86
131
_directory_kind = 'directory'
87
132
 
88
 
_formats = {
89
 
    stat.S_IFDIR:_directory_kind,
90
 
    stat.S_IFCHR:'chardev',
91
 
    stat.S_IFBLK:'block',
92
 
    stat.S_IFREG:'file',
93
 
    stat.S_IFIFO:'fifo',
94
 
    stat.S_IFLNK:'symlink',
95
 
    stat.S_IFSOCK:'socket',
 
133
def get_umask():
 
134
    """Return the current umask"""
 
135
    # Assume that people aren't messing with the umask while running
 
136
    # XXX: This is not thread safe, but there is no way to get the
 
137
    #      umask without setting it
 
138
    umask = os.umask(0)
 
139
    os.umask(umask)
 
140
    return umask
 
141
 
 
142
 
 
143
_kind_marker_map = {
 
144
    "file": "",
 
145
    _directory_kind: "/",
 
146
    "symlink": "@",
 
147
    'tree-reference': '+',
96
148
}
97
149
 
98
150
 
99
 
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
100
 
    """Generate a file kind from a stat mode. This is used in walkdirs.
101
 
 
102
 
    Its performance is critical: Do not mutate without careful benchmarking.
103
 
    """
 
151
def kind_marker(kind):
104
152
    try:
105
 
        return _formats[stat_mode & 0170000]
 
153
        return _kind_marker_map[kind]
106
154
    except KeyError:
107
 
        return _unknown
108
 
 
109
 
 
110
 
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
111
 
    try:
112
 
        return _mapper(_lstat(f).st_mode)
113
 
    except OSError, e:
114
 
        if getattr(e, 'errno', None) == errno.ENOENT:
115
 
            raise bzrlib.errors.NoSuchFile(f)
116
 
        raise
117
 
 
118
 
 
119
 
def kind_marker(kind):
120
 
    if kind == 'file':
121
 
        return ''
122
 
    elif kind == _directory_kind:
123
 
        return '/'
124
 
    elif kind == 'symlink':
125
 
        return '@'
126
 
    else:
127
 
        raise BzrError('invalid file kind %r' % kind)
 
155
        raise errors.BzrError('invalid file kind %r' % kind)
 
156
 
128
157
 
129
158
lexists = getattr(os.path, 'lexists', None)
130
159
if lexists is None:
131
160
    def lexists(f):
132
161
        try:
133
 
            if hasattr(os, 'lstat'):
134
 
                os.lstat(f)
135
 
            else:
136
 
                os.stat(f)
 
162
            stat = getattr(os, 'lstat', os.stat)
 
163
            stat(f)
137
164
            return True
138
 
        except OSError,e:
 
165
        except OSError, e:
139
166
            if e.errno == errno.ENOENT:
140
167
                return False;
141
168
            else:
142
 
                raise BzrError("lstat/stat of (%r): %r" % (f, e))
 
169
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
143
170
 
144
171
 
145
172
def fancy_rename(old, new, rename_func, unlink_func):
152
179
    """
153
180
 
154
181
    # sftp rename doesn't allow overwriting, so play tricks:
155
 
    import random
156
182
    base = os.path.basename(new)
157
183
    dirname = os.path.dirname(new)
158
184
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
166
192
    file_existed = False
167
193
    try:
168
194
        rename_func(new, tmp_name)
169
 
    except (NoSuchFile,), e:
 
195
    except (errors.NoSuchFile,), e:
170
196
        pass
171
197
    except IOError, e:
172
198
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
173
 
        # function raises an IOError with errno == None when a rename fails.
 
199
        # function raises an IOError with errno is None when a rename fails.
174
200
        # This then gets caught here.
175
201
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
176
202
            raise
177
203
    except Exception, e:
178
 
        if (not hasattr(e, 'errno') 
 
204
        if (getattr(e, 'errno', None) is None
179
205
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
180
206
            raise
181
207
    else:
183
209
 
184
210
    success = False
185
211
    try:
186
 
        # This may throw an exception, in which case success will
187
 
        # not be set.
188
 
        rename_func(old, new)
189
 
        success = True
 
212
        try:
 
213
            # This may throw an exception, in which case success will
 
214
            # not be set.
 
215
            rename_func(old, new)
 
216
            success = True
 
217
        except (IOError, OSError), e:
 
218
            # source and target may be aliases of each other (e.g. on a
 
219
            # case-insensitive filesystem), so we may have accidentally renamed
 
220
            # source by when we tried to rename target
 
221
            if not (file_existed and e.errno in (None, errno.ENOENT)):
 
222
                raise
190
223
    finally:
191
224
        if file_existed:
192
225
            # If the file used to exist, rename it back into place
201
234
# choke on a Unicode string containing a relative path if
202
235
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
203
236
# string.
204
 
_fs_enc = sys.getfilesystemencoding()
 
237
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
205
238
def _posix_abspath(path):
206
 
    return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
207
 
    # jam 20060426 This is another possibility which mimics 
208
 
    # os.path.abspath, only uses unicode characters instead
209
 
    # if not os.path.isabs(path):
210
 
    #     return os.path.join(os.getcwdu(), path)
211
 
    # return path
 
239
    # jam 20060426 rather than encoding to fsencoding
 
240
    # copy posixpath.abspath, but use os.getcwdu instead
 
241
    if not posixpath.isabs(path):
 
242
        path = posixpath.join(getcwd(), path)
 
243
    return posixpath.normpath(path)
212
244
 
213
245
 
214
246
def _posix_realpath(path):
215
 
    return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
247
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
248
 
 
249
 
 
250
def _win32_fixdrive(path):
 
251
    """Force drive letters to be consistent.
 
252
 
 
253
    win32 is inconsistent whether it returns lower or upper case
 
254
    and even if it was consistent the user might type the other
 
255
    so we force it to uppercase
 
256
    running python.exe under cmd.exe return capital C:\\
 
257
    running win32 python inside a cygwin shell returns lowercase c:\\
 
258
    """
 
259
    drive, path = _nt_splitdrive(path)
 
260
    return drive.upper() + path
216
261
 
217
262
 
218
263
def _win32_abspath(path):
219
 
    return _nt_abspath(path.encode(_fs_enc)).decode(_fs_enc).replace('\\', '/')
 
264
    # Real _nt_abspath doesn't have a problem with a unicode cwd
 
265
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
 
266
 
 
267
 
 
268
def _win98_abspath(path):
 
269
    """Return the absolute version of a path.
 
270
    Windows 98 safe implementation (python reimplementation
 
271
    of Win32 API function GetFullPathNameW)
 
272
    """
 
273
    # Corner cases:
 
274
    #   C:\path     => C:/path
 
275
    #   C:/path     => C:/path
 
276
    #   \\HOST\path => //HOST/path
 
277
    #   //HOST/path => //HOST/path
 
278
    #   path        => C:/cwd/path
 
279
    #   /path       => C:/path
 
280
    path = unicode(path)
 
281
    # check for absolute path
 
282
    drive = _nt_splitdrive(path)[0]
 
283
    if drive == '' and path[:2] not in('//','\\\\'):
 
284
        cwd = os.getcwdu()
 
285
        # we cannot simply os.path.join cwd and path
 
286
        # because os.path.join('C:','/path') produce '/path'
 
287
        # and this is incorrect
 
288
        if path[:1] in ('/','\\'):
 
289
            cwd = _nt_splitdrive(cwd)[0]
 
290
            path = path[1:]
 
291
        path = cwd + '\\' + path
 
292
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
220
293
 
221
294
 
222
295
def _win32_realpath(path):
223
 
    return _nt_realpath(path.encode(_fs_enc)).decode(_fs_enc).replace('\\', '/')
 
296
    # Real _nt_realpath doesn't have a problem with a unicode cwd
 
297
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
224
298
 
225
299
 
226
300
def _win32_pathjoin(*args):
228
302
 
229
303
 
230
304
def _win32_normpath(path):
231
 
    return _nt_normpath(path).replace('\\', '/')
 
305
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
232
306
 
233
307
 
234
308
def _win32_getcwd():
235
 
    return os.getcwdu().replace('\\', '/')
 
309
    return _win32_fixdrive(os.getcwdu().replace('\\', '/'))
236
310
 
237
311
 
238
312
def _win32_mkdtemp(*args, **kwargs):
239
 
    return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
 
313
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
240
314
 
241
315
 
242
316
def _win32_rename(old, new):
243
 
    fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
317
    """We expect to be able to atomically replace 'new' with old.
 
318
 
 
319
    On win32, if new exists, it must be moved out of the way first,
 
320
    and then deleted. 
 
321
    """
 
322
    try:
 
323
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
324
    except OSError, e:
 
325
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
 
326
            # If we try to rename a non-existant file onto cwd, we get 
 
327
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT 
 
328
            # if the old path doesn't exist, sometimes we get EACCES
 
329
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
 
330
            os.lstat(old)
 
331
        raise
 
332
 
 
333
 
 
334
def _mac_getcwd():
 
335
    return unicodedata.normalize('NFC', os.getcwdu())
244
336
 
245
337
 
246
338
# Default is to just use the python builtins, but these can be rebound on
250
342
pathjoin = os.path.join
251
343
normpath = os.path.normpath
252
344
getcwd = os.getcwdu
253
 
mkdtemp = tempfile.mkdtemp
254
345
rename = os.rename
255
346
dirname = os.path.dirname
256
347
basename = os.path.basename
257
 
rmtree = shutil.rmtree
 
348
split = os.path.split
 
349
splitext = os.path.splitext
 
350
# These were already imported into local scope
 
351
# mkdtemp = tempfile.mkdtemp
 
352
# rmtree = shutil.rmtree
258
353
 
259
354
MIN_ABS_PATHLENGTH = 1
260
355
 
261
356
 
262
357
if sys.platform == 'win32':
263
 
    abspath = _win32_abspath
 
358
    if win32utils.winver == 'Windows 98':
 
359
        abspath = _win98_abspath
 
360
    else:
 
361
        abspath = _win32_abspath
264
362
    realpath = _win32_realpath
265
363
    pathjoin = _win32_pathjoin
266
364
    normpath = _win32_normpath
274
372
        """Error handler for shutil.rmtree function [for win32]
275
373
        Helps to remove files and dirs marked as read-only.
276
374
        """
277
 
        type_, value = excinfo[:2]
 
375
        exception = excinfo[1]
278
376
        if function in (os.remove, os.rmdir) \
279
 
            and type_ == OSError \
280
 
            and value.errno == errno.EACCES:
281
 
            bzrlib.osutils.make_writable(path)
 
377
            and isinstance(exception, OSError) \
 
378
            and exception.errno == errno.EACCES:
 
379
            make_writable(path)
282
380
            function(path)
283
381
        else:
284
382
            raise
286
384
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
287
385
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
288
386
        return shutil.rmtree(path, ignore_errors, onerror)
 
387
elif sys.platform == 'darwin':
 
388
    getcwd = _mac_getcwd
 
389
 
 
390
 
 
391
def get_terminal_encoding():
 
392
    """Find the best encoding for printing to the screen.
 
393
 
 
394
    This attempts to check both sys.stdout and sys.stdin to see
 
395
    what encoding they are in, and if that fails it falls back to
 
396
    osutils.get_user_encoding().
 
397
    The problem is that on Windows, locale.getpreferredencoding()
 
398
    is not the same encoding as that used by the console:
 
399
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
 
400
 
 
401
    On my standard US Windows XP, the preferred encoding is
 
402
    cp1252, but the console is cp437
 
403
    """
 
404
    from bzrlib.trace import mutter
 
405
    output_encoding = getattr(sys.stdout, 'encoding', None)
 
406
    if not output_encoding:
 
407
        input_encoding = getattr(sys.stdin, 'encoding', None)
 
408
        if not input_encoding:
 
409
            output_encoding = get_user_encoding()
 
410
            mutter('encoding stdout as osutils.get_user_encoding() %r',
 
411
                   output_encoding)
 
412
        else:
 
413
            output_encoding = input_encoding
 
414
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
 
415
    else:
 
416
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
417
    if output_encoding == 'cp0':
 
418
        # invalid encoding (cp0 means 'no codepage' on Windows)
 
419
        output_encoding = get_user_encoding()
 
420
        mutter('cp0 is invalid encoding.'
 
421
               ' encoding stdout as osutils.get_user_encoding() %r',
 
422
               output_encoding)
 
423
    # check encoding
 
424
    try:
 
425
        codecs.lookup(output_encoding)
 
426
    except LookupError:
 
427
        sys.stderr.write('bzr: warning:'
 
428
                         ' unknown terminal encoding %s.\n'
 
429
                         '  Using encoding %s instead.\n'
 
430
                         % (output_encoding, get_user_encoding())
 
431
                        )
 
432
        output_encoding = get_user_encoding()
 
433
 
 
434
    return output_encoding
289
435
 
290
436
 
291
437
def normalizepath(f):
292
 
    if hasattr(os.path, 'realpath'):
 
438
    if getattr(os.path, 'realpath', None) is not None:
293
439
        F = realpath
294
440
    else:
295
441
        F = abspath
300
446
        return pathjoin(F(p), e)
301
447
 
302
448
 
303
 
def backup_file(fn):
304
 
    """Copy a file to a backup.
305
 
 
306
 
    Backups are named in GNU-style, with a ~ suffix.
307
 
 
308
 
    If the file is already a backup, it's not copied.
309
 
    """
310
 
    if fn[-1] == '~':
311
 
        return
312
 
    bfn = fn + '~'
313
 
 
314
 
    if has_symlinks() and os.path.islink(fn):
315
 
        target = os.readlink(fn)
316
 
        os.symlink(target, bfn)
317
 
        return
318
 
    inf = file(fn, 'rb')
319
 
    try:
320
 
        content = inf.read()
321
 
    finally:
322
 
        inf.close()
323
 
    
324
 
    outf = file(bfn, 'wb')
325
 
    try:
326
 
        outf.write(content)
327
 
    finally:
328
 
        outf.close()
329
 
 
330
 
 
331
449
def isdir(f):
332
450
    """True if f is an accessible directory."""
333
451
    try:
359
477
    
360
478
    The empty string as a dir name is taken as top-of-tree and matches 
361
479
    everything.
362
 
    
363
 
    >>> is_inside('src', pathjoin('src', 'foo.c'))
364
 
    True
365
 
    >>> is_inside('src', 'srccontrol')
366
 
    False
367
 
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
368
 
    True
369
 
    >>> is_inside('foo.c', 'foo.c')
370
 
    True
371
 
    >>> is_inside('foo.c', '')
372
 
    False
373
 
    >>> is_inside('', 'foo.c')
374
 
    True
375
480
    """
376
481
    # XXX: Most callers of this can actually do something smarter by 
377
482
    # looking at the inventory
392
497
    for dirname in dir_list:
393
498
        if is_inside(dirname, fname):
394
499
            return True
395
 
    else:
396
 
        return False
 
500
    return False
397
501
 
398
502
 
399
503
def is_inside_or_parent_of_any(dir_list, fname):
401
505
    for dirname in dir_list:
402
506
        if is_inside(dirname, fname) or is_inside(fname, dirname):
403
507
            return True
 
508
    return False
 
509
 
 
510
 
 
511
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768):
 
512
    """Copy contents of one file to another.
 
513
 
 
514
    The read_length can either be -1 to read to end-of-file (EOF) or
 
515
    it can specify the maximum number of bytes to read.
 
516
 
 
517
    The buff_size represents the maximum size for each read operation
 
518
    performed on from_file.
 
519
 
 
520
    :return: The number of bytes copied.
 
521
    """
 
522
    length = 0
 
523
    if read_length >= 0:
 
524
        # read specified number of bytes
 
525
 
 
526
        while read_length > 0:
 
527
            num_bytes_to_read = min(read_length, buff_size)
 
528
 
 
529
            block = from_file.read(num_bytes_to_read)
 
530
            if not block:
 
531
                # EOF reached
 
532
                break
 
533
            to_file.write(block)
 
534
 
 
535
            actual_bytes_read = len(block)
 
536
            read_length -= actual_bytes_read
 
537
            length += actual_bytes_read
404
538
    else:
405
 
        return False
406
 
 
407
 
 
408
 
def pumpfile(fromfile, tofile):
409
 
    """Copy contents of one file to another."""
410
 
    BUFSIZE = 32768
411
 
    while True:
412
 
        b = fromfile.read(BUFSIZE)
413
 
        if not b:
414
 
            break
415
 
        tofile.write(b)
 
539
        # read to EOF
 
540
        while True:
 
541
            block = from_file.read(buff_size)
 
542
            if not block:
 
543
                # EOF reached
 
544
                break
 
545
            to_file.write(block)
 
546
            length += len(block)
 
547
    return length
 
548
 
 
549
 
 
550
def pump_string_file(bytes, file_handle, segment_size=None):
 
551
    """Write bytes to file_handle in many smaller writes.
 
552
 
 
553
    :param bytes: The string to write.
 
554
    :param file_handle: The file to write to.
 
555
    """
 
556
    # Write data in chunks rather than all at once, because very large
 
557
    # writes fail on some platforms (e.g. Windows with SMB  mounted
 
558
    # drives).
 
559
    if not segment_size:
 
560
        segment_size = 5242880 # 5MB
 
561
    segments = range(len(bytes) / segment_size + 1)
 
562
    write = file_handle.write
 
563
    for segment_index in segments:
 
564
        segment = buffer(bytes, segment_index * segment_size, segment_size)
 
565
        write(segment)
416
566
 
417
567
 
418
568
def file_iterator(input_file, readsize=32768):
424
574
 
425
575
 
426
576
def sha_file(f):
427
 
    if hasattr(f, 'tell'):
428
 
        assert f.tell() == 0
429
 
    s = sha.new()
 
577
    """Calculate the hexdigest of an open file.
 
578
 
 
579
    The file cursor should be already at the start.
 
580
    """
 
581
    s = sha()
430
582
    BUFSIZE = 128<<10
431
583
    while True:
432
584
        b = f.read(BUFSIZE)
436
588
    return s.hexdigest()
437
589
 
438
590
 
439
 
 
440
 
def sha_strings(strings):
 
591
def sha_file_by_name(fname):
 
592
    """Calculate the SHA1 of a file by reading the full text"""
 
593
    s = sha()
 
594
    f = os.open(fname, os.O_RDONLY | O_BINARY)
 
595
    try:
 
596
        while True:
 
597
            b = os.read(f, 1<<16)
 
598
            if not b:
 
599
                return s.hexdigest()
 
600
            s.update(b)
 
601
    finally:
 
602
        os.close(f)
 
603
 
 
604
 
 
605
def sha_strings(strings, _factory=sha):
441
606
    """Return the sha-1 of concatenation of strings"""
442
 
    s = sha.new()
 
607
    s = _factory()
443
608
    map(s.update, strings)
444
609
    return s.hexdigest()
445
610
 
446
611
 
447
 
def sha_string(f):
448
 
    s = sha.new()
449
 
    s.update(f)
450
 
    return s.hexdigest()
 
612
def sha_string(f, _factory=sha):
 
613
    return _factory(f).hexdigest()
451
614
 
452
615
 
453
616
def fingerprint_file(f):
454
 
    s = sha.new()
455
617
    b = f.read()
456
 
    s.update(b)
457
 
    size = len(b)
458
 
    return {'size': size,
459
 
            'sha1': s.hexdigest()}
 
618
    return {'size': len(b),
 
619
            'sha1': sha(b).hexdigest()}
460
620
 
461
621
 
462
622
def compare_files(a, b):
473
633
 
474
634
def local_time_offset(t=None):
475
635
    """Return offset of local zone from GMT, either at present or at time t."""
476
 
    # python2.3 localtime() can't take None
477
 
    if t == None:
 
636
    if t is None:
478
637
        t = time.time()
479
 
        
480
 
    if time.localtime(t).tm_isdst and time.daylight:
481
 
        return -time.altzone
482
 
    else:
483
 
        return -time.timezone
 
638
    offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
 
639
    return offset.days * 86400 + offset.seconds
484
640
 
 
641
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
485
642
    
486
 
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
643
def format_date(t, offset=0, timezone='original', date_fmt=None,
487
644
                show_offset=True):
488
 
    ## TODO: Perhaps a global option to use either universal or local time?
489
 
    ## Or perhaps just let people set $TZ?
490
 
    assert isinstance(t, float)
491
 
    
 
645
    """Return a formatted date string.
 
646
 
 
647
    :param t: Seconds since the epoch.
 
648
    :param offset: Timezone offset in seconds east of utc.
 
649
    :param timezone: How to display the time: 'utc', 'original' for the
 
650
         timezone specified by offset, or 'local' for the process's current
 
651
         timezone.
 
652
    :param date_fmt: strftime format.
 
653
    :param show_offset: Whether to append the timezone.
 
654
    """
 
655
    (date_fmt, tt, offset_str) = \
 
656
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
657
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
 
658
    date_str = time.strftime(date_fmt, tt)
 
659
    return date_str + offset_str
 
660
 
 
661
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
 
662
                      show_offset=True):
 
663
    """Return an unicode date string formatted according to the current locale.
 
664
 
 
665
    :param t: Seconds since the epoch.
 
666
    :param offset: Timezone offset in seconds east of utc.
 
667
    :param timezone: How to display the time: 'utc', 'original' for the
 
668
         timezone specified by offset, or 'local' for the process's current
 
669
         timezone.
 
670
    :param date_fmt: strftime format.
 
671
    :param show_offset: Whether to append the timezone.
 
672
    """
 
673
    (date_fmt, tt, offset_str) = \
 
674
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
675
    date_str = time.strftime(date_fmt, tt)
 
676
    if not isinstance(date_str, unicode):
 
677
        date_str = date_str.decode(bzrlib.user_encoding, 'replace')
 
678
    return date_str + offset_str
 
679
 
 
680
def _format_date(t, offset, timezone, date_fmt, show_offset):
492
681
    if timezone == 'utc':
493
682
        tt = time.gmtime(t)
494
683
        offset = 0
495
684
    elif timezone == 'original':
496
 
        if offset == None:
 
685
        if offset is None:
497
686
            offset = 0
498
687
        tt = time.gmtime(t + offset)
499
688
    elif timezone == 'local':
500
689
        tt = time.localtime(t)
501
690
        offset = local_time_offset(t)
502
691
    else:
503
 
        raise BzrError("unsupported timezone format %r" % timezone,
504
 
                       ['options are "utc", "original", "local"'])
 
692
        raise errors.UnsupportedTimezoneFormat(timezone)
505
693
    if date_fmt is None:
506
694
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
507
695
    if show_offset:
508
696
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
509
697
    else:
510
698
        offset_str = ''
511
 
    return (time.strftime(date_fmt, tt) +  offset_str)
 
699
    return (date_fmt, tt, offset_str)
512
700
 
513
701
 
514
702
def compact_date(when):
515
703
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
516
704
    
517
705
 
 
706
def format_delta(delta):
 
707
    """Get a nice looking string for a time delta.
 
708
 
 
709
    :param delta: The time difference in seconds, can be positive or negative.
 
710
        positive indicates time in the past, negative indicates time in the
 
711
        future. (usually time.time() - stored_time)
 
712
    :return: String formatted to show approximate resolution
 
713
    """
 
714
    delta = int(delta)
 
715
    if delta >= 0:
 
716
        direction = 'ago'
 
717
    else:
 
718
        direction = 'in the future'
 
719
        delta = -delta
 
720
 
 
721
    seconds = delta
 
722
    if seconds < 90: # print seconds up to 90 seconds
 
723
        if seconds == 1:
 
724
            return '%d second %s' % (seconds, direction,)
 
725
        else:
 
726
            return '%d seconds %s' % (seconds, direction)
 
727
 
 
728
    minutes = int(seconds / 60)
 
729
    seconds -= 60 * minutes
 
730
    if seconds == 1:
 
731
        plural_seconds = ''
 
732
    else:
 
733
        plural_seconds = 's'
 
734
    if minutes < 90: # print minutes, seconds up to 90 minutes
 
735
        if minutes == 1:
 
736
            return '%d minute, %d second%s %s' % (
 
737
                    minutes, seconds, plural_seconds, direction)
 
738
        else:
 
739
            return '%d minutes, %d second%s %s' % (
 
740
                    minutes, seconds, plural_seconds, direction)
 
741
 
 
742
    hours = int(minutes / 60)
 
743
    minutes -= 60 * hours
 
744
    if minutes == 1:
 
745
        plural_minutes = ''
 
746
    else:
 
747
        plural_minutes = 's'
 
748
 
 
749
    if hours == 1:
 
750
        return '%d hour, %d minute%s %s' % (hours, minutes,
 
751
                                            plural_minutes, direction)
 
752
    return '%d hours, %d minute%s %s' % (hours, minutes,
 
753
                                         plural_minutes, direction)
518
754
 
519
755
def filesize(f):
520
756
    """Return size of given open file."""
530
766
except (NotImplementedError, AttributeError):
531
767
    # If python doesn't have os.urandom, or it doesn't work,
532
768
    # then try to first pull random data from /dev/urandom
533
 
    if os.path.exists("/dev/urandom"):
 
769
    try:
534
770
        rand_bytes = file('/dev/urandom', 'rb').read
535
771
    # Otherwise, use this hack as a last resort
536
 
    else:
 
772
    except (IOError, OSError):
537
773
        # not well seeded, but better than nothing
538
774
        def rand_bytes(n):
539
775
            import random
561
797
## decomposition (might be too tricksy though.)
562
798
 
563
799
def splitpath(p):
564
 
    """Turn string into list of parts.
565
 
 
566
 
    >>> splitpath('a')
567
 
    ['a']
568
 
    >>> splitpath('a/b')
569
 
    ['a', 'b']
570
 
    >>> splitpath('a/./b')
571
 
    ['a', 'b']
572
 
    >>> splitpath('a/.b')
573
 
    ['a', '.b']
574
 
    >>> splitpath('a/../b')
575
 
    Traceback (most recent call last):
576
 
    ...
577
 
    BzrError: sorry, '..' not allowed in path
578
 
    """
579
 
    assert isinstance(p, types.StringTypes)
580
 
 
 
800
    """Turn string into list of parts."""
581
801
    # split on either delimiter because people might use either on
582
802
    # Windows
583
803
    ps = re.split(r'[\\/]', p)
585
805
    rps = []
586
806
    for f in ps:
587
807
        if f == '..':
588
 
            raise BzrError("sorry, %r not allowed in path" % f)
 
808
            raise errors.BzrError("sorry, %r not allowed in path" % f)
589
809
        elif (f == '.') or (f == ''):
590
810
            pass
591
811
        else:
592
812
            rps.append(f)
593
813
    return rps
594
814
 
 
815
 
595
816
def joinpath(p):
596
 
    assert isinstance(p, list)
597
817
    for f in p:
598
 
        if (f == '..') or (f == None) or (f == ''):
599
 
            raise BzrError("sorry, %r not allowed in path" % f)
 
818
        if (f == '..') or (f is None) or (f == ''):
 
819
            raise errors.BzrError("sorry, %r not allowed in path" % f)
600
820
    return pathjoin(*p)
601
821
 
602
822
 
603
 
@deprecated_function(zero_nine)
604
 
def appendpath(p1, p2):
605
 
    if p1 == '':
606
 
        return p2
607
 
    else:
608
 
        return pathjoin(p1, p2)
609
 
    
 
823
try:
 
824
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
 
825
except ImportError:
 
826
    from bzrlib._chunks_to_lines_py import chunks_to_lines
 
827
 
610
828
 
611
829
def split_lines(s):
612
830
    """Split s into lines, but without removing the newline characters."""
 
831
    # Trivially convert a fulltext into a 'chunked' representation, and let
 
832
    # chunks_to_lines do the heavy lifting.
 
833
    if isinstance(s, str):
 
834
        # chunks_to_lines only supports 8-bit strings
 
835
        return chunks_to_lines([s])
 
836
    else:
 
837
        return _split_lines(s)
 
838
 
 
839
 
 
840
def _split_lines(s):
 
841
    """Split s into lines, but without removing the newline characters.
 
842
 
 
843
    This supports Unicode or plain string objects.
 
844
    """
613
845
    lines = s.split('\n')
614
846
    result = [line + '\n' for line in lines[:-1]]
615
847
    if lines[-1]:
624
856
def link_or_copy(src, dest):
625
857
    """Hardlink a file, or copy it if it can't be hardlinked."""
626
858
    if not hardlinks_good():
627
 
        copyfile(src, dest)
 
859
        shutil.copyfile(src, dest)
628
860
        return
629
861
    try:
630
862
        os.link(src, dest)
631
863
    except (OSError, IOError), e:
632
864
        if e.errno != errno.EXDEV:
633
865
            raise
634
 
        copyfile(src, dest)
635
 
 
636
 
def delete_any(full_path):
 
866
        shutil.copyfile(src, dest)
 
867
 
 
868
 
 
869
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
 
870
# Forgiveness than Permission (EAFP) because:
 
871
# - root can damage a solaris file system by using unlink,
 
872
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
 
873
#   EACCES, OSX: EPERM) when invoked on a directory.
 
874
def delete_any(path):
637
875
    """Delete a file or directory."""
638
 
    try:
639
 
        os.unlink(full_path)
640
 
    except OSError, e:
641
 
    # We may be renaming a dangling inventory id
642
 
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
643
 
            raise
644
 
        os.rmdir(full_path)
 
876
    if isdir(path): # Takes care of symlinks
 
877
        os.rmdir(path)
 
878
    else:
 
879
        os.unlink(path)
645
880
 
646
881
 
647
882
def has_symlinks():
648
 
    if hasattr(os, 'symlink'):
649
 
        return True
650
 
    else:
651
 
        return False
652
 
        
 
883
    if getattr(os, 'symlink', None) is not None:
 
884
        return True
 
885
    else:
 
886
        return False
 
887
 
 
888
 
 
889
def has_hardlinks():
 
890
    if getattr(os, 'link', None) is not None:
 
891
        return True
 
892
    else:
 
893
        return False
 
894
 
 
895
 
 
896
def host_os_dereferences_symlinks():
 
897
    return (has_symlinks()
 
898
            and sys.platform not in ('cygwin', 'win32'))
 
899
 
653
900
 
654
901
def contains_whitespace(s):
655
902
    """True if there are any whitespace characters in s."""
656
 
    for ch in string.whitespace:
 
903
    # string.whitespace can include '\xa0' in certain locales, because it is
 
904
    # considered "non-breaking-space" as part of ISO-8859-1. But it
 
905
    # 1) Isn't a breaking whitespace
 
906
    # 2) Isn't one of ' \t\r\n' which are characters we sometimes use as
 
907
    #    separators
 
908
    # 3) '\xa0' isn't unicode safe since it is >128.
 
909
 
 
910
    # This should *not* be a unicode set of characters in case the source
 
911
    # string is not a Unicode string. We can auto-up-cast the characters since
 
912
    # they are ascii, but we don't want to auto-up-cast the string in case it
 
913
    # is utf-8
 
914
    for ch in ' \t\n\r\v\f':
657
915
        if ch in s:
658
916
            return True
659
917
    else:
680
938
    avoids that problem.
681
939
    """
682
940
 
683
 
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
684
 
        ' exceed the platform minimum length (which is %d)' % 
685
 
        MIN_ABS_PATHLENGTH)
 
941
    if len(base) < MIN_ABS_PATHLENGTH:
 
942
        # must have space for e.g. a drive letter
 
943
        raise ValueError('%r is too short to calculate a relative path'
 
944
            % (base,))
686
945
 
687
946
    rp = abspath(path)
688
947
 
695
954
        if tail:
696
955
            s.insert(0, tail)
697
956
    else:
698
 
        raise PathNotChild(rp, base)
 
957
        raise errors.PathNotChild(rp, base)
699
958
 
700
959
    if s:
701
960
        return pathjoin(*s)
703
962
        return ''
704
963
 
705
964
 
 
965
def _cicp_canonical_relpath(base, path):
 
966
    """Return the canonical path relative to base.
 
967
 
 
968
    Like relpath, but on case-insensitive-case-preserving file-systems, this
 
969
    will return the relpath as stored on the file-system rather than in the
 
970
    case specified in the input string, for all existing portions of the path.
 
971
 
 
972
    This will cause O(N) behaviour if called for every path in a tree; if you
 
973
    have a number of paths to convert, you should use canonical_relpaths().
 
974
    """
 
975
    # TODO: it should be possible to optimize this for Windows by using the
 
976
    # win32 API FindFiles function to look for the specified name - but using
 
977
    # os.listdir() still gives us the correct, platform agnostic semantics in
 
978
    # the short term.
 
979
 
 
980
    rel = relpath(base, path)
 
981
    # '.' will have been turned into ''
 
982
    if not rel:
 
983
        return rel
 
984
 
 
985
    abs_base = abspath(base)
 
986
    current = abs_base
 
987
    _listdir = os.listdir
 
988
 
 
989
    # use an explicit iterator so we can easily consume the rest on early exit.
 
990
    bit_iter = iter(rel.split('/'))
 
991
    for bit in bit_iter:
 
992
        lbit = bit.lower()
 
993
        for look in _listdir(current):
 
994
            if lbit == look.lower():
 
995
                current = pathjoin(current, look)
 
996
                break
 
997
        else:
 
998
            # got to the end, nothing matched, so we just return the
 
999
            # non-existing bits as they were specified (the filename may be
 
1000
            # the target of a move, for example).
 
1001
            current = pathjoin(current, bit, *list(bit_iter))
 
1002
            break
 
1003
    return current[len(abs_base)+1:]
 
1004
 
 
1005
# XXX - TODO - we need better detection/integration of case-insensitive
 
1006
# file-systems; Linux often sees FAT32 devices, for example, so could
 
1007
# probably benefit from the same basic support there.  For now though, only
 
1008
# Windows gets that support, and it gets it for *all* file-systems!
 
1009
if sys.platform == "win32":
 
1010
    canonical_relpath = _cicp_canonical_relpath
 
1011
else:
 
1012
    canonical_relpath = relpath
 
1013
 
 
1014
def canonical_relpaths(base, paths):
 
1015
    """Create an iterable to canonicalize a sequence of relative paths.
 
1016
 
 
1017
    The intent is for this implementation to use a cache, vastly speeding
 
1018
    up multiple transformations in the same directory.
 
1019
    """
 
1020
    # but for now, we haven't optimized...
 
1021
    return [canonical_relpath(base, p) for p in paths]
 
1022
 
706
1023
def safe_unicode(unicode_or_utf8_string):
707
1024
    """Coerce unicode_or_utf8_string into unicode.
708
1025
 
716
1033
    try:
717
1034
        return unicode_or_utf8_string.decode('utf8')
718
1035
    except UnicodeDecodeError:
719
 
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
1036
        raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
1037
 
 
1038
 
 
1039
def safe_utf8(unicode_or_utf8_string):
 
1040
    """Coerce unicode_or_utf8_string to a utf8 string.
 
1041
 
 
1042
    If it is a str, it is returned.
 
1043
    If it is Unicode, it is encoded into a utf-8 string.
 
1044
    """
 
1045
    if isinstance(unicode_or_utf8_string, str):
 
1046
        # TODO: jam 20070209 This is overkill, and probably has an impact on
 
1047
        #       performance if we are dealing with lots of apis that want a
 
1048
        #       utf-8 revision id
 
1049
        try:
 
1050
            # Make sure it is a valid utf-8 string
 
1051
            unicode_or_utf8_string.decode('utf-8')
 
1052
        except UnicodeDecodeError:
 
1053
            raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
1054
        return unicode_or_utf8_string
 
1055
    return unicode_or_utf8_string.encode('utf-8')
 
1056
 
 
1057
 
 
1058
_revision_id_warning = ('Unicode revision ids were deprecated in bzr 0.15.'
 
1059
                        ' Revision id generators should be creating utf8'
 
1060
                        ' revision ids.')
 
1061
 
 
1062
 
 
1063
def safe_revision_id(unicode_or_utf8_string, warn=True):
 
1064
    """Revision ids should now be utf8, but at one point they were unicode.
 
1065
 
 
1066
    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be
 
1067
        utf8 or None).
 
1068
    :param warn: Functions that are sanitizing user data can set warn=False
 
1069
    :return: None or a utf8 revision id.
 
1070
    """
 
1071
    if (unicode_or_utf8_string is None
 
1072
        or unicode_or_utf8_string.__class__ == str):
 
1073
        return unicode_or_utf8_string
 
1074
    if warn:
 
1075
        symbol_versioning.warn(_revision_id_warning, DeprecationWarning,
 
1076
                               stacklevel=2)
 
1077
    return cache_utf8.encode(unicode_or_utf8_string)
 
1078
 
 
1079
 
 
1080
_file_id_warning = ('Unicode file ids were deprecated in bzr 0.15. File id'
 
1081
                    ' generators should be creating utf8 file ids.')
 
1082
 
 
1083
 
 
1084
def safe_file_id(unicode_or_utf8_string, warn=True):
 
1085
    """File ids should now be utf8, but at one point they were unicode.
 
1086
 
 
1087
    This is the same as safe_utf8, except it uses the cached encode functions
 
1088
    to save a little bit of performance.
 
1089
 
 
1090
    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be
 
1091
        utf8 or None).
 
1092
    :param warn: Functions that are sanitizing user data can set warn=False
 
1093
    :return: None or a utf8 file id.
 
1094
    """
 
1095
    if (unicode_or_utf8_string is None
 
1096
        or unicode_or_utf8_string.__class__ == str):
 
1097
        return unicode_or_utf8_string
 
1098
    if warn:
 
1099
        symbol_versioning.warn(_file_id_warning, DeprecationWarning,
 
1100
                               stacklevel=2)
 
1101
    return cache_utf8.encode(unicode_or_utf8_string)
720
1102
 
721
1103
 
722
1104
_platform_normalizes_filenames = False
732
1114
    return _platform_normalizes_filenames
733
1115
 
734
1116
 
 
1117
def _accessible_normalized_filename(path):
 
1118
    """Get the unicode normalized path, and if you can access the file.
 
1119
 
 
1120
    On platforms where the system normalizes filenames (Mac OSX),
 
1121
    you can access a file by any path which will normalize correctly.
 
1122
    On platforms where the system does not normalize filenames 
 
1123
    (Windows, Linux), you have to access a file by its exact path.
 
1124
 
 
1125
    Internally, bzr only supports NFC normalization, since that is 
 
1126
    the standard for XML documents.
 
1127
 
 
1128
    So return the normalized path, and a flag indicating if the file
 
1129
    can be accessed by that path.
 
1130
    """
 
1131
 
 
1132
    return unicodedata.normalize('NFC', unicode(path)), True
 
1133
 
 
1134
 
 
1135
def _inaccessible_normalized_filename(path):
 
1136
    __doc__ = _accessible_normalized_filename.__doc__
 
1137
 
 
1138
    normalized = unicodedata.normalize('NFC', unicode(path))
 
1139
    return normalized, normalized == path
 
1140
 
 
1141
 
735
1142
if _platform_normalizes_filenames:
736
 
    def unicode_filename(path):
737
 
        """Make sure 'path' is a properly normalized filename.
738
 
 
739
 
        On platforms where the system normalizes filenames (Mac OSX),
740
 
        you can access a file by any path which will normalize
741
 
        correctly.
742
 
        Internally, bzr only supports NFC/NFKC normalization, since
743
 
        that is the standard for XML documents.
744
 
        So we return an normalized path, and indicate this has been
745
 
        properly normalized.
746
 
 
747
 
        :return: (path, is_normalized) Return a path which can
748
 
                access the file, and whether or not this path is
749
 
                normalized.
750
 
        """
751
 
        return unicodedata.normalize('NFKC', path), True
 
1143
    normalized_filename = _accessible_normalized_filename
752
1144
else:
753
 
    def unicode_filename(path):
754
 
        """Make sure 'path' is a properly normalized filename.
755
 
 
756
 
        On platforms where the system does not normalize filenames 
757
 
        (Windows, Linux), you have to access a file by its exact path.
758
 
        Internally, bzr only supports NFC/NFKC normalization, since
759
 
        that is the standard for XML documents.
760
 
        So we return the original path, and indicate if this is
761
 
        properly normalized.
762
 
 
763
 
        :return: (path, is_normalized) Return a path which can
764
 
                access the file, and whether or not this path is
765
 
                normalized.
766
 
        """
767
 
        return path, unicodedata.normalize('NFKC', path) == path
 
1145
    normalized_filename = _inaccessible_normalized_filename
768
1146
 
769
1147
 
770
1148
def terminal_width():
771
1149
    """Return estimated terminal width."""
772
1150
    if sys.platform == 'win32':
773
 
        import bzrlib.win32console
774
 
        return bzrlib.win32console.get_console_size()[0]
 
1151
        return win32utils.get_console_size()[0]
775
1152
    width = 0
776
1153
    try:
777
1154
        import struct, fcntl, termios
790
1167
 
791
1168
    return width
792
1169
 
 
1170
 
793
1171
def supports_executable():
794
1172
    return sys.platform != "win32"
795
1173
 
796
1174
 
 
1175
def supports_posix_readonly():
 
1176
    """Return True if 'readonly' has POSIX semantics, False otherwise.
 
1177
 
 
1178
    Notably, a win32 readonly file cannot be deleted, unlike POSIX where the
 
1179
    directory controls creation/deletion, etc.
 
1180
 
 
1181
    And under win32, readonly means that the directory itself cannot be
 
1182
    deleted.  The contents of a readonly directory can be changed, unlike POSIX
 
1183
    where files in readonly directories cannot be added, deleted or renamed.
 
1184
    """
 
1185
    return sys.platform != "win32"
 
1186
 
 
1187
 
 
1188
def set_or_unset_env(env_variable, value):
 
1189
    """Modify the environment, setting or removing the env_variable.
 
1190
 
 
1191
    :param env_variable: The environment variable in question
 
1192
    :param value: The value to set the environment to. If None, then
 
1193
        the variable will be removed.
 
1194
    :return: The original value of the environment variable.
 
1195
    """
 
1196
    orig_val = os.environ.get(env_variable)
 
1197
    if value is None:
 
1198
        if orig_val is not None:
 
1199
            del os.environ[env_variable]
 
1200
    else:
 
1201
        if isinstance(value, unicode):
 
1202
            value = value.encode(get_user_encoding())
 
1203
        os.environ[env_variable] = value
 
1204
    return orig_val
 
1205
 
 
1206
 
797
1207
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
798
1208
 
799
1209
 
805
1215
    if sys.platform != "win32":
806
1216
        return
807
1217
    if _validWin32PathRE.match(path) is None:
808
 
        raise IllegalPath(path)
 
1218
        raise errors.IllegalPath(path)
 
1219
 
 
1220
 
 
1221
_WIN32_ERROR_DIRECTORY = 267 # Similar to errno.ENOTDIR
 
1222
 
 
1223
def _is_error_enotdir(e):
 
1224
    """Check if this exception represents ENOTDIR.
 
1225
 
 
1226
    Unfortunately, python is very inconsistent about the exception
 
1227
    here. The cases are:
 
1228
      1) Linux, Mac OSX all versions seem to set errno == ENOTDIR
 
1229
      2) Windows, Python2.4, uses errno == ERROR_DIRECTORY (267)
 
1230
         which is the windows error code.
 
1231
      3) Windows, Python2.5 uses errno == EINVAL and
 
1232
         winerror == ERROR_DIRECTORY
 
1233
 
 
1234
    :param e: An Exception object (expected to be OSError with an errno
 
1235
        attribute, but we should be able to cope with anything)
 
1236
    :return: True if this represents an ENOTDIR error. False otherwise.
 
1237
    """
 
1238
    en = getattr(e, 'errno', None)
 
1239
    if (en == errno.ENOTDIR
 
1240
        or (sys.platform == 'win32'
 
1241
            and (en == _WIN32_ERROR_DIRECTORY
 
1242
                 or (en == errno.EINVAL
 
1243
                     and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
 
1244
        ))):
 
1245
        return True
 
1246
    return False
809
1247
 
810
1248
 
811
1249
def walkdirs(top, prefix=""):
816
1254
    to exclude some directories, they are then not descended into.
817
1255
    
818
1256
    The data yielded is of the form:
819
 
    [(relpath, basename, kind, lstat, path_from_top), ...]
 
1257
    ((directory-relpath, directory-path-from-top),
 
1258
    [(relpath, basename, kind, lstat, path-from-top), ...]),
 
1259
     - directory-relpath is the relative path of the directory being returned
 
1260
       with respect to top. prefix is prepended to this.
 
1261
     - directory-path-from-root is the path including top for this directory. 
 
1262
       It is suitable for use with os functions.
 
1263
     - relpath is the relative path within the subtree being walked.
 
1264
     - basename is the basename of the path
 
1265
     - kind is the kind of the file now. If unknown then the file is not
 
1266
       present within the tree - but it may be recorded as versioned. See
 
1267
       versioned_kind.
 
1268
     - lstat is the stat data *if* the file was statted.
 
1269
     - planned, not implemented: 
 
1270
       path_from_tree_root is the path from the root of the tree.
820
1271
 
821
1272
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
822
1273
        allows one to walk a subtree but get paths that are relative to a tree
823
1274
        rooted higher up.
824
1275
    :return: an iterator over the dirs.
825
1276
    """
826
 
    lstat = os.lstat
827
 
    pending = []
 
1277
    #TODO there is a bit of a smell where the results of the directory-
 
1278
    # summary in this, and the path from the root, may not agree 
 
1279
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
 
1280
    # potentially confusing output. We should make this more robust - but
 
1281
    # not at a speed cost. RBC 20060731
 
1282
    _lstat = os.lstat
828
1283
    _directory = _directory_kind
829
 
    _listdir = listdir
830
 
    pending = [(prefix, "", _directory, None, top)]
 
1284
    _listdir = os.listdir
 
1285
    _kind_from_mode = file_kind_from_stat_mode
 
1286
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
831
1287
    while pending:
832
 
        dirblock = []
833
 
        currentdir = pending.pop()
834
1288
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
835
 
        top = currentdir[4]
836
 
        if currentdir[0]:
837
 
            relroot = currentdir[0] + '/'
838
 
        else:
839
 
            relroot = ""
 
1289
        relroot, _, _, _, top = pending.pop()
 
1290
        if relroot:
 
1291
            relprefix = relroot + u'/'
 
1292
        else:
 
1293
            relprefix = ''
 
1294
        top_slash = top + u'/'
 
1295
 
 
1296
        dirblock = []
 
1297
        append = dirblock.append
 
1298
        try:
 
1299
            names = sorted(_listdir(top))
 
1300
        except OSError, e:
 
1301
            if not _is_error_enotdir(e):
 
1302
                raise
 
1303
        else:
 
1304
            for name in names:
 
1305
                abspath = top_slash + name
 
1306
                statvalue = _lstat(abspath)
 
1307
                kind = _kind_from_mode(statvalue.st_mode)
 
1308
                append((relprefix + name, name, kind, statvalue, abspath))
 
1309
        yield (relroot, top), dirblock
 
1310
 
 
1311
        # push the user specified dirs from dirblock
 
1312
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1313
 
 
1314
 
 
1315
class DirReader(object):
 
1316
    """An interface for reading directories."""
 
1317
 
 
1318
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1319
        """Converts top and prefix to a starting dir entry
 
1320
 
 
1321
        :param top: A utf8 path
 
1322
        :param prefix: An optional utf8 path to prefix output relative paths
 
1323
            with.
 
1324
        :return: A tuple starting with prefix, and ending with the native
 
1325
            encoding of top.
 
1326
        """
 
1327
        raise NotImplementedError(self.top_prefix_to_starting_dir)
 
1328
 
 
1329
    def read_dir(self, prefix, top):
 
1330
        """Read a specific dir.
 
1331
 
 
1332
        :param prefix: A utf8 prefix to be preprended to the path basenames.
 
1333
        :param top: A natively encoded path to read.
 
1334
        :return: A list of the directories contents. Each item contains:
 
1335
            (utf8_relpath, utf8_name, kind, lstatvalue, native_abspath)
 
1336
        """
 
1337
        raise NotImplementedError(self.read_dir)
 
1338
 
 
1339
 
 
1340
_selected_dir_reader = None
 
1341
 
 
1342
 
 
1343
def _walkdirs_utf8(top, prefix=""):
 
1344
    """Yield data about all the directories in a tree.
 
1345
 
 
1346
    This yields the same information as walkdirs() only each entry is yielded
 
1347
    in utf-8. On platforms which have a filesystem encoding of utf8 the paths
 
1348
    are returned as exact byte-strings.
 
1349
 
 
1350
    :return: yields a tuple of (dir_info, [file_info])
 
1351
        dir_info is (utf8_relpath, path-from-top)
 
1352
        file_info is (utf8_relpath, utf8_name, kind, lstat, path-from-top)
 
1353
        if top is an absolute path, path-from-top is also an absolute path.
 
1354
        path-from-top might be unicode or utf8, but it is the correct path to
 
1355
        pass to os functions to affect the file in question. (such as os.lstat)
 
1356
    """
 
1357
    global _selected_dir_reader
 
1358
    if _selected_dir_reader is None:
 
1359
        fs_encoding = _fs_enc.upper()
 
1360
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
 
1361
            # Win98 doesn't have unicode apis like FindFirstFileW
 
1362
            # TODO: We possibly could support Win98 by falling back to the
 
1363
            #       original FindFirstFile, and using TCHAR instead of WCHAR,
 
1364
            #       but that gets a bit tricky, and requires custom compiling
 
1365
            #       for win98 anyway.
 
1366
            try:
 
1367
                from bzrlib._walkdirs_win32 import Win32ReadDir
 
1368
            except ImportError:
 
1369
                _selected_dir_reader = UnicodeDirReader()
 
1370
            else:
 
1371
                _selected_dir_reader = Win32ReadDir()
 
1372
        elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1373
            # ANSI_X3.4-1968 is a form of ASCII
 
1374
            _selected_dir_reader = UnicodeDirReader()
 
1375
        else:
 
1376
            try:
 
1377
                from bzrlib._readdir_pyx import UTF8DirReader
 
1378
            except ImportError:
 
1379
                # No optimised code path
 
1380
                _selected_dir_reader = UnicodeDirReader()
 
1381
            else:
 
1382
                _selected_dir_reader = UTF8DirReader()
 
1383
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
 
1384
    # But we don't actually uses 1-3 in pending, so set them to None
 
1385
    pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
 
1386
    read_dir = _selected_dir_reader.read_dir
 
1387
    _directory = _directory_kind
 
1388
    while pending:
 
1389
        relroot, _, _, _, top = pending[-1].pop()
 
1390
        if not pending[-1]:
 
1391
            pending.pop()
 
1392
        dirblock = sorted(read_dir(relroot, top))
 
1393
        yield (relroot, top), dirblock
 
1394
        # push the user specified dirs from dirblock
 
1395
        next = [d for d in reversed(dirblock) if d[2] == _directory]
 
1396
        if next:
 
1397
            pending.append(next)
 
1398
 
 
1399
 
 
1400
class UnicodeDirReader(DirReader):
 
1401
    """A dir reader for non-utf8 file systems, which transcodes."""
 
1402
 
 
1403
    __slots__ = ['_utf8_encode']
 
1404
 
 
1405
    def __init__(self):
 
1406
        self._utf8_encode = codecs.getencoder('utf8')
 
1407
 
 
1408
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1409
        """See DirReader.top_prefix_to_starting_dir."""
 
1410
        return (safe_utf8(prefix), None, None, None, safe_unicode(top))
 
1411
 
 
1412
    def read_dir(self, prefix, top):
 
1413
        """Read a single directory from a non-utf8 file system.
 
1414
 
 
1415
        top, and the abspath element in the output are unicode, all other paths
 
1416
        are utf8. Local disk IO is done via unicode calls to listdir etc.
 
1417
 
 
1418
        This is currently the fallback code path when the filesystem encoding is
 
1419
        not UTF-8. It may be better to implement an alternative so that we can
 
1420
        safely handle paths that are not properly decodable in the current
 
1421
        encoding.
 
1422
 
 
1423
        See DirReader.read_dir for details.
 
1424
        """
 
1425
        _utf8_encode = self._utf8_encode
 
1426
        _lstat = os.lstat
 
1427
        _listdir = os.listdir
 
1428
        _kind_from_mode = file_kind_from_stat_mode
 
1429
 
 
1430
        if prefix:
 
1431
            relprefix = prefix + '/'
 
1432
        else:
 
1433
            relprefix = ''
 
1434
        top_slash = top + u'/'
 
1435
 
 
1436
        dirblock = []
 
1437
        append = dirblock.append
840
1438
        for name in sorted(_listdir(top)):
841
 
            abspath = top + '/' + name
842
 
            statvalue = lstat(abspath)
843
 
            dirblock.append ((relroot + name, name, file_kind_from_stat_mode(statvalue.st_mode), statvalue, abspath))
844
 
        yield dirblock
845
 
        # push the user specified dirs from dirblock
846
 
        for dir in reversed(dirblock):
847
 
            if dir[2] == _directory:
848
 
                pending.append(dir)
 
1439
            try:
 
1440
                name_utf8 = _utf8_encode(name)[0]
 
1441
            except UnicodeDecodeError:
 
1442
                raise errors.BadFilenameEncoding(
 
1443
                    _utf8_encode(relprefix)[0] + name, _fs_enc)
 
1444
            abspath = top_slash + name
 
1445
            statvalue = _lstat(abspath)
 
1446
            kind = _kind_from_mode(statvalue.st_mode)
 
1447
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
 
1448
        return dirblock
 
1449
 
 
1450
 
 
1451
def copy_tree(from_path, to_path, handlers={}):
 
1452
    """Copy all of the entries in from_path into to_path.
 
1453
 
 
1454
    :param from_path: The base directory to copy. 
 
1455
    :param to_path: The target directory. If it does not exist, it will
 
1456
        be created.
 
1457
    :param handlers: A dictionary of functions, which takes a source and
 
1458
        destinations for files, directories, etc.
 
1459
        It is keyed on the file kind, such as 'directory', 'symlink', or 'file'
 
1460
        'file', 'directory', and 'symlink' should always exist.
 
1461
        If they are missing, they will be replaced with 'os.mkdir()',
 
1462
        'os.readlink() + os.symlink()', and 'shutil.copy2()', respectively.
 
1463
    """
 
1464
    # Now, just copy the existing cached tree to the new location
 
1465
    # We use a cheap trick here.
 
1466
    # Absolute paths are prefixed with the first parameter
 
1467
    # relative paths are prefixed with the second.
 
1468
    # So we can get both the source and target returned
 
1469
    # without any extra work.
 
1470
 
 
1471
    def copy_dir(source, dest):
 
1472
        os.mkdir(dest)
 
1473
 
 
1474
    def copy_link(source, dest):
 
1475
        """Copy the contents of a symlink"""
 
1476
        link_to = os.readlink(source)
 
1477
        os.symlink(link_to, dest)
 
1478
 
 
1479
    real_handlers = {'file':shutil.copy2,
 
1480
                     'symlink':copy_link,
 
1481
                     'directory':copy_dir,
 
1482
                    }
 
1483
    real_handlers.update(handlers)
 
1484
 
 
1485
    if not os.path.exists(to_path):
 
1486
        real_handlers['directory'](from_path, to_path)
 
1487
 
 
1488
    for dir_info, entries in walkdirs(from_path, prefix=to_path):
 
1489
        for relpath, name, kind, st, abspath in entries:
 
1490
            real_handlers[kind](abspath, relpath)
 
1491
 
 
1492
 
 
1493
def path_prefix_key(path):
 
1494
    """Generate a prefix-order path key for path.
 
1495
 
 
1496
    This can be used to sort paths in the same way that walkdirs does.
 
1497
    """
 
1498
    return (dirname(path) , path)
 
1499
 
 
1500
 
 
1501
def compare_paths_prefix_order(path_a, path_b):
 
1502
    """Compare path_a and path_b to generate the same order walkdirs uses."""
 
1503
    key_a = path_prefix_key(path_a)
 
1504
    key_b = path_prefix_key(path_b)
 
1505
    return cmp(key_a, key_b)
 
1506
 
 
1507
 
 
1508
_cached_user_encoding = None
 
1509
 
 
1510
 
 
1511
def get_user_encoding(use_cache=True):
 
1512
    """Find out what the preferred user encoding is.
 
1513
 
 
1514
    This is generally the encoding that is used for command line parameters
 
1515
    and file contents. This may be different from the terminal encoding
 
1516
    or the filesystem encoding.
 
1517
 
 
1518
    :param  use_cache:  Enable cache for detected encoding.
 
1519
                        (This parameter is turned on by default,
 
1520
                        and required only for selftesting)
 
1521
 
 
1522
    :return: A string defining the preferred user encoding
 
1523
    """
 
1524
    global _cached_user_encoding
 
1525
    if _cached_user_encoding is not None and use_cache:
 
1526
        return _cached_user_encoding
 
1527
 
 
1528
    if sys.platform == 'darwin':
 
1529
        # python locale.getpreferredencoding() always return
 
1530
        # 'mac-roman' on darwin. That's a lie.
 
1531
        sys.platform = 'posix'
 
1532
        try:
 
1533
            if os.environ.get('LANG', None) is None:
 
1534
                # If LANG is not set, we end up with 'ascii', which is bad
 
1535
                # ('mac-roman' is more than ascii), so we set a default which
 
1536
                # will give us UTF-8 (which appears to work in all cases on
 
1537
                # OSX). Users are still free to override LANG of course, as
 
1538
                # long as it give us something meaningful. This work-around
 
1539
                # *may* not be needed with python 3k and/or OSX 10.5, but will
 
1540
                # work with them too -- vila 20080908
 
1541
                os.environ['LANG'] = 'en_US.UTF-8'
 
1542
            import locale
 
1543
        finally:
 
1544
            sys.platform = 'darwin'
 
1545
    else:
 
1546
        import locale
 
1547
 
 
1548
    try:
 
1549
        user_encoding = locale.getpreferredencoding()
 
1550
    except locale.Error, e:
 
1551
        sys.stderr.write('bzr: warning: %s\n'
 
1552
                         '  Could not determine what text encoding to use.\n'
 
1553
                         '  This error usually means your Python interpreter\n'
 
1554
                         '  doesn\'t support the locale set by $LANG (%s)\n'
 
1555
                         "  Continuing with ascii encoding.\n"
 
1556
                         % (e, os.environ.get('LANG')))
 
1557
        user_encoding = 'ascii'
 
1558
 
 
1559
    # Windows returns 'cp0' to indicate there is no code page. So we'll just
 
1560
    # treat that as ASCII, and not support printing unicode characters to the
 
1561
    # console.
 
1562
    #
 
1563
    # For python scripts run under vim, we get '', so also treat that as ASCII
 
1564
    if user_encoding in (None, 'cp0', ''):
 
1565
        user_encoding = 'ascii'
 
1566
    else:
 
1567
        # check encoding
 
1568
        try:
 
1569
            codecs.lookup(user_encoding)
 
1570
        except LookupError:
 
1571
            sys.stderr.write('bzr: warning:'
 
1572
                             ' unknown encoding %s.'
 
1573
                             ' Continuing with ascii encoding.\n'
 
1574
                             % user_encoding
 
1575
                            )
 
1576
            user_encoding = 'ascii'
 
1577
 
 
1578
    if use_cache:
 
1579
        _cached_user_encoding = user_encoding
 
1580
 
 
1581
    return user_encoding
 
1582
 
 
1583
 
 
1584
def get_host_name():
 
1585
    """Return the current unicode host name.
 
1586
 
 
1587
    This is meant to be used in place of socket.gethostname() because that
 
1588
    behaves inconsistently on different platforms.
 
1589
    """
 
1590
    if sys.platform == "win32":
 
1591
        import win32utils
 
1592
        return win32utils.get_host_name()
 
1593
    else:
 
1594
        import socket
 
1595
        return socket.gethostname().decode(get_user_encoding())
 
1596
 
 
1597
 
 
1598
def recv_all(socket, bytes):
 
1599
    """Receive an exact number of bytes.
 
1600
 
 
1601
    Regular Socket.recv() may return less than the requested number of bytes,
 
1602
    dependning on what's in the OS buffer.  MSG_WAITALL is not available
 
1603
    on all platforms, but this should work everywhere.  This will return
 
1604
    less than the requested amount if the remote end closes.
 
1605
 
 
1606
    This isn't optimized and is intended mostly for use in testing.
 
1607
    """
 
1608
    b = ''
 
1609
    while len(b) < bytes:
 
1610
        new = until_no_eintr(socket.recv, bytes - len(b))
 
1611
        if new == '':
 
1612
            break # eof
 
1613
        b += new
 
1614
    return b
 
1615
 
 
1616
 
 
1617
def send_all(socket, bytes):
 
1618
    """Send all bytes on a socket.
 
1619
 
 
1620
    Regular socket.sendall() can give socket error 10053 on Windows.  This
 
1621
    implementation sends no more than 64k at a time, which avoids this problem.
 
1622
    """
 
1623
    chunk_size = 2**16
 
1624
    for pos in xrange(0, len(bytes), chunk_size):
 
1625
        until_no_eintr(socket.sendall, bytes[pos:pos+chunk_size])
 
1626
 
 
1627
 
 
1628
def dereference_path(path):
 
1629
    """Determine the real path to a file.
 
1630
 
 
1631
    All parent elements are dereferenced.  But the file itself is not
 
1632
    dereferenced.
 
1633
    :param path: The original path.  May be absolute or relative.
 
1634
    :return: the real path *to* the file
 
1635
    """
 
1636
    parent, base = os.path.split(path)
 
1637
    # The pathjoin for '.' is a workaround for Python bug #1213894.
 
1638
    # (initial path components aren't dereferenced)
 
1639
    return pathjoin(realpath(pathjoin('.', parent)), base)
 
1640
 
 
1641
 
 
1642
def supports_mapi():
 
1643
    """Return True if we can use MAPI to launch a mail client."""
 
1644
    return sys.platform == "win32"
 
1645
 
 
1646
 
 
1647
def resource_string(package, resource_name):
 
1648
    """Load a resource from a package and return it as a string.
 
1649
 
 
1650
    Note: Only packages that start with bzrlib are currently supported.
 
1651
 
 
1652
    This is designed to be a lightweight implementation of resource
 
1653
    loading in a way which is API compatible with the same API from
 
1654
    pkg_resources. See
 
1655
    http://peak.telecommunity.com/DevCenter/PkgResources#basic-resource-access.
 
1656
    If and when pkg_resources becomes a standard library, this routine
 
1657
    can delegate to it.
 
1658
    """
 
1659
    # Check package name is within bzrlib
 
1660
    if package == "bzrlib":
 
1661
        resource_relpath = resource_name
 
1662
    elif package.startswith("bzrlib."):
 
1663
        package = package[len("bzrlib."):].replace('.', os.sep)
 
1664
        resource_relpath = pathjoin(package, resource_name)
 
1665
    else:
 
1666
        raise errors.BzrError('resource package %s not in bzrlib' % package)
 
1667
 
 
1668
    # Map the resource to a file and read its contents
 
1669
    base = dirname(bzrlib.__file__)
 
1670
    if getattr(sys, 'frozen', None):    # bzr.exe
 
1671
        base = abspath(pathjoin(base, '..', '..'))
 
1672
    filename = pathjoin(base, resource_relpath)
 
1673
    return open(filename, 'rU').read()
 
1674
 
 
1675
 
 
1676
def file_kind_from_stat_mode_thunk(mode):
 
1677
    global file_kind_from_stat_mode
 
1678
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
 
1679
        try:
 
1680
            from bzrlib._readdir_pyx import UTF8DirReader
 
1681
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
 
1682
        except ImportError:
 
1683
            from bzrlib._readdir_py import (
 
1684
                _kind_from_mode as file_kind_from_stat_mode
 
1685
                )
 
1686
    return file_kind_from_stat_mode(mode)
 
1687
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
 
1688
 
 
1689
 
 
1690
def file_kind(f, _lstat=os.lstat):
 
1691
    try:
 
1692
        return file_kind_from_stat_mode(_lstat(f).st_mode)
 
1693
    except OSError, e:
 
1694
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
 
1695
            raise errors.NoSuchFile(f)
 
1696
        raise
 
1697
 
 
1698
 
 
1699
def until_no_eintr(f, *a, **kw):
 
1700
    """Run f(*a, **kw), retrying if an EINTR error occurs."""
 
1701
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
 
1702
    while True:
 
1703
        try:
 
1704
            return f(*a, **kw)
 
1705
        except (IOError, OSError), e:
 
1706
            if e.errno == errno.EINTR:
 
1707
                continue
 
1708
            raise
 
1709
 
 
1710
 
 
1711
if sys.platform == "win32":
 
1712
    import msvcrt
 
1713
    def getchar():
 
1714
        return msvcrt.getch()
 
1715
else:
 
1716
    import tty
 
1717
    import termios
 
1718
    def getchar():
 
1719
        fd = sys.stdin.fileno()
 
1720
        settings = termios.tcgetattr(fd)
 
1721
        try:
 
1722
            tty.setraw(fd)
 
1723
            ch = sys.stdin.read(1)
 
1724
        finally:
 
1725
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
 
1726
        return ch