49
49
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
50
50
from bzrlib.hooks import HookPoint, Hooks
51
51
from bzrlib.inter import InterObject
52
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
52
from bzrlib.lock import _RelockDebugMixin
53
53
from bzrlib import registry
54
54
from bzrlib.symbol_versioning import (
63
63
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
66
class Branch(bzrdir.ControlComponent):
66
# TODO: Maybe include checks for common corruption of newlines, etc?
68
# TODO: Some operations like log might retrieve the same revisions
69
# repeatedly to calculate deltas. We could perhaps have a weakref
70
# cache in memory to make this faster. In general anything can be
71
# cached in memory between lock and unlock operations. .. nb thats
72
# what the transaction identity map provides
75
######################################################################
67
79
"""Branch holding a history of revisions.
70
Base directory/url of the branch; using control_url and
71
control_transport is more standardized.
82
Base directory/url of the branch.
73
84
hooks: An instance of BranchHooks.
80
def control_transport(self):
81
return self._transport
84
def user_transport(self):
85
return self.bzrdir.user_transport
87
90
def __init__(self, *ignored, **ignored_too):
88
91
self.tags = self._format.make_tags(self)
89
92
self._revision_history_cache = None
104
107
"""Activate the branch/repository from url as a fallback repository."""
105
108
repo = self._get_fallback_repository(url)
106
109
if repo.has_same_location(self.repository):
107
raise errors.UnstackableLocationError(self.user_url, url)
110
raise errors.UnstackableLocationError(self.base, url)
108
111
self.repository.add_fallback_repository(repo)
110
113
def break_lock(self):
283
286
new_history.reverse()
284
287
return new_history
286
def lock_write(self, token=None):
287
"""Lock the branch for write operations.
289
:param token: A token to permit reacquiring a previously held and
291
:return: A BranchWriteLockResult.
289
def lock_write(self):
293
290
raise NotImplementedError(self.lock_write)
295
292
def lock_read(self):
296
"""Lock the branch for read operations.
298
:return: A bzrlib.lock.LogicalLockResult.
300
293
raise NotImplementedError(self.lock_read)
302
295
def unlock(self):
427
420
* 'include' - the stop revision is the last item in the result
428
421
* 'with-merges' - include the stop revision and all of its
429
422
merged revisions in the result
430
* 'with-merges-without-common-ancestry' - filter out revisions
431
that are in both ancestries
432
423
:param direction: either 'reverse' or 'forward':
433
424
* reverse means return the start_revision_id first, i.e.
434
425
start at the most recent revision and go backwards in history
456
447
# start_revision_id.
457
448
if self._merge_sorted_revisions_cache is None:
458
449
last_revision = self.last_revision()
459
known_graph = self.repository.get_known_graph_ancestry(
450
last_key = (last_revision,)
451
known_graph = self.repository.revisions.get_known_graph_ancestry(
461
453
self._merge_sorted_revisions_cache = known_graph.merge_sort(
463
455
filtered = self._filter_merge_sorted_revisions(
464
456
self._merge_sorted_revisions_cache, start_revision_id,
465
457
stop_revision_id, stop_rule)
466
# Make sure we don't return revisions that are not part of the
467
# start_revision_id ancestry.
468
filtered = self._filter_start_non_ancestors(filtered)
469
458
if direction == 'reverse':
471
460
if direction == 'forward':
508
497
node.end_of_merge)
509
498
if rev_id == stop_revision_id:
511
elif stop_rule == 'with-merges-without-common-ancestry':
512
# We want to exclude all revisions that are already part of the
513
# stop_revision_id ancestry.
514
graph = self.repository.get_graph()
515
ancestors = graph.find_unique_ancestors(start_revision_id,
517
for node in rev_iter:
518
rev_id = node.key[-1]
519
if rev_id not in ancestors:
521
yield (rev_id, node.merge_depth, node.revno,
523
500
elif stop_rule == 'with-merges':
524
501
stop_rev = self.repository.get_revision(stop_revision_id)
525
502
if stop_rev.parent_ids:
549
526
raise ValueError('invalid stop_rule %r' % stop_rule)
551
def _filter_start_non_ancestors(self, rev_iter):
552
# If we started from a dotted revno, we want to consider it as a tip
553
# and don't want to yield revisions that are not part of its
554
# ancestry. Given the order guaranteed by the merge sort, we will see
555
# uninteresting descendants of the first parent of our tip before the
557
first = rev_iter.next()
558
(rev_id, merge_depth, revno, end_of_merge) = first
561
# We start at a mainline revision so by definition, all others
562
# revisions in rev_iter are ancestors
563
for node in rev_iter:
568
pmap = self.repository.get_parent_map([rev_id])
569
parents = pmap.get(rev_id, [])
571
whitelist.update(parents)
573
# If there is no parents, there is nothing of interest left
575
# FIXME: It's hard to test this scenario here as this code is never
576
# called in that case. -- vila 20100322
579
for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
581
if rev_id in whitelist:
582
pmap = self.repository.get_parent_map([rev_id])
583
parents = pmap.get(rev_id, [])
584
whitelist.remove(rev_id)
585
whitelist.update(parents)
587
# We've reached the mainline, there is nothing left to
591
# A revision that is not part of the ancestry of our
594
yield (rev_id, merge_depth, revno, end_of_merge)
596
528
def leave_lock_in_place(self):
597
529
"""Tell this branch object not to release the physical lock when this
598
530
object is unlocked.
615
547
:param other: The branch to bind to
616
548
:type other: Branch
618
raise errors.UpgradeRequired(self.user_url)
550
raise errors.UpgradeRequired(self.base)
620
552
def set_append_revisions_only(self, enabled):
621
553
if not self._format.supports_set_append_revisions_only():
622
raise errors.UpgradeRequired(self.user_url)
554
raise errors.UpgradeRequired(self.base)
673
605
def get_old_bound_location(self):
674
606
"""Return the URL of the branch we used to be bound to
676
raise errors.UpgradeRequired(self.user_url)
608
raise errors.UpgradeRequired(self.base)
678
610
def get_commit_builder(self, parents, config=None, timestamp=None,
679
611
timezone=None, committer=None, revprops=None,
759
691
if not self._format.supports_stacking():
760
raise errors.UnstackableBranchFormat(self._format, self.user_url)
692
raise errors.UnstackableBranchFormat(self._format, self.base)
761
693
# XXX: Changing from one fallback repository to another does not check
762
694
# that all the data you need is present in the new fallback.
763
695
# Possibly it should.
915
847
def unbind(self):
916
848
"""Older format branches cannot bind or unbind."""
917
raise errors.UpgradeRequired(self.user_url)
849
raise errors.UpgradeRequired(self.base)
919
851
def last_revision(self):
920
852
"""Return last revision id, or NULL_REVISION."""
1081
1013
return urlutils.join(self.base[:-1], parent)
1082
1014
except errors.InvalidURLJoin, e:
1083
raise errors.InaccessibleParent(parent, self.user_url)
1015
raise errors.InaccessibleParent(parent, self.base)
1085
1017
def _get_parent_location(self):
1086
1018
raise NotImplementedError(self._get_parent_location)
1586
1518
:return: a branch in this format
1588
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1520
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1589
1521
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1591
1523
'metadir': ('lock', lockdir.LockDir),
1784
1716
self.create_hook(HookPoint('post_branch_init',
1785
1717
"Called after new branch initialization completes. "
1786
"post_branch_init is called with a "
1787
"bzrlib.branch.BranchInitHookParams. "
1788
"Note that init, branch and checkout (both heavyweight and "
1789
"lightweight) will all trigger this hook.", (2, 2), None))
1718
"post_branch_init is called with a bzrlib.branch.BranchInitHookParams. "
1719
"Note that init, branch and checkout will all trigger this hook.",
1790
1721
self.create_hook(HookPoint('post_switch',
1791
1722
"Called after a checkout switches branch. "
1792
1723
"post_switch is called with a "
1842
1773
There are 4 fields that hooks may wish to access:
1844
1775
:ivar format: the branch format
1845
:ivar bzrdir: the BzrDir where the branch will be/has been initialized
1776
:ivar bzrdir: the bzrdir where the branch will be/has been initialized
1846
1777
:ivar name: name of colocated branch, if any (or None)
1847
:ivar branch: the branch created
1849
Note that for lightweight checkouts, the bzrdir and format fields refer to
1850
the checkout, hence they are different from the corresponding fields in
1851
branch, which refer to the original branch.
1778
:ivar branch: the branch
1854
1781
def __init__(self, format, a_bzrdir, name, branch):
1855
1782
"""Create a group of BranchInitHook parameters.
1857
1784
:param format: the branch format
1858
:param a_bzrdir: the BzrDir where the branch will be/has been
1785
:param a_bzrdir: the bzrdir where the branch will be/has been initialized
1860
1786
:param name: name of colocated branch, if any (or None)
1861
:param branch: the branch created
1863
Note that for lightweight checkouts, the bzrdir and format fields refer
1864
to the checkout, hence they are different from the corresponding fields
1865
in branch, which refer to the original branch.
1787
:param branch: the branch
1867
1789
self.format = format
1868
1790
self.bzrdir = a_bzrdir
1978
1900
if format.__class__ != self.__class__:
1979
1901
raise AssertionError("wrong format %r found for %r" %
1980
1902
(format, self))
1981
transport = a_bzrdir.get_branch_transport(None, name=name)
1904
transport = a_bzrdir.get_branch_transport(None, name=name)
1983
1905
control_files = lockable_files.LockableFiles(transport, 'lock',
1984
1906
lockdir.LockDir)
1985
1907
return self._branch_class()(_format=self,
2183
2105
# this format does not implement branch itself, thus the implicit
2184
2106
# creation contract must see it as uninitializable
2185
2107
raise errors.UninitializableFormat(self)
2186
mutter('creating branch reference in %s', a_bzrdir.user_url)
2108
mutter('creating branch reference in %s', a_bzrdir.transport.base)
2187
2109
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2188
2110
branch_transport.put_bytes('location',
2189
target_branch.bzrdir.user_url)
2111
target_branch.bzrdir.root_transport.base)
2190
2112
branch_transport.put_bytes('format', self.get_format_string())
2191
2113
branch = self.open(
2192
2114
a_bzrdir, name, _found=True,
2275
2197
_legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2278
class BranchWriteLockResult(LogicalLockResult):
2279
"""The result of write locking a branch.
2281
:ivar branch_token: The token obtained from the underlying branch lock, or
2283
:ivar unlock: A callable which will unlock the lock.
2286
def __init__(self, unlock, branch_token):
2287
LogicalLockResult.__init__(self, unlock)
2288
self.branch_token = branch_token
2291
return "BranchWriteLockResult(%s, %s)" % (self.branch_token,
2295
2200
class BzrBranch(Branch, _RelockDebugMixin):
2296
2201
"""A branch stored in the actual filesystem.
2332
2237
def __str__(self):
2333
2238
if self.name is None:
2334
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2239
return '%s(%r)' % (self.__class__.__name__, self.base)
2336
return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2241
return '%s(%r,%r)' % (self.__class__.__name__, self.base, self.name)
2339
2243
__repr__ = __str__
2351
2255
return self.control_files.is_locked()
2353
2257
def lock_write(self, token=None):
2354
"""Lock the branch for write operations.
2356
:param token: A token to permit reacquiring a previously held and
2358
:return: A BranchWriteLockResult.
2360
2258
if not self.is_locked():
2361
2259
self._note_lock('w')
2362
2260
# All-in-one needs to always unlock/lock.
2369
2267
took_lock = False
2371
return BranchWriteLockResult(self.unlock,
2372
self.control_files.lock_write(token=token))
2269
return self.control_files.lock_write(token=token)
2375
2272
self.repository.unlock()
2378
2275
def lock_read(self):
2379
"""Lock the branch for read operations.
2381
:return: A bzrlib.lock.LogicalLockResult.
2383
2276
if not self.is_locked():
2384
2277
self._note_lock('r')
2385
2278
# All-in-one needs to always unlock/lock.
2569
2461
def get_stacked_on_url(self):
2570
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2462
raise errors.UnstackableBranchFormat(self._format, self.base)
2572
2464
def set_push_location(self, location):
2573
2465
"""See Branch.set_push_location."""
2763
2655
if _mod_revision.is_null(last_revision):
2765
2657
if last_revision not in self._lefthand_history(revision_id):
2766
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2658
raise errors.AppendRevisionsOnlyViolation(self.base)
2768
2660
def _gen_revision_history(self):
2769
2661
"""Generate the revision history from last revision
2869
2761
if branch_location is None:
2870
2762
return Branch.reference_parent(self, file_id, path,
2871
2763
possible_transports)
2872
branch_location = urlutils.join(self.user_url, branch_location)
2764
branch_location = urlutils.join(self.base, branch_location)
2873
2765
return Branch.open(branch_location,
2874
2766
possible_transports=possible_transports)
2921
2813
return stacked_url
2923
2815
def _get_append_revisions_only(self):
2924
return self.get_config(
2925
).get_user_option_as_bool('append_revisions_only')
2816
value = self.get_config().get_user_option('append_revisions_only')
2817
return value == 'True'
2927
2819
@needs_write_lock
2928
2820
def generate_revision_history(self, revision_id, last_rev=None,
2992
2884
def get_stacked_on_url(self):
2993
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2885
raise errors.UnstackableBranchFormat(self._format, self.base)
2996
2888
######################################################################
3083
2975
:param verbose: Requests more detailed display of what was checked,
3086
note('checked branch %s format %s', self.branch.user_url,
2978
note('checked branch %s format %s', self.branch.base,
3087
2979
self.branch._format)
3088
2980
for error in self.errors:
3089
2981
note('found error:%s', error)
3418
3310
if local and not bound_location:
3419
3311
raise errors.LocalRequiresBoundBranch()
3420
3312
master_branch = None
3421
if not local and bound_location and self.source.user_url != bound_location:
3313
if not local and bound_location and self.source.base != bound_location:
3422
3314
# not pulling from master, so we need to update master.
3423
3315
master_branch = self.target.get_master_branch(possible_transports)
3424
3316
master_branch.lock_write()
added
removed
bzrlib/branch.py
