~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

- ignore .swp files from upload

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
# Bazaar-NG -- distributed version control
2
 
 
 
2
#
3
3
# Copyright (C) 2005 by Canonical Ltd
4
 
 
 
4
#
5
5
# This program is free software; you can redistribute it and/or modify
6
6
# it under the terms of the GNU General Public License as published by
7
7
# the Free Software Foundation; either version 2 of the License, or
8
8
# (at your option) any later version.
9
 
 
 
9
#
10
10
# This program is distributed in the hope that it will be useful,
11
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
13
# GNU General Public License for more details.
14
 
 
 
14
#
15
15
# You should have received a copy of the GNU General Public License
16
16
# along with this program; if not, write to the Free Software
17
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 
19
 
import os, types, re, time, errno, sys
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
 
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
21
30
 
 
31
import bzrlib
 
32
from bzrlib.config import config_dir, _get_user_id
22
33
from bzrlib.errors import BzrError
23
34
from bzrlib.trace import mutter
24
 
import bzrlib
 
35
 
25
36
 
26
37
def make_readonly(filename):
27
38
    """Make a filename read-only."""
28
 
    # TODO: probably needs to be fixed for windows
29
39
    mod = os.stat(filename).st_mode
30
40
    mod = mod & 0777555
31
41
    os.chmod(filename, mod)
48
58
    # TODO: I'm not really sure this is the best format either.x
49
59
    global _QUOTE_RE
50
60
    if _QUOTE_RE == None:
51
 
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
61
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
52
62
        
53
63
    if _QUOTE_RE.search(f):
54
64
        return '"' + f + '"'
64
74
        return 'directory'
65
75
    elif S_ISLNK(mode):
66
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'
67
85
    else:
68
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
 
86
        return 'unknown'
69
87
 
70
88
 
71
89
def kind_marker(kind):
78
96
    else:
79
97
        raise BzrError('invalid file kind %r' % kind)
80
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))
81
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
    
82
123
 
83
124
def backup_file(fn):
84
125
    """Copy a file to a backup.
87
128
 
88
129
    If the file is already a backup, it's not copied.
89
130
    """
90
 
    import os
91
131
    if fn[-1] == '~':
92
132
        return
93
133
    bfn = fn + '~'
94
134
 
 
135
    if has_symlinks() and os.path.islink(fn):
 
136
        target = os.readlink(fn)
 
137
        os.symlink(target, bfn)
 
138
        return
95
139
    inf = file(fn, 'rb')
96
140
    try:
97
141
        content = inf.read()
104
148
    finally:
105
149
        outf.close()
106
150
 
107
 
def rename(path_from, path_to):
108
 
    """Basically the same as os.rename() just special for win32"""
109
 
    if sys.platform == 'win32':
110
 
        try:
111
 
            os.remove(path_to)
112
 
        except OSError, e:
113
 
            if e.errno != e.ENOENT:
114
 
                raise
115
 
    os.rename(path_from, path_to)
116
 
 
117
 
 
118
 
 
 
151
if os.name == 'nt':
 
152
    import shutil
 
153
    rename = shutil.move
 
154
else:
 
155
    rename = os.rename
119
156
 
120
157
 
121
158
def isdir(f):
126
163
        return False
127
164
 
128
165
 
129
 
 
130
166
def isfile(f):
131
167
    """True if f is a regular file."""
132
168
    try:
134
170
    except OSError:
135
171
        return False
136
172
 
 
173
def islink(f):
 
174
    """True if f is a symlink."""
 
175
    try:
 
176
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
177
    except OSError:
 
178
        return False
137
179
 
