/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from cStringIO import StringIO
18
17
import os
19
18
import re
20
19
import stat
21
 
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
22
 
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
23
21
import sys
24
22
import time
 
23
import codecs
25
24
 
26
25
from bzrlib.lazy_import import lazy_import
27
26
lazy_import(globals(), """
28
 
import codecs
29
27
from datetime import datetime
30
28
import errno
31
29
from ntpath import (abspath as _nt_abspath,
35
33
                    splitdrive as _nt_splitdrive,
36
34
                    )
37
35
import posixpath
38
 
import sha
39
36
import shutil
40
37
from shutil import (
41
38
    rmtree,
42
39
    )
 
40
import socket
 
41
import subprocess
43
42
import tempfile
44
43
from tempfile import (
45
44
    mkdtemp,
49
48
from bzrlib import (
50
49
    cache_utf8,
51
50
    errors,
 
51
    trace,
52
52
    win32utils,
53
53
    )
54
54
""")
55
55
 
56
 
import bzrlib
57
56
from bzrlib.symbol_versioning import (
58
57
    deprecated_function,
59
 
    zero_nine,
 
58
    deprecated_in,
60
59
    )
61
 
from bzrlib.trace import mutter
62
 
 
 
60
 
 
61
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
 
62
# of 2.5
 
63
if sys.version_info < (2, 5):
 
64
    import md5 as _mod_md5
 
65
    md5 = _mod_md5.new
 
66
    import sha as _mod_sha
 
67
    sha = _mod_sha.new
 
68
else:
 
69
    from hashlib import (
 
70
        md5,
 
71
        sha1 as sha,
 
72
        )
 
73
 
 
74
 
 
75
import bzrlib
 
76
from bzrlib import symbol_versioning
 
77
 
 
78
 
 
79
# Cross platform wall-clock time functionality with decent resolution.
 
80
# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``
 
81
# only has a resolution of ~15ms. Note that ``time.clock()`` is not
 
82
# synchronized with ``time.time()``, this is only meant to be used to find
 
83
# delta times by subtracting from another call to this function.
 
84
timer_func = time.time
 
85
if sys.platform == 'win32':
 
86
    timer_func = time.clock
63
87
 
64
88
# On win32, O_BINARY is used to indicate the file should
65
89
# be opened in binary mode, rather than text mode.
66
90
# On other platforms, O_BINARY doesn't exist, because
67
91
# they always open in binary mode, so it is okay to
68
 
# OR with 0 on those platforms
 
92
# OR with 0 on those platforms.
 
93
# O_NOINHERIT and O_TEXT exists only on win32 too.
69
94
O_BINARY = getattr(os, 'O_BINARY', 0)
 
95
O_TEXT = getattr(os, 'O_TEXT', 0)
 
96
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
 
97
 
 
98
 
 
99
def get_unicode_argv():
 
100
    try:
 
101
        user_encoding = get_user_encoding()
 
102
        return [a.decode(user_encoding) for a in sys.argv[1:]]
 
103
    except UnicodeDecodeError:
 
104
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
105
                                                            "encoding." % a))
70
106
 
71
107
 
72
108
def make_readonly(filename):
73
109
    """Make a filename read-only."""
74
 
    mod = os.stat(filename).st_mode
75
 
    mod = mod & 0777555
76
 
    os.chmod(filename, mod)
 
110
    mod = os.lstat(filename).st_mode
 
111
    if not stat.S_ISLNK(mod):
 
112
        mod = mod & 0777555
 
113
        os.chmod(filename, mod)
77
114
 
78
115
 
79
116
def make_writable(filename):
80
 
    mod = os.stat(filename).st_mode
81
 
    mod = mod | 0200
82
 
    os.chmod(filename, mod)
 
117
    mod = os.lstat(filename).st_mode
 
118
    if not stat.S_ISLNK(mod):
 
119
        mod = mod | 0200
 
120
        os.chmod(filename, mod)
 
121
 
 
122
 
 
123
def minimum_path_selection(paths):
 
124
    """Return the smallset subset of paths which are outside paths.
 
125
 
 
126
    :param paths: A container (and hence not None) of paths.
 
127
    :return: A set of paths sufficient to include everything in paths via
 
128
        is_inside, drawn from the paths parameter.
 
129
    """
 
130
    if len(paths) < 2:
 
131
        return set(paths)
 
132
 
 
133
    def sort_key(path):
 
134
        return path.split('/')
 
135
    sorted_paths = sorted(list(paths), key=sort_key)
 
136
 
 
137
    search_paths = [sorted_paths[0]]
 
138
    for path in sorted_paths[1:]:
 
139
        if not is_inside(search_paths[-1], path):
 
140
            # This path is unique, add it
 
141
            search_paths.append(path)
 
142
 
 
143
    return set(search_paths)
83
144
 
84
145
 
85
146
_QUOTE_RE = None
94
155
    global _QUOTE_RE
95
156
    if _QUOTE_RE is None:
96
157
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
97
 
        
 
158
 
98
159
    if _QUOTE_RE.search(f):
99
160
        return '"' + f + '"'
100
161
    else:
103
164
 
104
165
_directory_kind = 'directory'
105
166
 
106
 
_formats = {
107
 
    stat.S_IFDIR:_directory_kind,
108
 
    stat.S_IFCHR:'chardev',
109
 
    stat.S_IFBLK:'block',
110
 
    stat.S_IFREG:'file',
111
 
    stat.S_IFIFO:'fifo',
112
 
    stat.S_IFLNK:'symlink',
113
 
    stat.S_IFSOCK:'socket',
114
 
}
115
 
 
116
 
 
117
 
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
118
 
    """Generate a file kind from a stat mode. This is used in walkdirs.
119
 
 
120
 
    Its performance is critical: Do not mutate without careful benchmarking.
121
 
    """
122
 
    try:
123
 
        return _formats[stat_mode & 0170000]
124
 
    except KeyError:
125
 
        return _unknown
126
 
 
127
 
 
128
 
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
129
 
    try:
130
 
        return _mapper(_lstat(f).st_mode)
131
 
    except OSError, e:
132
 
        if getattr(e, 'errno', None) == errno.ENOENT:
133
 
            raise errors.NoSuchFile(f)
134
 
        raise
135
 
 
136
 
 
137
167
def get_umask():
138
168
    """Return the current umask"""
139
169
    # Assume that people aren't messing with the umask while running
144
174
    return umask
145
175
 
146
176
 
 
177
_kind_marker_map = {
 
178
    "file": "",
 
179
    _directory_kind: "/",
 
180
    "symlink": "@",
 
181
    'tree-reference': '+',
 
182
}
 
183
 
 
184
 
147
185
def kind_marker(kind):
148
 
    if kind == 'file':
 
186
    try:
 
187
        return _kind_marker_map[kind]
 
188
    except KeyError:
 
189
        # Slightly faster than using .get(, '') when the common case is that
 
190
        # kind will be found
149
191
        return ''
150
 
    elif kind == _directory_kind:
151
 
        return '/'
152
 
    elif kind == 'symlink':
153
 
        return '@'
154
 
    else:
155
 
        raise errors.BzrError('invalid file kind %r' % kind)
 
192
 
156
193
 
157
194
lexists = getattr(os.path, 'lexists', None)
158
195
if lexists is None:
159
196
    def lexists(f):
160
197
        try:
161
 
            if getattr(os, 'lstat') is not None:
162
 
                os.lstat(f)
163
 
            else:
164
 
                os.stat(f)
 
198
            stat = getattr(os, 'lstat', os.stat)
 
199
            stat(f)
165
200
            return True
166
 
        except OSError,e:
 
201
        except OSError, e:
167
202
            if e.errno == errno.ENOENT:
168
203
                return False;
169
204
            else:
172
207
 
173
208
def fancy_rename(old, new, rename_func, unlink_func):
174
209
    """A fancy rename, when you don't have atomic rename.
175
 
    
 
210
 
176
211
    :param old: The old path, to rename from
177
212
    :param new: The new path, to rename to
178
213
    :param rename_func: The potentially non-atomic rename function
179
 
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
214
    :param unlink_func: A way to delete the target file if the full rename
 
215
        succeeds
180
216
    """
181
 
 
182
217
    # sftp rename doesn't allow overwriting, so play tricks:
183
 
    import random
184
218
    base = os.path.basename(new)
185
219
    dirname = os.path.dirname(new)
186
 
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
 
220
    # callers use different encodings for the paths so the following MUST
 
221
    # respect that. We rely on python upcasting to unicode if new is unicode
 
222
    # and keeping a str if not.
 
223
    tmp_name = 'tmp.%s.%.9f.%d.%s' % (base, time.time(),
 
224
                                      os.getpid(), rand_chars(10))
187
225
    tmp_name = pathjoin(dirname, tmp_name)
188
226
 
189
227
    # Rename the file out of the way, but keep track if it didn't exist
209
247
    else:
210
248
        file_existed = True
211
249
 
 
250
    failure_exc = None
212
251
    success = False
213
252
    try:
214
 
        # This may throw an exception, in which case success will
215
 
        # not be set.
216
 
        rename_func(old, new)
217
 
        success = True
 
253
        try:
 
254
            # This may throw an exception, in which case success will
 
255
            # not be set.
 
256
            rename_func(old, new)
 
257
            success = True
 
258
        except (IOError, OSError), e:
 
259
            # source and target may be aliases of each other (e.g. on a
 
260
            # case-insensitive filesystem), so we may have accidentally renamed
 
261
            # source by when we tried to rename target
 
262
            failure_exc = sys.exc_info()
 
263
            if (file_existed and e.errno in (None, errno.ENOENT)
 
264
                and old.lower() == new.lower()):
 
265
                # source and target are the same file on a case-insensitive
 
266
                # filesystem, so we don't generate an exception
 
267
                failure_exc = None
218
268
    finally:
219
269
        if file_existed:
220
270
            # If the file used to exist, rename it back into place
223
273
                unlink_func(tmp_name)
224
274
            else:
225
275
                rename_func(tmp_name, new)
 
276
    if failure_exc is not None:
 
