« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 647
- compare with another revision
- download diff
- download tarball
- view history from revision 647
- Committer: Martin Pool
- Date: 2005-06-10 06:34:26 UTC
- Revision ID: mbp@sourcefrog.net-20050610063426-cfcf5c0f96c271ec
- split out updated progress indicator
- files removed:
- bzrlib/meta_store.py
- bzrlib/selftest
- effbot
- effbot/org
- plugins
- plugins/changeset
- plugins/rsync
- files renamed:
- bzrlib/selftest/__init__.py => bzrlib/selftest.py
- bzrlib/selftest/whitebox.py => bzrlib/whitebox.py
- files modified:
- NEWS
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
import sys, os
18
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
import traceback, socket, fnmatch, difflib, time
20
from binascii import hexlify
19
21
20
22
import bzrlib
21
from bzrlib.trace import mutter, note
22
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, splitpath, \
23
sha_file, appendpath, file_kind
24
from bzrlib.errors import BzrError
23
from inventory import Inventory
24
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
26
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
28
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
joinpath, sha_string, file_kind, local_time_offset, appendpath
30
from store import ImmutableStore
31
from revision import Revision
32
from errors import BzrError
33
from textui import show_status
25
34
26
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
27
36
## TODO: Maybe include checks for common corruption of newlines, etc?
36
45
return Branch(f, **args)
37
46
38
47
39
def find_cached_branch(f, cache_root, **args):
40
from remotebranch import RemoteBranch
41
br = find_branch(f, **args)
42
def cacheify(br, store_name):
43
from meta_store import CachedStore
44
cache_path = os.path.join(cache_root, store_name)
45
os.mkdir(cache_path)
46
new_store = CachedStore(getattr(br, store_name), cache_path)
47
setattr(br, store_name, new_store)
48
49
if isinstance(br, RemoteBranch):
50
cacheify(br, 'inventory_store')
51
cacheify(br, 'text_store')
52
cacheify(br, 'revision_store')
53
return br
54
55
48
56
49
def _relpath(base, path):
57
50
"""Return path relative to base, or raise exception.
117
110
self.branch2 = branch2
118
111
Exception.__init__(self, "These branches have diverged.")
119
112
120
121
class NoSuchRevision(BzrError):
122
def __init__(self, branch, revision):
123
self.branch = branch
124
self.revision = revision
125
msg = "Branch %s has no revision %d" % (branch, revision)
126
BzrError.__init__(self, msg)
127
128
129
113
######################################################################
130
114
# branch objects
131
115
165
149
In the test suite, creation of new trees is tested using the
166
150
`ScratchBranch` class.
167
151
"""
168
from bzrlib.store import ImmutableStore
169
152
if init:
170
153
self.base = os.path.realpath(base)
171
154
self._make_control()
257
240
258
241
def controlfilename(self, file_or_path):
259
242
"""Return location relative to branch."""
260
if isinstance(file_or_path, basestring):
243
if isinstance(file_or_path, types.StringTypes):
261
244
file_or_path = [file_or_path]
262
245
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
263
246
290
273
291
274
292
275
def _make_control(self):
293
from bzrlib.inventory import Inventory
294
from bzrlib.xml import pack_xml
295
296
276
os.mkdir(self.controlfilename([]))
297
277
self.controlfile('README', 'w').write(
298
278
"This is a Bazaar-NG control directory.\n"
299
"Do not change any files in this directory.\n")
279
"Do not change any files in this directory.")
300
280
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
301
281
for d in ('text-store', 'inventory-store', 'revision-store'):
302
282
os.mkdir(self.controlfilename(d))
305
285
'branch-lock'):
306
286
self.controlfile(f, 'w').write('')
307
287
mutter('created control directory in ' + self.base)
308
309
pack_xml(Inventory(), self.controlfile('inventory','w'))
288
Inventory().write_xml(self.controlfile('inventory','w'))
310
289
311
290
312
291
def _check_format(self):
331
310
332
311
def read_working_inventory(self):
333
312
"""Read the working inventory."""
334
from bzrlib.inventory import Inventory
335
from bzrlib.xml import unpack_xml
336
from time import time
337
before = time()
313
before = time.time()
314
# ElementTree does its own conversion from UTF-8, so open in
315
# binary.
338
316
self.lock_read()
339
317
try:
340
# ElementTree does its own conversion from UTF-8, so open in
341
# binary.
342
inv = unpack_xml(Inventory,
343
self.controlfile('inventory', 'rb'))
318
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
344
319
mutter("loaded inventory of %d items in %f"
345
% (len(inv), time() - before))
320
% (len(inv), time.time() - before))
346
321
return inv
347
322
finally:
348
323
self.unlock()
354
329
That is to say, the inventory describing changes underway, that
355
330
will be committed to the next revision.
356
331
"""
357
from bzrlib.atomicfile import AtomicFile
358
from bzrlib.xml import pack_xml
359
360
self.lock_write()
361
try:
362
f = AtomicFile(self.controlfilename('inventory'), 'wb')
363
try:
364
pack_xml(inv, f)
365
f.commit()
366
finally:
367
f.close()
368
finally:
369
self.unlock()
370
332
## TODO: factor out to atomicfile? is rename safe on windows?
333
## TODO: Maybe some kind of clean/dirty marker on inventory?
334
tmpfname = self.controlfilename('inventory.tmp')
335
tmpf = file(tmpfname, 'wb')
336
inv.write_xml(tmpf)
337
tmpf.close()
338
inv_fname = self.controlfilename('inventory')
339
if sys.platform == 'win32':
340
os.remove(inv_fname)
341
os.rename(tmpfname, inv_fname)
371
342
mutter('wrote working inventory')
372
343
373
344
401
372
add all non-ignored children. Perhaps do that in a
402
373
higher-level method.
403
374
"""
404
from bzrlib.textui import show_status
405
375
# TODO: Re-adding a file that is removed in the working copy
406
376
# should probably put it back with the previous ID.
407
if isinstance(files, basestring):
408
assert(ids is None or isinstance(ids, basestring))
377
if isinstance(files, types.StringTypes):
378
assert(ids is None or isinstance(ids, types.StringTypes))
409
379
files = [files]
410
380
if ids is not None:
411
381
ids = [ids]
443
413
inv.add_path(f, kind=kind, file_id=file_id)
444
414
445
415
if verbose:
446
print 'added', quotefn(f)
416
show_status('A', kind, quotefn(f))
447
417
448
418
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
449
419
480
450
is the opposite of add. Removing it is consistent with most
481
451
other tools. Maybe an option.
482
452
"""
483
from bzrlib.textui import show_status
484
453
## TODO: Normalize names
485
454
## TODO: Remove nested loops; better scalability
486
if isinstance(files, basestring):
455
if isinstance(files, types.StringTypes):
487
456
files = [files]
488
457
489
458
self.lock_write()
514
483
515
484
# FIXME: this doesn't need to be a branch method
516
485
def set_inventory(self, new_inventory_list):
517
from bzrlib.inventory import Inventory, InventoryEntry
518
486
inv = Inventory()
519
487
for path, file_id, parent, kind in new_inventory_list:
520
488
name = os.path.basename(path)
544
512
545
513
546
514
def append_revision(self, revision_id):
547
from bzrlib.atomicfile import AtomicFile
548
549
515
mutter("add {%s} to revision-history" % revision_id)
550
rev_history = self.revision_history() + [revision_id]
551
552
f = AtomicFile(self.controlfilename('revision-history'))
553
try:
554
for rev_id in rev_history:
555
print >>f, rev_id
556
f.commit()
557
finally:
558
f.close()
516
rev_history = self.revision_history()
517
518
tmprhname = self.controlfilename('revision-history.tmp')
519
rhname = self.controlfilename('revision-history')
520
521
f = file(tmprhname, 'wt')
522
rev_history.append(revision_id)
523
f.write('\n'.join(rev_history))
524
f.write('\n')
525
f.close()
526
527
if sys.platform == 'win32':
528
os.remove(rhname)
529
os.rename(tmprhname, rhname)
530
559
531
560
532
561
533
def get_revision(self, revision_id):
562
534
"""Return the Revision object for a named revision"""
563
from bzrlib.revision import Revision
564
from bzrlib.xml import unpack_xml
565
566
self.lock_read()
567
try:
568
if not revision_id or not isinstance(revision_id, basestring):
569
raise ValueError('invalid revision-id: %r' % revision_id)
570
r = unpack_xml(Revision, self.revision_store[revision_id])
571
finally:
572
self.unlock()
573
535
r = Revision.read_xml(self.revision_store[revision_id])
574
536
assert r.revision_id == revision_id
575
537
return r
576
577
578
def get_revision_sha1(self, revision_id):
579
"""Hash the stored value of a revision, and return it."""
580
# In the future, revision entries will be signed. At that
581
# point, it is probably best *not* to include the signature
582
# in the revision hash. Because that lets you re-sign
583
# the revision, (add signatures/remove signatures) and still
584
# have all hash pointers stay consistent.
585
# But for now, just hash the contents.
586
return sha_file(self.revision_store[revision_id])
587
538
588
539
589
540
def get_inventory(self, inventory_id):
592
543
TODO: Perhaps for this and similar methods, take a revision
593
544
parameter which can be either an integer revno or a
594
545
string hash."""
595
from bzrlib.inventory import Inventory
596
from bzrlib.xml import unpack_xml
597
598
return unpack_xml(Inventory, self.inventory_store[inventory_id])
599
600
601
def get_inventory_sha1(self, inventory_id):
602
"""Return the sha1 hash of the inventory entry
603
"""
604
return sha_file(self.inventory_store[inventory_id])
546
i = Inventory.read_xml(self.inventory_store[inventory_id])
547
return i
605
548
606
549
607
550
def get_revision_inventory(self, revision_id):
608
551
"""Return inventory of a past revision."""
609
552
if revision_id == None:
610
from bzrlib.inventory import Inventory
611
553
return Inventory()
612
554
else:
613
555
return self.get_inventory(self.get_revision(revision_id).inventory_id)
712
654
return None
713
655
714
656
715
def missing_revisions(self, other, stop_revision=None):
657
def missing_revisions(self, other):
716
658
"""
717
659
If self and other have not diverged, return a list of the revisions
718
660
present in other, but missing from self.
747
689
if common_index >= 0 and \
748
690
self_history[common_index] != other_history[common_index]:
749
691
raise DivergedBranches(self, other)
750
751
if stop_revision is None:
752
stop_revision = other_len
753
elif stop_revision > other_len:
754
raise NoSuchRevision(self, stop_revision)
755
756
return other_history[self_len:stop_revision]
757
758
759
def update_revisions(self, other, stop_revision=None):
760
"""Pull in all new revisions from other branch.
761
692
if self_len < other_len:
693
return other_history[self_len:]
694
return []
695
696
697
def update_revisions(self, other):
698
"""If self and other have not diverged, ensure self has all the
699
revisions in other
700
762
701
>>> from bzrlib.commit import commit
763
702
>>> bzrlib.trace.silent = True
764
703
>>> br1 = ScratchBranch(files=['foo', 'bar'])
779
718
>>> br1.text_store.total_size() == br2.text_store.total_size()
780
719
True
781
720
"""
782
from bzrlib.progress import ProgressBar
783
try:
784
set
785
except NameError:
786
from sets import Set as set
787
788
pb = ProgressBar()
789
790
pb.update('comparing histories')
791
revision_ids = self.missing_revisions(other, stop_revision)
792
793
if hasattr(other.revision_store, "prefetch"):
794
other.revision_store.prefetch(revision_ids)
795
if hasattr(other.inventory_store, "prefetch"):
796
inventory_ids = [other.get_revision(r).inventory_id
797
for r in revision_ids]
798
other.inventory_store.prefetch(inventory_ids)
799
800
revisions = []
801
needed_texts = set()
802
i = 0
803
for rev_id in revision_ids:
804
i += 1
805
pb.update('fetching revision', i, len(revision_ids))
806
rev = other.get_revision(rev_id)
807
revisions.append(rev)
721
revision_ids = self.missing_revisions(other)
722
revisions = [other.get_revision(f) for f in revision_ids]
723
needed_texts = sets.Set()
724
for rev in revisions:
808
725
inv = other.get_inventory(str(rev.inventory_id))
809
726
for key, entry in inv.iter_entries():
810
727
if entry.text_id is None:
811
728
continue
812
729
if entry.text_id not in self.text_store:
813
730
needed_texts.add(entry.text_id)
814
815
pb.clear()
816
817
731
count = self.text_store.copy_multi(other.text_store, needed_texts)
818
732
print "Added %d texts." % count
819
733
inventory_ids = [ f.inventory_id for f in revisions ]
829
743
830
744
831
745
def commit(self, *args, **kw):
746
"""Deprecated"""
832
747
from bzrlib.commit import commit
833
748
commit(self, *args, **kw)
834
749
850
765
851
766
`revision_id` may be None for the null revision, in which case
852
767
an `EmptyTree` is returned."""
853
from bzrlib.tree import EmptyTree, RevisionTree
854
768
# TODO: refactor this to use an existing revision object
855
769
# so we don't need to read it in twice.
856
770
if revision_id == None:
871
785
872
786
If there are no revisions yet, return an `EmptyTree`.
873
787
"""
874
from bzrlib.tree import EmptyTree, RevisionTree
875
788
r = self.last_patch()
876
789
if r == None:
877
790
return EmptyTree()
995
908
self.unlock()
996
909
997
910
998
def revert(self, filenames, old_tree=None, backups=True):
999
"""Restore selected files to the versions from a previous tree.
1000
1001
backups
1002
If true (default) backups are made of files before
1003
they're renamed.
1004
"""
1005
from bzrlib.errors import NotVersionedError, BzrError
1006
from bzrlib.atomicfile import AtomicFile
1007
from bzrlib.osutils import backup_file
1008
1009
inv = self.read_working_inventory()
1010
if old_tree is None:
1011
old_tree = self.basis_tree()
1012
old_inv = old_tree.inventory
1013
1014
nids = []
1015
for fn in filenames:
1016
file_id = inv.path2id(fn)
1017
if not file_id:
1018
raise NotVersionedError("not a versioned file", fn)
1019
if not old_inv.has_id(file_id):
1020
raise BzrError("file not present in old tree", fn, file_id)
1021
nids.append((fn, file_id))
1022
1023
# TODO: Rename back if it was previously at a different location
1024
1025
# TODO: If given a directory, restore the entire contents from
1026
# the previous version.
1027
1028
# TODO: Make a backup to a temporary file.
1029
1030
# TODO: If the file previously didn't exist, delete it?
1031
for fn, file_id in nids:
1032
backup_file(fn)
1033
1034
f = AtomicFile(fn, 'wb')
1035
try:
1036
f.write(old_tree.get_file(file_id).read())
1037
f.commit()
1038
finally:
1039
f.close()
1040
1041
1042
911
1043
912
class ScratchBranch(Branch):
1044
913
"""Special test class: a branch that cleans up after itself.
1058
927
1059
928
If any files are listed, they are created in the working copy.
1060
929
"""
1061
from tempfile import mkdtemp
1062
930
init = False
1063
931
if base is None:
1064
base = mkdtemp()
932
base = tempfile.mkdtemp()
1065
933
init = True
1066
934
Branch.__init__(self, base, init=init)
1067
935
for d in dirs:
1080
948
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1081
949
True
1082
950
"""
1083
from shutil import copytree
1084
from tempfile import mkdtemp
1085
base = mkdtemp()
951
base = tempfile.mkdtemp()
1086
952
os.rmdir(base)
1087
copytree(self.base, base, symlinks=True)
953
shutil.copytree(self.base, base, symlinks=True)
1088
954
return ScratchBranch(base=base)
1089
955
1090
956
def __del__(self):
1092
958
1093
959
def destroy(self):
1094
960
"""Destroy the test branch, removing the scratch directory."""
1095
from shutil import rmtree
1096
961
try:
1097
962
if self.base:
1098
963
mutter("delete ScratchBranch %s" % self.base)
1099
rmtree(self.base)
964
shutil.rmtree(self.base)
1100
965
except OSError, e:
1101
966
# Work around for shutil.rmtree failing on Windows when
1102
967
# readonly files are encountered
1104
969
for root, dirs, files in os.walk(self.base, topdown=False):
1105
970
for name in files:
1106
971
os.chmod(os.path.join(root, name), 0700)
1107
rmtree(self.base)
972
shutil.rmtree(self.base)
1108
973
self.base = None
1109
974
1110
975
1135
1000
cope with just randomness because running uuidgen every time is
1136
1001
slow."""
1137
1002
import re
1138
from binascii import hexlify
1139
from time import time
1140
1003
1141
1004
# get last component
1142
1005
idx = name.rfind('/')
1154
1017
name = re.sub(r'[^\w.]', '', name)
1155
1018
1156
1019
s = hexlify(rand_bytes(8))
1157
return '-'.join((name, compact_date(time()), s))
1020
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1