/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: Canonical.com Patch Queue Manager
  • Date: 2010-05-27 01:58:44 UTC
  • mfrom: (5193.4.24 gio-transport)
  • Revision ID: pqm@pqm.ubuntu.com-20100527015844-ya4jahnwjx5y8ej2
(lifeless) Add a gio based transport using gio+ as a prefix to get at the
 gio logic. (Mattias Eriksson)

Show diffs side-by-side

added added

removed removed

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