← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-04-08 06:17:41 UTC
  • mfrom: (4797.33.16 apport)
  • Revision ID: pqm@pqm.ubuntu.com-20100408061741-m7vl6z97vu33riv7
(robertc) Make sure ExecutablePath and InterpreterPath are set in
        Apport. (Martin Pool, James Westby, lp:528114)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
29
29
        errors,
30
30
        lockdir,
31
31
        lockable_files,
32
 
        remote,
33
32
        repository,
34
33
        revision as _mod_revision,
35
34
        rio,
50
49
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
51
50
from bzrlib.hooks import HookPoint, Hooks
52
51
from bzrlib.inter import InterObject
53
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
52
from bzrlib.lock import _RelockDebugMixin
54
53
from bzrlib import registry
55
54
from bzrlib.symbol_versioning import (
56
55
    deprecated_in,
64
63
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
65
64
 
66
65
 
67
 
class Branch(bzrdir.ControlComponent):
 
66
# TODO: Maybe include checks for common corruption of newlines, etc?
 
67
 
 
68
# TODO: Some operations like log might retrieve the same revisions
 
69
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
70
# cache in memory to make this faster.  In general anything can be
 
71
# cached in memory between lock and unlock operations. .. nb thats
 
72
# what the transaction identity map provides
 
73
 
 
74
 
 
75
######################################################################
 
76
# branch objects
 
77
 
 
78
class Branch(object):
68
79
    """Branch holding a history of revisions.
69
80
 
70
 
    :ivar base:
71
 
        Base directory/url of the branch; using control_url and
72
 
        control_transport is more standardized.
 
81
    base
 
82
        Base directory/url of the branch.
73
83
 
74
84
    hooks: An instance of BranchHooks.
75
85
    """
77
87
    # - RBC 20060112
78
88
    base = None
79
89
 
80
 
    @property
81
 
    def control_transport(self):
82
 
        return self._transport
83
 
 
84
 
    @property
85
 
    def user_transport(self):
86
 
        return self.bzrdir.user_transport
87
 
 
88
90
    def __init__(self, *ignored, **ignored_too):
89
91
        self.tags = self._format.make_tags(self)
90
92
        self._revision_history_cache = None
105
107
        """Activate the branch/repository from url as a fallback repository."""
106
108
        repo = self._get_fallback_repository(url)
107
109
        if repo.has_same_location(self.repository):
108
 
            raise errors.UnstackableLocationError(self.user_url, url)
 
110
            raise errors.UnstackableLocationError(self.base, url)
109
111
        self.repository.add_fallback_repository(repo)
110
112
 
111
113
    def break_lock(self):
198
200
        return self.supports_tags() and self.tags.get_tag_dict()
199
201
 
200
202
    def get_config(self):
201
 
        """Get a bzrlib.config.BranchConfig for this Branch.
202
 
 
203
 
        This can then be used to get and set configuration options for the
204
 
        branch.
205
 
 
206
 
        :return: A bzrlib.config.BranchConfig.
207
 
        """
208
203
        return BranchConfig(self)
209
204
 
210
205
    def _get_config(self):
246
241
        if not local and not config.has_explicit_nickname():
247
242
            try:
248
243
                master = self.get_master_branch(possible_transports)
249
 
                if master and self.user_url == master.user_url:
250
 
                    raise errors.RecursiveBind(self.user_url)
251
244
                if master is not None:
252
245
                    # return the master branch value
253
246
                    return master.nick
254
 
            except errors.RecursiveBind, e:
255
 
                raise e
256
247
            except errors.BzrError, e:
257
248
                # Silently fall back to local implicit nick if the master is
258
249
                # unavailable
295
286
        new_history.reverse()
296
287
        return new_history
297
288
 
298
 
    def lock_write(self, token=None):
299
 
        """Lock the branch for write operations.
300
 
 
301
 
        :param token: A token to permit reacquiring a previously held and
302
 
            preserved lock.
303
 
        :return: A BranchWriteLockResult.
304
 
        """
 
289
    def lock_write(self):
305
290
        raise NotImplementedError(self.lock_write)
306
291
 
307
292
    def lock_read(self):
308
 
        """Lock the branch for read operations.
309
 
 
310
 
        :return: A bzrlib.lock.LogicalLockResult.
311
 
        """
312
293
        raise NotImplementedError(self.lock_read)
313
294
 
314
295
    def unlock(self):
439
420
            * 'include' - the stop revision is the last item in the result
440
421
            * 'with-merges' - include the stop revision and all of its
441
422
              merged revisions in the result
442
 
            * 'with-merges-without-common-ancestry' - filter out revisions 
443
 
              that are in both ancestries
444
423
        :param direction: either 'reverse' or 'forward':
445
424
            * reverse means return the start_revision_id first, i.e.
446
425
              start at the most recent revision and go backwards in history
468
447
        # start_revision_id.
469
448
        if self._merge_sorted_revisions_cache is None:
470
449
            last_revision = self.last_revision()
471
 
            known_graph = self.repository.get_known_graph_ancestry(
472
 
                [last_revision])
 
450
            last_key = (last_revision,)
 
451
            known_graph = self.repository.revisions.get_known_graph_ancestry(
 
452
                [last_key])
473
453
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
474
 
                last_revision)
 
454
                last_key)
475
455
        filtered = self._filter_merge_sorted_revisions(
476
456
            self._merge_sorted_revisions_cache, start_revision_id,
477
457
            stop_revision_id, stop_rule)
478
458
        # Make sure we don't return revisions that are not part of the
479
459
        # start_revision_id ancestry.
480
 
        filtered = self._filter_start_non_ancestors(filtered)
 
460
        filtered = self._filter_non_ancestors(filtered)
481
461
        if direction == 'reverse':
482
462
            return filtered
483
463
        if direction == 'forward':
520
500
                       node.end_of_merge)
521
501
                if rev_id == stop_revision_id:
522
502
                    return
523
 
        elif stop_rule == 'with-merges-without-common-ancestry':
524
 
            # We want to exclude all revisions that are already part of the
525
 
            # stop_revision_id ancestry.
526
 
            graph = self.repository.get_graph()
