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 (
49
from bzrlib.i18n import gettext, ngettext
52
# Explicitly import bzrlib.bzrdir so that the BzrProber
53
# is guaranteed to be registered.
60
from bzrlib.decorators import (
65
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
66
53
from bzrlib.inter import InterObject
67
54
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
68
55
from bzrlib import registry
95
86
def user_transport(self):
96
87
return self.bzrdir.user_transport
98
def __init__(self, possible_transports=None):
89
def __init__(self, *ignored, **ignored_too):
99
90
self.tags = self._format.make_tags(self)
100
91
self._revision_history_cache = None
101
92
self._revision_id_to_revno_cache = None
102
93
self._partial_revision_id_to_revno_cache = {}
103
94
self._partial_revision_history_cache = []
104
self._tags_bytes = None
105
95
self._last_revision_info_cache = None
106
self._master_branch_cache = None
107
96
self._merge_sorted_revisions_cache = None
108
self._open_hook(possible_transports)
109
98
hooks = Branch.hooks['open']
110
99
for hook in hooks:
113
def _open_hook(self, possible_transports):
102
def _open_hook(self):
114
103
"""Called by init to allow simpler extension of the base class."""
116
def _activate_fallback_location(self, url, possible_transports):
105
def _activate_fallback_location(self, url):
117
106
"""Activate the branch/repository from url as a fallback repository."""
118
for existing_fallback_repo in self.repository._fallback_repositories:
119
if existing_fallback_repo.user_url == url:
120
# This fallback is already configured. This probably only
121
# happens because ControlDir.sprout is a horrible mess. To avoid
122
# confusing _unstack we don't add this a second time.
123
mutter('duplicate activation of fallback %r on %r', url, self)
125
repo = self._get_fallback_repository(url, possible_transports)
107
repo = self._get_fallback_repository(url)
126
108
if repo.has_same_location(self.repository):
127
109
raise errors.UnstackableLocationError(self.user_url, url)
128
110
self.repository.add_fallback_repository(repo)
182
164
For instance, if the branch is at URL/.bzr/branch,
183
165
Branch.open(URL) -> a Branch instance.
185
control = controldir.ControlDir.open(base,
186
possible_transports=possible_transports, _unsupported=_unsupported)
187
return control.open_branch(unsupported=_unsupported,
188
possible_transports=possible_transports)
167
control = bzrdir.BzrDir.open(base, _unsupported,
168
possible_transports=possible_transports)
169
return control.open_branch(unsupported=_unsupported)
191
def open_from_transport(transport, name=None, _unsupported=False,
192
possible_transports=None):
172
def open_from_transport(transport, name=None, _unsupported=False):
193
173
"""Open the branch rooted at transport"""
194
control = controldir.ControlDir.open_from_transport(transport, _unsupported)
195
return control.open_branch(name=name, unsupported=_unsupported,
196
possible_transports=possible_transports)
174
control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
175
return control.open_branch(name=name, unsupported=_unsupported)
199
178
def open_containing(url, possible_transports=None):
253
221
raise NotImplementedError(self._get_config)
255
def store_uncommitted(self, creator):
256
"""Store uncommitted changes from a ShelfCreator.
258
:param creator: The ShelfCreator containing uncommitted changes, or
259
None to delete any stored changes.
260
:raises: ChangesAlreadyStored if the branch already has changes.
262
raise NotImplementedError(self.store_uncommitted)
264
def get_unshelver(self, tree):
265
"""Return a shelf.Unshelver for this branch and tree.
267
:param tree: The tree to use to construct the Unshelver.
268
:return: an Unshelver or None if no changes are stored.
270
raise NotImplementedError(self.get_unshelver)
272
def _get_fallback_repository(self, url, possible_transports):
223
def _get_fallback_repository(self, url):
273
224
"""Get the repository we fallback to at url."""
274
225
url = urlutils.join(self.base, url)
275
a_branch = Branch.open(url, possible_transports=possible_transports)
226
a_branch = Branch.open(url,
227
possible_transports=[self.bzrdir.root_transport])
276
228
return a_branch.repository
279
230
def _get_tags_bytes(self):
280
231
"""Get the bytes of a serialised tags dict.
545
492
rev_iter = iter(merge_sorted_revisions)
546
493
if start_revision_id is not None:
547
494
for node in rev_iter:
495
rev_id = node.key[-1]
549
496
if rev_id != start_revision_id:
552
499
# The decision to include the start or not
553
500
# depends on the stop_rule if a stop is provided
554
501
# so pop this node back into the iterator
555
rev_iter = itertools.chain(iter([node]), rev_iter)
502
rev_iter = chain(iter([node]), rev_iter)
557
504
if stop_revision_id is None:
558
505
# Yield everything
559
506
for node in rev_iter:
507
rev_id = node.key[-1]
561
508
yield (rev_id, node.merge_depth, node.revno,
562
509
node.end_of_merge)
563
510
elif stop_rule == 'exclude':
564
511
for node in rev_iter:
512
rev_id = node.key[-1]
566
513
if rev_id == stop_revision_id:
568
515
yield (rev_id, node.merge_depth, node.revno,
569
516
node.end_of_merge)
570
517
elif stop_rule == 'include':
571
518
for node in rev_iter:
519
rev_id = node.key[-1]
573
520
yield (rev_id, node.merge_depth, node.revno,
574
521
node.end_of_merge)
575
522
if rev_id == stop_revision_id:
704
649
raise errors.UnsupportedOperation(self.get_reference_info, self)
706
651
@needs_write_lock
707
def fetch(self, from_branch, last_revision=None, limit=None):
652
def fetch(self, from_branch, last_revision=None, pb=None):
708
653
"""Copy revisions from from_branch into this branch.
710
655
:param from_branch: Where to copy from.
711
656
:param last_revision: What revision to stop at (None for at the end
713
:param limit: Optional rough limit of revisions to fetch
658
:param pb: An optional progress bar to use.
716
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,
718
678
def get_bound_location(self):
719
679
"""Return the URL of the branch we are bound to.
740
700
:param committer: Optional committer to set for commit.
741
701
:param revprops: Optional dictionary of revision properties.
742
702
:param revision_id: Optional revision id.
743
:param lossy: Whether to discard data that can not be natively
744
represented, when pushing to a foreign VCS
747
if config_stack is None:
748
config_stack = self.get_config_stack()
706
config = self.get_config()
750
return self.repository.get_commit_builder(self, parents, config_stack,
751
timestamp, timezone, committer, revprops, revision_id,
708
return self.repository.get_commit_builder(self, parents, config,
709
timestamp, timezone, committer, revprops, revision_id)
754
711
def get_master_branch(self, possible_transports=None):
755
712
"""Return the branch we are bound to.
784
739
"""Print `file` to stdout."""
785
740
raise NotImplementedError(self.print_file)
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)
742
def set_revision_history(self, rev_history):
743
raise NotImplementedError(self.set_revision_history)
818
745
@needs_write_lock
819
746
def set_parent(self, url):
1046
968
:return: A tuple (revno, revision_id).
1048
970
if self._last_revision_info_cache is None:
1049
self._last_revision_info_cache = self._read_last_revision_info()
971
self._last_revision_info_cache = self._last_revision_info()
1050
972
return self._last_revision_info_cache
1052
def _read_last_revision_info(self):
1053
raise NotImplementedError(self._read_last_revision_info)
1055
def import_last_revision_info_and_tags(self, source, revno, revid,
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,
1020
def import_last_revision_info(self, source_repo, revno, revid):
1057
1021
"""Set the last revision info, importing from another repo if necessary.
1059
1023
This is used by the bound branch code to upload a revision to
1060
1024
the master branch first before updating the tip of the local branch.
1061
Revisions referenced by source's tags are also transferred.
1063
:param source: Source branch to optionally fetch from
1026
:param source_repo: Source repository to optionally fetch from
1064
1027
:param revno: Revision number of the new tip
1065
1028
:param revid: Revision id of the new tip
1066
:param lossy: Whether to discard metadata that can not be
1067
natively represented
1068
:return: Tuple with the new revision number and revision id
1069
(should only be different from the arguments when lossy=True)
1071
if not self.repository.has_same_location(source.repository):
1072
self.fetch(source, revid)
1030
if not self.repository.has_same_location(source_repo):
1031
self.repository.fetch(source_repo, revision_id=revid)
1073
1032
self.set_last_revision_info(revno, revid)
1074
return (revno, revid)
1076
1034
def revision_id_to_revno(self, revision_id):
1077
1035
"""Given a revision id, return its revno"""
1078
1036
if _mod_revision.is_null(revision_id):
1080
history = self._revision_history()
1038
history = self.revision_history()
1082
1040
return history.index(revision_id) + 1
1083
1041
except ValueError:
1110
1068
stop_revision=stop_revision,
1111
1069
possible_transports=possible_transports, *args, **kwargs)
1113
def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1071
def push(self, target, overwrite=False, stop_revision=None, *args,
1115
1073
"""Mirror this branch into target.
1117
1075
This branch is considered to be 'local', having low latency.
1119
1077
return InterBranch.get(self, target).push(overwrite, stop_revision,
1120
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)
1122
1101
def basis_tree(self):
1123
1102
"""Return `Tree` object for last revision."""
1378
1354
# TODO: We should probably also check that self.revision_history
1379
1355
# matches the repository for older branch formats.
1380
1356
# If looking for the code that cross-checks repository parents against
1381
# the Graph.iter_lefthand_ancestry output, that is now a repository
1357
# the iter_reverse_revision_history output, that is now a repository
1382
1358
# specific check.
1385
def _get_checkout_format(self, lightweight=False):
1361
def _get_checkout_format(self):
1386
1362
"""Return the most suitable metadir for a checkout of this branch.
1387
1363
Weaves are used if this branch's repository uses weaves.
1389
format = self.repository.bzrdir.checkout_metadir()
1390
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)
1393
1374
def create_clone_on_transport(self, to_transport, revision_id=None,
1394
stacked_on=None, create_prefix=False, use_existing_dir=False,
1375
stacked_on=None, create_prefix=False, use_existing_dir=False):
1396
1376
"""Create a clone of this branch and its bzrdir.
1398
1378
:param to_transport: The transport to clone onto.
1435
1414
t = transport.get_transport(to_location)
1436
1415
t.ensure_base()
1437
format = self._get_checkout_format(lightweight=lightweight)
1417
format = self._get_checkout_format()
1439
1418
checkout = format.initialize_on_transport(t)
1440
except errors.AlreadyControlDirError:
1441
# It's fine if the control directory already exists,
1442
# as long as there is no existing branch and working tree.
1443
checkout = controldir.ControlDir.open_from_transport(t)
1445
checkout.open_branch()
1446
except errors.NotBranchError:
1449
raise errors.AlreadyControlDirError(t.base)
1450
if checkout.control_transport.base == self.bzrdir.control_transport.base:
1451
# When checking out to the same control directory,
1452
# always create a lightweight checkout
1456
from_branch = checkout.set_branch_reference(target_branch=self)
1419
from_branch = BranchReferenceFormat().initialize(checkout,
1458
policy = checkout.determine_repository_policy()
1459
repo = policy.acquire_repository()[0]
1460
checkout_branch = checkout.create_branch()
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
1461
1426
checkout_branch.bind(self)
1462
1427
# pull up to the specified revision_id to set the initial
1463
1428
# branch tip correctly, and seed it with history.
1464
1429
checkout_branch.pull(self, stop_revision=revision_id)
1466
1431
tree = checkout.create_workingtree(revision_id,
1467
1432
from_branch=from_branch,
1468
1433
accelerator_tree=accelerator_tree,
1549
1513
raise AssertionError("invalid heads: %r" % (heads,))
1551
def heads_to_fetch(self):
1552
"""Return the heads that must and that should be fetched to copy this
1553
branch into another repo.
1555
:returns: a 2-tuple of (must_fetch, if_present_fetch). must_fetch is a
1556
set of heads that must be fetched. if_present_fetch is a set of
1557
heads that must be fetched if present, but no error is necessary if
1558
they are not present.
1560
# For bzr native formats must_fetch is just the tip, and
1561
# if_present_fetch are the tags.
1562
must_fetch = set([self.last_revision()])
1563
if_present_fetch = set()
1564
if self.get_config_stack().get('branch.fetch_tags'):
1566
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1567
except errors.TagsNotSupported:
1569
must_fetch.discard(_mod_revision.NULL_REVISION)
1570
if_present_fetch.discard(_mod_revision.NULL_REVISION)
1571
return must_fetch, if_present_fetch
1574
class BranchFormat(controldir.ControlComponentFormat):
1516
class BranchFormat(object):
1575
1517
"""An encapsulation of the initialization and open routines for a format.
1577
1519
Formats provide three things:
1578
1520
* An initialization routine,
1579
* a format description
1580
1522
* an open routine.
1582
1524
Formats are placed in an dict by their format string for reference
1589
1531
object will be created every time regardless.
1534
_default_format = None
1535
"""The default format used for new branches."""
1538
"""The known formats."""
1540
can_set_append_revisions_only = True
1592
1542
def __eq__(self, other):
1593
1543
return self.__class__ is other.__class__
1595
1545
def __ne__(self, other):
1596
1546
return not (self == other)
1598
def get_reference(self, controldir, name=None):
1599
"""Get the target reference of the branch in controldir.
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')
1564
def get_default_format(klass):
1565
"""Return the current default format."""
1566
return klass._default_format
1569
def get_formats(klass):
1570
"""Get all the known formats.
1572
Warning: This triggers a load of all lazy registered formats: do not
1573
use except when that is desireed.
1576
for fmt in klass._formats.values():
1577
if isinstance(fmt, MetaDirBranchFormatFactory):
1582
def get_reference(self, a_bzrdir, name=None):
1583
"""Get the target reference of the branch in a_bzrdir.
1601
1585
format probing must have been completed before calling
1602
1586
this method - it is assumed that the format of the branch
1603
in controldir is correct.
1587
in a_bzrdir is correct.
1605
:param controldir: The controldir to get the branch data from.
1589
:param a_bzrdir: The bzrdir to get the branch data from.
1606
1590
:param name: Name of the colocated branch to fetch
1607
1591
:return: None if the branch is not a reference branch.
1612
def set_reference(self, controldir, name, to_branch):
1613
"""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.
1615
1599
format probing must have been completed before calling
1616
1600
this method - it is assumed that the format of the branch
1617
in controldir is correct.
1601
in a_bzrdir is correct.
1619
:param controldir: The controldir to set the branch reference for.
1603
:param a_bzrdir: The bzrdir to set the branch reference for.
1620
1604
:param name: Name of colocated branch to set, None for default
1621
1605
:param to_branch: branch that the checkout is to reference
1623
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)
1625
1613
def get_format_description(self):
1626
1614
"""Return the short format description for this format."""
1627
1615
raise NotImplementedError(self.get_format_description)
1629
def _run_post_branch_init_hooks(self, controldir, name, branch):
1617
def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1630
1618
hooks = Branch.hooks['post_branch_init']
1633
params = BranchInitHookParams(self, controldir, name, branch)
1621
params = BranchInitHookParams(self, a_bzrdir, name, branch)
1634
1622
for hook in hooks:
1637
def initialize(self, controldir, name=None, repository=None,
1638
append_revisions_only=None):
1639
"""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.
1641
1673
:param name: Name of the colocated branch to create.
1643
1675
raise NotImplementedError(self.initialize)
1757
1800
These are all empty initially, because by default nothing should get
1760
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1761
self.add_hook('open',
1803
Hooks.__init__(self)
1804
self.create_hook(HookPoint('set_rh',
1805
"Invoked whenever the revision history has been set via "
1806
"set_revision_history. The api signature is (branch, "
1807
"revision_history), and the branch will be write-locked. "
1808
"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',
1762
1811
"Called with the Branch object that has been opened after a "
1763
"branch is opened.", (1, 8))
1764
self.add_hook('post_push',
1812
"branch is opened.", (1, 8), None))
1813
self.create_hook(HookPoint('post_push',
1765
1814
"Called after a push operation completes. post_push is called "
1766
1815
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1767
"bzr client.", (0, 15))
1768
self.add_hook('post_pull',
1816
"bzr client.", (0, 15), None))
1817
self.create_hook(HookPoint('post_pull',
1769
1818
"Called after a pull operation completes. post_pull is called "
1770
1819
"with a bzrlib.branch.PullResult object and only runs in the "
1771
"bzr client.", (0, 15))
1772
self.add_hook('pre_commit',
1820
"bzr client.", (0, 15), None))
1821
self.create_hook(HookPoint('pre_commit',
1773
1822
"Called after a commit is calculated but before it is "
1774
1823
"completed. pre_commit is called with (local, master, old_revno, "
1775
1824
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1778
1827
"basis revision. hooks MUST NOT modify this delta. "
1779
1828
" future_tree is an in-memory tree obtained from "
1780
1829
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1782
self.add_hook('post_commit',
1830
"tree.", (0,91), None))
1831
self.create_hook(HookPoint('post_commit',
1783
1832
"Called in the bzr client after a commit has completed. "
1784
1833
"post_commit is called with (local, master, old_revno, old_revid, "
1785
1834
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1786
"commit to a branch.", (0, 15))
1787
self.add_hook('post_uncommit',
1835
"commit to a branch.", (0, 15), None))
1836
self.create_hook(HookPoint('post_uncommit',
1788
1837
"Called in the bzr client after an uncommit completes. "
1789
1838
"post_uncommit is called with (local, master, old_revno, "
1790
1839
"old_revid, new_revno, new_revid) where local is the local branch "
1791
1840
"or None, master is the target branch, and an empty branch "
1792
"receives new_revno of 0, new_revid of None.", (0, 15))
1793
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',
1794
1843
"Called in bzr client and server before a change to the tip of a "
1795
1844
"branch is made. pre_change_branch_tip is called with a "
1796
1845
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1797
"commit, uncommit will all trigger this hook.", (1, 6))
1798
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',
1799
1848
"Called in bzr client and server after a change to the tip of a "
1800
1849
"branch is made. post_change_branch_tip is called with a "
1801
1850
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1802
"commit, uncommit will all trigger this hook.", (1, 4))
1803
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',
1804
1853
"Called when a stacked branch is activating its fallback "
1805
1854
"locations. transform_fallback_location is called with (branch, "
1806
1855
"url), and should return a new url. Returning the same url "
1811
1860
"fallback locations have not been activated. When there are "
1812
1861
"multiple hooks installed for transform_fallback_location, "
1813
1862
"all are called with the url returned from the previous hook."
1814
"The order is however undefined.", (1, 9))
1815
self.add_hook('automatic_tag_name',
1863
"The order is however undefined.", (1, 9), None))
1864
self.create_hook(HookPoint('automatic_tag_name',
1816
1865
"Called to determine an automatic tag name for a revision. "
1817
1866
"automatic_tag_name is called with (branch, revision_id) and "
1818
1867
"should return a tag name or None if no tag name could be "
1819
1868
"determined. The first non-None tag name returned will be used.",
1821
self.add_hook('post_branch_init',
1870
self.create_hook(HookPoint('post_branch_init',
1822
1871
"Called after new branch initialization completes. "
1823
1872
"post_branch_init is called with a "
1824
1873
"bzrlib.branch.BranchInitHookParams. "
1825
1874
"Note that init, branch and checkout (both heavyweight and "
1826
"lightweight) will all trigger this hook.", (2, 2))
1827
self.add_hook('post_switch',
1875
"lightweight) will all trigger this hook.", (2, 2), None))
1876
self.create_hook(HookPoint('post_switch',
1828
1877
"Called after a checkout switches branch. "
1829
1878
"post_switch is called with a "
1830
"bzrlib.branch.SwitchHookParams.", (2, 2))
1879
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1946
1995
self.revision_id)
1949
class BranchFormatMetadir(bzrdir.BzrFormat, BranchFormat):
1950
"""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)
1953
2018
def __init__(self):
1954
BranchFormat.__init__(self)
1955
bzrdir.BzrFormat.__init__(self)
1958
def find_format(klass, controldir, name=None):
1959
"""Return the format for the branch object in controldir."""
1961
transport = controldir.get_branch_transport(None, name=name)
1962
except errors.NoSuchFile:
1963
raise errors.NotBranchError(path=name, bzrdir=controldir)
1965
format_string = transport.get_bytes("format")
1966
except errors.NoSuchFile:
1967
raise errors.NotBranchError(path=transport.base, bzrdir=controldir)
1968
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."""
1970
2044
def _branch_class(self):
1971
2045
"""What class to instantiate on open calls."""
1972
2046
raise NotImplementedError(self._branch_class)
1974
def _get_initial_config(self, append_revisions_only=None):
1975
if append_revisions_only:
1976
return "append_revisions_only = True\n"
1978
# Avoid writing anything if append_revisions_only is disabled,
1979
# as that is the default.
1982
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1984
"""Initialize a branch in a control dir, with specified files
1986
:param a_bzrdir: The bzrdir to initialize the branch in
1987
:param utf8_files: The files to create as a list of
1988
(filename, content) tuples
1989
:param name: Name of colocated branch to create, if any
1990
: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.
1993
name = a_bzrdir._get_selected_branch()
1994
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1995
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1996
control_files = lockable_files.LockableFiles(branch_transport,
1997
'lock', lockdir.LockDir)
1998
control_files.create_lock()
1999
control_files.lock_write()
2001
utf8_files += [('format', self.as_string())]
2002
for (filename, content) in utf8_files:
2003
branch_transport.put_bytes(
2005
mode=a_bzrdir._get_file_mode())
2007
control_files.unlock()
2008
branch = self.open(a_bzrdir, name, _found=True,
2009
found_repository=repository)
2010
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2053
return self.get_format_string()
2013
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2014
found_repository=None, possible_transports=None):
2055
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2015
2056
"""See BranchFormat.open()."""
2017
name = a_bzrdir._get_selected_branch()
2019
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2058
format = BranchFormat.find_format(a_bzrdir, name=name)
2020
2059
if format.__class__ != self.__class__:
2021
2060
raise AssertionError("wrong format %r found for %r" %
2022
2061
(format, self))
2025
2064
control_files = lockable_files.LockableFiles(transport, 'lock',
2026
2065
lockdir.LockDir)
2027
if found_repository is None:
2028
found_repository = a_bzrdir.find_repository()
2029
2066
return self._branch_class()(_format=self,
2030
2067
_control_files=control_files,
2032
2069
a_bzrdir=a_bzrdir,
2033
_repository=found_repository,
2034
ignore_fallbacks=ignore_fallbacks,
2035
possible_transports=possible_transports)
2070
_repository=a_bzrdir.find_repository(),
2071
ignore_fallbacks=ignore_fallbacks)
2036
2072
except errors.NoSuchFile:
2037
2073
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2040
def _matchingbzrdir(self):
2041
ret = bzrdir.BzrDirMetaFormat1()
2042
ret.set_branch_format(self)
2045
def supports_tags(self):
2048
def supports_leaving_lock(self):
2051
def check_support_status(self, allow_unsupported, recommend_upgrade=True,
2053
BranchFormat.check_support_status(self,
2054
allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
2056
bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
2057
recommend_upgrade=recommend_upgrade, basedir=basedir)
2076
super(BranchFormatMetadir, self).__init__()
2077
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2078
self._matchingbzrdir.set_branch_format(self)
2080
def supports_tags(self):
2084
class BzrBranchFormat5(BranchFormatMetadir):
2085
"""Bzr branch format 5.
2088
- a revision-history file.
2090
- a lock dir guarding the branch itself
2091
- all of this stored in a branch/ subdirectory
2092
- works with shared repositories.
2094
This format is new in bzr 0.8.
2097
def _branch_class(self):
2100
def get_format_string(self):
2101
"""See BranchFormat.get_format_string()."""
2102
return "Bazaar-NG branch format 5\n"
2104
def get_format_description(self):
2105
"""See BranchFormat.get_format_description()."""
2106
return "Branch format 5"
2108
def initialize(self, a_bzrdir, name=None):
2109
"""Create a branch of this format in a_bzrdir."""
2110
utf8_files = [('revision-history', ''),
2111
('branch-name', ''),
2113
return self._initialize_helper(a_bzrdir, utf8_files, name)
2115
def supports_tags(self):
2060
2119
class BzrBranchFormat6(BranchFormatMetadir):
2113
2168
"""See BranchFormat.get_format_description()."""
2114
2169
return "Branch format 8"
2116
def initialize(self, a_bzrdir, name=None, repository=None,
2117
append_revisions_only=None):
2171
def initialize(self, a_bzrdir, name=None):
2118
2172
"""Create a branch of this format in a_bzrdir."""
2119
2173
utf8_files = [('last-revision', '0 null:\n'),
2121
self._get_initial_config(append_revisions_only)),
2174
('branch.conf', ''),
2123
2176
('references', '')
2125
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()
2127
2185
def make_tags(self, branch):
2128
2186
"""See bzrlib.branch.BranchFormat.make_tags()."""
2129
return _mod_tag.BasicTags(branch)
2187
return BasicTags(branch)
2131
2189
def supports_set_append_revisions_only(self):
2211
2258
transport = a_bzrdir.get_branch_transport(None, name=name)
2212
2259
location = transport.put_bytes('location', to_branch.base)
2214
def initialize(self, a_bzrdir, name=None, target_branch=None,
2215
repository=None, append_revisions_only=None):
2261
def initialize(self, a_bzrdir, name=None, target_branch=None):
2216
2262
"""Create a branch of this format in a_bzrdir."""
2217
2263
if target_branch is None:
2218
2264
# this format does not implement branch itself, thus the implicit
2219
2265
# creation contract must see it as uninitializable
2220
2266
raise errors.UninitializableFormat(self)
2221
2267
mutter('creating branch reference in %s', a_bzrdir.user_url)
2222
if a_bzrdir._format.fixed_components:
2223
raise errors.IncompatibleFormat(self, a_bzrdir._format)
2225
name = a_bzrdir._get_selected_branch()
2226
2268
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2227
2269
branch_transport.put_bytes('location',
2228
target_branch.user_url)
2229
branch_transport.put_bytes('format', self.as_string())
2230
branch = self.open(a_bzrdir, name, _found=True,
2270
target_branch.bzrdir.user_url)
2271
branch_transport.put_bytes('format', self.get_format_string())
2273
a_bzrdir, name, _found=True,
2231
2274
possible_transports=[target_branch.bzrdir.root_transport])
2232
2275
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)
2235
2283
def _make_reference_clone_function(format, a_branch):
2236
2284
"""Create a clone() routine for a branch dynamically."""
2237
2285
def clone(to_bzrdir, revision_id=None,
2260
2307
:param possible_transports: An optional reusable transports list.
2263
name = a_bzrdir._get_selected_branch()
2265
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2310
format = BranchFormat.find_format(a_bzrdir, name=name)
2266
2311
if format.__class__ != self.__class__:
2267
2312
raise AssertionError("wrong format %r found for %r" %
2268
2313
(format, self))
2269
2314
if location is None:
2270
2315
location = self.get_reference(a_bzrdir, name)
2271
real_bzrdir = controldir.ControlDir.open(
2316
real_bzrdir = bzrdir.BzrDir.open(
2272
2317
location, possible_transports=possible_transports)
2273
result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks,
2274
possible_transports=possible_transports)
2318
result = real_bzrdir.open_branch(name=name,
2319
ignore_fallbacks=ignore_fallbacks)
2275
2320
# this changes the behaviour of result.clone to create a new reference
2276
2321
# rather than a copy of the content of the branch.
2277
2322
# I did not use a proxy object because that needs much more extensive
2306
2337
BranchFormat.network_name() for more detail.
2309
format_registry = BranchFormatRegistry(network_format_registry)
2312
2341
# formats which have no format string are not discoverable
2313
2342
# and not independently creatable, so are not registered.
2343
__format5 = BzrBranchFormat5()
2314
2344
__format6 = BzrBranchFormat6()
2315
2345
__format7 = BzrBranchFormat7()
2316
2346
__format8 = BzrBranchFormat8()
2317
format_registry.register_lazy(
2318
"Bazaar-NG branch format 5\n", "bzrlib.branchfmt.fullhistory", "BzrBranchFormat5")
2319
format_registry.register(BranchReferenceFormat())
2320
format_registry.register(__format6)
2321
format_registry.register(__format7)
2322
format_registry.register(__format8)
2323
format_registry.set_default(__format7)
2347
BranchFormat.register_format(__format5)
2348
BranchFormat.register_format(BranchReferenceFormat())
2349
BranchFormat.register_format(__format6)
2350
BranchFormat.register_format(__format7)
2351
BranchFormat.register_format(__format8)
2352
BranchFormat.set_default_format(__format7)
2353
_legacy_formats = [BzrBranchFormat4(),
2355
network_format_registry.register(
2356
_legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2326
2359
class BranchWriteLockResult(LogicalLockResult):
2359
2392
def __init__(self, _format=None,
2360
2393
_control_files=None, a_bzrdir=None, name=None,
2361
_repository=None, ignore_fallbacks=False,
2362
possible_transports=None):
2394
_repository=None, ignore_fallbacks=False):
2363
2395
"""Create new branch object at a particular location."""
2364
2396
if a_bzrdir is None:
2365
2397
raise ValueError('a_bzrdir must be supplied')
2367
raise ValueError('name must be supplied')
2368
self.bzrdir = a_bzrdir
2369
self._user_transport = self.bzrdir.transport.clone('..')
2371
self._user_transport.set_segment_parameter(
2372
"branch", urlutils.escape(name))
2373
self._base = self._user_transport.base
2399
self.bzrdir = a_bzrdir
2400
self._base = self.bzrdir.transport.clone('..').base
2374
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
2375
2405
self._format = _format
2376
2406
if _control_files is None:
2377
2407
raise ValueError('BzrBranch _control_files is None')
2378
2408
self.control_files = _control_files
2379
2409
self._transport = _control_files._transport
2380
2410
self.repository = _repository
2381
self.conf_store = None
2382
Branch.__init__(self, possible_transports)
2411
Branch.__init__(self)
2384
2413
def __str__(self):
2385
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,
2387
2420
__repr__ = __str__
2393
2426
base = property(_get_base, doc="The URL for the root of this branch.")
2396
def user_transport(self):
2397
return self._user_transport
2399
2428
def _get_config(self):
2400
return _mod_config.TransportConfig(self._transport, 'branch.conf')
2402
def _get_config_store(self):
2403
if self.conf_store is None:
2404
self.conf_store = _mod_config.BranchStore(self)
2405
return self.conf_store
2407
def _uncommitted_branch(self):
2408
"""Return the branch that may contain uncommitted changes."""
2409
master = self.get_master_branch()
2410
if master is not None:
2415
def store_uncommitted(self, creator):
2416
"""Store uncommitted changes from a ShelfCreator.
2418
:param creator: The ShelfCreator containing uncommitted changes, or
2419
None to delete any stored changes.
2420
:raises: ChangesAlreadyStored if the branch already has changes.
2422
branch = self._uncommitted_branch()
2424
branch._transport.delete('stored-transform')
2426
if branch._transport.has('stored-transform'):
2427
raise errors.ChangesAlreadyStored
2428
transform = StringIO()
2429
creator.write_shelf(transform)
2431
branch._transport.put_file('stored-transform', transform)
2433
def get_unshelver(self, tree):
2434
"""Return a shelf.Unshelver for this branch and tree.
2436
:param tree: The tree to use to construct the Unshelver.
2437
:return: an Unshelver or None if no changes are stored.
2439
branch = self._uncommitted_branch()
2441
transform = branch._transport.get('stored-transform')
2442
except errors.NoSuchFile:
2444
return shelf.Unshelver.from_tree_and_shelf(tree, transform)
2429
return TransportConfig(self._transport, 'branch.conf')
2446
2431
def is_locked(self):
2447
2432
return self.control_files.is_locked()
2514
2507
"""See Branch.print_file."""
2515
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)
2517
2573
@needs_write_lock
2518
2574
def set_last_revision_info(self, revno, revision_id):
2519
if not revision_id or not isinstance(revision_id, basestring):
2520
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
2521
2585
revision_id = _mod_revision.ensure_null(revision_id)
2522
old_revno, old_revid = self.last_revision_info()
2523
if self.get_append_revisions_only():
2524
self._check_history_violation(revision_id)
2525
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2526
self._write_last_revision_info(revno, revision_id)
2527
self._clear_cached_state()
2528
self._last_revision_info_cache = revno, revision_id
2529
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))
2531
2615
def basis_tree(self):
2532
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()
2544
2650
def get_stacked_on_url(self):
2545
2651
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2557
2663
self._transport.put_bytes('parent', url + '\n',
2558
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(
2560
2700
@needs_write_lock
2562
"""If bound, unbind"""
2563
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:
2565
2716
@needs_write_lock
2566
2717
def bind(self, other):
2588
2739
# history around
2589
2740
self.set_bound_location(other.base)
2591
def get_bound_location(self):
2593
return self._transport.get_bytes('bound')[:-1]
2594
except errors.NoSuchFile:
2598
def get_master_branch(self, possible_transports=None):
2599
"""Return the branch we are bound to.
2601
:return: Either a Branch, or None
2603
if self._master_branch_cache is None:
2604
self._master_branch_cache = self._get_master_branch(
2605
possible_transports)
2606
return self._master_branch_cache
2608
def _get_master_branch(self, possible_transports):
2609
bound_loc = self.get_bound_location()
2613
return Branch.open(bound_loc,
2614
possible_transports=possible_transports)
2615
except (errors.NotBranchError, errors.ConnectionError), e:
2616
raise errors.BoundBranchConnectionFailure(
2619
2742
@needs_write_lock
2620
def set_bound_location(self, location):
2621
"""Set the target where this branch is bound to.
2623
:param location: URL to the target branch
2625
self._master_branch_cache = None
2627
self._transport.put_bytes('bound', location+'\n',
2628
mode=self.bzrdir._get_file_mode())
2631
self._transport.delete('bound')
2632
except errors.NoSuchFile:
2744
"""If bound, unbind"""
2745
return self.set_bound_location(None)
2636
2747
@needs_write_lock
2637
2748
def update(self, possible_transports=None):
2653
def _read_last_revision_info(self):
2654
revision_string = self._transport.get_bytes('last-revision')
2655
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2656
revision_id = cache_utf8.get_cached_utf8(revision_id)
2658
return revno, revision_id
2660
def _write_last_revision_info(self, revno, revision_id):
2661
"""Simply write out the revision id, with no checks.
2663
Use set_last_revision_info to perform this safely.
2665
Does not update the revision_history cache.
2667
revision_id = _mod_revision.ensure_null(revision_id)
2668
out_string = '%d %s\n' % (revno, revision_id)
2669
self._transport.put_bytes('last-revision', out_string,
2670
mode=self.bzrdir._get_file_mode())
2673
def update_feature_flags(self, updated_flags):
2674
"""Update the feature flags for this branch.
2676
:param updated_flags: Dictionary mapping feature names to necessities
2677
A necessity can be None to indicate the feature should be removed
2679
self._format._update_feature_flags(updated_flags)
2680
self.control_transport.put_bytes('format', self._format.as_string())
2683
class BzrBranch8(BzrBranch):
2765
class BzrBranch8(BzrBranch5):
2684
2766
"""A branch that stores tree-reference locations."""
2686
def _open_hook(self, possible_transports=None):
2768
def _open_hook(self):
2687
2769
if self._ignore_fallbacks:
2689
if possible_transports is None:
2690
possible_transports = [self.bzrdir.root_transport]
2692
2772
url = self.get_stacked_on_url()
2693
2773
except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2715
2794
self._last_revision_info_cache = None
2716
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)
2718
2842
def _check_history_violation(self, revision_id):
2719
current_revid = self.last_revision()
2720
last_revision = _mod_revision.ensure_null(current_revid)
2843
last_revision = _mod_revision.ensure_null(self.last_revision())
2721
2844
if _mod_revision.is_null(last_revision):
2723
graph = self.repository.get_graph()
2724
for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
2725
if lh_ancestor == current_revid:
2727
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2846
if last_revision not in self._lefthand_history(revision_id):
2847
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2729
2849
def _gen_revision_history(self):
2730
2850
"""Generate the revision history from last revision
2825
2961
def set_bound_location(self, location):
2826
2962
"""See Branch.set_push_location."""
2827
self._master_branch_cache = None
2829
conf = self.get_config_stack()
2964
config = self.get_config()
2830
2965
if location is None:
2831
if not conf.get('bound'):
2966
if config.get_user_option('bound') != 'True':
2834
conf.set('bound', 'False')
2969
config.set_user_option('bound', 'False', warn_masked=True)
2837
2972
self._set_config_location('bound_location', location,
2839
conf.set('bound', 'True')
2974
config.set_user_option('bound', 'True', warn_masked=True)
2842
2977
def _get_bound_location(self, bound):
2843
2978
"""Return the bound location in the config file.
2845
2980
Return None if the bound parameter does not match"""
2846
conf = self.get_config_stack()
2847
if conf.get('bound') != bound:
2981
config = self.get_config()
2982
config_bound = (config.get_user_option('bound') == 'True')
2983
if config_bound != bound:
2849
return self._get_config_location('bound_location', config=conf)
2985
return self._get_config_location('bound_location', config=config)
2851
2987
def get_bound_location(self):
2852
"""See Branch.get_bound_location."""
2988
"""See Branch.set_push_location."""
2853
2989
return self._get_bound_location(True)
2855
2991
def get_old_bound_location(self):
2860
2996
# you can always ask for the URL; but you might not be able to use it
2861
2997
# if the repo can't support stacking.
2862
2998
## self._check_stackable_repo()
2863
# stacked_on_location is only ever defined in branch.conf, so don't
2864
# waste effort reading the whole stack of config files.
2865
conf = _mod_config.BranchOnlyStack(self)
2866
stacked_url = self._get_config_location('stacked_on_location',
2999
stacked_url = self._get_config_location('stacked_on_location')
2868
3000
if stacked_url is None:
2869
3001
raise errors.NotStacked(self)
2870
return stacked_url.encode('utf-8')
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)
2872
3016
@needs_read_lock
2873
3017
def get_rev_id(self, revno, history=None):
2962
3101
:ivar local_branch: target branch if there is a Master, else None
2963
3102
:ivar target_branch: Target/destination branch object. (write locked)
2964
3103
:ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
2965
:ivar tag_updates: A dict with new tags, see BasicTags.merge_to
3106
@deprecated_method(deprecated_in((2, 3, 0)))
3108
"""Return the relative change in revno.
3110
:deprecated: Use `new_revno` and `old_revno` instead.
3112
return self.new_revno - self.old_revno
2968
3114
def report(self, to_file):
2969
tag_conflicts = getattr(self, "tag_conflicts", None)
2970
tag_updates = getattr(self, "tag_updates", None)
2971
3115
if not is_quiet():
2972
if self.old_revid != self.new_revid:
3116
if self.old_revid == self.new_revid:
3117
to_file.write('No revisions to pull.\n')
2973
3119
to_file.write('Now on revision %d.\n' % self.new_revno)
2975
to_file.write('%d tag(s) updated.\n' % len(tag_updates))
2976
if self.old_revid == self.new_revid and not tag_updates:
2977
if not tag_conflicts:
2978
to_file.write('No revisions or tags to pull.\n')
2980
to_file.write('No revisions to pull.\n')
2981
3120
self._show_tag_conficts(to_file)
3000
3139
target, otherwise it will be None.
3142
@deprecated_method(deprecated_in((2, 3, 0)))
3144
"""Return the relative change in revno.
3146
:deprecated: Use `new_revno` and `old_revno` instead.
3148
return self.new_revno - self.old_revno
3003
3150
def report(self, to_file):
3004
# TODO: This function gets passed a to_file, but then
3005
# ignores it and calls note() instead. This is also
3006
# inconsistent with PullResult(), which writes to stdout.
3007
# -- JRV20110901, bug #838853
3008
tag_conflicts = getattr(self, "tag_conflicts", None)
3009
tag_updates = getattr(self, "tag_updates", None)
3011
if self.old_revid != self.new_revid:
3012
note(gettext('Pushed up to revision %d.') % self.new_revno)
3014
note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
3015
if self.old_revid == self.new_revid and not tag_updates:
3016
if not tag_conflicts:
3017
note(gettext('No new revisions or tags to push.'))
3019
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)
3020
3156
self._show_tag_conficts(to_file)
3053
3189
# Copy source data into target
3054
3190
new_branch._write_last_revision_info(*branch.last_revision_info())
3055
new_branch.lock_write()
3057
new_branch.set_parent(branch.get_parent())
3058
new_branch.set_bound_location(branch.get_bound_location())
3059
new_branch.set_push_location(branch.get_push_location())
3191
new_branch.set_parent(branch.get_parent())
3192
new_branch.set_bound_location(branch.get_bound_location())
3193
new_branch.set_push_location(branch.get_push_location())
3063
3195
# New branch has no tags by default
3064
3196
new_branch.tags._set_tag_dict({})
3066
3198
# Copying done; now update target format
3067
3199
new_branch._transport.put_bytes('format',
3200
format.get_format_string(),
3069
3201
mode=new_branch.bzrdir._get_file_mode())
3071
3203
# Clean up old files
3072
3204
new_branch._transport.delete('revision-history')
3076
branch.set_parent(None)
3077
except errors.NoSuchFile:
3079
branch.set_bound_location(None)
3206
branch.set_parent(None)
3207
except errors.NoSuchFile:
3209
branch.set_bound_location(None)
3084
3212
class Converter6to7(object):
3088
3216
format = BzrBranchFormat7()
3089
3217
branch._set_config_location('stacked_on_location', '')
3090
3218
# update target format
3091
branch._transport.put_bytes('format', format.as_string())
3219
branch._transport.put_bytes('format', format.get_format_string())
3094
3222
class Converter7to8(object):
3095
"""Perform an in-place upgrade of format 7 to format 8"""
3223
"""Perform an in-place upgrade of format 6 to format 7"""
3097
3225
def convert(self, branch):
3098
3226
format = BzrBranchFormat8()
3099
3227
branch._transport.put_bytes('references', '')
3100
3228
# update target format
3101
branch._transport.put_bytes('format', format.as_string())
3229
branch._transport.put_bytes('format', format.get_format_string())
3232
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3233
"""Run ``callable(*args, **kwargs)``, write-locking target for the
3236
_run_with_write_locked_target will attempt to release the lock it acquires.
3238
If an exception is raised by callable, then that exception *will* be
3239
propagated, even if the unlock attempt raises its own error. Thus
3240
_run_with_write_locked_target should be preferred to simply doing::
3244
return callable(*args, **kwargs)
3249
# This is very similar to bzrlib.decorators.needs_write_lock. Perhaps they
3250
# should share code?
3253
result = callable(*args, **kwargs)
3255
exc_info = sys.exc_info()
3259
raise exc_info[0], exc_info[1], exc_info[2]
3104
3265
class InterBranch(InterObject):
3209
3366
self.source.tags.merge_to(self.target.tags)
3211
3368
@needs_write_lock
3212
def fetch(self, stop_revision=None, limit=None):
3213
if self.target.base == self.source.base:
3215
self.source.lock_read()
3217
fetch_spec_factory = fetch.FetchSpecFactory()
3218
fetch_spec_factory.source_branch = self.source
3219
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3220
fetch_spec_factory.source_repo = self.source.repository
3221
fetch_spec_factory.target_repo = self.target.repository
3222
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3223
fetch_spec_factory.limit = limit
3224
fetch_spec = fetch_spec_factory.make_fetch_spec()
3225
return self.target.repository.fetch(self.source.repository,
3226
fetch_spec=fetch_spec)
3228
self.source.unlock()
3231
def _update_revisions(self, stop_revision=None, overwrite=False,
3369
def update_revisions(self, stop_revision=None, overwrite=False,
3371
"""See InterBranch.update_revisions()."""
3233
3372
other_revno, other_last_revision = self.source.last_revision_info()
3234
3373
stop_revno = None # unknown
3235
3374
if stop_revision is None:
3302
3431
return self._pull(overwrite,
3303
3432
stop_revision, _hook_master=master_branch,
3304
3433
run_hooks=run_hooks,
3305
_override_hook_target=_override_hook_target,
3306
merge_tags_to_master=not source_is_master)
3434
_override_hook_target=_override_hook_target)
3308
3436
if master_branch:
3309
3437
master_branch.unlock()
3311
def push(self, overwrite=False, stop_revision=None, lossy=False,
3439
def push(self, overwrite=False, stop_revision=None,
3312
3440
_override_hook_source_branch=None):
3313
3441
"""See InterBranch.push.
3315
3443
This is the basic concrete implementation of push()
3317
:param _override_hook_source_branch: If specified, run the hooks
3318
passing this Branch as the source, rather than self. This is for
3319
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.
3323
raise errors.LossyPushToSameVCS(self.source, self.target)
3324
3450
# TODO: Public option to disable running hooks - should be trivial but
3327
op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3328
op.add_cleanup(self.source.lock_read().unlock)
3329
op.add_cleanup(self.target.lock_write().unlock)
3330
return op.run(overwrite, stop_revision,
3331
_override_hook_source_branch=_override_hook_source_branch)
3333
def _basic_push(self, overwrite, stop_revision):
3334
"""Basic implementation of push without bound branches or hooks.
3336
Must be called with source read locked and target write locked.
3338
result = BranchPushResult()
3339
result.source_branch = self.source
3340
result.target_branch = self.target
3341
result.old_revno, result.old_revid = self.target.last_revision_info()
3342
self.source.update_references(self.target)
3343
overwrite = _fix_overwrite_type(overwrite)
3344
if result.old_revid != stop_revision:
3345
# We assume that during 'push' this repository is closer than
3347
graph = self.source.repository.get_graph(self.target.repository)
3348
self._update_revisions(stop_revision,
3349
overwrite=("history" in overwrite),
3351
if self.source._push_should_merge_tags():
3352
result.tag_updates, result.tag_conflicts = (
3353
self.source.tags.merge_to(
3354
self.target.tags, "tags" in overwrite))
3355
result.new_revno, result.new_revid = self.target.last_revision_info()
3358
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,
3359
3462
_override_hook_source_branch=None):
3360
3463
"""Push from source into target, and into target's master if any.
3373
3476
# be bound to itself? -- mbp 20070507
3374
3477
master_branch = self.target.get_master_branch()
3375
3478
master_branch.lock_write()
3376
operation.add_cleanup(master_branch.unlock)
3377
# push into the master from the source branch.
3378
master_inter = InterBranch.get(self.source, master_branch)
3379
master_inter._basic_push(overwrite, stop_revision)
3380
# and push into the target branch from the source. Note that
3381
# we push from the source branch again, because it's considered
3382
# the highest bandwidth repository.
3383
result = self._basic_push(overwrite, stop_revision)
3384
result.master_branch = master_branch
3385
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()
3387
master_branch = None
3388
3494
# no master branch
3389
result = self._basic_push(overwrite, stop_revision)
3495
result = self.source._basic_push(self.target, overwrite,
3390
3497
# TODO: Why set master_branch and local_branch if there's no
3391
3498
# binding? Maybe cleaner to just leave them unset? -- mbp
3393
3500
result.master_branch = self.target
3394
3501
result.local_branch = None
3398
3505
def _pull(self, overwrite=False, stop_revision=None,
3399
3506
possible_transports=None, _hook_master=None, run_hooks=True,
3400
_override_hook_target=None, local=False,
3401
merge_tags_to_master=True):
3507
_override_hook_target=None, local=False):
3402
3508
"""See Branch.pull.
3404
3510
This function is the core worker, used by GenericInterBranch.pull to
3435
3539
# -- JRV20090506
3436
3540
result.old_revno, result.old_revid = \
3437
3541
self.target.last_revision_info()
3438
overwrite = _fix_overwrite_type(overwrite)
3439
self._update_revisions(stop_revision,
3440
overwrite=("history" in overwrite),
3542
self.target.update_revisions(self.source, stop_revision,
3543
overwrite=overwrite, graph=graph)
3442
3544
# TODO: The old revid should be specified when merging tags,
3443
3545
# so a tags implementation that versions tags can only
3444
3546
# pull in the most recent changes. -- JRV20090506
3445
result.tag_updates, result.tag_conflicts = (
3446
self.source.tags.merge_to(self.target.tags,
3447
"tags" in overwrite,
3448
ignore_master=not merge_tags_to_master))
3547
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3449
3549
result.new_revno, result.new_revid = self.target.last_revision_info()
3450
3550
if _hook_master:
3451
3551
result.master_branch = _hook_master
added
removed
bzrlib/branch.py
