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, 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 fetch_spec: If specified, a SearchResult or
672
PendingAncestryResult that describes which revisions to copy. This
673
allows copying multiple heads at once. Mutually exclusive with
691
return InterBranch.get(from_branch, self).fetch(last_revision, limit=limit)
677
if fetch_spec is not None and last_revision is not None:
678
raise AssertionError(
679
"fetch_spec and last_revision are mutually exclusive.")
680
if self.base == from_branch.base:
682
from_branch.lock_read()
684
if last_revision is None and fetch_spec is None:
685
last_revision = from_branch.last_revision()
686
last_revision = _mod_revision.ensure_null(last_revision)
687
return self.repository.fetch(from_branch.repository,
688
revision_id=last_revision,
689
fetch_spec=fetch_spec)
693
693
def get_bound_location(self):
694
694
"""Return the URL of the branch we are bound to.
757
754
"""Print `file` to stdout."""
758
755
raise NotImplementedError(self.print_file)
760
@deprecated_method(deprecated_in((2, 4, 0)))
761
757
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)
758
raise NotImplementedError(self.set_revision_history)
809
760
@needs_write_lock
810
761
def set_parent(self, url):
1041
990
:return: A tuple (revno, revision_id).
1043
992
if self._last_revision_info_cache is None:
1044
self._last_revision_info_cache = self._read_last_revision_info()
993
self._last_revision_info_cache = self._last_revision_info()
1045
994
return self._last_revision_info_cache
1047
def _read_last_revision_info(self):
1048
raise NotImplementedError(self._read_last_revision_info)
996
def _last_revision_info(self):
997
rh = self.revision_history()
1000
return (revno, rh[-1])
1002
return (0, _mod_revision.NULL_REVISION)
1004
def update_revisions(self, other, stop_revision=None, overwrite=False,
1005
graph=None, fetch_tags=True):
1006
"""Pull in new perfect-fit revisions.
1008
:param other: Another Branch to pull from
1009
:param stop_revision: Updated until the given revision
1010
:param overwrite: Always set the branch pointer, rather than checking
1011
to see if it is a proper descendant.
1012
:param graph: A Graph object that can be used to query history
1013
information. This can be None.
1014
:param fetch_tags: Flag that specifies if tags from other should be
1018
return InterBranch.get(other, self).update_revisions(stop_revision,
1019
overwrite, graph, fetch_tags=fetch_tags)
1050
1021
@deprecated_method(deprecated_in((2, 4, 0)))
1051
1022
def import_last_revision_info(self, source_repo, revno, revid):
1070
1040
:param source: Source branch to optionally fetch from
1071
1041
:param revno: Revision number of the new tip
1072
1042
: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
1044
if not self.repository.has_same_location(source.repository):
1079
self.fetch(source, revid)
1046
tags_to_fetch = set(source.tags.get_reverse_tag_dict())
1047
except errors.TagsNotSupported:
1048
tags_to_fetch = set()
1049
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
1050
source.repository, [revid],
1051
if_present_ids=tags_to_fetch).execute()
1052
self.repository.fetch(source.repository, fetch_spec=fetch_spec)
1080
1053
self.set_last_revision_info(revno, revid)
1081
return (revno, revid)
1083
1055
def revision_id_to_revno(self, revision_id):
1084
1056
"""Given a revision id, return its revno"""
1117
1089
stop_revision=stop_revision,
1118
1090
possible_transports=possible_transports, *args, **kwargs)
1120
def push(self, target, overwrite=False, stop_revision=None, lossy=False,
1092
def push(self, target, overwrite=False, stop_revision=None, *args,
1122
1094
"""Mirror this branch into target.
1124
1096
This branch is considered to be 'local', having low latency.
1126
1098
return InterBranch.get(self, target).push(overwrite, stop_revision,
1127
lossy, *args, **kwargs)
1101
def lossy_push(self, target, stop_revision=None):
1102
"""Push deltas into another branch.
1104
:note: This does not, like push, retain the revision ids from
1105
the source branch and will, rather than adding bzr-specific
1106
metadata, push only those semantics of the revision that can be
1107
natively represented by this branch' VCS.
1109
:param target: Target branch
1110
:param stop_revision: Revision to push, defaults to last revision.
1111
:return: BranchPushResult with an extra member revidmap:
1112
A dictionary mapping revision ids from the target branch
1113
to new revision ids in the target branch, for each
1114
revision that was pushed.
1116
inter = InterBranch.get(self, target)
1117
lossy_push = getattr(inter, "lossy_push", None)
1118
if lossy_push is None:
1119
raise errors.LossyPushToSameVCS(self, target)
1120
return lossy_push(stop_revision)
1129
1122
def basis_tree(self):
1130
1123
"""Return `Tree` object for last revision."""
1543
1532
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
1535
class BranchFormat(controldir.ControlComponentFormat):
1572
1536
"""An encapsulation of the initialization and open routines for a format.
1663
1629
for hook in hooks:
1666
def initialize(self, a_bzrdir, name=None, repository=None,
1667
append_revisions_only=None):
1632
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1633
repository=None, lock_type='metadir',
1635
"""Initialize a branch in a bzrdir, with specified files
1637
:param a_bzrdir: The bzrdir to initialize the branch in
1638
:param utf8_files: The files to create as a list of
1639
(filename, content) tuples
1640
:param name: Name of colocated branch to create, if any
1641
:param set_format: If True, set the format with
1642
self.get_format_string. (BzrBranch4 has its format set
1644
:return: a branch in this format
1646
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1647
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1649
'metadir': ('lock', lockdir.LockDir),
1650
'branch4': ('branch-lock', lockable_files.TransportLock),
1652
lock_name, lock_class = lock_map[lock_type]
1653
control_files = lockable_files.LockableFiles(branch_transport,
1654
lock_name, lock_class)
1655
control_files.create_lock()
1657
control_files.lock_write()
1658
except errors.LockContention:
1659
if lock_type != 'branch4':
1665
utf8_files += [('format', self.get_format_string())]
1667
for (filename, content) in utf8_files:
1668
branch_transport.put_bytes(
1670
mode=a_bzrdir._get_file_mode())
1673
control_files.unlock()
1674
branch = self.open(a_bzrdir, name, _found=True,
1675
found_repository=repository)
1676
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1679
def initialize(self, a_bzrdir, name=None, repository=None):
1668
1680
"""Create a branch of this format in a_bzrdir.
1670
1682
:param name: Name of the colocated branch to create.
1806
1810
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',
1813
Hooks.__init__(self)
1814
self.create_hook(HookPoint('set_rh',
1811
1815
"Invoked whenever the revision history has been set via "
1812
1816
"set_revision_history. The api signature is (branch, "
1813
1817
"revision_history), and the branch will be write-locked. "
1814
1818
"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',
1819
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1820
self.create_hook(HookPoint('open',
1817
1821
"Called with the Branch object that has been opened after a "
1818
"branch is opened.", (1, 8))
1819
self.add_hook('post_push',
1822
"branch is opened.", (1, 8), None))
1823
self.create_hook(HookPoint('post_push',
1820
1824
"Called after a push operation completes. post_push is called "
1821
1825
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1822
"bzr client.", (0, 15))
1823
self.add_hook('post_pull',
1826
"bzr client.", (0, 15), None))
1827
self.create_hook(HookPoint('post_pull',
1824
1828
"Called after a pull operation completes. post_pull is called "
1825
1829
"with a bzrlib.branch.PullResult object and only runs in the "
1826
"bzr client.", (0, 15))
1827
self.add_hook('pre_commit',
1830
"bzr client.", (0, 15), None))
1831
self.create_hook(HookPoint('pre_commit',
1828
1832
"Called after a commit is calculated but before it is "
1829
1833
"completed. pre_commit is called with (local, master, old_revno, "
1830
1834
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1833
1837
"basis revision. hooks MUST NOT modify this delta. "
1834
1838
" future_tree is an in-memory tree obtained from "
1835
1839
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1837
self.add_hook('post_commit',
1840
"tree.", (0,91), None))
1841
self.create_hook(HookPoint('post_commit',
1838
1842
"Called in the bzr client after a commit has completed. "
1839
1843
"post_commit is called with (local, master, old_revno, old_revid, "
1840
1844
"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',
1845
"commit to a branch.", (0, 15), None))
1846
self.create_hook(HookPoint('post_uncommit',
1843
1847
"Called in the bzr client after an uncommit completes. "
1844
1848
"post_uncommit is called with (local, master, old_revno, "
1845
1849
"old_revid, new_revno, new_revid) where local is the local branch "
1846
1850
"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',
1851
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1852
self.create_hook(HookPoint('pre_change_branch_tip',
1849
1853
"Called in bzr client and server before a change to the tip of a "
1850
1854
"branch is made. pre_change_branch_tip is called with a "
1851
1855
"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',
1856
"commit, uncommit will all trigger this hook.", (1, 6), None))
1857
self.create_hook(HookPoint('post_change_branch_tip',
1854
1858
"Called in bzr client and server after a change to the tip of a "
1855
1859
"branch is made. post_change_branch_tip is called with a "
1856
1860
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1857
"commit, uncommit will all trigger this hook.", (1, 4))
1858
self.add_hook('transform_fallback_location',
1861
"commit, uncommit will all trigger this hook.", (1, 4), None))
1862
self.create_hook(HookPoint('transform_fallback_location',
1859
1863
"Called when a stacked branch is activating its fallback "
1860
1864
"locations. transform_fallback_location is called with (branch, "
1861
1865
"url), and should return a new url. Returning the same url "
1866
1870
"fallback locations have not been activated. When there are "
1867
1871
"multiple hooks installed for transform_fallback_location, "
1868
1872
"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',
1873
"The order is however undefined.", (1, 9), None))
1874
self.create_hook(HookPoint('automatic_tag_name',
1871
1875
"Called to determine an automatic tag name for a revision. "
1872
1876
"automatic_tag_name is called with (branch, revision_id) and "
1873
1877
"should return a tag name or None if no tag name could be "
1874
1878
"determined. The first non-None tag name returned will be used.",
1876
self.add_hook('post_branch_init',
1880
self.create_hook(HookPoint('post_branch_init',
1877
1881
"Called after new branch initialization completes. "
1878
1882
"post_branch_init is called with a "
1879
1883
"bzrlib.branch.BranchInitHookParams. "
1880
1884
"Note that init, branch and checkout (both heavyweight and "
1881
"lightweight) will all trigger this hook.", (2, 2))
1882
self.add_hook('post_switch',
1885
"lightweight) will all trigger this hook.", (2, 2), None))
1886
self.create_hook(HookPoint('post_switch',
1883
1887
"Called after a checkout switches branch. "
1884
1888
"post_switch is called with a "
1885
"bzrlib.branch.SwitchHookParams.", (2, 2))
1889
"bzrlib.branch.SwitchHookParams.", (2, 2), None))
2001
2005
self.revision_id)
2008
class BzrBranchFormat4(BranchFormat):
2009
"""Bzr branch format 4.
2012
- a revision-history file.
2013
- a branch-lock lock file [ to be shared with the bzrdir ]
2016
def get_format_description(self):
2017
"""See BranchFormat.get_format_description()."""
2018
return "Branch format 4"
2020
def initialize(self, a_bzrdir, name=None, repository=None):
2021
"""Create a branch of this format in a_bzrdir."""
2022
if repository is not None:
2023
raise NotImplementedError(
2024
"initialize(repository=<not None>) on %r" % (self,))
2025
utf8_files = [('revision-history', ''),
2026
('branch-name', ''),
2028
return self._initialize_helper(a_bzrdir, utf8_files, name=name,
2029
lock_type='branch4', set_format=False)
2032
super(BzrBranchFormat4, self).__init__()
2033
self._matchingbzrdir = bzrdir.BzrDirFormat6()
2035
def network_name(self):
2036
"""The network name for this format is the control dirs disk label."""
2037
return self._matchingbzrdir.get_format_string()
2039
def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2040
found_repository=None):
2041
"""See BranchFormat.open()."""
2043
# we are being called directly and must probe.
2044
raise NotImplementedError
2045
if found_repository is None:
2046
found_repository = a_bzrdir.open_repository()
2047
return BzrBranchPreSplitOut(_format=self,
2048
_control_files=a_bzrdir._control_files,
2051
_repository=found_repository)
2054
return "Bazaar-NG branch format 4"
2056
def supports_leaving_lock(self):
2004
2060
class BranchFormatMetadir(BranchFormat):
2005
2061
"""Common logic for meta-dir based branch formats."""
2008
2064
"""What class to instantiate on open calls."""
2009
2065
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
2067
def network_name(self):
2049
2068
"""A simple byte string uniquely identifying this format for RPC calls.
2147
2163
"""See BranchFormat.get_format_description()."""
2148
2164
return "Branch format 6"
2150
def initialize(self, a_bzrdir, name=None, repository=None,
2151
append_revisions_only=None):
2166
def initialize(self, a_bzrdir, name=None, repository=None):
2152
2167
"""Create a branch of this format in a_bzrdir."""
2153
2168
utf8_files = [('last-revision', '0 null:\n'),
2155
self._get_initial_config(append_revisions_only)),
2169
('branch.conf', ''),
2158
2172
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2160
2174
def make_tags(self, branch):
2161
2175
"""See bzrlib.branch.BranchFormat.make_tags()."""
2162
return _mod_tag.BasicTags(branch)
2176
return BasicTags(branch)
2164
2178
def supports_set_append_revisions_only(self):
2179
2193
"""See BranchFormat.get_format_description()."""
2180
2194
return "Branch format 8"
2182
def initialize(self, a_bzrdir, name=None, repository=None,
2183
append_revisions_only=None):
2196
def initialize(self, a_bzrdir, name=None, repository=None):
2184
2197
"""Create a branch of this format in a_bzrdir."""
2185
2198
utf8_files = [('last-revision', '0 null:\n'),
2187
self._get_initial_config(append_revisions_only)),
2199
('branch.conf', ''),
2189
2201
('references', '')
2191
2203
return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2206
super(BzrBranchFormat8, self).__init__()
2207
self._matchingbzrdir.repository_format = \
2208
RepositoryFormatKnitPack5RichRoot()
2193
2210
def make_tags(self, branch):
2194
2211
"""See bzrlib.branch.BranchFormat.make_tags()."""
2195
return _mod_tag.BasicTags(branch)
2212
return BasicTags(branch)
2197
2214
def supports_set_append_revisions_only(self):
2276
2284
location = transport.put_bytes('location', to_branch.base)
2278
2286
def initialize(self, a_bzrdir, name=None, target_branch=None,
2279
repository=None, append_revisions_only=None):
2280
2288
"""Create a branch of this format in a_bzrdir."""
2281
2289
if target_branch is None:
2282
2290
# this format does not implement branch itself, thus the implicit
2283
2291
# creation contract must see it as uninitializable
2284
2292
raise errors.UninitializableFormat(self)
2285
2293
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
2294
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2289
2295
branch_transport.put_bytes('location',
2290
2296
target_branch.bzrdir.user_url)
2540
2549
"""See Branch.print_file."""
2541
2550
return self.repository.print_file(file, revision_id)
2552
def _write_revision_history(self, history):
2553
"""Factored out of set_revision_history.
2555
This performs the actual writing to disk.
2556
It is intended to be called by BzrBranch5.set_revision_history."""
2557
self._transport.put_bytes(
2558
'revision-history', '\n'.join(history),
2559
mode=self.bzrdir._get_file_mode())
2562
def set_revision_history(self, rev_history):
2563
"""See Branch.set_revision_history."""
2564
if 'evil' in debug.debug_flags:
2565
mutter_callsite(3, "set_revision_history scales with history.")
2566
check_not_reserved_id = _mod_revision.check_not_reserved_id
2567
for rev_id in rev_history:
2568
check_not_reserved_id(rev_id)
2569
if Branch.hooks['post_change_branch_tip']:
2570
# Don't calculate the last_revision_info() if there are no hooks
2572
old_revno, old_revid = self.last_revision_info()
2573
if len(rev_history) == 0:
2574
revid = _mod_revision.NULL_REVISION
2576
revid = rev_history[-1]
2577
self._run_pre_change_branch_tip_hooks(len(rev_history), revid)
2578
self._write_revision_history(rev_history)
2579
self._clear_cached_state()
2580
self._cache_revision_history(rev_history)
2581
for hook in Branch.hooks['set_rh']:
2582
hook(self, rev_history)
2583
if Branch.hooks['post_change_branch_tip']:
2584
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2586
def _synchronize_history(self, destination, revision_id):
2587
"""Synchronize last revision and revision history between branches.
2589
This version is most efficient when the destination is also a
2590
BzrBranch5, but works for BzrBranch6 as long as the revision
2591
history is the true lefthand parent history, and all of the revisions
2592
are in the destination's repository. If not, set_revision_history
2595
:param destination: The branch to copy the history into
2596
:param revision_id: The revision-id to truncate history at. May
2597
be None to copy complete history.
2599
if not isinstance(destination._format, BzrBranchFormat5):
2600
super(BzrBranch, self)._synchronize_history(
2601
destination, revision_id)
2603
if revision_id == _mod_revision.NULL_REVISION:
2606
new_history = self.revision_history()
2607
if revision_id is not None and new_history != []:
2609
new_history = new_history[:new_history.index(revision_id) + 1]
2611
rev = self.repository.get_revision(revision_id)
2612
new_history = rev.get_history(self.repository)[1:]
2613
destination.set_revision_history(new_history)
2543
2615
@needs_write_lock
2544
2616
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)
2617
"""Set the last revision of this branch.
2619
The caller is responsible for checking that the revno is correct
2620
for this revision id.
2622
It may be possible to set the branch last revision to an id not
2623
present in the repository. However, branches can also be
2624
configured to check constraints on history, in which case this may not
2547
2627
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)
2628
# this old format stores the full history, but this api doesn't
2629
# provide it, so we must generate, and might as well check it's
2631
history = self._lefthand_history(revision_id)
2632
if len(history) != revno:
2633
raise AssertionError('%d != %d' % (len(history), revno))
2634
self.set_revision_history(history)
2636
def _gen_revision_history(self):
2637
history = self._transport.get_bytes('revision-history').split('\n')
2638
if history[-1:] == ['']:
2639
# There shouldn't be a trailing newline, but just in case.
2644
def generate_revision_history(self, revision_id, last_rev=None,
2646
"""Create a new revision history that will finish with revision_id.
2648
:param revision_id: the new tip to use.
2649
:param last_rev: The previous last_revision. If not None, then this
2650
must be a ancestory of revision_id, or DivergedBranches is raised.
2651
:param other_branch: The other branch that DivergedBranches should
2652
raise with respect to.
2654
self.set_revision_history(self._lefthand_history(revision_id,
2655
last_rev, other_branch))
2557
2657
def basis_tree(self):
2558
2658
"""See Branch.basis_tree."""
2670
def _basic_push(self, target, overwrite, stop_revision):
2671
"""Basic implementation of push without bound branches or hooks.
2673
Must be called with source read locked and target write locked.
2675
result = BranchPushResult()
2676
result.source_branch = self
2677
result.target_branch = target
2678
result.old_revno, result.old_revid = target.last_revision_info()
2679
self.update_references(target)
2680
if result.old_revid != stop_revision:
2681
# We assume that during 'push' this repository is closer than
2683
graph = self.repository.get_graph(target.repository)
2684
target.update_revisions(self, stop_revision,
2685
overwrite=overwrite, graph=graph)
2686
if self._push_should_merge_tags():
2687
result.tag_conflicts = self.tags.merge_to(target.tags,
2689
result.new_revno, result.new_revid = target.last_revision_info()
2570
2692
def get_stacked_on_url(self):
2571
2693
raise errors.UnstackableBranchFormat(self._format, self.user_url)
2583
2705
self._transport.put_bytes('parent', url + '\n',
2584
2706
mode=self.bzrdir._get_file_mode())
2709
class BzrBranchPreSplitOut(BzrBranch):
2711
def _get_checkout_format(self):
2712
"""Return the most suitable metadir for a checkout of this branch.
2713
Weaves are used if this branch's repository uses weaves.
2715
from bzrlib.repofmt.weaverepo import RepositoryFormat7
2716
from bzrlib.bzrdir import BzrDirMetaFormat1
2717
format = BzrDirMetaFormat1()
2718
format.repository_format = RepositoryFormat7()
2722
class BzrBranch5(BzrBranch):
2723
"""A format 5 branch. This supports new features over plain branches.
2725
It has support for a master_branch which is the data for bound branches.
2728
def get_bound_location(self):
2730
return self._transport.get_bytes('bound')[:-1]
2731
except errors.NoSuchFile:
2735
def get_master_branch(self, possible_transports=None):
2736
"""Return the branch we are bound to.
2738
:return: Either a Branch, or None
2740
This could memoise the branch, but if thats done
2741
it must be revalidated on each new lock.
2742
So for now we just don't memoise it.
2743
# RBC 20060304 review this decision.
2745
bound_loc = self.get_bound_location()
2749
return Branch.open(bound_loc,
2750
possible_transports=possible_transports)
2751
except (errors.NotBranchError, errors.ConnectionError), e:
2752
raise errors.BoundBranchConnectionFailure(
2586
2755
@needs_write_lock
2588
"""If bound, unbind"""
2589
return self.set_bound_location(None)
2756
def set_bound_location(self, location):
2757
"""Set the target where this branch is bound to.
2759
:param location: URL to the target branch
2762
self._transport.put_bytes('bound', location+'\n',
2763
mode=self.bzrdir._get_file_mode())
2766
self._transport.delete('bound')
2767
except errors.NoSuchFile:
2591
2771
@needs_write_lock
2592
2772
def bind(self, other):
2614
2794
# history around
2615
2795
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
2797
@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:
2799
"""If bound, unbind"""
2800
return self.set_bound_location(None)
2662
2802
@needs_write_lock
2663
2803
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):
2820
class BzrBranch8(BzrBranch5):
2808
2821
"""A branch that stores tree-reference locations."""
2810
2823
def _open_hook(self):
2836
2849
self._last_revision_info_cache = None
2837
2850
self._reference_info = None
2852
def _last_revision_info(self):
2853
revision_string = self._transport.get_bytes('last-revision')
2854
revno, revision_id = revision_string.rstrip('\n').split(' ', 1)
2855
revision_id = cache_utf8.get_cached_utf8(revision_id)
2857
return revno, revision_id
2859
def _write_last_revision_info(self, revno, revision_id):
2860
"""Simply write out the revision id, with no checks.
2862
Use set_last_revision_info to perform this safely.
2864
Does not update the revision_history cache.
2865
Intended to be called by set_last_revision_info and
2866
_write_revision_history.
2868
revision_id = _mod_revision.ensure_null(revision_id)
2869
out_string = '%d %s\n' % (revno, revision_id)
2870
self._transport.put_bytes('last-revision', out_string,
2871
mode=self.bzrdir._get_file_mode())
2874
def set_last_revision_info(self, revno, revision_id):
2875
revision_id = _mod_revision.ensure_null(revision_id)
2876
old_revno, old_revid = self.last_revision_info()
2877
if self._get_append_revisions_only():
2878
self._check_history_violation(revision_id)
2879
self._run_pre_change_branch_tip_hooks(revno, revision_id)
2880
self._write_last_revision_info(revno, revision_id)
2881
self._clear_cached_state()
2882
self._last_revision_info_cache = revno, revision_id
2883
self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2885
def _synchronize_history(self, destination, revision_id):
2886
"""Synchronize last revision and revision history between branches.
2888
:see: Branch._synchronize_history
2890
# XXX: The base Branch has a fast implementation of this method based
2891
# on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2892
# that uses set_revision_history. This class inherits from BzrBranch5,
2893
# but wants the fast implementation, so it calls
2894
# Branch._synchronize_history directly.
2895
Branch._synchronize_history(self, destination, revision_id)
2839
2897
def _check_history_violation(self, revision_id):
2840
current_revid = self.last_revision()
2841
last_revision = _mod_revision.ensure_null(current_revid)
2898
last_revision = _mod_revision.ensure_null(self.last_revision())
2842
2899
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)
2901
if last_revision not in self._lefthand_history(revision_id):
2902
raise errors.AppendRevisionsOnlyViolation(self.user_url)
2850
2904
def _gen_revision_history(self):
2851
2905
"""Generate the revision history from last revision
2982
3051
# you can always ask for the URL; but you might not be able to use it
2983
3052
# if the repo can't support stacking.
2984
3053
## 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',
3054
stacked_url = self._get_config_location('stacked_on_location')
2990
3055
if stacked_url is None:
2991
3056
raise errors.NotStacked(self)
2992
3057
return stacked_url
3059
def _get_append_revisions_only(self):
3060
return self.get_config(
3061
).get_user_option_as_bool('append_revisions_only')
3064
def generate_revision_history(self, revision_id, last_rev=None,
3066
"""See BzrBranch5.generate_revision_history"""
3067
history = self._lefthand_history(revision_id, last_rev, other_branch)
3068
revno = len(history)
3069
self.set_last_revision_info(revno, revision_id)
2994
3071
@needs_read_lock
2995
3072
def get_rev_id(self, revno, history=None):
2996
3073
"""Find the revision id of the specified revno."""
3137
3203
return self.new_revno - self.old_revno
3139
3205
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.'))
3206
"""Write a human-readable description of the result."""
3207
if self.old_revid == self.new_revid:
3208
note('No new revisions to push.')
3210
note('Pushed up to revision %d.' % self.new_revno)
3156
3211
self._show_tag_conficts(to_file)
3229
3284
branch._transport.put_bytes('format', format.get_format_string())
3287
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3288
"""Run ``callable(*args, **kwargs)``, write-locking target for the
3291
_run_with_write_locked_target will attempt to release the lock it acquires.
3293
If an exception is raised by callable, then that exception *will* be
3294
propagated, even if the unlock attempt raises its own error. Thus
3295
_run_with_write_locked_target should be preferred to simply doing::
3299
return callable(*args, **kwargs)
3304
# This is very similar to bzrlib.decorators.needs_write_lock. Perhaps they
3305
# should share code?
3308
result = callable(*args, **kwargs)
3310
exc_info = sys.exc_info()
3314
raise exc_info[0], exc_info[1], exc_info[2]
3232
3320
class InterBranch(InterObject):
3233
3321
"""This class represents operations taking place between two branches.
3262
3350
raise NotImplementedError(self.pull)
3264
3352
@needs_write_lock
3265
def push(self, overwrite=False, stop_revision=None, lossy=False,
3353
def update_revisions(self, stop_revision=None, overwrite=False,
3354
graph=None, fetch_tags=True):
3355
"""Pull in new perfect-fit revisions.
3357
:param stop_revision: Updated until the given revision
3358
:param overwrite: Always set the branch pointer, rather than checking
3359
to see if it is a proper descendant.
3360
:param graph: A Graph object that can be used to query history
3361
information. This can be None.
3362
:param fetch_tags: Flag that specifies if tags from source should be
3366
raise NotImplementedError(self.update_revisions)
3369
def push(self, overwrite=False, stop_revision=None,
3266
3370
_override_hook_source_branch=None):
3267
3371
"""Mirror the source branch into the target branch.
3328
3423
self.source.tags.merge_to(self.target.tags)
3330
3425
@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,
3426
def update_revisions(self, stop_revision=None, overwrite=False,
3427
graph=None, fetch_tags=True):
3428
"""See InterBranch.update_revisions()."""
3352
3429
other_revno, other_last_revision = self.source.last_revision_info()
3353
3430
stop_revno = None # unknown
3354
3431
if stop_revision is None:
3427
3506
if master_branch:
3428
3507
master_branch.unlock()
3430
def push(self, overwrite=False, stop_revision=None, lossy=False,
3509
def push(self, overwrite=False, stop_revision=None,
3431
3510
_override_hook_source_branch=None):
3432
3511
"""See InterBranch.push.
3434
3513
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
3515
:param _override_hook_source_branch: If specified, run
3516
the hooks passing this Branch as the source, rather than self.
3517
This is for use of RemoteBranch, where push is delegated to the
3518
underlying vfs-based Branch.
3442
raise errors.LossyPushToSameVCS(self.source, self.target)
3443
3520
# 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,
3522
self.source.lock_read()
3524
return _run_with_write_locked_target(
3525
self.target, self._push_with_bound_branches, overwrite,
3527
_override_hook_source_branch=_override_hook_source_branch)
3529
self.source.unlock()
3531
def _push_with_bound_branches(self, overwrite, stop_revision,
3475
3532
_override_hook_source_branch=None):
3476
3533
"""Push from source into target, and into target's master if any.
3489
3546
# be bound to itself? -- mbp 20070507
3490
3547
master_branch = self.target.get_master_branch()
3491
3548
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
3550
# push into the master from the source branch.
3551
self.source._basic_push(master_branch, overwrite, stop_revision)
3552
# and push into the target branch from the source. Note that we
3553
# push from the source branch again, because it's considered the
3554
# highest bandwidth repository.
3555
result = self.source._basic_push(self.target, overwrite,
3557
result.master_branch = master_branch
3558
result.local_branch = self.target
3562
master_branch.unlock()
3503
master_branch = None
3504
3564
# no master branch
3505
result = self._basic_push(overwrite, stop_revision)
3565
result = self.source._basic_push(self.target, overwrite,
3506
3567
# TODO: Why set master_branch and local_branch if there's no
3507
3568
# binding? Maybe cleaner to just leave them unset? -- mbp
3509
3570
result.master_branch = self.target
3510
3571
result.local_branch = None
3514
3575
def _pull(self, overwrite=False, stop_revision=None,
3515
3576
possible_transports=None, _hook_master=None, run_hooks=True,
3551
3612
# -- JRV20090506
3552
3613
result.old_revno, result.old_revid = \
3553
3614
self.target.last_revision_info()
3554
self._update_revisions(stop_revision, overwrite=overwrite,
3615
self.target.update_revisions(self.source, stop_revision,
3616
overwrite=overwrite, graph=graph)
3556
3617
# TODO: The old revid should be specified when merging tags,
3557
3618
# so a tags implementation that versions tags can only
3558
3619
# 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))
3620
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3621
overwrite, ignore_master=not merge_tags_to_master)
3562
3622
result.new_revno, result.new_revid = self.target.last_revision_info()
3563
3623
if _hook_master:
3564
3624
result.master_branch = _hook_master
added
removed
bzrlib/branch.py