277
        raise failure_exc[0], failure_exc[1], failure_exc[2]
226
278
 
227
279
 
228
280
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
286
338
        path = cwd + '\\' + path
287
339
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
288
340
 
289
 
if win32utils.winver == 'Windows 98':
290
 
    _win32_abspath = _win98_abspath
291
 
 
292
341
 
293
342
def _win32_realpath(path):
294
343
    # Real _nt_realpath doesn't have a problem with a unicode cwd
311
360
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
312
361
 
313
362
 
 
363
def _add_rename_error_details(e, old, new):
 
364
    new_e = OSError(e.errno, "failed to rename %s to %s: %s"
 
365
        % (old, new, e.strerror))
 
366
    new_e.filename = old
 
367
    new_e.to_filename = new
 
368
    return new_e
 
369
 
 
370
 
314
371
def _win32_rename(old, new):
315
372
    """We expect to be able to atomically replace 'new' with old.
316
373
 
317
374
    On win32, if new exists, it must be moved out of the way first,
318
 
    and then deleted. 
 
375
    and then deleted.
319
376
    """
320
377
    try:
321
 
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
378
        fancy_rename(old, new, rename_func=_wrapped_rename, unlink_func=os.unlink)
322
379
    except OSError, e:
323
380
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
324
 
            # If we try to rename a non-existant file onto cwd, we get 
325
 
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT 
 
381
            # If we try to rename a non-existant file onto cwd, we get
 
382
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT
326
383
            # if the old path doesn't exist, sometimes we get EACCES
327
384
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
328
385
            os.lstat(old)
329
386
        raise
330
387
 
331
388
 
 
389
def _wrapped_rename(old, new):
 
390
    """Rename a file or directory"""
 
391
    try:
 
392
        os.rename(old, new)
 
393
    except (IOError, OSError), e:
 
394
        # this is eventually called by all rename-like functions, so should 
 
395
        # catch all of them
 
396
        raise _add_rename_error_details(e, old, new)
 
397
 
 
398
 
332
399
def _mac_getcwd():
333
 
    return unicodedata.normalize('NFKC', os.getcwdu())
 
400
    return unicodedata.normalize('NFC', os.getcwdu())
334
401
 
335
402
 
336
403
# Default is to just use the python builtins, but these can be rebound on
339
406
realpath = _posix_realpath
340
407
pathjoin = os.path.join
341
408
normpath = os.path.normpath
 
409
rename = _wrapped_rename # overridden below on win32
342
410
getcwd = os.getcwdu
343
 
rename = os.rename
344
411
dirname = os.path.dirname
345
412
basename = os.path.basename
346
413
split = os.path.split
353
420
 
354
421
 
355
422
if sys.platform == 'win32':
356
 
    abspath = _win32_abspath
 
423
    if win32utils.winver == 'Windows 98':
 
424
        abspath = _win98_abspath
 
425
    else:
 
426
        abspath = _win32_abspath
357
427
    realpath = _win32_realpath
358
428
    pathjoin = _win32_pathjoin
359
429
    normpath = _win32_normpath
379
449
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
380
450
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
381
451
        return shutil.rmtree(path, ignore_errors, onerror)
 
452
 
 
453
    f = win32utils.get_unicode_argv     # special function or None
 
454
    if f is not None:
 
455
        get_unicode_argv = f
 
456
 
382
457
elif sys.platform == 'darwin':
383
458
    getcwd = _mac_getcwd
384
459
 
388
463
 
389
464
    This attempts to check both sys.stdout and sys.stdin to see
390
465
    what encoding they are in, and if that fails it falls back to
391
 
    bzrlib.user_encoding.
 
466
    osutils.get_user_encoding().
392
467
    The problem is that on Windows, locale.getpreferredencoding()
393
468
    is not the same encoding as that used by the console:
394
469
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
396
471
    On my standard US Windows XP, the preferred encoding is
397
472
    cp1252, but the console is cp437
398
473
    """
 
474
    from bzrlib.trace import mutter
399
475
    output_encoding = getattr(sys.stdout, 'encoding', None)
400
476
    if not output_encoding:
401
477
        input_encoding = getattr(sys.stdin, 'encoding', None)
402
478
        if not input_encoding:
403
 
            output_encoding = bzrlib.user_encoding
404
 
            mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
 
479
            output_encoding = get_user_encoding()
 
480
            mutter('encoding stdout as osutils.get_user_encoding() %r',
 
481
                   output_encoding)
405
482
        else:
406
483
            output_encoding = input_encoding
407
484
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
409
486
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
410
487
    if output_encoding == 'cp0':
411
488
        # invalid encoding (cp0 means 'no codepage' on Windows)
412
 
        output_encoding = bzrlib.user_encoding
 
489
        output_encoding = get_user_encoding()
413
490
        mutter('cp0 is invalid encoding.'
414
 
               ' encoding stdout as bzrlib.user_encoding %r', output_encoding)
 
491
               ' encoding stdout as osutils.get_user_encoding() %r',
 
492
               output_encoding)
415
493
    # check encoding
416
494
    try:
417
495
        codecs.lookup(output_encoding)
419
497
        sys.stderr.write('bzr: warning:'
420
498
                         ' unknown terminal encoding %s.\n'
421
499
                         '  Using encoding %s instead.\n'
422
 
                         % (output_encoding, bzrlib.user_encoding)
 
500
                         % (output_encoding, get_user_encoding())
423
501
                        )
424
 
        output_encoding = bzrlib.user_encoding
 
502
        output_encoding = get_user_encoding()
425
503
 
426
504
    return output_encoding
427
505
 
438
516
        return pathjoin(F(p), e)
439
517
 
440
518
 
441
 
def backup_file(fn):
442
 
    """Copy a file to a backup.
443
 
 
444
 
    Backups are named in GNU-style, with a ~ suffix.
445
 
 
446
 
    If the file is already a backup, it's not copied.
447
 
    """
448
 
    if fn[-1] == '~':
449
 
        return
450
 
    bfn = fn + '~'
451
 
 
452
 
    if has_symlinks() and os.path.islink(fn):
453
 
        target = os.readlink(fn)
454
 
        os.symlink(target, bfn)
455
 
        return
456
 
    inf = file(fn, 'rb')
457
 
    try:
458
 
        content = inf.read()
459
 
    finally:
460
 
        inf.close()
461
 
    
462
 
    outf = file(bfn, 'wb')
463
 
    try:
464
 
        outf.write(content)
465
 
    finally:
466
 
        outf.close()
467
 
 
468
 
 
469
519
def isdir(f):
470
520
    """True if f is an accessible directory."""
471
521
    try:
490
540
 
491
541
def is_inside(dir, fname):
492
542
    """True if fname is inside dir.
493
 
    
 
543
 
494
544
    The parameters should typically be passed to osutils.normpath first, so
495
545
    that . and .. and repeated slashes are eliminated, and the separators
496
546
    are canonical for the platform.
497
 
    
498
 
    The empty string as a dir name is taken as top-of-tree and matches 
 
547
 
 
548
    The empty string as a dir name is taken as top-of-tree and matches
499
549
    everything.
500
550
    """
501
 
    # XXX: Most callers of this can actually do something smarter by 
 
551
    # XXX: Most callers of this can actually do something smarter by
502
552
    # looking at the inventory
503
553
    if dir == fname:
504
554
        return True
505
 
    
 
555
 
506
556
    if dir == '':
507
557
        return True
508
558
 
517
567
    for dirname in dir_list:
518
568
        if is_inside(dirname, fname):
519
569
            return True
520
 
    else:
521
 
        return False
 
570
    return False
522
571
 
523
572
 
524
573
def is_inside_or_parent_of_any(dir_list, fname):
526
575
    for dirname in dir_list:
527
576
        if is_inside(dirname, fname) or is_inside(fname, dirname):
528
577
            return True
 
578
    return False
 
579
 
 
580
 
 
581
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768,
 
582
             report_activity=None, direction='read'):
 
583
    """Copy contents of one file to another.
 
584
 
 
585
    The read_length can either be -1 to read to end-of-file (EOF) or
 
586
    it can specify the maximum number of bytes to read.
 
587
 
 
588
    The buff_size represents the maximum size for each read operation
 
589
    performed on from_file.
 
590
 
 
591
    :param report_activity: Call this as bytes are read, see
 
592
        Transport._report_activity
 
593
    :param direction: Will be passed to report_activity
 
594
 
 
595
    :return: The number of bytes copied.
 
596
    """
 
597
    length = 0
 
598
    if read_length >= 0:
 
599
        # read specified number of bytes
 
600
 
 
601
        while read_length > 0:
 
602
            num_bytes_to_read = min(read_length, buff_size)
 
603
 
 
604
            block = from_file.read(num_bytes_to_read)
 
605
            if not block:
 
606
                # EOF reached
 
607
                break
 
608
            if report_activity is not None:
 
609
                report_activity(len(block), direction)
 
610
            to_file.write(block)
 
611
 
 
612
            actual_bytes_read = len(block)
 
613
            read_length -= actual_bytes_read
 
614
            length += actual_bytes_read
529
615
    else:
530
 
        return False
531
 
 
532
 
 
533
 
def pumpfile(fromfile, tofile):
534
 
    """Copy contents of one file to another."""
535
 
    BUFSIZE = 32768
536
 
    while True:
537
 
        b = fromfile.read(BUFSIZE)
538
 
        if not b:
539
 
            break
540
 
        tofile.write(b)
 
616
        # read to EOF
 
617
        while True:
 
618
            block = from_file.read(buff_size)
 
619
            if not block:
 
620
                # EOF reached
 
621
                break
 
622
            if report_activity is not None:
 
623
                report_activity(len(block), direction)
 
624
            to_file.write(block)
 
625
            length += len(block)
 
626
    return length
 
627
 
 
628
 
 
629
def pump_string_file(bytes, file_handle, segment_size=None):
 
630
    """Write bytes to file_handle in many smaller writes.
 
631
 
 
632
    :param bytes: The string to write.
 
633
    :param file_handle: The file to write to.
 
