← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/plugins/launchpad/lp_propose.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-12 18:05:15 UTC
  • mto: (4371.4.5 vila-better-heads)
  • mto: This revision was merged to the branch mainline in revision 4449.
  • Revision ID: john@arbash-meinel.com-20090612180515-t0cwbjsnve094oik
Add a failing test for handling nodes that are in the same linear chain.

It fails because the ancestry skipping causes us to miss the fact that the two nodes
are actually directly related. We could check at the beginning, as the 
code used to do, but I think that will be incomplete for the more-than-two
heads cases.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugins/launchpad/lp_propose.py
1
 
# Copyright (C) 2010, 2011 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
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 bzrlib import (
18
 
    errors,
19
 
    hooks,
20
 
    )
21
 
from bzrlib.lazy_import import lazy_import
22
 
lazy_import(globals(), """
23
 
import webbrowser
24
 
 
25
 
from bzrlib import (
26
 
    msgeditor,
27
 
    )
28
 
from bzrlib.plugins.launchpad import (
29
 
    lp_api,
30
 
    lp_registration,
31
 
    )
32
 
""")
33
 
 
34
 
 
35
 
class ProposeMergeHooks(hooks.Hooks):
36
 
    """Hooks for proposing a merge on Launchpad."""
37
 
 
38
 
    def __init__(self):
39
 
        hooks.Hooks.__init__(self, "bzrlib.plugins.launchpad.lp_propose",
40
 
            "Proposer.hooks")
41
 
        self.add_hook('get_prerequisite',
42
 
            "Return the prerequisite branch for proposing as merge.", (2, 1))
43
 
        self.add_hook('merge_proposal_body',
44
 
            "Return an initial body for the merge proposal message.", (2, 1))
45
 
 
46
 
 
47
 
class Proposer(object):
48
 
 
49
 
    hooks = ProposeMergeHooks()
50
 
 
51
 
    def __init__(self, tree, source_branch, target_branch, message, reviews,
52
 
                 staging=False, approve=False):
53
 
        """Constructor.
54
 
 
55
 
        :param tree: The working tree for the source branch.
56
 
        :param source_branch: The branch to propose for merging.
57
 
        :param target_branch: The branch to merge into.
58
 
        :param message: The commit message to use.  (May be None.)
59
 
        :param reviews: A list of tuples of reviewer, review type.
60
 
        :param staging: If True, propose the merge against staging instead of
61
 
            production.
62
 
        :param approve: If True, mark the new proposal as approved immediately.
63
 
            This is useful when a project permits some things to be approved
64
 
            by the submitter (e.g. merges between release and deployment
65
 
            branches).
66
 
        """
67
 
        self.tree = tree
68
 
        if staging:
69
 
            lp_instance = 'staging'
70
 
        else:
71
 
            lp_instance = 'production'
72
 
        service = lp_registration.LaunchpadService(lp_instance=lp_instance)
73
 
        self.launchpad = lp_api.login(service)
74
 
        self.source_branch = lp_api.LaunchpadBranch.from_bzr(
75
 
            self.launchpad, source_branch)
76
 
        if target_branch is None:
77
 
            self.target_branch = self.source_branch.get_target()
78
 
        else:
79
 
            self.target_branch = lp_api.LaunchpadBranch.from_bzr(
80
 
                self.launchpad, target_branch)
81
 
        self.commit_message = message
82
 
        # XXX: this is where bug lp:583638 could be tackled.
83
 
        if reviews == []:
84
 
            self.reviews = []
85
 
        else:
86
 
            self.reviews = [(self.launchpad.people[reviewer], review_type)
87
 
                            for reviewer, review_type in
88
 
                            reviews]
89
 
        self.approve = approve
90
 
 
91
 
    def get_comment(self, prerequisite_branch):
92
 
        """Determine the initial comment for the merge proposal."""
93
 
        info = ["Source: %s\n" % self.source_branch.lp.bzr_identity]
94
 
        info.append("Target: %s\n" % self.target_branch.lp.bzr_identity)
95
 
        if prerequisite_branch is not None:
96
 
            info.append("Prereq: %s\n" % prerequisite_branch.lp.bzr_identity)
97
 
        for rdata in self.reviews:
98
 
            uniquename = "%s (%s)" % (rdata[0].display_name, rdata[0].name)
99
 
            info.append('Reviewer: %s, type "%s"\n' % (uniquename, rdata[1]))
100
 
        self.source_branch.bzr.lock_read()
101
 
        try:
102
 
            self.target_branch.bzr.lock_read()
103
 
            try:
104
 
                body = self.get_initial_body()
105
 
            finally:
106
 
                self.target_branch.bzr.unlock()
107
 
        finally:
