← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/push.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/push.py
1
 
# Copyright (C) 2008 Canonical Ltd
 
1
# Copyright (C) 2008, 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
16
16
 
17
17
"""UI helper for the push command."""
18
18
 
19
 
from bzrlib import (builtins, bzrdir, errors, revision as _mod_revision,
20
 
                    transport)
21
 
from bzrlib.trace import note, warning
 
19
from bzrlib import (
 
20
    bzrdir,
 
21
    errors,
 
22
    revision as _mod_revision,
 
23
    transport,
 
24
    )
 
25
from bzrlib.trace import (
 
26
    note,
 
27
    warning,
 
28
    )
22
29
 
23
30
 
24
31
class PushResult(object):
25
32
    """Result of a push operation.
26
33
 
27
34
    :ivar branch_push_result: Result of a push between branches
 
35
    :ivar target_branch: The target branch
28
36
    :ivar stacked_on: URL of the branch on which the result is stacked
 
37
    :ivar workingtree_updated: Whether or not the target workingtree was updated.
29
38
    """
30
39
 
31
40
    def __init__(self):
32
41
        self.branch_push_result = None
33
42
        self.stacked_on = None
 
43
        self.workingtree_updated = None
 
44
        self.target_branch = None
34
45
 
35
46
    def report(self, to_file):
36
47
        """Write a human-readable description of the result."""
66
77
        directory exists without a current .bzr directory in it
