/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/switch.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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) 2007, 2009, 2010 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from __future__ import absolute_import
18
 
 
19
17
# Original author: David Allouche
20
18
 
21
 
from . import (
22
 
    errors,
23
 
    lock,
24
 
    merge,
25
 
    revision
26
 
    )
27
 
from .branch import Branch
28
 
from .i18n import gettext
29
 
from .trace import note
 
19
from bzrlib import errors, merge, revision
 
20
from bzrlib.branch import Branch
 
21
from bzrlib.trace import note
 
22
 
30
23
 
31
24
def _run_post_switch_hooks(control_dir, to_branch, force, revision_id):
32
 
    from .branch import SwitchHookParams
 
25
    from bzrlib.branch import SwitchHookParams
33
26
    hooks = Branch.hooks['post_switch']
34
27
    if not hooks:
35
28
        return
37
30
    for hook in hooks:
38
31
        hook(params)
39
32
 
40
 
def switch(control_dir, to_branch, force=False, quiet=False, revision_id=None,
41
 
           store_uncommitted=False):
 
33
def switch(control_dir, to_branch, force=False, quiet=False, revision_id=None):
42
34
    """Switch the branch associated with a checkout.
43
35
 
44
 
    :param control_dir: ControlDir of the checkout to change
 
36
    :param control_dir: BzrDir of the checkout to change
45
37
    :param to_branch: branch that the checkout is to reference
46
38
    :param force: skip the check for local commits in a heavy checkout
47
39
    :param revision_id: revision ID to switch to.
48
 
    :param store_uncommitted: If True, store uncommitted changes in the
49
 
        branch.
50
40
    """
51
41
    _check_pending_merges(control_dir, force)
52
42
    try:
53
43
        source_repository = control_dir.open_branch().repository
54
44
    except errors.NotBranchError:
55
45
        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
 
    with to_branch.lock_read():
60
 
        _set_branch_location(control_dir, to_branch, force)
 
46
    _set_branch_location(control_dir, to_branch, force)
61
47
    tree = control_dir.open_workingtree()
62
 
    _update(tree, source_repository, quiet, revision_id, store_uncommitted)
 
48
    _update(tree, source_repository, quiet, revision_id)
63
49
    _run_post_switch_hooks(control_dir, to_branch, force, revision_id)
64
50
 
65
51
def _check_pending_merges(control, force=False):
66
52
    """Check that there are no outstanding pending merges before switching.
67
53
 
68
 
    :param control: ControlDir of the branch to check
 
54
    :param control: BzrDir of the branch to check
69
55
    """
70
56
    try:
71
57
        tree = control.open_workingtree()
72
 
    except errors.NotBranchError as ex:
 
58
    except errors.NotBranchError, ex:
73
59
        # Lightweight checkout and branch is no longer there
74
60
        if force:
75
61
            return
78
64
    # XXX: Should the tree be locked for get_parent_ids?
79
65
    existing_pending_merges = tree.get_parent_ids()[1:]
80
66
    if len(existing_pending_merges) > 0:
81
 
        raise errors.BzrCommandError(gettext('Pending merges must be '
82
 
            'committed or reverted before using switch.'))
 
67
        raise errors.BzrCommandError('Pending merges must be '
 
68
            'committed or reverted before using switch.')
83
69
 
84
70
 
85
71
def _set_branch_location(control, to_branch, force=False):
86
72
    """Set location value of a branch reference.
87
73
 
88
 
    :param control: ControlDir of the checkout to change
 
74
    :param control: BzrDir of the checkout to change
89
75
    :param to_branch: branch that the checkout is to reference
90
76
    :param force: skip the check for local commits in a heavy checkout
91
77
    """
92
78
    branch_format = control.find_branch_format()
93
79
    if branch_format.get_reference(control) is not None:
94
80
        # Lightweight checkout: update the branch reference
95
 
        branch_format.set_reference(control, None, to_branch)
 
81
        branch_format.set_reference(control, to_branch)
96
82
    else:
97
83
        b = control.open_branch()
98
84
        bound_branch = b.get_bound_location()
104
90
            possible_transports = []
105
91
            try:
106
92
                if not force and _any_local_commits(b, possible_transports):
