← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Merge HEAD.

Show diffs side-by-side

added added

removed removed

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