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