/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2005-10-11 22:57:45 UTC
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051011225745-5c02a0cfc85b36d1
fixup the verbose-does-nothing for add - add a --quiet instead

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Bazaar-NG -- distributed version control
 
2
#
 
3
# Copyright (C) 2005 by Canonical Ltd
 
4
#
 
5
# This program is free software; you can redistribute it and/or modify
 
6
# it under the terms of the GNU General Public License as published by
 
7
# the Free Software Foundation; either version 2 of the License, or
 
8
# (at your option) any later version.
 
9
#
 
10
# This program is distributed in the hope that it will be useful,
 
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
# GNU General Public License for more details.
 
14
#
 
15
# You should have received a copy of the GNU General Public License
 
16
# along with this program; if not, write to the Free Software
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
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
 
24
import os
 
25
import re
 
26
import sha
 
27
import sys
 
28
import time
 
29
import types
 
30
 
 
31
import bzrlib
 
32
from bzrlib.config import config_dir, _get_user_id
 
33
from bzrlib.errors import BzrError
 
34
from bzrlib.trace import mutter
 
35
 
 
36
 
 
37
def make_readonly(filename):
 
38
    """Make a filename read-only."""
 
39
    mod = os.stat(filename).st_mode
 
40
    mod = mod & 0777555
 
41
    os.chmod(filename, mod)
 
42
 
 
43
 
 
44
def make_writable(filename):
 
45
    mod = os.stat(filename).st_mode
 
46
    mod = mod | 0200
 
47
    os.chmod(filename, mod)
 
48
 
 
49
 
 
50
_QUOTE_RE = None
 
51
 
 
52
 
 
53
def quotefn(f):
 
54
    """Return a quoted filename filename
 
55
 
 
56
    This previously used backslash quoting, but that works poorly on
 
57
    Windows."""
 
58
    # TODO: I'm not really sure this is the best format either.x
 
59
    global _QUOTE_RE
 
60
    if _QUOTE_RE == None:
 
61
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
62
        
 
63
    if _QUOTE_RE.search(f):
 
64
        return '"' + f + '"'
 
65
    else:
 
66
        return f
 
67
 
 
68
 
 
69
def file_kind(f):
 
70
    mode = os.lstat(f)[ST_MODE]
 
71
    if S_ISREG(mode):
 
72
        return 'file'
 
73
    elif S_ISDIR(mode):
 
74
        return 'directory'
 
75
    elif S_ISLNK(mode):
 
76
        return 'symlink'
 
77
    elif S_ISCHR(mode):
 
78
        return 'chardev'
 
79
    elif S_ISBLK(mode):
 
80
        return 'block'
 
81
    elif S_ISFIFO(mode):
 
82
        return 'fifo'
 
83
    elif S_ISSOCK(mode):
 
84
        return 'socket'
 
85
    else:
 
86
        return 'unknown'
 
87
 
 
88
 
 
89
def kind_marker(kind):
 
90
    if kind == 'file':
 
91
        return ''
 
92
    elif kind == 'directory':
 
93
        return '/'
 
94
    elif kind == 'symlink':
 
95
        return '@'
 
96
    else:
 
97
        raise BzrError('invalid file kind %r' % kind)
 
98
 
 
99
def lexists(f):
 
100
    try:
 
101
        if hasattr(os, 'lstat'):
 
102
            os.lstat(f)
 
103
        else:
 
104
            os.stat(f)
 
105
        return True
 
106
    except OSError,e:
 
107
        if e.errno == errno.ENOENT:
 
108
            return False;
 
109
        else:
 
110
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
 
111
 
 
112
def normalizepath(f):
 
113
    if hasattr(os.path, 'realpath'):
 
114
        F = os.path.realpath
 
115
    else:
 
116
        F = os.path.abspath
 
117
    [p,e] = os.path.split(f)
 
118
    if e == "" or e == "." or e == "..":
 
119
        return F(f)
 
120
    else:
 
121
        return os.path.join(F(p), e)
 
122
    
 
123
 
 
124
def backup_file(fn):
 
125
    """Copy a file to a backup.
 
126
 
 
127
    Backups are named in GNU-style, with a ~ suffix.
 
128
 
 
129
    If the file is already a backup, it's not copied.
 
130
    """
 
131
    if fn[-1] == '~':
 
132
        return
 
133
    bfn = fn + '~'
 
134
 
 
135
    inf = file(fn, 'rb')
 
136
    try:
 
137
        content = inf.read()
 
138
    finally:
 
139
        inf.close()
 
