18
18
from cStringIO import StringIO
21
20
from bzrlib.lazy_import import lazy_import
22
21
lazy_import(globals(), """
23
from itertools import chain
24
23
from bzrlib import (
27
27
config as _mod_config,
35
36
revision as _mod_revision,
43
from bzrlib.config import BranchConfig, TransportConfig
44
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
45
from bzrlib.tag import (
43
from bzrlib.i18n import gettext, ngettext
51
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
52
from bzrlib.hooks import HookPoint, Hooks
49
from bzrlib.decorators import (
54
from bzrlib.hooks import Hooks
53
55
from bzrlib.inter import InterObject
54
56
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
55
57
from bzrlib import registry
492
504
rev_iter = iter(merge_sorted_revisions)
493
505
if start_revision_id is not None:
494
506
for node in rev_iter:
495
rev_id = node.key[-1]
496
508
if rev_id != start_revision_id:
499
511
# The decision to include the start or not
500
512
# depends on the stop_rule if a stop is provided
501
513
# so pop this node back into the iterator
502
rev_iter = chain(iter([node]), rev_iter)
514
rev_iter = itertools.chain(iter([node]), rev_iter)
504
516
if stop_revision_id is None:
505
517
# Yield everything
506
518
for node in rev_iter:
507
rev_id = node.key[-1]
508
520
yield (rev_id, node.merge_depth, node.revno,
509
521
node.end_of_merge)
510
522
elif stop_rule == 'exclude':
511
523
for node in rev_iter:
512
rev_id = node.key[-1]
513
525
if rev_id == stop_revision_id:
515
527
yield (rev_id, node.merge_depth, node.revno,
516
528
node.end_of_merge)
517
529
elif stop_rule == 'include':
518
530
for node in rev_iter:
519
rev_id = node.key[-1]
520
532
yield (rev_id, node.merge_depth, node.revno,
521
533
node.end_of_merge)
522
534
if rev_id == stop_revision_id:
649
669
raise errors.UnsupportedOperation(self.get_reference_info, self)
651
671
@needs_write_lock
652
def fetch(self, from_branch, last_revision=None, pb=None):
672
def fetch(self, from_branch, last_revision=None, limit=None):
653
673
"""Copy revisions from from_branch into this branch.
655
675
:param from_branch: Where to copy from.
656
676
:param last_revision: What revision to stop at (None for at the end
658
:param pb: An optional progress bar to use.
678
:param limit: Optional rough limit of revisions to fetch
661
if self.base == from_branch.base:
664
symbol_versioning.warn(
665
symbol_versioning.deprecated_in((1, 14, 0))
666
% "pb parameter to fetch()")
667
from_branch.lock_read()
669
if last_revision is None:
670
last_revision = from_branch.last_revision()
671
last_revision = _mod_revision.ensure_null(last_revision)
672
return self.repository.fetch(from_branch.repository,
673
revision_id=last_revision,
681
return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)
678
683
def get_bound_location(self):
679
684
"""Return the URL of the branch we are bound to.
739
747
"""Print `file` to stdout."""
740
748
raise NotImplementedError(self.print_file)
750
@deprecated_method(deprecated_in((2, 4, 0)))
742
751
def set_revision_history(self, rev_history):
743
raise NotImplementedError(self.set_revision_history)
752
"""See Branch.set_revision_history."""
753
self._set_revision_history(rev_history)
756
def _set_revision_history(self, rev_history):
757
if len(rev_history) == 0:
758
revid = _mod_revision.NULL_REVISION
760
revid = rev_history[-1]
761
if rev_history != self._lefthand_history(revid):
762
raise errors.NotLefthandHistory(rev_history)
763
self.set_last_revision_info(len(rev_history), revid)
764
self._cache_revision_history(rev_history)
765
for hook in Branch.hooks['set_rh']:
766
hook(self, rev_history)
769
def set_last_revision_info(self, revno, revision_id):
770
"""Set the last revision of this branch.
772
The caller is responsible for checking that the revno is correct
773
for this revision id.
775
It may be possible to set the branch last revision to an id not
776
present in the repository. However, branches can also be
777
configured to check constraints on history, in which case this may not
780
raise NotImplementedError(self.set_last_revision_info)
783
def generate_revision_history(self, revision_id, last_rev=None,
785
"""See Branch.generate_revision_history"""
786
graph = self.repository.get_graph()
787
(last_revno, last_revid) = self.last_revision_info()
788
known_revision_ids = [
789
(last_revid, last_revno),
790
(_mod_revision.NULL_REVISION, 0),
792
if last_rev is not None:
793
if not graph.is_ancestor(last_rev, revision_id):
794
# our previous tip is not merged into stop_revision
795
raise errors.DivergedBranches(self, other_branch)
796
revno = graph.find_distance_to_null(revision_id, known_revision_ids)
797
self.set_last_revision_info(revno, revision_id)
745
799
@needs_write_lock
746
800
def set_parent(self, url):
859
914
# XXX: If you unstack a branch while it has a working tree
860
915
# with a pending merge, the pending-merged revisions will no
861
916
# longer be present. You can (probably) revert and remerge.
863
# XXX: This only fetches up to the tip of the repository; it
864
# doesn't bring across any tags. That's fairly consistent
865
# with how branch works, but perhaps not ideal.
866
self.repository.fetch(old_repository,
867
revision_id=self.last_revision(),
918
tags_to_fetch = set(self.tags.get_reverse_tag_dict())
919
except errors.TagsNotSupported:
920
tags_to_fetch = set()
921
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
922
old_repository, required_ids=[self.last_revision()],
923
if_present_ids=tags_to_fetch, find_ghosts=True).execute()
924
self.repository.fetch(old_repository, fetch_spec=fetch_spec)
870
926
old_repository.unlock()
968
1031
:return: A tuple (revno, revision_id).
970
1033
if self._last_revision_info_cache is None:
971
self._last_revision_info_cache = self._last_revision_info()
1034
self._last_revision_info_cache = self._read_last_revision_info()
972
1035
return self._last_revision_info_cache
974
def _last_revision_info(self):
975
rh = self.revision_history()
978
return (revno, rh[-1])
980
return (0, _mod_revision.NULL_REVISION)
982
@deprecated_method(deprecated_in((1, 6, 0)))
983
def missing_revisions(self, other, stop_revision=None):
984
"""Return a list of new revisions that would perfectly fit.
986
If self and other have not diverged, return a list of the revisions
987
present in other, but missing from self.
989
self_history = self.revision_history()
990
self_len = len(self_history)
991
other_history = other.revision_history()
992
other_len = len(other_history)
993
common_index = min(self_len, other_len) -1
994
if common_index >= 0 and \
995
self_history[common_index] != other_history[common_index]:
996
raise errors.DivergedBranches(self, other)
998
if stop_revision is None:
999
stop_revision = other_len
1001
if stop_revision > other_len:
1002
raise errors.NoSuchRevision(self, stop_revision)
1003
return other_history[self_len:stop_revision]
1005
def update_revisions(self, other, stop_revision=None, overwrite=False,
1007
"""Pull in new perfect-fit revisions.
1009
:param other: Another Branch to pull from
1010
:param stop_revision: Updated until the given revision
1011
:param overwrite: Always set the branch pointer, rather than checking
1012
to see if it is a proper descendant.
1013
:param graph: A Graph object that can be used to query history
1014
information. This can be None.
1017
return InterBranch.get(other, self).update_revisions(stop_revision,
1037
def _read_last_revision_info(self):
1038
raise NotImplementedError(self._read_last_revision_info)
1040
@deprecated_method(deprecated_in((2, 4, 0)))
1020
1041
def import_last_revision_info(self, source_repo, revno, revid):
1021
1042
"""Set the last revision info, importing from another repo if necessary.
1023
This is used by the bound branch code to upload a revision to
1024
the master branch first before updating the tip of the local branch.
1026
1044
:param source_repo: Source repository to optionally fetch from
1027
1045
:param revno: Revision number of the new tip
1028
1046
:param revid: Revision id of the new tip
1031
1049
self.repository.fetch(source_repo, revision_id=revid)
1032
1050
self.set_last_revision_info(revno, revid)
1052
def import_last_revision_info_and_tags(self, source, revno, revid,
1054
"""Set the last revision info, importing from another repo if necessary.
1056
This is used by the bound branch code to upload a revision to
1057
the master branch first before updating the tip of the local branch.
1058
Revisions referenced by source's tags are also transferred.
1060
:param source: Source branch to optionally fetch from
1061
:param revno: Revision number of the new tip
1062
:param revid: Revision id of the new tip
1063
:param lossy: Whether to discard metadata that can not be
1064
natively represented
1065
:return: Tuple with the new revision number and revision id
1066
(should only be different from the arguments when lossy=True)
1068
if not self.repository.has_same_location(source.repository):
1069
self.fetch(source, revid)
1070
self.set_last_revision_info(revno, revid)
1071
return (revno, revid)
1034
1073
def revision_id_to_revno(self, revision_id):
1035
1074
"""Given a revision id, return its revno"""
1036
1075
if _mod_revision.is_null(revision_id):
1068
1107
stop_revision=stop_revision,
1069
1108
possible_transports=possible_transports, *args, **kwargs)
1071
def push(self, target, overwrite=False, stop_revision=None, *args,
1110
def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1073
1112
"""Mirror this branch into target.
1075
1114
This branch is considered to be 'local', having low latency.
1077
1116
return InterBranch.get(self, target).push(overwrite, stop_revision,
1080
def lossy_push(self, target, stop_revision=None):
1081
"""Push deltas into another branch.
1083
:note: This does not, like push, retain the revision ids from
1084
the source branch and will, rather than adding bzr-specific
1085
metadata, push only those semantics of the revision that can be
1086
natively represented by this branch' VCS.
1088
:param target: Target branch
1089
:param stop_revision: Revision to push, defaults to last revision.
1090
:return: BranchPushResult with an extra member revidmap:
1091
A dictionary mapping revision ids from the target branch
1092
to new revision ids in the target branch, for each
1093
revision that was pushed.
1095
inter = InterBranch.get(self, target)
1096
lossy_push = getattr(inter, "lossy_push", None)
1097
if lossy_push is None:
1098
raise errors.LossyPushToSameVCS(self, target)
1099
return lossy_push(stop_revision)
1117
lossy, *args, **kwargs)
1101
1119
def basis_tree(self):
1102
1120
"""Return `Tree` object for last revision."""
1358
1381
# specific check.
1361
def _get_checkout_format(self):
1384
def _get_checkout_format(self, lightweight=False):
1362
1385
"""Return the most suitable metadir for a checkout of this branch.
1363
1386
Weaves are used if this branch's repository uses weaves.
1365
if isinstance(self.bzrdir, bzrdir.BzrDirPreSplitOut):
1366
from bzrlib.repofmt import weaverepo
1367
format = bzrdir.BzrDirMetaFormat1()
1368
format.repository_format = weaverepo.RepositoryFormat7()
1370
format = self.repository.bzrdir.checkout_metadir()
1371
format.set_branch_format(self._format)
1388
format = self.repository.bzrdir.checkout_metadir()
1389
format.set_branch_format(self._format)
1374
1392
def create_clone_on_transport(self, to_transport, revision_id=None,
1375
stacked_on=None, create_prefix=False, use_existing_dir=False):
1393
stacked_on=None, create_prefix=False, use_existing_dir=False,
1376
1395
"""Create a clone of this branch and its bzrdir.
1378
1397
:param to_transport: The transport to clone onto.
1513
1533
raise AssertionError("invalid heads: %r" % (heads,))
1516
class BranchFormat(object):
1535
def heads_to_fetch(self):
1536
"""Return the heads that must and that should be fetched to copy this
1537
branch into another repo.
1539
:returns: a 2-tuple of (must_fetch, if_present_fetch). must_fetch is a
1540
set of heads that must be fetched. if_present_fetch is a set of
1541
heads that must be fetched if present, but no error is necessary if
1542
they are not present.
1544
# For bzr native formats must_fetch is just the tip, and if_present_fetch
1546
must_fetch = set([self.last_revision()])
1547
if_present_fetch = set()
1548
c = self.get_config()
1549
include_tags = c.get_user_option_as_bool('branch.fetch_tags',
1553
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1554
except errors.TagsNotSupported:
1556
must_fetch.discard(_mod_revision.NULL_REVISION)
1557
if_present_fetch.discard(_mod_revision.NULL_REVISION)
1558
return must_fetch, if_present_fetch
1561
class BranchFormat(controldir.ControlComponentFormat):
1517
1562
"""An encapsulation of the initialization and open routines for a format.
1519
1564
Formats provide three things:
1552
1589
transport = a_bzrdir.get_branch_transport(None, name=name)
1553
1590
format_string = transport.get_bytes("format")
1554
format = klass._formats[format_string]
1555
if isinstance(format, MetaDirBranchFormatFactory):
1591
return format_registry.get(format_string)
1558
1592
except errors.NoSuchFile:
1559
1593
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1560
1594
except KeyError:
1561
1595
raise errors.UnknownFormatError(format=format_string, kind='branch')
1598
@deprecated_method(deprecated_in((2, 4, 0)))
1564
1599
def get_default_format(klass):
1565
1600
"""Return the current default format."""
1566
return klass._default_format
1601
return format_registry.get_default()
1604
@deprecated_method(deprecated_in((2, 4, 0)))
1569
1605
def get_formats(klass):
1570
1606
"""Get all the known formats.
1572
1608
Warning: This triggers a load of all lazy registered formats: do not
1573
1609
use except when that is desireed.
1576
for fmt in klass._formats.values():
1577
if isinstance(fmt, MetaDirBranchFormatFactory):
1611
return format_registry._get_all()
1582
1613
def get_reference(self, a_bzrdir, name=None):
1583
1614
"""Get the target reference of the branch in a_bzrdir.
1622
1653
for hook in hooks:
1625
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1626
lock_type='metadir', set_format=True):
1627
"""Initialize a branch in a bzrdir, with specified files
1629
:param a_bzrdir: The bzrdir to initialize the branch in
1630
:param utf8_files: The files to create as a list of
1631
(filename, content) tuples
1632
:param name: Name of colocated branch to create, if any
1633
:param set_format: If True, set the format with
1634
self.get_format_string. (BzrBranch4 has its format set
1636
:return: a branch in this format
1638
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1639
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1641
'metadir': ('lock', lockdir.LockDir),
1642
'branch4': ('branch-lock', lockable_files.TransportLock),
1644
lock_name, lock_class = lock_map[lock_type]
1645
control_files = lockable_files.LockableFiles(branch_transport,
1646
lock_name, lock_class)
1647
control_files.create_lock()
1649
control_files.lock_write()
1650
except errors.LockContention:
1651
if lock_type != 'branch4':
1657
utf8_files += [('format', self.get_format_string())]
1659
for (filename, content) in utf8_files:
1660
branch_transport.put_bytes(
1662
mode=a_bzrdir._get_file_mode())
1665
control_files.unlock()
1666
branch = self.open(a_bzrdir, name, _found=True)
1667
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1670
def initialize(self, a_bzrdir, name=None):
1656
def initialize(self, a_bzrdir, name=None, repository=None,
1657
append_revisions_only=None):
1671
1658
"""Create a branch of this format in a_bzrdir.
1673
1660
:param name: Name of the colocated branch to create.
1720
1708
raise NotImplementedError(self.open)
1711
@deprecated_method(deprecated_in((2, 4, 0)))
1723
1712
def register_format(klass, format):
1724
1713
"""Register a metadir format.
1726
1715
See MetaDirBranchFormatFactory for the ability to register a format
1727
1716
without loading the code the format needs until it is actually used.
1729
klass._formats[format.get_format_string()] = format
1730
# Metadir formats have a network name of their format string, and get
1731
# registered as factories.
1732
if isinstance(format, MetaDirBranchFormatFactory):
1733
network_format_registry.register(format.get_format_string(), format)
1735
network_format_registry.register(format.get_format_string(),
1718
format_registry.register(format)
1721
@deprecated_method(deprecated_in((2, 4, 0)))
1739
1722
def set_default_format(klass, format):
1740
klass._default_format = format
1723
format_registry.set_default(format)
1742
1725
def supports_set_append_revisions_only(self):
1743
1726
"""True if this format supports set_append_revisions_only."""
1800
1796
These are all empty initially, because by default nothing should get
1803
Hooks.__init__(self)
1804
self.create_hook(HookPoint('set_rh',
1799
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1800
self.add_hook('set_rh',
1805
1801
"Invoked whenever the revision history has been set via "
1806
1802
"set_revision_history. The api signature is (branch, "
1807
1803
"revision_history), and the branch will be write-locked. "
1808
1804
"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',
1805
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1806
self.add_hook('open',
1811
1807
"Called with the Branch object that has been opened after a "
1812
"branch is opened.", (1, 8), None))
1813
self.create_hook(HookPoint('post_push',
1808
"branch is opened.", (1, 8))
1809
self.add_hook('post_push',
1814
1810
"Called after a push operation completes. post_push is called "
1815
1811
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1816
"bzr client.", (0, 15), None))
1817
self.create_hook(HookPoint('post_pull',
1812
"bzr client.", (0, 15))
1813
self.add_hook('post_pull',
1818
1814
"Called after a pull operation completes. post_pull is called "
1819
1815
"with a bzrlib.branch.PullResult object and only runs in the "
1820
"bzr client.", (0, 15), None))
1821
self.create_hook(HookPoint('pre_commit',
1816
"bzr client.", (0, 15))
1817
self.add_hook('pre_commit',
1822
1818
"Called after a commit is calculated but before it is "
1823
1819
"completed. pre_commit is called with (local, master, old_revno, "
1824
1820
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1827
1823
"basis revision. hooks MUST NOT modify this delta. "
1828
1824
" future_tree is an in-memory tree obtained from "
1829
1825
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1830
"tree.", (0,91), None))
1831
self.create_hook(HookPoint('post_commit',
1827
self.add_hook('post_commit',
1832
1828
"Called in the bzr client after a commit has completed. "
1833
1829
"post_commit is called with (local, master, old_revno, old_revid, "
1834
1830
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1835
"commit to a branch.", (0, 15), None))
1836
self.create_hook(HookPoint('post_uncommit',
1831
"commit to a branch.", (0, 15))
1832
self.add_hook('post_uncommit',
1837
1833
"Called in the bzr client after an uncommit completes. "
1838
1834
"post_uncommit is called with (local, master, old_revno, "
1839
1835
"old_revid, new_revno, new_revid) where local is the local branch "
1840
1836
"or None, master is the target branch, and an empty branch "
1841
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1842
self.create_hook(HookPoint('pre_change_branch_tip',
1837
"receives new_revno of 0, new_revid of None.", (0, 15))
1838
self.add_hook('pre_change_branch_tip',
1843
1839
"Called in bzr client and server before a change to the tip of a "
1844
1840
"branch is made. pre_change_branch_tip is called with a "
1845
1841
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1846
"commit, uncommit will all trigger this hook.", (1, 6), None))
1847
self.create_hook(HookPoint('post_change_branch_tip',
1842
"commit, uncommit will all trigger this hook.", (1, 6))
1843
self.add_hook('post_change_branch_tip',
1848
1844
"Called in bzr client and server after a change to the tip of a "
1849
1845
"branch is made. post_change_branch_tip is called with a "
1850
1846
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1851
"commit, uncommit will all trigger this hook.", (1, 4), None))
1852
self.create_hook(HookPoint('transform_fallback_location',
1847
"commit, uncommit will all trigger this hook.", (1, 4))
1848
self.add_hook('transform_fallback_location',
1853
1849
"Called when a stacked branch is activating its fallback "
1854
1850
"locations. transform_fallback_location is called with (branch, "
1855
1851
"url), and should return a new url. Returning the same url "
1860
1856
"fallback locations have not been activated. When there are "
1861
1857
"multiple hooks installed for transform_fallback_location, "
1862
1858
"all are called with the url returned from the previous hook."
1863
"The order is however undefined.", (1, 9), None))
1864
self.create_hook(HookPoint('automatic_tag_name',
1859
"The order is however undefined.", (1, 9))
1860
self.add_hook('automatic_tag_name',
1865
1861
"Called to determine an automatic tag name for a revision. "
1866
1862
"automatic_tag_name is called with (branch, revision_id) and "
1867
1863
"should return a tag name or None if no tag name could be "
1868
1864
"determined. The first non-None tag name returned will be used.",
1870
self.create_hook(HookPoint('post_branch_init',
1866
self.add_hook('post_branch_init',
1871
1867
"Called after new branch initialization completes. "
1872
1868
"post_branch_init is called with a "
1873
1869
"bzrlib.branch.BranchInitHookParams. "
1874
1870
"Note that init, branch and checkout (both heavyweight and "
1875
"lightweight) will all trigger this hook.", (2, 2), None))
1876
self.create_hook(HookPoint('post_switch',
1871
"lightweight) will all trigger this hook.", (2, 2))
1872
self.add_hook('post_switch',
1877
1873
"Called after a checkout switches branch. "
1878
1874
"post_switch is called with a "
1879
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
1875
"bzrlib.branch.SwitchHookParams.", (2, 2))
1995
1991
self.revision_id)
1998
class BzrBranchFormat4(BranchFormat):
1999
"""Bzr branch format 4.
2002
- a revision-history file.
2003
- a branch-lock lock file [ to be shared with the bzrdir ]
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)
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
1994
class BranchFormatMetadir(BranchFormat):
2042
1995
"""Common logic for meta-dir based branch formats."""
2045
1998
"""What class to instantiate on open calls."""
2046
1999
raise NotImplementedError(self._branch_class)
2001
def _get_initial_config(self, append_revisions_only=None):
2002
if append_revisions_only:
2003
return "append_revisions_only = True\n"
2005
# Avoid writing anything if append_revisions_only is disabled,
2006
# as that is the default.
2009
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
2011
"""Initialize a branch in a bzrdir, with specified files
2013
:param a_bzrdir: The bzrdir to initialize the branch in
2014
:param utf8_files: The files to create as a list of
2015
(filename, content) tuples
2016
:param name: Name of colocated branch to create, if any
2017
:return: a branch in this format
2019
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2020
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2021
control_files = lockable_files.LockableFiles(branch_transport,
2022
'lock', lockdir.LockDir)
2023
control_files.create_lock()
2024
control_files.lock_write()
2026
utf8_files += [('format', self.get_format_string())]
2027
for (filename, content) in utf8_files:
2028
branch_transport.put_bytes(
2030
mode=a_bzrdir._get_file_mode())
2032
control_files.unlock()
2033
branch = self.open(a_bzrdir, name, _found=True,
2034
found_repository=repository)
2035
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2048
2038
def network_name(self):
2049
2039
"""A simple byte string uniquely identifying this format for RPC calls.
2138
2137
"""See BranchFormat.get_format_description()."""
2139
2138
return "Branch format 6"
2141
def initialize(self, a_bzrdir, name=None):
2140
def initialize(self, a_bzrdir, name=None, repository=None,
2141
append_revisions_only=None):
2142
2142
"""Create a branch of this format in a_bzrdir."""
2143
2143
utf8_files = [('last-revision', '0 null:\n'),
2144
('branch.conf', ''),
2145
self._get_initial_config(append_revisions_only)),
2147
return self._initialize_helper(a_bzrdir, utf8_files, name)
2148
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2149
2150
def make_tags(self, branch):
2150
2151
"""See bzrlib.branch.BranchFormat.make_tags()."""
2151
return BasicTags(branch)
2152
return _mod_tag.BasicTags(branch)
2153
2154
def supports_set_append_revisions_only(self):
2168
2169
"""See BranchFormat.get_format_description()."""
2169
2170
return "Branch format 8"
2171
def initialize(self, a_bzrdir, name=None):
2172
def initialize(self, a_bzrdir, name=None, repository=None,
2173
append_revisions_only=None):
2172
2174
"""Create a branch of this format in a_bzrdir."""
2173
2175
utf8_files = [('last-revision', '0 null:\n'),
2174
('branch.conf', ''),
2177
self._get_initial_config(append_revisions_only)),
2176
2179
('references', '')
2178
return self._initialize_helper(a_bzrdir, utf8_files, name)
2181
super(BzrBranchFormat8, self).__init__()
2182
self._matchingbzrdir.repository_format = \
2183
RepositoryFormatKnitPack5RichRoot()
2181
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2185
2183
def make_tags(self, branch):
2186
2184
"""See bzrlib.branch.BranchFormat.make_tags()."""
2187
return BasicTags(branch)
2185
return _mod_tag.BasicTags(branch)
2189
2187
def supports_set_append_revisions_only(self):
2258
2265
transport = a_bzrdir.get_branch_transport(None, name=name)
2259
2266
location = transport.put_bytes('location', to_branch.base)
2261
def initialize(self, a_bzrdir, name=None, target_branch=None):
2268
def initialize(self, a_bzrdir, name=None, target_branch=None,
2269
repository=None, append_revisions_only=None):
2262
2270
"""Create a branch of this format in a_bzrdir."""
2263
2271
if target_branch is None:
2264
2272
# this format does not implement branch itself, thus the implicit
2265
2273
# creation contract must see it as uninitializable
2266
2274
raise errors.UninitializableFormat(self)
2267
2275
mutter('creating branch reference in %s', a_bzrdir.user_url)
2276
if a_bzrdir._format.fixed_components:
2277
raise errors.IncompatibleFormat(self, a_bzrdir._format)
2268
2278
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2269
2279
branch_transport.put_bytes('location',
2270
2280
target_branch.bzrdir.user_url)
2344
2371
__format6 = BzrBranchFormat6()
2345
2372
__format7 = BzrBranchFormat7()
2346
2373
__format8 = BzrBranchFormat8()
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__)
2374
format_registry.register(__format5)
2375
format_registry.register(BranchReferenceFormat())
2376
format_registry.register(__format6)
2377
format_registry.register(__format7)
2378
format_registry.register(__format8)
2379
format_registry.set_default(__format7)
2359
2382
class BranchWriteLockResult(LogicalLockResult):
2507
2530
"""See Branch.print_file."""
2508
2531
return self.repository.print_file(file, revision_id)
2510
def _write_revision_history(self, history):
2511
"""Factored out of set_revision_history.
2513
This performs the actual writing to disk.
2514
It is intended to be called by BzrBranch5.set_revision_history."""
2515
self._transport.put_bytes(
2516
'revision-history', '\n'.join(history),
2517
mode=self.bzrdir._get_file_mode())
2520
def set_revision_history(self, rev_history):
2521
"""See Branch.set_revision_history."""
2522
if 'evil' in debug.debug_flags:
2523
mutter_callsite(3, "set_revision_history scales with history.")
2524
check_not_reserved_id = _mod_revision.check_not_reserved_id
2525
for rev_id in rev_history:
2526
check_not_reserved_id(rev_id)
2527
if Branch.hooks['post_change_branch_tip']:
2528
# Don't calculate the last_revision_info() if there are no hooks
2530
old_revno, old_revid = self.last_revision_info()
2531
if len(rev_history) == 0:
2532
revid = _mod_revision.NULL_REVISION
2534
revid = rev_history[-1]
2535
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2536
self._write_revision_history(rev_history)
2537
self._clear_cached_state()
2538
self._cache_revision_history(rev_history)
2539
for hook in Branch.hooks['set_rh']:
2540
hook(self, rev_history)
2541
if Branch.hooks['post_change_branch_tip']:
2542
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2544
def _synchronize_history(self, destination, revision_id):
2545
"""Synchronize last revision and revision history between branches.
2547
This version is most efficient when the destination is also a
2548
BzrBranch5, but works for BzrBranch6 as long as the revision
2549
history is the true lefthand parent history, and all of the revisions
2550
are in the destination's repository. If not, set_revision_history
2553
:param destination: The branch to copy the history into
2554
:param revision_id: The revision-id to truncate history at. May
2555
be None to copy complete history.
2557
if not isinstance(destination._format, BzrBranchFormat5):
2558
super(BzrBranch, self)._synchronize_history(
2559
destination, revision_id)
2561
if revision_id == _mod_revision.NULL_REVISION:
2564
new_history = self.revision_history()
2565
if revision_id is not None and new_history != []:
2567
new_history = new_history[:new_history.index(revision_id) + 1]
2569
rev = self.repository.get_revision(revision_id)
2570
new_history = rev.get_history(self.repository)[1:]
2571
destination.set_revision_history(new_history)
2573
2533
@needs_write_lock
2574
2534
def set_last_revision_info(self, revno, revision_id):
2575
"""Set the last revision of this branch.
2577
The caller is responsible for checking that the revno is correct
2578
for this revision id.
2580
It may be possible to set the branch last revision to an id not
2581
present in the repository. However, branches can also be
2582
configured to check constraints on history, in which case this may not
2535
if not revision_id or not isinstance(revision_id, basestring):
2536
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2585
2537
revision_id = _mod_revision.ensure_null(revision_id)
2586
# this old format stores the full history, but this api doesn't
2587
# provide it, so we must generate, and might as well check it's
2589
history = self._lefthand_history(revision_id)
2590
if len(history) != revno:
2591
raise AssertionError('%d != %d' % (len(history), revno))
2592
self.set_revision_history(history)
2594
def _gen_revision_history(self):
2595
history = self._transport.get_bytes('revision-history').split('\n')
2596
if history[-1:] == ['']:
2597
# There shouldn't be a trailing newline, but just in case.
2602
def generate_revision_history(self, revision_id, last_rev=None,
2604
"""Create a new revision history that will finish with revision_id.
2606
:param revision_id: the new tip to use.
2607
:param last_rev: The previous last_revision. If not None, then this
2608
must be a ancestory of revision_id, or DivergedBranches is raised.
2609
:param other_branch: The other branch that DivergedBranches should
2610
raise with respect to.
2612
self.set_revision_history(self._lefthand_history(revision_id,
2613
last_rev, other_branch))
2538
old_revno, old_revid = self.last_revision_info()
2539
if self.get_append_revisions_only():
2540
self._check_history_violation(revision_id)
2541
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2542
self._write_last_revision_info(revno, revision_id)
2543
self._clear_cached_state()
2544
self._last_revision_info_cache = revno, revision_id
2545
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2615
2547
def basis_tree(self):
2616
2548
"""See Branch.basis_tree."""
2628
def _basic_push(self, target, overwrite, stop_revision):
2629
"""Basic implementation of push without bound branches or hooks.
2631
Must be called with source read locked and target write locked.
2633
result = BranchPushResult()
2634
result.source_branch = self
2635
result.target_branch = target
2636
result.old_revno, result.old_revid = target.last_revision_info()
2637
self.update_references(target)
2638
if result.old_revid != self.last_revision():
2639
# We assume that during 'push' this repository is closer than
2641
graph = self.repository.get_graph(target.repository)
2642
target.update_revisions(self, stop_revision,
2643
overwrite=overwrite, graph=graph)
2644
if self._push_should_merge_tags():
2645
result.tag_conflicts = self.tags.merge_to(target.tags,
2647
result.new_revno, result.new_revid = target.last_revision_info()
2650
2560
def get_stacked_on_url(self):
2651
2561
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2663
2573
self._transport.put_bytes('parent', url + '\n',
2664
2574
mode=self.bzrdir._get_file_mode())
2667
class BzrBranch5(BzrBranch):
2668
"""A format 5 branch. This supports new features over plain branches.
2670
It has support for a master_branch which is the data for bound branches.
2673
def get_bound_location(self):
2675
return self._transport.get_bytes('bound')[:-1]
2676
except errors.NoSuchFile:
2680
def get_master_branch(self, possible_transports=None):
2681
"""Return the branch we are bound to.
2683
:return: Either a Branch, or None
2685
This could memoise the branch, but if thats done
2686
it must be revalidated on each new lock.
2687
So for now we just don't memoise it.
2688
# RBC 20060304 review this decision.
2690
bound_loc = self.get_bound_location()
2694
return Branch.open(bound_loc,
2695
possible_transports=possible_transports)
2696
except (errors.NotBranchError, errors.ConnectionError), e:
2697
raise errors.BoundBranchConnectionFailure(
2700
2576
@needs_write_lock
2701
def set_bound_location(self, location):
2702
"""Set the target where this branch is bound to.
2704
:param location: URL to the target branch
2707
self._transport.put_bytes('bound', location+'\n',
2708
mode=self.bzrdir._get_file_mode())
2711
self._transport.delete('bound')
2712
except errors.NoSuchFile:
2578
"""If bound, unbind"""
2579
return self.set_bound_location(None)
2716
2581
@needs_write_lock
2717
2582
def bind(self, other):
2739
2604
# history around
2740
2605
self.set_bound_location(other.base)
2607
def get_bound_location(self):
2609
return self._transport.get_bytes('bound')[:-1]
2610
except errors.NoSuchFile:
2614
def get_master_branch(self, possible_transports=None):
2615
"""Return the branch we are bound to.
2617
:return: Either a Branch, or None
2619
if self._master_branch_cache is None:
2620
self._master_branch_cache = self._get_master_branch(
2621
possible_transports)
2622
return self._master_branch_cache
2624
def _get_master_branch(self, possible_transports):
2625
bound_loc = self.get_bound_location()
2629
return Branch.open(bound_loc,
2630
possible_transports=possible_transports)
2631
except (errors.NotBranchError, errors.ConnectionError), e:
2632
raise errors.BoundBranchConnectionFailure(
2742
2635
@needs_write_lock
2744
"""If bound, unbind"""
2745
return self.set_bound_location(None)
2636
def set_bound_location(self, location):
2637
"""Set the target where this branch is bound to.
2639
:param location: URL to the target branch
2641
self._master_branch_cache = None
2643
self._transport.put_bytes('bound', location+'\n',
2644
mode=self.bzrdir._get_file_mode())
2647
self._transport.delete('bound')
2648
except errors.NoSuchFile:
2747
2652
@needs_write_lock
2748
2653
def update(self, possible_transports=None):
2765
class BzrBranch8(BzrBranch5):
2669
def _read_last_revision_info(self):
2670
revision_string = self._transport.get_bytes('last-revision')
2671
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2672
revision_id = cache_utf8.get_cached_utf8(revision_id)
2674
return revno, revision_id
2676
def _write_last_revision_info(self, revno, revision_id):
2677
"""Simply write out the revision id, with no checks.
2679
Use set_last_revision_info to perform this safely.
2681
Does not update the revision_history cache.
2683
revision_id = _mod_revision.ensure_null(revision_id)
2684
out_string = '%d %s\n' % (revno, revision_id)
2685
self._transport.put_bytes('last-revision', out_string,
2686
mode=self.bzrdir._get_file_mode())
2689
class FullHistoryBzrBranch(BzrBranch):
2690
"""Bzr branch which contains the full revision history."""
2693
def set_last_revision_info(self, revno, revision_id):
2694
if not revision_id or not isinstance(revision_id, basestring):
2695
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2696
revision_id = _mod_revision.ensure_null(revision_id)
2697
# this old format stores the full history, but this api doesn't
2698
# provide it, so we must generate, and might as well check it's
2700
history = self._lefthand_history(revision_id)
2701
if len(history) != revno:
2702
raise AssertionError('%d != %d' % (len(history), revno))
2703
self._set_revision_history(history)
2705
def _read_last_revision_info(self):
2706
rh = self.revision_history()
2709
return (revno, rh[-1])
2711
return (0, _mod_revision.NULL_REVISION)
2713
@deprecated_method(deprecated_in((2, 4, 0)))
2715
def set_revision_history(self, rev_history):
2716
"""See Branch.set_revision_history."""
2717
self._set_revision_history(rev_history)
2719
def _set_revision_history(self, rev_history):
2720
if 'evil' in debug.debug_flags:
2721
mutter_callsite(3, "set_revision_history scales with history.")
2722
check_not_reserved_id = _mod_revision.check_not_reserved_id
2723
for rev_id in rev_history:
2724
check_not_reserved_id(rev_id)
2725
if Branch.hooks['post_change_branch_tip']:
2726
# Don't calculate the last_revision_info() if there are no hooks
2728
old_revno, old_revid = self.last_revision_info()
2729
if len(rev_history) == 0:
2730
revid = _mod_revision.NULL_REVISION
2732
revid = rev_history[-1]
2733
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2734
self._write_revision_history(rev_history)
2735
self._clear_cached_state()
2736
self._cache_revision_history(rev_history)
2737
for hook in Branch.hooks['set_rh']:
2738
hook(self, rev_history)
2739
if Branch.hooks['post_change_branch_tip']:
2740
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2742
def _write_revision_history(self, history):
2743
"""Factored out of set_revision_history.
2745
This performs the actual writing to disk.
2746
It is intended to be called by set_revision_history."""
2747
self._transport.put_bytes(
2748
'revision-history', '\n'.join(history),
2749
mode=self.bzrdir._get_file_mode())
2751
def _gen_revision_history(self):
2752
history = self._transport.get_bytes('revision-history').split('\n')
2753
if history[-1:] == ['']:
2754
# There shouldn't be a trailing newline, but just in case.
2758
def _synchronize_history(self, destination, revision_id):
2759
if not isinstance(destination, FullHistoryBzrBranch):
2760
super(BzrBranch, self)._synchronize_history(
2761
destination, revision_id)
2763
if revision_id == _mod_revision.NULL_REVISION:
2766
new_history = self.revision_history()
2767
if revision_id is not None and new_history != []:
2769
new_history = new_history[:new_history.index(revision_id) + 1]
2771
rev = self.repository.get_revision(revision_id)
2772
new_history = rev.get_history(self.repository)[1:]
2773
destination._set_revision_history(new_history)
2776
def generate_revision_history(self, revision_id, last_rev=None,
2778
"""Create a new revision history that will finish with revision_id.
2780
:param revision_id: the new tip to use.
2781
:param last_rev: The previous last_revision. If not None, then this
2782
must be a ancestory of revision_id, or DivergedBranches is raised.
2783
:param other_branch: The other branch that DivergedBranches should
2784
raise with respect to.
2786
self._set_revision_history(self._lefthand_history(revision_id,
2787
last_rev, other_branch))
2790
class BzrBranch5(FullHistoryBzrBranch):
2791
"""A format 5 branch. This supports new features over plain branches.
2793
It has support for a master_branch which is the data for bound branches.
2797
class BzrBranch8(BzrBranch):
2766
2798
"""A branch that stores tree-reference locations."""
2768
2800
def _open_hook(self):
2794
2826
self._last_revision_info_cache = None
2795
2827
self._reference_info = None
2797
def _last_revision_info(self):
2798
revision_string = self._transport.get_bytes('last-revision')
2799
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2800
revision_id = cache_utf8.get_cached_utf8(revision_id)
2802
return revno, revision_id
2804
def _write_last_revision_info(self, revno, revision_id):
2805
"""Simply write out the revision id, with no checks.
2807
Use set_last_revision_info to perform this safely.
2809
Does not update the revision_history cache.
2810
Intended to be called by set_last_revision_info and
2811
_write_revision_history.
2813
revision_id = _mod_revision.ensure_null(revision_id)
2814
out_string = '%d %s\n' % (revno, revision_id)
2815
self._transport.put_bytes('last-revision', out_string,
2816
mode=self.bzrdir._get_file_mode())
2819
def set_last_revision_info(self, revno, revision_id):
2820
revision_id = _mod_revision.ensure_null(revision_id)
2821
old_revno, old_revid = self.last_revision_info()
2822
if self._get_append_revisions_only():
2823
self._check_history_violation(revision_id)
2824
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2825
self._write_last_revision_info(revno, revision_id)
2826
self._clear_cached_state()
2827
self._last_revision_info_cache = revno, revision_id
2828
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2830
def _synchronize_history(self, destination, revision_id):
2831
"""Synchronize last revision and revision history between branches.
2833
:see: Branch._synchronize_history
2835
# XXX: The base Branch has a fast implementation of this method based
2836
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2837
# that uses set_revision_history. This class inherits from BzrBranch5,
2838
# but wants the fast implementation, so it calls
2839
# Branch._synchronize_history directly.
2840
Branch._synchronize_history(self, destination, revision_id)
2842
2829
def _check_history_violation(self, revision_id):
2843
last_revision = _mod_revision.ensure_null(self.last_revision())
2830
current_revid = self.last_revision()
2831
last_revision = _mod_revision.ensure_null(current_revid)
2844
2832
if _mod_revision.is_null(last_revision):
2846
if last_revision not in self._lefthand_history(revision_id):
2847
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2834
graph = self.repository.get_graph()
2835
for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
2836
if lh_ancestor == current_revid:
2838
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2849
2840
def _gen_revision_history(self):
2850
2841
"""Generate the revision history from last revision
2996
2972
# you can always ask for the URL; but you might not be able to use it
2997
2973
# if the repo can't support stacking.
2998
2974
## self._check_stackable_repo()
2999
stacked_url = self._get_config_location('stacked_on_location')
2975
# stacked_on_location is only ever defined in branch.conf, so don't
2976
# waste effort reading the whole stack of config files.
2977
config = self.get_config()._get_branch_data_config()
2978
stacked_url = self._get_config_location('stacked_on_location',
3000
2980
if stacked_url is None:
3001
2981
raise errors.NotStacked(self)
3002
2982
return stacked_url
3004
def _get_append_revisions_only(self):
3005
return self.get_config(
3006
).get_user_option_as_bool('append_revisions_only')
3009
def generate_revision_history(self, revision_id, last_rev=None,
3011
"""See BzrBranch5.generate_revision_history"""
3012
history = self._lefthand_history(revision_id, last_rev, other_branch)
3013
revno = len(history)
3014
self.set_last_revision_info(revno, revision_id)
3016
2984
@needs_read_lock
3017
2985
def get_rev_id(self, revno, history=None):
3018
2986
"""Find the revision id of the specified revno."""
3148
3127
return self.new_revno - self.old_revno
3150
3129
def report(self, to_file):
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)
3130
# TODO: This function gets passed a to_file, but then
3131
# ignores it and calls note() instead. This is also
3132
# inconsistent with PullResult(), which writes to stdout.
3133
# -- JRV20110901, bug #838853
3134
tag_conflicts = getattr(self, "tag_conflicts", None)
3135
tag_updates = getattr(self, "tag_updates", None)
3137
if self.old_revid != self.new_revid:
3138
note(gettext('Pushed up to revision %d.') % self.new_revno)
3140
note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
3141
if self.old_revid == self.new_revid and not tag_updates:
3142
if not tag_conflicts:
3143
note(gettext('No new revisions or tags to push.'))
3145
note(gettext('No new revisions to push.'))
3156
3146
self._show_tag_conficts(to_file)
3229
3219
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]
3265
3222
class InterBranch(InterObject):
3266
3223
"""This class represents operations taking place between two branches.
3295
3252
raise NotImplementedError(self.pull)
3297
3254
@needs_write_lock
3298
def update_revisions(self, stop_revision=None, overwrite=False,
3300
"""Pull in new perfect-fit revisions.
3302
:param stop_revision: Updated until the given revision
3303
:param overwrite: Always set the branch pointer, rather than checking
3304
to see if it is a proper descendant.
3305
:param graph: A Graph object that can be used to query history
3306
information. This can be None.
3309
raise NotImplementedError(self.update_revisions)
3312
def push(self, overwrite=False, stop_revision=None,
3255
def push(self, overwrite=False, stop_revision=None, lossy=False,
3313
3256
_override_hook_source_branch=None):
3314
3257
"""Mirror the source branch into the target branch.
3366
3318
self.source.tags.merge_to(self.target.tags)
3368
3320
@needs_write_lock
3369
def update_revisions(self, stop_revision=None, overwrite=False,
3371
"""See InterBranch.update_revisions()."""
3321
def fetch(self, stop_revision=None, limit=None):
3322
if self.target.base == self.source.base:
3324
self.source.lock_read()
3326
fetch_spec_factory = fetch.FetchSpecFactory()
3327
fetch_spec_factory.source_branch = self.source
3328
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3329
fetch_spec_factory.source_repo = self.source.repository
3330
fetch_spec_factory.target_repo = self.target.repository
3331
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3332
fetch_spec_factory.limit = limit
3333
fetch_spec = fetch_spec_factory.make_fetch_spec()
3334
return self.target.repository.fetch(self.source.repository,
3335
fetch_spec=fetch_spec)
3337
self.source.unlock()
3340
def _update_revisions(self, stop_revision=None, overwrite=False,
3372
3342
other_revno, other_last_revision = self.source.last_revision_info()
3373
3343
stop_revno = None # unknown
3374
3344
if stop_revision is None:
3431
3411
return self._pull(overwrite,
3432
3412
stop_revision, _hook_master=master_branch,
3433
3413
run_hooks=run_hooks,
3434
_override_hook_target=_override_hook_target)
3414
_override_hook_target=_override_hook_target,
3415
merge_tags_to_master=not source_is_master)
3436
3417
if master_branch:
3437
3418
master_branch.unlock()
3439
def push(self, overwrite=False, stop_revision=None,
3420
def push(self, overwrite=False, stop_revision=None, lossy=False,
3440
3421
_override_hook_source_branch=None):
3441
3422
"""See InterBranch.push.
3443
3424
This is the basic concrete implementation of push()
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.
3426
:param _override_hook_source_branch: If specified, run the hooks
3427
passing this Branch as the source, rather than self. This is for
3428
use of RemoteBranch, where push is delegated to the underlying
3432
raise errors.LossyPushToSameVCS(self.source, self.target)
3450
3433
# TODO: Public option to disable running hooks - should be trivial but
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,
3436
op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3437
op.add_cleanup(self.source.lock_read().unlock)
3438
op.add_cleanup(self.target.lock_write().unlock)
3439
return op.run(overwrite, stop_revision,
3440
_override_hook_source_branch=_override_hook_source_branch)
3442
def _basic_push(self, overwrite, stop_revision):
3443
"""Basic implementation of push without bound branches or hooks.
3445
Must be called with source read locked and target write locked.
3447
result = BranchPushResult()
3448
result.source_branch = self.source
3449
result.target_branch = self.target
3450
result.old_revno, result.old_revid = self.target.last_revision_info()
3451
self.source.update_references(self.target)
3452
if result.old_revid != stop_revision:
3453
# We assume that during 'push' this repository is closer than
3455
graph = self.source.repository.get_graph(self.target.repository)
3456
self._update_revisions(stop_revision, overwrite=overwrite,
3458
if self.source._push_should_merge_tags():
3459
result.tag_updates, result.tag_conflicts = (
3460
self.source.tags.merge_to(self.target.tags, overwrite))
3461
result.new_revno, result.new_revid = self.target.last_revision_info()
3464
def _push_with_bound_branches(self, operation, overwrite, stop_revision,
3462
3465
_override_hook_source_branch=None):
3463
3466
"""Push from source into target, and into target's master if any.
3476
3479
# be bound to itself? -- mbp 20070507
3477
3480
master_branch = self.target.get_master_branch()
3478
3481
master_branch.lock_write()
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()
3482
operation.add_cleanup(master_branch.unlock)
3483
# push into the master from the source branch.
3484
master_inter = InterBranch.get(self.source, master_branch)
3485
master_inter._basic_push(overwrite, stop_revision)
3486
# and push into the target branch from the source. Note that
3487
# we push from the source branch again, because it's considered
3488
# the highest bandwidth repository.
3489
result = self._basic_push(overwrite, stop_revision)
3490
result.master_branch = master_branch
3491
result.local_branch = self.target
3493
master_branch = None
3494
3494
# no master branch
3495
result = self.source._basic_push(self.target, overwrite,
3495
result = self._basic_push(overwrite, stop_revision)
3497
3496
# TODO: Why set master_branch and local_branch if there's no
3498
3497
# binding? Maybe cleaner to just leave them unset? -- mbp
3500
3499
result.master_branch = self.target
3501
3500
result.local_branch = None
3505
3504
def _pull(self, overwrite=False, stop_revision=None,
3506
3505
possible_transports=None, _hook_master=None, run_hooks=True,
3507
_override_hook_target=None, local=False):
3506
_override_hook_target=None, local=False,
3507
merge_tags_to_master=True):
3508
3508
"""See Branch.pull.
3510
3510
This function is the core worker, used by GenericInterBranch.pull to
3539
3541
# -- JRV20090506
3540
3542
result.old_revno, result.old_revid = \
3541
3543
self.target.last_revision_info()
3542
self.target.update_revisions(self.source, stop_revision,
3543
overwrite=overwrite, graph=graph)
3544
self._update_revisions(stop_revision, overwrite=overwrite,
3544
3546
# TODO: The old revid should be specified when merging tags,
3545
3547
# so a tags implementation that versions tags can only
3546
3548
# pull in the most recent changes. -- JRV20090506
3547
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3549
result.tag_updates, result.tag_conflicts = (
3550
self.source.tags.merge_to(self.target.tags, overwrite,
3551
ignore_master=not merge_tags_to_master))
3549
3552
result.new_revno, result.new_revid = self.target.last_revision_info()
3550
3553
if _hook_master:
3551
3554
result.master_branch = _hook_master
added
removed
bzrlib/branch.py
