724
815
old_repository = self.repository
725
816
if len(old_repository._fallback_repositories) != 1:
726
817
raise AssertionError("can't cope with fallback repositories "
727
"of %r" % (self.repository,))
728
# unlock it, including unlocking the fallback
818
"of %r (fallbacks: %r)" % (old_repository,
819
old_repository._fallback_repositories))
820
# Open the new repository object.
821
# Repositories don't offer an interface to remove fallback
822
# repositories today; take the conceptually simpler option and just
823
# reopen it. We reopen it starting from the URL so that we
824
# get a separate connection for RemoteRepositories and can
825
# stream from one of them to the other. This does mean doing
826
# separate SSH connection setup, but unstacking is not a
827
# common operation so it's tolerable.
828
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
829
new_repository = new_bzrdir.find_repository()
830
if new_repository._fallback_repositories:
831
raise AssertionError("didn't expect %r to have "
832
"fallback_repositories"
833
% (self.repository,))
834
# Replace self.repository with the new repository.
835
# Do our best to transfer the lock state (i.e. lock-tokens and
836
# lock count) of self.repository to the new repository.
837
lock_token = old_repository.lock_write().repository_token
838
self.repository = new_repository
839
if isinstance(self, remote.RemoteBranch):
840
# Remote branches can have a second reference to the old
841
# repository that need to be replaced.
842
if self._real_branch is not None:
843
self._real_branch.repository = new_repository
844
self.repository.lock_write(token=lock_token)
845
if lock_token is not None:
846
old_repository.leave_lock_in_place()
729
847
old_repository.unlock()
848
if lock_token is not None:
849
# XXX: self.repository.leave_lock_in_place() before this
850
# function will not be preserved. Fortunately that doesn't
851
# affect the current default format (2a), and would be a
852
# corner-case anyway.
853
# - Andrew Bennetts, 2010/06/30
854
self.repository.dont_leave_lock_in_place()
858
old_repository.unlock()
859
except errors.LockNotHeld:
862
if old_lock_count == 0:
863
raise AssertionError(
864
'old_repository should have been locked at least once.')
865
for i in range(old_lock_count-1):
866
self.repository.lock_write()
867
# Fetch from the old repository into the new.
730
868
old_repository.lock_read()
732
# Repositories don't offer an interface to remove fallback
733
# repositories today; take the conceptually simpler option and just
734
# reopen it. We reopen it starting from the URL so that we
735
# get a separate connection for RemoteRepositories and can
736
# stream from one of them to the other. This does mean doing
737
# separate SSH connection setup, but unstacking is not a
738
# common operation so it's tolerable.
739
new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
740
new_repository = new_bzrdir.find_repository()
741
self.repository = new_repository
742
if self.repository._fallback_repositories:
743
raise AssertionError("didn't expect %r to have "
744
"fallback_repositories"
745
% (self.repository,))
746
# this is not paired with an unlock because it's just restoring
747
# the previous state; the lock's released when set_stacked_on_url
749
self.repository.lock_write()
750
870
# XXX: If you unstack a branch while it has a working tree
751
871
# with a pending merge, the pending-merged revisions will no
752
872
# longer be present. You can (probably) revert and remerge.
754
# XXX: This only fetches up to the tip of the repository; it
755
# doesn't bring across any tags. That's fairly consistent
756
# with how branch works, but perhaps not ideal.
757
self.repository.fetch(old_repository,
758
revision_id=self.last_revision(),
874
tags_to_fetch = set(self.tags.get_reverse_tag_dict())
875
except errors.TagsNotSupported:
876
tags_to_fetch = set()
877
fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
878
old_repository, required_ids=[self.last_revision()],
879
if_present_ids=tags_to_fetch, find_ghosts=True).execute()
880
self.repository.fetch(old_repository, fetch_spec=fetch_spec)
761
882
old_repository.unlock()
1483
1637
"""Return the short format description for this format."""
1484
1638
raise NotImplementedError(self.get_format_description)
1486
def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
1640
def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1641
hooks = Branch.hooks['post_branch_init']
1644
params = BranchInitHookParams(self, a_bzrdir, name, branch)
1648
def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1488
1650
"""Initialize a branch in a bzrdir, with specified files
1490
1652
:param a_bzrdir: The bzrdir to initialize the branch in
1491
1653
:param utf8_files: The files to create as a list of
1492
1654
(filename, content) tuples
1493
:param set_format: If True, set the format with
1494
self.get_format_string. (BzrBranch4 has its format set
1655
:param name: Name of colocated branch to create, if any
1496
1656
:return: a branch in this format
1498
mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1499
branch_transport = a_bzrdir.get_branch_transport(self)
1501
'metadir': ('lock', lockdir.LockDir),
1502
'branch4': ('branch-lock', lockable_files.TransportLock),
1504
lock_name, lock_class = lock_map[lock_type]
1658
mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1659
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1505
1660
control_files = lockable_files.LockableFiles(branch_transport,
1506
lock_name, lock_class)
1661
'lock', lockdir.LockDir)
1507
1662
control_files.create_lock()
1663
control_files.lock_write()
1509
control_files.lock_write()
1510
except errors.LockContention:
1511
if lock_type != 'branch4':
1517
1665
utf8_files += [('format', self.get_format_string())]
1519
1666
for (filename, content) in utf8_files:
1520
1667
branch_transport.put_bytes(
1521
1668
filename, content,
1522
1669
mode=a_bzrdir._get_file_mode())
1525
control_files.unlock()
1526
return self.open(a_bzrdir, _found=True)
1671
control_files.unlock()
1672
branch = self.open(a_bzrdir, name, _found=True,
1673
found_repository=repository)
1674
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1528
def initialize(self, a_bzrdir):
1529
"""Create a branch of this format in a_bzrdir."""
1677
def initialize(self, a_bzrdir, name=None, repository=None):
1678
"""Create a branch of this format in a_bzrdir.
1680
:param name: Name of the colocated branch to create.
1530
1682
raise NotImplementedError(self.initialize)
1532
1684
def is_supported(self):
1618
1808
These are all empty initially, because by default nothing should get
1621
Hooks.__init__(self)
1622
self.create_hook(HookPoint('set_rh',
1811
Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
1812
self.add_hook('set_rh',
1623
1813
"Invoked whenever the revision history has been set via "
1624
1814
"set_revision_history. The api signature is (branch, "
1625
1815
"revision_history), and the branch will be write-locked. "
1626
1816
"The set_rh hook can be expensive for bzr to trigger, a better "
1627
"hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1628
self.create_hook(HookPoint('open',
1817
"hook to use is Branch.post_change_branch_tip.", (0, 15))
1818
self.add_hook('open',
1629
1819
"Called with the Branch object that has been opened after a "
1630
"branch is opened.", (1, 8), None))
1631
self.create_hook(HookPoint('post_push',
1820
"branch is opened.", (1, 8))
1821
self.add_hook('post_push',
1632
1822
"Called after a push operation completes. post_push is called "
1633
1823
"with a bzrlib.branch.BranchPushResult object and only runs in the "
1634
"bzr client.", (0, 15), None))
1635
self.create_hook(HookPoint('post_pull',
1824
"bzr client.", (0, 15))
1825
self.add_hook('post_pull',
1636
1826
"Called after a pull operation completes. post_pull is called "
1637
1827
"with a bzrlib.branch.PullResult object and only runs in the "
1638
"bzr client.", (0, 15), None))
1639
self.create_hook(HookPoint('pre_commit',
1640
"Called after a commit is calculated but before it is is "
1828
"bzr client.", (0, 15))
1829
self.add_hook('pre_commit',
1830
"Called after a commit is calculated but before it is "
1641
1831
"completed. pre_commit is called with (local, master, old_revno, "
1642
1832
"old_revid, future_revno, future_revid, tree_delta, future_tree"
1643
1833
"). old_revid is NULL_REVISION for the first commit to a branch, "
1645
1835
"basis revision. hooks MUST NOT modify this delta. "
1646
1836
" future_tree is an in-memory tree obtained from "
1647
1837
"CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1648
"tree.", (0,91), None))
1649
self.create_hook(HookPoint('post_commit',
1839
self.add_hook('post_commit',
1650
1840
"Called in the bzr client after a commit has completed. "
1651
1841
"post_commit is called with (local, master, old_revno, old_revid, "
1652
1842
"new_revno, new_revid). old_revid is NULL_REVISION for the first "
1653
"commit to a branch.", (0, 15), None))
1654
self.create_hook(HookPoint('post_uncommit',
1843
"commit to a branch.", (0, 15))
1844
self.add_hook('post_uncommit',
1655
1845
"Called in the bzr client after an uncommit completes. "
1656
1846
"post_uncommit is called with (local, master, old_revno, "
1657
1847
"old_revid, new_revno, new_revid) where local is the local branch "
1658
1848
"or None, master is the target branch, and an empty branch "
1659
"receives new_revno of 0, new_revid of None.", (0, 15), None))
1660
self.create_hook(HookPoint('pre_change_branch_tip',
1849
"receives new_revno of 0, new_revid of None.", (0, 15))
1850
self.add_hook('pre_change_branch_tip',
1661
1851
"Called in bzr client and server before a change to the tip of a "
1662
1852
"branch is made. pre_change_branch_tip is called with a "
1663
1853
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1664
"commit, uncommit will all trigger this hook.", (1, 6), None))
1665
self.create_hook(HookPoint('post_change_branch_tip',
1854
"commit, uncommit will all trigger this hook.", (1, 6))
1855
self.add_hook('post_change_branch_tip',
1666
1856
"Called in bzr client and server after a change to the tip of a "
1667
1857
"branch is made. post_change_branch_tip is called with a "
1668
1858
"bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1669
"commit, uncommit will all trigger this hook.", (1, 4), None))
1670
self.create_hook(HookPoint('transform_fallback_location',
1859
"commit, uncommit will all trigger this hook.", (1, 4))
1860
self.add_hook('transform_fallback_location',
1671
1861
"Called when a stacked branch is activating its fallback "
1672
1862
"locations. transform_fallback_location is called with (branch, "
1673
1863
"url), and should return a new url. Returning the same url "
1723
1930
self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1726
class BzrBranchFormat4(BranchFormat):
1727
"""Bzr branch format 4.
1730
- a revision-history file.
1731
- a branch-lock lock file [ to be shared with the bzrdir ]
1734
def get_format_description(self):
1735
"""See BranchFormat.get_format_description()."""
1736
return "Branch format 4"
1738
def initialize(self, a_bzrdir):
1739
"""Create a branch of this format in a_bzrdir."""
1740
utf8_files = [('revision-history', ''),
1741
('branch-name', ''),
1743
return self._initialize_helper(a_bzrdir, utf8_files,
1744
lock_type='branch4', set_format=False)
1747
super(BzrBranchFormat4, self).__init__()
1748
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1750
def network_name(self):
1751
"""The network name for this format is the control dirs disk label."""
1752
return self._matchingbzrdir.get_format_string()
1754
def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
1755
"""See BranchFormat.open()."""
1757
# we are being called directly and must probe.
1758
raise NotImplementedError
1759
return BzrBranch(_format=self,
1760
_control_files=a_bzrdir._control_files,
1762
_repository=a_bzrdir.open_repository())
1765
return "Bazaar-NG branch format 4"
1933
class BranchInitHookParams(object):
1934
"""Object holding parameters passed to *_branch_init hooks.
1936
There are 4 fields that hooks may wish to access:
1938
:ivar format: the branch format
1939
:ivar bzrdir: the BzrDir where the branch will be/has been initialized
1940
:ivar name: name of colocated branch, if any (or None)
1941
:ivar branch: the branch created
1943
Note that for lightweight checkouts, the bzrdir and format fields refer to
1944
the checkout, hence they are different from the corresponding fields in
1945
branch, which refer to the original branch.
1948
def __init__(self, format, a_bzrdir, name, branch):
1949
"""Create a group of BranchInitHook parameters.
1951
:param format: the branch format
1952
:param a_bzrdir: the BzrDir where the branch will be/has been
1954
:param name: name of colocated branch, if any (or None)
1955
:param branch: the branch created
1957
Note that for lightweight checkouts, the bzrdir and format fields refer
1958
to the checkout, hence they are different from the corresponding fields
1959
in branch, which refer to the original branch.
1961
self.format = format
1962
self.bzrdir = a_bzrdir
1964
self.branch = branch
1966
def __eq__(self, other):
1967
return self.__dict__ == other.__dict__
1970
return "<%s of %s>" % (self.__class__.__name__, self.branch)
1973
class SwitchHookParams(object):
1974
"""Object holding parameters passed to *_switch hooks.
1976
There are 4 fields that hooks may wish to access:
1978
:ivar control_dir: BzrDir of the checkout to change
1979
:ivar to_branch: branch that the checkout is to reference
1980
:ivar force: skip the check for local commits in a heavy checkout
1981
:ivar revision_id: revision ID to switch to (or None)
1984
def __init__(self, control_dir, to_branch, force, revision_id):
1985
"""Create a group of SwitchHook parameters.
1987
:param control_dir: BzrDir of the checkout to change
1988
:param to_branch: branch that the checkout is to reference
1989
:param force: skip the check for local commits in a heavy checkout
1990
:param revision_id: revision ID to switch to (or None)
1992
self.control_dir = control_dir
1993
self.to_branch = to_branch
1995
self.revision_id = revision_id
1997
def __eq__(self, other):
1998
return self.__dict__ == other.__dict__
2001
return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
2002
self.control_dir, self.to_branch,
1768
2006
class BranchFormatMetadir(BranchFormat):
1974
2219
"""See BranchFormat.get_format_description()."""
1975
2220
return "Checkout reference format 1"
1977
def get_reference(self, a_bzrdir):
2222
def get_reference(self, a_bzrdir, name=None):
1978
2223
"""See BranchFormat.get_reference()."""
1979
transport = a_bzrdir.get_branch_transport(None)
2224
transport = a_bzrdir.get_branch_transport(None, name=name)
1980
2225
return transport.get_bytes('location')
1982
def set_reference(self, a_bzrdir, to_branch):
2227
def set_reference(self, a_bzrdir, name, to_branch):
1983
2228
"""See BranchFormat.set_reference()."""
1984
transport = a_bzrdir.get_branch_transport(None)
2229
transport = a_bzrdir.get_branch_transport(None, name=name)
1985
2230
location = transport.put_bytes('location', to_branch.base)
1987
def initialize(self, a_bzrdir, target_branch=None):
2232
def initialize(self, a_bzrdir, name=None, target_branch=None,
1988
2234
"""Create a branch of this format in a_bzrdir."""
1989
2235
if target_branch is None:
1990
2236
# this format does not implement branch itself, thus the implicit
1991
2237
# creation contract must see it as uninitializable
1992
2238
raise errors.UninitializableFormat(self)
1993
mutter('creating branch reference in %s', a_bzrdir.transport.base)
1994
branch_transport = a_bzrdir.get_branch_transport(self)
2239
mutter('creating branch reference in %s', a_bzrdir.user_url)
2240
branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1995
2241
branch_transport.put_bytes('location',
1996
target_branch.bzrdir.root_transport.base)
2242
target_branch.bzrdir.user_url)
1997
2243
branch_transport.put_bytes('format', self.get_format_string())
1999
a_bzrdir, _found=True,
2245
a_bzrdir, name, _found=True,
2000
2246
possible_transports=[target_branch.bzrdir.root_transport])
2247
self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2002
2250
def __init__(self):
2003
2251
super(BranchReferenceFormat, self).__init__()
2988
3310
raise NotImplementedError(self.push)
3313
def copy_content_into(self, revision_id=None):
3314
"""Copy the content of source into target
3316
revision_id: if not None, the revision history in the new branch will
3317
be truncated to end with revision_id.
3319
raise NotImplementedError(self.copy_content_into)
3322
def fetch(self, stop_revision=None, fetch_spec=None):
3325
:param stop_revision: Last revision to fetch
3326
:param fetch_spec: Fetch spec.
3328
raise NotImplementedError(self.fetch)
2991
3331
class GenericInterBranch(InterBranch):
2992
"""InterBranch implementation that uses public Branch functions.
2996
def _get_branch_formats_to_test():
2997
return BranchFormat._default_format, BranchFormat._default_format
3332
"""InterBranch implementation that uses public Branch functions."""
3335
def is_compatible(klass, source, target):
3336
# GenericBranch uses the public API, so always compatible
3340
def _get_branch_formats_to_test(klass):
3341
return [(format_registry.get_default(), format_registry.get_default())]
3344
def unwrap_format(klass, format):
3345
if isinstance(format, remote.RemoteBranchFormat):
3346
format._ensure_real()
3347
return format._custom_format
3351
def copy_content_into(self, revision_id=None):
3352
"""Copy the content of source into target
3354
revision_id: if not None, the revision history in the new branch will
3355
be truncated to end with revision_id.
3357
self.source.update_references(self.target)
3358
self.source._synchronize_history(self.target, revision_id)
3360
parent = self.source.get_parent()
3361
except errors.InaccessibleParent, e:
3362
mutter('parent was not accessible to copy: %s', e)
3365
self.target.set_parent(parent)
3366
if self.source._push_should_merge_tags():
3367
self.source.tags.merge_to(self.target.tags)
3370
def fetch(self, stop_revision=None, fetch_spec=None):
3371
if fetch_spec is not None and stop_revision is not None:
3372
raise AssertionError(
3373
"fetch_spec and last_revision are mutually exclusive.")
3374
if self.target.base == self.source.base:
3376
self.source.lock_read()
3378
if stop_revision is None and fetch_spec is None:
3379
stop_revision = self.source.last_revision()
3380
stop_revision = _mod_revision.ensure_null(stop_revision)
3381
return self.target.repository.fetch(self.source.repository,
3382
revision_id=stop_revision, fetch_spec=fetch_spec)
3384
self.source.unlock()
2999
3387
def update_revisions(self, stop_revision=None, overwrite=False,
3388
graph=None, fetch_tags=True):
3001
3389
"""See InterBranch.update_revisions()."""
3002
self.source.lock_read()
3004
other_revno, other_last_revision = self.source.last_revision_info()
3005
stop_revno = None # unknown
3006
if stop_revision is None:
3007
stop_revision = other_last_revision
3008
if _mod_revision.is_null(stop_revision):
3009
# if there are no commits, we're done.
3011
stop_revno = other_revno
3013
# what's the current last revision, before we fetch [and change it
3015
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3016
# we fetch here so that we don't process data twice in the common
3017
# case of having something to pull, and so that the check for
3018
# already merged can operate on the just fetched graph, which will
3019
# be cached in memory.
3020
self.target.fetch(self.source, stop_revision)
3021
# Check to see if one is an ancestor of the other
3024
graph = self.target.repository.get_graph()
3025
if self.target._check_if_descendant_or_diverged(
3026
stop_revision, last_rev, graph, self.source):
3027
# stop_revision is a descendant of last_rev, but we aren't
3028
# overwriting, so we're done.
3030
if stop_revno is None:
3032
graph = self.target.repository.get_graph()
3033
this_revno, this_last_revision = \
3034
self.target.last_revision_info()
3035
stop_revno = graph.find_distance_to_null(stop_revision,
3036
[(other_last_revision, other_revno),
3037
(this_last_revision, this_revno)])
3038
self.target.set_last_revision_info(stop_revno, stop_revision)
3040
self.source.unlock()
3390
other_revno, other_last_revision = self.source.last_revision_info()
3391
stop_revno = None # unknown
3392
if stop_revision is None:
3393
stop_revision = other_last_revision
3394
if _mod_revision.is_null(stop_revision):
3395
# if there are no commits, we're done.
3397
stop_revno = other_revno
3399
# what's the current last revision, before we fetch [and change it
3401
last_rev = _mod_revision.ensure_null(self.target.last_revision())
3402
# we fetch here so that we don't process data twice in the common
3403
# case of having something to pull, and so that the check for
3404
# already merged can operate on the just fetched graph, which will
3405
# be cached in memory.
3407
fetch_spec_factory = fetch.FetchSpecFactory()
3408
fetch_spec_factory.source_branch = self.source
3409
fetch_spec_factory.source_branch_stop_revision_id = stop_revision
3410
fetch_spec_factory.source_repo = self.source.repository
3411
fetch_spec_factory.target_repo = self.target.repository
3412
fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
3413
fetch_spec = fetch_spec_factory.make_fetch_spec()
3415
fetch_spec = _mod_graph.NotInOtherForRevs(self.target.repository,
3416
self.source.repository, revision_ids=[stop_revision]).execute()
3417
self.target.fetch(self.source, fetch_spec=fetch_spec)
3418
# Check to see if one is an ancestor of the other
3421
graph = self.target.repository.get_graph()
3422
if self.target._check_if_descendant_or_diverged(
3423
stop_revision, last_rev, graph, self.source):
3424
# stop_revision is a descendant of last_rev, but we aren't
3425
# overwriting, so we're done.
3427
if stop_revno is None:
3429
graph = self.target.repository.get_graph()
3430
this_revno, this_last_revision = \
3431
self.target.last_revision_info()
3432
stop_revno = graph.find_distance_to_null(stop_revision,
3433
[(other_last_revision, other_revno),
3434
(this_last_revision, this_revno)])
3435
self.target.set_last_revision_info(stop_revno, stop_revision)
3042
3438
def pull(self, overwrite=False, stop_revision=None,
3043
possible_transports=None, _hook_master=None, run_hooks=True,
3439
possible_transports=None, run_hooks=True,
3044
3440
_override_hook_target=None, local=False):
3441
"""Pull from source into self, updating my master if any.
3047
:param _hook_master: Private parameter - set the branch to
3048
be supplied as the master to pull hooks.
3049
3443
:param run_hooks: Private parameter - if false, this branch
3050
3444
is being called because it's the master of the primary branch,
3051
3445
so it should not run its hooks.
3052
:param _override_hook_target: Private parameter - set the branch to be
3053
supplied as the target_branch to pull hooks.
3054
:param local: Only update the local branch, and not the bound branch.
3056
# This type of branch can't be bound.
3447
bound_location = self.target.get_bound_location()
3448
if local and not bound_location:
3058
3449
raise errors.LocalRequiresBoundBranch()
3059
result = PullResult()
3060
result.source_branch = self.source
3061
if _override_hook_target is None:
3062
result.target_branch = self.target
3064
result.target_branch = _override_hook_target
3065
self.source.lock_read()
3450
master_branch = None
3451
source_is_master = (self.source.user_url == bound_location)
3452
if not local and bound_location and not source_is_master:
3453
# not pulling from master, so we need to update master.
3454
master_branch = self.target.get_master_branch(possible_transports)
3455
master_branch.lock_write()
3067
# We assume that during 'pull' the target repository is closer than
3069
self.source.update_references(self.target)
3070
graph = self.target.repository.get_graph(self.source.repository)
3071
# TODO: Branch formats should have a flag that indicates
3072
# that revno's are expensive, and pull() should honor that flag.
3074
result.old_revno, result.old_revid = \
3075
self.target.last_revision_info()
3076
self.target.update_revisions(self.source, stop_revision,
3077
overwrite=overwrite, graph=graph)
3078
# TODO: The old revid should be specified when merging tags,
3079
# so a tags implementation that versions tags can only
3080
# pull in the most recent changes. -- JRV20090506
3081
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3083
result.new_revno, result.new_revid = self.target.last_revision_info()
3085
result.master_branch = _hook_master
3086
result.local_branch = result.target_branch
3088
result.master_branch = result.target_branch
3089
result.local_branch = None
3091
for hook in Branch.hooks['post_pull']:
3458
# pull from source into master.
3459
master_branch.pull(self.source, overwrite, stop_revision,
3461
return self._pull(overwrite,
3462
stop_revision, _hook_master=master_branch,
3463
run_hooks=run_hooks,
3464
_override_hook_target=_override_hook_target,
3465
merge_tags_to_master=not source_is_master)
3094
self.source.unlock()
3468
master_branch.unlock()
3097
3470
def push(self, overwrite=False, stop_revision=None,
3098
3471
_override_hook_source_branch=None):
3164
def is_compatible(self, source, target):
3165
# GenericBranch uses the public API, so always compatible
3169
class InterToBranch5(GenericInterBranch):
3172
def _get_branch_formats_to_test():
3173
return BranchFormat._default_format, BzrBranchFormat5()
3175
def pull(self, overwrite=False, stop_revision=None,
3176
possible_transports=None, run_hooks=True,
3177
_override_hook_target=None, local=False):
3178
"""Pull from source into self, updating my master if any.
3536
def _pull(self, overwrite=False, stop_revision=None,
3537
possible_transports=None, _hook_master=None, run_hooks=True,
3538
_override_hook_target=None, local=False,
3539
merge_tags_to_master=True):
3542
This function is the core worker, used by GenericInterBranch.pull to
3543
avoid duplication when pulling source->master and source->local.
3545
:param _hook_master: Private parameter - set the branch to
3546
be supplied as the master to pull hooks.
3180
3547
:param run_hooks: Private parameter - if false, this branch
3181
3548
is being called because it's the master of the primary branch,
3182
3549
so it should not run its hooks.
3550
is being called because it's the master of the primary branch,
3551
so it should not run its hooks.
3552
:param _override_hook_target: Private parameter - set the branch to be
3553
supplied as the target_branch to pull hooks.
3554
:param local: Only update the local branch, and not the bound branch.
3184
bound_location = self.target.get_bound_location()
3185
if local and not bound_location:
3556
# This type of branch can't be bound.
3186
3558
raise errors.LocalRequiresBoundBranch()
3187
master_branch = None
3188
if not local and bound_location and self.source.base != bound_location:
3189
# not pulling from master, so we need to update master.
3190
master_branch = self.target.get_master_branch(possible_transports)
3191
master_branch.lock_write()
3559
result = PullResult()
3560
result.source_branch = self.source
3561
if _override_hook_target is None:
3562
result.target_branch = self.target
3564
result.target_branch = _override_hook_target
3565
self.source.lock_read()
3194
# pull from source into master.
3195
master_branch.pull(self.source, overwrite, stop_revision,
3197
return super(InterToBranch5, self).pull(overwrite,
3198
stop_revision, _hook_master=master_branch,
3199
run_hooks=run_hooks,
3200
_override_hook_target=_override_hook_target)
3567
# We assume that during 'pull' the target repository is closer than
3569
self.source.update_references(self.target)
3570
graph = self.target.repository.get_graph(self.source.repository)
3571
# TODO: Branch formats should have a flag that indicates
3572
# that revno's are expensive, and pull() should honor that flag.
3574
result.old_revno, result.old_revid = \
3575
self.target.last_revision_info()
3576
self.target.update_revisions(self.source, stop_revision,
3577
overwrite=overwrite, graph=graph)
3578
# TODO: The old revid should be specified when merging tags,
3579
# so a tags implementation that versions tags can only
3580
# pull in the most recent changes. -- JRV20090506
3581
result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3582
overwrite, ignore_master=not merge_tags_to_master)
3583
result.new_revno, result.new_revid = self.target.last_revision_info()
3585
result.master_branch = _hook_master
3586
result.local_branch = result.target_branch
3588
result.master_branch = result.target_branch
3589
result.local_branch = None
3591
for hook in Branch.hooks['post_pull']:
3203
master_branch.unlock()
3594
self.source.unlock()
3206
3598
InterBranch.register_optimiser(GenericInterBranch)
3207
InterBranch.register_optimiser(InterToBranch5)
added
removed
bzrlib/branch.py