138
180
def is_inside(dir, fname):
139
181
    """True if fname is inside dir.
145
187
    The empty string as a dir name is taken as top-of-tree and matches 
146
188
    everything.
147
189
    
148
 
    >>> is_inside('src', 'src/foo.c')
 
190
    >>> is_inside('src', os.path.join('src', 'foo.c'))
149
191
    True
150
192
    >>> is_inside('src', 'srccontrol')
151
193
    False
152
 
    >>> is_inside('src', 'src/a/a/a/foo.c')
 
194
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
153
195
    True
154
196
    >>> is_inside('foo.c', 'foo.c')
155
197
    True
165
207
    
166
208
    if dir == '':
167
209
        return True
168
 
    
 
210
 
169
211
    if dir[-1] != os.sep:
170
212
        dir += os.sep
171
 
    
 
213
 
172
214
    return fname.startswith(dir)
173
215
 
174
216
 
186
228
    tofile.write(fromfile.read())
187
229
 
188
230
 
189
 
def uuid():
190
 
    """Return a new UUID"""
191
 
    try:
192
 
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
193
 
    except IOError:
194
 
        return chomp(os.popen('uuidgen').readline())
195
 
 
196
 
 
197
231
def sha_file(f):
198
 
    import sha
199
232
    if hasattr(f, 'tell'):
200
233
        assert f.tell() == 0
201
234
    s = sha.new()
208
241
    return s.hexdigest()
209
242
 
210
243
 
 
244
 
 
245
def sha_strings(strings):
 
246
    """Return the sha-1 of concatenation of strings"""
 
247
    s = sha.new()
 
248
    map(s.update, strings)
 
249
    return s.hexdigest()
 
250
 
 
251
 
211
252
def sha_string(f):
212
 
    import sha
213
253
    s = sha.new()
214
254
    s.update(f)
215
255
    return s.hexdigest()
216
256
 
217
257
 
218
 
 
219
258
def fingerprint_file(f):
220
 
    import sha
221
259
    s = sha.new()
222
260
    b = f.read()
223
261
    s.update(b)
226
264
            'sha1': s.hexdigest()}
227
265
 
228
266
 
229
 
def config_dir():
230
 
    """Return per-user configuration directory.
231
 
 
232
 
    By default this is ~/.bzr.conf/
233
 
    
234
 
    TODO: Global option --config-dir to override this.
235
 
    """
236
 
    return os.path.expanduser("~/.bzr.conf")
237
 
 
238
 
 
239
 
def _auto_user_id():
240
 
    """Calculate automatic user identification.
241
 
 
242
 
    Returns (realname, email).
243
 
 
244
 
    Only used when none is set in the environment or the id file.
245
 
 
246
 
    This previously used the FQDN as the default domain, but that can
247
 
    be very slow on machines where DNS is broken.  So now we simply
248
 
    use the hostname.
249
 
    """
250
 
    import socket
251
 
 
252
 
    # XXX: Any good way to get real user name on win32?
253
 
 
254
 
    try:
255
 
        import pwd
256
 
        uid = os.getuid()
257
 
        w = pwd.getpwuid(uid)
258
 
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
259
 
        username = w.pw_name.decode(bzrlib.user_encoding)
260
 
        comma = gecos.find(',')
261
 
        if comma == -1:
262
 
            realname = gecos
263
 
        else:
264
 
            realname = gecos[:comma]
265
 
        if not realname:
266
 
            realname = username
267
 
 
268
 
    except ImportError:
269
 
        import getpass
270
 
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
271
 
 
272
 
    return realname, (username + '@' + socket.gethostname())
273
 
 
274
 
 
275
 
def _get_user_id(branch):
276
 
    """Return the full user id from a file or environment variable.
277
 
 
278
 
    e.g. "John Hacker <jhacker@foo.org>"
279
 
 
280
 
    branch
281
 
        A branch to use for a per-branch configuration, or None.
282
 
 
283
 
    The following are searched in order:
284
 
 
285
 
    1. $BZREMAIL
286
 
    2. .bzr/email for this branch.
287
 
    3. ~/.bzr.conf/email
288
 
    4. $EMAIL