527
 
            ancestors = graph.find_unique_ancestors(start_revision_id,
528
 
                                                    [stop_revision_id])
529
 
            for node in rev_iter:
530
 
                rev_id = node.key[-1]
531
 
                if rev_id not in ancestors:
532
 
                    continue
533
 
                yield (rev_id, node.merge_depth, node.revno,
534
 
                       node.end_of_merge)
535
503
        elif stop_rule == 'with-merges':
536
504
            stop_rev = self.repository.get_revision(stop_revision_id)
537
505
            if stop_rev.parent_ids:
560
528
        else:
561
529
            raise ValueError('invalid stop_rule %r' % stop_rule)
562
530
 
563
 
    def _filter_start_non_ancestors(self, rev_iter):
 
531
    def _filter_non_ancestors(self, rev_iter):
564
532
        # If we started from a dotted revno, we want to consider it as a tip
565
533
        # and don't want to yield revisions that are not part of its
566
534
        # ancestry. Given the order guaranteed by the merge sort, we will see
627
595
        :param other: The branch to bind to
628
596
        :type other: Branch
629
597
        """
630
 
        raise errors.UpgradeRequired(self.user_url)
 
598
        raise errors.UpgradeRequired(self.base)
631
599
 
632
600
    def set_append_revisions_only(self, enabled):
633
601
        if not self._format.supports_set_append_revisions_only():
634
 
            raise errors.UpgradeRequired(self.user_url)
 
602
            raise errors.UpgradeRequired(self.base)
635
603
        if enabled:
636
604
            value = 'True'
637
605
        else:
685
653
    def get_old_bound_location(self):
686
654
        """Return the URL of the branch we used to be bound to
687
655
        """
688
 
        raise errors.UpgradeRequired(self.user_url)
 
656
        raise errors.UpgradeRequired(self.base)
689
657
 
690
658
    def get_commit_builder(self, parents, config=None, timestamp=None,
691
659
                           timezone=None, committer=None, revprops=None,
769
737
            stacking.
770
738
        """
771
739
        if not self._format.supports_stacking():
772
 
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
740
            raise errors.UnstackableBranchFormat(self._format, self.base)
773
741
        # XXX: Changing from one fallback repository to another does not check
774
742
        # that all the data you need is present in the new fallback.
775
743
        # Possibly it should.
805
773
            if len(old_repository._fallback_repositories) != 1:
806
774
                raise AssertionError("can't cope with fallback repositories "
807
775
                    "of %r" % (self.repository,))
808
 
            # Open the new repository object.
809
 
            # Repositories don't offer an interface to remove fallback
810
 
            # repositories today; take the conceptually simpler option and just
811
 
            # reopen it.  We reopen it starting from the URL so that we
812
 
            # get a separate connection for RemoteRepositories and can
813
 
            # stream from one of them to the other.  This does mean doing
814
 
            # separate SSH connection setup, but unstacking is not a
815
 
            # common operation so it's tolerable.
816
 
            new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
817
 
            new_repository = new_bzrdir.find_repository()
818
 
            if new_repository._fallback_repositories:
819
 
                raise AssertionError("didn't expect %r to have "
820
 
                    "fallback_repositories"
821
 
                    % (self.repository,))
822
 
            # Replace self.repository with the new repository.
823
 
            # Do our best to transfer the lock state (i.e. lock-tokens and
824
 
            # lock count) of self.repository to the new repository.
825
 
            lock_token = old_repository.lock_write().repository_token
826
 
            self.repository = new_repository
827
 
            if isinstance(self, remote.RemoteBranch):
828
 
                # Remote branches can have a second reference to the old
829
 
                # repository that need to be replaced.
830
 
                if self._real_branch is not None:
831
 
                    self._real_branch.repository = new_repository
832
 
            self.repository.lock_write(token=lock_token)
833
 
            if lock_token is not None:
834
 
                old_repository.leave_lock_in_place()
 
776
            # unlock it, including unlocking the fallback
835
777
            old_repository.unlock()
836
 
            if lock_token is not None:
837
 
                # XXX: self.repository.leave_lock_in_place() before this
838
 
                # function will not be preserved.  Fortunately that doesn't
839
 
                # affect the current default format (2a), and would be a
840
 
                # corner-case anyway.
841
 
                #  - Andrew Bennetts, 2010/06/30
842
 
                self.repository.dont_leave_lock_in_place()
843
 
            old_lock_count = 0
844
 
            while True:
845
 
                try:
846
 
                    old_repository.unlock()
847
 
                except errors.LockNotHeld:
848
 
                    break
849
 
                old_lock_count += 1
850
 
            if old_lock_count == 0:
851
 
                raise AssertionError(
852
 
                    'old_repository should have been locked at least once.')
853
 
            for i in range(old_lock_count-1):
 
778
            old_repository.lock_read()
 
779
            try:
 
780
                # Repositories don't offer an interface to remove fallback
 
781
                # repositories today; take the conceptually simpler option and just
 
782
                # reopen it.  We reopen it starting from the URL so that we
 
783
                # get a separate connection for RemoteRepositories and can
 
784
                # stream from one of them to the other.  This does mean doing
 
785
                # separate SSH connection setup, but unstacking is not a
 
786
                # common operation so it's tolerable.
 
787
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
 
788
                new_repository = new_bzrdir.find_repository()
 
789
                self.repository = new_repository
 
790
                if self.repository._fallback_repositories:
 
791
                    raise AssertionError("didn't expect %r to have "
 
792
                        "fallback_repositories"
 
793
                        % (self.repository,))
 
794
                # this is not paired with an unlock because it's just restoring
 
795
                # the previous state; the lock's released when set_stacked_on_url
 
796
                # returns
854
797
                self.repository.lock_write()
855
 
            # Fetch from the old repository into the new.
856
 
            old_repository.lock_read()
857
 
            try:
858
798
                # XXX: If you unstack a branch while it has a working tree
859
799
                # with a pending merge, the pending-merged revisions will no
860
800
                # longer be present.  You can (probably) revert and remerge.
954
894
 
955
895
    def unbind(self):
956
896
        """Older format branches cannot bind or unbind."""
957
 
        raise errors.UpgradeRequired(self.user_url)
 