634
    """
 
635
    # Write data in chunks rather than all at once, because very large
 
636
    # writes fail on some platforms (e.g. Windows with SMB  mounted
 
637
    # drives).
 
638
    if not segment_size:
 
639
        segment_size = 5242880 # 5MB
 
640
    segments = range(len(bytes) / segment_size + 1)
 
641
    write = file_handle.write
 
642
    for segment_index in segments:
 
643
        segment = buffer(bytes, segment_index * segment_size, segment_size)
 
644
        write(segment)
541
645
 
542
646
 
543
647
def file_iterator(input_file, readsize=32768):
549
653
 
550
654
 
551
655
def sha_file(f):
552
 
    if getattr(f, 'tell', None) is not None:
553
 
        assert f.tell() == 0
554
 
    s = sha.new()
 
656
    """Calculate the hexdigest of an open file.
 
657
 
 
658
    The file cursor should be already at the start.
 
659
    """
 
660
    s = sha()
555
661
    BUFSIZE = 128<<10
556
662
    while True:
557
663
        b = f.read(BUFSIZE)
561
667
    return s.hexdigest()
562
668
 
563
669
 
564
 
 
565
 
def sha_strings(strings):
 
670
def size_sha_file(f):
 
671
    """Calculate the size and hexdigest of an open file.
 
672
 
 
673
    The file cursor should be already at the start and
 
674
    the caller is responsible for closing the file afterwards.
 
675
    """
 
676
    size = 0
 
677
    s = sha()
 
678
    BUFSIZE = 128<<10
 
679
    while True:
 
680
        b = f.read(BUFSIZE)
 
681
        if not b:
 
682
            break
 
683
        size += len(b)
 
684
        s.update(b)
 
685
    return size, s.hexdigest()
 
686
 
 
687
 
 
688
def sha_file_by_name(fname):
 
689
    """Calculate the SHA1 of a file by reading the full text"""
 
690
    s = sha()
 
691
    f = os.open(fname, os.O_RDONLY | O_BINARY | O_NOINHERIT)
 
692
    try:
 
693
        while True:
 
694
            b = os.read(f, 1<<16)
 
695
            if not b:
 
696
                return s.hexdigest()
 
697
            s.update(b)
 
698
    finally:
 
699
        os.close(f)
 
700
 
 
701
 
 
702
def sha_strings(strings, _factory=sha):
566
703
    """Return the sha-1 of concatenation of strings"""
567
 
    s = sha.new()
 
704
    s = _factory()
568
705
    map(s.update, strings)
569
706
    return s.hexdigest()
570
707
 
571
708
 
572
 
def sha_string(f):
573
 
    s = sha.new()
574
 
    s.update(f)
575
 
    return s.hexdigest()
 
709
def sha_string(f, _factory=sha):
 
710
    return _factory(f).hexdigest()
576
711
 
577
712
 
578
713
def fingerprint_file(f):
579
 
    s = sha.new()
580
714
    b = f.read()
581
 
    s.update(b)
582
 
    size = len(b)
583
 
    return {'size': size,
584
 
            'sha1': s.hexdigest()}
 
715
    return {'size': len(b),
 
716
            'sha1': sha(b).hexdigest()}
585
717
 
586
718
 
587
719
def compare_files(a, b):
603
735
    offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
604
736
    return offset.days * 86400 + offset.seconds
605
737
 
606
 
    
607
 
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
738
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
 
739
_default_format_by_weekday_num = [wd + " %Y-%m-%d %H:%M:%S" for wd in weekdays]
 
740
 
 
741
 
 
742
def format_date(t, offset=0, timezone='original', date_fmt=None,
608
743
                show_offset=True):
609
 
    ## TODO: Perhaps a global option to use either universal or local time?
610
 
    ## Or perhaps just let people set $TZ?
611
 
    assert isinstance(t, float)
612
 
    
 
744
    """Return a formatted date string.
 
745
 
 
746
    :param t: Seconds since the epoch.
 
747
    :param offset: Timezone offset in seconds east of utc.
 
748
    :param timezone: How to display the time: 'utc', 'original' for the
 
749
         timezone specified by offset, or 'local' for the process's current
 
750
         timezone.
 
751
    :param date_fmt: strftime format.
 
752
    :param show_offset: Whether to append the timezone.
 
753
    """
 
754
    (date_fmt, tt, offset_str) = \
 
755
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
756
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
 
757
    date_str = time.strftime(date_fmt, tt)
 
758
    return date_str + offset_str
 
759
 
 
760
 
 
761
# Cache of formatted offset strings
 
762
_offset_cache = {}
 
763
 
 
764
 
 
765
def format_date_with_offset_in_original_timezone(t, offset=0,
 
766
    _cache=_offset_cache):
 
767
    """Return a formatted date string in the original timezone.
 
768
 
 
769
    This routine may be faster then format_date.
 
770
 
 
771
    :param t: Seconds since the epoch.
 
772
    :param offset: Timezone offset in seconds east of utc.
 
773
    """
 
774
    if offset is None:
 
775
        offset = 0
 
776
    tt = time.gmtime(t + offset)
 
777
    date_fmt = _default_format_by_weekday_num[tt[6]]
 
778
    date_str = time.strftime(date_fmt, tt)
 
779
    offset_str = _cache.get(offset, None)
 
780
    if offset_str is None:
 
781
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
782
        _cache[offset] = offset_str
 
783
    return date_str + offset_str
 
784
 
 
785
 
 
786
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
 
787
                      show_offset=True):
 
788
    """Return an unicode date string formatted according to the current locale.
 
789
 
 
790
    :param t: Seconds since the epoch.
 
791
    :param offset: Timezone offset in seconds east of utc.
 
792
    :param timezone: How to display the time: 'utc', 'original' for the
 
793
         timezone specified by offset, or 'local' for the process's current
 
794
         timezone.
 
795
    :param date_fmt: strftime format.
 
796
    :param show_offset: Whether to append the timezone.
 
797
    """
 
798
    (date_fmt, tt, offset_str) = \
 
799
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
800
    date_str = time.strftime(date_fmt, tt)
 
801
    if not isinstance(date_str, unicode):
 
802
        date_str = date_str.decode(get_user_encoding(), 'replace')
 
803
    return date_str + offset_str
 
804
 
 
805
 
 
806
def _format_date(t, offset, timezone, date_fmt, show_offset):
613
807
    if timezone == 'utc':
614
808
        tt = time.gmtime(t)
615
809
        offset = 0
621
815
        tt = time.localtime(t)
622
816
        offset = local_time_offset(t)
623
817
    else:
624
 
        raise errors.BzrError("unsupported timezone format %r" % timezone,
625
 
                              ['options are "utc", "original", "local"'])
 
818
        raise errors.UnsupportedTimezoneFormat(timezone)
626
819
    if date_fmt is None:
627
820
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
628
821
    if show_offset:
629
822
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
630
823
    else:
631
824
        offset_str = ''
632
 
    return (time.strftime(date_fmt, tt) +  offset_str)
 
825
    return (date_fmt, tt, offset_str)
633
826
 
634
827
 
635
828
def compact_date(when):
636
829
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
637
 
    
 
830
 
638
831
 
639
832
def format_delta(delta):
640
833
    """Get a nice looking string for a time delta.
716
909
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
717
910
def rand_chars(num):
718
911
    """Return a random string of num alphanumeric characters
719
 
    
720
 
    The result only contains lowercase chars because it may be used on 
 
912
 
 
913
    The result only contains lowercase chars because it may be used on
721
914
    case-insensitive filesystems.
722
915
    """
723
916
    s = ''
731
924
 
732
925
def splitpath(p):
733
926
    """Turn string into list of parts."""
734
 
    assert isinstance(p, basestring)
735
 
 
736
927
    # split on either delimiter because people might use either on
737
928
    # Windows
738
929
    ps = re.split(r'[\\/]', p)
747
938
            rps.append(f)
748
939
    return rps
749
940
 
 
941
 
750
942
def joinpath(p):
751
 
    assert isinstance(p, list)
752
943
    for f in p:
753
944
        if (f == '..') or (f is None) or (f == ''):
754
945
            raise errors.BzrError("sorry, %r not allowed in path" % f)
755
946
    return pathjoin(*p)
756
947
 
757
948
 
758
 
@deprecated_function(zero_nine)
759
 
def appendpath(p1, p2):
760
 
    if p1 == '':
761
 
        return p2
762
 
    else:
763
 
        return pathjoin(p1, p2)
764
 
    
 
949
def parent_directories(filename):
 
950
    """Return the list of parent directories, deepest first.
 
951
    
 
952
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
 
953
    """
 
954
    parents = []
 
955
    parts = splitpath(dirname(filename))
 
956
    while parts:
 
957
        parents.append(joinpath(parts))
 
958
        parts.pop()
 
959
    return parents
 
960
 
 
961
 
 
962
_extension_load_failures = []
 
963
 
 
964
 
 
965
def failed_to_load_extension(exception):
 
966
    """Handle failing to load a binary extension.
 
967
 
 
968
    This should be called from the ImportError block guarding the attempt to
 
969
    import the native extension.  If this function returns, the pure-Python
 
970
    implementation should be loaded instead::
 
971
 
 
972
    >>> try:
 
973
    >>>     import bzrlib._fictional_extension_pyx
 
974
    >>> except ImportError, e:
 
975
    >>>     bzrlib.osutils.failed_to_load_extension(e)
 
976
    >>>     import bzrlib._fictional_extension_py
 
977
    """
 
978
    # NB: This docstring is just an example, not a doctest, because doctest
 
979
    # currently can't cope with the use of lazy imports in this namespace --
 
980
    # mbp 20090729
 
981
    
 
982
    # This currently doesn't report the failure at the time it occurs, because
 
983
    # they tend to happen very early in startup when we can't check config
 
984
    # files etc, and also we want to report all failures but not spam the user
 
985
    # with 10 warnings.
 
986
    from bzrlib import trace
 
987
    exception_str = str(exception)
 
988
    if exception_str not in _extension_load_failures:
 
989
        trace.mutter("failed to load compiled extension: %s" % exception_str)
 
