← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/switch.py

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/switch.py
1
 
# Copyright (C) 2007, 2009-2012 Canonical Ltd.
 
1
# Copyright (C) 2006, 2007 Canonical Ltd.
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
from __future__ import absolute_import
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
19
17
# Original author: David Allouche
20
18
 
21
 
from bzrlib import (
22
 
    errors,
23
 
    lock,
24
 
    merge,
25
 
    revision
26
 
    )
27
 
from bzrlib.branch import Branch
28
 
from bzrlib.i18n import gettext
 
19
from bzrlib import errors, merge
 
20
from bzrlib.branch import Branch, BranchFormat, BranchReferenceFormat
 
21
from bzrlib.bzrdir import BzrDir
29
22
from bzrlib.trace import note
30
23
 
31
 
def _run_post_switch_hooks(control_dir, to_branch, force, revision_id):
32
 
    from bzrlib.branch import SwitchHookParams
33
 
    hooks = Branch.hooks['post_switch']
34
 
    if not hooks:
35
 
        return
36
 
    params = SwitchHookParams(control_dir, to_branch, force, revision_id)
37
 
    for hook in hooks:
38
 
        hook(params)
39
24
 
40
 
def switch(control_dir, to_branch, force=False, quiet=False, revision_id=None,
41
 
           store_uncommitted=False):
 
25
def switch(control_dir, to_branch):
42
26
    """Switch the branch associated with a checkout.
43
27
 
44
 
    :param control_dir: ControlDir of the checkout to change
 
28
    :param control_dir: BzrDir of the checkout to change
45
29
    :param to_branch: branch that the checkout is to reference
46
 
    :param force: skip the check for local commits in a heavy checkout
47
 
    :param revision_id: revision ID to switch to.
48
 
    :param store_uncommitted: If True, store uncommitted changes in the
49
 
        branch.
50
30
    """
51
 
    _check_pending_merges(control_dir, force)
 
31
    _check_switch_branch_format(control_dir)
 
32
    _check_pending_merges(control_dir)
52
33
    try:
53
34
        source_repository = control_dir.open_branch().repository
54
35
    except errors.NotBranchError:
55
36
        source_repository = to_branch.repository
56
 
    if store_uncommitted:
57
 
        with lock.write_locked(control_dir.open_workingtree()) as tree:
58
 
            tree.store_uncommitted()
59
 
    to_branch.lock_read()
60
 
    try:
61
 
        _set_branch_location(control_dir, to_branch, force)
62
 
    finally:
63
 
        to_branch.unlock()
 
37
    _set_branch_location(control_dir, to_branch)
64
38
    tree = control_dir.open_workingtree()
65
 
    _update(tree, source_repository, quiet, revision_id, store_uncommitted)
66
 
    _run_post_switch_hooks(control_dir, to_branch, force, revision_id)
67
 
 
68
 
def _check_pending_merges(control, force=False):
 
39
    _update(tree, source_repository)
 
40
 
 
41
 
 
42
def _check_switch_branch_format(control):
 
43
    """Check that the branch format supports the switch operation.
 
44
 
 
45
    Note: Only lightweight checkouts are currently supported.
 
46
    This may change in the future though.
 
47
 
 
48
    :param control: BzrDir of the branch to check
 
49
    """
 
50
    branch_format = BranchFormat.find_format(control)
 
51
    format_string = branch_format.get_format_string()
 
52
    if not format_string.startswith("Bazaar-NG Branch Reference Format "):
 
53
        raise errors.BzrCommandError(
 
54
            'The switch command can only be used on a lightweight checkout.\n'
 
55
            'Expected branch reference, found %s at %s' % (
 
56
            format_string.strip(), control.root_transport.base))
 
57
    if not format_string == BranchReferenceFormat().get_format_string():
 
58
        raise errors.BzrCommandError(
 
59
            'Unsupported: %r' % (format_string.strip(),))        
 
60
 
 
61
 
 
62
def _check_pending_merges(control):
69
63
    """Check that there are no outstanding pending merges before switching.
70
64
 
71
 
    :param control: ControlDir of the branch to check
 
65
    :param control: BzrDir of the branch to check
72
66
    """
73
67
    try:
74
68
        tree = control.open_workingtree()
75
 
    except errors.NotBranchError, ex:
76
 
        # Lightweight checkout and branch is no longer there
77
 
        if force:
78
 
            return
79
 
        else:
80
 
            raise ex
 
69
    except errors.NotBranchError:
 
70
        # old branch is gone
 
71
        return
81
72
    # XXX: Should the tree be locked for get_parent_ids?
82
73
    existing_pending_merges = tree.get_parent_ids()[1:]
83
74
    if len(existing_pending_merges) > 0:
84
 
        raise errors.BzrCommandError(gettext('Pending merges must be '
85
 
            'committed or reverted before using switch.'))
86
 
 
87
 
 
88
 
def _set_branch_location(control, to_branch, force=False):
 
75
        raise errors.BzrCommandError('Pending merges must be '
 
76
            'committed or reverted before using switch.')
 
77
 
 
78
 
 
79
def _set_branch_location(control, to_branch):
89
80
    """Set location value of a branch reference.
90
81
 
91
 
    :param control: ControlDir of the checkout to change
 
82
    :param control: BzrDir of the checkout to change
92
83
    :param to_branch: branch that the checkout is to reference
93
 
    :param force: skip the check for local commits in a heavy checkout
94
84
    """