897
        raise errors.UpgradeRequired(self.base)
958
898
 
959
899
    def last_revision(self):
960
900
        """Return last revision id, or NULL_REVISION."""
1001
941
                raise errors.NoSuchRevision(self, stop_revision)
1002
942
        return other_history[self_len:stop_revision]
1003
943
 
 
944
    @needs_write_lock
1004
945
    def update_revisions(self, other, stop_revision=None, overwrite=False,
1005
946
                         graph=None):
1006
947
        """Pull in new perfect-fit revisions.
1055
996
            self._extend_partial_history(distance_from_last)
1056
997
        return self._partial_revision_history_cache[distance_from_last]
1057
998
 
 
999
    @needs_write_lock
1058
1000
    def pull(self, source, overwrite=False, stop_revision=None,
1059
1001
             possible_transports=None, *args, **kwargs):
1060
1002
        """Mirror source into this branch.
1118
1060
        try:
1119
1061
            return urlutils.join(self.base[:-1], parent)
1120
1062
        except errors.InvalidURLJoin, e:
1121
 
            raise errors.InaccessibleParent(parent, self.user_url)
 
1063
            raise errors.InaccessibleParent(parent, self.base)
1122
1064
 
1123
1065
    def _get_parent_location(self):
1124
1066
        raise NotImplementedError(self._get_parent_location)
1303
1245
                revno = 1
1304
1246
        destination.set_last_revision_info(revno, revision_id)
1305
1247
 
 
1248
    @needs_read_lock
1306
1249
    def copy_content_into(self, destination, revision_id=None):
1307
1250
        """Copy the content of self into destination.
1308
1251
 
1309
1252
        revision_id: if not None, the revision history in the new branch will
1310
1253
                     be truncated to end with revision_id.
1311
1254
        """
1312
 
        return InterBranch.get(self, destination).copy_content_into(
1313
 
            revision_id=revision_id)
 
1255
        self.update_references(destination)
 
1256
        self._synchronize_history(destination, revision_id)
 
1257
        try:
 
1258
            parent = self.get_parent()
 
1259
        except errors.InaccessibleParent, e:
 
1260
            mutter('parent was not accessible to copy: %s', e)
 
1261
        else:
 
1262
            if parent:
 
1263
                destination.set_parent(parent)
 
1264
        if self._push_should_merge_tags():
 
1265
            self.tags.merge_to(destination.tags)
1314
1266
 
1315
1267
    def update_references(self, target):
1316
1268
        if not getattr(self._format, 'supports_reference_locations', False):
1384
1336
        """
1385
1337
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1386
1338
        # clone call. Or something. 20090224 RBC/spiv.
1387
 
        # XXX: Should this perhaps clone colocated branches as well, 
1388
 
        # rather than just the default branch? 20100319 JRV
1389
1339
        if revision_id is None:
1390
1340
            revision_id = self.last_revision()
1391
1341
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1550
1500
        try:
1551
1501
            transport = a_bzrdir.get_branch_transport(None, name=name)
1552
1502
            format_string = transport.get_bytes("format")
1553
 
            format = klass._formats[format_string]
1554
 
            if isinstance(format, MetaDirBranchFormatFactory):
1555
 
                return format()
1556
 
            return format
 
1503
            return klass._formats[format_string]
1557
1504
        except errors.NoSuchFile:
1558
1505
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1559
1506
        except KeyError:
1564
1511
        """Return the current default format."""
1565
1512
        return klass._default_format
1566
1513
 
1567
 
    @classmethod
1568
 
    def get_formats(klass):
1569
 
        """Get all the known formats.
1570
 
 
1571
 
        Warning: This triggers a load of all lazy registered formats: do not
1572
 
        use except when that is desireed.
1573
 
        """
1574
 
        result = []
1575
 
        for fmt in klass._formats.values():
1576
 
            if isinstance(fmt, MetaDirBranchFormatFactory):
1577
 
                fmt = fmt()
1578
 
            result.append(fmt)
1579
 
        return result
1580
 
 
1581
 
    def get_reference(self, a_bzrdir, name=None):
 
1514
    def get_reference(self, a_bzrdir):
1582
1515
        """Get the target reference of the branch in a_bzrdir.
1583
1516
 
1584
1517
        format probing must have been completed before calling
1586
1519
        in a_bzrdir is correct.
1587
1520
 
1588
1521
        :param a_bzrdir: The bzrdir to get the branch data from.
1589
 
        :param name: Name of the colocated branch to fetch
1590
1522
        :return: None if the branch is not a reference branch.
1591
1523
        """
1592
1524
        return None
1593
1525
 
1594
1526
    @classmethod
1595
 
    def set_reference(self, a_bzrdir, name, to_branch):
 
1527
    def set_reference(self, a_bzrdir, to_branch):
1596
1528
        """Set the target reference of the branch in a_bzrdir.
1597
1529
 
1598
1530
        format probing must have been completed before calling
1600
1532
        in a_bzrdir is correct.
1601
1533
 
1602
1534
        :param a_bzrdir: The bzrdir to set the branch reference for.
1603
 
        :param name: Name of colocated branch to set, None for default
1604
1535
        :param to_branch: branch that the checkout is to reference
1605
1536
        """
1606
1537
        raise NotImplementedError(self.set_reference)
1613
1544
        """Return the short format description for this format."""
1614
1545
        raise NotImplementedError(self.get_format_description)
1615
1546
 
1616
 
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1617
 
        hooks = Branch.hooks['post_branch_init']
1618
 
        if not hooks:
1619
 
            return
1620
 
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
1621
 
        for hook in hooks:
1622
 
            hook(params)
1623
 
 
1624
1547
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1625
1548
                           lock_type='metadir', set_format=True):
1626
1549
        """Initialize a branch in a bzrdir, with specified files
1634
1557
            elsewhere)
1635
1558
        :return: a branch in this format
