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,
34
revision as _mod_revision,
42
from bzrlib.config import BranchConfig, TransportConfig
43
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
44
from bzrlib.tag import (
31
config as _mod_config,
40
revision as _mod_revision,
49
from bzrlib.i18n import gettext, ngettext
50
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
51
from bzrlib.hooks import HookPoint, Hooks
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
52
66
from bzrlib.inter import InterObject
53
67
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
54
68
from bzrlib import registry
85
95
def user_transport(self):
86
96
return self.bzrdir.user_transport
88
def __init__(self, *ignored, **ignored_too):
98
def __init__(self, possible_transports=None):
89
99
self.tags = self._format.make_tags(self)
90
100
self._revision_history_cache = None
91
101
self._revision_id_to_revno_cache = None
92
102
self._partial_revision_id_to_revno_cache = {}
93
103
self._partial_revision_history_cache = []
104
self._tags_bytes = None
94
105
self._last_revision_info_cache = None
106
self._master_branch_cache = None
95
107
self._merge_sorted_revisions_cache = None
108
self._open_hook(possible_transports)
97
109
hooks = Branch.hooks['open']
98
110
for hook in hooks:
101
def _open_hook(self):
113
def _open_hook(self, possible_transports):
102
114
"""Called by init to allow simpler extension of the base class."""
104
def _activate_fallback_location(self, url):
116
def _activate_fallback_location(self, url, possible_transports):
105
117
"""Activate the branch/repository from url as a fallback repository."""
106
repo = self._get_fallback_repository(url)
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
126
if repo.has_same_location(self.repository):
108
127
raise errors.UnstackableLocationError(self.user_url, url)
109
128
self.repository.add_fallback_repository(repo)
163
182
For instance, if the branch is at URL/.bzr/branch,
164
183
Branch.open(URL) -> a Branch instance.
166
control = bzrdir.BzrDir.open(base, _unsupported,
167
possible_transports=possible_transports)
168
return control.open_branch(unsupported=_unsupported)
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)
171
def open_from_transport(transport, name=None, _unsupported=False):
191
def open_from_transport(transport, name=None, _unsupported=False,
192
possible_transports=None):
172
193
"""Open the branch rooted at transport"""
173
control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
174
return control.open_branch(name=name, unsupported=_unsupported)
194
control = controldir.ControlDir.open_from_transport(transport, _unsupported)
195
return control.open_branch(name=name, unsupported=_unsupported,
196
possible_transports=possible_transports)
177
199
def open_containing(url, possible_transports=None):
220
253
raise NotImplementedError(self._get_config)
222
def _get_fallback_repository(self, url):
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
273
"""Get the repository we fallback to at url."""
224
274
url = urlutils.join(self.base, url)
225
a_branch = Branch.open(url,
226
possible_transports=[self.bzrdir.root_transport])
275
a_branch = Branch.open(url, possible_transports=possible_transports)
227
276
return a_branch.repository
229
279
def _get_tags_bytes(self):
230
280
"""Get the bytes of a serialised tags dict.
491
545
rev_iter = iter(merge_sorted_revisions)
492
546
if start_revision_id is not None:
493
547
for node in rev_iter:
494
rev_id = node.key[-1]
495
549
if rev_id != start_revision_id:
498
552
# The decision to include the start or not
499
553
# depends on the stop_rule if a stop is provided
500
554
# so pop this node back into the iterator
501
rev_iter = chain(iter([node]), rev_iter)
555
rev_iter = itertools.chain(iter([node]), rev_iter)
503
557
if stop_revision_id is None:
504
558
# Yield everything
505
559
for node in rev_iter:
506
rev_id = node.key[-1]
507
561
yield (rev_id, node.merge_depth, node.revno,
508
562
node.end_of_merge)
509
563
elif stop_rule == 'exclude':
510
564
for node in rev_iter:
511
rev_id = node.key[-1]
512
566
if rev_id == stop_revision_id:
514
568
yield (rev_id, node.merge_depth, node.revno,
515
569
node.end_of_merge)
516
570
elif stop_rule == 'include':
517
571
for node in rev_iter:
518
rev_id = node.key[-1]
519
573
yield (rev_id, node.merge_depth, node.revno,
520
574
node.end_of_merge)
521
575
if rev_id == stop_revision_id:
648
704
raise errors.UnsupportedOperation(self.get_reference_info, self)
650
706
@needs_write_lock
651
def fetch(self, from_branch, last_revision=None, pb=None):
707
def fetch(self, from_branch, last_revision=None, limit=None):
652
708
"""Copy revisions from from_branch into this branch.
654
710
:param from_branch: Where to copy from.
655
711
:param last_revision: What revision to stop at (None for at the end
657
:param pb: An optional progress bar to use.
713
:param limit: Optional rough limit of revisions to fetch
660
if self.base == from_branch.base:
663
symbol_versioning.warn(
664
symbol_versioning.deprecated_in((1, 14, 0))
665
% "pb parameter to fetch()")
666
from_branch.lock_read()
668
if last_revision is None:
669
last_revision = from_branch.last_revision()
670
last_revision = _mod_revision.ensure_null(last_revision)
671
return self.repository.fetch(from_branch.repository,
672
revision_id=last_revision,
716
return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)
677
718
def get_bound_location(self):
678
719
"""Return the URL of the branch we are bound to.
699
740
:param committer: Optional committer to set for commit.
700
741
:param revprops: Optional dictionary of revision properties.
701
742
: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
705
config = self.get_config()
747
if config_stack is None:
748
config_stack = self.get_config_stack()
707
return self.repository.get_commit_builder(self, parents, config,
708
timestamp, timezone, committer, revprops, revision_id)
750
return self.repository.get_commit_builder(self, parents, config_stack,
751
timestamp, timezone, committer, revprops, revision_id,
710
754
def get_master_branch(self, possible_transports=None):
711
755
"""Return the branch we are bound to.
738
784
"""Print `file` to stdout."""
739
785
raise NotImplementedError(self.print_file)
741
def set_revision_history(self, rev_history):
742
raise NotImplementedError(self.set_revision_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)
744
818
@needs_write_lock
745
819
def set_parent(self, url):
967
1046
:return: A tuple (revno, revision_id).
969
1048
if self._last_revision_info_cache is None:
970
self._last_revision_info_cache = self._last_revision_info()
1049
self._last_revision_info_cache = self._read_last_revision_info()
971
1050
return self._last_revision_info_cache
973
def _last_revision_info(self):
974
rh = self.revision_history()
977
return (revno, rh[-1])
979
return (0, _mod_revision.NULL_REVISION)
981
@deprecated_method(deprecated_in((1, 6, 0)))
982
def missing_revisions(self, other, stop_revision=None):
983
"""Return a list of new revisions that would perfectly fit.
985
If self and other have not diverged, return a list of the revisions
986
present in other, but missing from self.
988
self_history = self.revision_history()
989
self_len = len(self_history)
990
other_history = other.revision_history()
991
other_len = len(other_history)
992
common_index = min(self_len, other_len) -1
993
if common_index >= 0 and \
994
self_history[common_index] != other_history[common_index]:
995
raise errors.DivergedBranches(self, other)
997
if stop_revision is None:
998
stop_revision = other_len
1000
if stop_revision > other_len:
1001
raise errors.NoSuchRevision(self, stop_revision)
1002
return other_history[self_len:stop_revision]
1004
def update_revisions(self, other, stop_revision=None, overwrite=False,
1006
"""Pull in new perfect-fit revisions.
1008
:param other: Another Branch to pull from
1009
:param stop_revision: Updated until the given revision
1010
:param overwrite: Always set the branch pointer, rather than checking
1011
to see if it is a proper descendant.
1012
:param graph: A Graph object that can be used to query history
1013
information. This can be None.
1016
return InterBranch.get(other, self).update_revisions(stop_revision,
1019
def import_last_revision_info(self, source_repo, revno, revid):
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,
1020
1057
"""Set the last revision info, importing from another repo if necessary.
1022
1059
This is used by the bound branch code to upload a revision to
1023
1060
the master branch first before updating the tip of the local branch.
1061
Revisions referenced by source's tags are also transferred.
1025
:param source_repo: Source repository to optionally fetch from
1063
:param source: Source branch to optionally fetch from
1026
1064
:param revno: Revision number of the new tip
1027
1065
: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)
1029
if not self.repository.has_same_location(source_repo):
1030
self.repository.fetch(source_repo, revision_id=revid)
1071
if not self.repository.has_same_location(source.repository):
1072
self.fetch(source, revid)
1031
1073
self.set_last_revision_info(revno, revid)
1074
return (revno, revid)
1033
1076
def revision_id_to_revno(self, revision_id):
1034
1077
"""Given a revision id, return its revno"""
1035
1078
if _mod_revision.is_null(revision_id):
1037
history = self.revision_history()
1080
history = self._revision_history()
1039
1082
return history.index(revision_id) + 1
1040
1083
except ValueError:
1067
1110
stop_revision=stop_revision,
1068
1111
possible_transports=possible_transports, *args, **kwargs)
1070
def push(self, target, overwrite=False, stop_revision=None, *args,
1113
def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1072
1115
"""Mirror this branch into target.
1074
1117
This branch is considered to be 'local', having low latency.
1076
1119
return InterBranch.get(self, target).push(overwrite, stop_revision,
1079
def lossy_push(self, target, stop_revision=None):
1080
"""Push deltas into another branch.
1082
:note: This does not, like push, retain the revision ids from
1083
the source branch and will, rather than adding bzr-specific
1084
metadata, push only those semantics of the revision that can be
1085
natively represented by this branch' VCS.
1087
:param target: Target branch
1088
:param stop_revision: Revision to push, defaults to last revision.
1089
:return: BranchPushResult with an extra member revidmap:
1090
A dictionary mapping revision ids from the target branch
1091
to new revision ids in the target branch, for each
1092
revision that was pushed.
1094
inter = InterBranch.get(self, target)
1095
lossy_push = getattr(inter, "lossy_push", None)
1096
if lossy_push is None:
1097
raise errors.LossyPushToSameVCS(self, target)
1098
return lossy_push(stop_revision)
1120
lossy, *args, **kwargs)
1100
1122
def basis_tree(self):
1101
1123
"""Return `Tree` object for last revision."""
1353
1378
# TODO: We should probably also check that self.revision_history
1354
1379
# matches the repository for older branch formats.
1355
1380
# If looking for the code that cross-checks repository parents against
1356
# the iter_reverse_revision_history output, that is now a repository
1381
# the Graph.iter_lefthand_ancestry output, that is now a repository
1357
1382
# specific check.
1360
def _get_checkout_format(self):
1385
def _get_checkout_format(self, lightweight=False):
1361
1386
"""Return the most suitable metadir for a checkout of this branch.
1362
1387
Weaves are used if this branch's repository uses weaves.
1364
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1365
from bzrlib.repofmt import weaverepo
1366
format = bzrdir.BzrDirMetaFormat1()
1367
format.repository_format = weaverepo.RepositoryFormat7()
1369
format = self.repository.bzrdir.checkout_metadir()
1370
format.set_branch_format(self._format)
1389
format = self.repository.bzrdir.checkout_metadir()
1390
format.set_branch_format(self._format)
1373
1393
def create_clone_on_transport(self, to_transport, revision_id=None,
1374
stacked_on=None, create_prefix=False, use_existing_dir=False):
1394
stacked_on=None, create_prefix=False, use_existing_dir=False,
1375
1396
"""Create a clone of this branch and its bzrdir.
1377
1398
:param to_transport: The transport to clone onto.
1413
1435
t = transport.get_transport(to_location)
1414
1436
t.ensure_base()
1437
format = self._get_checkout_format(lightweight=lightweight)
1439
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
1415
1455
if lightweight:
1416
format = self._get_checkout_format()
1417
checkout = format.initialize_on_transport(t)
1418
from_branch = BranchReferenceFormat().initialize(checkout,
1456
from_branch = checkout.set_branch_reference(target_branch=self)
1421
format = self._get_checkout_format()
1422
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1423
to_location, force_new_tree=False, format=format)
1424
checkout = checkout_branch.bzrdir
1458
policy = checkout.determine_repository_policy()
1459
repo = policy.acquire_repository()[0]
1460
checkout_branch = checkout.create_branch()
1425
1461
checkout_branch.bind(self)
1426
1462
# pull up to the specified revision_id to set the initial
1427
1463
# branch tip correctly, and seed it with history.
1428
1464
checkout_branch.pull(self, stop_revision=revision_id)
1430
1466
tree = checkout.create_workingtree(revision_id,
1431
1467
from_branch=from_branch,
1432
1468
accelerator_tree=accelerator_tree,
1512
1549
raise AssertionError("invalid heads: %r" % (heads,))
1515
class BranchFormat(object):
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
1575
"""An encapsulation of the initialization and open routines for a format.
1518
1577
Formats provide three things:
1519
1578
* An initialization routine,
1579
* a format description
1521
1580
* an open routine.
1523
1582
Formats are placed in an dict by their format string for reference
1524
during branch opening. Its not required that these be instances, they
1583
during branch opening. It's not required that these be instances, they
1525
1584
can be classes themselves with class methods - it simply depends on
1526
1585
whether state is needed for a given format or not.
1530
1589
object will be created every time regardless.
1533
_default_format = None
1534
"""The default format used for new branches."""
1537
"""The known formats."""
1539
can_set_append_revisions_only = True
1541
1592
def __eq__(self, other):
1542
1593
return self.__class__ is other.__class__
1544
1595
def __ne__(self, other):
1545
1596
return not (self == other)
1548
def find_format(klass, a_bzrdir, name=None):
1549
"""Return the format for the branch object in a_bzrdir."""
1551
transport = a_bzrdir.get_branch_transport(None, name=name)
1552
format_string = transport.get_bytes("format")
1553
format = klass._formats[format_string]
1554
if isinstance(format, MetaDirBranchFormatFactory):
1557
except errors.NoSuchFile:
1558
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1560
raise errors.UnknownFormatError(format=format_string, kind='branch')
1563
def get_default_format(klass):
1564
"""Return the current default format."""
1565
return klass._default_format
1568
def get_formats(klass):
1569
"""Get all the known formats.
1571
Warning: This triggers a load of all lazy registered formats: do not
1572
use except when that is desireed.
1575
for fmt in klass._formats.values():
1576
if isinstance(fmt, MetaDirBranchFormatFactory):
1581
def get_reference(self, a_bzrdir, name=None):
1582
"""Get the target reference of the branch in a_bzrdir.
1598
def get_reference(self, controldir, name=None):
1599
"""Get the target reference of the branch in controldir.
1584
1601
format probing must have been completed before calling
1585
1602
this method - it is assumed that the format of the branch
1586
in a_bzrdir is correct.
1603
in controldir is correct.
1588
:param a_bzrdir: The bzrdir to get the branch data from.
1605
:param controldir: The controldir to get the branch data from.
1589
1606
:param name: Name of the colocated branch to fetch
1590
1607
:return: None if the branch is not a reference branch.
1595
def set_reference(self, a_bzrdir, name, to_branch):
1596
"""Set the target reference of the branch in a_bzrdir.
1612
def set_reference(self, controldir, name, to_branch):
1613
"""Set the target reference of the branch in controldir.
1598
1615
format probing must have been completed before calling
1599
1616
this method - it is assumed that the format of the branch
1600
in a_bzrdir is correct.
1617
in controldir is correct.
1602
:param a_bzrdir: The bzrdir to set the branch reference for.
1619
:param controldir: The controldir to set the branch reference for.
1603
1620
:param name: Name of colocated branch to set, None for default
1604
1621
:param to_branch: branch that the checkout is to reference
1606
1623
raise NotImplementedError(self.set_reference)
1608
def get_format_string(self):
1609
"""Return the ASCII format string that identifies this format."""
1610
raise NotImplementedError(self.get_format_string)
1612
1625
def get_format_description(self):
1613
1626
"""Return the short format description for this format."""
1614
1627
raise NotImplementedError(self.get_format_description)
1616
def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1629
def _run_post_branch_init_hooks(self, controldir, name, branch):
1617
1630
hooks = Branch.hooks['post_branch_init']
1620
params = BranchInitHookParams(self, a_bzrdir, name, branch)
1633
params = BranchInitHookParams(self, controldir, name, branch)
1621
1634
for hook in hooks:
1624
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1625
lock_type='metadir', set_format=True):
1626
"""Initialize a branch in a bzrdir, with specified files
1628
:param a_bzrdir: The bzrdir to initialize the branch in
1629
:param utf8_files: The files to create as a list of
1630
(filename, content) tuples
1631
:param name: Name of colocated branch to create, if any
1632
:param set_format: If True, set the format with
1633
self.get_format_string. (BzrBranch4 has its format set
1635
:return: a branch in this format
1637
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1638
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1640
'metadir': ('lock', lockdir.LockDir),
1641
'branch4': ('branch-lock', lockable_files.TransportLock),
1643
lock_name, lock_class = lock_map[lock_type]
1644
control_files = lockable_files.LockableFiles(branch_transport,
1645
lock_name, lock_class)
1646
control_files.create_lock()
1648
control_files.lock_write()
1649
except errors.LockContention:
1650
if lock_type != 'branch4':
1656
utf8_files += [('format', self.get_format_string())]
1658
for (filename, content) in utf8_files:
1659
branch_transport.put_bytes(
1661
mode=a_bzrdir._get_file_mode())
1664
control_files.unlock()
1665
branch = self.open(a_bzrdir, name, _found=True)
1666
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1669
def initialize(self, a_bzrdir, name=None):
1670
"""Create a branch of this format in a_bzrdir.
1637
def initialize(self, controldir, name=None, repository=None,
1638
append_revisions_only=None):
1639
"""Create a branch of this format in controldir.
1672
1641
:param name: Name of the colocated branch to create.
1674
1643
raise NotImplementedError(self.initialize)
1799
1757
These are all empty initially, because by default nothing should get
1802
Hooks.__init__(self)
1803
self.create_hook(HookPoint('set_rh',
1804
"Invoked whenever the revision history has been set via "
1805
"set_revision_history. The api signature is (branch, "
1806
"revision_history), and the branch will be write-locked. "
1807
"The set_rh hook can be expensive for bzr to trigger, a better "
1808
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1809
self.create_hook(HookPoint('open',
1760
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1761
self.add_hook('open',
1810
1762
"Called with the Branch object that has been opened after a "
1811
"branch is opened.", (1, 8), None))
1812
self.create_hook(HookPoint('post_push',
1763
"branch is opened.", (1, 8))
1764
self.add_hook('post_push',
1813
1765
"Called after a push operation completes. post_push is called "
1814
1766
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1815
"bzr client.", (0, 15), None))
1816
self.create_hook(HookPoint('post_pull',
1767
"bzr client.", (0, 15))
1768
self.add_hook('post_pull',
1817
1769
"Called after a pull operation completes. post_pull is called "
1818
1770
"with a bzrlib.branch.PullResult object and only runs in the "
1819
"bzr client.", (0, 15), None))
1820
self.create_hook(HookPoint('pre_commit',
1821
"Called after a commit is calculated but before it is is "
1771
"bzr client.", (0, 15))
1772
self.add_hook('pre_commit',
1773
"Called after a commit is calculated but before it is "
1822
1774
"completed. pre_commit is called with (local, master, old_revno, "
1823
1775
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1824
1776
"). old_revid is NULL_REVISION for the first commit to a branch, "
1826
1778
"basis revision. hooks MUST NOT modify this delta. "
1827
1779
" future_tree is an in-memory tree obtained from "
1828
1780
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1829
"tree.", (0,91), None))
1830
self.create_hook(HookPoint('post_commit',
1782
self.add_hook('post_commit',
1831
1783
"Called in the bzr client after a commit has completed. "
1832
1784
"post_commit is called with (local, master, old_revno, old_revid, "
1833
1785
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1834
"commit to a branch.", (0, 15), None))
1835
self.create_hook(HookPoint('post_uncommit',
1786
"commit to a branch.", (0, 15))
1787
self.add_hook('post_uncommit',
1836
1788
"Called in the bzr client after an uncommit completes. "
1837
1789
"post_uncommit is called with (local, master, old_revno, "
1838
1790
"old_revid, new_revno, new_revid) where local is the local branch "
1839
1791
"or None, master is the target branch, and an empty branch "
1840
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1841
self.create_hook(HookPoint('pre_change_branch_tip',
1792
"receives new_revno of 0, new_revid of None.", (0, 15))
1793
self.add_hook('pre_change_branch_tip',
1842
1794
"Called in bzr client and server before a change to the tip of a "
1843
1795
"branch is made. pre_change_branch_tip is called with a "
1844
1796
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1845
"commit, uncommit will all trigger this hook.", (1, 6), None))
1846
self.create_hook(HookPoint('post_change_branch_tip',
1797
"commit, uncommit will all trigger this hook.", (1, 6))
1798
self.add_hook('post_change_branch_tip',
1847
1799
"Called in bzr client and server after a change to the tip of a "
1848
1800
"branch is made. post_change_branch_tip is called with a "
1849
1801
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1850
"commit, uncommit will all trigger this hook.", (1, 4), None))
1851
self.create_hook(HookPoint('transform_fallback_location',
1802
"commit, uncommit will all trigger this hook.", (1, 4))
1803
self.add_hook('transform_fallback_location',
1852
1804
"Called when a stacked branch is activating its fallback "
1853
1805
"locations. transform_fallback_location is called with (branch, "
1854
1806
"url), and should return a new url. Returning the same url "
1859
1811
"fallback locations have not been activated. When there are "
1860
1812
"multiple hooks installed for transform_fallback_location, "
1861
1813
"all are called with the url returned from the previous hook."
1862
"The order is however undefined.", (1, 9), None))
1863
self.create_hook(HookPoint('automatic_tag_name',
1864
"Called to determine an automatic tag name for a revision."
1814
"The order is however undefined.", (1, 9))
1815
self.add_hook('automatic_tag_name',
1816
"Called to determine an automatic tag name for a revision. "
1865
1817
"automatic_tag_name is called with (branch, revision_id) and "
1866
1818
"should return a tag name or None if no tag name could be "
1867
1819
"determined. The first non-None tag name returned will be used.",
1869
self.create_hook(HookPoint('post_branch_init',
1821
self.add_hook('post_branch_init',
1870
1822
"Called after new branch initialization completes. "
1871
1823
"post_branch_init is called with a "
1872
1824
"bzrlib.branch.BranchInitHookParams. "
1873
1825
"Note that init, branch and checkout (both heavyweight and "
1874
"lightweight) will all trigger this hook.", (2, 2), None))
1875
self.create_hook(HookPoint('post_switch',
1826
"lightweight) will all trigger this hook.", (2, 2))
1827
self.add_hook('post_switch',
1876
1828
"Called after a checkout switches branch. "
1877
1829
"post_switch is called with a "
1878
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1830
"bzrlib.branch.SwitchHookParams.", (2, 2))
1999
1946
self.revision_id)
2002
class BzrBranchFormat4(BranchFormat):
2003
"""Bzr branch format 4.
2006
- a revision-history file.
2007
- a branch-lock lock file [ to be shared with the bzrdir ]
1949
class BranchFormatMetadir(bzrdir.BzrFormat, BranchFormat):
1950
"""Base class for branch formats that live in meta directories.
2010
def get_format_description(self):
2011
"""See BranchFormat.get_format_description()."""
2012
return "Branch format 4"
2014
def initialize(self, a_bzrdir, name=None):
2015
"""Create a branch of this format in a_bzrdir."""
2016
utf8_files = [('revision-history', ''),
2017
('branch-name', ''),
2019
return self._initialize_helper(a_bzrdir, utf8_files, name=name,
2020
lock_type='branch4', set_format=False)
2022
1953
def __init__(self):
2023
super(BzrBranchFormat4, self).__init__()
2024
self._matchingbzrdir = bzrdir.BzrDirFormat6()
2026
def network_name(self):
2027
"""The network name for this format is the control dirs disk label."""
2028
return self._matchingbzrdir.get_format_string()
2030
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2031
"""See BranchFormat.open()."""
2033
# we are being called directly and must probe.
2034
raise NotImplementedError
2035
return BzrBranch(_format=self,
2036
_control_files=a_bzrdir._control_files,
2039
_repository=a_bzrdir.open_repository())
2042
return "Bazaar-NG branch format 4"
2045
class BranchFormatMetadir(BranchFormat):
2046
"""Common logic for meta-dir based branch formats."""
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)
2048
1970
def _branch_class(self):
2049
1971
"""What class to instantiate on open calls."""
2050
1972
raise NotImplementedError(self._branch_class)
2052
def network_name(self):
2053
"""A simple byte string uniquely identifying this format for RPC calls.
2055
Metadir branch formats use their format string.
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
2057
return self.get_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)
2059
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
2013
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2014
found_repository=None, possible_transports=None):
2060
2015
"""See BranchFormat.open()."""
2017
name = a_bzrdir._get_selected_branch()
2062
format = BranchFormat.find_format(a_bzrdir, name=name)
2019
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2063
2020
if format.__class__ != self.__class__:
2064
2021
raise AssertionError("wrong format %r found for %r" %
2065
2022
(format, self))
2068
2025
control_files = lockable_files.LockableFiles(transport, 'lock',
2069
2026
lockdir.LockDir)
2027
if found_repository is None:
2028
found_repository = a_bzrdir.find_repository()
2070
2029
return self._branch_class()(_format=self,
2071
2030
_control_files=control_files,
2073
2032
a_bzrdir=a_bzrdir,
2074
_repository=a_bzrdir.find_repository(),
2075
ignore_fallbacks=ignore_fallbacks)
2033
_repository=found_repository,
2034
ignore_fallbacks=ignore_fallbacks,
2035
possible_transports=possible_transports)
2076
2036
except errors.NoSuchFile:
2077
2037
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2080
super(BranchFormatMetadir, self).__init__()
2081
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2082
self._matchingbzrdir.set_branch_format(self)
2084
def supports_tags(self):
2088
class BzrBranchFormat5(BranchFormatMetadir):
2089
"""Bzr branch format 5.
2092
- a revision-history file.
2094
- a lock dir guarding the branch itself
2095
- all of this stored in a branch/ subdirectory
2096
- works with shared repositories.
2098
This format is new in bzr 0.8.
2101
def _branch_class(self):
2104
def get_format_string(self):
2105
"""See BranchFormat.get_format_string()."""
2106
return "Bazaar-NG branch format 5\n"
2108
def get_format_description(self):
2109
"""See BranchFormat.get_format_description()."""
2110
return "Branch format 5"
2112
def initialize(self, a_bzrdir, name=None):
2113
"""Create a branch of this format in a_bzrdir."""
2114
utf8_files = [('revision-history', ''),
2115
('branch-name', ''),
2117
return self._initialize_helper(a_bzrdir, utf8_files, name)
2119
def supports_tags(self):
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)
2123
2060
class BzrBranchFormat6(BranchFormatMetadir):
2172
2113
"""See BranchFormat.get_format_description()."""
2173
2114
return "Branch format 8"
2175
def initialize(self, a_bzrdir, name=None):
2116
def initialize(self, a_bzrdir, name=None, repository=None,
2117
append_revisions_only=None):
2176
2118
"""Create a branch of this format in a_bzrdir."""
2177
2119
utf8_files = [('last-revision', '0 null:\n'),
2178
('branch.conf', ''),
2121
self._get_initial_config(append_revisions_only)),
2180
2123
('references', '')
2182
return self._initialize_helper(a_bzrdir, utf8_files, name)
2185
super(BzrBranchFormat8, self).__init__()
2186
self._matchingbzrdir.repository_format = \
2187
RepositoryFormatKnitPack5RichRoot()
2125
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2189
2127
def make_tags(self, branch):
2190
2128
"""See bzrlib.branch.BranchFormat.make_tags()."""
2191
return BasicTags(branch)
2129
return _mod_tag.BasicTags(branch)
2193
2131
def supports_set_append_revisions_only(self):
2262
2211
transport = a_bzrdir.get_branch_transport(None, name=name)
2263
2212
location = transport.put_bytes('location', to_branch.base)
2265
def initialize(self, a_bzrdir, name=None, target_branch=None):
2214
def initialize(self, a_bzrdir, name=None, target_branch=None,
2215
repository=None, append_revisions_only=None):
2266
2216
"""Create a branch of this format in a_bzrdir."""
2267
2217
if target_branch is None:
2268
2218
# this format does not implement branch itself, thus the implicit
2269
2219
# creation contract must see it as uninitializable
2270
2220
raise errors.UninitializableFormat(self)
2271
2221
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()
2272
2226
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2273
2227
branch_transport.put_bytes('location',
2274
target_branch.bzrdir.user_url)
2275
branch_transport.put_bytes('format', self.get_format_string())
2277
a_bzrdir, name, _found=True,
2228
target_branch.user_url)
2229
branch_transport.put_bytes('format', self.as_string())
2230
branch = self.open(a_bzrdir, name, _found=True,
2278
2231
possible_transports=[target_branch.bzrdir.root_transport])
2279
2232
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2283
super(BranchReferenceFormat, self).__init__()
2284
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2285
self._matchingbzrdir.set_branch_format(self)
2287
2235
def _make_reference_clone_function(format, a_branch):
2288
2236
"""Create a clone() routine for a branch dynamically."""
2289
2237
def clone(to_bzrdir, revision_id=None,
2311
2260
:param possible_transports: An optional reusable transports list.
2263
name = a_bzrdir._get_selected_branch()
2314
format = BranchFormat.find_format(a_bzrdir, name=name)
2265
format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2315
2266
if format.__class__ != self.__class__:
2316
2267
raise AssertionError("wrong format %r found for %r" %
2317
2268
(format, self))
2318
2269
if location is None:
2319
2270
location = self.get_reference(a_bzrdir, name)
2320
real_bzrdir = bzrdir.BzrDir.open(
2271
real_bzrdir = controldir.ControlDir.open(
2321
2272
location, possible_transports=possible_transports)
2322
result = real_bzrdir.open_branch(name=name,
2323
ignore_fallbacks=ignore_fallbacks)
2273
result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks,
2274
possible_transports=possible_transports)
2324
2275
# this changes the behaviour of result.clone to create a new reference
2325
2276
# rather than a copy of the content of the branch.
2326
2277
# I did not use a proxy object because that needs much more extensive
2341
2306
BranchFormat.network_name() for more detail.
2309
format_registry = BranchFormatRegistry(network_format_registry)
2345
2312
# formats which have no format string are not discoverable
2346
2313
# and not independently creatable, so are not registered.
2347
__format5 = BzrBranchFormat5()
2348
2314
__format6 = BzrBranchFormat6()
2349
2315
__format7 = BzrBranchFormat7()
2350
2316
__format8 = BzrBranchFormat8()
2351
BranchFormat.register_format(__format5)
2352
BranchFormat.register_format(BranchReferenceFormat())
2353
BranchFormat.register_format(__format6)
2354
BranchFormat.register_format(__format7)
2355
BranchFormat.register_format(__format8)
2356
BranchFormat.set_default_format(__format7)
2357
_legacy_formats = [BzrBranchFormat4(),
2359
network_format_registry.register(
2360
_legacy_formats[0].network_name(), _legacy_formats[0].__class__)
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)
2363
2326
class BranchWriteLockResult(LogicalLockResult):
2396
2359
def __init__(self, _format=None,
2397
2360
_control_files=None, a_bzrdir=None, name=None,
2398
_repository=None, ignore_fallbacks=False):
2361
_repository=None, ignore_fallbacks=False,
2362
possible_transports=None):
2399
2363
"""Create new branch object at a particular location."""
2400
2364
if a_bzrdir is None:
2401
2365
raise ValueError('a_bzrdir must be supplied')
2403
self.bzrdir = a_bzrdir
2404
self._base = self.bzrdir.transport.clone('..').base
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
2405
2374
self.name = name
2406
# XXX: We should be able to just do
2407
# self.base = self.bzrdir.root_transport.base
2408
# but this does not quite work yet -- mbp 20080522
2409
2375
self._format = _format
2410
2376
if _control_files is None:
2411
2377
raise ValueError('BzrBranch _control_files is None')
2412
2378
self.control_files = _control_files
2413
2379
self._transport = _control_files._transport
2414
2380
self.repository = _repository
2415
Branch.__init__(self)
2381
self.conf_store = None
2382
Branch.__init__(self, possible_transports)
2417
2384
def __str__(self):
2418
if self.name is None:
2419
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2421
return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2385
return '%s(%s)' % (self.__class__.__name__, self.user_url)
2424
2387
__repr__ = __str__
2430
2393
base = property(_get_base, doc="The URL for the root of this branch.")
2396
def user_transport(self):
2397
return self._user_transport
2432
2399
def _get_config(self):
2433
return TransportConfig(self._transport, 'branch.conf')
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)
2435
2446
def is_locked(self):
2436
2447
return self.control_files.is_locked()
2511
2514
"""See Branch.print_file."""
2512
2515
return self.repository.print_file(file, revision_id)
2514
def _write_revision_history(self, history):
2515
"""Factored out of set_revision_history.
2517
This performs the actual writing to disk.
2518
It is intended to be called by BzrBranch5.set_revision_history."""
2519
self._transport.put_bytes(
2520
'revision-history', '\n'.join(history),
2521
mode=self.bzrdir._get_file_mode())
2524
def set_revision_history(self, rev_history):
2525
"""See Branch.set_revision_history."""
2526
if 'evil' in debug.debug_flags:
2527
mutter_callsite(3, "set_revision_history scales with history.")
2528
check_not_reserved_id = _mod_revision.check_not_reserved_id
2529
for rev_id in rev_history:
2530
check_not_reserved_id(rev_id)
2531
if Branch.hooks['post_change_branch_tip']:
2532
# Don't calculate the last_revision_info() if there are no hooks
2534
old_revno, old_revid = self.last_revision_info()
2535
if len(rev_history) == 0:
2536
revid = _mod_revision.NULL_REVISION
2538
revid = rev_history[-1]
2539
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2540
self._write_revision_history(rev_history)
2541
self._clear_cached_state()
2542
self._cache_revision_history(rev_history)
2543
for hook in Branch.hooks['set_rh']:
2544
hook(self, rev_history)
2545
if Branch.hooks['post_change_branch_tip']:
2546
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2548
def _synchronize_history(self, destination, revision_id):
2549
"""Synchronize last revision and revision history between branches.
2551
This version is most efficient when the destination is also a
2552
BzrBranch5, but works for BzrBranch6 as long as the revision
2553
history is the true lefthand parent history, and all of the revisions
2554
are in the destination's repository. If not, set_revision_history
2557
:param destination: The branch to copy the history into
2558
:param revision_id: The revision-id to truncate history at. May
2559
be None to copy complete history.
2561
if not isinstance(destination._format, BzrBranchFormat5):
2562
super(BzrBranch, self)._synchronize_history(
2563
destination, revision_id)
2565
if revision_id == _mod_revision.NULL_REVISION:
2568
new_history = self.revision_history()
2569
if revision_id is not None and new_history != []:
2571
new_history = new_history[:new_history.index(revision_id) + 1]
2573
rev = self.repository.get_revision(revision_id)
2574
new_history = rev.get_history(self.repository)[1:]
2575
destination.set_revision_history(new_history)
2577
2517
@needs_write_lock
2578
2518
def set_last_revision_info(self, revno, revision_id):
2579
"""Set the last revision of this branch.
2581
The caller is responsible for checking that the revno is correct
2582
for this revision id.
2584
It may be possible to set the branch last revision to an id not
2585
present in the repository. However, branches can also be
2586
configured to check constraints on history, in which case this may not
2519
if not revision_id or not isinstance(revision_id, basestring):
2520
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2589
2521
revision_id = _mod_revision.ensure_null(revision_id)
2590
# this old format stores the full history, but this api doesn't
2591
# provide it, so we must generate, and might as well check it's
2593
history = self._lefthand_history(revision_id)
2594
if len(history) != revno:
2595
raise AssertionError('%d != %d' % (len(history), revno))
2596
self.set_revision_history(history)
2598
def _gen_revision_history(self):
2599
history = self._transport.get_bytes('revision-history').split('\n')
2600
if history[-1:] == ['']:
2601
# There shouldn't be a trailing newline, but just in case.
2606
def generate_revision_history(self, revision_id, last_rev=None,
2608
"""Create a new revision history that will finish with revision_id.
2610
:param revision_id: the new tip to use.
2611
:param last_rev: The previous last_revision. If not None, then this
2612
must be a ancestory of revision_id, or DivergedBranches is raised.
2613
:param other_branch: The other branch that DivergedBranches should
2614
raise with respect to.
2616
self.set_revision_history(self._lefthand_history(revision_id,
2617
last_rev, other_branch))
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)
2619
2531
def basis_tree(self):
2620
2532
"""See Branch.basis_tree."""
2632
def _basic_push(self, target, overwrite, stop_revision):
2633
"""Basic implementation of push without bound branches or hooks.
2635
Must be called with source read locked and target write locked.
2637
result = BranchPushResult()
2638
result.source_branch = self
2639
result.target_branch = target
2640
result.old_revno, result.old_revid = target.last_revision_info()
2641
self.update_references(target)
2642
if result.old_revid != self.last_revision():
2643
# We assume that during 'push' this repository is closer than
2645
graph = self.repository.get_graph(target.repository)
2646
target.update_revisions(self, stop_revision,
2647
overwrite=overwrite, graph=graph)
2648
if self._push_should_merge_tags():
2649
result.tag_conflicts = self.tags.merge_to(target.tags,
2651
result.new_revno, result.new_revid = target.last_revision_info()
2654
2544
def get_stacked_on_url(self):
2655
2545
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2667
2557
self._transport.put_bytes('parent', url + '\n',
2668
2558
mode=self.bzrdir._get_file_mode())
2671
class BzrBranch5(BzrBranch):
2672
"""A format 5 branch. This supports new features over plain branches.
2674
It has support for a master_branch which is the data for bound branches.
2677
def get_bound_location(self):
2679
return self._transport.get_bytes('bound')[:-1]
2680
except errors.NoSuchFile:
2684
def get_master_branch(self, possible_transports=None):
2685
"""Return the branch we are bound to.
2687
:return: Either a Branch, or None
2689
This could memoise the branch, but if thats done
2690
it must be revalidated on each new lock.
2691
So for now we just don't memoise it.
2692
# RBC 20060304 review this decision.
2694
bound_loc = self.get_bound_location()
2698
return Branch.open(bound_loc,
2699
possible_transports=possible_transports)
2700
except (errors.NotBranchError, errors.ConnectionError), e:
2701
raise errors.BoundBranchConnectionFailure(
2704
2560
@needs_write_lock
2705
def set_bound_location(self, location):
2706
"""Set the target where this branch is bound to.
2708
:param location: URL to the target branch
2711
self._transport.put_bytes('bound', location+'\n',
2712
mode=self.bzrdir._get_file_mode())
2715
self._transport.delete('bound')
2716
except errors.NoSuchFile:
2562
"""If bound, unbind"""
2563
return self.set_bound_location(None)
2720
2565
@needs_write_lock
2721
2566
def bind(self, other):
2743
2588
# history around
2744
2589
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(
2746
2619
@needs_write_lock
2748
"""If bound, unbind"""
2749
return self.set_bound_location(None)
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:
2751
2636
@needs_write_lock
2752
2637
def update(self, possible_transports=None):
2769
class BzrBranch8(BzrBranch5):
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):
2770
2684
"""A branch that stores tree-reference locations."""
2772
def _open_hook(self):
2686
def _open_hook(self, possible_transports=None):
2773
2687
if self._ignore_fallbacks:
2689
if possible_transports is None:
2690
possible_transports = [self.bzrdir.root_transport]
2776
2692
url = self.get_stacked_on_url()
2777
2693
except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2798
2715
self._last_revision_info_cache = None
2799
2716
self._reference_info = None
2801
def _last_revision_info(self):
2802
revision_string = self._transport.get_bytes('last-revision')
2803
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2804
revision_id = cache_utf8.get_cached_utf8(revision_id)
2806
return revno, revision_id
2808
def _write_last_revision_info(self, revno, revision_id):
2809
"""Simply write out the revision id, with no checks.
2811
Use set_last_revision_info to perform this safely.
2813
Does not update the revision_history cache.
2814
Intended to be called by set_last_revision_info and
2815
_write_revision_history.
2817
revision_id = _mod_revision.ensure_null(revision_id)
2818
out_string = '%d %s\n' % (revno, revision_id)
2819
self._transport.put_bytes('last-revision', out_string,
2820
mode=self.bzrdir._get_file_mode())
2823
def set_last_revision_info(self, revno, revision_id):
2824
revision_id = _mod_revision.ensure_null(revision_id)
2825
old_revno, old_revid = self.last_revision_info()
2826
if self._get_append_revisions_only():
2827
self._check_history_violation(revision_id)
2828
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2829
self._write_last_revision_info(revno, revision_id)
2830
self._clear_cached_state()
2831
self._last_revision_info_cache = revno, revision_id
2832
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2834
def _synchronize_history(self, destination, revision_id):
2835
"""Synchronize last revision and revision history between branches.
2837
:see: Branch._synchronize_history
2839
# XXX: The base Branch has a fast implementation of this method based
2840
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2841
# that uses set_revision_history. This class inherits from BzrBranch5,
2842
# but wants the fast implementation, so it calls
2843
# Branch._synchronize_history directly.
2844
Branch._synchronize_history(self, destination, revision_id)
2846
2718
def _check_history_violation(self, revision_id):
2847
last_revision = _mod_revision.ensure_null(self.last_revision())
2719
current_revid = self.last_revision()
2720
last_revision = _mod_revision.ensure_null(current_revid)
2848
2721
if _mod_revision.is_null(last_revision):
2850
if last_revision not in self._lefthand_history(revision_id):
2851
raise errors.AppendRevisionsOnlyViolation(self.user_url)
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)
2853
2729
def _gen_revision_history(self):
2854
2730
"""Generate the revision history from last revision
2965
2825
def set_bound_location(self, location):
2966
2826
"""See Branch.set_push_location."""
2827
self._master_branch_cache = None
2968
config = self.get_config()
2829
conf = self.get_config_stack()
2969
2830
if location is None:
2970
if config.get_user_option('bound') != 'True':
2831
if not conf.get('bound'):
2973
config.set_user_option('bound', 'False', warn_masked=True)
2834
conf.set('bound', 'False')
2976
2837
self._set_config_location('bound_location', location,
2978
config.set_user_option('bound', 'True', warn_masked=True)
2839
conf.set('bound', 'True')
2981
2842
def _get_bound_location(self, bound):
2982
2843
"""Return the bound location in the config file.
2984
2845
Return None if the bound parameter does not match"""
2985
config = self.get_config()
2986
config_bound = (config.get_user_option('bound') == 'True')
2987
if config_bound != bound:
2846
conf = self.get_config_stack()
2847
if conf.get('bound') != bound:
2989
return self._get_config_location('bound_location', config=config)
2849
return self._get_config_location('bound_location', config=conf)
2991
2851
def get_bound_location(self):
2992
"""See Branch.set_push_location."""
2852
"""See Branch.get_bound_location."""
2993
2853
return self._get_bound_location(True)
2995
2855
def get_old_bound_location(self):
3000
2860
# you can always ask for the URL; but you might not be able to use it
3001
2861
# if the repo can't support stacking.
3002
2862
## self._check_stackable_repo()
3003
stacked_url = self._get_config_location('stacked_on_location')
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',
3004
2868
if stacked_url is None:
3005
2869
raise errors.NotStacked(self)
3008
def _get_append_revisions_only(self):
3009
return self.get_config(
3010
).get_user_option_as_bool('append_revisions_only')
3013
def generate_revision_history(self, revision_id, last_rev=None,
3015
"""See BzrBranch5.generate_revision_history"""
3016
history = self._lefthand_history(revision_id, last_rev, other_branch)
3017
revno = len(history)
3018
self.set_last_revision_info(revno, revision_id)
2870
return stacked_url.encode('utf-8')
3020
2872
@needs_read_lock
3021
2873
def get_rev_id(self, revno, history=None):
3105
2962
:ivar local_branch: target branch if there is a Master, else None
3106
2963
:ivar target_branch: Target/destination branch object. (write locked)
3107
2964
: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
3111
# DEPRECATED: pull used to return the change in revno
3112
return self.new_revno - self.old_revno
3114
2968
def report(self, to_file):
2969
tag_conflicts = getattr(self, "tag_conflicts", None)
2970
tag_updates = getattr(self, "tag_updates", None)
3115
2971
if not is_quiet():
3116
if self.old_revid == self.new_revid:
3117
to_file.write('No revisions to pull.\n')
2972
if self.old_revid != self.new_revid:
3119
2973
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')
3120
2981
self._show_tag_conficts(to_file)
3139
3000
target, otherwise it will be None.
3143
# DEPRECATED: push used to return the change in revno
3144
return self.new_revno - self.old_revno
3146
3003
def report(self, to_file):
3147
"""Write a human-readable description of the result."""
3148
if self.old_revid == self.new_revid:
3149
note('No new revisions to push.')
3151
note('Pushed up to revision %d.' % self.new_revno)
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.'))
3152
3020
self._show_tag_conficts(to_file)
3185
3053
# Copy source data into target
3186
3054
new_branch._write_last_revision_info(*branch.last_revision_info())
3187
new_branch.set_parent(branch.get_parent())
3188
new_branch.set_bound_location(branch.get_bound_location())
3189
new_branch.set_push_location(branch.get_push_location())
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
3063
# New branch has no tags by default
3192
3064
new_branch.tags._set_tag_dict({})
3194
3066
# Copying done; now update target format
3195
3067
new_branch._transport.put_bytes('format',
3196
format.get_format_string(),
3197
3069
mode=new_branch.bzrdir._get_file_mode())
3199
3071
# Clean up old files
3200
3072
new_branch._transport.delete('revision-history')
3202
branch.set_parent(None)
3203
except errors.NoSuchFile:
3205
branch.set_bound_location(None)
3076
branch.set_parent(None)
3077
except errors.NoSuchFile:
3079
branch.set_bound_location(None)
3208
3084
class Converter6to7(object):
3212
3088
format = BzrBranchFormat7()
3213
3089
branch._set_config_location('stacked_on_location', '')
3214
3090
# update target format
3215
branch._transport.put_bytes('format', format.get_format_string())
3091
branch._transport.put_bytes('format', format.as_string())
3218
3094
class Converter7to8(object):
3219
"""Perform an in-place upgrade of format 6 to format 7"""
3095
"""Perform an in-place upgrade of format 7 to format 8"""
3221
3097
def convert(self, branch):
3222
3098
format = BzrBranchFormat8()
3223
3099
branch._transport.put_bytes('references', '')
3224
3100
# update target format
3225
branch._transport.put_bytes('format', format.get_format_string())
3228
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3229
"""Run ``callable(*args, **kwargs)``, write-locking target for the
3232
_run_with_write_locked_target will attempt to release the lock it acquires.
3234
If an exception is raised by callable, then that exception *will* be
3235
propagated, even if the unlock attempt raises its own error. Thus
3236
_run_with_write_locked_target should be preferred to simply doing::
3240
return callable(*args, **kwargs)
3245
# This is very similar to bzrlib.decorators.needs_write_lock. Perhaps they
3246
# should share code?
3249
result = callable(*args, **kwargs)
3251
exc_info = sys.exc_info()
3255
raise exc_info[0], exc_info[1], exc_info[2]
3101
branch._transport.put_bytes('format', format.as_string())
3261
3104
class InterBranch(InterObject):
3353
3209
self.source.tags.merge_to(self.target.tags)
3355
3211
@needs_write_lock
3356
def update_revisions(self, stop_revision=None, overwrite=False,
3358
"""See InterBranch.update_revisions()."""
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,
3359
3233
other_revno, other_last_revision = self.source.last_revision_info()
3360
3234
stop_revno = None # unknown
3361
3235
if stop_revision is None:
3418
3302
return self._pull(overwrite,
3419
3303
stop_revision, _hook_master=master_branch,
3420
3304
run_hooks=run_hooks,
3421
_override_hook_target=_override_hook_target)
3305
_override_hook_target=_override_hook_target,
3306
merge_tags_to_master=not source_is_master)
3423
3308
if master_branch:
3424
3309
master_branch.unlock()
3426
def push(self, overwrite=False, stop_revision=None,
3311
def push(self, overwrite=False, stop_revision=None, lossy=False,
3427
3312
_override_hook_source_branch=None):
3428
3313
"""See InterBranch.push.
3430
3315
This is the basic concrete implementation of push()
3432
:param _override_hook_source_branch: If specified, run
3433
the hooks passing this Branch as the source, rather than self.
3434
This is for use of RemoteBranch, where push is delegated to the
3435
underlying vfs-based Branch.
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
3323
raise errors.LossyPushToSameVCS(self.source, self.target)
3437
3324
# TODO: Public option to disable running hooks - should be trivial but
3439
self.source.lock_read()
3441
return _run_with_write_locked_target(
3442
self.target, self._push_with_bound_branches, overwrite,
3444
_override_hook_source_branch=_override_hook_source_branch)
3446
self.source.unlock()
3448
def _push_with_bound_branches(self, overwrite, stop_revision,
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,
3449
3359
_override_hook_source_branch=None):
3450
3360
"""Push from source into target, and into target's master if any.
3463
3373
# be bound to itself? -- mbp 20070507
3464
3374
master_branch = self.target.get_master_branch()
3465
3375
master_branch.lock_write()
3467
# push into the master from the source branch.
3468
self.source._basic_push(master_branch, overwrite, stop_revision)
3469
# and push into the target branch from the source. Note that we
3470
# push from the source branch again, because its considered the
3471
# highest bandwidth repository.
3472
result = self.source._basic_push(self.target, overwrite,
3474
result.master_branch = master_branch
3475
result.local_branch = self.target
3479
master_branch.unlock()
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
3387
master_branch = None
3481
3388
# no master branch
3482
result = self.source._basic_push(self.target, overwrite,
3389
result = self._basic_push(overwrite, stop_revision)
3484
3390
# TODO: Why set master_branch and local_branch if there's no
3485
3391
# binding? Maybe cleaner to just leave them unset? -- mbp
3487
3393
result.master_branch = self.target
3488
3394
result.local_branch = None
3492
3398
def _pull(self, overwrite=False, stop_revision=None,
3493
3399
possible_transports=None, _hook_master=None, run_hooks=True,
3494
_override_hook_target=None, local=False):
3400
_override_hook_target=None, local=False,
3401
merge_tags_to_master=True):
3495
3402
"""See Branch.pull.
3497
3404
This function is the core worker, used by GenericInterBranch.pull to
3526
3435
# -- JRV20090506
3527
3436
result.old_revno, result.old_revid = \
3528
3437
self.target.last_revision_info()
3529
self.target.update_revisions(self.source, stop_revision,
3530
overwrite=overwrite, graph=graph)
3438
overwrite = _fix_overwrite_type(overwrite)
3439
self._update_revisions(stop_revision,
3440
overwrite=("history" in overwrite),
3531
3442
# TODO: The old revid should be specified when merging tags,
3532
3443
# so a tags implementation that versions tags can only
3533
3444
# pull in the most recent changes. -- JRV20090506
3534
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
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))
3536
3449
result.new_revno, result.new_revid = self.target.last_revision_info()
3537
3450
if _hook_master:
3538
3451
result.master_branch = _hook_master
added
removed
bzrlib/branch.py
