~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: John Arbash Meinel
  • Date: 2006-07-21 04:02:14 UTC
  • mto: This revision was merged to the branch mainline in revision 1877.
  • Revision ID: john@arbash-meinel.com-20060721040214-9db86450785a5c3e
Make set_user_ignores a private function, and update the doc string to recommend it isn't used.

Show diffs side-by-side

added added

removed removed

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