1636
1559
        """
1637
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
 
1560
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1638
1561
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1639
1562
        lock_map = {
1640
1563
            'metadir': ('lock', lockdir.LockDir),
1662
1585
        finally:
1663
1586
            if lock_taken:
1664
1587
                control_files.unlock()
1665
 
        branch = self.open(a_bzrdir, name, _found=True)
1666
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1667
 
        return branch
 
1588
        return self.open(a_bzrdir, name, _found=True)
1668
1589
 
1669
1590
    def initialize(self, a_bzrdir, name=None):
1670
1591
        """Create a branch of this format in a_bzrdir.
1720
1641
 
1721
1642
    @classmethod
1722
1643
    def register_format(klass, format):
1723
 
        """Register a metadir format.
1724
 
        
1725
 
        See MetaDirBranchFormatFactory for the ability to register a format
1726
 
        without loading the code the format needs until it is actually used.
1727
 
        """
 
1644
        """Register a metadir format."""
1728
1645
        klass._formats[format.get_format_string()] = format
1729
1646
        # Metadir formats have a network name of their format string, and get
1730
 
        # registered as factories.
1731
 
        if isinstance(format, MetaDirBranchFormatFactory):
1732
 
            network_format_registry.register(format.get_format_string(), format)
1733
 
        else:
1734
 
            network_format_registry.register(format.get_format_string(),
1735
 
                format.__class__)
 
1647
        # registered as class factories.
 
1648
        network_format_registry.register(format.get_format_string(), format.__class__)
1736
1649
 
1737
1650
    @classmethod
1738
1651
    def set_default_format(klass, format):
1758
1671
        return False  # by default
1759
1672
 
1760
1673
 
1761
 
class MetaDirBranchFormatFactory(registry._LazyObjectGetter):
1762
 
    """A factory for a BranchFormat object, permitting simple lazy registration.
1763
 
    
1764
 
    While none of the built in BranchFormats are lazy registered yet,
1765
 
    bzrlib.tests.test_branch.TestMetaDirBranchFormatFactory demonstrates how to
1766
 
    use it, and the bzr-loom plugin uses it as well (see
1767
 
    bzrlib.plugins.loom.formats).
1768
 
    """
1769
 
 
1770
 
    def __init__(self, format_string, module_name, member_name):
1771
 
        """Create a MetaDirBranchFormatFactory.
1772
 
 
1773
 
        :param format_string: The format string the format has.
1774
 
        :param module_name: Module to load the format class from.
1775
 
        :param member_name: Attribute name within the module for the format class.
1776
 
        """
1777
 
        registry._LazyObjectGetter.__init__(self, module_name, member_name)
1778
 
        self._format_string = format_string
1779
 
        
1780
 
    def get_format_string(self):
1781
 
        """See BranchFormat.get_format_string."""
1782
 
        return self._format_string
1783
 
 
1784
 
    def __call__(self):
1785
 
        """Used for network_format_registry support."""
1786
 
        return self.get_obj()()
1787
 
 
1788
 
 
1789
1674
class BranchHooks(Hooks):
1790
1675
    """A dictionary mapping hook name to a list of callables for branch hooks.
1791
1676
 
1866
1751
            "should return a tag name or None if no tag name could be "
1867
1752
            "determined. The first non-None tag name returned will be used.",
1868
1753
            (2, 2), None))
1869
 
        self.create_hook(HookPoint('post_branch_init',
1870
 
            "Called after new branch initialization completes. "
1871
 
            "post_branch_init is called with a "
1872
 
            "bzrlib.branch.BranchInitHookParams. "
1873
 
            "Note that init, branch and checkout (both heavyweight and "
1874
 
            "lightweight) will all trigger this hook.", (2, 2), None))
1875
 
        self.create_hook(HookPoint('post_switch',
1876
 
            "Called after a checkout switches branch. "
1877
 
            "post_switch is called with a "
1878
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1879
1754
 
1880
1755
 
1881
1756
 
1921
1796
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1922
1797
 
1923
1798
 
1924
 
class BranchInitHookParams(object):
1925
 
    """Object holding parameters passed to *_branch_init hooks.
1926
 
 
1927
 
    There are 4 fields that hooks may wish to access:
1928
 
 
1929
 
    :ivar format: the branch format
1930
 
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
1931
 
    :ivar name: name of colocated branch, if any (or None)
1932
 
    :ivar branch: the branch created
1933
 
 
1934
 
    Note that for lightweight checkouts, the bzrdir and format fields refer to
1935
 
    the checkout, hence they are different from the corresponding fields in
1936
 
    branch, which refer to the original branch.
1937
 
    """
1938
 
 
1939
 
    def __init__(self, format, a_bzrdir, name, branch):
1940
 
        """Create a group of BranchInitHook parameters.
1941
 
 
1942
 
        :param format: the branch format
1943
 
        :param a_bzrdir: the BzrDir where the branch will be/has been
1944
 
            initialized
1945
 
        :param name: name of colocated branch, if any (or None)
1946
 
        :param branch: the branch created
1947
 
 
1948
 
        Note that for lightweight checkouts, the bzrdir and format fields refer
1949
 
        to the checkout, hence they are different from the corresponding fields
1950
 
        in branch, which refer to the original branch.
1951
 
        """
1952
 
        self.format = format
1953
 
        self.bzrdir = a_bzrdir
1954
 
        self.name = name
1955
 
        self.branch = branch
1956
 
 
1957
 
    def __eq__(self, other):
1958
 
        return self.__dict__ == other.__dict__
1959
 
 
1960
 
    def __repr__(self):
1961
 
        if self.branch:
1962
 
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
1963
 
        else:
1964
 
            return "<%s of format:%s bzrdir:%s>" % (
1965
 
                self.__class__.__name__, self.branch,
1966
 
                self.format, self.bzrdir)
1967
 
 
1968
 
 
1969
 
class SwitchHookParams(object):
1970
 
    """Object holding parameters passed to *_switch hooks.
1971
 
 
1972
 
    There are 4 fields that hooks may wish to access:
1973
 
 
1974
 
    :ivar control_dir: BzrDir of the checkout to change
1975
 
    :ivar to_branch: branch that the checkout is to reference
1976
 
    :ivar force: skip the check for local commits in a heavy checkout
1977
 
    :ivar revision_id: revision ID to switch to (or None)
1978
 
    """
1979
 
 
1980
 
    def __init__(self, control_dir, to_branch, force, revision_id):
1981
 
        """Create a group of SwitchHook parameters.
