« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 306
- compare with another revision
- download diff
- download tarball
- view history from revision 306
- Committer: Martin Pool
- Date: 2005-04-28 09:48:35 UTC
- Revision ID: mbp@sourcefrog.net-20050428094835-14efc14a297e1835
testbzr: test renames
- files added:
- bzrlib/tests.py
- files removed:
- bzrlib/atomicfile.py
- contrib
- contrib/bash
- contrib/zsh
- patches
- 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
31
joinpath, sha_string, file_kind, local_time_offset, appendpath
30
32
from store import ImmutableStore
31
33
from revision import Revision
32
34
from errors import bailout, BzrError
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
43
def find_branch_root(f=None):
49
44
"""Find the branch root enclosing f, or pwd.
50
45
51
f may be a filename or a URL.
52
53
46
It is not necessary that f exists.
54
47
55
48
Basically we keep looking up until we find the control directory or
60
53
f = os.path.realpath(f)
61
54
else:
62
55
f = os.path.abspath(f)
63
if not os.path.exists(f):
64
raise BzrError('%r does not exist' % f)
65
66
56
67
57
orig_f = f
68
58
80
70
######################################################################
81
71
# branch objects
82
72
83
class Branch(object):
73
class Branch:
84
74
"""Branch holding a history of revisions.
85
75
86
base
87
Base directory of the branch.
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.
88
88
"""
89
_lockmode = None
90
base = None
91
92
def __init__(self, base, init=False, find_root=True, lock_mode='w'):
89
def __init__(self, base, init=False, find_root=True):
93
90
"""Create new branch object at a particular location.
94
91
95
92
base -- Base directory for the branch.
116
113
['use "bzr init" to initialize a new working tree',
117
114
'current bzr can only operate from top-of-tree'])
118
115
self._check_format()
119
self.lock(lock_mode)
120
116
121
117
self.text_store = ImmutableStore(self.controlfilename('text-store'))
122
118
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
130
126
__repr__ = __str__
131
127
132
128
133
134
def lock(self, mode='w'):
135
"""Lock the on-disk branch, excluding other processes."""
136
try:
137
import fcntl, errno
138
139
if mode == 'w':
140
lm = fcntl.LOCK_EX
141
om = os.O_WRONLY | os.O_CREAT
142
elif mode == 'r':
143
lm = fcntl.LOCK_SH
144
om = os.O_RDONLY
145
else:
146
raise BzrError("invalid locking mode %r" % mode)
147
148
try:
149
lockfile = os.open(self.controlfilename('branch-lock'), om)
150
except OSError, e:
151
if e.errno == errno.ENOENT:
152
# might not exist on branches from <0.0.4
153
self.controlfile('branch-lock', 'w').close()
154
lockfile = os.open(self.controlfilename('branch-lock'), om)
155
else:
156
raise e
157
158
fcntl.lockf(lockfile, lm)
159
def unlock():
160
fcntl.lockf(lockfile, fcntl.LOCK_UN)
161
os.close(lockfile)
162
self._lockmode = None
163
self.unlock = unlock
164
self._lockmode = mode
165
except ImportError:
166
warning("please write a locking method for platform %r" % sys.platform)
167
def unlock():
168
self._lockmode = None
169
self.unlock = unlock
170
self._lockmode = mode
171
172
173
def _need_readlock(self):
174
if self._lockmode not in ['r', 'w']:
175
raise BzrError('need read lock on branch, only have %r' % self._lockmode)
176
177
def _need_writelock(self):
178
if self._lockmode not in ['w']:
179
raise BzrError('need write lock on branch, only have %r' % self._lockmode)
180
181
182
129
def abspath(self, name):
183
130
"""Return absolute filename for something in the branch"""
184
131
return os.path.join(self.base, name)
211
158
and binary. binary files are untranslated byte streams. Text
212
159
control files are stored with Unix newlines and in UTF-8, even
213
160
if the platform or locale defaults are different.
214
215
Controlfiles should almost never be opened in write mode but
216
rather should be atomically copied and replaced using atomicfile.
217
161
"""
218
162
219
163
fn = self.controlfilename(file_or_path)
240
184
for d in ('text-store', 'inventory-store', 'revision-store'):
241
185
os.mkdir(self.controlfilename(d))
242
186
for f in ('revision-history', 'merged-patches',
243
'pending-merged-patches', 'branch-name',
244
'branch-lock'):
187
'pending-merged-patches', 'branch-name'):
245
188
self.controlfile(f, 'w').write('')
246
189
mutter('created control directory in ' + self.base)
247
190
Inventory().write_xml(self.controlfile('inventory','w'))
268
211
269
212
def read_working_inventory(self):
270
213
"""Read the working inventory."""
271
self._need_readlock()
272
214
before = time.time()
273
215
# ElementTree does its own conversion from UTF-8, so open in
274
216
# binary.
284
226
That is to say, the inventory describing changes underway, that
285
227
will be committed to the next revision.
286
228
"""
287
self._need_writelock()
288
229
## TODO: factor out to atomicfile? is rename safe on windows?
289
230
## TODO: Maybe some kind of clean/dirty marker on inventory?
290
231
tmpfname = self.controlfilename('inventory.tmp')
302
243
"""Inventory for the working copy.""")
303
244
304
245
305
def add(self, files, verbose=False, ids=None):
246
def add(self, files, verbose=False):
306
247
"""Make files versioned.
307
248
308
249
Note that the command line normally calls smart_add instead.
321
262
TODO: Adding a directory should optionally recurse down and
322
263
add all non-ignored children. Perhaps do that in a
323
264
higher-level method.
265
266
>>> b = ScratchBranch(files=['foo'])
267
>>> 'foo' in b.unknowns()
268
True
269
>>> b.show_status()
270
? foo
271
>>> b.add('foo')
272
>>> 'foo' in b.unknowns()
273
False
274
>>> bool(b.inventory.path2id('foo'))
275
True
276
>>> b.show_status()
277
A foo
278
279
>>> b.add('foo')
280
Traceback (most recent call last):
281
...
282
BzrError: ('foo is already versioned', [])
283
284
>>> b.add(['nothere'])
285
Traceback (most recent call last):
286
BzrError: ('cannot add: not a regular file or directory: nothere', [])
324
287
"""
325
self._need_writelock()
326
288
327
289
# TODO: Re-adding a file that is removed in the working copy
328
290
# should probably put it back with the previous ID.
329
291
if isinstance(files, types.StringTypes):
330
assert(ids is None or isinstance(ids, types.StringTypes))
331
292
files = [files]
332
if ids is not None:
333
ids = [ids]
334
335
if ids is None:
336
ids = [None] * len(files)
337
else:
338
assert(len(ids) == len(files))
339
293
340
294
inv = self.read_working_inventory()
341
for f,file_id in zip(files, ids):
295
for f in files:
342
296
if is_control_file(f):
343
297
bailout("cannot add control file %s" % quotefn(f))
344
298
358
312
if kind != 'file' and kind != 'directory':
359
313
bailout('cannot add: not a regular file or directory: %s' % quotefn(f))
360
314
361
if file_id is None:
362
file_id = gen_file_id(f)
315
file_id = gen_file_id(f)
363
316
inv.add_path(f, kind=kind, file_id=file_id)
364
317
365
318
if verbose:
372
325
373
326
def print_file(self, file, revno):
374
327
"""Print `file` to stdout."""
375
self._need_readlock()
376
328
tree = self.revision_tree(self.lookup_revision(revno))
377
329
# use inventory as it was in that revision
378
330
file_id = tree.inventory.path2id(file)
388
340
389
341
TODO: Refuse to remove modified files unless --force is given?
390
342
343
>>> b = ScratchBranch(files=['foo'])
344
>>> b.add('foo')
345
>>> b.inventory.has_filename('foo')
346
True
347
>>> b.remove('foo')
348
>>> b.working_tree().has_filename('foo')
349
True
350
>>> b.inventory.has_filename('foo')
351
False
352
353
>>> b = ScratchBranch(files=['foo'])
354
>>> b.add('foo')
355
>>> b.commit('one')
356
>>> b.remove('foo')
357
>>> b.commit('two')
358
>>> b.inventory.has_filename('foo')
359
False
360
>>> b.basis_tree().has_filename('foo')
361
False
362
>>> b.working_tree().has_filename('foo')
363
True
364
391
365
TODO: Do something useful with directories.
392
366
393
367
TODO: Should this remove the text or not? Tough call; not
397
371
"""
398
372
## TODO: Normalize names
399
373
## TODO: Remove nested loops; better scalability
400
self._need_writelock()
401
374
402
375
if isinstance(files, types.StringTypes):
403
376
files = [files]
422
395
423
396
self._write_inventory(inv)
424
397
425
def set_inventory(self, new_inventory_list):
426
inv = Inventory()
427
for path, file_id, parent, kind in new_inventory_list:
428
name = os.path.basename(path)
429
if name == "":
430
continue
431
inv.add(InventoryEntry(file_id, name, kind, parent))
432
self._write_inventory(inv)
433
434
398
435
399
def unknowns(self):
436
400
"""Return all unknown files.
451
415
return self.working_tree().unknowns()
452
416
453
417
418
def commit(self, message, timestamp=None, timezone=None,
419
committer=None,
420
verbose=False):
421
"""Commit working copy as a new revision.
422
423
The basic approach is to add all the file texts into the
424
store, then the inventory, then make a new revision pointing
425
to that inventory and store that.
426
427
This is not quite safe if the working copy changes during the
428
commit; for the moment that is simply not allowed. A better
429
approach is to make a temporary copy of the files before
430
computing their hashes, and then add those hashes in turn to
431
the inventory. This should mean at least that there are no
432
broken hash pointers. There is no way we can get a snapshot
433
of the whole directory at an instant. This would also have to
434
be robust against files disappearing, moving, etc. So the
435
whole thing is a bit hard.
436
437
timestamp -- if not None, seconds-since-epoch for a
438
postdated/predated commit.
439
"""
440
441
## TODO: Show branch names
442
443
# TODO: Don't commit if there are no changes, unless forced?
444
445
# First walk over the working inventory; and both update that
446
# and also build a new revision inventory. The revision
447
# inventory needs to hold the text-id, sha1 and size of the
448
# actual file versions committed in the revision. (These are
449
# not present in the working inventory.) We also need to
450
# detect missing/deleted files, and remove them from the
451
# working inventory.
452
453
work_inv = self.read_working_inventory()
454
inv = Inventory()
455
basis = self.basis_tree()
456
basis_inv = basis.inventory
457
missing_ids = []
458
for path, entry in work_inv.iter_entries():
459
## TODO: Cope with files that have gone missing.
460
461
## TODO: Check that the file kind has not changed from the previous
462
## revision of this file (if any).
463
464
entry = entry.copy()
465
466
p = self.abspath(path)
467
file_id = entry.file_id
468
mutter('commit prep file %s, id %r ' % (p, file_id))
469
470
if not os.path.exists(p):
471
mutter(" file is missing, removing from inventory")
472
if verbose:
473
show_status('D', entry.kind, quotefn(path))
474
missing_ids.append(file_id)
475
continue
476
477
# TODO: Handle files that have been deleted
478
479
# TODO: Maybe a special case for empty files? Seems a
480
# waste to store them many times.
481
482
inv.add(entry)
483
484
if basis_inv.has_id(file_id):
485
old_kind = basis_inv[file_id].kind
486
if old_kind != entry.kind:
487
bailout("entry %r changed kind from %r to %r"
488
% (file_id, old_kind, entry.kind))
489
490
if entry.kind == 'directory':
491
if not isdir(p):
492
bailout("%s is entered as directory but not a directory" % quotefn(p))
493
elif entry.kind == 'file':
494
if not isfile(p):
495
bailout("%s is entered as file but is not a file" % quotefn(p))
496
497
content = file(p, 'rb').read()
498
499
entry.text_sha1 = sha_string(content)
500
entry.text_size = len(content)
501
502
old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
503
if (old_ie
504
and (old_ie.text_size == entry.text_size)
505
and (old_ie.text_sha1 == entry.text_sha1)):
506
## assert content == basis.get_file(file_id).read()
507
entry.text_id = basis_inv[file_id].text_id
508
mutter(' unchanged from previous text_id {%s}' %
509
entry.text_id)
510
511
else:
512
entry.text_id = gen_file_id(entry.name)
513
self.text_store.add(content, entry.text_id)
514
mutter(' stored with text_id {%s}' % entry.text_id)
515
if verbose:
516
if not old_ie:
517
state = 'A'
518
elif (old_ie.name == entry.name
519
and old_ie.parent_id == entry.parent_id):
520
state = 'M'
521
else:
522
state = 'R'
523
524
show_status(state, entry.kind, quotefn(path))
525
526
for file_id in missing_ids:
527
# have to do this later so we don't mess up the iterator.
528
# since parents may be removed before their children we
529
# have to test.
530
531
# FIXME: There's probably a better way to do this; perhaps
532
# the workingtree should know how to filter itself.
533
if work_inv.has_id(file_id):
534
del work_inv[file_id]
535
536
537
inv_id = rev_id = _gen_revision_id(time.time())
538
539
inv_tmp = tempfile.TemporaryFile()
540
inv.write_xml(inv_tmp)
541
inv_tmp.seek(0)
542
self.inventory_store.add(inv_tmp, inv_id)
543
mutter('new inventory_id is {%s}' % inv_id)
544
545
self._write_inventory(work_inv)
546
547
if timestamp == None:
548
timestamp = time.time()
549
550
if committer == None:
551
committer = username()
552
553
if timezone == None:
554
timezone = local_time_offset()
555
556
mutter("building commit log message")
557
rev = Revision(timestamp=timestamp,
558
timezone=timezone,
559
committer=committer,
560
precursor = self.last_patch(),
561
message = message,
562
inventory_id=inv_id,
563
revision_id=rev_id)
564
565
rev_tmp = tempfile.TemporaryFile()
566
rev.write_xml(rev_tmp)
567
rev_tmp.seek(0)
568
self.revision_store.add(rev_tmp, rev_id)
569
mutter("new revision_id is {%s}" % rev_id)
570
571
## XXX: Everything up to here can simply be orphaned if we abort
572
## the commit; it will leave junk files behind but that doesn't
573
## matter.
574
575
## TODO: Read back the just-generated changeset, and make sure it
576
## applies and recreates the right state.
577
578
## TODO: Also calculate and store the inventory SHA1
579
mutter("committing patch r%d" % (self.revno() + 1))
580
581
582
self.append_revision(rev_id)
583
584
if verbose:
585
note("commited r%d" % self.revno())
586
587
454
588
def append_revision(self, revision_id):
455
589
mutter("add {%s} to revision-history" % revision_id)
456
590
rev_history = self.revision_history()
472
606
473
607
def get_revision(self, revision_id):
474
608
"""Return the Revision object for a named revision"""
475
self._need_readlock()
476
609
r = Revision.read_xml(self.revision_store[revision_id])
477
610
assert r.revision_id == revision_id
478
611
return r
484
617
TODO: Perhaps for this and similar methods, take a revision
485
618
parameter which can be either an integer revno or a
486
619
string hash."""
487
self._need_readlock()
488
620
i = Inventory.read_xml(self.inventory_store[inventory_id])
489
621
return i
490
622
491
623
492
624
def get_revision_inventory(self, revision_id):
493
625
"""Return inventory of a past revision."""
494
self._need_readlock()
495
626
if revision_id == None:
496
627
return Inventory()
497
628
else:
504
635
>>> ScratchBranch().revision_history()
505
636
[]
506
637
"""
507
self._need_readlock()
508
return [l.rstrip('\r\n') for l in self.controlfile('revision-history', 'r').readlines()]
509
510
511
def enum_history(self, direction):
512
"""Return (revno, revision_id) for history of branch.
513
514
direction
515
'forward' is from earliest to latest
516
'reverse' is from latest to earliest
517
"""
518
rh = self.revision_history()
519
if direction == 'forward':
520
i = 1
521
for rid in rh:
522
yield i, rid
523
i += 1
524
elif direction == 'reverse':
525
i = len(rh)
526
while i > 0:
527
yield i, rh[i-1]
528
i -= 1
529
else:
530
raise ValueError('invalid history direction', direction)
638
return [chomp(l) for l in self.controlfile('revision-history', 'r').readlines()]
531
639
532
640
533
641
def revno(self):
535
643
536
644
That is equivalent to the number of revisions committed to
537
645
this branch.
646
647
>>> b = ScratchBranch()
648
>>> b.revno()
649
0
650
>>> b.commit('no foo')
651
>>> b.revno()
652
1
538
653
"""
539
654
return len(self.revision_history())
540
655
541
656
542
657
def last_patch(self):
543
658
"""Return last patch hash, or None if no history.
659
660
>>> ScratchBranch().last_patch() == None
661
True
544
662
"""
545
663
ph = self.revision_history()
546
664
if ph:
547
665
return ph[-1]
548
666
else:
549
667
return None
550
551
552
def commit(self, *args, **kw):
553
"""Deprecated"""
554
from bzrlib.commit import commit
555
commit(self, *args, **kw)
556
668
557
669
558
670
def lookup_revision(self, revno):
572
684
573
685
`revision_id` may be None for the null revision, in which case
574
686
an `EmptyTree` is returned."""
575
# TODO: refactor this to use an existing revision object
576
# so we don't need to read it in twice.
577
self._need_readlock()
687
578
688
if revision_id == None:
579
689
return EmptyTree()
580
690
else:
584
694
585
695
def working_tree(self):
586
696
"""Return a `Tree` for the working copy."""
587
from workingtree import WorkingTree
588
697
return WorkingTree(self.base, self.read_working_inventory())
589
698
590
699
592
701
"""Return `Tree` object for last revision.
593
702
594
703
If there are no revisions yet, return an `EmptyTree`.
704
705
>>> b = ScratchBranch(files=['foo'])
706
>>> b.basis_tree().has_filename('foo')
707
False
708
>>> b.working_tree().has_filename('foo')
709
True
710
>>> b.add('foo')
711
>>> b.commit('add foo')
712
>>> b.basis_tree().has_filename('foo')
713
True
595
714
"""
596
715
r = self.last_patch()
597
716
if r == None:
601
720
602
721
603
722
723
def write_log(self, show_timezone='original', verbose=False):
724
"""Write out human-readable log of commits to this branch
725
726
utc -- If true, show dates in universal time, not local time."""
727
## TODO: Option to choose either original, utc or local timezone
728
revno = 1
729
precursor = None
730
for p in self.revision_history():
731
print '-' * 40
732
print 'revno:', revno
733
## TODO: Show hash if --id is given.
734
##print 'revision-hash:', p
735
rev = self.get_revision(p)
736
print 'committer:', rev.committer
737
print 'timestamp: %s' % (format_date(rev.timestamp, rev.timezone or 0,
738
show_timezone))
739
740
## opportunistic consistency check, same as check_patch_chaining
741
if rev.precursor != precursor:
742
bailout("mismatched precursor!")
743
744
print 'message:'
745
if not rev.message:
746
print ' (no message)'
747
else:
748
for l in rev.message.split('\n'):
749
print ' ' + l
750
751
if verbose == True and precursor != None:
752
print 'changed files:'
753
tree = self.revision_tree(p)
754
prevtree = self.revision_tree(precursor)
755
756
for file_state, fid, old_name, new_name, kind in \
757
diff_trees(prevtree, tree, ):
758
if file_state == 'A' or file_state == 'M':
759
show_status(file_state, kind, new_name)
760
elif file_state == 'D':
761
show_status(file_state, kind, old_name)
762
elif file_state == 'R':
763
show_status(file_state, kind,
764
old_name + ' => ' + new_name)
765
766
revno += 1
767
precursor = p
768
769
604
770
def rename_one(self, from_rel, to_rel):
605
"""Rename one file.
606
607
This can change the directory or the filename or both.
608
"""
609
self._need_writelock()
610
771
tree = self.working_tree()
611
772
inv = tree.inventory
612
773
if not tree.has_filename(from_rel):
661
822
Note that to_name is only the last component of the new name;
662
823
this doesn't change the directory.
663
824
"""
664
self._need_writelock()
665
825
## TODO: Option to move IDs only
666
826
assert not isinstance(from_paths, basestring)
667
827
tree = self.working_tree()
678
838
if to_dir_ie.kind not in ('directory', 'root_directory'):
679
839
bailout("destination %r is not a directory" % to_abs)
680
840
681
to_idpath = inv.get_idpath(to_dir_id)
841
to_idpath = Set(inv.get_idpath(to_dir_id))
682
842
683
843
for f in from_paths:
684
844
if not tree.has_filename(f):
712
872
713
873
714
874
875
def show_status(self, show_all=False):
876
"""Display single-line status for non-ignored working files.
877
878
The list is show sorted in order by file name.
879
880
>>> b = ScratchBranch(files=['foo', 'foo~'])
881
>>> b.show_status()
882
? foo
883
>>> b.add('foo')
884
>>> b.show_status()
885
A foo
886
>>> b.commit("add foo")
887
>>> b.show_status()
888
>>> os.unlink(b.abspath('foo'))
889
>>> b.show_status()
890
D foo
891
892
TODO: Get state for single files.
893
"""
894
895
# We have to build everything into a list first so that it can
896
# sorted by name, incorporating all the different sources.
897
898
# FIXME: Rather than getting things in random order and then sorting,
899
# just step through in order.
900
901
# Interesting case: the old ID for a file has been removed,
902
# but a new file has been created under that name.
903
904
old = self.basis_tree()
905
new = self.working_tree()
906
907
for fs, fid, oldname, newname, kind in diff_trees(old, new):
908
if fs == 'R':
909
show_status(fs, kind,
910
oldname + ' => ' + newname)
911
elif fs == 'A' or fs == 'M':
912
show_status(fs, kind, newname)
913
elif fs == 'D':
914
show_status(fs, kind, oldname)
915
elif fs == '.':
916
if show_all:
917
show_status(fs, kind, newname)
918
elif fs == 'I':
919
if show_all:
920
show_status(fs, kind, newname)
921
elif fs == '?':
922
show_status(fs, kind, newname)
923
else:
924
bailout("weird file state %r" % ((fs, fid),))
925
926
715
927
716
928
class ScratchBranch(Branch):
717
929
"""Special test class: a branch that cleans up after itself.
720
932
>>> isdir(b.base)
721
933
True
722
934
>>> bd = b.base
723
>>> b.destroy()
935
>>> del b
724
936
>>> isdir(bd)
725
937
False
726
938
"""
740
952
741
953
742
954
def __del__(self):
743
self.destroy()
744
745
def destroy(self):
746
955
"""Destroy the test branch, removing the scratch directory."""
747
956
try:
748
mutter("delete ScratchBranch %s" % self.base)
749
957
shutil.rmtree(self.base)
750
except OSError, e:
958
except OSError:
751
959
# Work around for shutil.rmtree failing on Windows when
752
960
# readonly files are encountered
753
mutter("hit exception in destroying ScratchBranch: %s" % e)
754
961
for root, dirs, files in os.walk(self.base, topdown=False):
755
962
for name in files:
756
963
os.chmod(os.path.join(root, name), 0700)
757
964
shutil.rmtree(self.base)
758
self.base = None
759
965
760
966
761
967
778
984
779
985
780
986
987
def _gen_revision_id(when):
988
"""Return new revision-id."""
989
s = '%s-%s-' % (user_email(), compact_date(when))
990
s += hexlify(rand_bytes(8))
991
return s
992
993
781
994
def gen_file_id(name):
782
995
"""Return new file id.
783
996
784
997
This should probably generate proper UUIDs, but for the moment we
785
998
cope with just randomness because running uuidgen every time is
786
999
slow."""
787
import re
788
789
# get last component
790
1000
idx = name.rfind('/')
791
1001
if idx != -1:
792
1002
name = name[idx+1 : ]
794
1004
if idx != -1:
795
1005
name = name[idx+1 : ]
796
1006
797
# make it not a hidden file
798
1007
name = name.lstrip('.')
799
1008
800
# remove any wierd characters; we don't escape them but rather
801
# just pull them out
802
name = re.sub(r'[^\w.]', '', name)
803
804
1009
s = hexlify(rand_bytes(8))
805
1010
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1