14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from __future__ import absolute_import
21
18
from cStringIO import StringIO
23
21
from bzrlib.lazy_import import lazy_import
24
22
lazy_import(globals(), """
23
from itertools import chain
26
24
from bzrlib import (
31
config as _mod_config,
40
revision as _mod_revision,
27
config as _mod_config,
35
revision as _mod_revision,
43
from bzrlib.config import BranchConfig, TransportConfig
44
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
45
from bzrlib.tag import (
48
from bzrlib.i18n import gettext, ngettext
51
# Explicitly import bzrlib.bzrdir so that the BzrProber
52
# is guaranteed to be registered.
58
from bzrlib.decorators import (
63
from bzrlib.hooks import Hooks
51
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
52
from bzrlib.hooks import HookPoint, Hooks
64
53
from bzrlib.inter import InterObject
65
54
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
66
55
from bzrlib import registry
93
86
def user_transport(self):
94
87
return self.bzrdir.user_transport
96
def __init__(self, possible_transports=None):
89
def __init__(self, *ignored, **ignored_too):
97
90
self.tags = self._format.make_tags(self)
98
91
self._revision_history_cache = None
99
92
self._revision_id_to_revno_cache = None
100
93
self._partial_revision_id_to_revno_cache = {}
101
94
self._partial_revision_history_cache = []
102
self._tags_bytes = None
103
95
self._last_revision_info_cache = None
104
self._master_branch_cache = None
105
96
self._merge_sorted_revisions_cache = None
106
self._open_hook(possible_transports)
107
98
hooks = Branch.hooks['open']
108
99
for hook in hooks:
111
def _open_hook(self, possible_transports):
102
def _open_hook(self):
112
103
"""Called by init to allow simpler extension of the base class."""
114
def _activate_fallback_location(self, url, possible_transports):
105
def _activate_fallback_location(self, url):
115
106
"""Activate the branch/repository from url as a fallback repository."""
116
for existing_fallback_repo in self.repository._fallback_repositories:
117
if existing_fallback_repo.user_url == url:
118
# This fallback is already configured. This probably only
119
# happens because ControlDir.sprout is a horrible mess. To avoid
120
# confusing _unstack we don't add this a second time.
121
mutter('duplicate activation of fallback %r on %r', url, self)
123
repo = self._get_fallback_repository(url, possible_transports)
107
repo = self._get_fallback_repository(url)
124
108
if repo.has_same_location(self.repository):
125
109
raise errors.UnstackableLocationError(self.user_url, url)
126
110
self.repository.add_fallback_repository(repo)
180
164
For instance, if the branch is at URL/.bzr/branch,
181
165
Branch.open(URL) -> a Branch instance.
183
control = controldir.ControlDir.open(base, _unsupported,
167
control = bzrdir.BzrDir.open(base, _unsupported,
184
168
possible_transports=possible_transports)
185
return control.open_branch(unsupported=_unsupported,
186
possible_transports=possible_transports)
169
return control.open_branch(unsupported=_unsupported)
189
def open_from_transport(transport, name=None, _unsupported=False,
190
possible_transports=None):
172
def open_from_transport(transport, name=None, _unsupported=False):
191
173
"""Open the branch rooted at transport"""
192
control = controldir.ControlDir.open_from_transport(transport, _unsupported)
193
return control.open_branch(name=name, unsupported=_unsupported,
194
possible_transports=possible_transports)
174
control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
175
return control.open_branch(name=name, unsupported=_unsupported)
197
178
def open_containing(url, possible_transports=None):
526
492
rev_iter = iter(merge_sorted_revisions)
527
493
if start_revision_id is not None:
528
494
for node in rev_iter:
495
rev_id = node.key[-1]
530
496
if rev_id != start_revision_id:
533
499
# The decision to include the start or not
534
500
# depends on the stop_rule if a stop is provided
535
501
# so pop this node back into the iterator
536
rev_iter = itertools.chain(iter([node]), rev_iter)
502
rev_iter = chain(iter([node]), rev_iter)
538
504
if stop_revision_id is None:
539
505
# Yield everything
540
506
for node in rev_iter:
507
rev_id = node.key[-1]
542
508
yield (rev_id, node.merge_depth, node.revno,
543
509
node.end_of_merge)
544
510
elif stop_rule == 'exclude':
545
511
for node in rev_iter:
512
rev_id = node.key[-1]
547
513
if rev_id == stop_revision_id:
549
515
yield (rev_id, node.merge_depth, node.revno,
550
516
node.end_of_merge)
551
517
elif stop_rule == 'include':
552
518
for node in rev_iter:
519
rev_id = node.key[-1]
554
520
yield (rev_id, node.merge_depth, node.revno,
555
521
node.end_of_merge)
556
522
if rev_id == stop_revision_id:
685
649
raise errors.UnsupportedOperation(self.get_reference_info, self)
687
651
@needs_write_lock
688
def fetch(self, from_branch, last_revision=None, limit=None):
652
def fetch(self, from_branch, last_revision=None, pb=None):
689
653
"""Copy revisions from from_branch into this branch.
691
655
:param from_branch: Where to copy from.
692
656
:param last_revision: What revision to stop at (None for at the end
694
:param limit: Optional rough limit of revisions to fetch
658
:param pb: An optional progress bar to use.
697
return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)
661
if self.base == from_branch.base:
664
symbol_versioning.warn(
665
symbol_versioning.deprecated_in((1, 14, 0))
666
% "pb parameter to fetch()")
667
from_branch.lock_read()
669
if last_revision is None:
670
last_revision = from_branch.last_revision()
671
last_revision = _mod_revision.ensure_null(last_revision)
672
return self.repository.fetch(from_branch.repository,
673
revision_id=last_revision,
699
678
def get_bound_location(self):
700
679
"""Return the URL of the branch we are bound to.
721
700
:param committer: Optional committer to set for commit.
722
701
:param revprops: Optional dictionary of revision properties.
723
702
:param revision_id: Optional revision id.
724
:param lossy: Whether to discard data that can not be natively
725
represented, when pushing to a foreign VCS
728
if config_stack is None:
729
config_stack = self.get_config_stack()
706
config = self.get_config()
731
return self.repository.get_commit_builder(self, parents, config_stack,
732
timestamp, timezone, committer, revprops, revision_id,
708
return self.repository.get_commit_builder(self, parents, config,
709
timestamp, timezone, committer, revprops, revision_id)
735
711
def get_master_branch(self, possible_transports=None):
736
712
"""Return the branch we are bound to.
765
739
"""Print `file` to stdout."""
766
740
raise NotImplementedError(self.print_file)
768
@deprecated_method(deprecated_in((2, 4, 0)))
769
742
def set_revision_history(self, rev_history):
770
"""See Branch.set_revision_history."""
771
self._set_revision_history(rev_history)
774
def _set_revision_history(self, rev_history):
775
if len(rev_history) == 0:
776
revid = _mod_revision.NULL_REVISION
778
revid = rev_history[-1]
779
if rev_history != self._lefthand_history(revid):
780
raise errors.NotLefthandHistory(rev_history)
781
self.set_last_revision_info(len(rev_history), revid)
782
self._cache_revision_history(rev_history)
783
for hook in Branch.hooks['set_rh']:
784
hook(self, rev_history)
787
def set_last_revision_info(self, revno, revision_id):
788
"""Set the last revision of this branch.
790
The caller is responsible for checking that the revno is correct
791
for this revision id.
793
It may be possible to set the branch last revision to an id not
794
present in the repository. However, branches can also be
795
configured to check constraints on history, in which case this may not
798
raise NotImplementedError(self.set_last_revision_info)
801
def generate_revision_history(self, revision_id, last_rev=None,
803
"""See Branch.generate_revision_history"""
804
graph = self.repository.get_graph()
805
(last_revno, last_revid) = self.last_revision_info()
806
known_revision_ids = [
807
(last_revid, last_revno),
808
(_mod_revision.NULL_REVISION, 0),
810
if last_rev is not None:
811
if not graph.is_ancestor(last_rev, revision_id):
812
# our previous tip is not merged into stop_revision
813
raise errors.DivergedBranches(self, other_branch)
814
revno = graph.find_distance_to_null(revision_id, known_revision_ids)
815
self.set_last_revision_info(revno, revision_id)
743
raise NotImplementedError(self.set_revision_history)
817
745
@needs_write_lock
818
746
def set_parent(self, url):
1055
968
:return: A tuple (revno, revision_id).
1057
970
if self._last_revision_info_cache is None:
1058
self._last_revision_info_cache = self._read_last_revision_info()
971
self._last_revision_info_cache = self._last_revision_info()
1059
972
return self._last_revision_info_cache
1061
def _read_last_revision_info(self):
1062
raise NotImplementedError(self._read_last_revision_info)
1064
@deprecated_method(deprecated_in((2, 4, 0)))
974
def _last_revision_info(self):
975
rh = self.revision_history()
978
return (revno, rh[-1])
980
return (0, _mod_revision.NULL_REVISION)
982
@deprecated_method(deprecated_in((1, 6, 0)))
983
def missing_revisions(self, other, stop_revision=None):
984
"""Return a list of new revisions that would perfectly fit.
986
If self and other have not diverged, return a list of the revisions
987
present in other, but missing from self.
989
self_history = self.revision_history()
990
self_len = len(self_history)
991
other_history = other.revision_history()
992
other_len = len(other_history)
993
common_index = min(self_len, other_len) -1
994
if common_index >= 0 and \
995
self_history[common_index] != other_history[common_index]:
996
raise errors.DivergedBranches(self, other)
998
if stop_revision is None:
999
stop_revision = other_len
1001
if stop_revision > other_len:
1002
raise errors.NoSuchRevision(self, stop_revision)
1003
return other_history[self_len:stop_revision]
1005
def update_revisions(self, other, stop_revision=None, overwrite=False,
1007
"""Pull in new perfect-fit revisions.
1009
:param other: Another Branch to pull from
1010
:param stop_revision: Updated until the given revision
1011
:param overwrite: Always set the branch pointer, rather than checking
1012
to see if it is a proper descendant.
1013
:param graph: A Graph object that can be used to query history
1014
information. This can be None.
1017
return InterBranch.get(other, self).update_revisions(stop_revision,
1065
1020
def import_last_revision_info(self, source_repo, revno, revid):
1066
1021
"""Set the last revision info, importing from another repo if necessary.
1023
This is used by the bound branch code to upload a revision to
1024
the master branch first before updating the tip of the local branch.
1068
1026
:param source_repo: Source repository to optionally fetch from
1069
1027
:param revno: Revision number of the new tip
1070
1028
:param revid: Revision id of the new tip
1073
1031
self.repository.fetch(source_repo, revision_id=revid)
1074
1032
self.set_last_revision_info(revno, revid)
1076
def import_last_revision_info_and_tags(self, source, revno, revid,
1078
"""Set the last revision info, importing from another repo if necessary.
1080
This is used by the bound branch code to upload a revision to
1081
the master branch first before updating the tip of the local branch.
1082
Revisions referenced by source's tags are also transferred.
1084
:param source: Source branch to optionally fetch from
1085
:param revno: Revision number of the new tip
1086
:param revid: Revision id of the new tip
1087
:param lossy: Whether to discard metadata that can not be
1088
natively represented
1089
:return: Tuple with the new revision number and revision id
1090
(should only be different from the arguments when lossy=True)
1092
if not self.repository.has_same_location(source.repository):
1093
self.fetch(source, revid)
1094
self.set_last_revision_info(revno, revid)
1095
return (revno, revid)
1097
1034
def revision_id_to_revno(self, revision_id):
1098
1035
"""Given a revision id, return its revno"""
1099
1036
if _mod_revision.is_null(revision_id):
1101
history = self._revision_history()
1038
history = self.revision_history()
1103
1040
return history.index(revision_id) + 1
1104
1041
except ValueError:
1131
1068
stop_revision=stop_revision,
1132
1069
possible_transports=possible_transports, *args, **kwargs)
1134
def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1071
def push(self, target, overwrite=False, stop_revision=None, *args,
1136
1073
"""Mirror this branch into target.
1138
1075
This branch is considered to be 'local', having low latency.
1140
1077
return InterBranch.get(self, target).push(overwrite, stop_revision,
1141
lossy, *args, **kwargs)
1080
def lossy_push(self, target, stop_revision=None):
1081
"""Push deltas into another branch.
1083
:note: This does not, like push, retain the revision ids from
1084
the source branch and will, rather than adding bzr-specific
1085
metadata, push only those semantics of the revision that can be
1086
natively represented by this branch' VCS.
1088
:param target: Target branch
1089
:param stop_revision: Revision to push, defaults to last revision.
1090
:return: BranchPushResult with an extra member revidmap:
1091
A dictionary mapping revision ids from the target branch
1092
to new revision ids in the target branch, for each
1093
revision that was pushed.
1095
inter = InterBranch.get(self, target)
1096
lossy_push = getattr(inter, "lossy_push", None)
1097
if lossy_push is None:
1098
raise errors.LossyPushToSameVCS(self, target)
1099
return lossy_push(stop_revision)
1143
1101
def basis_tree(self):
1144
1102
"""Return `Tree` object for last revision."""
1401
1354
# TODO: We should probably also check that self.revision_history
1402
1355
# matches the repository for older branch formats.
1403
1356
# If looking for the code that cross-checks repository parents against
1404
# the Graph.iter_lefthand_ancestry output, that is now a repository
1357
# the iter_reverse_revision_history output, that is now a repository
1405
1358
# specific check.
1408
def _get_checkout_format(self, lightweight=False):
1361
def _get_checkout_format(self):
1409
1362
"""Return the most suitable metadir for a checkout of this branch.
1410
1363
Weaves are used if this branch's repository uses weaves.
1412
format = self.repository.bzrdir.checkout_metadir()
1413
format.set_branch_format(self._format)
1365
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1366
from bzrlib.repofmt import weaverepo
1367
format = bzrdir.BzrDirMetaFormat1()
1368
format.repository_format = weaverepo.RepositoryFormat7()
1370
format = self.repository.bzrdir.checkout_metadir()
1371
format.set_branch_format(self._format)
1416
1374
def create_clone_on_transport(self, to_transport, revision_id=None,
1417
stacked_on=None, create_prefix=False, use_existing_dir=False,
1375
stacked_on=None, create_prefix=False, use_existing_dir=False):
1419
1376
"""Create a clone of this branch and its bzrdir.
1421
1378
:param to_transport: The transport to clone onto.
1557
1513
raise AssertionError("invalid heads: %r" % (heads,))
1559
def heads_to_fetch(self):
1560
"""Return the heads that must and that should be fetched to copy this
1561
branch into another repo.
1563
:returns: a 2-tuple of (must_fetch, if_present_fetch). must_fetch is a
1564
set of heads that must be fetched. if_present_fetch is a set of
1565
heads that must be fetched if present, but no error is necessary if
1566
they are not present.
1568
# For bzr native formats must_fetch is just the tip, and if_present_fetch
1570
must_fetch = set([self.last_revision()])
1571
if_present_fetch = set()
1572
c = self.get_config()
1573
include_tags = c.get_user_option_as_bool('branch.fetch_tags',
1577
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1578
except errors.TagsNotSupported:
1580
must_fetch.discard(_mod_revision.NULL_REVISION)
1581
if_present_fetch.discard(_mod_revision.NULL_REVISION)
1582
return must_fetch, if_present_fetch
1585
class BranchFormat(controldir.ControlComponentFormat):
1516
class BranchFormat(object):
1586
1517
"""An encapsulation of the initialization and open routines for a format.
1588
1519
Formats provide three things:
1607
1546
return not (self == other)
1610
@deprecated_method(deprecated_in((2, 4, 0)))
1549
def find_format(klass, a_bzrdir, name=None):
1550
"""Return the format for the branch object in a_bzrdir."""
1552
transport = a_bzrdir.get_branch_transport(None, name=name)
1553
format_string = transport.get_bytes("format")
1554
format = klass._formats[format_string]
1555
if isinstance(format, MetaDirBranchFormatFactory):
1558
except errors.NoSuchFile:
1559
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1561
raise errors.UnknownFormatError(format=format_string, kind='branch')
1611
1564
def get_default_format(klass):
1612
1565
"""Return the current default format."""
1613
return format_registry.get_default()
1566
return klass._default_format
1616
@deprecated_method(deprecated_in((2, 4, 0)))
1617
1569
def get_formats(klass):
1618
1570
"""Get all the known formats.
1620
1572
Warning: This triggers a load of all lazy registered formats: do not
1621
1573
use except when that is desireed.
1623
return format_registry._get_all()
1576
for fmt in klass._formats.values():
1577
if isinstance(fmt, MetaDirBranchFormatFactory):
1625
def get_reference(self, controldir, name=None):
1626
"""Get the target reference of the branch in controldir.
1582
def get_reference(self, a_bzrdir, name=None):
1583
"""Get the target reference of the branch in a_bzrdir.
1628
1585
format probing must have been completed before calling
1629
1586
this method - it is assumed that the format of the branch
1630
in controldir is correct.
1587
in a_bzrdir is correct.
1632
:param controldir: The controldir to get the branch data from.
1589
:param a_bzrdir: The bzrdir to get the branch data from.
1633
1590
:param name: Name of the colocated branch to fetch
1634
1591
:return: None if the branch is not a reference branch.
1639
def set_reference(self, controldir, name, to_branch):
1640
"""Set the target reference of the branch in controldir.
1596
def set_reference(self, a_bzrdir, name, to_branch):
1597
"""Set the target reference of the branch in a_bzrdir.
1642
1599
format probing must have been completed before calling
1643
1600
this method - it is assumed that the format of the branch
1644
in controldir is correct.
1601
in a_bzrdir is correct.
1646
:param controldir: The controldir to set the branch reference for.
1603
:param a_bzrdir: The bzrdir to set the branch reference for.
1647
1604
:param name: Name of colocated branch to set, None for default
1648
1605
:param to_branch: branch that the checkout is to reference
1650
1607
raise NotImplementedError(self.set_reference)
1609
def get_format_string(self):
1610
"""Return the ASCII format string that identifies this format."""
1611
raise NotImplementedError(self.get_format_string)
1652
1613
def get_format_description(self):
1653
1614
"""Return the short format description for this format."""
1654
1615
raise NotImplementedError(self.get_format_description)
1656
def _run_post_branch_init_hooks(self, controldir, name, branch):
1617
def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1657
1618
hooks = Branch.hooks['post_branch_init']
1660
params = BranchInitHookParams(self, controldir, name, branch)
1621
params = BranchInitHookParams(self, a_bzrdir, name, branch)
1661
1622
for hook in hooks:
1664
def initialize(self, controldir, name=None, repository=None,
1665
append_revisions_only=None):
1666
"""Create a branch of this format in controldir.
1625
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1626
lock_type='metadir', set_format=True):
1627
"""Initialize a branch in a bzrdir, with specified files
1629
:param a_bzrdir: The bzrdir to initialize the branch in
1630
:param utf8_files: The files to create as a list of
1631
(filename, content) tuples
1632
:param name: Name of colocated branch to create, if any
1633
:param set_format: If True, set the format with
1634
self.get_format_string. (BzrBranch4 has its format set
1636
:return: a branch in this format
1638
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1639
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1641
'metadir': ('lock', lockdir.LockDir),
1642
'branch4': ('branch-lock', lockable_files.TransportLock),
1644
lock_name, lock_class = lock_map[lock_type]
1645
control_files = lockable_files.LockableFiles(branch_transport,
1646
lock_name, lock_class)
1647
control_files.create_lock()
1649
control_files.lock_write()
1650
except errors.LockContention:
1651
if lock_type != 'branch4':
1657
utf8_files += [('format', self.get_format_string())]
1659
for (filename, content) in utf8_files:
1660
branch_transport.put_bytes(
1662
mode=a_bzrdir._get_file_mode())
1665
control_files.unlock()
1666
branch = self.open(a_bzrdir, name, _found=True)
1667
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1670
def initialize(self, a_bzrdir, name=None):
1671
"""Create a branch of this format in a_bzrdir.
1668
1673
:param name: Name of the colocated branch to create.
1670
1675
raise NotImplementedError(self.initialize)
1716
1720
raise NotImplementedError(self.open)
1719
@deprecated_method(deprecated_in((2, 4, 0)))
1720
1723
def register_format(klass, format):
1721
1724
"""Register a metadir format.
1723
1726
See MetaDirBranchFormatFactory for the ability to register a format
1724
1727
without loading the code the format needs until it is actually used.
1726
format_registry.register(format)
1729
klass._formats[format.get_format_string()] = format
1730
# Metadir formats have a network name of their format string, and get
1731
# registered as factories.
1732
if isinstance(format, MetaDirBranchFormatFactory):
1733
network_format_registry.register(format.get_format_string(), format)
1735
network_format_registry.register(format.get_format_string(),
1729
@deprecated_method(deprecated_in((2, 4, 0)))
1730
1739
def set_default_format(klass, format):
1731
format_registry.set_default(format)
1740
klass._default_format = format
1733
1742
def supports_set_append_revisions_only(self):
1734
1743
"""True if this format supports set_append_revisions_only."""
1804
1800
These are all empty initially, because by default nothing should get
1807
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1808
self.add_hook('set_rh',
1803
Hooks.__init__(self)
1804
self.create_hook(HookPoint('set_rh',
1809
1805
"Invoked whenever the revision history has been set via "
1810
1806
"set_revision_history. The api signature is (branch, "
1811
1807
"revision_history), and the branch will be write-locked. "
1812
1808
"The set_rh hook can be expensive for bzr to trigger, a better "
1813
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1814
self.add_hook('open',
1809
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1810
self.create_hook(HookPoint('open',
1815
1811
"Called with the Branch object that has been opened after a "
1816
"branch is opened.", (1, 8))
1817
self.add_hook('post_push',
1812
"branch is opened.", (1, 8), None))
1813
self.create_hook(HookPoint('post_push',
1818
1814
"Called after a push operation completes. post_push is called "
1819
1815
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1820
"bzr client.", (0, 15))
1821
self.add_hook('post_pull',
1816
"bzr client.", (0, 15), None))
1817
self.create_hook(HookPoint('post_pull',
1822
1818
"Called after a pull operation completes. post_pull is called "
1823
1819
"with a bzrlib.branch.PullResult object and only runs in the "
1824
"bzr client.", (0, 15))
1825
self.add_hook('pre_commit',
1820
"bzr client.", (0, 15), None))
1821
self.create_hook(HookPoint('pre_commit',
1826
1822
"Called after a commit is calculated but before it is "
1827
1823
"completed. pre_commit is called with (local, master, old_revno, "
1828
1824
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1831
1827
"basis revision. hooks MUST NOT modify this delta. "
1832
1828
" future_tree is an in-memory tree obtained from "
1833
1829
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1835
self.add_hook('post_commit',
1830
"tree.", (0,91), None))
1831
self.create_hook(HookPoint('post_commit',
1836
1832
"Called in the bzr client after a commit has completed. "
1837
1833
"post_commit is called with (local, master, old_revno, old_revid, "
1838
1834
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1839
"commit to a branch.", (0, 15))
1840
self.add_hook('post_uncommit',
1835
"commit to a branch.", (0, 15), None))
1836
self.create_hook(HookPoint('post_uncommit',
1841
1837
"Called in the bzr client after an uncommit completes. "
1842
1838
"post_uncommit is called with (local, master, old_revno, "
1843
1839
"old_revid, new_revno, new_revid) where local is the local branch "
1844
1840
"or None, master is the target branch, and an empty branch "
1845
"receives new_revno of 0, new_revid of None.", (0, 15))
1846
self.add_hook('pre_change_branch_tip',
1841
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1842
self.create_hook(HookPoint('pre_change_branch_tip',
1847
1843
"Called in bzr client and server before a change to the tip of a "
1848
1844
"branch is made. pre_change_branch_tip is called with a "
1849
1845
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1850
"commit, uncommit will all trigger this hook.", (1, 6))
1851
self.add_hook('post_change_branch_tip',
1846
"commit, uncommit will all trigger this hook.", (1, 6), None))
1847
self.create_hook(HookPoint('post_change_branch_tip',
1852
1848
"Called in bzr client and server after a change to the tip of a "
1853
1849
"branch is made. post_change_branch_tip is called with a "
1854
1850
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1855
"commit, uncommit will all trigger this hook.", (1, 4))
1856
self.add_hook('transform_fallback_location',
1851
"commit, uncommit will all trigger this hook.", (1, 4), None))
1852
self.create_hook(HookPoint('transform_fallback_location',
1857
1853
"Called when a stacked branch is activating its fallback "
1858
1854
"locations. transform_fallback_location is called with (branch, "
1859
1855
"url), and should return a new url. Returning the same url "
1864
1860
"fallback locations have not been activated. When there are "
1865
1861
"multiple hooks installed for transform_fallback_location, "
1866
1862
"all are called with the url returned from the previous hook."
1867
"The order is however undefined.", (1, 9))
1868
self.add_hook('automatic_tag_name',
1863
"The order is however undefined.", (1, 9), None))
1864
self.create_hook(HookPoint('automatic_tag_name',
1869
1865
"Called to determine an automatic tag name for a revision. "
1870
1866
"automatic_tag_name is called with (branch, revision_id) and "
1871
1867
"should return a tag name or None if no tag name could be "
1872
1868
"determined. The first non-None tag name returned will be used.",
1874
self.add_hook('post_branch_init',
1870
self.create_hook(HookPoint('post_branch_init',
1875
1871
"Called after new branch initialization completes. "
1876
1872
"post_branch_init is called with a "
1877
1873
"bzrlib.branch.BranchInitHookParams. "
1878
1874
"Note that init, branch and checkout (both heavyweight and "
1879
"lightweight) will all trigger this hook.", (2, 2))
1880
self.add_hook('post_switch',
1875
"lightweight) will all trigger this hook.", (2, 2), None))
1876
self.create_hook(HookPoint('post_switch',
1881
1877
"Called after a checkout switches branch. "
1882
1878
"post_switch is called with a "
1883
"bzrlib.branch.SwitchHookParams.", (2, 2))
1879
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1999
1995
self.revision_id)
2002
class BranchFormatMetadir(bzrdir.BzrDirMetaComponentFormat, BranchFormat):
2003
"""Base class for branch formats that live in meta directories.
1998
class BzrBranchFormat4(BranchFormat):
1999
"""Bzr branch format 4.
2002
- a revision-history file.
2003
- a branch-lock lock file [ to be shared with the bzrdir ]
2006
def get_format_description(self):
2007
"""See BranchFormat.get_format_description()."""
2008
return "Branch format 4"
2010
def initialize(self, a_bzrdir, name=None):
2011
"""Create a branch of this format in a_bzrdir."""
2012
utf8_files = [('revision-history', ''),
2013
('branch-name', ''),
2015
return self._initialize_helper(a_bzrdir, utf8_files, name=name,
2016
lock_type='branch4', set_format=False)
2006
2018
def __init__(self):
2007
BranchFormat.__init__(self)
2008
bzrdir.BzrDirMetaComponentFormat.__init__(self)
2011
def find_format(klass, controldir, name=None):
2012
"""Return the format for the branch object in controldir."""
2014
transport = controldir.get_branch_transport(None, name=name)
2015
except errors.NoSuchFile:
2016
raise errors.NotBranchError(path=name, bzrdir=controldir)
2018
format_string = transport.get_bytes("format")
2019
except errors.NoSuchFile:
2020
raise errors.NotBranchError(path=transport.base, bzrdir=controldir)
2021
return klass._find_format(format_registry, 'branch', format_string)
2019
super(BzrBranchFormat4, self).__init__()
2020
self._matchingbzrdir = bzrdir.BzrDirFormat6()
2022
def network_name(self):
2023
"""The network name for this format is the control dirs disk label."""
2024
return self._matchingbzrdir.get_format_string()
2026
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2027
"""See BranchFormat.open()."""
2029
# we are being called directly and must probe.
2030
raise NotImplementedError
2031
return BzrBranch(_format=self,
2032
_control_files=a_bzrdir._control_files,
2035
_repository=a_bzrdir.open_repository())
2038
return "Bazaar-NG branch format 4"
2041
class BranchFormatMetadir(BranchFormat):
2042
"""Common logic for meta-dir based branch formats."""
2023
2044
def _branch_class(self):
2024
2045
"""What class to instantiate on open calls."""
2025
2046
raise NotImplementedError(self._branch_class)
2027
def _get_initial_config(self, append_revisions_only=None):
2028
if append_revisions_only:
2029
return "append_revisions_only = True\n"
2031
# Avoid writing anything if append_revisions_only is disabled,
2032
# as that is the default.
2035
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
2037
"""Initialize a branch in a bzrdir, with specified files
2039
:param a_bzrdir: The bzrdir to initialize the branch in
2040
:param utf8_files: The files to create as a list of
2041
(filename, content) tuples
2042
:param name: Name of colocated branch to create, if any
2043
:return: a branch in this format
2048
def network_name(self):
2049
"""A simple byte string uniquely identifying this format for RPC calls.
2051
Metadir branch formats use their format string.
2045
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2046
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2047
control_files = lockable_files.LockableFiles(branch_transport,
2048
'lock', lockdir.LockDir)
2049
control_files.create_lock()
2050
control_files.lock_write()
2052
utf8_files += [('format', self.get_format_string())]
2053
for (filename, content) in utf8_files:
2054
branch_transport.put_bytes(
2056
mode=a_bzrdir._get_file_mode())
2058
control_files.unlock()
2059
branch = self.open(a_bzrdir, name, _found=True,
2060
found_repository=repository)
2061
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2053
return self.get_format_string()
2064
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2065
found_repository=None, possible_transports=None):
2055
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2066
2056
"""See BranchFormat.open()."""
2068
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2058
format = BranchFormat.find_format(a_bzrdir, name=name)
2069
2059
if format.__class__ != self.__class__:
2070
2060
raise AssertionError("wrong format %r found for %r" %
2071
2061
(format, self))
2074
2064
control_files = lockable_files.LockableFiles(transport, 'lock',
2075
2065
lockdir.LockDir)
2076
if found_repository is None:
2077
found_repository = a_bzrdir.find_repository()
2078
2066
return self._branch_class()(_format=self,
2079
2067
_control_files=control_files,
2081
2069
a_bzrdir=a_bzrdir,
2082
_repository=found_repository,
2083
ignore_fallbacks=ignore_fallbacks,
2084
possible_transports=possible_transports)
2070
_repository=a_bzrdir.find_repository(),
2071
ignore_fallbacks=ignore_fallbacks)
2085
2072
except errors.NoSuchFile:
2086
2073
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2089
def _matchingbzrdir(self):
2090
ret = bzrdir.BzrDirMetaFormat1()
2091
ret.set_branch_format(self)
2076
super(BranchFormatMetadir, self).__init__()
2077
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2078
self._matchingbzrdir.set_branch_format(self)
2094
2080
def supports_tags(self):
2097
def supports_leaving_lock(self):
2101
2084
class BzrBranchFormat5(BranchFormatMetadir):
2102
2085
"""Bzr branch format 5.
2193
2168
"""See BranchFormat.get_format_description()."""
2194
2169
return "Branch format 8"
2196
def initialize(self, a_bzrdir, name=None, repository=None,
2197
append_revisions_only=None):
2171
def initialize(self, a_bzrdir, name=None):
2198
2172
"""Create a branch of this format in a_bzrdir."""
2199
2173
utf8_files = [('last-revision', '0 null:\n'),
2201
self._get_initial_config(append_revisions_only)),
2174
('branch.conf', ''),
2203
2176
('references', '')
2205
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2178
return self._initialize_helper(a_bzrdir, utf8_files, name)
2181
super(BzrBranchFormat8, self).__init__()
2182
self._matchingbzrdir.repository_format = \
2183
RepositoryFormatKnitPack5RichRoot()
2207
2185
def make_tags(self, branch):
2208
2186
"""See bzrlib.branch.BranchFormat.make_tags()."""
2209
return _mod_tag.BasicTags(branch)
2187
return BasicTags(branch)
2211
2189
def supports_set_append_revisions_only(self):
2291
2258
transport = a_bzrdir.get_branch_transport(None, name=name)
2292
2259
location = transport.put_bytes('location', to_branch.base)
2294
def initialize(self, a_bzrdir, name=None, target_branch=None,
2295
repository=None, append_revisions_only=None):
2261
def initialize(self, a_bzrdir, name=None, target_branch=None):
2296
2262
"""Create a branch of this format in a_bzrdir."""
2297
2263
if target_branch is None:
2298
2264
# this format does not implement branch itself, thus the implicit
2299
2265
# creation contract must see it as uninitializable
2300
2266
raise errors.UninitializableFormat(self)
2301
2267
mutter('creating branch reference in %s', a_bzrdir.user_url)
2302
if a_bzrdir._format.fixed_components:
2303
raise errors.IncompatibleFormat(self, a_bzrdir._format)
2304
2268
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2305
2269
branch_transport.put_bytes('location',
2306
target_branch.user_url)
2270
target_branch.bzrdir.user_url)
2307
2271
branch_transport.put_bytes('format', self.get_format_string())
2308
2272
branch = self.open(
2309
2273
a_bzrdir, name, _found=True,
2437
2392
def __init__(self, _format=None,
2438
2393
_control_files=None, a_bzrdir=None, name=None,
2439
_repository=None, ignore_fallbacks=False,
2440
possible_transports=None):
2394
_repository=None, ignore_fallbacks=False):
2441
2395
"""Create new branch object at a particular location."""
2442
2396
if a_bzrdir is None:
2443
2397
raise ValueError('a_bzrdir must be supplied')
2445
2399
self.bzrdir = a_bzrdir
2446
self._user_transport = self.bzrdir.transport.clone('..')
2447
if name is not None:
2448
self._user_transport.set_segment_parameter(
2449
"branch", urlutils.escape(name))
2450
self._base = self._user_transport.base
2400
self._base = self.bzrdir.transport.clone('..').base
2451
2401
self.name = name
2402
# XXX: We should be able to just do
2403
# self.base = self.bzrdir.root_transport.base
2404
# but this does not quite work yet -- mbp 20080522
2452
2405
self._format = _format
2453
2406
if _control_files is None:
2454
2407
raise ValueError('BzrBranch _control_files is None')
2455
2408
self.control_files = _control_files
2456
2409
self._transport = _control_files._transport
2457
2410
self.repository = _repository
2458
Branch.__init__(self, possible_transports)
2411
Branch.__init__(self)
2460
2413
def __str__(self):
2461
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2414
if self.name is None:
2415
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2417
return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2463
2420
__repr__ = __str__
2557
2507
"""See Branch.print_file."""
2558
2508
return self.repository.print_file(file, revision_id)
2510
def _write_revision_history(self, history):
2511
"""Factored out of set_revision_history.
2513
This performs the actual writing to disk.
2514
It is intended to be called by BzrBranch5.set_revision_history."""
2515
self._transport.put_bytes(
2516
'revision-history', '\n'.join(history),
2517
mode=self.bzrdir._get_file_mode())
2520
def set_revision_history(self, rev_history):
2521
"""See Branch.set_revision_history."""
2522
if 'evil' in debug.debug_flags:
2523
mutter_callsite(3, "set_revision_history scales with history.")
2524
check_not_reserved_id = _mod_revision.check_not_reserved_id
2525
for rev_id in rev_history:
2526
check_not_reserved_id(rev_id)
2527
if Branch.hooks['post_change_branch_tip']:
2528
# Don't calculate the last_revision_info() if there are no hooks
2530
old_revno, old_revid = self.last_revision_info()
2531
if len(rev_history) == 0:
2532
revid = _mod_revision.NULL_REVISION
2534
revid = rev_history[-1]
2535
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2536
self._write_revision_history(rev_history)
2537
self._clear_cached_state()
2538
self._cache_revision_history(rev_history)
2539
for hook in Branch.hooks['set_rh']:
2540
hook(self, rev_history)
2541
if Branch.hooks['post_change_branch_tip']:
2542
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2544
def _synchronize_history(self, destination, revision_id):
2545
"""Synchronize last revision and revision history between branches.
2547
This version is most efficient when the destination is also a
2548
BzrBranch5, but works for BzrBranch6 as long as the revision
2549
history is the true lefthand parent history, and all of the revisions
2550
are in the destination's repository. If not, set_revision_history
2553
:param destination: The branch to copy the history into
2554
:param revision_id: The revision-id to truncate history at. May
2555
be None to copy complete history.
2557
if not isinstance(destination._format, BzrBranchFormat5):
2558
super(BzrBranch, self)._synchronize_history(
2559
destination, revision_id)
2561
if revision_id == _mod_revision.NULL_REVISION:
2564
new_history = self.revision_history()
2565
if revision_id is not None and new_history != []:
2567
new_history = new_history[:new_history.index(revision_id) + 1]
2569
rev = self.repository.get_revision(revision_id)
2570
new_history = rev.get_history(self.repository)[1:]
2571
destination.set_revision_history(new_history)
2560
2573
@needs_write_lock
2561
2574
def set_last_revision_info(self, revno, revision_id):
2562
if not revision_id or not isinstance(revision_id, basestring):
2563
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2575
"""Set the last revision of this branch.
2577
The caller is responsible for checking that the revno is correct
2578
for this revision id.
2580
It may be possible to set the branch last revision to an id not
2581
present in the repository. However, branches can also be
2582
configured to check constraints on history, in which case this may not
2564
2585
revision_id = _mod_revision.ensure_null(revision_id)
2565
old_revno, old_revid = self.last_revision_info()
2566
if self.get_append_revisions_only():
2567
self._check_history_violation(revision_id)
2568
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2569
self._write_last_revision_info(revno, revision_id)
2570
self._clear_cached_state()
2571
self._last_revision_info_cache = revno, revision_id
2572
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2586
# this old format stores the full history, but this api doesn't
2587
# provide it, so we must generate, and might as well check it's
2589
history = self._lefthand_history(revision_id)
2590
if len(history) != revno:
2591
raise AssertionError('%d != %d' % (len(history), revno))
2592
self.set_revision_history(history)
2594
def _gen_revision_history(self):
2595
history = self._transport.get_bytes('revision-history').split('\n')
2596
if history[-1:] == ['']:
2597
# There shouldn't be a trailing newline, but just in case.
2602
def generate_revision_history(self, revision_id, last_rev=None,
2604
"""Create a new revision history that will finish with revision_id.
2606
:param revision_id: the new tip to use.
2607
:param last_rev: The previous last_revision. If not None, then this
2608
must be a ancestory of revision_id, or DivergedBranches is raised.
2609
:param other_branch: The other branch that DivergedBranches should
2610
raise with respect to.
2612
self.set_revision_history(self._lefthand_history(revision_id,
2613
last_rev, other_branch))
2574
2615
def basis_tree(self):
2575
2616
"""See Branch.basis_tree."""
2628
def _basic_push(self, target, overwrite, stop_revision):
2629
"""Basic implementation of push without bound branches or hooks.
2631
Must be called with source read locked and target write locked.
2633
result = BranchPushResult()
2634
result.source_branch = self
2635
result.target_branch = target
2636
result.old_revno, result.old_revid = target.last_revision_info()
2637
self.update_references(target)
2638
if result.old_revid != self.last_revision():
2639
# We assume that during 'push' this repository is closer than
2641
graph = self.repository.get_graph(target.repository)
2642
target.update_revisions(self, stop_revision,
2643
overwrite=overwrite, graph=graph)
2644
if self._push_should_merge_tags():
2645
result.tag_conflicts = self.tags.merge_to(target.tags,
2647
result.new_revno, result.new_revid = target.last_revision_info()
2587
2650
def get_stacked_on_url(self):
2588
2651
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2600
2663
self._transport.put_bytes('parent', url + '\n',
2601
2664
mode=self.bzrdir._get_file_mode())
2667
class BzrBranch5(BzrBranch):
2668
"""A format 5 branch. This supports new features over plain branches.
2670
It has support for a master_branch which is the data for bound branches.
2673
def get_bound_location(self):
2675
return self._transport.get_bytes('bound')[:-1]
2676
except errors.NoSuchFile:
2680
def get_master_branch(self, possible_transports=None):
2681
"""Return the branch we are bound to.
2683
:return: Either a Branch, or None
2685
This could memoise the branch, but if thats done
2686
it must be revalidated on each new lock.
2687
So for now we just don't memoise it.
2688
# RBC 20060304 review this decision.
2690
bound_loc = self.get_bound_location()
2694
return Branch.open(bound_loc,
2695
possible_transports=possible_transports)
2696
except (errors.NotBranchError, errors.ConnectionError), e:
2697
raise errors.BoundBranchConnectionFailure(
2603
2700
@needs_write_lock
2605
"""If bound, unbind"""
2606
return self.set_bound_location(None)
2701
def set_bound_location(self, location):
2702
"""Set the target where this branch is bound to.
2704
:param location: URL to the target branch
2707
self._transport.put_bytes('bound', location+'\n',
2708
mode=self.bzrdir._get_file_mode())
2711
self._transport.delete('bound')
2712
except errors.NoSuchFile:
2608
2716
@needs_write_lock
2609
2717
def bind(self, other):
2631
2739
# history around
2632
2740
self.set_bound_location(other.base)
2634
def get_bound_location(self):
2636
return self._transport.get_bytes('bound')[:-1]
2637
except errors.NoSuchFile:
2641
def get_master_branch(self, possible_transports=None):
2642
"""Return the branch we are bound to.
2644
:return: Either a Branch, or None
2646
if self._master_branch_cache is None:
2647
self._master_branch_cache = self._get_master_branch(
2648
possible_transports)
2649
return self._master_branch_cache
2651
def _get_master_branch(self, possible_transports):
2652
bound_loc = self.get_bound_location()
2656
return Branch.open(bound_loc,
2657
possible_transports=possible_transports)
2658
except (errors.NotBranchError, errors.ConnectionError), e:
2659
raise errors.BoundBranchConnectionFailure(
2662
2742
@needs_write_lock
2663
def set_bound_location(self, location):
2664
"""Set the target where this branch is bound to.
2666
:param location: URL to the target branch
2668
self._master_branch_cache = None
2670
self._transport.put_bytes('bound', location+'\n',
2671
mode=self.bzrdir._get_file_mode())
2674
self._transport.delete('bound')
2675
except errors.NoSuchFile:
2744
"""If bound, unbind"""
2745
return self.set_bound_location(None)
2679
2747
@needs_write_lock
2680
2748
def update(self, possible_transports=None):
2696
def _read_last_revision_info(self):
2697
revision_string = self._transport.get_bytes('last-revision')
2698
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2699
revision_id = cache_utf8.get_cached_utf8(revision_id)
2701
return revno, revision_id
2703
def _write_last_revision_info(self, revno, revision_id):
2704
"""Simply write out the revision id, with no checks.
2706
Use set_last_revision_info to perform this safely.
2708
Does not update the revision_history cache.
2710
revision_id = _mod_revision.ensure_null(revision_id)
2711
out_string = '%d %s\n' % (revno, revision_id)
2712
self._transport.put_bytes('last-revision', out_string,
2713
mode=self.bzrdir._get_file_mode())
2716
class FullHistoryBzrBranch(BzrBranch):
2717
"""Bzr branch which contains the full revision history."""
2720
def set_last_revision_info(self, revno, revision_id):
2721
if not revision_id or not isinstance(revision_id, basestring):
2722
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2723
revision_id = _mod_revision.ensure_null(revision_id)
2724
# this old format stores the full history, but this api doesn't
2725
# provide it, so we must generate, and might as well check it's
2727
history = self._lefthand_history(revision_id)
2728
if len(history) != revno:
2729
raise AssertionError('%d != %d' % (len(history), revno))
2730
self._set_revision_history(history)
2732
def _read_last_revision_info(self):
2733
rh = self._revision_history()
2736
return (revno, rh[-1])
2738
return (0, _mod_revision.NULL_REVISION)
2740
@deprecated_method(deprecated_in((2, 4, 0)))
2742
def set_revision_history(self, rev_history):
2743
"""See Branch.set_revision_history."""
2744
self._set_revision_history(rev_history)
2746
def _set_revision_history(self, rev_history):
2747
if 'evil' in debug.debug_flags:
2748
mutter_callsite(3, "set_revision_history scales with history.")
2749
check_not_reserved_id = _mod_revision.check_not_reserved_id
2750
for rev_id in rev_history:
2751
check_not_reserved_id(rev_id)
2752
if Branch.hooks['post_change_branch_tip']:
2753
# Don't calculate the last_revision_info() if there are no hooks
2755
old_revno, old_revid = self.last_revision_info()
2756
if len(rev_history) == 0:
2757
revid = _mod_revision.NULL_REVISION
2759
revid = rev_history[-1]
2760
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2761
self._write_revision_history(rev_history)
2762
self._clear_cached_state()
2763
self._cache_revision_history(rev_history)
2764
for hook in Branch.hooks['set_rh']:
2765
hook(self, rev_history)
2766
if Branch.hooks['post_change_branch_tip']:
2767
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2769
def _write_revision_history(self, history):
2770
"""Factored out of set_revision_history.
2772
This performs the actual writing to disk.
2773
It is intended to be called by set_revision_history."""
2774
self._transport.put_bytes(
2775
'revision-history', '\n'.join(history),
2776
mode=self.bzrdir._get_file_mode())
2778
def _gen_revision_history(self):
2779
history = self._transport.get_bytes('revision-history').split('\n')
2780
if history[-1:] == ['']:
2781
# There shouldn't be a trailing newline, but just in case.
2785
def _synchronize_history(self, destination, revision_id):
2786
if not isinstance(destination, FullHistoryBzrBranch):
2787
super(BzrBranch, self)._synchronize_history(
2788
destination, revision_id)
2790
if revision_id == _mod_revision.NULL_REVISION:
2793
new_history = self._revision_history()
2794
if revision_id is not None and new_history != []:
2796
new_history = new_history[:new_history.index(revision_id) + 1]
2798
rev = self.repository.get_revision(revision_id)
2799
new_history = rev.get_history(self.repository)[1:]
2800
destination._set_revision_history(new_history)
2803
def generate_revision_history(self, revision_id, last_rev=None,
2805
"""Create a new revision history that will finish with revision_id.
2807
:param revision_id: the new tip to use.
2808
:param last_rev: The previous last_revision. If not None, then this
2809
must be a ancestory of revision_id, or DivergedBranches is raised.
2810
:param other_branch: The other branch that DivergedBranches should
2811
raise with respect to.
2813
self._set_revision_history(self._lefthand_history(revision_id,
2814
last_rev, other_branch))
2817
class BzrBranch5(FullHistoryBzrBranch):
2818
"""A format 5 branch. This supports new features over plain branches.
2820
It has support for a master_branch which is the data for bound branches.
2824
class BzrBranch8(BzrBranch):
2765
class BzrBranch8(BzrBranch5):
2825
2766
"""A branch that stores tree-reference locations."""
2827
def _open_hook(self, possible_transports=None):
2768
def _open_hook(self):
2828
2769
if self._ignore_fallbacks:
2830
if possible_transports is None:
2831
possible_transports = [self.bzrdir.root_transport]
2833
2772
url = self.get_stacked_on_url()
2834
2773
except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2856
2794
self._last_revision_info_cache = None
2857
2795
self._reference_info = None
2797
def _last_revision_info(self):
2798
revision_string = self._transport.get_bytes('last-revision')
2799
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2800
revision_id = cache_utf8.get_cached_utf8(revision_id)
2802
return revno, revision_id
2804
def _write_last_revision_info(self, revno, revision_id):
2805
"""Simply write out the revision id, with no checks.
2807
Use set_last_revision_info to perform this safely.
2809
Does not update the revision_history cache.
2810
Intended to be called by set_last_revision_info and
2811
_write_revision_history.
2813
revision_id = _mod_revision.ensure_null(revision_id)
2814
out_string = '%d %s\n' % (revno, revision_id)
2815
self._transport.put_bytes('last-revision', out_string,
2816
mode=self.bzrdir._get_file_mode())
2819
def set_last_revision_info(self, revno, revision_id):
2820
revision_id = _mod_revision.ensure_null(revision_id)
2821
old_revno, old_revid = self.last_revision_info()
2822
if self._get_append_revisions_only():
2823
self._check_history_violation(revision_id)
2824
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2825
self._write_last_revision_info(revno, revision_id)
2826
self._clear_cached_state()
2827
self._last_revision_info_cache = revno, revision_id
2828
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2830
def _synchronize_history(self, destination, revision_id):
2831
"""Synchronize last revision and revision history between branches.
2833
:see: Branch._synchronize_history
2835
# XXX: The base Branch has a fast implementation of this method based
2836
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2837
# that uses set_revision_history. This class inherits from BzrBranch5,
2838
# but wants the fast implementation, so it calls
2839
# Branch._synchronize_history directly.
2840
Branch._synchronize_history(self, destination, revision_id)
2859
2842
def _check_history_violation(self, revision_id):
2860
current_revid = self.last_revision()
2861
last_revision = _mod_revision.ensure_null(current_revid)
2843
last_revision = _mod_revision.ensure_null(self.last_revision())
2862
2844
if _mod_revision.is_null(last_revision):
2864
graph = self.repository.get_graph()
2865
for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
2866
if lh_ancestor == current_revid:
2868
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2846
if last_revision not in self._lefthand_history(revision_id):
2847
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2870
2849
def _gen_revision_history(self):
2871
2850
"""Generate the revision history from last revision
2966
2961
def set_bound_location(self, location):
2967
2962
"""See Branch.set_push_location."""
2968
self._master_branch_cache = None
2970
conf = self.get_config_stack()
2964
config = self.get_config()
2971
2965
if location is None:
2972
if not conf.get('bound'):
2966
if config.get_user_option('bound') != 'True':
2975
conf.set('bound', 'False')
2969
config.set_user_option('bound', 'False', warn_masked=True)
2978
2972
self._set_config_location('bound_location', location,
2980
conf.set('bound', 'True')
2974
config.set_user_option('bound', 'True', warn_masked=True)
2983
2977
def _get_bound_location(self, bound):
2984
2978
"""Return the bound location in the config file.
2986
2980
Return None if the bound parameter does not match"""
2987
conf = self.get_config_stack()
2988
if conf.get('bound') != bound:
2981
config = self.get_config()
2982
config_bound = (config.get_user_option('bound') == 'True')
2983
if config_bound != bound:
2990
return self._get_config_location('bound_location', config=conf)
2985
return self._get_config_location('bound_location', config=config)
2992
2987
def get_bound_location(self):
2993
2988
"""See Branch.set_push_location."""
3001
2996
# you can always ask for the URL; but you might not be able to use it
3002
2997
# if the repo can't support stacking.
3003
2998
## self._check_stackable_repo()
3004
# stacked_on_location is only ever defined in branch.conf, so don't
3005
# waste effort reading the whole stack of config files.
3006
conf = _mod_config.BranchOnlyStack(self)
3007
stacked_url = self._get_config_location('stacked_on_location',
2999
stacked_url = self._get_config_location('stacked_on_location')
3009
3000
if stacked_url is None:
3010
3001
raise errors.NotStacked(self)
3011
3002
return stacked_url
3004
def _get_append_revisions_only(self):
3005
return self.get_config(
3006
).get_user_option_as_bool('append_revisions_only')
3009
def generate_revision_history(self, revision_id, last_rev=None,
3011
"""See BzrBranch5.generate_revision_history"""
3012
history = self._lefthand_history(revision_id, last_rev, other_branch)
3013
revno = len(history)
3014
self.set_last_revision_info(revno, revision_id)
3013
3016
@needs_read_lock
3014
3017
def get_rev_id(self, revno, history=None):
3015
3018
"""Find the revision id of the specified revno."""
3158
3148
return self.new_revno - self.old_revno
3160
3150
def report(self, to_file):
3161
# TODO: This function gets passed a to_file, but then
3162
# ignores it and calls note() instead. This is also
3163
# inconsistent with PullResult(), which writes to stdout.
3164
# -- JRV20110901, bug #838853
3165
tag_conflicts = getattr(self, "tag_conflicts", None)
3166
tag_updates = getattr(self, "tag_updates", None)
3168
if self.old_revid != self.new_revid:
3169
note(gettext('Pushed up to revision %d.') % self.new_revno)
3171
note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
3172
if self.old_revid == self.new_revid and not tag_updates:
3173
if not tag_conflicts:
3174
note(gettext('No new revisions or tags to push.'))
3176
note(gettext('No new revisions to push.'))
3151
"""Write a human-readable description of the result."""
3152
if self.old_revid == self.new_revid:
3153
note('No new revisions to push.')
3155
note('Pushed up to revision %d.' % self.new_revno)
3177
3156
self._show_tag_conficts(to_file)
3349
3366
self.source.tags.merge_to(self.target.tags)
3351
3368
@needs_write_lock
3352
def fetch(self, stop_revision=None, limit=None):
3353
if self.target.base == self.source.base:
3355
self.source.lock_read()
3357
fetch_spec_factory = fetch.FetchSpecFactory()
3358
fetch_spec_factory.source_branch = self.source
3359
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3360
fetch_spec_factory.source_repo = self.source.repository
3361
fetch_spec_factory.target_repo = self.target.repository
3362
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3363
fetch_spec_factory.limit = limit
3364
fetch_spec = fetch_spec_factory.make_fetch_spec()
3365
return self.target.repository.fetch(self.source.repository,
3366
fetch_spec=fetch_spec)
3368
self.source.unlock()
3371
def _update_revisions(self, stop_revision=None, overwrite=False,
3369
def update_revisions(self, stop_revision=None, overwrite=False,
3371
"""See InterBranch.update_revisions()."""
3373
3372
other_revno, other_last_revision = self.source.last_revision_info()
3374
3373
stop_revno = None # unknown
3375
3374
if stop_revision is None:
3442
3431
return self._pull(overwrite,
3443
3432
stop_revision, _hook_master=master_branch,
3444
3433
run_hooks=run_hooks,
3445
_override_hook_target=_override_hook_target,
3446
merge_tags_to_master=not source_is_master)
3434
_override_hook_target=_override_hook_target)
3448
3436
if master_branch:
3449
3437
master_branch.unlock()
3451
def push(self, overwrite=False, stop_revision=None, lossy=False,
3439
def push(self, overwrite=False, stop_revision=None,
3452
3440
_override_hook_source_branch=None):
3453
3441
"""See InterBranch.push.
3455
3443
This is the basic concrete implementation of push()
3457
:param _override_hook_source_branch: If specified, run the hooks
3458
passing this Branch as the source, rather than self. This is for
3459
use of RemoteBranch, where push is delegated to the underlying
3445
:param _override_hook_source_branch: If specified, run
3446
the hooks passing this Branch as the source, rather than self.
3447
This is for use of RemoteBranch, where push is delegated to the
3448
underlying vfs-based Branch.
3463
raise errors.LossyPushToSameVCS(self.source, self.target)
3464
3450
# TODO: Public option to disable running hooks - should be trivial but
3467
op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3468
op.add_cleanup(self.source.lock_read().unlock)
3469
op.add_cleanup(self.target.lock_write().unlock)
3470
return op.run(overwrite, stop_revision,
3471
_override_hook_source_branch=_override_hook_source_branch)
3473
def _basic_push(self, overwrite, stop_revision):
3474
"""Basic implementation of push without bound branches or hooks.
3476
Must be called with source read locked and target write locked.
3478
result = BranchPushResult()
3479
result.source_branch = self.source
3480
result.target_branch = self.target
3481
result.old_revno, result.old_revid = self.target.last_revision_info()
3482
self.source.update_references(self.target)
3483
if result.old_revid != stop_revision:
3484
# We assume that during 'push' this repository is closer than
3486
graph = self.source.repository.get_graph(self.target.repository)
3487
self._update_revisions(stop_revision, overwrite=overwrite,
3489
if self.source._push_should_merge_tags():
3490
result.tag_updates, result.tag_conflicts = (
3491
self.source.tags.merge_to(self.target.tags, overwrite))
3492
result.new_revno, result.new_revid = self.target.last_revision_info()
3495
def _push_with_bound_branches(self, operation, overwrite, stop_revision,
3452
self.source.lock_read()
3454
return _run_with_write_locked_target(
3455
self.target, self._push_with_bound_branches, overwrite,
3457
_override_hook_source_branch=_override_hook_source_branch)
3459
self.source.unlock()
3461
def _push_with_bound_branches(self, overwrite, stop_revision,
3496
3462
_override_hook_source_branch=None):
3497
3463
"""Push from source into target, and into target's master if any.
3510
3476
# be bound to itself? -- mbp 20070507
3511
3477
master_branch = self.target.get_master_branch()
3512
3478
master_branch.lock_write()
3513
operation.add_cleanup(master_branch.unlock)
3514
# push into the master from the source branch.
3515
master_inter = InterBranch.get(self.source, master_branch)
3516
master_inter._basic_push(overwrite, stop_revision)
3517
# and push into the target branch from the source. Note that
3518
# we push from the source branch again, because it's considered
3519
# the highest bandwidth repository.
3520
result = self._basic_push(overwrite, stop_revision)
3521
result.master_branch = master_branch
3522
result.local_branch = self.target
3480
# push into the master from the source branch.
3481
self.source._basic_push(master_branch, overwrite, stop_revision)
3482
# and push into the target branch from the source. Note that we
3483
# push from the source branch again, because it's considered the
3484
# highest bandwidth repository.
3485
result = self.source._basic_push(self.target, overwrite,
3487
result.master_branch = master_branch
3488
result.local_branch = self.target
3492
master_branch.unlock()
3524
master_branch = None
3525
3494
# no master branch
3526
result = self._basic_push(overwrite, stop_revision)
3495
result = self.source._basic_push(self.target, overwrite,
3527
3497
# TODO: Why set master_branch and local_branch if there's no
3528
3498
# binding? Maybe cleaner to just leave them unset? -- mbp
3530
3500
result.master_branch = self.target
3531
3501
result.local_branch = None
3535
3505
def _pull(self, overwrite=False, stop_revision=None,
3536
3506
possible_transports=None, _hook_master=None, run_hooks=True,
3537
_override_hook_target=None, local=False,
3538
merge_tags_to_master=True):
3507
_override_hook_target=None, local=False):
3539
3508
"""See Branch.pull.
3541
3510
This function is the core worker, used by GenericInterBranch.pull to
added
removed
bzrlib/branch.py
