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
18
21
from cStringIO import StringIO
21
23
from bzrlib.lazy_import import lazy_import
22
24
lazy_import(globals(), """
23
from itertools import chain
24
26
from bzrlib import (
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 (
31
config as _mod_config,
40
revision as _mod_revision,
48
from bzrlib.i18n import gettext, ngettext
51
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
52
from bzrlib.hooks import HookPoint, Hooks
51
# Explicitly import bzrlib.bzrdir so that the BzrProber
52
# is guaranteed to be registered.
59
from bzrlib.decorators import (
64
from bzrlib.hooks import Hooks
53
65
from bzrlib.inter import InterObject
54
66
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
55
67
from bzrlib import registry
86
94
def user_transport(self):
87
95
return self.bzrdir.user_transport
89
def __init__(self, *ignored, **ignored_too):
97
def __init__(self, possible_transports=None):
90
98
self.tags = self._format.make_tags(self)
91
99
self._revision_history_cache = None
92
100
self._revision_id_to_revno_cache = None
93
101
self._partial_revision_id_to_revno_cache = {}
94
102
self._partial_revision_history_cache = []
103
self._tags_bytes = None
95
104
self._last_revision_info_cache = None
105
self._master_branch_cache = None
96
106
self._merge_sorted_revisions_cache = None
107
self._open_hook(possible_transports)
98
108
hooks = Branch.hooks['open']
99
109
for hook in hooks:
102
def _open_hook(self):
112
def _open_hook(self, possible_transports):
103
113
"""Called by init to allow simpler extension of the base class."""
105
def _activate_fallback_location(self, url):
115
def _activate_fallback_location(self, url, possible_transports):
106
116
"""Activate the branch/repository from url as a fallback repository."""
107
repo = self._get_fallback_repository(url)
117
for existing_fallback_repo in self.repository._fallback_repositories:
118
if existing_fallback_repo.user_url == url:
119
# This fallback is already configured. This probably only
120
# happens because ControlDir.sprout is a horrible mess. To avoid
121
# confusing _unstack we don't add this a second time.
122
mutter('duplicate activation of fallback %r on %r', url, self)
124
repo = self._get_fallback_repository(url, possible_transports)
108
125
if repo.has_same_location(self.repository):
109
126
raise errors.UnstackableLocationError(self.user_url, url)
110
127
self.repository.add_fallback_repository(repo)
164
181
For instance, if the branch is at URL/.bzr/branch,
165
182
Branch.open(URL) -> a Branch instance.
167
control = bzrdir.BzrDir.open(base, _unsupported,
168
possible_transports=possible_transports)
169
return control.open_branch(unsupported=_unsupported)
184
control = controldir.ControlDir.open(base,
185
possible_transports=possible_transports, _unsupported=_unsupported)
186
return control.open_branch(unsupported=_unsupported,
187
possible_transports=possible_transports)
172
def open_from_transport(transport, name=None, _unsupported=False):
190
def open_from_transport(transport, name=None, _unsupported=False,
191
possible_transports=None):
173
192
"""Open the branch rooted at transport"""
174
control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
175
return control.open_branch(name=name, unsupported=_unsupported)
193
control = controldir.ControlDir.open_from_transport(transport, _unsupported)
194
return control.open_branch(name=name, unsupported=_unsupported,
195
possible_transports=possible_transports)
178
198
def open_containing(url, possible_transports=None):
492
527
rev_iter = iter(merge_sorted_revisions)
493
528
if start_revision_id is not None:
494
529
for node in rev_iter:
495
rev_id = node.key[-1]
496
531
if rev_id != start_revision_id:
499
534
# The decision to include the start or not
500
535
# depends on the stop_rule if a stop is provided
501
536
# so pop this node back into the iterator
502
rev_iter = chain(iter([node]), rev_iter)
537
rev_iter = itertools.chain(iter([node]), rev_iter)
504
539
if stop_revision_id is None:
505
540
# Yield everything
506
541
for node in rev_iter:
507
rev_id = node.key[-1]
508
543
yield (rev_id, node.merge_depth, node.revno,
509
544
node.end_of_merge)
510
545
elif stop_rule == 'exclude':
511
546
for node in rev_iter:
512
rev_id = node.key[-1]
513
548
if rev_id == stop_revision_id:
515
550
yield (rev_id, node.merge_depth, node.revno,
516
551
node.end_of_merge)
517
552
elif stop_rule == 'include':
518
553
for node in rev_iter:
519
rev_id = node.key[-1]
520
555
yield (rev_id, node.merge_depth, node.revno,
521
556
node.end_of_merge)
522
557
if rev_id == stop_revision_id:
649
686
raise errors.UnsupportedOperation(self.get_reference_info, self)
651
688
@needs_write_lock
652
def fetch(self, from_branch, last_revision=None, pb=None):
689
def fetch(self, from_branch, last_revision=None, limit=None):
653
690
"""Copy revisions from from_branch into this branch.
655
692
:param from_branch: Where to copy from.
656
693
:param last_revision: What revision to stop at (None for at the end
658
:param pb: An optional progress bar to use.
695
:param limit: Optional rough limit of revisions to fetch
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,
698
return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)
678
700
def get_bound_location(self):
679
701
"""Return the URL of the branch we are bound to.
700
722
:param committer: Optional committer to set for commit.
701
723
:param revprops: Optional dictionary of revision properties.
702
724
:param revision_id: Optional revision id.
725
:param lossy: Whether to discard data that can not be natively
726
represented, when pushing to a foreign VCS
706
config = self.get_config()
729
if config_stack is None:
730
config_stack = self.get_config_stack()
708
return self.repository.get_commit_builder(self, parents, config,
709
timestamp, timezone, committer, revprops, revision_id)
732
return self.repository.get_commit_builder(self, parents, config_stack,
733
timestamp, timezone, committer, revprops, revision_id,
711
736
def get_master_branch(self, possible_transports=None):
712
737
"""Return the branch we are bound to.
739
766
"""Print `file` to stdout."""
740
767
raise NotImplementedError(self.print_file)
769
@deprecated_method(deprecated_in((2, 4, 0)))
742
770
def set_revision_history(self, rev_history):
743
raise NotImplementedError(self.set_revision_history)
771
"""See Branch.set_revision_history."""
772
self._set_revision_history(rev_history)
775
def _set_revision_history(self, rev_history):
776
if len(rev_history) == 0:
777
revid = _mod_revision.NULL_REVISION
779
revid = rev_history[-1]
780
if rev_history != self._lefthand_history(revid):
781
raise errors.NotLefthandHistory(rev_history)
782
self.set_last_revision_info(len(rev_history), revid)
783
self._cache_revision_history(rev_history)
784
for hook in Branch.hooks['set_rh']:
785
hook(self, rev_history)
788
def set_last_revision_info(self, revno, revision_id):
789
"""Set the last revision of this branch.
791
The caller is responsible for checking that the revno is correct
792
for this revision id.
794
It may be possible to set the branch last revision to an id not
795
present in the repository. However, branches can also be
796
configured to check constraints on history, in which case this may not
799
raise NotImplementedError(self.set_last_revision_info)
802
def generate_revision_history(self, revision_id, last_rev=None,
804
"""See Branch.generate_revision_history"""
805
graph = self.repository.get_graph()
806
(last_revno, last_revid) = self.last_revision_info()
807
known_revision_ids = [
808
(last_revid, last_revno),
809
(_mod_revision.NULL_REVISION, 0),
811
if last_rev is not None:
812
if not graph.is_ancestor(last_rev, revision_id):
813
# our previous tip is not merged into stop_revision
814
raise errors.DivergedBranches(self, other_branch)
815
revno = graph.find_distance_to_null(revision_id, known_revision_ids)
816
self.set_last_revision_info(revno, revision_id)
745
818
@needs_write_lock
746
819
def set_parent(self, url):
968
1056
:return: A tuple (revno, revision_id).
970
1058
if self._last_revision_info_cache is None:
971
self._last_revision_info_cache = self._last_revision_info()
1059
self._last_revision_info_cache = self._read_last_revision_info()
972
1060
return self._last_revision_info_cache
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,
1062
def _read_last_revision_info(self):
1063
raise NotImplementedError(self._read_last_revision_info)
1065
@deprecated_method(deprecated_in((2, 4, 0)))
1020
1066
def import_last_revision_info(self, source_repo, revno, revid):
1021
1067
"""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.
1026
1069
:param source_repo: Source repository to optionally fetch from
1027
1070
:param revno: Revision number of the new tip
1028
1071
:param revid: Revision id of the new tip
1031
1074
self.repository.fetch(source_repo, revision_id=revid)
1032
1075
self.set_last_revision_info(revno, revid)
1077
def import_last_revision_info_and_tags(self, source, revno, revid,
1079
"""Set the last revision info, importing from another repo if necessary.
1081
This is used by the bound branch code to upload a revision to
1082
the master branch first before updating the tip of the local branch.
1083
Revisions referenced by source's tags are also transferred.
1085
:param source: Source branch to optionally fetch from
1086
:param revno: Revision number of the new tip
1087
:param revid: Revision id of the new tip
1088
:param lossy: Whether to discard metadata that can not be
1089
natively represented
1090
:return: Tuple with the new revision number and revision id
1091
(should only be different from the arguments when lossy=True)
1093
if not self.repository.has_same_location(source.repository):
1094
self.fetch(source, revid)
1095
self.set_last_revision_info(revno, revid)
1096
return (revno, revid)
1034
1098
def revision_id_to_revno(self, revision_id):
1035
1099
"""Given a revision id, return its revno"""
1036
1100
if _mod_revision.is_null(revision_id):
1038
history = self.revision_history()
1102
history = self._revision_history()
1040
1104
return history.index(revision_id) + 1
1041
1105
except ValueError:
1068
1132
stop_revision=stop_revision,
1069
1133
possible_transports=possible_transports, *args, **kwargs)
1071
def push(self, target, overwrite=False, stop_revision=None, *args,
1135
def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1073
1137
"""Mirror this branch into target.
1075
1139
This branch is considered to be 'local', having low latency.
1077
1141
return InterBranch.get(self, target).push(overwrite, stop_revision,
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)
1142
lossy, *args, **kwargs)
1101
1144
def basis_tree(self):
1102
1145
"""Return `Tree` object for last revision."""
1354
1400
# TODO: We should probably also check that self.revision_history
1355
1401
# matches the repository for older branch formats.
1356
1402
# If looking for the code that cross-checks repository parents against
1357
# the iter_reverse_revision_history output, that is now a repository
1403
# the Graph.iter_lefthand_ancestry output, that is now a repository
1358
1404
# specific check.
1361
def _get_checkout_format(self):
1407
def _get_checkout_format(self, lightweight=False):
1362
1408
"""Return the most suitable metadir for a checkout of this branch.
1363
1409
Weaves are used if this branch's repository uses weaves.
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)
1411
format = self.repository.bzrdir.checkout_metadir()
1412
format.set_branch_format(self._format)
1374
1415
def create_clone_on_transport(self, to_transport, revision_id=None,
1375
stacked_on=None, create_prefix=False, use_existing_dir=False):
1416
stacked_on=None, create_prefix=False, use_existing_dir=False,
1376
1418
"""Create a clone of this branch and its bzrdir.
1378
1420
:param to_transport: The transport to clone onto.
1414
1457
t = transport.get_transport(to_location)
1415
1458
t.ensure_base()
1459
format = self._get_checkout_format(lightweight=lightweight)
1461
checkout = format.initialize_on_transport(t)
1462
except errors.AlreadyControlDirError:
1463
# It's fine if the control directory already exists,
1464
# as long as there is no existing branch and working tree.
1465
checkout = controldir.ControlDir.open_from_transport(t)
1467
checkout.open_branch()
1468
except errors.NotBranchError:
1471
raise errors.AlreadyControlDirError(t.base)
1416
1473
if lightweight:
1417
format = self._get_checkout_format()
1418
checkout = format.initialize_on_transport(t)
1419
from_branch = BranchReferenceFormat().initialize(checkout,
1474
from_branch = checkout.set_branch_reference(target_branch=self)
1422
format = self._get_checkout_format()
1423
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1424
to_location, force_new_tree=False, format=format)
1425
checkout = checkout_branch.bzrdir
1476
policy = checkout.determine_repository_policy()
1477
repo = policy.acquire_repository()[0]
1478
checkout_branch = checkout.create_branch()
1426
1479
checkout_branch.bind(self)
1427
1480
# pull up to the specified revision_id to set the initial
1428
1481
# branch tip correctly, and seed it with history.
1429
1482
checkout_branch.pull(self, stop_revision=revision_id)
1431
1484
tree = checkout.create_workingtree(revision_id,
1432
1485
from_branch=from_branch,
1433
1486
accelerator_tree=accelerator_tree,
1513
1567
raise AssertionError("invalid heads: %r" % (heads,))
1516
class BranchFormat(object):
1569
def heads_to_fetch(self):
1570
"""Return the heads that must and that should be fetched to copy this
1571
branch into another repo.
1573
:returns: a 2-tuple of (must_fetch, if_present_fetch). must_fetch is a
1574
set of heads that must be fetched. if_present_fetch is a set of
1575
heads that must be fetched if present, but no error is necessary if
1576
they are not present.
1578
# For bzr native formats must_fetch is just the tip, and
1579
# if_present_fetch are the tags.
1580
must_fetch = set([self.last_revision()])
1581
if_present_fetch = set()
1582
if self.get_config_stack().get('branch.fetch_tags'):
1584
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1585
except errors.TagsNotSupported:
1587
must_fetch.discard(_mod_revision.NULL_REVISION)
1588
if_present_fetch.discard(_mod_revision.NULL_REVISION)
1589
return must_fetch, if_present_fetch
1592
class BranchFormat(controldir.ControlComponentFormat):
1517
1593
"""An encapsulation of the initialization and open routines for a format.
1519
1595
Formats provide three things:
1520
1596
* An initialization routine,
1597
* a format description
1522
1598
* an open routine.
1524
1600
Formats are placed in an dict by their format string for reference
1525
during branch opening. Its not required that these be instances, they
1601
during branch opening. It's not required that these be instances, they
1526
1602
can be classes themselves with class methods - it simply depends on
1527
1603
whether state is needed for a given format or not.
1546
1614
return not (self == other)
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')
1617
@deprecated_method(deprecated_in((2, 4, 0)))
1564
1618
def get_default_format(klass):
1565
1619
"""Return the current default format."""
1566
return klass._default_format
1620
return format_registry.get_default()
1623
@deprecated_method(deprecated_in((2, 4, 0)))
1569
1624
def get_formats(klass):
1570
1625
"""Get all the known formats.
1572
1627
Warning: This triggers a load of all lazy registered formats: do not
1573
1628
use except when that is desireed.
1576
for fmt in klass._formats.values():
1577
if isinstance(fmt, MetaDirBranchFormatFactory):
1630
return format_registry._get_all()
1582
def get_reference(self, a_bzrdir, name=None):
1583
"""Get the target reference of the branch in a_bzrdir.
1632
def get_reference(self, controldir, name=None):
1633
"""Get the target reference of the branch in controldir.
1585
1635
format probing must have been completed before calling
1586
1636
this method - it is assumed that the format of the branch
1587
in a_bzrdir is correct.
1637
in controldir is correct.
1589
:param a_bzrdir: The bzrdir to get the branch data from.
1639
:param controldir: The controldir to get the branch data from.
1590
1640
:param name: Name of the colocated branch to fetch
1591
1641
:return: None if the branch is not a reference branch.
1596
def set_reference(self, a_bzrdir, name, to_branch):
1597
"""Set the target reference of the branch in a_bzrdir.
1646
def set_reference(self, controldir, name, to_branch):
1647
"""Set the target reference of the branch in controldir.
1599
1649
format probing must have been completed before calling
1600
1650
this method - it is assumed that the format of the branch
1601
in a_bzrdir is correct.
1651
in controldir is correct.
1603
:param a_bzrdir: The bzrdir to set the branch reference for.
1653
:param controldir: The controldir to set the branch reference for.
1604
1654
:param name: Name of colocated branch to set, None for default
1605
1655
:param to_branch: branch that the checkout is to reference
1607
1657
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)
1613
1659
def get_format_description(self):
1614
1660
"""Return the short format description for this format."""
1615
1661
raise NotImplementedError(self.get_format_description)
1617
def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1663
def _run_post_branch_init_hooks(self, controldir, name, branch):
1618
1664
hooks = Branch.hooks['post_branch_init']
1621
params = BranchInitHookParams(self, a_bzrdir, name, branch)
1667
params = BranchInitHookParams(self, controldir, name, branch)
1622
1668
for hook in hooks:
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.
1671
def initialize(self, controldir, name=None, repository=None,
1672
append_revisions_only=None):
1673
"""Create a branch of this format in controldir.
1673
1675
:param name: Name of the colocated branch to create.
1675
1677
raise NotImplementedError(self.initialize)
1720
1723
raise NotImplementedError(self.open)
1726
@deprecated_method(deprecated_in((2, 4, 0)))
1723
1727
def register_format(klass, format):
1724
1728
"""Register a metadir format.
1726
1730
See MetaDirBranchFormatFactory for the ability to register a format
1727
1731
without loading the code the format needs until it is actually used.
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(),
1733
format_registry.register(format)
1736
@deprecated_method(deprecated_in((2, 4, 0)))
1739
1737
def set_default_format(klass, format):
1740
klass._default_format = format
1738
format_registry.set_default(format)
1742
1740
def supports_set_append_revisions_only(self):
1743
1741
"""True if this format supports set_append_revisions_only."""
1800
1811
These are all empty initially, because by default nothing should get
1803
Hooks.__init__(self)
1804
self.create_hook(HookPoint('set_rh',
1814
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1815
self.add_hook('set_rh',
1805
1816
"Invoked whenever the revision history has been set via "
1806
1817
"set_revision_history. The api signature is (branch, "
1807
1818
"revision_history), and the branch will be write-locked. "
1808
1819
"The set_rh hook can be expensive for bzr to trigger, a better "
1809
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1810
self.create_hook(HookPoint('open',
1820
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1821
self.add_hook('open',
1811
1822
"Called with the Branch object that has been opened after a "
1812
"branch is opened.", (1, 8), None))
1813
self.create_hook(HookPoint('post_push',
1823
"branch is opened.", (1, 8))
1824
self.add_hook('post_push',
1814
1825
"Called after a push operation completes. post_push is called "
1815
1826
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1816
"bzr client.", (0, 15), None))
1817
self.create_hook(HookPoint('post_pull',
1827
"bzr client.", (0, 15))
1828
self.add_hook('post_pull',
1818
1829
"Called after a pull operation completes. post_pull is called "
1819
1830
"with a bzrlib.branch.PullResult object and only runs in the "
1820
"bzr client.", (0, 15), None))
1821
self.create_hook(HookPoint('pre_commit',
1822
"Called after a commit is calculated but before it is is "
1831
"bzr client.", (0, 15))
1832
self.add_hook('pre_commit',
1833
"Called after a commit is calculated but before it is "
1823
1834
"completed. pre_commit is called with (local, master, old_revno, "
1824
1835
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1825
1836
"). old_revid is NULL_REVISION for the first commit to a branch, "
1827
1838
"basis revision. hooks MUST NOT modify this delta. "
1828
1839
" future_tree is an in-memory tree obtained from "
1829
1840
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1830
"tree.", (0,91), None))
1831
self.create_hook(HookPoint('post_commit',
1842
self.add_hook('post_commit',
1832
1843
"Called in the bzr client after a commit has completed. "
1833
1844
"post_commit is called with (local, master, old_revno, old_revid, "
1834
1845
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1835
"commit to a branch.", (0, 15), None))
1836
self.create_hook(HookPoint('post_uncommit',
1846
"commit to a branch.", (0, 15))
1847
self.add_hook('post_uncommit',
1837
1848
"Called in the bzr client after an uncommit completes. "
1838
1849
"post_uncommit is called with (local, master, old_revno, "
1839
1850
"old_revid, new_revno, new_revid) where local is the local branch "
1840
1851
"or None, master is the target branch, and an empty branch "
1841
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1842
self.create_hook(HookPoint('pre_change_branch_tip',
1852
"receives new_revno of 0, new_revid of None.", (0, 15))
1853
self.add_hook('pre_change_branch_tip',
1843
1854
"Called in bzr client and server before a change to the tip of a "
1844
1855
"branch is made. pre_change_branch_tip is called with a "
1845
1856
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1846
"commit, uncommit will all trigger this hook.", (1, 6), None))
1847
self.create_hook(HookPoint('post_change_branch_tip',
1857
"commit, uncommit will all trigger this hook.", (1, 6))
1858
self.add_hook('post_change_branch_tip',
1848
1859
"Called in bzr client and server after a change to the tip of a "
1849
1860
"branch is made. post_change_branch_tip is called with a "
1850
1861
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1851
"commit, uncommit will all trigger this hook.", (1, 4), None))
1852
self.create_hook(HookPoint('transform_fallback_location',
1862
"commit, uncommit will all trigger this hook.", (1, 4))
1863
self.add_hook('transform_fallback_location',
1853
1864
"Called when a stacked branch is activating its fallback "
1854
1865
"locations. transform_fallback_location is called with (branch, "
1855
1866
"url), and should return a new url. Returning the same url "
1860
1871
"fallback locations have not been activated. When there are "
1861
1872
"multiple hooks installed for transform_fallback_location, "
1862
1873
"all are called with the url returned from the previous hook."
1863
"The order is however undefined.", (1, 9), None))
1864
self.create_hook(HookPoint('automatic_tag_name',
1874
"The order is however undefined.", (1, 9))
1875
self.add_hook('automatic_tag_name',
1865
1876
"Called to determine an automatic tag name for a revision. "
1866
1877
"automatic_tag_name is called with (branch, revision_id) and "
1867
1878
"should return a tag name or None if no tag name could be "
1868
1879
"determined. The first non-None tag name returned will be used.",
1870
self.create_hook(HookPoint('post_branch_init',
1881
self.add_hook('post_branch_init',
1871
1882
"Called after new branch initialization completes. "
1872
1883
"post_branch_init is called with a "
1873
1884
"bzrlib.branch.BranchInitHookParams. "
1874
1885
"Note that init, branch and checkout (both heavyweight and "
1875
"lightweight) will all trigger this hook.", (2, 2), None))
1876
self.create_hook(HookPoint('post_switch',
1886
"lightweight) will all trigger this hook.", (2, 2))
1887
self.add_hook('post_switch',
1877
1888
"Called after a checkout switches branch. "
1878
1889
"post_switch is called with a "
1879
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1890
"bzrlib.branch.SwitchHookParams.", (2, 2))
1995
2006
self.revision_id)
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 ]
2009
class BranchFormatMetadir(bzrdir.BzrFormat, BranchFormat):
2010
"""Base class for branch formats that live in meta directories.
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)
2018
2013
def __init__(self):
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."""
2014
BranchFormat.__init__(self)
2015
bzrdir.BzrFormat.__init__(self)
2018
def find_format(klass, controldir, name=None):
2019
"""Return the format for the branch object in controldir."""
2021
transport = controldir.get_branch_transport(None, name=name)
2022
except errors.NoSuchFile:
2023
raise errors.NotBranchError(path=name, bzrdir=controldir)
2025
format_string = transport.get_bytes("format")
2026
except errors.NoSuchFile:
2027
raise errors.NotBranchError(path=transport.base, bzrdir=controldir)
2028
return klass._find_format(format_registry, 'branch', format_string)
2044
2030
def _branch_class(self):
2045
2031
"""What class to instantiate on open calls."""
2046
2032
raise NotImplementedError(self._branch_class)
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.
2034
def _get_initial_config(self, append_revisions_only=None):
2035
if append_revisions_only:
2036
return "append_revisions_only = True\n"
2038
# Avoid writing anything if append_revisions_only is disabled,
2039
# as that is the default.
2042
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
2044
"""Initialize a branch in a bzrdir, with specified files
2046
:param a_bzrdir: The bzrdir to initialize the branch in
2047
:param utf8_files: The files to create as a list of
2048
(filename, content) tuples
2049
:param name: Name of colocated branch to create, if any
2050
:return: a branch in this format
2053
return self.get_format_string()
2053
name = a_bzrdir._get_selected_branch()
2054
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2055
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2056
control_files = lockable_files.LockableFiles(branch_transport,
2057
'lock', lockdir.LockDir)
2058
control_files.create_lock()
2059
control_files.lock_write()
2061
utf8_files += [('format', self.as_string())]
2062
for (filename, content) in utf8_files:
2063
branch_transport.put_bytes(
2065
mode=a_bzrdir._get_file_mode())
2067
control_files.unlock()
2068
branch = self.open(a_bzrdir, name, _found=True,
2069
found_repository=repository)
2070
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2055
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2073
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2074
found_repository=None, possible_transports=None):
2056
2075
"""See BranchFormat.open()."""
2077
name = a_bzrdir._get_selected_branch()
2058
format = BranchFormat.find_format(a_bzrdir, name=name)
2079
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2059
2080
if format.__class__ != self.__class__:
2060
2081
raise AssertionError("wrong format %r found for %r" %
2061
2082
(format, self))
2064
2085
control_files = lockable_files.LockableFiles(transport, 'lock',
2065
2086
lockdir.LockDir)
2087
if found_repository is None:
2088
found_repository = a_bzrdir.find_repository()
2066
2089
return self._branch_class()(_format=self,
2067
2090
_control_files=control_files,
2069
2092
a_bzrdir=a_bzrdir,
2070
_repository=a_bzrdir.find_repository(),
2071
ignore_fallbacks=ignore_fallbacks)
2093
_repository=found_repository,
2094
ignore_fallbacks=ignore_fallbacks,
2095
possible_transports=possible_transports)
2072
2096
except errors.NoSuchFile:
2073
2097
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2076
super(BranchFormatMetadir, self).__init__()
2077
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2078
self._matchingbzrdir.set_branch_format(self)
2100
def _matchingbzrdir(self):
2101
ret = bzrdir.BzrDirMetaFormat1()
2102
ret.set_branch_format(self)
2080
2105
def supports_tags(self):
2108
def supports_leaving_lock(self):
2111
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
2113
BranchFormat.check_support_status(self,
2114
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
2116
bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
2117
recommend_upgrade=recommend_upgrade, basedir=basedir)
2084
2120
class BzrBranchFormat5(BranchFormatMetadir):
2085
2121
"""Bzr branch format 5.
2168
2212
"""See BranchFormat.get_format_description()."""
2169
2213
return "Branch format 8"
2171
def initialize(self, a_bzrdir, name=None):
2215
def initialize(self, a_bzrdir, name=None, repository=None,
2216
append_revisions_only=None):
2172
2217
"""Create a branch of this format in a_bzrdir."""
2173
2218
utf8_files = [('last-revision', '0 null:\n'),
2174
('branch.conf', ''),
2220
self._get_initial_config(append_revisions_only)),
2176
2222
('references', '')
2178
return self._initialize_helper(a_bzrdir, utf8_files, name)
2181
super(BzrBranchFormat8, self).__init__()
2182
self._matchingbzrdir.repository_format = \
2183
RepositoryFormatKnitPack5RichRoot()
2224
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2185
2226
def make_tags(self, branch):
2186
2227
"""See bzrlib.branch.BranchFormat.make_tags()."""
2187
return BasicTags(branch)
2228
return _mod_tag.BasicTags(branch)
2189
2230
def supports_set_append_revisions_only(self):
2258
2310
transport = a_bzrdir.get_branch_transport(None, name=name)
2259
2311
location = transport.put_bytes('location', to_branch.base)
2261
def initialize(self, a_bzrdir, name=None, target_branch=None):
2313
def initialize(self, a_bzrdir, name=None, target_branch=None,
2314
repository=None, append_revisions_only=None):
2262
2315
"""Create a branch of this format in a_bzrdir."""
2263
2316
if target_branch is None:
2264
2317
# this format does not implement branch itself, thus the implicit
2265
2318
# creation contract must see it as uninitializable
2266
2319
raise errors.UninitializableFormat(self)
2267
2320
mutter('creating branch reference in %s', a_bzrdir.user_url)
2321
if a_bzrdir._format.fixed_components:
2322
raise errors.IncompatibleFormat(self, a_bzrdir._format)
2324
name = a_bzrdir._get_selected_branch()
2268
2325
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2269
2326
branch_transport.put_bytes('location',
2270
target_branch.bzrdir.user_url)
2271
branch_transport.put_bytes('format', self.get_format_string())
2273
a_bzrdir, name, _found=True,
2327
target_branch.user_url)
2328
branch_transport.put_bytes('format', self.as_string())
2329
branch = self.open(a_bzrdir, name, _found=True,
2274
2330
possible_transports=[target_branch.bzrdir.root_transport])
2275
2331
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2279
super(BranchReferenceFormat, self).__init__()
2280
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2281
self._matchingbzrdir.set_branch_format(self)
2283
2334
def _make_reference_clone_function(format, a_branch):
2284
2335
"""Create a clone() routine for a branch dynamically."""
2285
2336
def clone(to_bzrdir, revision_id=None,
2392
2458
def __init__(self, _format=None,
2393
2459
_control_files=None, a_bzrdir=None, name=None,
2394
_repository=None, ignore_fallbacks=False):
2460
_repository=None, ignore_fallbacks=False,
2461
possible_transports=None):
2395
2462
"""Create new branch object at a particular location."""
2396
2463
if a_bzrdir is None:
2397
2464
raise ValueError('a_bzrdir must be supplied')
2399
self.bzrdir = a_bzrdir
2400
self._base = self.bzrdir.transport.clone('..').base
2466
raise ValueError('name must be supplied')
2467
self.bzrdir = a_bzrdir
2468
self._user_transport = self.bzrdir.transport.clone('..')
2470
self._user_transport.set_segment_parameter(
2471
"branch", urlutils.escape(name))
2472
self._base = self._user_transport.base
2401
2473
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
2405
2474
self._format = _format
2406
2475
if _control_files is None:
2407
2476
raise ValueError('BzrBranch _control_files is None')
2408
2477
self.control_files = _control_files
2409
2478
self._transport = _control_files._transport
2410
2479
self.repository = _repository
2411
Branch.__init__(self)
2480
Branch.__init__(self, possible_transports)
2413
2482
def __str__(self):
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,
2483
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2420
2485
__repr__ = __str__
2507
2579
"""See Branch.print_file."""
2508
2580
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)
2573
2582
@needs_write_lock
2574
2583
def set_last_revision_info(self, revno, revision_id):
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
2584
if not revision_id or not isinstance(revision_id, basestring):
2585
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2585
2586
revision_id = _mod_revision.ensure_null(revision_id)
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))
2587
old_revno, old_revid = self.last_revision_info()
2588
if self.get_append_revisions_only():
2589
self._check_history_violation(revision_id)
2590
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2591
self._write_last_revision_info(revno, revision_id)
2592
self._clear_cached_state()
2593
self._last_revision_info_cache = revno, revision_id
2594
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2615
2596
def basis_tree(self):
2616
2597
"""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()
2650
2609
def get_stacked_on_url(self):
2651
2610
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2663
2622
self._transport.put_bytes('parent', url + '\n',
2664
2623
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(
2700
2625
@needs_write_lock
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:
2627
"""If bound, unbind"""
2628
return self.set_bound_location(None)
2716
2630
@needs_write_lock
2717
2631
def bind(self, other):
2739
2653
# history around
2740
2654
self.set_bound_location(other.base)
2656
def get_bound_location(self):
2658
return self._transport.get_bytes('bound')[:-1]
2659
except errors.NoSuchFile:
2663
def get_master_branch(self, possible_transports=None):
2664
"""Return the branch we are bound to.
2666
:return: Either a Branch, or None
2668
if self._master_branch_cache is None:
2669
self._master_branch_cache = self._get_master_branch(
2670
possible_transports)
2671
return self._master_branch_cache
2673
def _get_master_branch(self, possible_transports):
2674
bound_loc = self.get_bound_location()
2678
return Branch.open(bound_loc,
2679
possible_transports=possible_transports)
2680
except (errors.NotBranchError, errors.ConnectionError), e:
2681
raise errors.BoundBranchConnectionFailure(
2742
2684
@needs_write_lock
2744
"""If bound, unbind"""
2745
return self.set_bound_location(None)
2685
def set_bound_location(self, location):
2686
"""Set the target where this branch is bound to.
2688
:param location: URL to the target branch
2690
self._master_branch_cache = None
2692
self._transport.put_bytes('bound', location+'\n',
2693
mode=self.bzrdir._get_file_mode())
2696
self._transport.delete('bound')
2697
except errors.NoSuchFile:
2747
2701
@needs_write_lock
2748
2702
def update(self, possible_transports=None):
2765
class BzrBranch8(BzrBranch5):
2718
def _read_last_revision_info(self):
2719
revision_string = self._transport.get_bytes('last-revision')
2720
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2721
revision_id = cache_utf8.get_cached_utf8(revision_id)
2723
return revno, revision_id
2725
def _write_last_revision_info(self, revno, revision_id):
2726
"""Simply write out the revision id, with no checks.
2728
Use set_last_revision_info to perform this safely.
2730
Does not update the revision_history cache.
2732
revision_id = _mod_revision.ensure_null(revision_id)
2733
out_string = '%d %s\n' % (revno, revision_id)
2734
self._transport.put_bytes('last-revision', out_string,
2735
mode=self.bzrdir._get_file_mode())
2738
def update_feature_flags(self, updated_flags):
2739
"""Update the feature flags for this branch.
2741
:param updated_flags: Dictionary mapping feature names to necessities
2742
A necessity can be None to indicate the feature should be removed
2744
self._format._update_feature_flags(updated_flags)
2745
self.control_transport.put_bytes('format', self._format.as_string())
2748
class FullHistoryBzrBranch(BzrBranch):
2749
"""Bzr branch which contains the full revision history."""
2752
def set_last_revision_info(self, revno, revision_id):
2753
if not revision_id or not isinstance(revision_id, basestring):
2754
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2755
revision_id = _mod_revision.ensure_null(revision_id)
2756
# this old format stores the full history, but this api doesn't
2757
# provide it, so we must generate, and might as well check it's
2759
history = self._lefthand_history(revision_id)
2760
if len(history) != revno:
2761
raise AssertionError('%d != %d' % (len(history), revno))
2762
self._set_revision_history(history)
2764
def _read_last_revision_info(self):
2765
rh = self._revision_history()
2768
return (revno, rh[-1])
2770
return (0, _mod_revision.NULL_REVISION)
2772
@deprecated_method(deprecated_in((2, 4, 0)))
2774
def set_revision_history(self, rev_history):
2775
"""See Branch.set_revision_history."""
2776
self._set_revision_history(rev_history)
2778
def _set_revision_history(self, rev_history):
2779
if 'evil' in debug.debug_flags:
2780
mutter_callsite(3, "set_revision_history scales with history.")
2781
check_not_reserved_id = _mod_revision.check_not_reserved_id
2782
for rev_id in rev_history:
2783
check_not_reserved_id(rev_id)
2784
if Branch.hooks['post_change_branch_tip']:
2785
# Don't calculate the last_revision_info() if there are no hooks
2787
old_revno, old_revid = self.last_revision_info()
2788
if len(rev_history) == 0:
2789
revid = _mod_revision.NULL_REVISION
2791
revid = rev_history[-1]
2792
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2793
self._write_revision_history(rev_history)
2794
self._clear_cached_state()
2795
self._cache_revision_history(rev_history)
2796
for hook in Branch.hooks['set_rh']:
2797
hook(self, rev_history)
2798
if Branch.hooks['post_change_branch_tip']:
2799
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2801
def _write_revision_history(self, history):
2802
"""Factored out of set_revision_history.
2804
This performs the actual writing to disk.
2805
It is intended to be called by set_revision_history."""
2806
self._transport.put_bytes(
2807
'revision-history', '\n'.join(history),
2808
mode=self.bzrdir._get_file_mode())
2810
def _gen_revision_history(self):
2811
history = self._transport.get_bytes('revision-history').split('\n')
2812
if history[-1:] == ['']:
2813
# There shouldn't be a trailing newline, but just in case.
2817
def _synchronize_history(self, destination, revision_id):
2818
if not isinstance(destination, FullHistoryBzrBranch):
2819
super(BzrBranch, self)._synchronize_history(
2820
destination, revision_id)
2822
if revision_id == _mod_revision.NULL_REVISION:
2825
new_history = self._revision_history()
2826
if revision_id is not None and new_history != []:
2828
new_history = new_history[:new_history.index(revision_id) + 1]
2830
rev = self.repository.get_revision(revision_id)
2831
new_history = rev.get_history(self.repository)[1:]
2832
destination._set_revision_history(new_history)
2835
def generate_revision_history(self, revision_id, last_rev=None,
2837
"""Create a new revision history that will finish with revision_id.
2839
:param revision_id: the new tip to use.
2840
:param last_rev: The previous last_revision. If not None, then this
2841
must be a ancestory of revision_id, or DivergedBranches is raised.
2842
:param other_branch: The other branch that DivergedBranches should
2843
raise with respect to.
2845
self._set_revision_history(self._lefthand_history(revision_id,
2846
last_rev, other_branch))
2849
class BzrBranch5(FullHistoryBzrBranch):
2850
"""A format 5 branch. This supports new features over plain branches.
2852
It has support for a master_branch which is the data for bound branches.
2856
class BzrBranch8(BzrBranch):
2766
2857
"""A branch that stores tree-reference locations."""
2768
def _open_hook(self):
2859
def _open_hook(self, possible_transports=None):
2769
2860
if self._ignore_fallbacks:
2862
if possible_transports is None:
2863
possible_transports = [self.bzrdir.root_transport]
2772
2865
url = self.get_stacked_on_url()
2773
2866
except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2794
2888
self._last_revision_info_cache = None
2795
2889
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)
2842
2891
def _check_history_violation(self, revision_id):
2843
last_revision = _mod_revision.ensure_null(self.last_revision())
2892
current_revid = self.last_revision()
2893
last_revision = _mod_revision.ensure_null(current_revid)
2844
2894
if _mod_revision.is_null(last_revision):
2846
if last_revision not in self._lefthand_history(revision_id):
2847
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2896
graph = self.repository.get_graph()
2897
for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
2898
if lh_ancestor == current_revid:
2900
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2849
2902
def _gen_revision_history(self):
2850
2903
"""Generate the revision history from last revision
2961
2998
def set_bound_location(self, location):
2962
2999
"""See Branch.set_push_location."""
3000
self._master_branch_cache = None
2964
config = self.get_config()
3002
conf = self.get_config_stack()
2965
3003
if location is None:
2966
if config.get_user_option('bound') != 'True':
3004
if not conf.get('bound'):
2969
config.set_user_option('bound', 'False', warn_masked=True)
3007
conf.set('bound', 'False')
2972
3010
self._set_config_location('bound_location', location,
2974
config.set_user_option('bound', 'True', warn_masked=True)
3012
conf.set('bound', 'True')
2977
3015
def _get_bound_location(self, bound):
2978
3016
"""Return the bound location in the config file.
2980
3018
Return None if the bound parameter does not match"""
2981
config = self.get_config()
2982
config_bound = (config.get_user_option('bound') == 'True')
2983
if config_bound != bound:
3019
conf = self.get_config_stack()
3020
if conf.get('bound') != bound:
2985
return self._get_config_location('bound_location', config=config)
3022
return self._get_config_location('bound_location', config=conf)
2987
3024
def get_bound_location(self):
2988
"""See Branch.set_push_location."""
3025
"""See Branch.get_bound_location."""
2989
3026
return self._get_bound_location(True)
2991
3028
def get_old_bound_location(self):
2996
3033
# you can always ask for the URL; but you might not be able to use it
2997
3034
# if the repo can't support stacking.
2998
3035
## self._check_stackable_repo()
2999
stacked_url = self._get_config_location('stacked_on_location')
3036
# stacked_on_location is only ever defined in branch.conf, so don't
3037
# waste effort reading the whole stack of config files.
3038
conf = _mod_config.BranchOnlyStack(self)
3039
stacked_url = self._get_config_location('stacked_on_location',
3000
3041
if stacked_url is None:
3001
3042
raise errors.NotStacked(self)
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)
3043
return stacked_url.encode('utf-8')
3016
3045
@needs_read_lock
3017
3046
def get_rev_id(self, revno, history=None):
3101
3135
:ivar local_branch: target branch if there is a Master, else None
3102
3136
:ivar target_branch: Target/destination branch object. (write locked)
3103
3137
:ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
3138
:ivar tag_updates: A dict with new tags, see BasicTags.merge_to
3141
@deprecated_method(deprecated_in((2, 3, 0)))
3106
3142
def __int__(self):
3107
# DEPRECATED: pull used to return the change in revno
3143
"""Return the relative change in revno.
3145
:deprecated: Use `new_revno` and `old_revno` instead.
3108
3147
return self.new_revno - self.old_revno
3110
3149
def report(self, to_file):
3150
tag_conflicts = getattr(self, "tag_conflicts", None)
3151
tag_updates = getattr(self, "tag_updates", None)
3111
3152
if not is_quiet():
3112
if self.old_revid == self.new_revid:
3113
to_file.write('No revisions to pull.\n')
3153
if self.old_revid != self.new_revid:
3115
3154
to_file.write('Now on revision %d.\n' % self.new_revno)
3156
to_file.write('%d tag(s) updated.\n' % len(tag_updates))
3157
if self.old_revid == self.new_revid and not tag_updates:
3158
if not tag_conflicts:
3159
to_file.write('No revisions or tags to pull.\n')
3161
to_file.write('No revisions to pull.\n')
3116
3162
self._show_tag_conficts(to_file)
3135
3181
target, otherwise it will be None.
3184
@deprecated_method(deprecated_in((2, 3, 0)))
3138
3185
def __int__(self):
3139
# DEPRECATED: push used to return the change in revno
3186
"""Return the relative change in revno.
3188
:deprecated: Use `new_revno` and `old_revno` instead.
3140
3190
return self.new_revno - self.old_revno
3142
3192
def report(self, to_file):
3143
"""Write a human-readable description of the result."""
3144
if self.old_revid == self.new_revid:
3145
note('No new revisions to push.')
3147
note('Pushed up to revision %d.' % self.new_revno)
3193
# TODO: This function gets passed a to_file, but then
3194
# ignores it and calls note() instead. This is also
3195
# inconsistent with PullResult(), which writes to stdout.
3196
# -- JRV20110901, bug #838853
3197
tag_conflicts = getattr(self, "tag_conflicts", None)
3198
tag_updates = getattr(self, "tag_updates", None)
3200
if self.old_revid != self.new_revid:
3201
note(gettext('Pushed up to revision %d.') % self.new_revno)
3203
note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
3204
if self.old_revid == self.new_revid and not tag_updates:
3205
if not tag_conflicts:
3206
note(gettext('No new revisions or tags to push.'))
3208
note(gettext('No new revisions to push.'))
3148
3209
self._show_tag_conficts(to_file)
3208
3269
format = BzrBranchFormat7()
3209
3270
branch._set_config_location('stacked_on_location', '')
3210
3271
# update target format
3211
branch._transport.put_bytes('format', format.get_format_string())
3272
branch._transport.put_bytes('format', format.as_string())
3214
3275
class Converter7to8(object):
3215
"""Perform an in-place upgrade of format 6 to format 7"""
3276
"""Perform an in-place upgrade of format 7 to format 8"""
3217
3278
def convert(self, branch):
3218
3279
format = BzrBranchFormat8()
3219
3280
branch._transport.put_bytes('references', '')
3220
3281
# update target format
3221
branch._transport.put_bytes('format', format.get_format_string())
3224
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3225
"""Run ``callable(*args, **kwargs)``, write-locking target for the
3228
_run_with_write_locked_target will attempt to release the lock it acquires.
3230
If an exception is raised by callable, then that exception *will* be
3231
propagated, even if the unlock attempt raises its own error. Thus
3232
_run_with_write_locked_target should be preferred to simply doing::
3236
return callable(*args, **kwargs)
3241
# This is very similar to bzrlib.decorators.needs_write_lock. Perhaps they
3242
# should share code?
3245
result = callable(*args, **kwargs)
3247
exc_info = sys.exc_info()
3251
raise exc_info[0], exc_info[1], exc_info[2]
3282
branch._transport.put_bytes('format', format.as_string())
3257
3285
class InterBranch(InterObject):
3358
3381
self.source.tags.merge_to(self.target.tags)
3360
3383
@needs_write_lock
3361
def update_revisions(self, stop_revision=None, overwrite=False,
3363
"""See InterBranch.update_revisions()."""
3384
def fetch(self, stop_revision=None, limit=None):
3385
if self.target.base == self.source.base:
3387
self.source.lock_read()
3389
fetch_spec_factory = fetch.FetchSpecFactory()
3390
fetch_spec_factory.source_branch = self.source
3391
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3392
fetch_spec_factory.source_repo = self.source.repository
3393
fetch_spec_factory.target_repo = self.target.repository
3394
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3395
fetch_spec_factory.limit = limit
3396
fetch_spec = fetch_spec_factory.make_fetch_spec()
3397
return self.target.repository.fetch(self.source.repository,
3398
fetch_spec=fetch_spec)
3400
self.source.unlock()
3403
def _update_revisions(self, stop_revision=None, overwrite=False,
3364
3405
other_revno, other_last_revision = self.source.last_revision_info()
3365
3406
stop_revno = None # unknown
3366
3407
if stop_revision is None:
3423
3474
return self._pull(overwrite,
3424
3475
stop_revision, _hook_master=master_branch,
3425
3476
run_hooks=run_hooks,
3426
_override_hook_target=_override_hook_target)
3477
_override_hook_target=_override_hook_target,
3478
merge_tags_to_master=not source_is_master)
3428
3480
if master_branch:
3429
3481
master_branch.unlock()
3431
def push(self, overwrite=False, stop_revision=None,
3483
def push(self, overwrite=False, stop_revision=None, lossy=False,
3432
3484
_override_hook_source_branch=None):
3433
3485
"""See InterBranch.push.
3435
3487
This is the basic concrete implementation of push()
3437
:param _override_hook_source_branch: If specified, run
3438
the hooks passing this Branch as the source, rather than self.
3439
This is for use of RemoteBranch, where push is delegated to the
3440
underlying vfs-based Branch.
3489
:param _override_hook_source_branch: If specified, run the hooks
3490
passing this Branch as the source, rather than self. This is for
3491
use of RemoteBranch, where push is delegated to the underlying
3495
raise errors.LossyPushToSameVCS(self.source, self.target)
3442
3496
# TODO: Public option to disable running hooks - should be trivial but
3444
self.source.lock_read()
3446
return _run_with_write_locked_target(
3447
self.target, self._push_with_bound_branches, overwrite,
3449
_override_hook_source_branch=_override_hook_source_branch)
3451
self.source.unlock()
3453
def _push_with_bound_branches(self, overwrite, stop_revision,
3499
op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3500
op.add_cleanup(self.source.lock_read().unlock)
3501
op.add_cleanup(self.target.lock_write().unlock)
3502
return op.run(overwrite, stop_revision,
3503
_override_hook_source_branch=_override_hook_source_branch)
3505
def _basic_push(self, overwrite, stop_revision):
3506
"""Basic implementation of push without bound branches or hooks.
3508
Must be called with source read locked and target write locked.
3510
result = BranchPushResult()
3511
result.source_branch = self.source
3512
result.target_branch = self.target
3513
result.old_revno, result.old_revid = self.target.last_revision_info()
3514
self.source.update_references(self.target)
3515
if result.old_revid != stop_revision:
3516
# We assume that during 'push' this repository is closer than
3518
graph = self.source.repository.get_graph(self.target.repository)
3519
self._update_revisions(stop_revision, overwrite=overwrite,
3521
if self.source._push_should_merge_tags():
3522
result.tag_updates, result.tag_conflicts = (
3523
self.source.tags.merge_to(self.target.tags, overwrite))
3524
result.new_revno, result.new_revid = self.target.last_revision_info()
3527
def _push_with_bound_branches(self, operation, overwrite, stop_revision,
3454
3528
_override_hook_source_branch=None):
3455
3529
"""Push from source into target, and into target's master if any.
3468
3542
# be bound to itself? -- mbp 20070507
3469
3543
master_branch = self.target.get_master_branch()
3470
3544
master_branch.lock_write()
3472
# push into the master from the source branch.
3473
self.source._basic_push(master_branch, overwrite, stop_revision)
3474
# and push into the target branch from the source. Note that we
3475
# push from the source branch again, because its considered the
3476
# highest bandwidth repository.
3477
result = self.source._basic_push(self.target, overwrite,
3479
result.master_branch = master_branch
3480
result.local_branch = self.target
3484
master_branch.unlock()
3545
operation.add_cleanup(master_branch.unlock)
3546
# push into the master from the source branch.
3547
master_inter = InterBranch.get(self.source, master_branch)
3548
master_inter._basic_push(overwrite, stop_revision)
3549
# and push into the target branch from the source. Note that
3550
# we push from the source branch again, because it's considered
3551
# the highest bandwidth repository.
3552
result = self._basic_push(overwrite, stop_revision)
3553
result.master_branch = master_branch
3554
result.local_branch = self.target
3556
master_branch = None
3486
3557
# no master branch
3487
result = self.source._basic_push(self.target, overwrite,
3558
result = self._basic_push(overwrite, stop_revision)
3489
3559
# TODO: Why set master_branch and local_branch if there's no
3490
3560
# binding? Maybe cleaner to just leave them unset? -- mbp
3492
3562
result.master_branch = self.target
3493
3563
result.local_branch = None
3497
3567
def _pull(self, overwrite=False, stop_revision=None,
3498
3568
possible_transports=None, _hook_master=None, run_hooks=True,
3499
_override_hook_target=None, local=False):
3569
_override_hook_target=None, local=False,
3570
merge_tags_to_master=True):
3500
3571
"""See Branch.pull.
3502
3573
This function is the core worker, used by GenericInterBranch.pull to
added
removed
bzrlib/branch.py