140
    
 
141
    outf = file(bfn, 'wb')
 
142
    try:
 
143
        outf.write(content)
 
144
    finally:
 
145
        outf.close()
 
146
 
 
147
if os.name == 'nt':
 
148
    import shutil
 
149
    rename = shutil.move
 
150
else:
 
151
    rename = os.rename
 
152
 
 
153
 
 
154
def isdir(f):
 
155
    """True if f is an accessible directory."""
 
156
    try:
 
157
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
158
    except OSError:
 
159
        return False
 
160
 
 
161
 
 
162
def isfile(f):
 
163
    """True if f is a regular file."""
 
164
    try:
 
165
        return S_ISREG(os.lstat(f)[ST_MODE])
 
166
    except OSError:
 
167
        return False
 
168
 
 
169
def islink(f):
 
170
    """True if f is a symlink."""
 
171
    try:
 
172
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
173
    except OSError:
 
174
        return False
 
175
 
 
176
def is_inside(dir, fname):
 
177
    """True if fname is inside dir.
 
178
    
 
179
    The parameters should typically be passed to os.path.normpath first, so
 
180
    that . and .. and repeated slashes are eliminated, and the separators
 
181
    are canonical for the platform.
 
182
    
 
183
    The empty string as a dir name is taken as top-of-tree and matches 
 
184
    everything.
 
185
    
 
186
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
187
    True
 
188
    >>> is_inside('src', 'srccontrol')
 
189
    False
 
190
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
191
    True
 
192
    >>> is_inside('foo.c', 'foo.c')
 
193
    True
 
194
    >>> is_inside('foo.c', '')
 
195
    False
 
196
    >>> is_inside('', 'foo.c')
 
197
    True
 
198
    """
 
199
    # XXX: Most callers of this can actually do something smarter by 
 
200
    # looking at the inventory
 
201
    if dir == fname:
 
202
        return True
 
203
    
 
204
    if dir == '':
 
205
        return True
 
206
 
 
207
    if dir[-1] != os.sep:
 
208
        dir += os.sep
 
209
 
 
210
    return fname.startswith(dir)
 
211
 
 
212
 
 
213
def is_inside_any(dir_list, fname):
 
214
    """True if fname is inside any of given dirs."""
 
215
    for dirname in dir_list:
 
216
        if is_inside(dirname, fname):
 
217
            return True
 
218
    else:
 
219
        return False
 
220
 
 
221
 
 
222
def pumpfile(fromfile, tofile):
 
223
    """Copy contents of one file to another."""
 
224
    tofile.write(fromfile.read())
 
225
 
 
226
 
 
227
def sha_file(f):
 
228
    if hasattr(f, 'tell'):
 
229
        assert f.tell() == 0
 
230
    s = sha.new()
 
231
    BUFSIZE = 128<<10
 
232
    while True:
 
233
        b = f.read(BUFSIZE)
 
234
        if not b:
 
235
            break
 
236
        s.update(b)
 
237
    return s.hexdigest()
 
238
 
 
239
 
 
240
 
 
241
def sha_strings(strings):
 
242
    """Return the sha-1 of concatenation of strings"""
 
243
    s = sha.new()
 
244
    map(s.update, strings)
 
245
    return s.hexdigest()
 
246
 
 
247
 
 
248
def sha_string(f):
 
249
    s = sha.new()
 
250
    s.update(f)
 
251
    return s.hexdigest()
 
252
 
 
253
 
 
254
def fingerprint_file(f):
 
255
    s = sha.new()
 
256
    b = f.read()
 
257
    s.update(b)
 
258
    size = len(b)
 
259
    return {'size': size,
 
260
            'sha1': s.hexdigest()}
 
261
 
 
262
 
 
263
def compare_files(a, b):
 
264
    """Returns true if equal in contents"""
 
265
    BUFSIZE = 4096
 
266
    while True:
 
267
        ai = a.read(BUFSIZE)
 
268
        bi = b.read(BUFSIZE)
 
269
        if ai != bi:
 
270
            return False
 
271
        if ai == '':
 
272
            return True
 
273
 
 
274
 
 
275
def local_time_offset(t=None):
 
276
    """Return offset of local zone from GMT, either at present or at time t."""
 
277
    # python2.3 localtime() can't take None
 
278
    if t == None:
 
279
        t = time.time()
 
280
        
 
281
    if time.localtime(t).tm_isdst and time.daylight:
 
282
        return -time.altzone
 
283
    else:
 
284
        return -time.timezone
 
285
 
 
286
    
 
287
def format_date(t, offset=0, timezone='original'):
 