67
78
    """
68
79
    to_transport = transport.get_transport(location)
69
 
    br_to = repository_to = dir_to = None
70
80
    try:
71
81
        dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
72
82
    except errors.NotBranchError:
73
 
        pass # Didn't find anything
74
 
    else:
75
 
        # If we can open a branch, use its direct repository, otherwise see
76
 
        # if there is a repository without a branch.
77
 
        try:
78
 
            br_to = dir_to.open_branch()
79
 
        except errors.NotBranchError:
80
 
            # Didn't find a branch, can we find a repository?
81
 
            try:
82
 
                repository_to = dir_to.find_repository()
83
 
            except errors.NoRepositoryPresent:
84
 
                pass
85
 
        else:
86
 
            # Found a branch, so we must have found a repository
87
 
            repository_to = br_to.repository
 
83
        # Didn't find anything
 
84
        dir_to = None
88
85
 
89
 
    push_result = PushResult()
90
86
    if dir_to is None:
91
 
        # The destination doesn't exist; create it.
92
 
        # XXX: Refactor the create_prefix/no_create_prefix code into a
93
 
        #      common helper function
94
 
 
95
 
        def make_directory(transport):
96
 
            transport.mkdir('.')
97
 
            return transport
98
 
 
99
 
        def redirected(transport, e, redirection_notice):
100
 
            note(redirection_notice)
101
 
            return transport._redirected_to(e.source, e.target)
102
 
 
103
87
        try:
104
 
            to_transport = transport.do_catching_redirections(
105
 
                make_directory, to_transport, redirected)
106
 
        except errors.FileExists:
 
88
            br_to = br_from.create_clone_on_transport(to_transport,
 
89
                revision_id=revision_id, stacked_on=stacked_on,
 
90
                create_prefix=create_prefix, use_existing_dir=use_existing_dir)
 
91
        except errors.FileExists, err:
 
92
            if err.path.endswith('/.bzr'):
 
93
                raise errors.BzrCommandError(
 
94
                    "Target directory %s already contains a .bzr directory, "
 
95
                    "but it is not valid." % (location,))
107
96
            if not use_existing_dir:
108
97
                raise errors.BzrCommandError("Target directory %s"
109
 
                     " already exists, but does not have a valid .bzr"
 
98
                     " already exists, but does not have a .bzr"
110
99
                     " directory. Supply --use-existing-dir to push"
111
100
                     " there anyway." % location)
 
101
            # This shouldn't occur, but if it does the FileExists error will be
 
102
            # more informative than an UnboundLocalError for br_to.
 
103
            raise
112
104
        except errors.NoSuchFile:
113
105
            if not create_prefix:
114
106
                raise errors.BzrCommandError("Parent directory of %s"
116
108
                    "\nYou may supply --create-prefix to create all"
117
109
                    " leading parent directories."
118
110
                    % location)
119
 
            builtins._create_prefix(to_transport)
 
111
            # This shouldn't occur (because create_prefix is true, so
 
112
            # create_clone_on_transport should be catching NoSuchFile and
 
113
            # creating the missing directories) but if it does the original
 
114
            # NoSuchFile error will be more informative than an
 
115
            # UnboundLocalError for br_to.
 
116
            raise
120
117
        except errors.TooManyRedirections:
121
118
            raise errors.BzrCommandError("Too many redirections trying "
122
119
                                         "to make %s." % location)
123
 
 
124
 
        # Now the target directory exists, but doesn't have a .bzr
125
 
        # directory. So we need to create it, along with any work to create
126
 
        # all of the dependent branches, etc.
127
 
        br_to = br_from.create_clone_on_transport(to_transport,
128
 
            revision_id=revision_id, stacked_on=stacked_on)
 
120
        push_result = PushResult()
129
121
        # TODO: Some more useful message about what was copied
130
122
        try:
131
123
            push_result.stacked_on = br_to.get_stacked_on_url()
133
125
                errors.UnstackableRepositoryFormat,
134
126
                errors.NotStacked):
135
127
            push_result.stacked_on = None
136
 
        # We successfully created the target, remember it
 
128
        push_result.target_branch = br_to
 
129
        push_result.old_revid = _mod_revision.NULL_REVISION
 
130
        push_result.old_revno = 0
137
131
        if br_from.get_push_location() is None or remember:
138
132
            br_from.set_push_location(br_to.base)
139
 
    elif repository_to is None:
140
 
        # we have a bzrdir but no branch or repository
141
 
        # XXX: Figure out what to do other than complain.
142
 
        raise errors.BzrCommandError("At %s you have a valid .bzr control"
143
 
            " directory, but not a branch or repository. This is an"
144
 
            " unsupported configuration. Please move the target directory"
145
 
            " out of the way and try again."
146
 
            % location)
147
 
    elif br_to is None:
148
 
        # We have a repository but no branch, copy the revisions, and then
149
 
        # create a branch.
 
133
    else:
150
134
        if stacked_on is not None:
151
135
            warning("Ignoring request for a stacked branch as repository "
152
136
                    "already exists at the destination location.")
153
 
        repository_to.fetch(br_from.repository, revision_id=revision_id)
154
 
        br_to = br_from.clone(dir_to, revision_id=revision_id)
155
 
        if br_from.get_push_location() is None or remember:
156
 
            br_from.set_push_location(br_to.base)
157
 
    else: # We have a valid to branch
158
 
        if stacked_on is not None:
159
 
            warning("Ignoring request for a stacked branch as branch "
160
 
                    "already exists at the destination location.")
161
 
        # We were able to connect to the remote location, so remember it.
162
 
        # (We don't need to successfully push because of possible divergence.)
163
 
        if br_from.get_push_location() is None or remember:
164
 
            br_from.set_push_location(br_to.base)
165
137
        try:
166
 
            try:
167
 
                tree_to = dir_to.open_workingtree()
168
 
            except errors.NotLocalUrl:
169
 
                note("This transport does not update the working "
170
 
                        "tree of: %s. See 'bzr help working-trees' for "
171
 
                        "more information." % br_to.base)
172
 
                push_result.branch_push_result = br_from.push(br_to, overwrite,
173
 
                                                   stop_revision=revision_id)
174
 
            except errors.NoWorkingTree:
175
 
                push_result.branch_push_result = br_from.push(br_to, overwrite,
176
 
                                                   stop_revision=revision_id)
177
 
            else:
178
 
                tree_to.lock_write()
179
 
                try:
180
 
                    push_result.branch_push_result = br_from.push(tree_to.branch,
181
 
                        overwrite, stop_revision=revision_id)
182
 
                    tree_to.update()
183
 
                finally:
184
 
                    tree_to.unlock()
 
138
            push_result = dir_to.push_branch(br_from, revision_id, overwrite, 
 
139
                remember, create_prefix)
185
140
        except errors.DivergedBranches:
186
141
            raise errors.BzrCommandError('These branches have diverged.'
187
 
                                    '  Try using "merge" and then "push".')
 
142
                                    '  See "bzr help diverged-branches"'
 
143
                                    ' for more information.')
 
144
        except errors.NoRoundtrippingSupport, e:
 
145
            raise errors.BzrCommandError("It is not possible to losslessly "
 
146
                "push to %s. You may want to use dpush instead." % 
 
147
                    e.target_branch.mapping.vcs.abbreviation)
 
148
        except errors.NoRepositoryPresent:
 
149
            # we have a bzrdir but no branch or repository
 
150
            # XXX: Figure out what to do other than complain.
 
151
            raise errors.BzrCommandError("At %s you have a valid .bzr"
 
152
                " control directory, but not a branch or repository. This"
 
153
                " is an unsupported configuration. Please move the target"
 
154
                " directory out of the way and try again." % location)
 
155
        if push_result.workingtree_updated == False:
 
156
            warning("This transport does not update the working " 
 
157
                    "tree of: %s. See 'bzr help working-trees' for "
 
158
                    "more information." % push_result.target_branch.base)
188
159
    push_result.report(to_file)
189
 
    if push_result.branch_push_result is not None:
190
 
        old_revid = push_result.branch_push_result.old_revid
191
 
        old_revno = push_result.branch_push_result.old_revno
192
 
    else:
193
 
        old_revid = _mod_revision.NULL_REVISION
194
 
        old_revno = 0
195
160
    if verbose:
 
161
        br_to = push_result.target_branch
196
162
        br_to.lock_read()
197
163
        try:
198
164
            from bzrlib.log import show_branch_change
199
 
            show_branch_change(br_to, to_file, old_revno, old_revid)
 
165
            show_branch_change(br_to, to_file, push_result.old_revno, 
 
166
                               push_result.old_revid)
200
167
        finally:
201
168
            br_to.unlock()
 
169
 
 
170