289
 
    """
290
 
    v = os.environ.get('BZREMAIL')
291
 
    if v:
292
 
        return v.decode(bzrlib.user_encoding)
293
 
 
294
 
    if branch:
295
 
        try:
296
 
            return (branch.controlfile("email", "r") 
297
 
                    .read()
298
 
                    .decode(bzrlib.user_encoding)
299
 
                    .rstrip("\r\n"))
300
 
        except IOError, e:
301
 
            if e.errno != errno.ENOENT:
302
 
                raise
303
 
        except BzrError, e:
304
 
            pass
305
 
    
306
 
    try:
307
 
        return (open(os.path.join(config_dir(), "email"))
308
 
                .read()
309
 
                .decode(bzrlib.user_encoding)
310
 
                .rstrip("\r\n"))
311
 
    except IOError, e:
312
 
        if e.errno != errno.ENOENT:
313
 
            raise e
314
 
 
315
 
    v = os.environ.get('EMAIL')
316
 
    if v:
317
 
        return v.decode(bzrlib.user_encoding)
318
 
    else:    
319
 
        return None
320
 
 
321
 
 
322
 
def username(branch):
323
 
    """Return email-style username.
324
 
 
325
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
326
 
 
327
 
    TODO: Check it's reasonably well-formed.
328
 
    """
329
 
    v = _get_user_id(branch)
330
 
    if v:
331
 
        return v
332
 
    
333
 
    name, email = _auto_user_id()
334
 
    if name:
335
 
        return '%s <%s>' % (name, email)
336
 
    else:
337
 
        return email
338
 
 
339
 
 
340
 
def user_email(branch):
341
 
    """Return just the email component of a username."""
342
 
    e = _get_user_id(branch)
343
 
    if e:
344
 
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
345
 
        if not m:
346
 
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
347
 
        return m.group(0)
348
 
 
349
 
    return _auto_user_id()[1]
350
 
    
351
 
 
352
 
 
353
267
def compare_files(a, b):
354
268
    """Returns true if equal in contents"""
355
269
    BUFSIZE = 4096
362
276
            return True
363
277
 
364
278
 
365
 
 
366
279
def local_time_offset(t=None):
367
280
    """Return offset of local zone from GMT, either at present or at time t."""
368
281
    # python2.3 localtime() can't take None
407
320
    """Return size of given open file."""
408
321
    return os.fstat(f.fileno())[ST_SIZE]
409
322
 
410
 
 
411
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
323
# Define rand_bytes based on platform.
 
324
try:
 
325
    # Python 2.4 and later have os.urandom,
 
326
    # but it doesn't work on some arches
 
327
    os.urandom(1)
412
328
    rand_bytes = os.urandom
413
 
elif sys.platform == 'linux2':
414
 
    rand_bytes = file('/dev/urandom', 'rb').read
415
 
else:
416
 
    # not well seeded, but better than nothing
417
 
    def rand_bytes(n):
418
 
        import random
419
 
        s = ''
420
 
        while n:
421
 
            s += chr(random.randint(0, 255))
422
 
            n -= 1
423
 
        return s
424
 
 
 
329
except (NotImplementedError, AttributeError):
 
330
    # If python doesn't have os.urandom, or it doesn't work,
 
331
    # then try to first pull random data from /dev/urandom
 
332
    if os.path.exists("/dev/urandom"):
 
333
        rand_bytes = file('/dev/urandom', 'rb').read
 
334
    # Otherwise, use this hack as a last resort
 
335
    else:
 
336
        # not well seeded, but better than nothing
 
337
        def rand_bytes(n):
 
338
            import random
 
339
            s = ''
 
340
            while n:
 
341
                s += chr(random.randint(0, 255))
 
342
                n -= 1
 
343
            return s
425
344
 
426
345
## TODO: We could later have path objects that remember their list
427
346
## decomposition (might be too tricksy though.)
473
392
        return os.path.join(p1, p2)
474
393
    
475
394
 
476
 
def extern_command(cmd, ignore_errors = False):
477
 
    mutter('external command: %s' % `cmd`)
478
 
    if os.system(cmd):
479
 
        if not ignore_errors:
480
 
            raise BzrError('command failed')
481
 
 
482
 
 
483
 
def _read_config_value(name):
484
 
    """Read a config value from the file ~/.bzr.conf/<name>