990
        _extension_load_failures.append(exception_str)
 
991
 
 
992
 
 
993
def report_extension_load_failures():
 
994
    if not _extension_load_failures:
 
995
        return
 
996
    from bzrlib.config import GlobalConfig
 
997
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
 
998
        return
 
999
    # the warnings framework should by default show this only once
 
1000
    from bzrlib.trace import warning
 
1001
    warning(
 
1002
        "bzr: warning: some compiled extensions could not be loaded; "
 
1003
        "see <https://answers.launchpad.net/bzr/+faq/703>")
 
1004
    # we no longer show the specific missing extensions here, because it makes
 
1005
    # the message too long and scary - see
 
1006
    # https://bugs.launchpad.net/bzr/+bug/430529
 
1007
 
 
1008
 
 
1009
try:
 
1010
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
 
1011
except ImportError, e:
 
1012
    failed_to_load_extension(e)
 
1013
    from bzrlib._chunks_to_lines_py import chunks_to_lines
 
1014
 
765
1015
 
766
1016
def split_lines(s):
767
1017
    """Split s into lines, but without removing the newline characters."""
 
1018
    # Trivially convert a fulltext into a 'chunked' representation, and let
 
1019
    # chunks_to_lines do the heavy lifting.
 
1020
    if isinstance(s, str):
 
1021
        # chunks_to_lines only supports 8-bit strings
 
1022
        return chunks_to_lines([s])
 
1023
    else:
 
1024
        return _split_lines(s)
 
1025
 
 
1026
 
 
1027
def _split_lines(s):
 
1028
    """Split s into lines, but without removing the newline characters.
 
1029
 
 
1030
    This supports Unicode or plain string objects.
 
1031
    """
768
1032
    lines = s.split('\n')
769
1033
    result = [line + '\n' for line in lines[:-1]]
770
1034
    if lines[-1]:
788
1052
            raise
789
1053
        shutil.copyfile(src, dest)
790
1054
 
791
 
def delete_any(full_path):
792
 
    """Delete a file or directory."""
 
1055
 
 
1056
def delete_any(path):
 
1057
    """Delete a file, symlink or directory.  
 
1058
    
 
1059
    Will delete even if readonly.
 
1060
    """
793
1061
    try:
794
 
        os.unlink(full_path)
795
 
    except OSError, e:
796
 
    # We may be renaming a dangling inventory id
797
 
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
 
1062
       _delete_file_or_dir(path)
 
1063
    except (OSError, IOError), e:
 
1064
        if e.errno in (errno.EPERM, errno.EACCES):
 
1065
            # make writable and try again
 
1066
            try:
 
1067
                make_writable(path)
 
1068
            except (OSError, IOError):
 
1069
                pass
 
1070
            _delete_file_or_dir(path)
 
1071
        else:
798
1072
            raise
799
 
        os.rmdir(full_path)
 
1073
 
 
1074
 
 
1075
def _delete_file_or_dir(path):
 
1076
    # Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
 
1077
    # Forgiveness than Permission (EAFP) because:
 
1078
    # - root can damage a solaris file system by using unlink,
 
1079
    # - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
 
1080
    #   EACCES, OSX: EPERM) when invoked on a directory.
 
1081
    if isdir(path): # Takes care of symlinks
 
1082
        os.rmdir(path)
 
1083
    else:
 
1084
        os.unlink(path)
800
1085
 
801
1086
 
802
1087
def has_symlinks():
804
1089
        return True
805
1090
    else:
806
1091
        return False
807
 
        
 
1092
 
 
1093
 
 
1094
def has_hardlinks():
 
1095
    if getattr(os, 'link', None) is not None:
 
1096
        return True
 
1097
    else:
 
1098
        return False
 
1099
 
 
1100
 
 
1101
def host_os_dereferences_symlinks():
 
1102
    return (has_symlinks()
 
1103
            and sys.platform not in ('cygwin', 'win32'))
 
1104
 
 
1105
 
 
1106
def readlink(abspath):
 
1107
    """Return a string representing the path to which the symbolic link points.
 
1108
 
 
1109
    :param abspath: The link absolute unicode path.
 
1110
 
 
1111
    This his guaranteed to return the symbolic link in unicode in all python
 
1112
    versions.
 
1113
    """
 
1114
    link = abspath.encode(_fs_enc)
 
1115
    target = os.readlink(link)
 
1116
    target = target.decode(_fs_enc)
 
1117
    return target
 
1118
 
808
1119
 
809
1120
def contains_whitespace(s):
810
1121
    """True if there are any whitespace characters in s."""
836
1147
 
837
1148
 
838
1149
def relpath(base, path):
839
 
    """Return path relative to base, or raise exception.
 
1150
    """Return path relative to base, or raise PathNotChild exception.
840
1151
 
841
1152
    The path may be either an absolute path or a path relative to the
842
1153
    current working directory.
844
1155
    os.path.commonprefix (python2.4) has a bad bug that it works just
845
1156
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
846
1157
    avoids that problem.
 
1158
 
 
1159
    NOTE: `base` should not have a trailing slash otherwise you'll get
 
1160
    PathNotChild exceptions regardless of `path`.
847
1161
    """
848
1162
 
849
 
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
850
 
        ' exceed the platform minimum length (which is %d)' % 
851
 
        MIN_ABS_PATHLENGTH)
 
1163
    if len(base) < MIN_ABS_PATHLENGTH:
 
1164
        # must have space for e.g. a drive letter
 
1165
        raise ValueError('%r is too short to calculate a relative path'
 
1166
            % (base,))
852
1167
 
853
1168
    rp = abspath(path)
854
1169
 
855
1170
    s = []
856
1171
    head = rp
857
 
    while len(head) >= len(base):
 
1172
    while True:
 
1173
        if len(head) <= len(base) and head != base:
 
1174
            raise errors.PathNotChild(rp, base)
858
1175
        if head == base:
859
1176
            break
860
 
        head, tail = os.path.split(head)
 
1177
        head, tail = split(head)
861
1178
        if tail:
862
 
            s.insert(0, tail)
863
 
    else:
864
 
        raise errors.PathNotChild(rp, base)
 
1179
            s.append(tail)
865
1180
 
866
1181
    if s:
867
 
        return pathjoin(*s)
 
1182
        return pathjoin(*reversed(s))
868
1183
    else:
869
1184
        return ''
870
1185
 
871
1186
 
 
1187
def _cicp_canonical_relpath(base, path):
 
1188
    """Return the canonical path relative to base.
 
1189
 
 
1190
    Like relpath, but on case-insensitive-case-preserving file-systems, this
 
1191
    will return the relpath as stored on the file-system rather than in the
 
1192
    case specified in the input string, for all existing portions of the path.
 
1193
 
 
1194
    This will cause O(N) behaviour if called for every path in a tree; if you
 
1195
    have a number of paths to convert, you should use canonical_relpaths().
 
1196
    """
 
1197
    # TODO: it should be possible to optimize this for Windows by using the
 
1198
    # win32 API FindFiles function to look for the specified name - but using
 
1199
    # os.listdir() still gives us the correct, platform agnostic semantics in
 
1200
    # the short term.
 
1201
 
 
1202
    rel = relpath(base, path)
 
1203
    # '.' will have been turned into ''
 
1204
    if not rel:
 
1205
        return rel
 
1206
 
 
1207
    abs_base = abspath(base)
 
1208
    current = abs_base
 
1209
    _listdir = os.listdir
 
1210
 
 
1211
    # use an explicit iterator so we can easily consume the rest on early exit.
 
1212
    bit_iter = iter(rel.split('/'))
 
1213
    for bit in bit_iter:
 
1214
        lbit = bit.lower()
 
1215
        try:
 
1216
            next_entries = _listdir(current)
 
1217
        except OSError: # enoent, eperm, etc
 
1218
            # We can't find this in the filesystem, so just append the
 
1219
            # remaining bits.
 
1220
            current = pathjoin(current, bit, *list(bit_iter))
 
1221
            break
 
1222
        for look in next_entries:
 
1223
            if lbit == look.lower():
 
1224
                current = pathjoin(current, look)
 
1225
                break
 
1226
        else:
 
1227
            # got to the end, nothing matched, so we just return the
 
1228
            # non-existing bits as they were specified (the filename may be
 
1229
            # the target of a move, for example).
 
1230
            current = pathjoin(current, bit, *list(bit_iter))
 
1231
            break
 
1232
    return current[len(abs_base):].lstrip('/')
 
1233
 
 
1234
# XXX - TODO - we need better detection/integration of case-insensitive
 
1235
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
 
1236
# filesystems), for example, so could probably benefit from the same basic
 
1237
# support there.  For now though, only Windows and OSX get that support, and
 
1238
# they get it for *all* file-systems!
 
1239
if sys.platform in ('win32', 'darwin'):
 
1240
    canonical_relpath = _cicp_canonical_relpath
 
1241
else:
 
1242
    canonical_relpath = relpath
 
1243
 
 
1244
def canonical_relpaths(base, paths):
 
1245
    """Create an iterable to canonicalize a sequence of relative paths.
 
1246
 
 
1247
    The intent is for this implementation to use a cache, vastly speeding
 
1248
    up multiple transformations in the same directory.
 
1249
    """
 
1250
    # but for now, we haven't optimized...
 
1251
    return [canonical_relpath(base, p) for p in paths]
 
1252
 
872
1253
def safe_unicode(unicode_or_utf8_string):
873
1254
    """Coerce unicode_or_utf8_string into unicode.
874
1255
 
875
1256
    If it is unicode, it is returned.
876
 
    Otherwise it is decoded from utf-8. If a decoding error
877
 
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
878
 
    as a BzrBadParameter exception.
 
1257
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
 
1258
    wrapped in a BzrBadParameterNotUnicode exception.