108
 
            self.source_branch.bzr.unlock()
109
 
        initial_comment = msgeditor.edit_commit_message(''.join(info),
110
 
                                                        start_message=body)
111
 
        return initial_comment.strip().encode('utf-8')
112
 
 
113
 
    def get_initial_body(self):
114
 
        """Get a body for the proposal for the user to modify.
115
 
 
116
 
        :return: a str or None.
117
 
        """
118
 
        def list_modified_files():
119
 
            lca_tree = self.source_branch.find_lca_tree(
120
 
                self.target_branch)
121
 
            source_tree = self.source_branch.bzr.basis_tree()
122
 
            files = modified_files(lca_tree, source_tree)
123
 
            return list(files)
124
 
        target_loc = ('bzr+ssh://bazaar.launchpad.net/%s' %
125
 
                       self.target_branch.lp.unique_name)
126
 
        body = None
127
 
        for hook in self.hooks['merge_proposal_body']:
128
 
            body = hook({
129
 
                'tree': self.tree,
130
 
                'target_branch': target_loc,
131
 
                'modified_files_callback': list_modified_files,
132
 
                'old_body': body,
133
 
            })
134
 
        return body
135
 
 
136
 
    def check_proposal(self):
137
 
        """Check that the submission is sensible."""
138
 
        if self.source_branch.lp.self_link == self.target_branch.lp.self_link:
139
 
            raise errors.BzrCommandError(
140
 
                'Source and target branches must be different.')
141
 
        for mp in self.source_branch.lp.landing_targets:
142
 
            if mp.queue_status in ('Merged', 'Rejected'):
143
 
                continue
144
 
            if mp.target_branch.self_link == self.target_branch.lp.self_link:
145
 
                raise errors.BzrCommandError(
146
 
                    'There is already a branch merge proposal: %s' %
147
 
                    lp_api.canonical_url(mp))
148
 
 
149
 
    def _get_prerequisite_branch(self):
150
 
        hooks = self.hooks['get_prerequisite']
151
 
        prerequisite_branch = None
152
 
        for hook in hooks:
153
 
            prerequisite_branch = hook(
154
 
                {'launchpad': self.launchpad,
155
 
                 'source_branch': self.source_branch,
156
 
                 'target_branch': self.target_branch,
157
 
                 'prerequisite_branch': prerequisite_branch})
158
 
        return prerequisite_branch
159
 
 
160
 
    def call_webservice(self, call, *args, **kwargs):
161
 
        """Make a call to the webservice, wrapping failures.
162
 
        
163
 
        :param call: The call to make.
164
 
        :param *args: *args for the call.
165
 
        :param **kwargs: **kwargs for the call.
166
 
        :return: The result of calling call(*args, *kwargs).
167
 
        """
168
 
        from lazr.restfulclient import errors as restful_errors
169
 
        try:
170
 
            return call(*args, **kwargs)
171
 
        except restful_errors.HTTPError, e:
172
 
            error_lines = []
173
 
            for line in e.content.splitlines():
174
 
                if line.startswith('Traceback (most recent call last):'):
175
 
                    break
176
 
                error_lines.append(line)
177
 
            raise Exception(''.join(error_lines))
178
 
 
179
 
    def create_proposal(self):
180
 
        """Perform the submission."""
181
 
        prerequisite_branch = self._get_prerequisite_branch()
182
 
        if prerequisite_branch is None:
183
 
            prereq = None
184
 
        else:
185
 
            prereq = prerequisite_branch.lp
186
 
            prerequisite_branch.update_lp()
187
 
        self.source_branch.update_lp()
188
 
        reviewers = []
189
 
        review_types = []
190
 
        for reviewer, review_type in self.reviews:
191
 
            review_types.append(review_type)
192
 
            reviewers.append(reviewer.self_link)
193
 
        initial_comment = self.get_comment(prerequisite_branch)
194
 
        mp = self.call_webservice(
195
 
            self.source_branch.lp.createMergeProposal,
196
 
            target_branch=self.target_branch.lp,
197
 
            prerequisite_branch=prereq,
198
 
            initial_comment=initial_comment,
199
 
            commit_message=self.commit_message, reviewers=reviewers,
200
 
            review_types=review_types)
201
 
        if self.approve:
202
 
            self.call_webservice(mp.setStatus, status='Approved')
203
 
        webbrowser.open(lp_api.canonical_url(mp))
204
 
 
205
 
 
206
 
def modified_files(old_tree, new_tree):
207
 
    """Return a list of paths in the new tree with modified contents."""
208
 
    for f, (op, path), c, v, p, n, (ok, k), e in new_tree.iter_changes(
209
 
        old_tree):
210
 
        if c and k == 'file':
211
 
            yield str(path)