107
 
                    raise errors.BzrCommandError(gettext(
 
93
                    raise errors.BzrCommandError(
108
94
                        'Cannot switch as local commits found in the checkout. '
109
95
                        'Commit these to the bound branch or use --force to '
110
 
                        'throw them away.'))
111
 
            except errors.BoundBranchConnectionFailure as e:
112
 
                raise errors.BzrCommandError(gettext(
 
96
                        'throw them away.')
 
97
            except errors.BoundBranchConnectionFailure, e:
 
98
                raise errors.BzrCommandError(
113
99
                        'Unable to connect to current master branch %(target)s: '
114
 
                        '%(error)s To switch anyway, use --force.') %
 
100
                        '%(error)s To switch anyway, use --force.' %
115
101
                        e.__dict__)
116
 
            b.lock_write()
117
 
            try:
118
 
                b.set_bound_location(None)
119
 
                b.pull(to_branch, overwrite=True,
120
 
                       possible_transports=possible_transports)
121
 
                b.set_bound_location(to_branch.base)
122
 
                b.set_parent(b.get_master_branch().get_parent())
123
 
            finally:
124
 
                b.unlock()
 
102
            b.set_bound_location(None)
 
103
            b.pull(to_branch, overwrite=True,
 
104
                possible_transports=possible_transports)
 
105
            b.set_bound_location(to_branch.base)
125
106
        else:
126
 
            # If this is a standalone tree and the new branch
127
 
            # is derived from this one, create a lightweight checkout.
128
 
            with b.lock_read():
129
 
                graph = b.repository.get_graph(to_branch.repository)
130
 
                if (b.controldir._format.colocated_branches and
131
 
                     (force or graph.is_ancestor(b.last_revision(),
132
 
                        to_branch.last_revision()))):
133
 
                    b.controldir.destroy_branch()
134
 
                    b.controldir.set_branch_reference(to_branch, name="")
135
 
                else:
136
 
                    raise errors.BzrCommandError(gettext('Cannot switch a branch, '
137
 
                        'only a checkout.'))
 
107
            raise errors.BzrCommandError('Cannot switch a branch, '
 
108
                'only a checkout.')
138
109
 
139
110
 
140
111
def _any_local_commits(this_branch, possible_transports):
142
113
    last_rev = revision.ensure_null(this_branch.last_revision())
143
114
    if last_rev != revision.NULL_REVISION:
144
115
        other_branch = this_branch.get_master_branch(possible_transports)
145
 
        with this_branch.lock_read(), other_branch.lock_read():
 
116
        this_branch.lock_read()
 
117
        other_branch.lock_read()
 
118
        try:
146
119
            other_last_rev = other_branch.last_revision()
147
120
            graph = this_branch.repository.get_graph(
148
121
                other_branch.repository)
149
122
            if not graph.is_ancestor(last_rev, other_last_rev):
150
123
                return True
 
124
        finally:
 
125
            other_branch.unlock()
 
126
            this_branch.unlock()
151
127
    return False
152
128
 
153
129
 
154
 
def _update(tree, source_repository, quiet=False, revision_id=None,
155
 
            restore_uncommitted=False):
 
130
def _update(tree, source_repository, quiet=False, revision_id=None):
156
131
    """Update a working tree to the latest revision of its branch.
157
132
 
158
133
    :param tree: the working tree
159
134
    :param source_repository: repository holding the revisions
160
 
    :param restore_uncommitted: restore any uncommitted changes in the branch.
161
135
    """
162
 
    if restore_uncommitted:
163
 
        tree.lock_write()
164
 
    else:
165
 
        tree.lock_tree_write()
 
136
    tree.lock_tree_write()
166
137
    try:
167
138
        to_branch = tree.branch
168
139
        if revision_id is None:
169
140
            revision_id = to_branch.last_revision()
170
141
        if tree.last_revision() == revision_id:
171
142
            if not quiet:
172
 
                note(gettext("Tree is up to date at revision %d."), to_branch.revno())
173
 
        else:
174
 
            base_tree = source_repository.revision_tree(tree.last_revision())
175
 
            merge.Merge3Merger(tree, tree, base_tree,
176
 
                               to_branch.repository.revision_tree(revision_id))
177
 
            tree.set_last_revision(to_branch.last_revision())
178
 
            if not quiet:
179
 
                note(gettext('Updated to revision %d.') % to_branch.revno())
180
 
        if restore_uncommitted:
181
 
            tree.restore_uncommitted()
 
143
                note("Tree is up to date at revision %d.", to_branch.revno())
 
144
            return
 
145
        base_tree = source_repository.revision_tree(tree.last_revision())
 
146
        merge.Merge3Merger(tree, tree, base_tree, to_branch.repository.revision_tree(revision_id))
 
147
        tree.set_last_revision(to_branch.last_revision())
 
148
        if not quiet:
 
149
            note('Updated to revision %d.' % to_branch.revno())
182
150
    finally:
183
151
        tree.unlock()