1982
 
 
1983
 
        :param control_dir: BzrDir of the checkout to change
1984
 
        :param to_branch: branch that the checkout is to reference
1985
 
        :param force: skip the check for local commits in a heavy checkout
1986
 
        :param revision_id: revision ID to switch to (or None)
1987
 
        """
1988
 
        self.control_dir = control_dir
1989
 
        self.to_branch = to_branch
1990
 
        self.force = force
1991
 
        self.revision_id = revision_id
1992
 
 
1993
 
    def __eq__(self, other):
1994
 
        return self.__dict__ == other.__dict__
1995
 
 
1996
 
    def __repr__(self):
1997
 
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1998
 
            self.control_dir, self.to_branch,
1999
 
            self.revision_id)
2000
 
 
2001
 
 
2002
1799
class BzrBranchFormat4(BranchFormat):
2003
1800
    """Bzr branch format 4.
2004
1801
 
2063
1860
            if format.__class__ != self.__class__:
2064
1861
                raise AssertionError("wrong format %r found for %r" %
2065
1862
                    (format, self))
2066
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
2067
1863
        try:
 
1864
            transport = a_bzrdir.get_branch_transport(None, name=name)
2068
1865
            control_files = lockable_files.LockableFiles(transport, 'lock',
2069
1866
                                                         lockdir.LockDir)
2070
1867
            return self._branch_class()(_format=self,
2252
2049
        """See BranchFormat.get_format_description()."""
2253
2050
        return "Checkout reference format 1"
2254
2051
 
2255
 
    def get_reference(self, a_bzrdir, name=None):
 
2052
    def get_reference(self, a_bzrdir):
2256
2053
        """See BranchFormat.get_reference()."""
2257
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
 
2054
        transport = a_bzrdir.get_branch_transport(None)
2258
2055
        return transport.get_bytes('location')
2259
2056
 
2260
 
    def set_reference(self, a_bzrdir, name, to_branch):
 
2057
    def set_reference(self, a_bzrdir, to_branch):
2261
2058
        """See BranchFormat.set_reference()."""
2262
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
 
2059
        transport = a_bzrdir.get_branch_transport(None)
2263
2060
        location = transport.put_bytes('location', to_branch.base)
2264
2061
 
2265
2062
    def initialize(self, a_bzrdir, name=None, target_branch=None):
2268
2065
            # this format does not implement branch itself, thus the implicit
2269
2066
            # creation contract must see it as uninitializable
2270
2067
            raise errors.UninitializableFormat(self)
2271
 
        mutter('creating branch reference in %s', a_bzrdir.user_url)
 
2068
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
2272
2069
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2273
2070
        branch_transport.put_bytes('location',
2274
 
            target_branch.bzrdir.user_url)
 
2071
            target_branch.bzrdir.root_transport.base)
2275
2072
        branch_transport.put_bytes('format', self.get_format_string())
