« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 177
- compare with another revision
- download diff
- download tarball
- view history from revision 177
- Committer: mbp at sourcefrog
- Date: 2005-04-06 02:20:40 UTC
- Revision ID: mbp@sourcefrog.net-20050406022039-dfbff590495c81193a32fd8b
- better output from test.sh- test.sh exercises cat command (currently broken)
- files added:
- bzrlib/tests.py
- files removed:
- .rsyncexclude
- bzrlib/selftest
- contrib
- contrib/bash
- contrib/plugins
- contrib/plugins/changeset
- contrib/zsh
- patches
- urlgrabber
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
from sets import Set
19
18
20
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
21
import traceback, socket, fnmatch, difflib, time
20
22
from binascii import hexlify
22
24
import bzrlib
23
25
from inventory import Inventory
24
26
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
27
from tree import Tree, EmptyTree, RevisionTree, WorkingTree
26
28
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
29
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, chomp, \
28
30
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
joinpath, sha_file, sha_string, file_kind, local_time_offset, appendpath
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
30
32
from store import ImmutableStore
31
33
from revision import Revision
32
from errors import BzrError
34
from errors import bailout
33
35
from textui import show_status
36
from diff import diff_trees
34
37
35
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
36
39
## TODO: Maybe include checks for common corruption of newlines, etc?
37
40
38
41
39
42
40
def find_branch(f, **args):
41
if f and (f.startswith('http://') or f.startswith('https://')):
42
import remotebranch
43
return remotebranch.RemoteBranch(f, **args)
44
else:
45
return Branch(f, **args)
46
47
48
49
def _relpath(base, path):
50
"""Return path relative to base, or raise exception.
51
52
The path may be either an absolute path or a path relative to the
53
current working directory.
54
55
Lifted out of Branch.relpath for ease of testing.
56
57
os.path.commonprefix (python2.4) has a bad bug that it works just
58
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
59
avoids that problem."""
60
rp = os.path.abspath(path)
61
62
s = []
63
head = rp
64
while len(head) >= len(base):
65
if head == base:
66
break
67
head, tail = os.path.split(head)
68
if tail:
69
s.insert(0, tail)
70
else:
71
from errors import NotBranchError
72
raise NotBranchError("path %r is not within branch %r" % (rp, base))
73
74
return os.sep.join(s)
75
76
77
43
def find_branch_root(f=None):
78
44
"""Find the branch root enclosing f, or pwd.
79
45
80
f may be a filename or a URL.
81
82
46
It is not necessary that f exists.
83
47
84
48
Basically we keep looking up until we find the control directory or
85
49
run into the root."""
86
if f == None:
50
if f is None:
87
51
f = os.getcwd()
88
52
elif hasattr(os.path, 'realpath'):
89
53
f = os.path.realpath(f)
90
54
else:
91
55
f = os.path.abspath(f)
92
if not os.path.exists(f):
93
raise BzrError('%r does not exist' % f)
94
95
56
96
57
orig_f = f
97
58
59
last_f = f
98
60
while True:
99
61
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
100
62
return f
101
63
head, tail = os.path.split(f)
102
64
if head == f:
103
65
# reached the root, whatever that may be
104
raise BzrError('%r is not in a branch' % orig_f)
66
bailout('%r is not in a branch' % orig_f)
105
67
f = head
106
68
107
class DivergedBranches(Exception):
108
def __init__(self, branch1, branch2):
109
self.branch1 = branch1
110
self.branch2 = branch2
111
Exception.__init__(self, "These branches have diverged.")
112
113
114
class NoSuchRevision(BzrError):
115
def __init__(self, branch, revision):
116
self.branch = branch
117
self.revision = revision
118
msg = "Branch %s has no revision %d" % (branch, revision)
119
BzrError.__init__(self, msg)
120
69
121
70
122
71
######################################################################
123
72
# branch objects
124
73
125
class Branch(object):
74
class Branch:
126
75
"""Branch holding a history of revisions.
127
76
128
base
129
Base directory of the branch.
130
131
_lock_mode
132
None, or 'r' or 'w'
133
134
_lock_count
135
If _lock_mode is true, a positive count of the number of times the
136
lock has been taken.
137
138
_lock
139
Lock object from bzrlib.lock.
77
:todo: Perhaps use different stores for different classes of object,
78
so that we can keep track of how much space each one uses,
79
or garbage-collect them.
80
81
:todo: Add a RemoteBranch subclass. For the basic case of read-only
82
HTTP access this should be very easy by,
83
just redirecting controlfile access into HTTP requests.
84
We would need a RemoteStore working similarly.
85
86
:todo: Keep the on-disk branch locked while the object exists.
87
88
:todo: mkdir() method.
140
89
"""
141
base = None
142
_lock_mode = None
143
_lock_count = None
144
_lock = None
145
146
90
def __init__(self, base, init=False, find_root=True):
147
91
"""Create new branch object at a particular location.
148
92
149
base -- Base directory for the branch.
93
:param base: Base directory for the branch.
150
94
151
init -- If True, create new control files in a previously
95
:param init: If True, create new control files in a previously
152
96
unversioned directory. If False, the branch must already
153
97
be versioned.
154
98
155
find_root -- If true and init is false, find the root of the
99
:param find_root: If true and init is false, find the root of the
156
100
existing branch containing base.
157
101
158
102
In the test suite, creation of new trees is tested using the
166
110
else:
167
111
self.base = os.path.realpath(base)
168
112
if not isdir(self.controlfilename('.')):
169
from errors import NotBranchError
170
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
171
['use "bzr init" to initialize a new working tree',
172
'current bzr can only operate from top-of-tree'])
113
bailout("not a bzr branch: %s" % quotefn(base),
114
['use "bzr init" to initialize a new working tree',
115
'current bzr can only operate from top-of-tree'])
173
116
self._check_format()
174
117
175
118
self.text_store = ImmutableStore(self.controlfilename('text-store'))
184
127
__repr__ = __str__
185
128
186
129
187
def __del__(self):
188
if self._lock_mode or self._lock:
189
from warnings import warn
190
warn("branch %r was not explicitly unlocked" % self)
191
self._lock.unlock()
192
193
194
195
def lock_write(self):
196
if self._lock_mode:
197
if self._lock_mode != 'w':
198
from errors import LockError
199
raise LockError("can't upgrade to a write lock from %r" %
200
self._lock_mode)
201
self._lock_count += 1
202
else:
203
from bzrlib.lock import WriteLock
204
205
self._lock = WriteLock(self.controlfilename('branch-lock'))
206
self._lock_mode = 'w'
207
self._lock_count = 1
208
209
210
211
def lock_read(self):
212
if self._lock_mode:
213
assert self._lock_mode in ('r', 'w'), \
214
"invalid lock mode %r" % self._lock_mode
215
self._lock_count += 1
216
else:
217
from bzrlib.lock import ReadLock
218
219
self._lock = ReadLock(self.controlfilename('branch-lock'))
220
self._lock_mode = 'r'
221
self._lock_count = 1
222
223
224
225
def unlock(self):
226
if not self._lock_mode:
227
from errors import LockError
228
raise LockError('branch %r is not locked' % (self))
229
230
if self._lock_count > 1:
231
self._lock_count -= 1
232
else:
233
self._lock.unlock()
234
self._lock = None
235
self._lock_mode = self._lock_count = None
236
237
238
130
def abspath(self, name):
239
131
"""Return absolute filename for something in the branch"""
240
132
return os.path.join(self.base, name)
244
136
"""Return path relative to this branch of something inside it.
245
137
246
138
Raises an error if path is not in this branch."""
247
return _relpath(self.base, path)
139
rp = os.path.realpath(path)
140
# FIXME: windows
141
if not rp.startswith(self.base):
142
bailout("path %r is not within branch %r" % (rp, self.base))
143
rp = rp[len(self.base):]
144
rp = rp.lstrip(os.sep)
145
return rp
248
146
249
147
250
148
def controlfilename(self, file_or_path):
255
153
256
154
257
155
def controlfile(self, file_or_path, mode='r'):
258
"""Open a control file for this branch.
259
260
There are two classes of file in the control directory: text
261
and binary. binary files are untranslated byte streams. Text
262
control files are stored with Unix newlines and in UTF-8, even
263
if the platform or locale defaults are different.
264
265
Controlfiles should almost never be opened in write mode but
266
rather should be atomically copied and replaced using atomicfile.
267
"""
268
269
fn = self.controlfilename(file_or_path)
270
271
if mode == 'rb' or mode == 'wb':
272
return file(fn, mode)
273
elif mode == 'r' or mode == 'w':
274
# open in binary mode anyhow so there's no newline translation;
275
# codecs uses line buffering by default; don't want that.
276
import codecs
277
return codecs.open(fn, mode + 'b', 'utf-8',
278
buffering=60000)
279
else:
280
raise BzrError("invalid controlfile mode %r" % mode)
281
156
"""Open a control file for this branch"""
157
return file(self.controlfilename(file_or_path), mode)
282
158
283
159
284
160
def _make_control(self):
285
161
os.mkdir(self.controlfilename([]))
286
162
self.controlfile('README', 'w').write(
287
163
"This is a Bazaar-NG control directory.\n"
288
"Do not change any files in this directory.\n")
289
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
164
"Do not change any files in this directory.")
165
self.controlfile('branch-format', 'wb').write(BZR_BRANCH_FORMAT)
290
166
for d in ('text-store', 'inventory-store', 'revision-store'):
291
167
os.mkdir(self.controlfilename(d))
292
168
for f in ('revision-history', 'merged-patches',
293
'pending-merged-patches', 'branch-name',
294
'branch-lock'):
169
'pending-merged-patches', 'branch-name'):
295
170
self.controlfile(f, 'w').write('')
296
171
mutter('created control directory in ' + self.base)
297
172
Inventory().write_xml(self.controlfile('inventory','w'))
308
183
# This ignores newlines so that we can open branches created
309
184
# on Windows from Linux and so on. I think it might be better
310
185
# to always make all internal files in unix format.
311
fmt = self.controlfile('branch-format', 'r').read()
186
fmt = self.controlfile('branch-format', 'rb').read()
312
187
fmt.replace('\r\n', '')
313
188
if fmt != BZR_BRANCH_FORMAT:
314
raise BzrError('sorry, branch format %r not supported' % fmt,
315
['use a different bzr version',
316
'or remove the .bzr directory and "bzr init" again'])
317
189
bailout('sorry, branch format %r not supported' % fmt,
190
['use a different bzr version',
191
'or remove the .bzr directory and "bzr init" again'])
318
192
319
193
320
194
def read_working_inventory(self):
321
195
"""Read the working inventory."""
322
196
before = time.time()
323
# ElementTree does its own conversion from UTF-8, so open in
324
# binary.
325
self.lock_read()
326
try:
327
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
328
mutter("loaded inventory of %d items in %f"
329
% (len(inv), time.time() - before))
330
return inv
331
finally:
332
self.unlock()
333
197
inv = Inventory.read_xml(self.controlfile('inventory', 'r'))
198
mutter("loaded inventory of %d items in %f"
199
% (len(inv), time.time() - before))
200
return inv
201
334
202
335
203
def _write_inventory(self, inv):
336
204
"""Update the working inventory.
341
209
## TODO: factor out to atomicfile? is rename safe on windows?
342
210
## TODO: Maybe some kind of clean/dirty marker on inventory?
343
211
tmpfname = self.controlfilename('inventory.tmp')
344
tmpf = file(tmpfname, 'wb')
212
tmpf = file(tmpfname, 'w')
345
213
inv.write_xml(tmpf)
346
214
tmpf.close()
347
215
inv_fname = self.controlfilename('inventory')
349
217
os.remove(inv_fname)
350
218
os.rename(tmpfname, inv_fname)
351
219
mutter('wrote working inventory')
352
220
353
221
354
222
inventory = property(read_working_inventory, _write_inventory, None,
355
223
"""Inventory for the working copy.""")
356
224
357
225
358
def add(self, files, verbose=False, ids=None):
226
def add(self, files, verbose=False):
359
227
"""Make files versioned.
360
228
361
Note that the command line normally calls smart_add instead.
362
363
229
This puts the files in the Added state, so that they will be
364
230
recorded by the next commit.
365
231
366
files
367
List of paths to add, relative to the base of the tree.
368
369
ids
370
If set, use these instead of automatically generated ids.
371
Must be the same length as the list of files, but may
372
contain None for ids that are to be autogenerated.
373
374
TODO: Perhaps have an option to add the ids even if the files do
375
not (yet) exist.
376
377
TODO: Perhaps return the ids of the files? But then again it
378
is easy to retrieve them if they're needed.
379
380
TODO: Adding a directory should optionally recurse down and
381
add all non-ignored children. Perhaps do that in a
382
higher-level method.
232
:todo: Perhaps have an option to add the ids even if the files do
233
not (yet) exist.
234
235
:todo: Perhaps return the ids of the files? But then again it
236
is easy to retrieve them if they're needed.
237
238
:todo: Option to specify file id.
239
240
:todo: Adding a directory should optionally recurse down and
241
add all non-ignored children. Perhaps do that in a
242
higher-level method.
243
244
>>> b = ScratchBranch(files=['foo'])
245
>>> 'foo' in b.unknowns()
246
True
247
>>> b.show_status()
248
? foo
249
>>> b.add('foo')
250
>>> 'foo' in b.unknowns()
251
False
252
>>> bool(b.inventory.path2id('foo'))
253
True
254
>>> b.show_status()
255
A foo
256
257
>>> b.add('foo')
258
Traceback (most recent call last):
259
...
260
BzrError: ('foo is already versioned', [])
261
262
>>> b.add(['nothere'])
263
Traceback (most recent call last):
264
BzrError: ('cannot add: not a regular file or directory: nothere', [])
383
265
"""
266
384
267
# TODO: Re-adding a file that is removed in the working copy
385
268
# should probably put it back with the previous ID.
386
269
if isinstance(files, types.StringTypes):
387
assert(ids is None or isinstance(ids, types.StringTypes))
388
270
files = [files]
389
if ids is not None:
390
ids = [ids]
391
392
if ids is None:
393
ids = [None] * len(files)
394
else:
395
assert(len(ids) == len(files))
396
397
self.lock_write()
398
try:
399
inv = self.read_working_inventory()
400
for f,file_id in zip(files, ids):
401
if is_control_file(f):
402
raise BzrError("cannot add control file %s" % quotefn(f))
403
404
fp = splitpath(f)
405
406
if len(fp) == 0:
407
raise BzrError("cannot add top-level %r" % f)
408
409
fullpath = os.path.normpath(self.abspath(f))
410
411
try:
412
kind = file_kind(fullpath)
413
except OSError:
414
# maybe something better?
415
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
416
417
if kind != 'file' and kind != 'directory':
418
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
419
420
if file_id is None:
421
file_id = gen_file_id(f)
422
inv.add_path(f, kind=kind, file_id=file_id)
423
424
if verbose:
425
show_status('A', kind, quotefn(f))
426
427
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
428
429
self._write_inventory(inv)
430
finally:
431
self.unlock()
432
271
272
inv = self.read_working_inventory()
273
for f in files:
274
if is_control_file(f):
275
bailout("cannot add control file %s" % quotefn(f))
276
277
fp = splitpath(f)
278
279
if len(fp) == 0:
280
bailout("cannot add top-level %r" % f)
281
282
fullpath = os.path.normpath(self.abspath(f))
283
284
try:
285
kind = file_kind(fullpath)
286
except OSError:
287
# maybe something better?
288
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
289
290
if kind != 'file' and kind != 'directory':
291
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
292
293
file_id = gen_file_id(f)
294
inv.add_path(f, kind=kind, file_id=file_id)
295
296
if verbose:
297
show_status('A', kind, quotefn(f))
298
299
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
300
301
self._write_inventory(inv)
302
433
303
434
304
def print_file(self, file, revno):
435
305
"""Print `file` to stdout."""
436
self.lock_read()
437
try:
438
tree = self.revision_tree(self.lookup_revision(revno))
439
# use inventory as it was in that revision
440
file_id = tree.inventory.path2id(file)
441
if not file_id:
442
raise BzrError("%r is not present in revision %d" % (file, revno))
443
tree.print_file(file_id)
444
finally:
445
self.unlock()
446
306
tree = self.revision_tree(self.lookup_revision(revno))
307
tree.print_file(self.inventory.path2id(file))
308
447
309
448
310
def remove(self, files, verbose=False):
449
311
"""Mark nominated files for removal from the inventory.
450
312
451
313
This does not remove their text. This does not run on
452
314
453
TODO: Refuse to remove modified files unless --force is given?
454
455
TODO: Do something useful with directories.
456
457
TODO: Should this remove the text or not? Tough call; not
315
:todo: Refuse to remove modified files unless --force is given?
316
317
>>> b = ScratchBranch(files=['foo'])
318
>>> b.add('foo')
319
>>> b.inventory.has_filename('foo')
320
True
321
>>> b.remove('foo')
322
>>> b.working_tree().has_filename('foo')
323
True
324
>>> b.inventory.has_filename('foo')
325
False
326
327
>>> b = ScratchBranch(files=['foo'])
328
>>> b.add('foo')
329
>>> b.commit('one')
330
>>> b.remove('foo')
331
>>> b.commit('two')
332
>>> b.inventory.has_filename('foo')
333
False
334
>>> b.basis_tree().has_filename('foo')
335
False
336
>>> b.working_tree().has_filename('foo')
337
True
338
339
:todo: Do something useful with directories.
340
341
:todo: Should this remove the text or not? Tough call; not
458
342
removing may be useful and the user can just use use rm, and
459
343
is the opposite of add. Removing it is consistent with most
460
344
other tools. Maybe an option.
461
345
"""
462
346
## TODO: Normalize names
463
347
## TODO: Remove nested loops; better scalability
348
464
349
if isinstance(files, types.StringTypes):
465
350
files = [files]
466
467
self.lock_write()
468
469
try:
470
tree = self.working_tree()
471
inv = tree.inventory
472
473
# do this before any modifications
474
for f in files:
475
fid = inv.path2id(f)
476
if not fid:
477
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
478
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
479
if verbose:
480
# having remove it, it must be either ignored or unknown
481
if tree.is_ignored(f):
482
new_status = 'I'
483
else:
484
new_status = '?'
485
show_status(new_status, inv[fid].kind, quotefn(f))
486
del inv[fid]
487
488
self._write_inventory(inv)
489
finally:
490
self.unlock()
491
492
493
# FIXME: this doesn't need to be a branch method
494
def set_inventory(self, new_inventory_list):
495
inv = Inventory()
496
for path, file_id, parent, kind in new_inventory_list:
497
name = os.path.basename(path)
498
if name == "":
499
continue
500
inv.add(InventoryEntry(file_id, name, kind, parent))
351
352
tree = self.working_tree()
353
inv = tree.inventory
354
355
# do this before any modifications
356
for f in files:
357
fid = inv.path2id(f)
358
if not fid:
359
bailout("cannot remove unversioned file %s" % quotefn(f))
360
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
361
if verbose:
362
# having remove it, it must be either ignored or unknown
363
if tree.is_ignored(f):
364
new_status = 'I'
365
else:
366
new_status = '?'
367
show_status(new_status, inv[fid].kind, quotefn(f))
368
del inv[fid]
369
501
370
self._write_inventory(inv)
502
371
503
372
520
389
return self.working_tree().unknowns()
521
390
522
391
523
def append_revision(self, revision_id):
524
mutter("add {%s} to revision-history" % revision_id)
525
rev_history = self.revision_history()
526
527
tmprhname = self.controlfilename('revision-history.tmp')
528
rhname = self.controlfilename('revision-history')
529
530
f = file(tmprhname, 'wt')
531
rev_history.append(revision_id)
532
f.write('\n'.join(rev_history))
533
f.write('\n')
392
def commit(self, message, timestamp=None, timezone=None,
393
committer=None,
394
verbose=False):
395
"""Commit working copy as a new revision.
396
397
The basic approach is to add all the file texts into the
398
store, then the inventory, then make a new revision pointing
399
to that inventory and store that.
400
401
This is not quite safe if the working copy changes during the
402
commit; for the moment that is simply not allowed. A better
403
approach is to make a temporary copy of the files before
404
computing their hashes, and then add those hashes in turn to
405
the inventory. This should mean at least that there are no
406
broken hash pointers. There is no way we can get a snapshot
407
of the whole directory at an instant. This would also have to
408
be robust against files disappearing, moving, etc. So the
409
whole thing is a bit hard.
410
411
:param timestamp: if not None, seconds-since-epoch for a
412
postdated/predated commit.
413
"""
414
415
## TODO: Show branch names
416
417
# TODO: Don't commit if there are no changes, unless forced?
418
419
# First walk over the working inventory; and both update that
420
# and also build a new revision inventory. The revision
421
# inventory needs to hold the text-id, sha1 and size of the
422
# actual file versions committed in the revision. (These are
423
# not present in the working inventory.) We also need to
424
# detect missing/deleted files, and remove them from the
425
# working inventory.
426
427
work_inv = self.read_working_inventory()
428
inv = Inventory()
429
basis = self.basis_tree()
430
basis_inv = basis.inventory
431
missing_ids = []
432
for path, entry in work_inv.iter_entries():
433
## TODO: Cope with files that have gone missing.
434
435
## TODO: Check that the file kind has not changed from the previous
436
## revision of this file (if any).
437
438
entry = entry.copy()
439
440
p = self.abspath(path)
441
file_id = entry.file_id
442
mutter('commit prep file %s, id %r ' % (p, file_id))
443
444
if not os.path.exists(p):
445
mutter(" file is missing, removing from inventory")
446
if verbose:
447
show_status('D', entry.kind, quotefn(path))
448
missing_ids.append(file_id)
449
continue
450
451
# TODO: Handle files that have been deleted
452
453
# TODO: Maybe a special case for empty files? Seems a
454
# waste to store them many times.
455
456
inv.add(entry)
457
458
if basis_inv.has_id(file_id):
459
old_kind = basis_inv[file_id].kind
460
if old_kind != entry.kind:
461
bailout("entry %r changed kind from %r to %r"
462
% (file_id, old_kind, entry.kind))
463
464
if entry.kind == 'directory':
465
if not isdir(p):
466
bailout("%s is entered as directory but not a directory" % quotefn(p))
467
elif entry.kind == 'file':
468
if not isfile(p):
469
bailout("%s is entered as file but is not a file" % quotefn(p))
470
471
content = file(p, 'rb').read()
472
473
entry.text_sha1 = sha_string(content)
474
entry.text_size = len(content)
475
476
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
477
if (old_ie
478
and (old_ie.text_size == entry.text_size)
479
and (old_ie.text_sha1 == entry.text_sha1)):
480
## assert content == basis.get_file(file_id).read()
481
entry.text_id = basis_inv[file_id].text_id
482
mutter(' unchanged from previous text_id {%s}' %
483
entry.text_id)
484
485
else:
486
entry.text_id = gen_file_id(entry.name)
487
self.text_store.add(content, entry.text_id)
488
mutter(' stored with text_id {%s}' % entry.text_id)
489
if verbose:
490
if not old_ie:
491
state = 'A'
492
elif (old_ie.name == entry.name
493
and old_ie.parent_id == entry.parent_id):
494
state = 'M'
495
else:
496
state = 'R'
497
498
show_status(state, entry.kind, quotefn(path))
499
500
for file_id in missing_ids:
501
# have to do this later so we don't mess up the iterator.
502
# since parents may be removed before their children we
503
# have to test.
504
505
# FIXME: There's probably a better way to do this; perhaps
506
# the workingtree should know how to filter itself.
507
if work_inv.has_id(file_id):
508
del work_inv[file_id]
509
510
511
inv_id = rev_id = _gen_revision_id(time.time())
512
513
inv_tmp = tempfile.TemporaryFile()
514
inv.write_xml(inv_tmp)
515
inv_tmp.seek(0)
516
self.inventory_store.add(inv_tmp, inv_id)
517
mutter('new inventory_id is {%s}' % inv_id)
518
519
self._write_inventory(work_inv)
520
521
if timestamp == None:
522
timestamp = time.time()
523
524
if committer == None:
525
committer = username()
526
527
if timezone == None:
528
timezone = local_time_offset()
529
530
mutter("building commit log message")
531
rev = Revision(timestamp=timestamp,
532
timezone=timezone,
533
committer=committer,
534
precursor = self.last_patch(),
535
message = message,
536
inventory_id=inv_id,
537
revision_id=rev_id)
538
539
rev_tmp = tempfile.TemporaryFile()
540
rev.write_xml(rev_tmp)
541
rev_tmp.seek(0)
542
self.revision_store.add(rev_tmp, rev_id)
543
mutter("new revision_id is {%s}" % rev_id)
544
545
## XXX: Everything up to here can simply be orphaned if we abort
546
## the commit; it will leave junk files behind but that doesn't
547
## matter.
548
549
## TODO: Read back the just-generated changeset, and make sure it
550
## applies and recreates the right state.
551
552
## TODO: Also calculate and store the inventory SHA1
553
mutter("committing patch r%d" % (self.revno() + 1))
554
555
mutter("append to revision-history")
556
f = self.controlfile('revision-history', 'at')
557
f.write(rev_id + '\n')
534
558
f.close()
535
559
536
if sys.platform == 'win32':
537
os.remove(rhname)
538
os.rename(tmprhname, rhname)
539
560
if verbose:
561
note("commited r%d" % self.revno())
540
562
541
563
542
564
def get_revision(self, revision_id):
543
565
"""Return the Revision object for a named revision"""
544
if not revision_id or not isinstance(revision_id, basestring):
545
raise ValueError('invalid revision-id: %r' % revision_id)
546
566
r = Revision.read_xml(self.revision_store[revision_id])
547
567
assert r.revision_id == revision_id
548
568
return r
549
569
550
def get_revision_sha1(self, revision_id):
551
"""Hash the stored value of a revision, and return it."""
552
# In the future, revision entries will be signed. At that
553
# point, it is probably best *not* to include the signature
554
# in the revision hash. Because that lets you re-sign
555
# the revision, (add signatures/remove signatures) and still
556
# have all hash pointers stay consistent.
557
# But for now, just hash the contents.
558
return sha_file(self.revision_store[revision_id])
559
560
570
561
571
def get_inventory(self, inventory_id):
562
572
"""Get Inventory object by hash.
563
573
564
TODO: Perhaps for this and similar methods, take a revision
574
:todo: Perhaps for this and similar methods, take a revision
565
575
parameter which can be either an integer revno or a
566
576
string hash."""
567
577
i = Inventory.read_xml(self.inventory_store[inventory_id])
568
578
return i
569
579
570
def get_inventory_sha1(self, inventory_id):
571
"""Return the sha1 hash of the inventory entry
572
"""
573
return sha_file(self.inventory_store[inventory_id])
574
575
580
576
581
def get_revision_inventory(self, revision_id):
577
582
"""Return inventory of a past revision."""
587
592
>>> ScratchBranch().revision_history()
588
593
[]
589
594
"""
590
self.lock_read()
591
try:
592
return [l.rstrip('\r\n') for l in
593
self.controlfile('revision-history', 'r').readlines()]
594
finally:
595
self.unlock()
596
597
598
def common_ancestor(self, other, self_revno=None, other_revno=None):
599
"""
600
>>> import commit
601
>>> sb = ScratchBranch(files=['foo', 'foo~'])
602
>>> sb.common_ancestor(sb) == (None, None)
603
True
604
>>> commit.commit(sb, "Committing first revision", verbose=False)
605
>>> sb.common_ancestor(sb)[0]
606
1
607
>>> clone = sb.clone()
608
>>> commit.commit(sb, "Committing second revision", verbose=False)
609
>>> sb.common_ancestor(sb)[0]
610
2
611
>>> sb.common_ancestor(clone)[0]
612
1
613
>>> commit.commit(clone, "Committing divergent second revision",
614
... verbose=False)
615
>>> sb.common_ancestor(clone)[0]
616
1
617
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
618
True
619
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
620
True
621
>>> clone2 = sb.clone()
622
>>> sb.common_ancestor(clone2)[0]
623
2
624
>>> sb.common_ancestor(clone2, self_revno=1)[0]
625
1
626
>>> sb.common_ancestor(clone2, other_revno=1)[0]
627
1
628
"""
629
my_history = self.revision_history()
630
other_history = other.revision_history()
631
if self_revno is None:
632
self_revno = len(my_history)
633
if other_revno is None:
634
other_revno = len(other_history)
635
indices = range(min((self_revno, other_revno)))
636
indices.reverse()
637
for r in indices:
638
if my_history[r] == other_history[r]:
639
return r+1, my_history[r]
640
return None, None
641
642
def enum_history(self, direction):
643
"""Return (revno, revision_id) for history of branch.
644
645
direction
646
'forward' is from earliest to latest
647
'reverse' is from latest to earliest
648
"""
649
rh = self.revision_history()
650
if direction == 'forward':
651
i = 1
652
for rid in rh:
653
yield i, rid
654
i += 1
655
elif direction == 'reverse':
656
i = len(rh)
657
while i > 0:
658
yield i, rh[i-1]
659
i -= 1
660
else:
661
raise ValueError('invalid history direction', direction)
595
return [chomp(l) for l in self.controlfile('revision-history').readlines()]
662
596
663
597
664
598
def revno(self):
666
600
667
601
That is equivalent to the number of revisions committed to
668
602
this branch.
603
604
>>> b = ScratchBranch()
605
>>> b.revno()
606
0
607
>>> b.commit('no foo')
608
>>> b.revno()
609
1
669
610
"""
670
611
return len(self.revision_history())
671
612
672
613
673
614
def last_patch(self):
674
615
"""Return last patch hash, or None if no history.
616
617
>>> ScratchBranch().last_patch() == None
618
True
675
619
"""
676
620
ph = self.revision_history()
677
621
if ph:
678
622
return ph[-1]
679
else:
680
return None
681
682
683
def missing_revisions(self, other, stop_revision=None):
684
"""
685
If self and other have not diverged, return a list of the revisions
686
present in other, but missing from self.
687
688
>>> from bzrlib.commit import commit
689
>>> bzrlib.trace.silent = True
690
>>> br1 = ScratchBranch()
691
>>> br2 = ScratchBranch()
692
>>> br1.missing_revisions(br2)
693
[]
694
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
695
>>> br1.missing_revisions(br2)
696
[u'REVISION-ID-1']
697
>>> br2.missing_revisions(br1)
698
[]
699
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
700
>>> br1.missing_revisions(br2)
701
[]
702
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
703
>>> br1.missing_revisions(br2)
704
[u'REVISION-ID-2A']
705
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
706
>>> br1.missing_revisions(br2)
707
Traceback (most recent call last):
708
DivergedBranches: These branches have diverged.
709
"""
710
self_history = self.revision_history()
711
self_len = len(self_history)
712
other_history = other.revision_history()
713
other_len = len(other_history)
714
common_index = min(self_len, other_len) -1
715
if common_index >= 0 and \
716
self_history[common_index] != other_history[common_index]:
717
raise DivergedBranches(self, other)
718
719
if stop_revision is None:
720
stop_revision = other_len
721
elif stop_revision > other_len:
722
raise NoSuchRevision(self, stop_revision)
723
724
return other_history[self_len:stop_revision]
725
726
727
def update_revisions(self, other, stop_revision=None):
728
"""Pull in all new revisions from other branch.
729
730
>>> from bzrlib.commit import commit
731
>>> bzrlib.trace.silent = True
732
>>> br1 = ScratchBranch(files=['foo', 'bar'])
733
>>> br1.add('foo')
734
>>> br1.add('bar')
735
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
736
>>> br2 = ScratchBranch()
737
>>> br2.update_revisions(br1)
738
Added 2 texts.
739
Added 1 inventories.
740
Added 1 revisions.
741
>>> br2.revision_history()
742
[u'REVISION-ID-1']
743
>>> br2.update_revisions(br1)
744
Added 0 texts.
745
Added 0 inventories.
746
Added 0 revisions.
747
>>> br1.text_store.total_size() == br2.text_store.total_size()
748
True
749
"""
750
from bzrlib.progress import ProgressBar
751
752
pb = ProgressBar()
753
754
pb.update('comparing histories')
755
revision_ids = self.missing_revisions(other, stop_revision)
756
revisions = []
757
needed_texts = sets.Set()
758
i = 0
759
for rev_id in revision_ids:
760
i += 1
761
pb.update('fetching revision', i, len(revision_ids))
762
rev = other.get_revision(rev_id)
763
revisions.append(rev)
764
inv = other.get_inventory(str(rev.inventory_id))
765
for key, entry in inv.iter_entries():
766
if entry.text_id is None:
767
continue
768
if entry.text_id not in self.text_store:
769
needed_texts.add(entry.text_id)
770
771
pb.clear()
772
773
count = self.text_store.copy_multi(other.text_store, needed_texts)
774
print "Added %d texts." % count
775
inventory_ids = [ f.inventory_id for f in revisions ]
776
count = self.inventory_store.copy_multi(other.inventory_store,
777
inventory_ids)
778
print "Added %d inventories." % count
779
revision_ids = [ f.revision_id for f in revisions]
780
count = self.revision_store.copy_multi(other.revision_store,
781
revision_ids)
782
for revision_id in revision_ids:
783
self.append_revision(revision_id)
784
print "Added %d revisions." % count
785
786
787
def commit(self, *args, **kw):
788
"""Deprecated"""
789
from bzrlib.commit import commit
790
commit(self, *args, **kw)
791
623
792
624
793
625
def lookup_revision(self, revno):
794
626
"""Return revision hash for revision number."""
799
631
# list is 0-based; revisions are 1-based
800
632
return self.revision_history()[revno-1]
801
633
except IndexError:
802
raise BzrError("no such revision %s" % revno)
634
bailout("no such revision %s" % revno)
803
635
804
636
805
637
def revision_tree(self, revision_id):
807
639
808
640
`revision_id` may be None for the null revision, in which case
809
641
an `EmptyTree` is returned."""
810
# TODO: refactor this to use an existing revision object
811
# so we don't need to read it in twice.
642
812
643
if revision_id == None:
813
644
return EmptyTree()
814
645
else:
818
649
819
650
def working_tree(self):
820
651
"""Return a `Tree` for the working copy."""
821
from workingtree import WorkingTree
822
652
return WorkingTree(self.base, self.read_working_inventory())
823
653
824
654
826
656
"""Return `Tree` object for last revision.
827
657
828
658
If there are no revisions yet, return an `EmptyTree`.
659
660
>>> b = ScratchBranch(files=['foo'])
661
>>> b.basis_tree().has_filename('foo')
662
False
663
>>> b.working_tree().has_filename('foo')
664
True
665
>>> b.add('foo')
666
>>> b.commit('add foo')
667
>>> b.basis_tree().has_filename('foo')
668
True
829
669
"""
830
670
r = self.last_patch()
831
671
if r == None:
835
675
836
676
837
677
678
def write_log(self, show_timezone='original'):
679
"""Write out human-readable log of commits to this branch
680
681
:param utc: If true, show dates in universal time, not local time."""
682
## TODO: Option to choose either original, utc or local timezone
683
revno = 1
684
precursor = None
685
for p in self.revision_history():
686
print '-' * 40
687
print 'revno:', revno
688
## TODO: Show hash if --id is given.
689
##print 'revision-hash:', p
690
rev = self.get_revision(p)
691
print 'committer:', rev.committer
692
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
693
show_timezone))
694
695
## opportunistic consistency check, same as check_patch_chaining
696
if rev.precursor != precursor:
697
bailout("mismatched precursor!")
698
699
print 'message:'
700
if not rev.message:
701
print ' (no message)'
702
else:
703
for l in rev.message.split('\n'):
704
print ' ' + l
705
706
revno += 1
707
precursor = p
708
709
838
710
def rename_one(self, from_rel, to_rel):
839
"""Rename one file.
840
841
This can change the directory or the filename or both.
842
"""
843
self.lock_write()
711
tree = self.working_tree()
712
inv = tree.inventory
713
if not tree.has_filename(from_rel):
714
bailout("can't rename: old working file %r does not exist" % from_rel)
715
if tree.has_filename(to_rel):
716
bailout("can't rename: new working file %r already exists" % to_rel)
717
718
file_id = inv.path2id(from_rel)
719
if file_id == None:
720
bailout("can't rename: old name %r is not versioned" % from_rel)
721
722
if inv.path2id(to_rel):
723
bailout("can't rename: new name %r is already versioned" % to_rel)
724
725
to_dir, to_tail = os.path.split(to_rel)
726
to_dir_id = inv.path2id(to_dir)
727
if to_dir_id == None and to_dir != '':
728
bailout("can't determine destination directory id for %r" % to_dir)
729
730
mutter("rename_one:")
731
mutter(" file_id {%s}" % file_id)
732
mutter(" from_rel %r" % from_rel)
733
mutter(" to_rel %r" % to_rel)
734
mutter(" to_dir %r" % to_dir)
735
mutter(" to_dir_id {%s}" % to_dir_id)
736
737
inv.rename(file_id, to_dir_id, to_tail)
738
739
print "%s => %s" % (from_rel, to_rel)
740
741
from_abs = self.abspath(from_rel)
742
to_abs = self.abspath(to_rel)
844
743
try:
845
tree = self.working_tree()
846
inv = tree.inventory
847
if not tree.has_filename(from_rel):
848
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
849
if tree.has_filename(to_rel):
850
raise BzrError("can't rename: new working file %r already exists" % to_rel)
851
852
file_id = inv.path2id(from_rel)
853
if file_id == None:
854
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
855
856
if inv.path2id(to_rel):
857
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
858
859
to_dir, to_tail = os.path.split(to_rel)
860
to_dir_id = inv.path2id(to_dir)
861
if to_dir_id == None and to_dir != '':
862
raise BzrError("can't determine destination directory id for %r" % to_dir)
863
864
mutter("rename_one:")
865
mutter(" file_id {%s}" % file_id)
866
mutter(" from_rel %r" % from_rel)
867
mutter(" to_rel %r" % to_rel)
868
mutter(" to_dir %r" % to_dir)
869
mutter(" to_dir_id {%s}" % to_dir_id)
870
871
inv.rename(file_id, to_dir_id, to_tail)
872
873
print "%s => %s" % (from_rel, to_rel)
874
875
from_abs = self.abspath(from_rel)
876
to_abs = self.abspath(to_rel)
877
try:
878
os.rename(from_abs, to_abs)
879
except OSError, e:
880
raise BzrError("failed to rename %r to %r: %s"
881
% (from_abs, to_abs, e[1]),
882
["rename rolled back"])
883
884
self._write_inventory(inv)
885
finally:
886
self.unlock()
744
os.rename(from_abs, to_abs)
745
except OSError, e:
746
bailout("failed to rename %r to %r: %s"
747
% (from_abs, to_abs, e[1]),
748
["rename rolled back"])
749
750
self._write_inventory(inv)
751
887
752
888
753
889
754
def move(self, from_paths, to_name):
897
762
Note that to_name is only the last component of the new name;
898
763
this doesn't change the directory.
899
764
"""
900
self.lock_write()
901
try:
902
## TODO: Option to move IDs only
903
assert not isinstance(from_paths, basestring)
904
tree = self.working_tree()
905
inv = tree.inventory
906
to_abs = self.abspath(to_name)
907
if not isdir(to_abs):
908
raise BzrError("destination %r is not a directory" % to_abs)
909
if not tree.has_filename(to_name):
910
raise BzrError("destination %r not in working directory" % to_abs)
911
to_dir_id = inv.path2id(to_name)
912
if to_dir_id == None and to_name != '':
913
raise BzrError("destination %r is not a versioned directory" % to_name)
914
to_dir_ie = inv[to_dir_id]
915
if to_dir_ie.kind not in ('directory', 'root_directory'):
916
raise BzrError("destination %r is not a directory" % to_abs)
917
918
to_idpath = inv.get_idpath(to_dir_id)
919
920
for f in from_paths:
921
if not tree.has_filename(f):
922
raise BzrError("%r does not exist in working tree" % f)
923
f_id = inv.path2id(f)
924
if f_id == None:
925
raise BzrError("%r is not versioned" % f)
926
name_tail = splitpath(f)[-1]
927
dest_path = appendpath(to_name, name_tail)
928
if tree.has_filename(dest_path):
929
raise BzrError("destination %r already exists" % dest_path)
930
if f_id in to_idpath:
931
raise BzrError("can't move %r to a subdirectory of itself" % f)
932
933
# OK, so there's a race here, it's possible that someone will
934
# create a file in this interval and then the rename might be
935
# left half-done. But we should have caught most problems.
936
937
for f in from_paths:
938
name_tail = splitpath(f)[-1]
939
dest_path = appendpath(to_name, name_tail)
940
print "%s => %s" % (f, dest_path)
941
inv.rename(inv.path2id(f), to_dir_id, name_tail)
942
try:
943
os.rename(self.abspath(f), self.abspath(dest_path))
944
except OSError, e:
945
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
946
["rename rolled back"])
947
948
self._write_inventory(inv)
949
finally:
950
self.unlock()
951
765
## TODO: Option to move IDs only
766
assert not isinstance(from_paths, basestring)
767
tree = self.working_tree()
768
inv = tree.inventory
769
to_abs = self.abspath(to_name)
770
if not isdir(to_abs):
771
bailout("destination %r is not a directory" % to_abs)
772
if not tree.has_filename(to_name):
773
bailout("destination %r not in working directory" % to_abs)
774
to_dir_id = inv.path2id(to_name)
775
if to_dir_id == None and to_name != '':
776
bailout("destination %r is not a versioned directory" % to_name)
777
to_dir_ie = inv[to_dir_id]
778
if to_dir_ie.kind not in ('directory', 'root_directory'):
779
bailout("destination %r is not a directory" % to_abs)
780
781
to_idpath = Set(inv.get_idpath(to_dir_id))
782
783
for f in from_paths:
784
if not tree.has_filename(f):
785
bailout("%r does not exist in working tree" % f)
786
f_id = inv.path2id(f)
787
if f_id == None:
788
bailout("%r is not versioned" % f)
789
name_tail = splitpath(f)[-1]
790
dest_path = appendpath(to_name, name_tail)
791
if tree.has_filename(dest_path):
792
bailout("destination %r already exists" % dest_path)
793
if f_id in to_idpath:
794
bailout("can't move %r to a subdirectory of itself" % f)
795
796
# OK, so there's a race here, it's possible that someone will
797
# create a file in this interval and then the rename might be
798
# left half-done. But we should have caught most problems.
799
800
for f in from_paths:
801
name_tail = splitpath(f)[-1]
802
dest_path = appendpath(to_name, name_tail)
803
print "%s => %s" % (f, dest_path)
804
inv.rename(inv.path2id(f), to_dir_id, name_tail)
805
try:
806
os.rename(self.abspath(f), self.abspath(dest_path))
807
except OSError, e:
808
bailout("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
809
["rename rolled back"])
810
811
self._write_inventory(inv)
812
813
814
815
def show_status(branch, show_all=False):
816
"""Display single-line status for non-ignored working files.
817
818
The list is show sorted in order by file name.
819
820
>>> b = ScratchBranch(files=['foo', 'foo~'])
821
>>> b.show_status()
822
? foo
823
>>> b.add('foo')
824
>>> b.show_status()
825
A foo
826
>>> b.commit("add foo")
827
>>> b.show_status()
828
>>> os.unlink(b.abspath('foo'))
829
>>> b.show_status()
830
D foo
831
832
833
:todo: Get state for single files.
834
835
:todo: Perhaps show a slash at the end of directory names.
836
837
"""
838
839
# We have to build everything into a list first so that it can
840
# sorted by name, incorporating all the different sources.
841
842
# FIXME: Rather than getting things in random order and then sorting,
843
# just step through in order.
844
845
# Interesting case: the old ID for a file has been removed,
846
# but a new file has been created under that name.
847
848
old = branch.basis_tree()
849
old_inv = old.inventory
850
new = branch.working_tree()
851
new_inv = new.inventory
852
853
for fs, fid, oldname, newname, kind in diff_trees(old, new):
854
if fs == 'R':
855
show_status(fs, kind,
856
oldname + ' => ' + newname)
857
elif fs == 'A' or fs == 'M':
858
show_status(fs, kind, newname)
859
elif fs == 'D':
860
show_status(fs, kind, oldname)
861
elif fs == '.':
862
if show_all:
863
show_status(fs, kind, newname)
864
elif fs == 'I':
865
if show_all:
866
show_status(fs, kind, newname)
867
elif fs == '?':
868
show_status(fs, kind, newname)
869
else:
870
bailout("wierd file state %r" % ((fs, fid),))
871
952
872
953
873
954
874
class ScratchBranch(Branch):
958
878
>>> isdir(b.base)
959
879
True
960
880
>>> bd = b.base
961
>>> b.destroy()
881
>>> del b
962
882
>>> isdir(bd)
963
883
False
964
884
"""
965
def __init__(self, files=[], dirs=[], base=None):
885
def __init__(self, files=[], dirs=[]):
966
886
"""Make a test branch.
967
887
968
888
This creates a temporary directory and runs init-tree in it.
969
889
970
890
If any files are listed, they are created in the working copy.
971
891
"""
972
init = False
973
if base is None:
974
base = tempfile.mkdtemp()
975
init = True
976
Branch.__init__(self, base, init=init)
892
Branch.__init__(self, tempfile.mkdtemp(), init=True)
977
893
for d in dirs:
978
894
os.mkdir(self.abspath(d))
979
895
981
897
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
982
898
983
899
984
def clone(self):
985
"""
986
>>> orig = ScratchBranch(files=["file1", "file2"])
987
>>> clone = orig.clone()
988
>>> os.path.samefile(orig.base, clone.base)
989
False
990
>>> os.path.isfile(os.path.join(clone.base, "file1"))
991
True
992
"""
993
base = tempfile.mkdtemp()
994
os.rmdir(base)
995
shutil.copytree(self.base, base, symlinks=True)
996
return ScratchBranch(base=base)
997
998
900
def __del__(self):
999
self.destroy()
1000
1001
def destroy(self):
1002
901
"""Destroy the test branch, removing the scratch directory."""
1003
902
try:
1004
if self.base:
1005
mutter("delete ScratchBranch %s" % self.base)
1006
shutil.rmtree(self.base)
1007
except OSError, e:
903
shutil.rmtree(self.base)
904
except OSError:
1008
905
# Work around for shutil.rmtree failing on Windows when
1009
906
# readonly files are encountered
1010
mutter("hit exception in destroying ScratchBranch: %s" % e)
1011
907
for root, dirs, files in os.walk(self.base, topdown=False):
1012
908
for name in files:
1013
909
os.chmod(os.path.join(root, name), 0700)
1014
910
shutil.rmtree(self.base)
1015
self.base = None
1016
911
1017
912
1018
913
1035
930
1036
931
1037
932
933
def _gen_revision_id(when):
934
"""Return new revision-id."""
935
s = '%s-%s-' % (user_email(), compact_date(when))
936
s += hexlify(rand_bytes(12))
937
return s
938
939
1038
940
def gen_file_id(name):
1039
941
"""Return new file id.
1040
942
1041
943
This should probably generate proper UUIDs, but for the moment we
1042
944
cope with just randomness because running uuidgen every time is
1043
945
slow."""
1044
import re
1045
1046
# get last component
1047
946
idx = name.rfind('/')
1048
947
if idx != -1:
1049
948
name = name[idx+1 : ]
1050
idx = name.rfind('\\')
1051
if idx != -1:
1052
name = name[idx+1 : ]
1053
949
1054
# make it not a hidden file
1055
950
name = name.lstrip('.')
1056
951
1057
# remove any wierd characters; we don't escape them but rather
1058
# just pull them out
1059
name = re.sub(r'[^\w.]', '', name)
1060
1061
s = hexlify(rand_bytes(8))
952
s = hexlify(rand_bytes(12))
1062
953
return '-'.join((name, compact_date(time.time()), s))
954
955
Loggerhead is a web-based interface for Breezy
Version: 2.0.1