« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1393.1.11
- compare with another revision
- download diff
- download tarball
- view history from revision 1393.1.11
- Committer: Martin Pool
- Date: 2005-09-30 00:58:02 UTC
- mto: (1185.14.2)
- mto: This revision was merged to the branch mainline in revision 1396.
- Revision ID: mbp@sourcefrog.net-20050930005802-721cfc318e393817
- copy_branch creates destination if it doesn't exist
- files added:
- NEWS.developers
- files removed:
- bzrlib/upgrade.py
- files renamed:
- tools/testweave.py => bzrlib/selftest/test_weave.py
- tools/history2weaves.py => bzrlib/upgrade.py
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
17
17
18
18
import sys
19
19
import os
20
import errno
21
from warnings import warn
22
20
23
21
24
import bzrlib
22
25
from bzrlib.trace import mutter, note
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
splitpath, \
25
sha_file, appendpath, file_kind
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
28
import bzrlib.errors
26
from bzrlib.osutils import (isdir, quotefn, compact_date, rand_bytes,
27
rename, splitpath, sha_file, appendpath,
28
file_kind)
29
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
30
NoSuchRevision, HistoryMissing, NotBranchError,
31
DivergedBranches, LockError, UnlistableStore,
32
UnlistableBranch)
29
33
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
31
from bzrlib.xml import unpack_xml
34
from bzrlib.revision import Revision, validate_revision_id, is_ancestor
32
35
from bzrlib.delta import compare_trees
33
36
from bzrlib.tree import EmptyTree, RevisionTree
37
from bzrlib.inventory import Inventory
38
from bzrlib.weavestore import WeaveStore
39
from bzrlib.store import copy_all, ImmutableStore
40
import bzrlib.xml5
34
41
import bzrlib.ui
35
42
36
43
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
44
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
45
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
39
46
## TODO: Maybe include checks for common corruption of newlines, etc?
40
47
41
48
42
49
# TODO: Some operations like log might retrieve the same revisions
43
50
# repeatedly to calculate deltas. We could perhaps have a weakref
44
# cache in memory to make this faster.
45
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
48
49
50
def find_branch(f, **args):
51
if f and (f.startswith('http://') or f.startswith('https://')):
52
import remotebranch
53
return remotebranch.RemoteBranch(f, **args)
54
else:
55
return Branch(f, **args)
56
57
58
def find_cached_branch(f, cache_root, **args):
59
from remotebranch import RemoteBranch
60
br = find_branch(f, **args)
61
def cacheify(br, store_name):
62
from meta_store import CachedStore
63
cache_path = os.path.join(cache_root, store_name)
64
os.mkdir(cache_path)
65
new_store = CachedStore(getattr(br, store_name), cache_path)
66
setattr(br, store_name, new_store)
67
68
if isinstance(br, RemoteBranch):
69
cacheify(br, 'inventory_store')
70
cacheify(br, 'text_store')
71
cacheify(br, 'revision_store')
72
return br
73
51
# cache in memory to make this faster. In general anything can be
52
# cached in memory between lock and unlock operations.
53
54
def find_branch(*ignored, **ignored_too):
55
# XXX: leave this here for about one release, then remove it
56
raise NotImplementedError('find_branch() is not supported anymore, '
57
'please use one of the new branch constructors')
74
58
75
59
def _relpath(base, path):
76
60
"""Return path relative to base, or raise exception.
94
78
if tail:
95
79
s.insert(0, tail)
96
80
else:
97
from errors import NotBranchError
98
81
raise NotBranchError("path %r is not within branch %r" % (rp, base))
99
82
100
83
return os.sep.join(s)
128
111
head, tail = os.path.split(f)
129
112
if head == f:
130
113
# reached the root, whatever that may be
131
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
114
raise NotBranchError('%s is not in a branch' % orig_f)
132
115
f = head
133
116
134
117
135
118
136
# XXX: move into bzrlib.errors; subclass BzrError
137
class DivergedBranches(Exception):
138
def __init__(self, branch1, branch2):
139
self.branch1 = branch1
140
self.branch2 = branch2
141
Exception.__init__(self, "These branches have diverged.")
142
143
119
144
120
######################################################################
145
121
# branch objects
148
124
"""Branch holding a history of revisions.
149
125
150
126
base
151
Base directory of the branch.
127
Base directory/url of the branch.
128
"""
129
base = None
130
131
def __init__(self, *ignored, **ignored_too):
132
raise NotImplementedError('The Branch class is abstract')
133
134
@staticmethod
135
def open_downlevel(base):
136
"""Open a branch which may be of an old format.
137
138
Only local branches are supported."""
139
return LocalBranch(base, find_root=False, relax_version_check=True)
140
141
@staticmethod
142
def open(base):
143
"""Open an existing branch, rooted at 'base' (url)"""
144
if base and (base.startswith('http://') or base.startswith('https://')):
145
from bzrlib.remotebranch import RemoteBranch
146
return RemoteBranch(base, find_root=False)
147
else:
148
return LocalBranch(base, find_root=False)
149
150
@staticmethod
151
def open_containing(url):
152
"""Open an existing branch which contains url.
153
154
This probes for a branch at url, and searches upwards from there.
155
"""
156
if url and (url.startswith('http://') or url.startswith('https://')):
157
from bzrlib.remotebranch import RemoteBranch
158
return RemoteBranch(url)
159
else:
160
return LocalBranch(url)
161
162
@staticmethod
163
def initialize(base):
164
"""Create a new branch, rooted at 'base' (url)"""
165
if base and (base.startswith('http://') or base.startswith('https://')):
166
from bzrlib.remotebranch import RemoteBranch
167
return RemoteBranch(base, init=True)
168
else:
169
return LocalBranch(base, init=True)
170
171
def setup_caching(self, cache_root):
172
"""Subclasses that care about caching should override this, and set
173
up cached stores located under cache_root.
174
"""
175
176
177
class LocalBranch(Branch):
178
"""A branch stored in the actual filesystem.
179
180
Note that it's "local" in the context of the filesystem; it doesn't
181
really matter if it's on an nfs/smb/afs/coda/... share, as long as
182
it's writable, and can be accessed via the normal filesystem API.
152
183
153
184
_lock_mode
154
185
None, or 'r' or 'w'
160
191
_lock
161
192
Lock object from bzrlib.lock.
162
193
"""
163
base = None
194
# We actually expect this class to be somewhat short-lived; part of its
195
# purpose is to try to isolate what bits of the branch logic are tied to
196
# filesystem access, so that in a later step, we can extricate them to
197
# a separarte ("storage") class.
164
198
_lock_mode = None
165
199
_lock_count = None
166
200
_lock = None
201
_inventory_weave = None
167
202
168
203
# Map some sort of prefix into a namespace
169
204
# stuff like "revno:10", "revid:", etc.
170
205
# This should match a prefix with a function which accepts
171
206
REVISION_NAMESPACES = {}
172
207
173
def __init__(self, base, init=False, find_root=True):
208
def push_stores(self, branch_to):
209
"""Copy the content of this branches store to branch_to."""
210
if (self._branch_format != branch_to._branch_format
211
or self._branch_format != 4):
212
from bzrlib.fetch import greedy_fetch
213
mutter("falling back to fetch logic to push between %s(%s) and %s(%s)",
214
self, self._branch_format, branch_to, branch_to._branch_format)
215
greedy_fetch(to_branch=branch_to, from_branch=self,
216
revision=self.last_revision())
217
return
218
219
store_pairs = ((self.text_store, branch_to.text_store),
220
(self.inventory_store, branch_to.inventory_store),
221
(self.revision_store, branch_to.revision_store))
222
try:
223
for from_store, to_store in store_pairs:
224
copy_all(from_store, to_store)
225
except UnlistableStore:
226
raise UnlistableBranch(from_store)
227
228
def __init__(self, base, init=False, find_root=True,
229
relax_version_check=False):
174
230
"""Create new branch object at a particular location.
175
231
176
base -- Base directory for the branch.
232
base -- Base directory for the branch. May be a file:// url.
177
233
178
234
init -- If True, create new control files in a previously
179
235
unversioned directory. If False, the branch must already
182
238
find_root -- If true and init is false, find the root of the
183
239
existing branch containing base.
184
240
241
relax_version_check -- If true, the usual check for the branch
242
version is not applied. This is intended only for
243
upgrade/recovery type use; it's not guaranteed that
244
all operations will work on old format branches.
245
185
246
In the test suite, creation of new trees is tested using the
186
247
`ScratchBranch` class.
187
248
"""
188
from bzrlib.store import ImmutableStore
189
249
if init:
190
250
self.base = os.path.realpath(base)
191
251
self._make_control()
192
252
elif find_root:
193
253
self.base = find_branch_root(base)
194
254
else:
255
if base.startswith("file://"):
256
base = base[7:]
195
257
self.base = os.path.realpath(base)
196
258
if not isdir(self.controlfilename('.')):
197
from errors import NotBranchError
198
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
199
['use "bzr init" to initialize a new working tree',
200
'current bzr can only operate from top-of-tree'])
201
self._check_format()
202
203
self.text_store = ImmutableStore(self.controlfilename('text-store'))
204
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
205
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
259
raise NotBranchError('not a bzr branch: %s' % quotefn(base),
260
['use "bzr init" to initialize a '
261
'new working tree'])
262
self._check_format(relax_version_check)
263
cfn = self.controlfilename
264
if self._branch_format == 4:
265
self.inventory_store = ImmutableStore(cfn('inventory-store'))
266
self.text_store = ImmutableStore(cfn('text-store'))
267
elif self._branch_format == 5:
268
self.control_weaves = WeaveStore(cfn([]))
269
self.weave_store = WeaveStore(cfn('weaves'))
270
if init:
271
# FIXME: Unify with make_control_files
272
self.control_weaves.put_empty_weave('inventory')
273
self.control_weaves.put_empty_weave('ancestry')
274
self.revision_store = ImmutableStore(cfn('revision-store'))
206
275
207
276
208
277
def __str__(self):
214
283
215
284
def __del__(self):
216
285
if self._lock_mode or self._lock:
217
from warnings import warn
286
# XXX: This should show something every time, and be suitable for
287
# headless operation and embedding
218
288
warn("branch %r was not explicitly unlocked" % self)
219
289
self._lock.unlock()
220
290
221
222
291
def lock_write(self):
223
292
if self._lock_mode:
224
293
if self._lock_mode != 'w':
225
from errors import LockError
226
294
raise LockError("can't upgrade to a write lock from %r" %
227
295
self._lock_mode)
228
296
self._lock_count += 1
248
316
249
317
def unlock(self):
250
318
if not self._lock_mode:
251
from errors import LockError
252
319
raise LockError('branch %r is not locked' % (self))
253
320
254
321
if self._lock_count > 1:
301
368
raise BzrError("invalid controlfile mode %r" % mode)
302
369
303
370
def _make_control(self):
304
from bzrlib.inventory import Inventory
305
from bzrlib.xml import pack_xml
306
307
371
os.mkdir(self.controlfilename([]))
308
372
self.controlfile('README', 'w').write(
309
373
"This is a Bazaar-NG control directory.\n"
310
374
"Do not change any files in this directory.\n")
311
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
312
for d in ('text-store', 'inventory-store', 'revision-store'):
375
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT_5)
376
for d in ('text-store', 'revision-store',
377
'weaves'):
313
378
os.mkdir(self.controlfilename(d))
314
for f in ('revision-history', 'merged-patches',
315
'pending-merged-patches', 'branch-name',
379
for f in ('revision-history',
380
'branch-name',
316
381
'branch-lock',
317
382
'pending-merges'):
318
383
self.controlfile(f, 'w').write('')
321
386
# if we want per-tree root ids then this is the place to set
322
387
# them; they're not needed for now and so ommitted for
323
388
# simplicity.
324
pack_xml(Inventory(), self.controlfile('inventory','w'))
325
326
def _check_format(self):
389
f = self.controlfile('inventory','w')
390
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), f)
391
392
393
def _check_format(self, relax_version_check):
327
394
"""Check this branch format is supported.
328
395
329
The current tool only supports the current unstable format.
396
The format level is stored, as an integer, in
397
self._branch_format for code that needs to check it later.
330
398
331
399
In the future, we might need different in-memory Branch
332
400
classes to support downlevel branches. But not yet.
333
401
"""
334
# This ignores newlines so that we can open branches created
335
# on Windows from Linux and so on. I think it might be better
336
# to always make all internal files in unix format.
337
fmt = self.controlfile('branch-format', 'r').read()
338
fmt.replace('\r\n', '')
339
if fmt != BZR_BRANCH_FORMAT:
402
try:
403
fmt = self.controlfile('branch-format', 'r').read()
404
except IOError, e:
405
if e.errno == errno.ENOENT:
406
raise NotBranchError(self.base)
407
else:
408
raise
409
410
if fmt == BZR_BRANCH_FORMAT_5:
411
self._branch_format = 5
412
elif fmt == BZR_BRANCH_FORMAT_4:
413
self._branch_format = 4
414
415
if (not relax_version_check
416
and self._branch_format != 5):
340
417
raise BzrError('sorry, branch format %r not supported' % fmt,
341
418
['use a different bzr version',
342
419
'or remove the .bzr directory and "bzr init" again'])
360
437
361
438
def read_working_inventory(self):
362
439
"""Read the working inventory."""
363
from bzrlib.inventory import Inventory
364
from bzrlib.xml import unpack_xml
365
from time import time
366
before = time()
367
440
self.lock_read()
368
441
try:
369
442
# ElementTree does its own conversion from UTF-8, so open in
370
443
# binary.
371
inv = unpack_xml(Inventory,
372
self.controlfile('inventory', 'rb'))
373
mutter("loaded inventory of %d items in %f"
374
% (len(inv), time() - before))
375
return inv
444
f = self.controlfile('inventory', 'rb')
445
return bzrlib.xml5.serializer_v5.read_inventory(f)
376
446
finally:
377
447
self.unlock()
378
448
384
454
will be committed to the next revision.
385
455
"""
386
456
from bzrlib.atomicfile import AtomicFile
387
from bzrlib.xml import pack_xml
388
457
389
458
self.lock_write()
390
459
try:
391
460
f = AtomicFile(self.controlfilename('inventory'), 'wb')
392
461
try:
393
pack_xml(inv, f)
462
bzrlib.xml5.serializer_v5.write_inventory(inv, f)
394
463
f.commit()
395
464
finally:
396
465
f.close()
477
546
"""Print `file` to stdout."""
478
547
self.lock_read()
479
548
try:
480
tree = self.revision_tree(self.lookup_revision(revno))
549
tree = self.revision_tree(self.get_rev_id(revno))
481
550
# use inventory as it was in that revision
482
551
file_id = tree.inventory.path2id(file)
483
552
if not file_id:
581
650
f.close()
582
651
583
652
584
def get_revision_xml(self, revision_id):
653
def has_revision(self, revision_id):
654
"""True if this branch has a copy of the revision.
655
656
This does not necessarily imply the revision is merge
657
or on the mainline."""
658
return (revision_id is None
659
or revision_id in self.revision_store)
660
661
662
def get_revision_xml_file(self, revision_id):
585
663
"""Return XML file object for revision object."""
586
664
if not revision_id or not isinstance(revision_id, basestring):
587
665
raise InvalidRevisionId(revision_id)
590
668
try:
591
669
try:
592
670
return self.revision_store[revision_id]
593
except IndexError:
671
except (IndexError, KeyError):
594
672
raise bzrlib.errors.NoSuchRevision(self, revision_id)
595
673
finally:
596
674
self.unlock()
597
675
598
676
677
def get_revision_xml(self, revision_id):
678
return self.get_revision_xml_file(revision_id).read()
679
680
599
681
def get_revision(self, revision_id):
600
682
"""Return the Revision object for a named revision"""
601
xml_file = self.get_revision_xml(revision_id)
683
xml_file = self.get_revision_xml_file(revision_id)
602
684
603
685
try:
604
r = unpack_xml(Revision, xml_file)
686
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
605
687
except SyntaxError, e:
606
688
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
607
689
[revision_id,
632
714
633
715
return compare_trees(old_tree, new_tree)
634
716
635
636
717
637
718
def get_revision_sha1(self, revision_id):
638
719
"""Hash the stored value of a revision, and return it."""
639
# In the future, revision entries will be signed. At that
640
# point, it is probably best *not* to include the signature
641
# in the revision hash. Because that lets you re-sign
642
# the revision, (add signatures/remove signatures) and still
643
# have all hash pointers stay consistent.
644
# But for now, just hash the contents.
645
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
646
647
648
def get_inventory(self, inventory_id):
649
"""Get Inventory object by hash.
650
651
TODO: Perhaps for this and similar methods, take a revision
652
parameter which can be either an integer revno or a
653
string hash."""
654
from bzrlib.inventory import Inventory
655
from bzrlib.xml import unpack_xml
656
657
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
658
659
660
def get_inventory_xml(self, inventory_id):
720
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
721
722
723
def _get_ancestry_weave(self):
724
return self.control_weaves.get_weave('ancestry')
725
726
727
def get_ancestry(self, revision_id):
728
"""Return a list of revision-ids integrated by a revision.
729
"""
730
# strip newlines
731
if revision_id is None:
732
return [None]
733
w = self._get_ancestry_weave()
734
return [None] + [l[:-1] for l in w.get_iter(w.lookup(revision_id))]
735
736
737
def get_inventory_weave(self):
738
return self.control_weaves.get_weave('inventory')
739
740
741
def get_inventory(self, revision_id):
742
"""Get Inventory object by hash."""
743
xml = self.get_inventory_xml(revision_id)
744
return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
745
746
747
def get_inventory_xml(self, revision_id):
661
748
"""Get inventory XML as a file object."""
662
return self.inventory_store[inventory_id]
663
664
665
def get_inventory_sha1(self, inventory_id):
749
try:
750
assert isinstance(revision_id, basestring), type(revision_id)
751
iw = self.get_inventory_weave()
752
return iw.get_text(iw.lookup(revision_id))
753
except IndexError:
754
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
755
756
757
def get_inventory_sha1(self, revision_id):
666
758
"""Return the sha1 hash of the inventory entry
667
759
"""
668
return sha_file(self.get_inventory_xml(inventory_id))
760
return self.get_revision(revision_id).inventory_sha1
669
761
670
762
671
763
def get_revision_inventory(self, revision_id):
672
764
"""Return inventory of a past revision."""
673
# bzr 0.0.6 imposes the constraint that the inventory_id
765
# TODO: Unify this with get_inventory()
766
# bzr 0.0.6 and later imposes the constraint that the inventory_id
674
767
# must be the same as its revision, so this is trivial.
675
768
if revision_id == None:
676
from bzrlib.inventory import Inventory
677
769
return Inventory(self.get_root_id())
678
770
else:
679
771
return self.get_inventory(revision_id)
680
772
681
773
682
774
def revision_history(self):
683
"""Return sequence of revision hashes on to this branch.
684
685
>>> ScratchBranch().revision_history()
686
[]
687
"""
775
"""Return sequence of revision hashes on to this branch."""
688
776
self.lock_read()
689
777
try:
690
778
return [l.rstrip('\r\n') for l in
695
783
696
784
def common_ancestor(self, other, self_revno=None, other_revno=None):
697
785
"""
698
>>> import commit
786
>>> from bzrlib.commit import commit
699
787
>>> sb = ScratchBranch(files=['foo', 'foo~'])
700
788
>>> sb.common_ancestor(sb) == (None, None)
701
789
True
702
>>> commit.commit(sb, "Committing first revision", verbose=False)
790
>>> commit(sb, "Committing first revision", verbose=False)
703
791
>>> sb.common_ancestor(sb)[0]
704
792
1
705
793
>>> clone = sb.clone()
706
>>> commit.commit(sb, "Committing second revision", verbose=False)
794
>>> commit(sb, "Committing second revision", verbose=False)
707
795
>>> sb.common_ancestor(sb)[0]
708
796
2
709
797
>>> sb.common_ancestor(clone)[0]
710
798
1
711
>>> commit.commit(clone, "Committing divergent second revision",
799
>>> commit(clone, "Committing divergent second revision",
712
800
... verbose=False)
713
801
>>> sb.common_ancestor(clone)[0]
714
802
1
747
835
return len(self.revision_history())
748
836
749
837
750
def last_patch(self):
838
def last_revision(self):
751
839
"""Return last patch hash, or None if no history.
752
840
"""
753
841
ph = self.revision_history()
758
846
759
847
760
848
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
761
"""
849
"""Return a list of new revisions that would perfectly fit.
850
762
851
If self and other have not diverged, return a list of the revisions
763
852
present in other, but missing from self.
764
853
784
873
Traceback (most recent call last):
785
874
DivergedBranches: These branches have diverged.
786
875
"""
876
# FIXME: If the branches have diverged, but the latest
877
# revision in this branch is completely merged into the other,
878
# then we should still be able to pull.
787
879
self_history = self.revision_history()
788
880
self_len = len(self_history)
789
881
other_history = other.revision_history()
795
887
796
888
if stop_revision is None:
797
889
stop_revision = other_len
798
elif stop_revision > other_len:
799
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
800
890
else:
891
assert isinstance(stop_revision, int)
892
if stop_revision > other_len:
893
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
801
894
return other_history[self_len:stop_revision]
802
895
803
804
896
def update_revisions(self, other, stop_revision=None):
805
"""Pull in all new revisions from other branch.
806
"""
897
"""Pull in new perfect-fit revisions."""
807
898
from bzrlib.fetch import greedy_fetch
808
809
pb = bzrlib.ui.ui_factory.progress_bar()
810
pb.update('comparing histories')
811
812
revision_ids = self.missing_revisions(other, stop_revision)
813
814
if len(revision_ids) > 0:
815
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
816
else:
817
count = 0
818
self.append_revision(*revision_ids)
819
## note("Added %d revisions." % count)
820
pb.clear()
821
822
def install_revisions(self, other, revision_ids, pb):
823
if hasattr(other.revision_store, "prefetch"):
824
other.revision_store.prefetch(revision_ids)
825
if hasattr(other.inventory_store, "prefetch"):
826
inventory_ids = [other.get_revision(r).inventory_id
827
for r in revision_ids]
828
other.inventory_store.prefetch(inventory_ids)
829
830
if pb is None:
831
pb = bzrlib.ui.ui_factory.progress_bar()
832
833
revisions = []
834
needed_texts = set()
835
i = 0
836
837
failures = set()
838
for i, rev_id in enumerate(revision_ids):
839
pb.update('fetching revision', i+1, len(revision_ids))
840
try:
841
rev = other.get_revision(rev_id)
842
except bzrlib.errors.NoSuchRevision:
843
failures.add(rev_id)
844
continue
845
846
revisions.append(rev)
847
inv = other.get_inventory(str(rev.inventory_id))
848
for key, entry in inv.iter_entries():
849
if entry.text_id is None:
850
continue
851
if entry.text_id not in self.text_store:
852
needed_texts.add(entry.text_id)
853
854
pb.clear()
855
856
count, cp_fail = self.text_store.copy_multi(other.text_store,
857
needed_texts)
858
#print "Added %d texts." % count
859
inventory_ids = [ f.inventory_id for f in revisions ]
860
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
861
inventory_ids)
862
#print "Added %d inventories." % count
863
revision_ids = [ f.revision_id for f in revisions]
864
865
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
866
revision_ids,
867
permit_failure=True)
868
assert len(cp_fail) == 0
869
return count, failures
870
899
from bzrlib.revision import get_intervening_revisions
900
if stop_revision is None:
901
stop_revision = other.last_revision()
902
greedy_fetch(to_branch=self, from_branch=other,
903
revision=stop_revision)
904
pullable_revs = self.missing_revisions(
905
other, other.revision_id_to_revno(stop_revision))
906
if pullable_revs:
907
greedy_fetch(to_branch=self,
908
from_branch=other,
909
revision=pullable_revs[-1])
910
self.append_revision(*pullable_revs)
911
871
912
872
913
def commit(self, *args, **kw):
873
from bzrlib.commit import commit
874
commit(self, *args, **kw)
875
876
877
def lookup_revision(self, revision):
878
"""Return the revision identifier for a given revision information."""
879
revno, info = self._get_revision_info(revision)
880
return info
881
882
914
from bzrlib.commit import Commit
915
Commit().commit(self, *args, **kw)
916
883
917
def revision_id_to_revno(self, revision_id):
884
918
"""Given a revision id, return its revno"""
919
if revision_id is None:
920
return 0
885
921
history = self.revision_history()
886
922
try:
887
923
return history.index(revision_id) + 1
888
924
except ValueError:
889
925
raise bzrlib.errors.NoSuchRevision(self, revision_id)
890
926
891
892
def get_revision_info(self, revision):
893
"""Return (revno, revision id) for revision identifier.
894
895
revision can be an integer, in which case it is assumed to be revno (though
896
this will translate negative values into positive ones)
897
revision can also be a string, in which case it is parsed for something like
898
'date:' or 'revid:' etc.
899
"""
900
revno, rev_id = self._get_revision_info(revision)
901
if revno is None:
902
raise bzrlib.errors.NoSuchRevision(self, revision)
903
return revno, rev_id
904
905
927
def get_rev_id(self, revno, history=None):
906
928
"""Find the revision id of the specified revno."""
907
929
if revno == 0:
912
934
raise bzrlib.errors.NoSuchRevision(self, revno)
913
935
return history[revno - 1]
914
936
915
def _get_revision_info(self, revision):
916
"""Return (revno, revision id) for revision specifier.
917
918
revision can be an integer, in which case it is assumed to be revno
919
(though this will translate negative values into positive ones)
920
revision can also be a string, in which case it is parsed for something
921
like 'date:' or 'revid:' etc.
922
923
A revid is always returned. If it is None, the specifier referred to
924
the null revision. If the revid does not occur in the revision
925
history, revno will be None.
926
"""
927
928
if revision is None:
929
return 0, None
930
revno = None
931
try:# Convert to int if possible
932
revision = int(revision)
933
except ValueError:
934
pass
935
revs = self.revision_history()
936
if isinstance(revision, int):
937
if revision < 0:
938
revno = len(revs) + revision + 1
939
else:
940
revno = revision
941
rev_id = self.get_rev_id(revno, revs)
942
elif isinstance(revision, basestring):
943
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
944
if revision.startswith(prefix):
945
result = func(self, revs, revision)
946
if len(result) > 1:
947
revno, rev_id = result
948
else:
949
revno = result[0]
950
rev_id = self.get_rev_id(revno, revs)
951
break
952
else:
953
raise BzrError('No namespace registered for string: %r' %
954
revision)
955
else:
956
raise TypeError('Unhandled revision type %s' % revision)
957
958
if revno is None:
959
if rev_id is None:
960
raise bzrlib.errors.NoSuchRevision(self, revision)
961
return revno, rev_id
962
963
def _namespace_revno(self, revs, revision):
964
"""Lookup a revision by revision number"""
965
assert revision.startswith('revno:')
966
try:
967
return (int(revision[6:]),)
968
except ValueError:
969
return None
970
REVISION_NAMESPACES['revno:'] = _namespace_revno
971
972
def _namespace_revid(self, revs, revision):
973
assert revision.startswith('revid:')
974
rev_id = revision[len('revid:'):]
975
try:
976
return revs.index(rev_id) + 1, rev_id
977
except ValueError:
978
return None, rev_id
979
REVISION_NAMESPACES['revid:'] = _namespace_revid
980
981
def _namespace_last(self, revs, revision):
982
assert revision.startswith('last:')
983
try:
984
offset = int(revision[5:])
985
except ValueError:
986
return (None,)
987
else:
988
if offset <= 0:
989
raise BzrError('You must supply a positive value for --revision last:XXX')
990
return (len(revs) - offset + 1,)
991
REVISION_NAMESPACES['last:'] = _namespace_last
992
993
def _namespace_tag(self, revs, revision):
994
assert revision.startswith('tag:')
995
raise BzrError('tag: namespace registered, but not implemented.')
996
REVISION_NAMESPACES['tag:'] = _namespace_tag
997
998
def _namespace_date(self, revs, revision):
999
assert revision.startswith('date:')
1000
import datetime
1001
# Spec for date revisions:
1002
# date:value
1003
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
1004
# it can also start with a '+/-/='. '+' says match the first
1005
# entry after the given date. '-' is match the first entry before the date
1006
# '=' is match the first entry after, but still on the given date.
1007
#
1008
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
1009
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
1010
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
1011
# May 13th, 2005 at 0:00
1012
#
1013
# So the proper way of saying 'give me all entries for today' is:
1014
# -r {date:+today}:{date:-tomorrow}
1015
# The default is '=' when not supplied
1016
val = revision[5:]
1017
match_style = '='
1018
if val[:1] in ('+', '-', '='):
1019
match_style = val[:1]
1020
val = val[1:]
1021
1022
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1023
if val.lower() == 'yesterday':
1024
dt = today - datetime.timedelta(days=1)
1025
elif val.lower() == 'today':
1026
dt = today
1027
elif val.lower() == 'tomorrow':
1028
dt = today + datetime.timedelta(days=1)
1029
else:
1030
import re
1031
# This should be done outside the function to avoid recompiling it.
1032
_date_re = re.compile(
1033
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1034
r'(,|T)?\s*'
1035
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1036
)
1037
m = _date_re.match(val)
1038
if not m or (not m.group('date') and not m.group('time')):
1039
raise BzrError('Invalid revision date %r' % revision)
1040
1041
if m.group('date'):
1042
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1043
else:
1044
year, month, day = today.year, today.month, today.day
1045
if m.group('time'):
1046
hour = int(m.group('hour'))
1047
minute = int(m.group('minute'))
1048
if m.group('second'):
1049
second = int(m.group('second'))
1050
else:
1051
second = 0
1052
else:
1053
hour, minute, second = 0,0,0
1054
1055
dt = datetime.datetime(year=year, month=month, day=day,
1056
hour=hour, minute=minute, second=second)
1057
first = dt
1058
last = None
1059
reversed = False
1060
if match_style == '-':
1061
reversed = True
1062
elif match_style == '=':
1063
last = dt + datetime.timedelta(days=1)
1064
1065
if reversed:
1066
for i in range(len(revs)-1, -1, -1):
1067
r = self.get_revision(revs[i])
1068
# TODO: Handle timezone.
1069
dt = datetime.datetime.fromtimestamp(r.timestamp)
1070
if first >= dt and (last is None or dt >= last):
1071
return (i+1,)
1072
else:
1073
for i in range(len(revs)):
1074
r = self.get_revision(revs[i])
1075
# TODO: Handle timezone.
1076
dt = datetime.datetime.fromtimestamp(r.timestamp)
1077
if first <= dt and (last is None or dt <= last):
1078
return (i+1,)
1079
REVISION_NAMESPACES['date:'] = _namespace_date
1080
1081
937
def revision_tree(self, revision_id):
1082
938
"""Return Tree for a revision on this branch.
1083
939
1089
945
return EmptyTree()
1090
946
else:
1091
947
inv = self.get_revision_inventory(revision_id)
1092
return RevisionTree(self.text_store, inv)
948
return RevisionTree(self.weave_store, inv, revision_id)
1093
949
1094
950
1095
951
def working_tree(self):
1096
952
"""Return a `Tree` for the working copy."""
1097
from workingtree import WorkingTree
953
from bzrlib.workingtree import WorkingTree
1098
954
return WorkingTree(self.base, self.read_working_inventory())
1099
955
1100
956
1103
959
1104
960
If there are no revisions yet, return an `EmptyTree`.
1105
961
"""
1106
r = self.last_patch()
1107
if r == None:
1108
return EmptyTree()
1109
else:
1110
return RevisionTree(self.text_store, self.get_revision_inventory(r))
1111
962
return self.revision_tree(self.last_revision())
1112
963
1113
964
1114
965
def rename_one(self, from_rel, to_rel):
1149
1000
from_abs = self.abspath(from_rel)
1150
1001
to_abs = self.abspath(to_rel)
1151
1002
try:
1152
os.rename(from_abs, to_abs)
1003
rename(from_abs, to_abs)
1153
1004
except OSError, e:
1154
1005
raise BzrError("failed to rename %r to %r: %s"
1155
1006
% (from_abs, to_abs, e[1]),
1218
1069
result.append((f, dest_path))
1219
1070
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1220
1071
try:
1221
os.rename(self.abspath(f), self.abspath(dest_path))
1072
rename(self.abspath(f), self.abspath(dest_path))
1222
1073
except OSError, e:
1223
1074
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1224
1075
["rename rolled back"])
1290
1141
1291
1142
1292
1143
def add_pending_merge(self, revision_id):
1293
from bzrlib.revision import validate_revision_id
1294
1295
1144
validate_revision_id(revision_id)
1296
1145
# TODO: Perhaps should check at this point that the
1146
# history of the revision is actually present?
1297
1147
p = self.pending_merges()
1298
1148
if revision_id in p:
1299
1149
return
1365
1215
raise InvalidRevisionNumber(revno)
1366
1216
1367
1217
1368
1369
1370
class ScratchBranch(Branch):
1218
1219
1220
1221
class ScratchBranch(LocalBranch):
1371
1222
"""Special test class: a branch that cleans up after itself.
1372
1223
1373
1224
>>> b = ScratchBranch()
1390
1241
if base is None:
1391
1242
base = mkdtemp()
1392
1243
init = True
1393
Branch.__init__(self, base, init=init)
1244
LocalBranch.__init__(self, base, init=init)
1394
1245
for d in dirs:
1395
1246
os.mkdir(self.abspath(d))
1396
1247
1402
1253
"""
1403
1254
>>> orig = ScratchBranch(files=["file1", "file2"])
1404
1255
>>> clone = orig.clone()
1405
>>> os.path.samefile(orig.base, clone.base)
1256
>>> if os.name != 'nt':
1257
... os.path.samefile(orig.base, clone.base)
1258
... else:
1259
... orig.base == clone.base
1260
...
1406
1261
False
1407
1262
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1408
1263
True
1491
1346
return gen_file_id('TREE_ROOT')
1492
1347
1493
1348
1494
def pull_loc(branch):
1495
# TODO: Should perhaps just make attribute be 'base' in
1496
# RemoteBranch and Branch?
1497
if hasattr(branch, "baseurl"):
1498
return branch.baseurl
1499
else:
1500
return branch.base
1501
1502
1503
def copy_branch(branch_from, to_location, revision=None):
1504
"""Copy branch_from into the existing directory to_location.
1505
1506
revision
1507
If not None, only revisions up to this point will be copied.
1508
The head of the new branch will be that revision.
1509
1510
to_location
1511
The name of a local directory that exists but is empty.
1512
"""
1513
from bzrlib.merge import merge
1514
from bzrlib.branch import Branch
1515
1516
assert isinstance(branch_from, Branch)
1517
assert isinstance(to_location, basestring)
1518
1519
br_to = Branch(to_location, init=True)
1520
br_to.set_root_id(branch_from.get_root_id())
1521
if revision is None:
1522
revno = branch_from.revno()
1523
else:
1524
revno, rev_id = branch_from.get_revision_info(revision)
1525
br_to.update_revisions(branch_from, stop_revision=revno)
1526
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1527
check_clean=False, ignore_zero=True)
1528
1529
from_location = pull_loc(branch_from)
1530
br_to.set_parent(pull_loc(branch_from))
1531
Loggerhead is a web-based interface for Breezy
Version: 2.0.1