2276
 
        branch = self.open(
 
2073
        return self.open(
2277
2074
            a_bzrdir, name, _found=True,
2278
2075
            possible_transports=[target_branch.bzrdir.root_transport])
2279
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2280
 
        return branch
2281
2076
 
2282
2077
    def __init__(self):
2283
2078
        super(BranchReferenceFormat, self).__init__()
2316
2111
                raise AssertionError("wrong format %r found for %r" %
2317
2112
                    (format, self))
2318
2113
        if location is None:
2319
 
            location = self.get_reference(a_bzrdir, name)
 
2114
            location = self.get_reference(a_bzrdir)
2320
2115
        real_bzrdir = bzrdir.BzrDir.open(
2321
2116
            location, possible_transports=possible_transports)
2322
2117
        result = real_bzrdir.open_branch(name=name, 
2360
2155
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2361
2156
 
2362
2157
 
2363
 
class BranchWriteLockResult(LogicalLockResult):
2364
 
    """The result of write locking a branch.
2365
 
 
2366
 
    :ivar branch_token: The token obtained from the underlying branch lock, or
2367
 
        None.
2368
 
    :ivar unlock: A callable which will unlock the lock.
2369
 
    """
2370
 
 
2371
 
    def __init__(self, unlock, branch_token):
2372
 
        LogicalLockResult.__init__(self, unlock)
2373
 
        self.branch_token = branch_token
2374
 
 
2375
 
    def __repr__(self):
2376
 
        return "BranchWriteLockResult(%s, %s)" % (self.branch_token,
2377
 
            self.unlock)
2378
 
 
2379
 
 
2380
2158
class BzrBranch(Branch, _RelockDebugMixin):
2381
2159
    """A branch stored in the actual filesystem.
2382
2160
 
2416
2194
 
2417
2195
    def __str__(self):
2418
2196
        if self.name is None:
2419
 
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
 
2197
            return '%s(%r)' % (self.__class__.__name__, self.base)
2420
2198
        else:
2421
 
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2422
 
                self.name)
 
2199
            return '%s(%r,%r)' % (self.__class__.__name__, self.base, self.name)
2423
2200
 
2424
2201
    __repr__ = __str__
2425
2202
 
2436
2213
        return self.control_files.is_locked()
2437
2214
 
2438
2215
    def lock_write(self, token=None):
2439
 
        """Lock the branch for write operations.
2440
 
 
2441
 
        :param token: A token to permit reacquiring a previously held and
2442
 
            preserved lock.
2443
 
        :return: A BranchWriteLockResult.
2444
 
        """
2445
2216
        if not self.is_locked():
2446
2217
            self._note_lock('w')
2447
2218
        # All-in-one needs to always unlock/lock.
2453
2224
        else:
2454
2225
            took_lock = False
2455
2226
        try:
2456
 
            return BranchWriteLockResult(self.unlock,
2457
 
                self.control_files.lock_write(token=token))
 
2227
            return self.control_files.lock_write(token=token)
2458
2228
        except:
2459
2229
            if took_lock:
2460
2230
                self.repository.unlock()
2461
2231
            raise
2462
2232
 
2463
2233
    def lock_read(self):
2464
 
        """Lock the branch for read operations.
2465
 
 
2466
 
        :return: A bzrlib.lock.LogicalLockResult.
2467
 
        """
2468
2234
        if not self.is_locked():
2469
2235
            self._note_lock('r')
2470
2236
        # All-in-one needs to always unlock/lock.
2477
2243
            took_lock = False
2478
2244
        try:
2479
2245
            self.control_files.lock_read()
2480
 
            return LogicalLockResult(self.unlock)
2481
2246
        except:
2482
2247
            if took_lock:
2483
2248
                self.repository.unlock()
2652
2417
        return result
2653
2418
 
2654
2419
    def get_stacked_on_url(self):
2655
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
2420
        raise errors.UnstackableBranchFormat(self._format, self.base)
2656
2421
 
2657
2422
    def set_push_location(self, location):
2658
2423
        """See Branch.set_push_location."""
2848
2613
        if _mod_revision.is_null(last_revision):
2849
2614
            return
2850
2615
        if last_revision not in self._lefthand_history(revision_id):
2851
 
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
 
2616
            raise errors.AppendRevisionsOnlyViolation(self.base)
2852
2617
 
2853
2618
    def _gen_revision_history(self):
2854
2619
        """Generate the revision history from last revision
2954
2719
        if branch_location is None:
2955
2720
            return Branch.reference_parent(self, file_id, path,
2956
2721
                                           possible_transports)
2957
 
        branch_location = urlutils.join(self.user_url, branch_location)
 
2722
        branch_location = urlutils.join(self.base, branch_location)
2958
2723
        return Branch.open(branch_location,
2959
2724
                           possible_transports=possible_transports)
2960
2725
 
3006
2771
        return stacked_url
3007
2772
 
3008
2773
    def _get_append_revisions_only(self):
3009
 
        return self.get_config(
3010
 
            ).get_user_option_as_bool('append_revisions_only')
 
2774
        value = self.get_config().get_user_option('append_revisions_only')
 
2775
        return value == 'True'
3011
2776
 
3012
2777
    @needs_write_lock
3013
2778
    def generate_revision_history(self, revision_id, last_rev=None,
3075
2840
    """
3076
2841
 
3077
2842
    def get_stacked_on_url(self):
3078
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
2843
        raise errors.UnstackableBranchFormat(self._format, self.base)
3079
2844
 
3080
2845
 
3081
2846
######################################################################
3168
2933
        :param verbose: Requests more detailed display of what was checked,
3169
2934
            if any.
3170
2935
        """
3171
 
        note('checked branch %s format %s', self.branch.user_url,
 
2936
        note('checked branch %s format %s', self.branch.base,
3172
2937
            self.branch._format)
3173
2938
        for error in self.errors:
3174
2939
            note('found error:%s', error)
3269
3034
    _optimisers = []
3270
3035
    """The available optimised InterBranch types."""
3271
3036
 
3272
 
    @classmethod
3273
 
    def _get_branch_formats_to_test(klass):
3274
 
        """Return an iterable of format tuples for testing.
3275
 
        
3276
 
        :return: An iterable of (from_format, to_format) to use when testing
3277
 
            this InterBranch class. Each InterBranch class should define this
3278
 
            method itself.
3279
 
        """
3280
 
        raise NotImplementedError(klass._get_branch_formats_to_test)
 
3037
    @staticmethod
 
3038
    def _get_branch_formats_to_test():
 
3039
        """Return a tuple with the Branch formats to use when testing."""
 
3040
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
3281
3041
 
3282
 
    @needs_write_lock
3283
3042
    def pull(self, overwrite=False, stop_revision=None,
3284
3043
             possible_transports=None, local=False):
3285
3044
        """Mirror source into target branch.
3290
3049
        """
3291
3050
        raise NotImplementedError(self.pull)
3292
3051
 
3293
 
    @needs_write_lock
3294
3052
    def update_revisions(self, stop_revision=None, overwrite=False,
3295
3053
                         graph=None):
3296
3054
        """Pull in new perfect-fit revisions.
3304
3062
        """
3305
3063
        raise NotImplementedError(self.update_revisions)
3306
3064
 
3307
 
    @needs_write_lock
3308
3065
    def push(self, overwrite=False, stop_revision=None,
3309
3066
             _override_hook_source_branch=None):
3310
3067
        """Mirror the source branch into the target branch.
3315
3072
 
3316
3073
 
3317
3074
class GenericInterBranch(InterBranch):
3318
 
    """InterBranch implementation that uses public Branch functions."""
3319
 
 
3320
 
    @classmethod
3321
 
    def is_compatible(klass, source, target):
3322
 
        # GenericBranch uses the public API, so always compatible
3323
 
        return True
3324
 
 
3325
 
    @classmethod
3326
 
    def _get_branch_formats_to_test(klass):
3327
 
        return [(BranchFormat._default_format, BranchFormat._default_format)]
3328
 
 
3329
 
    @classmethod
3330
 
    def unwrap_format(klass, format):
3331
 
        if isinstance(format, remote.RemoteBranchFormat):
3332
 
            format._ensure_real()
3333
 
            return format._custom_format
3334
 
        return format                                                                                                  
3335
 
 
3336
 
    @needs_write_lock
3337
 
    def copy_content_into(self, revision_id=None):
3338
 
        """Copy the content of source into target
3339
 
 
3340
 
        revision_id: if not None, the revision history in the new branch will
3341
 
                     be truncated to end with revision_id.
3342
 
        """
3343
 
        self.source.update_references(self.target)
3344
 
        self.source._synchronize_history(self.target, revision_id)
3345
 
        try:
3346
 
            parent = self.source.get_parent()
3347
 
        except errors.InaccessibleParent, e:
3348
 
            mutter('parent was not accessible to copy: %s', e)
3349
 
        else:
3350
 
            if parent:
3351
 
                self.target.set_parent(parent)
3352
 
        if self.source._push_should_merge_tags():
3353
 
            self.source.tags.merge_to(self.target.tags)
3354
 
 
3355
 
    @needs_write_lock
 
3075
    """InterBranch implementation that uses public Branch functions.
 
3076
    """
 
3077
 
 
3078
    @staticmethod
 
3079
    def _get_branch_formats_to_test():
 
3080
        return BranchFormat._default_format, BranchFormat._default_format
 
3081
 
3356
3082
    def update_revisions(self, stop_revision=None, overwrite=False,
3357
3083
        graph=None):
3358
3084
        """See InterBranch.update_revisions()."""
3359
 
        other_revno, other_last_revision = self.source.last_revision_info()
3360
 
        stop_revno = None # unknown
3361
 
        if stop_revision is None:
3362
 
            stop_revision = other_last_revision
3363
 
            if _mod_revision.is_null(stop_revision):
3364
 
                # if there are no commits, we're done.
3365
 
                return
3366
 
            stop_revno = other_revno
3367
 
 
3368
 
        # what's the current last revision, before we fetch [and change it
3369
 
        # possibly]
3370
 
        last_rev = _mod_revision.ensure_null(self.target.last_revision())
3371
 
        # we fetch here so that we don't process data twice in the common
3372
 
        # case of having something to pull, and so that the check for
3373
 
        # already merged can operate on the just fetched graph, which will
3374
 
        # be cached in memory.
3375
 
        self.target.fetch(self.source, stop_revision)
3376
 
        # Check to see if one is an ancestor of the other
3377
 
        if not overwrite:
3378
 
            if graph is None:
3379
 
                graph = self.target.repository.get_graph()
3380
 
            if self.target._check_if_descendant_or_diverged(
3381
 
                    stop_revision, last_rev, graph, self.source):
3382
 
                # stop_revision is a descendant of last_rev, but we aren't
3383
 
                # overwriting, so we're done.
3384
 
                return
3385
 
        if stop_revno is None:
3386
 
            if graph is None:
3387
 
                graph = self.target.repository.get_graph()
3388
 
            this_revno, this_last_revision = \
3389
 
                    self.target.last_revision_info()
3390
 
            stop_revno = graph.find_distance_to_null(stop_revision,
3391
 
                            [(other_last_revision, other_revno),
3392
 
                             (this_last_revision, this_revno)])
3393
 
        self.target.set_last_revision_info(stop_revno, stop_revision)
3394
 
 
3395
 
    @needs_write_lock
 
3085
        self.source.lock_read()
 
3086
        try:
 
3087
            other_revno, other_last_revision = self.source.last_revision_info()
 
3088
            stop_revno = None # unknown
 
3089
            if stop_revision is None:
 
3090
                stop_revision = other_last_revision
 
3091
                if _mod_revision.is_null(stop_revision):
 
3092
                    # if there are no commits, we're done.
 
3093
                    return
 
3094
                stop_revno = other_revno
 
3095
 
 
3096
            # what's the current last revision, before we fetch [and change it
 
3097
            # possibly]
 
3098
            last_rev = _mod_revision.ensure_null(self.target.last_revision())
 
3099
            # we fetch here so that we don't process data twice in the common
 
3100
            # case of having something to pull, and so that the check for
 
3101
            # already merged can operate on the just fetched graph, which will
 
3102
            # be cached in memory.
 
3103
            self.target.fetch(self.source, stop_revision)
 
3104
            # Check to see if one is an ancestor of the other
 
3105
            if not overwrite:
 
3106
                if graph is None:
 
3107
                    graph = self.target.repository.get_graph()
 
3108
                if self.target._check_if_descendant_or_diverged(
 
3109
                        stop_revision, last_rev, graph, self.source):
 
3110
                    # stop_revision is a descendant of last_rev, but we aren't
 
3111
                    # overwriting, so we're done.
 
3112
                    return
 
3113
            if stop_revno is None:
 
3114
                if graph is None:
 
3115
                    graph = self.target.repository.get_graph()
 
3116
                this_revno, this_last_revision = \
 
3117
                        self.target.last_revision_info()
 
3118
                stop_revno = graph.find_distance_to_null(stop_revision,
 
3119
                                [(other_last_revision, other_revno),
 
3120
                                 (this_last_revision, this_revno)])
 
3121
            self.target.set_last_revision_info(stop_revno, stop_revision)
 
3122
        finally:
 
3123
            self.source.unlock()
 
3124
 
3396
3125
    def pull(self, overwrite=False, stop_revision=None,
3397
 
             possible_transports=None, run_hooks=True,
 
3126
             possible_transports=None, _hook_master=None, run_hooks=True,
3398
3127
             _override_hook_target=None, local=False):
3399
 
        """Pull from source into self, updating my master if any.
 
3128
        """See Branch.pull.
3400
3129
 
 
3130
        :param _hook_master: Private parameter - set the branch to
 
3131
            be supplied as the master to pull hooks.
3401
3132
        :param run_hooks: Private parameter - if false, this branch
3402
3133
            is being called because it's the master of the primary branch,
3403
3134
            so it should not run its hooks.
 
3135
        :param _override_hook_target: Private parameter - set the branch to be
 
3136
            supplied as the target_branch to pull hooks.
 
3137
        :param local: Only update the local branch, and not the bound branch.
3404
3138
        """
3405
 
        bound_location = self.target.get_bound_location()
3406
 
        if local and not bound_location:
 
3139
        # This type of branch can't be bound.
 
3140
        if local:
3407
3141
            raise errors.LocalRequiresBoundBranch()
3408
 
        master_branch = None
3409
 
        if not local and bound_location and self.source.user_url != bound_location:
3410
 
            # not pulling from master, so we need to update master.
3411
 
            master_branch = self.target.get_master_branch(possible_transports)
3412
 
            master_branch.lock_write()
 
3142
        result = PullResult()
 
3143
        result.source_branch = self.source
 
3144
        if _override_hook_target is None:
 
3145
            result.target_branch = self.target
 
3146
        else:
 
3147
            result.target_branch = _override_hook_target
 
3148
        self.source.lock_read()
3413
3149
        try:
3414
 
            if master_branch:
3415
 
                # pull from source into master.
3416
 
                master_branch.pull(self.source, overwrite, stop_revision,
3417
 
                    run_hooks=False)
3418
 
            return self._pull(overwrite,
3419
 
                stop_revision, _hook_master=master_branch,
3420
 
                run_hooks=run_hooks,
3421
 
                _override_hook_target=_override_hook_target)
 
3150
            # We assume that during 'pull' the target repository is closer than
 
3151
            # the source one.
 
3152
            self.source.update_references(self.target)
 
3153
            graph = self.target.repository.get_graph(self.source.repository)
 
3154
            # TODO: Branch formats should have a flag that indicates 
 
3155
            # that revno's are expensive, and pull() should honor that flag.
 
3156
            # -- JRV20090506
 
3157
            result.old_revno, result.old_revid = \
 
3158
                self.target.last_revision_info()
 
3159
            self.target.update_revisions(self.source, stop_revision,
 
3160
                overwrite=overwrite, graph=graph)
 
3161
            # TODO: The old revid should be specified when merging tags, 
 
3162
            # so a tags implementation that versions tags can only 
 
3163
            # pull in the most recent changes. -- JRV20090506
 
3164
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
3165
                overwrite)
 
3166
            result.new_revno, result.new_revid = self.target.last_revision_info()
 
3167
            if _hook_master:
 
3168
                result.master_branch = _hook_master
 
3169
                result.local_branch = result.target_branch
 
3170
            else:
 
3171
                result.master_branch = result.target_branch
 
3172
                result.local_branch = None
 
3173
            if run_hooks:
 
3174
                for hook in Branch.hooks['post_pull']:
 
3175
                    hook(result)
3422
3176
        finally:
3423
 
            if master_branch:
3424
 
                master_branch.unlock()
 
3177
            self.source.unlock()
 
3178
        return result
3425
3179
 
3426
3180
    def push(self, overwrite=False, stop_revision=None,
3427
3181
             _override_hook_source_branch=None):
3489
3243
            _run_hooks()
3490
3244
            return result
3491
3245
 
3492
 
    def _pull(self, overwrite=False, stop_revision=None,
3493
 
             possible_transports=None, _hook_master=None, run_hooks=True,
 
3246
    @classmethod
 
3247
    def is_compatible(self, source, target):
 
3248
        # GenericBranch uses the public API, so always compatible
 
3249
        return True
 
3250
 
 
3251
 
 
3252
class InterToBranch5(GenericInterBranch):
 
3253
 
 
3254
    @staticmethod
 
3255
    def _get_branch_formats_to_test():
 
3256
        return BranchFormat._default_format, BzrBranchFormat5()
 
3257
 
 
3258
    def pull(self, overwrite=False, stop_revision=None,
 
3259
             possible_transports=None, run_hooks=True,
3494
3260
             _override_hook_target=None, local=False):
3495
 
        """See Branch.pull.
3496
 
 
3497
 
        This function is the core worker, used by GenericInterBranch.pull to
3498
 
        avoid duplication when pulling source->master and source->local.
3499
 
 
3500
 
        :param _hook_master: Private parameter - set the branch to
3501
 
            be supplied as the master to pull hooks.
 
3261
        """Pull from source into self, updating my master if any.
 
3262
 
3502
3263
        :param run_hooks: Private parameter - if false, this branch
3503
3264
            is being called because it's the master of the primary branch,
3504
3265
            so it should not run its hooks.
3505
 
        :param _override_hook_target: Private parameter - set the branch to be
3506
 
            supplied as the target_branch to pull hooks.
3507
 
        :param local: Only update the local branch, and not the bound branch.
3508
3266
        """
3509
 
        # This type of branch can't be bound.
3510
 
        if local:
 
3267
        bound_location = self.target.get_bound_location()
 
3268
        if local and not bound_location:
3511
3269
            raise errors.LocalRequiresBoundBranch()
3512
 
        result = PullResult()
3513
 
        result.source_branch = self.source
3514
 
        if _override_hook_target is None:
3515
 
            result.target_branch = self.target
3516
 
        else:
3517
 
            result.target_branch = _override_hook_target
3518
 
        self.source.lock_read()
 
3270
        master_branch = None
 
3271
        if not local and bound_location and self.source.base != bound_location:
 
3272
            # not pulling from master, so we need to update master.
 
3273
            master_branch = self.target.get_master_branch(possible_transports)
 
3274
            master_branch.lock_write()
3519
3275
        try:
3520
 
            # We assume that during 'pull' the target repository is closer than
3521
 
            # the source one.
3522
 
            self.source.update_references(self.target)
3523
 
            graph = self.target.repository.get_graph(self.source.repository)
3524
 
            # TODO: Branch formats should have a flag that indicates 
3525
 
            # that revno's are expensive, and pull() should honor that flag.
3526
 
            # -- JRV20090506
3527
 
            result.old_revno, result.old_revid = \
3528
 
                self.target.last_revision_info()
3529
 
            self.target.update_revisions(self.source, stop_revision,
3530
 
                overwrite=overwrite, graph=graph)
3531
 
            # TODO: The old revid should be specified when merging tags, 
3532
 
            # so a tags implementation that versions tags can only 
3533
 
            # pull in the most recent changes. -- JRV20090506
3534
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3535
 
                overwrite)
3536
 
            result.new_revno, result.new_revid = self.target.last_revision_info()
3537
 
            if _hook_master:
3538
 
                result.master_branch = _hook_master
3539
 
                result.local_branch = result.target_branch
3540
 
            else:
3541
 
                result.master_branch = result.target_branch
3542
 
                result.local_branch = None
3543
 
            if run_hooks:
3544
 
                for hook in Branch.hooks['post_pull']:
3545
 
                    hook(result)
 
3276
            if master_branch:
 
3277
                # pull from source into master.
 
3278
                master_branch.pull(self.source, overwrite, stop_revision,
 
3279
                    run_hooks=False)
 
3280
            return super(InterToBranch5, self).pull(overwrite,
 
3281
                stop_revision, _hook_master=master_branch,
 
3282
                run_hooks=run_hooks,
 
3283
                _override_hook_target=_override_hook_target)
3546
3284
        finally:
3547
 
            self.source.unlock()
3548
 
        return result
 
3285
            if master_branch:
 
3286
                master_branch.unlock()
3549
3287
 
3550
3288
 
3551
3289
InterBranch.register_optimiser(GenericInterBranch)
 
3290
InterBranch.register_optimiser(InterToBranch5)