← 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: 2009-08-27 02:27:19 UTC
  • mfrom: (4634.3.19 gc-batching)
  • Revision ID: pqm@pqm.ubuntu.com-20090827022719-bl2yoqhpj3fcfczu
(andrew) Fix #402657: 2a fetch over dumb transport reads one group at
        a time.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/push.py
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""UI helper for the push command."""
18
18
 
19
 
from bzrlib import builtins, bzrdir, errors, transport
20
 
from bzrlib.trace import note, warning
 
19
from bzrlib import (
 
20
    builtins,
 
21
    branch,
 
22
    bzrdir,
 
23
    errors,
 
24
    revision as _mod_revision,
 
25
    transport,
 
26
    )
 
27
from bzrlib.trace import (
 
28
    note,
 
29
    warning,
 
30
    )
 
31
 
 
32
 
 
33
class PushResult(object):
 
34
    """Result of a push operation.
 
35
 
 
36
    :ivar branch_push_result: Result of a push between branches
 
37
    :ivar target_branch: The target branch
 
38
    :ivar stacked_on: URL of the branch on which the result is stacked
 
39
    :ivar workingtree_updated: Whether or not the target workingtree was updated.
 
40
    """
 
41
 
 
42
    def __init__(self):
 
43
        self.branch_push_result = None
 
44
        self.stacked_on = None
 
45
        self.workingtree_updated = None
 
46
        self.target_branch = None
 
47
 
 
48
    def report(self, to_file):
 
49
        """Write a human-readable description of the result."""
 
50
        if self.branch_push_result is None:
 
51
            if self.stacked_on is not None:
 
52
                note('Created new stacked branch referring to %s.' %
 
53
                    self.stacked_on)
 
54
            else:
 
55
                note('Created new branch.')
 
56
        else:
 
57
            self.branch_push_result.report(to_file)
21
58
 
22
59
 
23
60
def _show_push_branch(br_from, revision_id, location, to_file, verbose=False,
42
79
        directory exists without a current .bzr directory in it
43
80
    """
44
81
    to_transport = transport.get_transport(location)
45
 
    br_to = repository_to = dir_to = None
46
82
    try:
47
83
        dir_to = bzrdir.BzrDir.open_from_transport(to_transport)
48
84
    except errors.NotBranchError:
49
 
        pass # Didn't find anything
50
 
    else:
51
 
        # If we can open a branch, use its direct repository, otherwise see
52
 
        # if there is a repository without a branch.
53
 
        try:
54
 
            br_to = dir_to.open_branch()
55
 
        except errors.NotBranchError:
56
 
            # Didn't find a branch, can we find a repository?
57
 
            try:
58
 
                repository_to = dir_to.find_repository()
59
 
            except errors.NoRepositoryPresent:
60
 
                pass
61
 
        else:
62
 
            # Found a branch, so we must have found a repository
63
 
            repository_to = br_to.repository
 
85
        # Didn't find anything
 
86
        dir_to = None
64
87
 
65
 
    push_result = None
66
 
    if verbose:
67
 
        old_rh = []
68
88
    if dir_to is None:
69
 
        # The destination doesn't exist; create it.
70
 
        # XXX: Refactor the create_prefix/no_create_prefix code into a
71
 
        #      common helper function
72
 
 
73
 
        def make_directory(transport):
74
 
            transport.mkdir('.')
75
 
            return transport
76
 
 
77
 
        def redirected(redirected_transport, e, redirection_notice):
78
 
            return transport.get_transport(e.get_target_url())
79
 
 
80
89
        try:
81
 
            to_transport = transport.do_catching_redirections(
82
 
                make_directory, to_transport, redirected)
 
90
            br_to = br_from.create_clone_on_transport(to_transport,
 
91
                revision_id=revision_id, stacked_on=stacked_on,
 
92
                create_prefix=create_prefix, use_existing_dir=use_existing_dir)
83
93
        except errors.FileExists:
84
94
            if not use_existing_dir:
85
95
                raise errors.BzrCommandError("Target directory %s"
93
103
                    "\nYou may supply --create-prefix to create all"
94
104
                    " leading parent directories."
95
105
                    % location)
96
 
            builtins._create_prefix(to_transport)
97
106
        except errors.TooManyRedirections:
98
107
            raise errors.BzrCommandError("Too many redirections trying "
99
108
                                         "to make %s." % location)
100
 
 
101
 
        # Now the target directory exists, but doesn't have a .bzr
102
 
        # directory. So we need to create it, along with any work to create
103
 
        # all of the dependent branches, etc.
104
 
        dir_to = br_from.bzrdir.clone_on_transport(to_transport,
105
 
            revision_id=revision_id, stacked_on=stacked_on)
106
 
        br_to = dir_to.open_branch()
 
109
        push_result = PushResult()
107
110
        # TODO: Some more useful message about what was copied
108
111
        try:
109
 
            finally_stacked_on = br_to.get_stacked_on_url()
 
112
            push_result.stacked_on = br_to.get_stacked_on_url()
