← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

ApplyMerge3 -> Merge3Merger

Show diffs side-by-side

added added

removed removed

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