288
    ## TODO: Perhaps a global option to use either universal or local time?
 
289
    ## Or perhaps just let people set $TZ?
 
290
    assert isinstance(t, float)
 
291
    
 
292
    if timezone == 'utc':
 
293
        tt = time.gmtime(t)
 
294
        offset = 0
 
295
    elif timezone == 'original':
 
296
        if offset == None:
 
297
            offset = 0
 
298
        tt = time.gmtime(t + offset)
 
299
    elif timezone == 'local':
 
300
        tt = time.localtime(t)
 
301
        offset = local_time_offset(t)
 
302
    else:
 
303
        raise BzrError("unsupported timezone format %r" % timezone,
 
304
                       ['options are "utc", "original", "local"'])
 
305
 
 
306
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
 
307
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
308
 
 
309
 
 
310
def compact_date(when):
 
311
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
 
312
    
 
313
 
 
314
 
 
315
def filesize(f):
 
316
    """Return size of given open file."""
 
317
    return os.fstat(f.fileno())[ST_SIZE]
 
318
 
 
319
# Define rand_bytes based on platform.
 
320
try:
 
321
    # Python 2.4 and later have os.urandom,
 
322
    # but it doesn't work on some arches
 
323
    os.urandom(1)
 
324
    rand_bytes = os.urandom
 
325
except (NotImplementedError, AttributeError):
 
326
    # If python doesn't have os.urandom, or it doesn't work,
 
327
    # then try to first pull random data from /dev/urandom
 
328
    if os.path.exists("/dev/urandom"):
 
329
        rand_bytes = file('/dev/urandom', 'rb').read
 
330
    # Otherwise, use this hack as a last resort
 
331
    else:
 
332
        # not well seeded, but better than nothing
 
333
        def rand_bytes(n):
 
334
            import random
 
335
            s = ''
 
336
            while n:
 
337
                s += chr(random.randint(0, 255))
 
338
                n -= 1
 
339
            return s
 
340
 
 
341
## TODO: We could later have path objects that remember their list
 
342
## decomposition (might be too tricksy though.)
 
343
 
 
344
def splitpath(p):
 
345
    """Turn string into list of parts.
 
346
 
 
347
    >>> splitpath('a')
 
348
    ['a']
 
349
    >>> splitpath('a/b')
 
350
    ['a', 'b']
 
351
    >>> splitpath('a/./b')
 
352
    ['a', 'b']
 
353
    >>> splitpath('a/.b')
 
354
    ['a', '.b']
 
355
    >>> splitpath('a/../b')
 
356
    Traceback (most recent call last):
 
357
    ...
 
358
    BzrError: sorry, '..' not allowed in path
 
359
    """
 
360
    assert isinstance(p, types.StringTypes)
 
361
 
 
362
    # split on either delimiter because people might use either on
 
363
    # Windows
 
364
    ps = re.split(r'[\\/]', p)
 
365
 
 
366
    rps = []
 
367
    for f in ps:
 
368
        if f == '..':
 
369
            raise BzrError("sorry, %r not allowed in path" % f)
 
370
        elif (f == '.') or (f == ''):
 
371
            pass
 
372
        else:
 
373
            rps.append(f)
 
374
    return rps
 
375
 
 
376
def joinpath(p):
 
377
    assert isinstance(p, list)
 
378
    for f in p:
 
379
        if (f == '..') or (f == None) or (f == ''):
 
380
            raise BzrError("sorry, %r not allowed in path" % f)
 
381
    return os.path.join(*p)
 
382
 
 
383
 
 
384
def appendpath(p1, p2):
 
385
    if p1 == '':
 
386
        return p2
 
387
    else:
 
388
        return os.path.join(p1, p2)
 
389
    
 
390
 
 
391
def split_lines(s):
 
392
    """Split s into lines, but without removing the newline characters."""
 
393
    return StringIO(s).readlines()
 
394
 
 
395
 
 
396
def hardlinks_good():
 
397
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
398
 
 
399
 
 
400
def link_or_copy(src, dest):
 
401
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
402
    if not hardlinks_good():
 
403
        copyfile(src, dest)
 
404
        return
 
405
    try:
 
406
        os.link(src, dest)
 
407
    except (OSError, IOError), e:
 
408
        if e.errno != errno.EXDEV:
 
409
            raise
 
410
        copyfile(src, dest)
 
411
 
 
412
 
 
413
def has_symlinks():
 
414
    if hasattr(os, 'symlink'):
 
415
        return True
 
416
    else:
 
417
        return False