879
1259
    """
880
1260
    if isinstance(unicode_or_utf8_string, unicode):
881
1261
        return unicode_or_utf8_string
904
1284
    return unicode_or_utf8_string.encode('utf-8')
905
1285
 
906
1286
 
907
 
def safe_revision_id(unicode_or_utf8_string):
 
1287
_revision_id_warning = ('Unicode revision ids were deprecated in bzr 0.15.'
 
1288
                        ' Revision id generators should be creating utf8'
 
1289
                        ' revision ids.')
 
1290
 
 
1291
 
 
1292
def safe_revision_id(unicode_or_utf8_string, warn=True):
908
1293
    """Revision ids should now be utf8, but at one point they were unicode.
909
1294
 
 
1295
    :param unicode_or_utf8_string: A possibly Unicode revision_id. (can also be
 
1296
        utf8 or None).
 
1297
    :param warn: Functions that are sanitizing user data can set warn=False
 
1298
    :return: None or a utf8 revision id.
 
1299
    """
 
1300
    if (unicode_or_utf8_string is None
 
1301
        or unicode_or_utf8_string.__class__ == str):
 
1302
        return unicode_or_utf8_string
 
1303
    if warn:
 
1304
        symbol_versioning.warn(_revision_id_warning, DeprecationWarning,
 
1305
                               stacklevel=2)
 
1306
    return cache_utf8.encode(unicode_or_utf8_string)
 
1307
 
 
1308
 
 
1309
_file_id_warning = ('Unicode file ids were deprecated in bzr 0.15. File id'
 
1310
                    ' generators should be creating utf8 file ids.')
 
1311
 
 
1312
 
 
1313
def safe_file_id(unicode_or_utf8_string, warn=True):
 
1314
    """File ids should now be utf8, but at one point they were unicode.
 
1315
 
910
1316
    This is the same as safe_utf8, except it uses the cached encode functions
911
1317
    to save a little bit of performance.
 
1318
 
 
1319
    :param unicode_or_utf8_string: A possibly Unicode file_id. (can also be
 
1320
        utf8 or None).
 
1321
    :param warn: Functions that are sanitizing user data can set warn=False
 
1322
    :return: None or a utf8 file id.
912
1323
    """
913
 
    if unicode_or_utf8_string is None:
914
 
        return None
915
 
    if isinstance(unicode_or_utf8_string, str):
916
 
        # TODO: jam 20070209 Eventually just remove this check.
917
 
        try:
918
 
            utf8_str = cache_utf8.get_cached_utf8(unicode_or_utf8_string)
919
 
        except UnicodeDecodeError:
920
 
            raise errors.BzrBadParameterNotUnicode(unicode_or_utf8_string)
921
 
        return utf8_str
 
1324
    if (unicode_or_utf8_string is None
 
1325
        or unicode_or_utf8_string.__class__ == str):
 
1326
        return unicode_or_utf8_string
 
1327
    if warn:
 
1328
        symbol_versioning.warn(_file_id_warning, DeprecationWarning,
 
1329
                               stacklevel=2)
922
1330
    return cache_utf8.encode(unicode_or_utf8_string)
923
1331
 
924
1332
 
925
 
# TODO: jam 20070217 We start by just re-using safe_revision_id, but ultimately
926
 
#       we want to use a different dictionary cache, because trapping file ids
927
 
#       and revision ids in the same dict seemed to have a noticable effect on
928
 
#       performance.
929
 
safe_file_id = safe_revision_id
930
 
 
931
 
 
932
1333
_platform_normalizes_filenames = False
933
1334
if sys.platform == 'darwin':
934
1335
    _platform_normalizes_filenames = True
947
1348
 
948
1349
    On platforms where the system normalizes filenames (Mac OSX),
949
1350
    you can access a file by any path which will normalize correctly.
950
 
    On platforms where the system does not normalize filenames 
 
1351
    On platforms where the system does not normalize filenames
951
1352
    (Windows, Linux), you have to access a file by its exact path.
952
1353
 
953
 
    Internally, bzr only supports NFC/NFKC normalization, since that is 
 
1354
    Internally, bzr only supports NFC normalization, since that is
954
1355
    the standard for XML documents.
955
1356
 
956
1357
    So return the normalized path, and a flag indicating if the file
957
1358
    can be accessed by that path.
958
1359
    """
959
1360
 
960
 
    return unicodedata.normalize('NFKC', unicode(path)), True
 
1361
    return unicodedata.normalize('NFC', unicode(path)), True
961
1362
 
962
1363
 
963
1364
def _inaccessible_normalized_filename(path):
964
1365
    __doc__ = _accessible_normalized_filename.__doc__
965
1366
 
966
 
    normalized = unicodedata.normalize('NFKC', unicode(path))
 
1367
    normalized = unicodedata.normalize('NFC', unicode(path))
967
1368
    return normalized, normalized == path
968
1369
 
969
1370
 
973
1374
    normalized_filename = _inaccessible_normalized_filename
974
1375
 
975
1376
 
 
1377
def set_signal_handler(signum, handler, restart_syscall=True):
 
1378
    """A wrapper for signal.signal that also calls siginterrupt(signum, False)
 
1379
    on platforms that support that.
 
1380
 
 
1381
    :param restart_syscall: if set, allow syscalls interrupted by a signal to
 
1382
        automatically restart (by calling `signal.siginterrupt(signum,
 
1383
        False)`).  May be ignored if the feature is not available on this
 
1384
        platform or Python version.
 
1385
    """
 
1386
    try:
 
1387
        import signal
 
1388
        siginterrupt = signal.siginterrupt
 
1389
    except ImportError:
 
1390
        # This python implementation doesn't provide signal support, hence no
 
1391
        # handler exists
 
1392
        return None
 
1393
    except AttributeError:
 
1394
        # siginterrupt doesn't exist on this platform, or for this version
 
1395
        # of Python.
 
1396
        siginterrupt = lambda signum, flag: None
 
1397
    if restart_syscall:
 
1398
        def sig_handler(*args):
 
1399
            # Python resets the siginterrupt flag when a signal is
 
1400
            # received.  <http://bugs.python.org/issue8354>
 
1401
            # As a workaround for some cases, set it back the way we want it.
 
1402
            siginterrupt(signum, False)
 
1403
            # Now run the handler function passed to set_signal_handler.
 
1404
            handler(*args)
 
1405
    else:
 
1406
        sig_handler = handler
 
1407
    old_handler = signal.signal(signum, sig_handler)
 
1408
    if restart_syscall:
 
1409
        siginterrupt(signum, False)
 
1410
    return old_handler
 
1411
 
 
1412
 
 
1413
default_terminal_width = 80
 
1414
"""The default terminal width for ttys.
 
1415
 
 
1416
This is defined so that higher levels can share a common fallback value when
 
1417
terminal_width() returns None.
 
1418
"""
 
1419
 
 
1420
 
976
1421
def terminal_width():
977
 
    """Return estimated terminal width."""
978
 
    if sys.platform == 'win32':
979
 
        return win32utils.get_console_size()[0]
980
 
    width = 0
 
1422
    """Return terminal width.
 
1423
 
 
1424
    None is returned if the width can't established precisely.
 
1425
 
 
1426
    The rules are:
 
1427
    - if BZR_COLUMNS is set, returns its value
 
1428
    - if there is no controlling terminal, returns None
 
1429
    - if COLUMNS is set, returns its value,
 
1430
 
 
1431
    From there, we need to query the OS to get the size of the controlling
 
1432
    terminal.
 
1433
 
 
1434
    Unices:
 
1435
    - get termios.TIOCGWINSZ
 
1436
    - if an error occurs or a negative value is obtained, returns None
 
1437
 
 
1438
    Windows:
 
1439
    
 
1440
    - win32utils.get_console_size() decides,
 
1441
    - returns None on error (provided default value)
 
1442
    """
 
1443
 
 
1444
    # If BZR_COLUMNS is set, take it, user is always right
 
1445
    try:
 
1446
        return int(os.environ['BZR_COLUMNS'])
 
1447
    except (KeyError, ValueError):
 
1448
        pass
 
1449
 
 
1450
    isatty = getattr(sys.stdout, 'isatty', None)
 
1451
    if  isatty is None or not isatty():
 
1452
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
 
1453
        return None
 
1454
 
 
1455
    # If COLUMNS is set, take it, the terminal knows better (even inside a
 
1456
    # given terminal, the application can decide to set COLUMNS to a lower
 
1457
    # value (splitted screen) or a bigger value (scroll bars))
 
1458
    try:
 
1459
        return int(os.environ['COLUMNS'])
 
1460
    except (KeyError, ValueError):
 
1461
        pass
 
1462
 
 
1463
    width, height = _terminal_size(None, None)
 
1464
    if width <= 0:
 
1465
        # Consider invalid values as meaning no width
 
1466
        return None
 
1467
 
 
1468
    return width
 
1469
 
 
1470
 
 
1471
def _win32_terminal_size(width, height):
 
1472
    width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
 
1473
    return width, height
 
1474
 
 
1475
 
 
1476
def _ioctl_terminal_size(width, height):
981
1477
    try:
982
1478
        import struct, fcntl, termios
983
1479
        s = struct.pack('HHHH', 0, 0, 0, 0)
984
1480
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
985
 
        width = struct.unpack('HHHH', x)[1]
986
 
    except IOError:
 
1481
        height, width = struct.unpack('HHHH', x)[0:2]
 
1482
    except (IOError, AttributeError):
987
1483
        pass
988
 
    if width <= 0:
 
1484
    return width, height
 
1485
 
 
1486
_terminal_size = None
 
1487
"""Returns the terminal size as (width, height).
 
1488
 
 
1489
:param width: Default value for width.
 
1490
:param height: Default value for height.
 
1491
 
 
1492
This is defined specifically for each OS and query the size of the controlling
 
1493
terminal. If any error occurs, the provided default values should be returned.
 
1494
"""
 
1495
if sys.platform == 'win32':
 
1496
    _terminal_size = _win32_terminal_size
 
1497
else:
 
1498
    _terminal_size = _ioctl_terminal_size
 
1499
 
 
1500
 
 
1501
def _terminal_size_changed(signum, frame):
 
1502
    """Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
 
1503
    width, height = _terminal_size(None, None)
 
1504
    if width is not None:
 
1505
        os.environ['COLUMNS'] = str(width)
 
1506
 
 
1507
 
 
1508
_registered_sigwinch = False
 
1509
def watch_sigwinch():
 
1510
    """Register for SIGWINCH, once and only once.
 
