514
505
rev_iter = iter(merge_sorted_revisions)
515
506
if start_revision_id is not None:
516
507
for node in rev_iter:
508
rev_id = node.key[-1]
518
509
if rev_id != start_revision_id:
521
512
# The decision to include the start or not
522
513
# depends on the stop_rule if a stop is provided
523
514
# so pop this node back into the iterator
524
rev_iter = itertools.chain(iter([node]), rev_iter)
515
rev_iter = chain(iter([node]), rev_iter)
526
517
if stop_revision_id is None:
527
518
# Yield everything
528
519
for node in rev_iter:
520
rev_id = node.key[-1]
530
521
yield (rev_id, node.merge_depth, node.revno,
531
522
node.end_of_merge)
532
523
elif stop_rule == 'exclude':
533
524
for node in rev_iter:
525
rev_id = node.key[-1]
535
526
if rev_id == stop_revision_id:
537
528
yield (rev_id, node.merge_depth, node.revno,
538
529
node.end_of_merge)
539
530
elif stop_rule == 'include':
540
531
for node in rev_iter:
532
rev_id = node.key[-1]
542
533
yield (rev_id, node.merge_depth, node.revno,
543
534
node.end_of_merge)
544
535
if rev_id == stop_revision_id:
679
662
raise errors.UnsupportedOperation(self.get_reference_info, self)
681
664
@needs_write_lock
682
def fetch(self, from_branch, last_revision=None, limit=None):
665
def fetch(self, from_branch, last_revision=None, pb=None, fetch_spec=None):
683
666
"""Copy revisions from from_branch into this branch.
685
668
:param from_branch: Where to copy from.
686
669
:param last_revision: What revision to stop at (None for at the end
688
:param limit: Optional rough limit of revisions to fetch
671
:param pb: An optional progress bar to use.
672
:param fetch_spec: If specified, a SearchResult or
673
PendingAncestryResult that describes which revisions to copy. This
674
allows copying multiple heads at once. Mutually exclusive with
691
return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)
678
if fetch_spec is not None and last_revision is not None:
679
raise AssertionError(
680
"fetch_spec and last_revision are mutually exclusive.")
681
if self.base == from_branch.base:
684
symbol_versioning.warn(
685
symbol_versioning.deprecated_in((1, 14, 0))
686
% "pb parameter to fetch()")
687
from_branch.lock_read()
689
if last_revision is None and fetch_spec is None:
690
last_revision = from_branch.last_revision()
691
last_revision = _mod_revision.ensure_null(last_revision)
692
return self.repository.fetch(from_branch.repository,
693
revision_id=last_revision,
694
pb=pb, fetch_spec=fetch_spec)
693
698
def get_bound_location(self):
694
699
"""Return the URL of the branch we are bound to.
757
759
"""Print `file` to stdout."""
758
760
raise NotImplementedError(self.print_file)
760
@deprecated_method(deprecated_in((2, 4, 0)))
761
762
def set_revision_history(self, rev_history):
762
"""See Branch.set_revision_history."""
763
self._set_revision_history(rev_history)
766
def _set_revision_history(self, rev_history):
767
if len(rev_history) == 0:
768
revid = _mod_revision.NULL_REVISION
770
revid = rev_history[-1]
771
if rev_history != self._lefthand_history(revid):
772
raise errors.NotLefthandHistory(rev_history)
773
self.set_last_revision_info(len(rev_history), revid)
774
self._cache_revision_history(rev_history)
775
for hook in Branch.hooks['set_rh']:
776
hook(self, rev_history)
779
def set_last_revision_info(self, revno, revision_id):
780
"""Set the last revision of this branch.
782
The caller is responsible for checking that the revno is correct
783
for this revision id.
785
It may be possible to set the branch last revision to an id not
786
present in the repository. However, branches can also be
787
configured to check constraints on history, in which case this may not
790
raise NotImplementedError(self.set_last_revision_info)
793
def generate_revision_history(self, revision_id, last_rev=None,
795
"""See Branch.generate_revision_history"""
796
graph = self.repository.get_graph()
797
(last_revno, last_revid) = self.last_revision_info()
798
known_revision_ids = [
799
(last_revid, last_revno),
800
(_mod_revision.NULL_REVISION, 0),
802
if last_rev is not None:
803
if not graph.is_ancestor(last_rev, revision_id):
804
# our previous tip is not merged into stop_revision
805
raise errors.DivergedBranches(self, other_branch)
806
revno = graph.find_distance_to_null(revision_id, known_revision_ids)
807
self.set_last_revision_info(revno, revision_id)
763
raise NotImplementedError(self.set_revision_history)
809
765
@needs_write_lock
810
766
def set_parent(self, url):
1041
995
:return: A tuple (revno, revision_id).
1043
997
if self._last_revision_info_cache is None:
1044
self._last_revision_info_cache = self._read_last_revision_info()
998
self._last_revision_info_cache = self._last_revision_info()
1045
999
return self._last_revision_info_cache
1047
def _read_last_revision_info(self):
1048
raise NotImplementedError(self._read_last_revision_info)
1001
def _last_revision_info(self):
1002
rh = self.revision_history()
1005
return (revno, rh[-1])
1007
return (0, _mod_revision.NULL_REVISION)
1009
@deprecated_method(deprecated_in((1, 6, 0)))
1010
def missing_revisions(self, other, stop_revision=None):
1011
"""Return a list of new revisions that would perfectly fit.
1013
If self and other have not diverged, return a list of the revisions
1014
present in other, but missing from self.
1016
self_history = self.revision_history()
1017
self_len = len(self_history)
1018
other_history = other.revision_history()
1019
other_len = len(other_history)
1020
common_index = min(self_len, other_len) -1
1021
if common_index >= 0 and \
1022
self_history[common_index] != other_history[common_index]:
1023
raise errors.DivergedBranches(self, other)
1025
if stop_revision is None:
1026
stop_revision = other_len
1028
if stop_revision > other_len:
1029
raise errors.NoSuchRevision(self, stop_revision)
1030
return other_history[self_len:stop_revision]
1032
def update_revisions(self, other, stop_revision=None, overwrite=False,
1033
graph=None, fetch_tags=True):
1034
"""Pull in new perfect-fit revisions.
1036
:param other: Another Branch to pull from
1037
:param stop_revision: Updated until the given revision
1038
:param overwrite: Always set the branch pointer, rather than checking
1039
to see if it is a proper descendant.
1040
:param graph: A Graph object that can be used to query history
1041
information. This can be None.
1042
:param fetch_tags: Flag that specifies if tags from other should be
1046
return InterBranch.get(other, self).update_revisions(stop_revision,
1047
overwrite, graph, fetch_tags=fetch_tags)
1050
1049
@deprecated_method(deprecated_in((2, 4, 0)))
1051
1050
def import_last_revision_info(self, source_repo, revno, revid):
1070
1068
:param source: Source branch to optionally fetch from
1071
1069
:param revno: Revision number of the new tip
1072
1070
:param revid: Revision id of the new tip
1073
:param lossy: Whether to discard metadata that can not be
1074
natively represented
1075
:return: Tuple with the new revision number and revision id
1076
(should only be different from the arguments when lossy=True)
1078
1072
if not self.repository.has_same_location(source.repository):
1079
self.fetch(source, revid)
1074
tags_to_fetch = set(source.tags.get_reverse_tag_dict())
1075
except errors.TagsNotSupported:
1076
tags_to_fetch = set()
1077
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
1078
source.repository, [revid],
1079
if_present_ids=tags_to_fetch).execute()
1080
self.repository.fetch(source.repository, fetch_spec=fetch_spec)
1080
1081
self.set_last_revision_info(revno, revid)
1081
return (revno, revid)
1083
1083
def revision_id_to_revno(self, revision_id):
1084
1084
"""Given a revision id, return its revno"""
1117
1117
stop_revision=stop_revision,
1118
1118
possible_transports=possible_transports, *args, **kwargs)
1120
def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1120
def push(self, target, overwrite=False, stop_revision=None, *args,
1122
1122
"""Mirror this branch into target.
1124
1124
This branch is considered to be 'local', having low latency.
1126
1126
return InterBranch.get(self, target).push(overwrite, stop_revision,
1127
lossy, *args, **kwargs)
1129
def lossy_push(self, target, stop_revision=None):
1130
"""Push deltas into another branch.
1132
:note: This does not, like push, retain the revision ids from
1133
the source branch and will, rather than adding bzr-specific
1134
metadata, push only those semantics of the revision that can be
1135
natively represented by this branch' VCS.
1137
:param target: Target branch
1138
:param stop_revision: Revision to push, defaults to last revision.
1139
:return: BranchPushResult with an extra member revidmap:
1140
A dictionary mapping revision ids from the target branch
1141
to new revision ids in the target branch, for each
1142
revision that was pushed.
1144
inter = InterBranch.get(self, target)
1145
lossy_push = getattr(inter, "lossy_push", None)
1146
if lossy_push is None:
1147
raise errors.LossyPushToSameVCS(self, target)
1148
return lossy_push(stop_revision)
1129
1150
def basis_tree(self):
1130
1151
"""Return `Tree` object for last revision."""
1543
1560
raise AssertionError("invalid heads: %r" % (heads,))
1545
def heads_to_fetch(self):
1546
"""Return the heads that must and that should be fetched to copy this
1547
branch into another repo.
1549
:returns: a 2-tuple of (must_fetch, if_present_fetch). must_fetch is a
1550
set of heads that must be fetched. if_present_fetch is a set of
1551
heads that must be fetched if present, but no error is necessary if
1552
they are not present.
1554
# For bzr native formats must_fetch is just the tip, and if_present_fetch
1556
must_fetch = set([self.last_revision()])
1557
if_present_fetch = set()
1558
c = self.get_config()
1559
include_tags = c.get_user_option_as_bool('branch.fetch_tags',
1563
if_present_fetch = set(self.tags.get_reverse_tag_dict())
1564
except errors.TagsNotSupported:
1566
must_fetch.discard(_mod_revision.NULL_REVISION)
1567
if_present_fetch.discard(_mod_revision.NULL_REVISION)
1568
return must_fetch, if_present_fetch
1571
class BranchFormat(controldir.ControlComponentFormat):
1563
class BranchFormat(object):
1572
1564
"""An encapsulation of the initialization and open routines for a format.
1574
1566
Formats provide three things:
1599
1602
transport = a_bzrdir.get_branch_transport(None, name=name)
1600
1603
format_string = transport.get_bytes("format")
1601
return format_registry.get(format_string)
1604
format = klass._formats[format_string]
1605
if isinstance(format, MetaDirBranchFormatFactory):
1602
1608
except errors.NoSuchFile:
1603
1609
raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1604
1610
except KeyError:
1605
1611
raise errors.UnknownFormatError(format=format_string, kind='branch')
1608
@deprecated_method(deprecated_in((2, 4, 0)))
1609
1614
def get_default_format(klass):
1610
1615
"""Return the current default format."""
1611
return format_registry.get_default()
1616
return klass._default_format
1614
@deprecated_method(deprecated_in((2, 4, 0)))
1615
1619
def get_formats(klass):
1616
1620
"""Get all the known formats.
1618
1622
Warning: This triggers a load of all lazy registered formats: do not
1619
1623
use except when that is desireed.
1621
return format_registry._get_all()
1626
for fmt in klass._formats.values():
1627
if isinstance(fmt, MetaDirBranchFormatFactory):
1630
return result + klass._extra_formats
1623
1632
def get_reference(self, a_bzrdir, name=None):
1624
1633
"""Get the target reference of the branch in a_bzrdir.
1663
1672
for hook in hooks:
1666
def initialize(self, a_bzrdir, name=None, repository=None,
1667
append_revisions_only=None):
1675
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1676
repository=None, lock_type='metadir',
1678
"""Initialize a branch in a bzrdir, with specified files
1680
:param a_bzrdir: The bzrdir to initialize the branch in
1681
:param utf8_files: The files to create as a list of
1682
(filename, content) tuples
1683
:param name: Name of colocated branch to create, if any
1684
:param set_format: If True, set the format with
1685
self.get_format_string. (BzrBranch4 has its format set
1687
:return: a branch in this format
1689
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1690
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1692
'metadir': ('lock', lockdir.LockDir),
1693
'branch4': ('branch-lock', lockable_files.TransportLock),
1695
lock_name, lock_class = lock_map[lock_type]
1696
control_files = lockable_files.LockableFiles(branch_transport,
1697
lock_name, lock_class)
1698
control_files.create_lock()
1700
control_files.lock_write()
1701
except errors.LockContention:
1702
if lock_type != 'branch4':
1708
utf8_files += [('format', self.get_format_string())]
1710
for (filename, content) in utf8_files:
1711
branch_transport.put_bytes(
1713
mode=a_bzrdir._get_file_mode())
1716
control_files.unlock()
1717
branch = self.open(a_bzrdir, name, _found=True,
1718
found_repository=repository)
1719
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1722
def initialize(self, a_bzrdir, name=None, repository=None):
1668
1723
"""Create a branch of this format in a_bzrdir.
1670
1725
:param name: Name of the colocated branch to create.
1718
1773
raise NotImplementedError(self.open)
1721
@deprecated_method(deprecated_in((2, 4, 0)))
1776
def register_extra_format(klass, format):
1777
"""Register a branch format that can not be part of a metadir.
1779
This is mainly useful to allow custom branch formats, such as
1780
older Bazaar formats and foreign formats, to be tested
1782
klass._extra_formats.append(format)
1783
network_format_registry.register(
1784
format.network_name(), format.__class__)
1722
1787
def register_format(klass, format):
1723
1788
"""Register a metadir format.
1725
1790
See MetaDirBranchFormatFactory for the ability to register a format
1726
1791
without loading the code the format needs until it is actually used.
1728
format_registry.register(format)
1793
klass._formats[format.get_format_string()] = format
1794
# Metadir formats have a network name of their format string, and get
1795
# registered as factories.
1796
if isinstance(format, MetaDirBranchFormatFactory):
1797
network_format_registry.register(format.get_format_string(), format)
1799
network_format_registry.register(format.get_format_string(),
1731
@deprecated_method(deprecated_in((2, 4, 0)))
1732
1803
def set_default_format(klass, format):
1733
format_registry.set_default(format)
1804
klass._default_format = format
1735
1806
def supports_set_append_revisions_only(self):
1736
1807
"""True if this format supports set_append_revisions_only."""
1806
1868
These are all empty initially, because by default nothing should get
1809
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1810
self.add_hook('set_rh',
1871
Hooks.__init__(self)
1872
self.create_hook(HookPoint('set_rh',
1811
1873
"Invoked whenever the revision history has been set via "
1812
1874
"set_revision_history. The api signature is (branch, "
1813
1875
"revision_history), and the branch will be write-locked. "
1814
1876
"The set_rh hook can be expensive for bzr to trigger, a better "
1815
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1816
self.add_hook('open',
1877
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1878
self.create_hook(HookPoint('open',
1817
1879
"Called with the Branch object that has been opened after a "
1818
"branch is opened.", (1, 8))
1819
self.add_hook('post_push',
1880
"branch is opened.", (1, 8), None))
1881
self.create_hook(HookPoint('post_push',
1820
1882
"Called after a push operation completes. post_push is called "
1821
1883
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1822
"bzr client.", (0, 15))
1823
self.add_hook('post_pull',
1884
"bzr client.", (0, 15), None))
1885
self.create_hook(HookPoint('post_pull',
1824
1886
"Called after a pull operation completes. post_pull is called "
1825
1887
"with a bzrlib.branch.PullResult object and only runs in the "
1826
"bzr client.", (0, 15))
1827
self.add_hook('pre_commit',
1888
"bzr client.", (0, 15), None))
1889
self.create_hook(HookPoint('pre_commit',
1828
1890
"Called after a commit is calculated but before it is "
1829
1891
"completed. pre_commit is called with (local, master, old_revno, "
1830
1892
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1833
1895
"basis revision. hooks MUST NOT modify this delta. "
1834
1896
" future_tree is an in-memory tree obtained from "
1835
1897
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1837
self.add_hook('post_commit',
1898
"tree.", (0,91), None))
1899
self.create_hook(HookPoint('post_commit',
1838
1900
"Called in the bzr client after a commit has completed. "
1839
1901
"post_commit is called with (local, master, old_revno, old_revid, "
1840
1902
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1841
"commit to a branch.", (0, 15))
1842
self.add_hook('post_uncommit',
1903
"commit to a branch.", (0, 15), None))
1904
self.create_hook(HookPoint('post_uncommit',
1843
1905
"Called in the bzr client after an uncommit completes. "
1844
1906
"post_uncommit is called with (local, master, old_revno, "
1845
1907
"old_revid, new_revno, new_revid) where local is the local branch "
1846
1908
"or None, master is the target branch, and an empty branch "
1847
"receives new_revno of 0, new_revid of None.", (0, 15))
1848
self.add_hook('pre_change_branch_tip',
1909
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1910
self.create_hook(HookPoint('pre_change_branch_tip',
1849
1911
"Called in bzr client and server before a change to the tip of a "
1850
1912
"branch is made. pre_change_branch_tip is called with a "
1851
1913
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1852
"commit, uncommit will all trigger this hook.", (1, 6))
1853
self.add_hook('post_change_branch_tip',
1914
"commit, uncommit will all trigger this hook.", (1, 6), None))
1915
self.create_hook(HookPoint('post_change_branch_tip',
1854
1916
"Called in bzr client and server after a change to the tip of a "
1855
1917
"branch is made. post_change_branch_tip is called with a "
1856
1918
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1857
"commit, uncommit will all trigger this hook.", (1, 4))
1858
self.add_hook('transform_fallback_location',
1919
"commit, uncommit will all trigger this hook.", (1, 4), None))
1920
self.create_hook(HookPoint('transform_fallback_location',
1859
1921
"Called when a stacked branch is activating its fallback "
1860
1922
"locations. transform_fallback_location is called with (branch, "
1861
1923
"url), and should return a new url. Returning the same url "
1866
1928
"fallback locations have not been activated. When there are "
1867
1929
"multiple hooks installed for transform_fallback_location, "
1868
1930
"all are called with the url returned from the previous hook."
1869
"The order is however undefined.", (1, 9))
1870
self.add_hook('automatic_tag_name',
1931
"The order is however undefined.", (1, 9), None))
1932
self.create_hook(HookPoint('automatic_tag_name',
1871
1933
"Called to determine an automatic tag name for a revision. "
1872
1934
"automatic_tag_name is called with (branch, revision_id) and "
1873
1935
"should return a tag name or None if no tag name could be "
1874
1936
"determined. The first non-None tag name returned will be used.",
1876
self.add_hook('post_branch_init',
1938
self.create_hook(HookPoint('post_branch_init',
1877
1939
"Called after new branch initialization completes. "
1878
1940
"post_branch_init is called with a "
1879
1941
"bzrlib.branch.BranchInitHookParams. "
1880
1942
"Note that init, branch and checkout (both heavyweight and "
1881
"lightweight) will all trigger this hook.", (2, 2))
1882
self.add_hook('post_switch',
1943
"lightweight) will all trigger this hook.", (2, 2), None))
1944
self.create_hook(HookPoint('post_switch',
1883
1945
"Called after a checkout switches branch. "
1884
1946
"post_switch is called with a "
1885
"bzrlib.branch.SwitchHookParams.", (2, 2))
1947
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
2001
2063
self.revision_id)
2066
class BzrBranchFormat4(BranchFormat):
2067
"""Bzr branch format 4.
2070
- a revision-history file.
2071
- a branch-lock lock file [ to be shared with the bzrdir ]
2074
def get_format_description(self):
2075
"""See BranchFormat.get_format_description()."""
2076
return "Branch format 4"
2078
def initialize(self, a_bzrdir, name=None, repository=None):
2079
"""Create a branch of this format in a_bzrdir."""
2080
if repository is not None:
2081
raise NotImplementedError(
2082
"initialize(repository=<not None>) on %r" % (self,))
2083
utf8_files = [('revision-history', ''),
2084
('branch-name', ''),
2086
return self._initialize_helper(a_bzrdir, utf8_files, name=name,
2087
lock_type='branch4', set_format=False)
2090
super(BzrBranchFormat4, self).__init__()
2091
self._matchingbzrdir = bzrdir.BzrDirFormat6()
2093
def network_name(self):
2094
"""The network name for this format is the control dirs disk label."""
2095
return self._matchingbzrdir.get_format_string()
2097
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2098
found_repository=None):
2099
"""See BranchFormat.open()."""
2101
# we are being called directly and must probe.
2102
raise NotImplementedError
2103
if found_repository is None:
2104
found_repository = a_bzrdir.open_repository()
2105
return BzrBranchPreSplitOut(_format=self,
2106
_control_files=a_bzrdir._control_files,
2109
_repository=found_repository)
2112
return "Bazaar-NG branch format 4"
2004
2115
class BranchFormatMetadir(BranchFormat):
2005
2116
"""Common logic for meta-dir based branch formats."""
2008
2119
"""What class to instantiate on open calls."""
2009
2120
raise NotImplementedError(self._branch_class)
2011
def _get_initial_config(self, append_revisions_only=None):
2012
if append_revisions_only:
2013
return "append_revisions_only = True\n"
2015
# Avoid writing anything if append_revisions_only is disabled,
2016
# as that is the default.
2019
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
2021
"""Initialize a branch in a bzrdir, with specified files
2023
:param a_bzrdir: The bzrdir to initialize the branch in
2024
:param utf8_files: The files to create as a list of
2025
(filename, content) tuples
2026
:param name: Name of colocated branch to create, if any
2027
:return: a branch in this format
2029
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2030
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2031
control_files = lockable_files.LockableFiles(branch_transport,
2032
'lock', lockdir.LockDir)
2033
control_files.create_lock()
2034
control_files.lock_write()
2036
utf8_files += [('format', self.get_format_string())]
2037
for (filename, content) in utf8_files:
2038
branch_transport.put_bytes(
2040
mode=a_bzrdir._get_file_mode())
2042
control_files.unlock()
2043
branch = self.open(a_bzrdir, name, _found=True,
2044
found_repository=repository)
2045
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2048
2122
def network_name(self):
2049
2123
"""A simple byte string uniquely identifying this format for RPC calls.
2147
2215
"""See BranchFormat.get_format_description()."""
2148
2216
return "Branch format 6"
2150
def initialize(self, a_bzrdir, name=None, repository=None,
2151
append_revisions_only=None):
2218
def initialize(self, a_bzrdir, name=None, repository=None):
2152
2219
"""Create a branch of this format in a_bzrdir."""
2153
2220
utf8_files = [('last-revision', '0 null:\n'),
2155
self._get_initial_config(append_revisions_only)),
2221
('branch.conf', ''),
2158
2224
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2160
2226
def make_tags(self, branch):
2161
2227
"""See bzrlib.branch.BranchFormat.make_tags()."""
2162
return _mod_tag.BasicTags(branch)
2228
return BasicTags(branch)
2164
2230
def supports_set_append_revisions_only(self):
2179
2245
"""See BranchFormat.get_format_description()."""
2180
2246
return "Branch format 8"
2182
def initialize(self, a_bzrdir, name=None, repository=None,
2183
append_revisions_only=None):
2248
def initialize(self, a_bzrdir, name=None, repository=None):
2184
2249
"""Create a branch of this format in a_bzrdir."""
2185
2250
utf8_files = [('last-revision', '0 null:\n'),
2187
self._get_initial_config(append_revisions_only)),
2251
('branch.conf', ''),
2189
2253
('references', '')
2191
2255
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2258
super(BzrBranchFormat8, self).__init__()
2259
self._matchingbzrdir.repository_format = \
2260
RepositoryFormatKnitPack5RichRoot()
2193
2262
def make_tags(self, branch):
2194
2263
"""See bzrlib.branch.BranchFormat.make_tags()."""
2195
return _mod_tag.BasicTags(branch)
2264
return BasicTags(branch)
2197
2266
def supports_set_append_revisions_only(self):
2276
2336
location = transport.put_bytes('location', to_branch.base)
2278
2338
def initialize(self, a_bzrdir, name=None, target_branch=None,
2279
repository=None, append_revisions_only=None):
2280
2340
"""Create a branch of this format in a_bzrdir."""
2281
2341
if target_branch is None:
2282
2342
# this format does not implement branch itself, thus the implicit
2283
2343
# creation contract must see it as uninitializable
2284
2344
raise errors.UninitializableFormat(self)
2285
2345
mutter('creating branch reference in %s', a_bzrdir.user_url)
2286
if a_bzrdir._format.fixed_components:
2287
raise errors.IncompatibleFormat(self, a_bzrdir._format)
2288
2346
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2289
2347
branch_transport.put_bytes('location',
2290
2348
target_branch.bzrdir.user_url)
2540
2583
"""See Branch.print_file."""
2541
2584
return self.repository.print_file(file, revision_id)
2586
def _write_revision_history(self, history):
2587
"""Factored out of set_revision_history.
2589
This performs the actual writing to disk.
2590
It is intended to be called by BzrBranch5.set_revision_history."""
2591
self._transport.put_bytes(
2592
'revision-history', '\n'.join(history),
2593
mode=self.bzrdir._get_file_mode())
2596
def set_revision_history(self, rev_history):
2597
"""See Branch.set_revision_history."""
2598
if 'evil' in debug.debug_flags:
2599
mutter_callsite(3, "set_revision_history scales with history.")
2600
check_not_reserved_id = _mod_revision.check_not_reserved_id
2601
for rev_id in rev_history:
2602
check_not_reserved_id(rev_id)
2603
if Branch.hooks['post_change_branch_tip']:
2604
# Don't calculate the last_revision_info() if there are no hooks
2606
old_revno, old_revid = self.last_revision_info()
2607
if len(rev_history) == 0:
2608
revid = _mod_revision.NULL_REVISION
2610
revid = rev_history[-1]
2611
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2612
self._write_revision_history(rev_history)
2613
self._clear_cached_state()
2614
self._cache_revision_history(rev_history)
2615
for hook in Branch.hooks['set_rh']:
2616
hook(self, rev_history)
2617
if Branch.hooks['post_change_branch_tip']:
2618
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2620
def _synchronize_history(self, destination, revision_id):
2621
"""Synchronize last revision and revision history between branches.
2623
This version is most efficient when the destination is also a
2624
BzrBranch5, but works for BzrBranch6 as long as the revision
2625
history is the true lefthand parent history, and all of the revisions
2626
are in the destination's repository. If not, set_revision_history
2629
:param destination: The branch to copy the history into
2630
:param revision_id: The revision-id to truncate history at. May
2631
be None to copy complete history.
2633
if not isinstance(destination._format, BzrBranchFormat5):
2634
super(BzrBranch, self)._synchronize_history(
2635
destination, revision_id)
2637
if revision_id == _mod_revision.NULL_REVISION:
2640
new_history = self.revision_history()
2641
if revision_id is not None and new_history != []:
2643
new_history = new_history[:new_history.index(revision_id) + 1]
2645
rev = self.repository.get_revision(revision_id)
2646
new_history = rev.get_history(self.repository)[1:]
2647
destination.set_revision_history(new_history)
2543
2649
@needs_write_lock
2544
2650
def set_last_revision_info(self, revno, revision_id):
2545
if not revision_id or not isinstance(revision_id, basestring):
2546
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2651
"""Set the last revision of this branch.
2653
The caller is responsible for checking that the revno is correct
2654
for this revision id.
2656
It may be possible to set the branch last revision to an id not
2657
present in the repository. However, branches can also be
2658
configured to check constraints on history, in which case this may not
2547
2661
revision_id = _mod_revision.ensure_null(revision_id)
2548
old_revno, old_revid = self.last_revision_info()
2549
if self.get_append_revisions_only():
2550
self._check_history_violation(revision_id)
2551
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2552
self._write_last_revision_info(revno, revision_id)
2553
self._clear_cached_state()
2554
self._last_revision_info_cache = revno, revision_id
2555
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2662
# this old format stores the full history, but this api doesn't
2663
# provide it, so we must generate, and might as well check it's
2665
history = self._lefthand_history(revision_id)
2666
if len(history) != revno:
2667
raise AssertionError('%d != %d' % (len(history), revno))
2668
self.set_revision_history(history)
2670
def _gen_revision_history(self):
2671
history = self._transport.get_bytes('revision-history').split('\n')
2672
if history[-1:] == ['']:
2673
# There shouldn't be a trailing newline, but just in case.
2678
def generate_revision_history(self, revision_id, last_rev=None,
2680
"""Create a new revision history that will finish with revision_id.
2682
:param revision_id: the new tip to use.
2683
:param last_rev: The previous last_revision. If not None, then this
2684
must be a ancestory of revision_id, or DivergedBranches is raised.
2685
:param other_branch: The other branch that DivergedBranches should
2686
raise with respect to.
2688
self.set_revision_history(self._lefthand_history(revision_id,
2689
last_rev, other_branch))
2557
2691
def basis_tree(self):
2558
2692
"""See Branch.basis_tree."""
2704
def _basic_push(self, target, overwrite, stop_revision):
2705
"""Basic implementation of push without bound branches or hooks.
2707
Must be called with source read locked and target write locked.
2709
result = BranchPushResult()
2710
result.source_branch = self
2711
result.target_branch = target
2712
result.old_revno, result.old_revid = target.last_revision_info()
2713
self.update_references(target)
2714
if result.old_revid != stop_revision:
2715
# We assume that during 'push' this repository is closer than
2717
graph = self.repository.get_graph(target.repository)
2718
target.update_revisions(self, stop_revision,
2719
overwrite=overwrite, graph=graph)
2720
if self._push_should_merge_tags():
2721
result.tag_conflicts = self.tags.merge_to(target.tags,
2723
result.new_revno, result.new_revid = target.last_revision_info()
2570
2726
def get_stacked_on_url(self):
2571
2727
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2583
2739
self._transport.put_bytes('parent', url + '\n',
2584
2740
mode=self.bzrdir._get_file_mode())
2743
class BzrBranchPreSplitOut(BzrBranch):
2745
def _get_checkout_format(self):
2746
"""Return the most suitable metadir for a checkout of this branch.
2747
Weaves are used if this branch's repository uses weaves.
2749
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2750
from bzrlib.bzrdir import BzrDirMetaFormat1
2751
format = BzrDirMetaFormat1()
2752
format.repository_format = RepositoryFormat7()
2756
class BzrBranch5(BzrBranch):
2757
"""A format 5 branch. This supports new features over plain branches.
2759
It has support for a master_branch which is the data for bound branches.
2762
def get_bound_location(self):
2764
return self._transport.get_bytes('bound')[:-1]
2765
except errors.NoSuchFile:
2769
def get_master_branch(self, possible_transports=None):
2770
"""Return the branch we are bound to.
2772
:return: Either a Branch, or None
2774
This could memoise the branch, but if thats done
2775
it must be revalidated on each new lock.
2776
So for now we just don't memoise it.
2777
# RBC 20060304 review this decision.
2779
bound_loc = self.get_bound_location()
2783
return Branch.open(bound_loc,
2784
possible_transports=possible_transports)
2785
except (errors.NotBranchError, errors.ConnectionError), e:
2786
raise errors.BoundBranchConnectionFailure(
2586
2789
@needs_write_lock
2588
"""If bound, unbind"""
2589
return self.set_bound_location(None)
2790
def set_bound_location(self, location):
2791
"""Set the target where this branch is bound to.
2793
:param location: URL to the target branch
2796
self._transport.put_bytes('bound', location+'\n',
2797
mode=self.bzrdir._get_file_mode())
2800
self._transport.delete('bound')
2801
except errors.NoSuchFile:
2591
2805
@needs_write_lock
2592
2806
def bind(self, other):
2614
2828
# history around
2615
2829
self.set_bound_location(other.base)
2617
def get_bound_location(self):
2619
return self._transport.get_bytes('bound')[:-1]
2620
except errors.NoSuchFile:
2624
def get_master_branch(self, possible_transports=None):
2625
"""Return the branch we are bound to.
2627
:return: Either a Branch, or None
2629
if self._master_branch_cache is None:
2630
self._master_branch_cache = self._get_master_branch(
2631
possible_transports)
2632
return self._master_branch_cache
2634
def _get_master_branch(self, possible_transports):
2635
bound_loc = self.get_bound_location()
2639
return Branch.open(bound_loc,
2640
possible_transports=possible_transports)
2641
except (errors.NotBranchError, errors.ConnectionError), e:
2642
raise errors.BoundBranchConnectionFailure(
2645
2831
@needs_write_lock
2646
def set_bound_location(self, location):
2647
"""Set the target where this branch is bound to.
2649
:param location: URL to the target branch
2651
self._master_branch_cache = None
2653
self._transport.put_bytes('bound', location+'\n',
2654
mode=self.bzrdir._get_file_mode())
2657
self._transport.delete('bound')
2658
except errors.NoSuchFile:
2833
"""If bound, unbind"""
2834
return self.set_bound_location(None)
2662
2836
@needs_write_lock
2663
2837
def update(self, possible_transports=None):
2679
def _read_last_revision_info(self):
2680
revision_string = self._transport.get_bytes('last-revision')
2681
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2682
revision_id = cache_utf8.get_cached_utf8(revision_id)
2684
return revno, revision_id
2686
def _write_last_revision_info(self, revno, revision_id):
2687
"""Simply write out the revision id, with no checks.
2689
Use set_last_revision_info to perform this safely.
2691
Does not update the revision_history cache.
2693
revision_id = _mod_revision.ensure_null(revision_id)
2694
out_string = '%d %s\n' % (revno, revision_id)
2695
self._transport.put_bytes('last-revision', out_string,
2696
mode=self.bzrdir._get_file_mode())
2699
class FullHistoryBzrBranch(BzrBranch):
2700
"""Bzr branch which contains the full revision history."""
2703
def set_last_revision_info(self, revno, revision_id):
2704
if not revision_id or not isinstance(revision_id, basestring):
2705
raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2706
revision_id = _mod_revision.ensure_null(revision_id)
2707
# this old format stores the full history, but this api doesn't
2708
# provide it, so we must generate, and might as well check it's
2710
history = self._lefthand_history(revision_id)
2711
if len(history) != revno:
2712
raise AssertionError('%d != %d' % (len(history), revno))
2713
self._set_revision_history(history)
2715
def _read_last_revision_info(self):
2716
rh = self.revision_history()
2719
return (revno, rh[-1])
2721
return (0, _mod_revision.NULL_REVISION)
2723
@deprecated_method(deprecated_in((2, 4, 0)))
2725
def set_revision_history(self, rev_history):
2726
"""See Branch.set_revision_history."""
2727
self._set_revision_history(rev_history)
2729
def _set_revision_history(self, rev_history):
2730
if 'evil' in debug.debug_flags:
2731
mutter_callsite(3, "set_revision_history scales with history.")
2732
check_not_reserved_id = _mod_revision.check_not_reserved_id
2733
for rev_id in rev_history:
2734
check_not_reserved_id(rev_id)
2735
if Branch.hooks['post_change_branch_tip']:
2736
# Don't calculate the last_revision_info() if there are no hooks
2738
old_revno, old_revid = self.last_revision_info()
2739
if len(rev_history) == 0:
2740
revid = _mod_revision.NULL_REVISION
2742
revid = rev_history[-1]
2743
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2744
self._write_revision_history(rev_history)
2745
self._clear_cached_state()
2746
self._cache_revision_history(rev_history)
2747
for hook in Branch.hooks['set_rh']:
2748
hook(self, rev_history)
2749
if Branch.hooks['post_change_branch_tip']:
2750
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2752
def _write_revision_history(self, history):
2753
"""Factored out of set_revision_history.
2755
This performs the actual writing to disk.
2756
It is intended to be called by set_revision_history."""
2757
self._transport.put_bytes(
2758
'revision-history', '\n'.join(history),
2759
mode=self.bzrdir._get_file_mode())
2761
def _gen_revision_history(self):
2762
history = self._transport.get_bytes('revision-history').split('\n')
2763
if history[-1:] == ['']:
2764
# There shouldn't be a trailing newline, but just in case.
2768
def _synchronize_history(self, destination, revision_id):
2769
if not isinstance(destination, FullHistoryBzrBranch):
2770
super(BzrBranch, self)._synchronize_history(
2771
destination, revision_id)
2773
if revision_id == _mod_revision.NULL_REVISION:
2776
new_history = self.revision_history()
2777
if revision_id is not None and new_history != []:
2779
new_history = new_history[:new_history.index(revision_id) + 1]
2781
rev = self.repository.get_revision(revision_id)
2782
new_history = rev.get_history(self.repository)[1:]
2783
destination._set_revision_history(new_history)
2786
def generate_revision_history(self, revision_id, last_rev=None,
2788
"""Create a new revision history that will finish with revision_id.
2790
:param revision_id: the new tip to use.
2791
:param last_rev: The previous last_revision. If not None, then this
2792
must be a ancestory of revision_id, or DivergedBranches is raised.
2793
:param other_branch: The other branch that DivergedBranches should
2794
raise with respect to.
2796
self._set_revision_history(self._lefthand_history(revision_id,
2797
last_rev, other_branch))
2800
class BzrBranch5(FullHistoryBzrBranch):
2801
"""A format 5 branch. This supports new features over plain branches.
2803
It has support for a master_branch which is the data for bound branches.
2807
class BzrBranch8(BzrBranch):
2854
class BzrBranch8(BzrBranch5):
2808
2855
"""A branch that stores tree-reference locations."""
2810
2857
def _open_hook(self):
2836
2883
self._last_revision_info_cache = None
2837
2884
self._reference_info = None
2886
def _last_revision_info(self):
2887
revision_string = self._transport.get_bytes('last-revision')
2888
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2889
revision_id = cache_utf8.get_cached_utf8(revision_id)
2891
return revno, revision_id
2893
def _write_last_revision_info(self, revno, revision_id):
2894
"""Simply write out the revision id, with no checks.
2896
Use set_last_revision_info to perform this safely.
2898
Does not update the revision_history cache.
2899
Intended to be called by set_last_revision_info and
2900
_write_revision_history.
2902
revision_id = _mod_revision.ensure_null(revision_id)
2903
out_string = '%d %s\n' % (revno, revision_id)
2904
self._transport.put_bytes('last-revision', out_string,
2905
mode=self.bzrdir._get_file_mode())
2908
def set_last_revision_info(self, revno, revision_id):
2909
revision_id = _mod_revision.ensure_null(revision_id)
2910
old_revno, old_revid = self.last_revision_info()
2911
if self._get_append_revisions_only():
2912
self._check_history_violation(revision_id)
2913
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2914
self._write_last_revision_info(revno, revision_id)
2915
self._clear_cached_state()
2916
self._last_revision_info_cache = revno, revision_id
2917
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2919
def _synchronize_history(self, destination, revision_id):
2920
"""Synchronize last revision and revision history between branches.
2922
:see: Branch._synchronize_history
2924
# XXX: The base Branch has a fast implementation of this method based
2925
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2926
# that uses set_revision_history. This class inherits from BzrBranch5,
2927
# but wants the fast implementation, so it calls
2928
# Branch._synchronize_history directly.
2929
Branch._synchronize_history(self, destination, revision_id)
2839
2931
def _check_history_violation(self, revision_id):
2840
current_revid = self.last_revision()
2841
last_revision = _mod_revision.ensure_null(current_revid)
2932
last_revision = _mod_revision.ensure_null(self.last_revision())
2842
2933
if _mod_revision.is_null(last_revision):
2844
graph = self.repository.get_graph()
2845
for lh_ancestor in graph.iter_lefthand_ancestry(revision_id):
2846
if lh_ancestor == current_revid:
2848
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2935
if last_revision not in self._lefthand_history(revision_id):
2936
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2850
2938
def _gen_revision_history(self):
2851
2939
"""Generate the revision history from last revision
2982
3085
# you can always ask for the URL; but you might not be able to use it
2983
3086
# if the repo can't support stacking.
2984
3087
## self._check_stackable_repo()
2985
# stacked_on_location is only ever defined in branch.conf, so don't
2986
# waste effort reading the whole stack of config files.
2987
config = self.get_config()._get_branch_data_config()
2988
stacked_url = self._get_config_location('stacked_on_location',
3088
stacked_url = self._get_config_location('stacked_on_location')
2990
3089
if stacked_url is None:
2991
3090
raise errors.NotStacked(self)
2992
3091
return stacked_url
3093
def _get_append_revisions_only(self):
3094
return self.get_config(
3095
).get_user_option_as_bool('append_revisions_only')
3098
def generate_revision_history(self, revision_id, last_rev=None,
3100
"""See BzrBranch5.generate_revision_history"""
3101
history = self._lefthand_history(revision_id, last_rev, other_branch)
3102
revno = len(history)
3103
self.set_last_revision_info(revno, revision_id)
2994
3105
@needs_read_lock
2995
3106
def get_rev_id(self, revno, history=None):
2996
3107
"""Find the revision id of the specified revno."""
3137
3237
return self.new_revno - self.old_revno
3139
3239
def report(self, to_file):
3140
# TODO: This function gets passed a to_file, but then
3141
# ignores it and calls note() instead. This is also
3142
# inconsistent with PullResult(), which writes to stdout.
3143
# -- JRV20110901, bug #838853
3144
tag_conflicts = getattr(self, "tag_conflicts", None)
3145
tag_updates = getattr(self, "tag_updates", None)
3147
if self.old_revid != self.new_revid:
3148
note(gettext('Pushed up to revision %d.') % self.new_revno)
3150
note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
3151
if self.old_revid == self.new_revid and not tag_updates:
3152
if not tag_conflicts:
3153
note(gettext('No new revisions or tags to push.'))
3155
note(gettext('No new revisions to push.'))
3240
"""Write a human-readable description of the result."""
3241
if self.old_revid == self.new_revid:
3242
note('No new revisions to push.')
3244
note('Pushed up to revision %d.' % self.new_revno)
3156
3245
self._show_tag_conficts(to_file)
3229
3318
branch._transport.put_bytes('format', format.get_format_string())
3321
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3322
"""Run ``callable(*args, **kwargs)``, write-locking target for the
3325
_run_with_write_locked_target will attempt to release the lock it acquires.
3327
If an exception is raised by callable, then that exception *will* be
3328
propagated, even if the unlock attempt raises its own error. Thus
3329
_run_with_write_locked_target should be preferred to simply doing::
3333
return callable(*args, **kwargs)
3338
# This is very similar to bzrlib.decorators.needs_write_lock. Perhaps they
3339
# should share code?
3342
result = callable(*args, **kwargs)
3344
exc_info = sys.exc_info()
3348
raise exc_info[0], exc_info[1], exc_info[2]
3232
3354
class InterBranch(InterObject):
3233
3355
"""This class represents operations taking place between two branches.
3262
3384
raise NotImplementedError(self.pull)
3264
3386
@needs_write_lock
3265
def push(self, overwrite=False, stop_revision=None, lossy=False,
3387
def update_revisions(self, stop_revision=None, overwrite=False,
3388
graph=None, fetch_tags=True):
3389
"""Pull in new perfect-fit revisions.
3391
:param stop_revision: Updated until the given revision
3392
:param overwrite: Always set the branch pointer, rather than checking
3393
to see if it is a proper descendant.
3394
:param graph: A Graph object that can be used to query history
3395
information. This can be None.
3396
:param fetch_tags: Flag that specifies if tags from source should be
3400
raise NotImplementedError(self.update_revisions)
3403
def push(self, overwrite=False, stop_revision=None,
3266
3404
_override_hook_source_branch=None):
3267
3405
"""Mirror the source branch into the target branch.
3328
3457
self.source.tags.merge_to(self.target.tags)
3330
3459
@needs_write_lock
3331
def fetch(self, stop_revision=None, limit=None):
3332
if self.target.base == self.source.base:
3334
self.source.lock_read()
3336
fetch_spec_factory = fetch.FetchSpecFactory()
3337
fetch_spec_factory.source_branch = self.source
3338
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3339
fetch_spec_factory.source_repo = self.source.repository
3340
fetch_spec_factory.target_repo = self.target.repository
3341
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3342
fetch_spec_factory.limit = limit
3343
fetch_spec = fetch_spec_factory.make_fetch_spec()
3344
return self.target.repository.fetch(self.source.repository,
3345
fetch_spec=fetch_spec)
3347
self.source.unlock()
3350
def _update_revisions(self, stop_revision=None, overwrite=False,
3460
def update_revisions(self, stop_revision=None, overwrite=False,
3461
graph=None, fetch_tags=True):
3462
"""See InterBranch.update_revisions()."""
3352
3463
other_revno, other_last_revision = self.source.last_revision_info()
3353
3464
stop_revno = None # unknown
3354
3465
if stop_revision is None:
3427
3540
if master_branch:
3428
3541
master_branch.unlock()
3430
def push(self, overwrite=False, stop_revision=None, lossy=False,
3543
def push(self, overwrite=False, stop_revision=None,
3431
3544
_override_hook_source_branch=None):
3432
3545
"""See InterBranch.push.
3434
3547
This is the basic concrete implementation of push()
3436
:param _override_hook_source_branch: If specified, run the hooks
3437
passing this Branch as the source, rather than self. This is for
3438
use of RemoteBranch, where push is delegated to the underlying
3549
:param _override_hook_source_branch: If specified, run
3550
the hooks passing this Branch as the source, rather than self.
3551
This is for use of RemoteBranch, where push is delegated to the
3552
underlying vfs-based Branch.
3442
raise errors.LossyPushToSameVCS(self.source, self.target)
3443
3554
# TODO: Public option to disable running hooks - should be trivial but
3446
op = cleanup.OperationWithCleanups(self._push_with_bound_branches)
3447
op.add_cleanup(self.source.lock_read().unlock)
3448
op.add_cleanup(self.target.lock_write().unlock)
3449
return op.run(overwrite, stop_revision,
3450
_override_hook_source_branch=_override_hook_source_branch)
3452
def _basic_push(self, overwrite, stop_revision):
3453
"""Basic implementation of push without bound branches or hooks.
3455
Must be called with source read locked and target write locked.
3457
result = BranchPushResult()
3458
result.source_branch = self.source
3459
result.target_branch = self.target
3460
result.old_revno, result.old_revid = self.target.last_revision_info()
3461
self.source.update_references(self.target)
3462
if result.old_revid != stop_revision:
3463
# We assume that during 'push' this repository is closer than
3465
graph = self.source.repository.get_graph(self.target.repository)
3466
self._update_revisions(stop_revision, overwrite=overwrite,
3468
if self.source._push_should_merge_tags():
3469
result.tag_updates, result.tag_conflicts = (
3470
self.source.tags.merge_to(self.target.tags, overwrite))
3471
result.new_revno, result.new_revid = self.target.last_revision_info()
3474
def _push_with_bound_branches(self, operation, overwrite, stop_revision,
3556
self.source.lock_read()
3558
return _run_with_write_locked_target(
3559
self.target, self._push_with_bound_branches, overwrite,
3561
_override_hook_source_branch=_override_hook_source_branch)
3563
self.source.unlock()
3565
def _push_with_bound_branches(self, overwrite, stop_revision,
3475
3566
_override_hook_source_branch=None):
3476
3567
"""Push from source into target, and into target's master if any.
3489
3580
# be bound to itself? -- mbp 20070507
3490
3581
master_branch = self.target.get_master_branch()
3491
3582
master_branch.lock_write()
3492
operation.add_cleanup(master_branch.unlock)
3493
# push into the master from the source branch.
3494
master_inter = InterBranch.get(self.source, master_branch)
3495
master_inter._basic_push(overwrite, stop_revision)
3496
# and push into the target branch from the source. Note that
3497
# we push from the source branch again, because it's considered
3498
# the highest bandwidth repository.
3499
result = self._basic_push(overwrite, stop_revision)
3500
result.master_branch = master_branch
3501
result.local_branch = self.target
3584
# push into the master from the source branch.
3585
self.source._basic_push(master_branch, overwrite, stop_revision)
3586
# and push into the target branch from the source. Note that we
3587
# push from the source branch again, because it's considered the
3588
# highest bandwidth repository.
3589
result = self.source._basic_push(self.target, overwrite,
3591
result.master_branch = master_branch
3592
result.local_branch = self.target
3596
master_branch.unlock()
3503
master_branch = None
3504
3598
# no master branch
3505
result = self._basic_push(overwrite, stop_revision)
3599
result = self.source._basic_push(self.target, overwrite,
3506
3601
# TODO: Why set master_branch and local_branch if there's no
3507
3602
# binding? Maybe cleaner to just leave them unset? -- mbp
3509
3604
result.master_branch = self.target
3510
3605
result.local_branch = None
3514
3609
def _pull(self, overwrite=False, stop_revision=None,
3515
3610
possible_transports=None, _hook_master=None, run_hooks=True,
3551
3644
# -- JRV20090506
3552
3645
result.old_revno, result.old_revid = \
3553
3646
self.target.last_revision_info()
3554
self._update_revisions(stop_revision, overwrite=overwrite,
3647
self.target.update_revisions(self.source, stop_revision,
3648
overwrite=overwrite, graph=graph)
3556
3649
# TODO: The old revid should be specified when merging tags,
3557
3650
# so a tags implementation that versions tags can only
3558
3651
# pull in the most recent changes. -- JRV20090506
3559
result.tag_updates, result.tag_conflicts = (
3560
self.source.tags.merge_to(self.target.tags, overwrite,
3561
ignore_master=not merge_tags_to_master))
3652
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3653
overwrite, ignore_master=not merge_tags_to_master)
3562
3654
result.new_revno, result.new_revid = self.target.last_revision_info()
3563
3655
if _hook_master:
3564
3656
result.master_branch = _hook_master
added
removed
bzrlib/branch.py