110
113
        except (errors.UnstackableBranchFormat,
111
114
                errors.UnstackableRepositoryFormat,
112
115
                errors.NotStacked):
113
 
            finally_stacked_on = None
114
 
        if finally_stacked_on is not None:
115
 
            note('Created new stacked branch referring to %s.' %
116
 
                 finally_stacked_on)
117
 
        else:
118
 
            note('Created new branch.')
119
 
        # We successfully created the target, remember it
 
116
            push_result.stacked_on = None
 
117
        push_result.target_branch = br_to
 
118
        push_result.old_revid = _mod_revision.NULL_REVISION
 
119
        push_result.old_revno = 0
120
120
        if br_from.get_push_location() is None or remember:
121
121
            br_from.set_push_location(br_to.base)
122
 
    elif repository_to is None:
123
 
        # we have a bzrdir but no branch or repository
124
 
        # XXX: Figure out what to do other than complain.
125
 
        raise errors.BzrCommandError("At %s you have a valid .bzr control"
126
 
            " directory, but not a branch or repository. This is an"
127
 
            " unsupported configuration. Please move the target directory"
128
 
            " out of the way and try again."
129
 
            % location)
130
 
    elif br_to is None:
131
 
        # We have a repository but no branch, copy the revisions, and then
132
 
        # create a branch.
 
122
    else:
133
123
        if stacked_on is not None:
134
124
            warning("Ignoring request for a stacked branch as repository "
135
125
                    "already exists at the destination location.")
136
 
        repository_to.fetch(br_from.repository, revision_id=revision_id)
137
 
        br_to = br_from.clone(dir_to, revision_id=revision_id)
138
 
        note('Created new branch.')
139
 
        if br_from.get_push_location() is None or remember:
140
 
            br_from.set_push_location(br_to.base)
141
 
    else: # We have a valid to branch
142
 
        if stacked_on is not None:
143
 
            warning("Ignoring request for a stacked branch as branch "
144
 
                    "already exists at the destination location.")
145
 
        # We were able to connect to the remote location, so remember it.
146
 
        # (We don't need to successfully push because of possible divergence.)
147
 
        if br_from.get_push_location() is None or remember:
148
 
            br_from.set_push_location(br_to.base)
149
 
        if verbose:
150
 
            old_rh = br_to.revision_history()
151
126
        try:
152
 
            try:
153
 
                tree_to = dir_to.open_workingtree()
154
 
            except errors.NotLocalUrl:
155
 
                warning("This transport does not update the working " 
156
 
                        "tree of: %s. See 'bzr help working-trees' for "
157
 
                        "more information." % br_to.base)
158
 
                push_result = br_from.push(br_to, overwrite,
159
 
                                           stop_revision=revision_id)
160
 
            except errors.NoWorkingTree:
161
 
                push_result = br_from.push(br_to, overwrite,
162
 
                                           stop_revision=revision_id)
163
 
            else:
164
 
                tree_to.lock_write()
165
 
                try:
166
 
                    push_result = br_from.push(tree_to.branch, overwrite,
167
 
                                               stop_revision=revision_id)
168
 
                    tree_to.update()
169
 
                finally:
170
 
                    tree_to.unlock()
 
127
            push_result = dir_to.push_branch(br_from, revision_id, overwrite, 
 
128
                remember, create_prefix)
171
129
        except errors.DivergedBranches:
172
130
            raise errors.BzrCommandError('These branches have diverged.'
173
 
                                    '  Try using "merge" and then "push".')
174
 
    if push_result is not None:
175
 
        push_result.report(to_file)
176
 
    elif verbose:
177
 
        new_rh = br_to.revision_history()
178
 
        if old_rh != new_rh:
179
 
            # Something changed
180
 
            from bzrlib.log import show_changed_revisions
181
 
            show_changed_revisions(br_to, old_rh, new_rh,
182
 
                                   to_file=to_file)
183
 
    else:
184
 
        # we probably did a clone rather than a push, so a message was
185
 
        # emitted above
186
 
        pass
 
131
                                    '  See "bzr help diverged-branches"'
 
132
                                    ' for more information.')
 
133
        except errors.NoRepositoryPresent:
 
134
            # we have a bzrdir but no branch or repository
 
135
            # XXX: Figure out what to do other than complain.
 
136
            raise errors.BzrCommandError("At %s you have a valid .bzr"
 
137
                " control directory, but not a branch or repository. This"
 
138
                " is an unsupported configuration. Please move the target"
 
139
                " directory out of the way and try again." % location)
 
140
        if push_result.workingtree_updated == False:
 
141
            warning("This transport does not update the working " 
 
142
                    "tree of: %s. See 'bzr help working-trees' for "
 
143
                    "more information." % push_result.target_branch.base)
 
144
    push_result.report(to_file)
 
145
    if verbose:
 
146
        br_to = push_result.target_branch
 
147
        br_to.lock_read()
 
148
        try:
 
149
            from bzrlib.log import show_branch_change
 
150
            show_branch_change(br_to, to_file, push_result.old_revno, 
 
151
                               push_result.old_revid)
 
152
        finally:
 
153
            br_to.unlock()
 
154
 
 
155