1511
 
 
1512
    Do nothing if the signal module is not available.
 
1513
    """
 
1514
    global _registered_sigwinch
 
1515
    if not _registered_sigwinch:
989
1516
        try:
990
 
            width = int(os.environ['COLUMNS'])
991
 
        except:
 
1517
            import signal
 
1518
            if getattr(signal, "SIGWINCH", None) is not None:
 
1519
                set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
 
1520
        except ImportError:
 
1521
            # python doesn't provide signal support, nothing we can do about it
992
1522
            pass
993
 
    if width <= 0:
994
 
        width = 80
995
 
 
996
 
    return width
 
1523
        _registered_sigwinch = True
997
1524
 
998
1525
 
999
1526
def supports_executable():
1027
1554
            del os.environ[env_variable]
1028
1555
    else:
1029
1556
        if isinstance(value, unicode):
1030
 
            value = value.encode(bzrlib.user_encoding)
 
1557
            value = value.encode(get_user_encoding())
1031
1558
        os.environ[env_variable] = value
1032
1559
    return orig_val
1033
1560
 
1036
1563
 
1037
1564
 
1038
1565
def check_legal_path(path):
1039
 
    """Check whether the supplied path is legal.  
 
1566
    """Check whether the supplied path is legal.
1040
1567
    This is only required on Windows, so we don't test on other platforms
1041
1568
    right now.
1042
1569
    """
1046
1573
        raise errors.IllegalPath(path)
1047
1574
 
1048
1575
 
 
1576
_WIN32_ERROR_DIRECTORY = 267 # Similar to errno.ENOTDIR
 
1577
 
 
1578
def _is_error_enotdir(e):
 
1579
    """Check if this exception represents ENOTDIR.
 
1580
 
 
1581
    Unfortunately, python is very inconsistent about the exception
 
1582
    here. The cases are:
 
1583
      1) Linux, Mac OSX all versions seem to set errno == ENOTDIR
 
1584
      2) Windows, Python2.4, uses errno == ERROR_DIRECTORY (267)
 
1585
         which is the windows error code.
 
1586
      3) Windows, Python2.5 uses errno == EINVAL and
 
1587
         winerror == ERROR_DIRECTORY
 
1588
 
 
1589
    :param e: An Exception object (expected to be OSError with an errno
 
1590
        attribute, but we should be able to cope with anything)
 
1591
    :return: True if this represents an ENOTDIR error. False otherwise.
 
1592
    """
 
1593
    en = getattr(e, 'errno', None)
 