95
 
    branch_format = control.find_branch_format()
96
 
    if branch_format.get_reference(control) is not None:
97
 
        # Lightweight checkout: update the branch reference
98
 
        branch_format.set_reference(control, None, to_branch)
99
 
    else:
100
 
        b = control.open_branch()
101
 
        bound_branch = b.get_bound_location()
102
 
        if bound_branch is not None:
103
 
            # Heavyweight checkout: check all local commits
104
 
            # have been pushed to the current bound branch then
105
 
            # synchronise the local branch with the new remote branch
106
 
            # and bind to it
107
 
            possible_transports = []
108
 
            try:
109
 
                if not force and _any_local_commits(b, possible_transports):
110
 
                    raise errors.BzrCommandError(gettext(
111
 
                        'Cannot switch as local commits found in the checkout. '
112
 
                        'Commit these to the bound branch or use --force to '
113
 
                        'throw them away.'))
114
 
            except errors.BoundBranchConnectionFailure, e:
115
 
                raise errors.BzrCommandError(gettext(
116
 
                        'Unable to connect to current master branch %(target)s: '
117
 
                        '%(error)s To switch anyway, use --force.') %
118
 
                        e.__dict__)
119
 
            b.lock_write()
120
 
            try:
121
 
                b.set_bound_location(None)
122
 
                b.pull(to_branch, overwrite=True,
123
 
                       possible_transports=possible_transports)
124
 
                b.set_bound_location(to_branch.base)
125
 
                b.set_parent(b.get_master_branch().get_parent())
126
 
            finally:
127
 
                b.unlock()
128
 
        else:
129
 
            # If this is a standalone tree and the new branch
130
 
            # is derived from this one, create a lightweight checkout.
131
 
            b.lock_read()
132
 
            try:
133
 
                graph = b.repository.get_graph(to_branch.repository)
134
 
                if (b.bzrdir._format.colocated_branches and
135
 
                     (force or graph.is_ancestor(b.last_revision(),
136
 
                        to_branch.last_revision()))):
137
 
                    b.bzrdir.destroy_branch()
138
 
                    b.bzrdir.set_branch_reference(to_branch, name="")
139
 
                else:
140
 
                    raise errors.BzrCommandError(gettext('Cannot switch a branch, '
141
 
                        'only a checkout.'))
142
 
            finally:
143
 
                b.unlock()
144
 
 
145
 
 
146
 
def _any_local_commits(this_branch, possible_transports):
147
 
    """Does this branch have any commits not in the master branch?"""
148
 
    last_rev = revision.ensure_null(this_branch.last_revision())
149
 
    if last_rev != revision.NULL_REVISION:
150
 
        other_branch = this_branch.get_master_branch(possible_transports)
151
 
        this_branch.lock_read()
152
 
        other_branch.lock_read()
153
 
        try:
154
 
            other_last_rev = other_branch.last_revision()
155
 
            graph = this_branch.repository.get_graph(
156
 
                other_branch.repository)
157
 
            if not graph.is_ancestor(last_rev, other_last_rev):
158
 
                return True
159
 
        finally:
160
 
            other_branch.unlock()
161
 
            this_branch.unlock()
162
 
    return False
163
 
 
164
 
 
165
 
def _update(tree, source_repository, quiet=False, revision_id=None,
166
 
            restore_uncommitted=False):
 
85
    transport = control.get_branch_transport(None)
 
86
    location = transport.put_bytes('location', to_branch.base)
 
87
 
 
88
 
 
89
def _update(tree, source_repository):
167
90
    """Update a working tree to the latest revision of its branch.
168
91
 
169
92
    :param tree: the working tree
170
93
    :param source_repository: repository holding the revisions
171
 
    :param restore_uncommitted: restore any uncommitted changes in the branch.
172
94
    """
173
 
    if restore_uncommitted:
174
 
        tree.lock_write()
175
 
    else:
176
 
        tree.lock_tree_write()
 
95
    tree.lock_tree_write()
177
96
    try:
178
97
        to_branch = tree.branch
179
 
        if revision_id is None:
180
 
            revision_id = to_branch.last_revision()
181
 
        if tree.last_revision() == revision_id:
182
 
            if not quiet:
183
 
                note(gettext("Tree is up to date at revision %d."), to_branch.revno())
184
 
        else:
185
 
            base_tree = source_repository.revision_tree(tree.last_revision())
186
 
            merge.Merge3Merger(tree, tree, base_tree,
187
 
                               to_branch.repository.revision_tree(revision_id))
188
 
            tree.set_last_revision(to_branch.last_revision())
189
 
            if not quiet:
190
 
                note(gettext('Updated to revision %d.') % to_branch.revno())
191
 
        if restore_uncommitted:
192
 
            tree.restore_uncommitted()
 
98
        if tree.last_revision() == to_branch.last_revision():
 
99
            note("Tree is up to date at revision %d.", to_branch.revno())
 
100
            return
 
101
        base_tree = source_repository.revision_tree(tree.last_revision())
 
102
        merge.Merge3Merger(tree, tree, base_tree, to_branch.basis_tree())
 
103
        tree.set_last_revision(to_branch.last_revision())
 
104
        note('Updated to revision %d.' % to_branch.revno())
193
105
    finally:
194
106
        tree.unlock()