← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2009-09-07 03:08:30 UTC
  • mto: This revision was merged to the branch mainline in revision 4690.
  • Revision ID: robertc@robertcollins.net-20090907030830-rf59kt28d550eauj
Milestones language tightning, internal consistency.

Show diffs side-by-side

added added

removed removed

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