1594
    if (en == errno.ENOTDIR
 
1595
        or (sys.platform == 'win32'
 
1596
            and (en == _WIN32_ERROR_DIRECTORY
 
1597
                 or (en == errno.EINVAL
 
1598
                     and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
 
1599
        ))):
 
1600
        return True
 
1601
    return False
 
1602
 
 
1603
 
1049
1604
def walkdirs(top, prefix=""):
1050
1605
    """Yield data about all the directories in a tree.
1051
 
    
 
1606
 
1052
1607
    This yields all the data about the contents of a directory at a time.
1053
1608
    After each directory has been yielded, if the caller has mutated the list
1054
1609
    to exclude some directories, they are then not descended into.
1055
 
    
 
1610
 
1056
1611
    The data yielded is of the form:
1057
1612
    ((directory-relpath, directory-path-from-top),
1058
 
    [(relpath, basename, kind, lstat), ...]),
 
1613
    [(relpath, basename, kind, lstat, path-from-top), ...]),
1059
1614
     - directory-relpath is the relative path of the directory being returned
1060
1615
       with respect to top. prefix is prepended to this.
1061
 
     - directory-path-from-root is the path including top for this directory. 
 
1616
     - directory-path-from-root is the path including top for this directory.
1062
1617
       It is suitable for use with os functions.
1063
1618
     - relpath is the relative path within the subtree being walked.
1064
1619
     - basename is the basename of the path
1066
1621
       present within the tree - but it may be recorded as versioned. See
1067
1622
       versioned_kind.
1068
1623
     - lstat is the stat data *if* the file was statted.
1069
 
     - planned, not implemented: 
 
1624
     - planned, not implemented:
1070
1625
       path_from_tree_root is the path from the root of the tree.
1071
1626
 
1072
 
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
 
1627
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This
1073
1628
        allows one to walk a subtree but get paths that are relative to a tree
1074
1629
        rooted higher up.
1075
1630
    :return: an iterator over the dirs.
1076
1631
    """
1077
1632
    #TODO there is a bit of a smell where the results of the directory-
1078
 
    # summary in this, and the path from the root, may not agree 
 
1633
    # summary in this, and the path from the root, may not agree
1079
1634
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
1080
1635
    # potentially confusing output. We should make this more robust - but
1081
1636
    # not at a speed cost. RBC 20060731
1082
 
    lstat = os.lstat
1083
 
    pending = []
 
1637
    _lstat = os.lstat
1084
1638
    _directory = _directory_kind
1085
1639
    _listdir = os.listdir
1086
 
    pending = [(prefix, "", _directory, None, top)]
 
1640
    _kind_from_mode = file_kind_from_stat_mode
 
1641
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
1087
1642
    while pending:
1088
 
        dirblock = []
1089
 
        currentdir = pending.pop()
1090
1643
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1091
 
        top = currentdir[4]
1092
 
        if currentdir[0]:
1093
 
            relroot = currentdir[0] + '/'
1094
 
        else:
1095
 
            relroot = ""
 
1644
        relroot, _, _, _, top = pending.pop()
 
1645
        if relroot:
 
1646
            relprefix = relroot + u'/'
 
1647
        else:
 
1648
            relprefix = ''
 
1649
        top_slash = top + u'/'
 
1650
 
 
1651
        dirblock = []
 
1652
        append = dirblock.append
 
1653
        try:
 
1654
            names = sorted(_listdir(top))
 
1655
        except OSError, e:
 
1656
            if not _is_error_enotdir(e):
 
1657
                raise
 
1658
        else:
 
1659
            for name in names:
 
1660
                abspath = top_slash + name
 
1661
                statvalue = _lstat(abspath)
 
1662
                kind = _kind_from_mode(statvalue.st_mode)
 
1663
                append((relprefix + name, name, kind, statvalue, abspath))
 
1664
        yield (relroot, top), dirblock
 
1665
 
 
1666
        # push the user specified dirs from dirblock
 
1667
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1668
 
 
1669
 
 
1670
class DirReader(object):
 
1671
    """An interface for reading directories."""
 
1672
 
 
1673
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1674
        """Converts top and prefix to a starting dir entry
 
1675
 
 
1676
        :param top: A utf8 path
 
1677
        :param prefix: An optional utf8 path to prefix output relative paths
 
1678
            with.
 
1679
        :return: A tuple starting with prefix, and ending with the native
 
1680
            encoding of top.
 
1681
        """
 
1682
        raise NotImplementedError(self.top_prefix_to_starting_dir)
 
1683
 
 
1684
    def read_dir(self, prefix, top):
 
1685
        """Read a specific dir.
 
1686
 
 
1687
        :param prefix: A utf8 prefix to be preprended to the path basenames.
 
1688
        :param top: A natively encoded path to read.
 
1689
        :return: A list of the directories contents. Each item contains:
 
1690
            (utf8_relpath, utf8_name, kind, lstatvalue, native_abspath)
 
1691
        """
 
1692
        raise NotImplementedError(self.read_dir)
 
1693
 
 
1694
 
 
1695
_selected_dir_reader = None
 
1696
 
 
1697
 
 
1698
def _walkdirs_utf8(top, prefix=""):
 
1699
    """Yield data about all the directories in a tree.
 
1700
 
 
1701
    This yields the same information as walkdirs() only each entry is yielded
 
1702
    in utf-8. On platforms which have a filesystem encoding of utf8 the paths
 
1703
    are returned as exact byte-strings.
 
1704
 
 
1705
    :return: yields a tuple of (dir_info, [file_info])
 
1706
        dir_info is (utf8_relpath, path-from-top)
 
1707
        file_info is (utf8_relpath, utf8_name, kind, lstat, path-from-top)
 
1708
        if top is an absolute path, path-from-top is also an absolute path.
 
1709
        path-from-top might be unicode or utf8, but it is the correct path to
 
1710
        pass to os functions to affect the file in question. (such as os.lstat)
 
1711
    """
 
1712
    global _selected_dir_reader
 
1713
    if _selected_dir_reader is None:
 
1714
        fs_encoding = _fs_enc.upper()
 
1715
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
 
1716
            # Win98 doesn't have unicode apis like FindFirstFileW
 
1717
            # TODO: We possibly could support Win98 by falling back to the
 
1718
            #       original FindFirstFile, and using TCHAR instead of WCHAR,
 
1719
            #       but that gets a bit tricky, and requires custom compiling
 
1720
            #       for win98 anyway.
 
1721
            try:
 
1722
                from bzrlib._walkdirs_win32 import Win32ReadDir
 
1723
                _selected_dir_reader = Win32ReadDir()
 
1724
            except ImportError:
 
1725
                pass
 
1726
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1727
            # ANSI_X3.4-1968 is a form of ASCII
 
1728
            try:
 
1729
                from bzrlib._readdir_pyx import UTF8DirReader
 
1730
                _selected_dir_reader = UTF8DirReader()
 
1731
            except ImportError, e:
 
1732
                failed_to_load_extension(e)
 
1733
                pass
 
1734
 
 
1735
    if _selected_dir_reader is None:
 
1736
        # Fallback to the python version
 
1737
        _selected_dir_reader = UnicodeDirReader()
 
1738
 
 
1739
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
 
1740
    # But we don't actually uses 1-3 in pending, so set them to None
 
1741
    pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
 
1742
    read_dir = _selected_dir_reader.read_dir
 
1743
    _directory = _directory_kind
 
1744
    while pending:
 
1745
        relroot, _, _, _, top = pending[-1].pop()
 
1746
        if not pending[-1]:
 
1747
            pending.pop()
 
1748
        dirblock = sorted(read_dir(relroot, top))
 
1749
        yield (relroot, top), dirblock
 
1750
        # push the user specified dirs from dirblock
 
1751
        next = [d for d in reversed(dirblock) if d[2] == _directory]
 
1752
        if next:
 
1753
            pending.append(next)
 
1754
 
 
1755
 
 
1756
class UnicodeDirReader(DirReader):
 
1757
    """A dir reader for non-utf8 file systems, which transcodes."""
 
1758
 
 
1759
    __slots__ = ['_utf8_encode']
 
1760
 
 
1761
    def __init__(self):
 
1762
        self._utf8_encode = codecs.getencoder('utf8')
 
1763
 
 
1764
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1765
        """See DirReader.top_prefix_to_starting_dir."""
 
1766
        return (safe_utf8(prefix), None, None, None, safe_unicode(top))
 
1767
 
 
1768
    def read_dir(self, prefix, top):
 
1769
        """Read a single directory from a non-utf8 file system.
 
1770
 
 
1771
        top, and the abspath element in the output are unicode, all other paths
 
1772
        are utf8. Local disk IO is done via unicode calls to listdir etc.
 
1773
 
 
1774
        This is currently the fallback code path when the filesystem encoding is
 
1775
        not UTF-8. It may be better to implement an alternative so that we can
 
1776
        safely handle paths that are not properly decodable in the current
 
1777
        encoding.
 
1778
 
 
1779
        See DirReader.read_dir for details.
 
1780
        """
 
1781
        _utf8_encode = self._utf8_encode
 
1782
        _lstat = os.lstat
 
1783
        _listdir = os.listdir
 
1784
        _kind_from_mode = file_kind_from_stat_mode
 
1785
 
 
1786
        if prefix:
 
1787
            relprefix = prefix + '/'
 
1788
        else:
 
1789
            relprefix = ''
 
1790
        top_slash = top + u'/'
 
1791
 
 
1792
        dirblock = []
 
1793
        append = dirblock.append
1096
1794
        for name in sorted(_listdir(top)):
1097
 
            abspath = top + '/' + name
1098
 
            statvalue = lstat(abspath)
1099
 
            dirblock.append((relroot + name, name,
1100
 
                file_kind_from_stat_mode(statvalue.st_mode),
1101
 
                statvalue, abspath))
1102
 
        yield (currentdir[0], top), dirblock
1103
 
        # push the user specified dirs from dirblock
1104
 
        for dir in reversed(dirblock):
1105
 
            if dir[2] == _directory:
1106
 
                pending.append(dir)
 
1795
            try:
 
1796
                name_utf8 = _utf8_encode(name)[0]
 
1797
            except UnicodeDecodeError:
 
1798
                raise errors.BadFilenameEncoding(
 
1799
                    _utf8_encode(relprefix)[0] + name, _fs_enc)
 
1800
            abspath = top_slash + name
 
1801
            statvalue = _lstat(abspath)
 
1802
            kind = _kind_from_mode(statvalue.st_mode)
 
1803
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
 
1804
        return dirblock
1107
1805
 
1108
1806
 
1109
1807
def copy_tree(from_path, to_path, handlers={}):
1110
1808
    """Copy all of the entries in from_path into to_path.
1111
1809
 
1112
 
    :param from_path: The base directory to copy. 
 
1810
    :param from_path: The base directory to copy.
1113
1811
    :param to_path: The target directory. If it does not exist, it will
1114
1812
        be created.
1115
1813
    :param handlers: A dictionary of functions, which takes a source and
1148
1846
            real_handlers[kind](abspath, relpath)
1149
1847
 
1150
1848
 
 
1849
def copy_ownership_from_path(dst, src=None):
 
1850
    """Copy usr/grp ownership from src file/dir to dst file/dir.
 
1851
 
 
1852
    If src is None, the containing directory is used as source. If chown
 
1853
    fails, the error is ignored and a warning is printed.
 
1854
    """
 
1855
    chown = getattr(os, 'chown', None)
 
1856
    if chown is None:
 
1857
        return
 
1858
 
 
1859
    if src == None:
 
1860
        src = os.path.dirname(dst)
 
1861
        if src == '':
 
1862
            src = '.'
 
1863
 
 
1864
    try:
 
1865
        s = os.stat(src)
 
1866
        chown(dst, s.st_uid, s.st_gid)
 
1867
    except OSError, e:
 
1868
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
 
1869
 
 
1870
 
1151
1871
def path_prefix_key(path):
1152
1872
    """Generate a prefix-order path key for path.
1153
1873
 
1184
1904
        return _cached_user_encoding
1185
1905
 
1186
1906
    if sys.platform == 'darwin':
1187
 
        # work around egregious python 2.4 bug
 
1907
        # python locale.getpreferredencoding() always return
 
1908
        # 'mac-roman' on darwin. That's a lie.
1188
1909
        sys.platform = 'posix'
1189
1910
        try:
 
1911
            if os.environ.get('LANG', None) is None:
 
1912
                # If LANG is not set, we end up with 'ascii', which is bad
 
1913
                # ('mac-roman' is more than ascii), so we set a default which
 
1914
                # will give us UTF-8 (which appears to work in all cases on
 
1915
                # OSX). Users are still free to override LANG of course, as
 
1916
                # long as it give us something meaningful. This work-around
 
1917
                # *may* not be needed with python 3k and/or OSX 10.5, but will
 
1918
                # work with them too -- vila 20080908
 
1919
                os.environ['LANG'] = 'en_US.UTF-8'
1190
1920
            import locale
1191
1921
        finally:
1192
1922
            sys.platform = 'darwin'
1207
1937
    # Windows returns 'cp0' to indicate there is no code page. So we'll just
1208
1938
    # treat that as ASCII, and not support printing unicode characters to the
1209
1939
    # console.
1210
 
    if user_encoding in (None, 'cp0'):
 
1940
    #
 
1941
    # For python scripts run under vim, we get '', so also treat that as ASCII
 
1942
    if user_encoding in (None, 'cp0', ''):
1211
1943
        user_encoding = 'ascii'
1212
1944
    else:
1213
1945
        # check encoding
1227
1959
    return user_encoding
1228
1960
 
1229
1961
 
1230
 
def recv_all(socket, bytes):
 
1962
def get_host_name():
 
1963
    """Return the current unicode host name.
 
1964
 
 
1965
    This is meant to be used in place of socket.gethostname() because that
 
1966
    behaves inconsistently on different platforms.
 
1967
    """
 
1968
    if sys.platform == "win32":
 
1969
        import win32utils
 
1970
        return win32utils.get_host_name()
 
1971
    else:
 
1972
        import socket
 
1973
        return socket.gethostname().decode(get_user_encoding())
 
1974
 
 
1975
 
 
1976
# We must not read/write any more than 64k at a time from/to a socket so we
 
1977
# don't risk "no buffer space available" errors on some platforms.  Windows in
 
1978
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
 
1979
# data at once.
 
1980
MAX_SOCKET_CHUNK = 64 * 1024
 
1981
 
 
1982
def read_bytes_from_socket(sock, report_activity=None,
 
1983
        max_read_size=MAX_SOCKET_CHUNK):
 
1984
    """Read up to max_read_size of bytes from sock and notify of progress.
 
1985
 
 
1986
    Translates "Connection reset by peer" into file-like EOF (return an
 
1987
    empty string rather than raise an error), and repeats the recv if
 
1988
    interrupted by a signal.
 
1989
    """
 
1990
    while 1:
 
1991
        try:
 
1992
            bytes = sock.recv(max_read_size)
 
1993
        except socket.error, e:
 
1994
            eno = e.args[0]
 
1995
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
 
1996
                # The connection was closed by the other side.  Callers expect
 
1997
                # an empty string to signal end-of-stream.
 
1998
                return ""
 
1999
            elif eno == errno.EINTR:
 
2000
                # Retry the interrupted recv.
 
2001
                continue
 
2002
            raise
 
2003
        else:
 
2004
            if report_activity is not None:
 
2005
                report_activity(len(bytes), 'read')
 
2006
            return bytes
 
2007
 
 
2008
 
 
2009
def recv_all(socket, count):
1231
2010
    """Receive an exact number of bytes.
1232
2011
 
1233
2012
    Regular Socket.recv() may return less than the requested number of bytes,
1234
 
    dependning on what's in the OS buffer.  MSG_WAITALL is not available
 
2013
    depending on what's in the OS buffer.  MSG_WAITALL is not available
1235
2014
    on all platforms, but this should work everywhere.  This will return
1236
2015
    less than the requested amount if the remote end closes.
1237
2016
 
1238
2017
    This isn't optimized and is intended mostly for use in testing.
1239
2018
    """
1240
2019
    b = ''
1241
 
    while len(b) < bytes:
1242
 
        new = socket.recv(bytes - len(b))
 
2020
    while len(b) < count:
 
2021
        new = read_bytes_from_socket(socket, None, count - len(b))
1243
2022
        if new == '':
1244
2023
            break # eof
1245
2024
        b += new
1246
2025
    return b
1247
2026
 
 
2027
 
 
2028
def send_all(sock, bytes, report_activity=None):
 
2029
    """Send all bytes on a socket.
 
2030
 
 
2031
    Breaks large blocks in smaller chunks to avoid buffering limitations on
 
2032
    some platforms, and catches EINTR which may be thrown if the send is
 
2033
    interrupted by a signal.
 
2034
 
 
2035
    This is preferred to socket.sendall(), because it avoids portability bugs
 
2036
    and provides activity reporting.
 
2037
 
 
2038
    :param report_activity: Call this as bytes are read, see
 
2039
        Transport._report_activity
 
2040
    """
 
2041
    sent_total = 0
 
2042
    byte_count = len(bytes)
 
2043
    while sent_total < byte_count:
 
2044
        try:
 
2045
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
 
2046
        except socket.error, e:
 
2047
            if e.args[0] != errno.EINTR:
 
2048
                raise
 
2049
        else:
 
2050
            sent_total += sent
 
2051
            report_activity(sent, 'write')
 
2052
 
 
2053
 
1248
2054
def dereference_path(path):
1249
2055
    """Determine the real path to a file.
1250
2056
 
1257
2063
    # The pathjoin for '.' is a workaround for Python bug #1213894.
1258
2064
    # (initial path components aren't dereferenced)
1259
2065
    return pathjoin(realpath(pathjoin('.', parent)), base)
 
2066
 
 
2067
 
 
2068
def supports_mapi():
 
2069
    """Return True if we can use MAPI to launch a mail client."""
 
2070
    return sys.platform == "win32"
 
2071
 
 
2072
 
 
2073
def resource_string(package, resource_name):
 
2074
    """Load a resource from a package and return it as a string.
 
2075
 
 
2076
    Note: Only packages that start with bzrlib are currently supported.
 
2077
 
 
2078
    This is designed to be a lightweight implementation of resource
 
2079
    loading in a way which is API compatible with the same API from
 
2080
    pkg_resources. See
 
2081
    http://peak.telecommunity.com/DevCenter/PkgResources#basic-resource-access.
 
2082
    If and when pkg_resources becomes a standard library, this routine
 
2083
    can delegate to it.
 
2084
    """
 
2085
    # Check package name is within bzrlib
 
2086
    if package == "bzrlib":
 
2087
        resource_relpath = resource_name
 
2088
    elif package.startswith("bzrlib."):
 
2089
        package = package[len("bzrlib."):].replace('.', os.sep)
 
2090
        resource_relpath = pathjoin(package, resource_name)
 
2091
    else:
 
2092
        raise errors.BzrError('resource package %s not in bzrlib' % package)
 
2093
 
 
2094
    # Map the resource to a file and read its contents
 
2095
    base = dirname(bzrlib.__file__)
 
2096
    if getattr(sys, 'frozen', None):    # bzr.exe
 
2097
        base = abspath(pathjoin(base, '..', '..'))
 
2098
    filename = pathjoin(base, resource_relpath)
 
2099
    return open(filename, 'rU').read()
 
2100
 
 
2101
 
 
2102
def file_kind_from_stat_mode_thunk(mode):
 
2103
    global file_kind_from_stat_mode
 
2104
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
 
2105
        try:
 
2106
            from bzrlib._readdir_pyx import UTF8DirReader
 
2107
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
 
2108
        except ImportError, e:
 
2109
            # This is one time where we won't warn that an extension failed to
 
2110
            # load. The extension is never available on Windows anyway.
 
2111
            from bzrlib._readdir_py import (
 
2112
                _kind_from_mode as file_kind_from_stat_mode
 
2113
                )
 
2114
    return file_kind_from_stat_mode(mode)
 
2115
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
 
2116
 
 
2117
 
 
2118
def file_kind(f, _lstat=os.lstat):
 
2119
    try:
 
2120
        return file_kind_from_stat_mode(_lstat(f).st_mode)
 
2121
    except OSError, e:
 
2122
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
 
2123
            raise errors.NoSuchFile(f)
 
2124
        raise
 
2125
 
 
2126
 
 
2127
def until_no_eintr(f, *a, **kw):
 
2128
    """Run f(*a, **kw), retrying if an EINTR error occurs.
 
2129
    
 
2130
    WARNING: you must be certain that it is safe to retry the call repeatedly
 
2131
    if EINTR does occur.  This is typically only true for low-level operations
 
2132
    like os.read.  If in any doubt, don't use this.
 
2133
 
 
2134
    Keep in mind that this is not a complete solution to EINTR.  There is
 
2135
    probably code in the Python standard library and other dependencies that
 
2136
    may encounter EINTR if a signal arrives (and there is signal handler for
 
2137
    that signal).  So this function can reduce the impact for IO that bzrlib
 
2138
    directly controls, but it is not a complete solution.
 
2139
    """
 
2140
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
 
2141
    while True:
 
2142
        try:
 
2143
            return f(*a, **kw)
 
2144
        except (IOError, OSError), e:
 
2145
            if e.errno == errno.EINTR:
 
2146
                continue
 
2147
            raise
 
2148
 
 
2149
 
 
2150
def re_compile_checked(re_string, flags=0, where=""):
 
2151
    """Return a compiled re, or raise a sensible error.
 
2152
 
 
2153
    This should only be used when compiling user-supplied REs.
 
2154
 
 
2155
    :param re_string: Text form of regular expression.
 
2156
    :param flags: eg re.IGNORECASE
 
2157
    :param where: Message explaining to the user the context where
 
2158
        it occurred, eg 'log search filter'.
 
2159
    """
 
2160
    # from https://bugs.launchpad.net/bzr/+bug/251352
 
2161
    try:
 
2162
        re_obj = re.compile(re_string, flags)
 
2163
        re_obj.search("")
 
2164
        return re_obj
 
2165
    except re.error, e:
 
2166
        if where:
 
2167
            where = ' in ' + where
 
2168
        # despite the name 'error' is a type
 
2169
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
 
2170
            % (where, re_string, e))
 
2171
 
 
2172
 
 
2173
if sys.platform == "win32":
 
2174
    import msvcrt
 
2175
    def getchar():
 
2176
        return msvcrt.getch()
 
2177
else:
 
2178
    import tty
 
2179
    import termios
 
2180
    def getchar():
 
2181
        fd = sys.stdin.fileno()
 
2182
        settings = termios.tcgetattr(fd)
 
2183
        try:
 
2184
            tty.setraw(fd)
 
2185
            ch = sys.stdin.read(1)
 
2186
        finally:
 
2187
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
 
2188
        return ch
 
2189
 
 
2190
 
 
2191
if sys.platform == 'linux2':
 
2192
    def _local_concurrency():
 
2193
        concurrency = None
 
2194
        prefix = 'processor'
 
2195
        for line in file('/proc/cpuinfo', 'rb'):
 
2196
            if line.startswith(prefix):
 
2197
                concurrency = int(line[line.find(':')+1:]) + 1
 
2198
        return concurrency
 
2199
elif sys.platform == 'darwin':
 
2200
    def _local_concurrency():
 
2201
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
 
2202
                                stdout=subprocess.PIPE).communicate()[0]
 
2203
elif sys.platform[0:7] == 'freebsd':
 
2204
    def _local_concurrency():
 
2205
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
 
2206
                                stdout=subprocess.PIPE).communicate()[0]
 
2207
elif sys.platform == 'sunos5':
 
2208
    def _local_concurrency():
 
2209
        return subprocess.Popen(['psrinfo', '-p',],
 
2210
                                stdout=subprocess.PIPE).communicate()[0]
 
2211
elif sys.platform == "win32":
 
2212
    def _local_concurrency():
 
2213
        # This appears to return the number of cores.
 
2214
        return os.environ.get('NUMBER_OF_PROCESSORS')
 
2215
else:
 
2216
    def _local_concurrency():
 
2217
        # Who knows ?
 
2218
        return None
 
2219
 
 
2220
 
 
2221
_cached_local_concurrency = None
 
2222
 
 
2223
def local_concurrency(use_cache=True):
 
2224
    """Return how many processes can be run concurrently.
 
2225
 
 
2226
    Rely on platform specific implementations and default to 1 (one) if
 
2227
    anything goes wrong.
 
2228
    """
 
2229
    global _cached_local_concurrency
 
2230
 
 
2231
    if _cached_local_concurrency is not None and use_cache:
 
2232
        return _cached_local_concurrency
 
2233
 
 
2234
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
 
2235
    if concurrency is None:
 
2236
        try:
 
2237
            concurrency = _local_concurrency()
 
2238
        except (OSError, IOError):
 
2239
            pass
 
2240
    try:
 
2241
        concurrency = int(concurrency)
 
2242
    except (TypeError, ValueError):
 
2243
        concurrency = 1
 
2244
    if use_cache:
 
2245
        _cached_concurrency = concurrency
 
2246
    return concurrency
 
2247
 
 
2248
 
 
2249
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
 
2250
    """A stream writer that doesn't decode str arguments."""
 
2251
 
 
2252
    def __init__(self, encode, stream, errors='strict'):
 
2253
        codecs.StreamWriter.__init__(self, stream, errors)
 
2254
        self.encode = encode
 
2255
 
 
2256
    def write(self, object):
 
2257
        if type(object) is str:
 
2258
            self.stream.write(object)
 
2259
        else:
 
2260
            data, _ = self.encode(object, self.errors)
 
2261
            self.stream.write(data)
 
2262
 
 
2263
if sys.platform == 'win32':
 
2264
    def open_file(filename, mode='r', bufsize=-1):
 
2265
        """This function is used to override the ``open`` builtin.
 
2266
        
 
2267
        But it uses O_NOINHERIT flag so the file handle is not inherited by
 
2268
        child processes.  Deleting or renaming a closed file opened with this
 
2269
        function is not blocking child processes.
 
2270
        """
 
2271
        writing = 'w' in mode
 
2272
        appending = 'a' in mode
 
2273
        updating = '+' in mode
 
2274
        binary = 'b' in mode
 
2275
 
 
2276
        flags = O_NOINHERIT
 
2277
        # see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
 
2278
        # for flags for each modes.
 
2279
        if binary:
 
2280
            flags |= O_BINARY
 
2281
        else:
 
2282
            flags |= O_TEXT
 
2283
 
 
2284
        if writing:
 
2285
            if updating:
 
2286
                flags |= os.O_RDWR
 
2287
            else:
 
2288
                flags |= os.O_WRONLY
 
2289
            flags |= os.O_CREAT | os.O_TRUNC
 
2290
        elif appending:
 
2291
            if updating:
 
2292
                flags |= os.O_RDWR
 
2293
            else:
 
2294
                flags |= os.O_WRONLY
 
2295
            flags |= os.O_CREAT | os.O_APPEND
 
2296
        else: #reading
 
2297
            if updating:
 
2298
                flags |= os.O_RDWR
 
2299
            else:
 
2300
                flags |= os.O_RDONLY
 
2301
 
 
2302
        return os.fdopen(os.open(filename, flags), mode, bufsize)
 
2303
else:
 
2304
    open_file = open