485
 
    Return None if the file does not exist"""
486
 
    try:
487
 
        f = file(os.path.join(config_dir(), name), "r")
488
 
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
489
 
    except IOError, e:
490
 
        if e.errno == errno.ENOENT:
491
 
            return None
492
 
        raise
493
 
 
494
 
 
495
 
def _get_editor():
496
 
    """Return a sequence of possible editor binaries for the current platform"""
497
 
    e = _read_config_value("editor")
498
 
    if e is not None:
499
 
        yield e
500
 
        
501
 
    if os.name == "windows":
502
 
        yield "notepad.exe"
503
 
    elif os.name == "posix":
504
 
        try:
505
 
            yield os.environ["EDITOR"]
506
 
        except KeyError:
507
 
            yield "/usr/bin/vi"
508
 
 
509
 
 
510
 
def _run_editor(filename):
511
 
    """Try to execute an editor to edit the commit message. Returns True on success,
512
 
    False on failure"""
513
 
    for e in _get_editor():
514
 
        x = os.spawnvp(os.P_WAIT, e, (e, filename))
515
 
        if x == 0:
516
 
            return True
517
 
        elif x == 127:
518
 
            continue
519
 
        else:
520
 
            break
521
 
    raise BzrError("Could not start any editor. Please specify $EDITOR or use ~/.bzr.conf/editor")
522
 
    return False
523
 
                          
524
 
 
525
 
def get_text_message(infotext, ignoreline = "default"):
526
 
    import tempfile
527
 
    
528
 
    if ignoreline == "default":
529
 
        ignoreline = "-- This line and the following will be ignored --"
530
 
        
531
 
    try:
532
 
        tmp_fileno, msgfilename = tempfile.mkstemp()
533
 
        msgfile = os.close(tmp_fileno)
534
 
        if infotext is not None and infotext != "":
535
 
            hasinfo = True
536
 
            msgfile = file(msgfilename, "w")
537
 
            msgfile.write("\n\n%s\n\n%s" % (ignoreline, infotext))
538
 
            msgfile.close()
539
 
        else:
540
 
            hasinfo = False
541
 
 
542
 
        if not _run_editor(msgfilename):
543
 
            return None
544
 
        
545
 
        started = False
546
 
        msg = []
547
 
        lastline, nlines = 0, 0
548
 
        for line in file(msgfilename, "r"):
549
 
            stripped_line = line.strip()
550
 
            # strip empty line before the log message starts
551
 
            if not started:
552
 
                if stripped_line != "":
553
 
                    started = True
554
 
                else:
555
 
                    continue
556
 
            # check for the ignore line only if there
557
 
            # is additional information at the end
558
 
            if hasinfo and stripped_line == ignoreline:
559
 
                break
560
 
            nlines += 1
561
 
            # keep track of the last line that had some content
562
 
            if stripped_line != "":
563
 
                lastline = nlines
564
 
            msg.append(line)
565
 
            
566
 
        if len(msg) == 0:
567
 
            return None
568
 
        # delete empty lines at the end
569
 
        del msg[lastline:]
570
 
        # add a newline at the end, if needed
571
 
        if not msg[-1].endswith("\n"):
572
 
            return "%s%s" % ("".join(msg), "\n")
573
 
        else:
574
 
            return "".join(msg)
575
 
    finally:
576
 
        # delete the msg file in any case
577
 
        try: os.unlink(msgfilename)
578
 
        except IOError: pass
 
395
def split_lines(s):
 
396
    """Split s into lines, but without removing the newline characters."""
 
397
    return StringIO(s).readlines()
 
398
 
 
399
 
 
400
def hardlinks_good():
 
401
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
402
 
 
403
 
 
404
def link_or_copy(src, dest):
 
405
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
406
    if not hardlinks_good():
 
407
        copyfile(src, dest)
 
408
        return
 
409
    try:
 
410
        os.link(src, dest)
 
411
    except (OSError, IOError), e:
 
412
        if e.errno != errno.EXDEV:
 
413
            raise
 
414
        copyfile(src, dest)
 
415
 
 
416
 
 
417
def has_symlinks():
 
418
    if hasattr(os, 'symlink'):
 
419
        return True
 
420
    else:
 
421
        return False