/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: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

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