/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 brzlib/plugins/launchpad/cmds.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/plugins/launchpad/cmds.py
1
 
# Copyright (C) 2006-2017 Canonical Ltd
 
1
# Copyright (C) 2006-2012 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
"""Launchpad plugin commands."""
18
18
 
19
 
from ... import (
 
19
from __future__ import absolute_import
 
20
 
 
21
from brzlib import (
20
22
    branch as _mod_branch,
21
23
    controldir,
22
24
    trace,
23
25
    )
24
 
from ...commands import (
 
26
from brzlib.commands import (
25
27
    Command,
26
28
    )
27
 
from ...errors import (
 
29
from brzlib.errors import (
28
30
    BzrCommandError,
 
31
    InvalidURL,
 
32
    NoPublicBranch,
29
33
    NotBranchError,
30
34
    )
31
 
from ...i18n import gettext
32
 
from ...option import (
 
35
from brzlib.i18n import gettext
 
36
from brzlib.option import (
33
37
    Option,
34
38
    ListOption,
35
39
    )
36
40
 
37
41
 
 
42
class cmd_register_branch(Command):
 
43
    __doc__ = """Register a branch with launchpad.net.
 
44
 
 
45
    This command lists a bzr branch in the directory of branches on
 
46
    launchpad.net.  Registration allows the branch to be associated with
 
47
    bugs or specifications.
 
48
 
 
49
    Before using this command you must register the project to which the
 
50
    branch belongs, and create an account for yourself on launchpad.net.
 
51
 
 
52
    arguments:
 
53
        public_url: The publicly visible url for the branch to register.
 
54
                    This must be an http or https url (which Launchpad can read
 
55
                    from to access the branch). Local file urls, SFTP urls, and
 
56
                    bzr+ssh urls will not work.
 
57
                    If no public_url is provided, bzr will use the configured
 
58
                    public_url if there is one for the current branch, and
 
59
                    otherwise error.
 
60
 
 
61
    example:
 
62
        bzr register-branch http://foo.com/bzr/fooproject.mine \\
 
63
                --project fooproject
 
64
    """
 
65
    takes_args = ['public_url?']
 
66
    takes_options = [
 
67
         Option('project',
 
68
                'Launchpad project short name to associate with the branch.',
 
69
                unicode),
 
70
         Option('product',
 
71
                'Launchpad product short name to associate with the branch.',
 
72
                unicode,
 
73
                hidden=True),
 
74
         Option('branch-name',
 
75
                'Short name for the branch; '
 
76
                'by default taken from the last component of the url.',
 
77
                unicode),
 
78
         Option('branch-title',
 
79
                'One-sentence description of the branch.',
 
80
                unicode),
 
81
         Option('branch-description',
 
82
                'Longer description of the purpose or contents of the branch.',
 
83
                unicode),
 
84
         Option('author',
 
85
                "Branch author's email address, if not yourself.",
 
86
                unicode),
 
87
         Option('link-bug',
 
88
                'The bug this branch fixes.',
 
89
                int),
 
90
         Option('dry-run',
 
91
                'Prepare the request but don\'t actually send it.')
 
92
        ]
 
93
 
 
94
 
 
95
    def run(self,
 
96
            public_url=None,
 
97
            project='',
 
98
            product=None,
 
99
            branch_name='',
 
100
            branch_title='',
 
101
            branch_description='',
 
102
            author='',
 
103
            link_bug=None,
 
104
            dry_run=False):
 
105
        from brzlib.plugins.launchpad.lp_registration import (
 
106
            BranchRegistrationRequest, BranchBugLinkRequest,
 
107
            DryRunLaunchpadService, LaunchpadService)
 
108
        if public_url is None:
 
109
            try:
 
110
                b = _mod_branch.Branch.open_containing('.')[0]
 
111
            except NotBranchError:
 
112
                raise BzrCommandError(gettext(
 
113
                            'register-branch requires a public '
 
114
                            'branch url - see bzr help register-branch.'))
 
115
            public_url = b.get_public_branch()
 
116
            if public_url is None:
 
117
                raise NoPublicBranch(b)
 
118
        if product is not None:
 
119
            project = product
 
120
            trace.note(gettext(
 
121
                '--product is deprecated; please use --project.'))
 
122
 
 
123
 
 
124
        rego = BranchRegistrationRequest(branch_url=public_url,
 
125
                                         branch_name=branch_name,
 
126
                                         branch_title=branch_title,
 
127
                                         branch_description=branch_description,
 
128
                                         product_name=project,
 
129
                                         author_email=author,
 
130
                                         )
 
131
        linko = BranchBugLinkRequest(branch_url=public_url,
 
132
                                     bug_id=link_bug)
 
133
        if not dry_run:
 
134
            service = LaunchpadService()
 
135
            # This gives back the xmlrpc url that can be used for future
 
136
            # operations on the branch.  It's not so useful to print to the
 
137
            # user since they can't do anything with it from a web browser; it
 
138
            # might be nice for the server to tell us about an html url as
 
139
            # well.
 
140
        else:
 
141
            # Run on service entirely in memory
 
142
            service = DryRunLaunchpadService()
 
143
        service.gather_user_credentials()
 
144
        rego.submit(service)
 
145
        if link_bug:
 
146
            linko.submit(service)
 
147
        self.outf.write('Branch registered.\n')
 
148
 
 
149
 
38
150
class cmd_launchpad_open(Command):
39
151
    __doc__ = """Open a Launchpad branch page in your web browser."""
40
152
 
61
173
            yield branch_url
62
174
 
63
175
    def _get_web_url(self, service, location):
64
 
        from .lp_registration import (
65
 
            InvalidURL,
 
176
        from brzlib.plugins.launchpad.lp_registration import (
66
177
            NotLaunchpadBranch)
67
178
        for branch_url in self._possible_locations(location):
68
179
            try:
72
183
        raise NotLaunchpadBranch(branch_url)
73
184
 
74
185
    def run(self, location=None, dry_run=False):
75
 
        from .lp_registration import (
 
186
        from brzlib.plugins.launchpad.lp_registration import (
76
187
            LaunchpadService)
77
188
        if location is None:
78
189
            location = u'.'
80
191
        trace.note(gettext('Opening %s in web browser') % web_url)
81
192
        if not dry_run:
82
193
            import webbrowser   # this import should not be lazy
83
 
            # otherwise brz.exe lacks this module
 
194
                                # otherwise bzr.exe lacks this module
84
195
            webbrowser.open(web_url)
85
196
 
86
197
 
94
205
    :Examples:
95
206
      Show the Launchpad ID of the current user::
96
207
 
97
 
          brz launchpad-login
 
208
          bzr launchpad-login
98
209
 
99
210
      Set the Launchpad ID of the current user to 'bob'::
100
211
 
101
 
          brz launchpad-login bob
 
212
          bzr launchpad-login bob
102
213
    """
103
214
    aliases = ['lp-login']
104
215
    takes_args = ['name?']
110
221
 
111
222
    def run(self, name=None, no_check=False, verbose=False):
112
223
        # This is totally separate from any launchpadlib login system.
113
 
        from . import account
 
224
        from brzlib.plugins.launchpad import account
114
225
        check_account = not no_check
115
226
 
116
227
        if name is None:
135
246
            account.set_lp_login(name)
136
247
            if verbose:
137
248
                self.outf.write(gettext("Launchpad user ID set to '%s'.\n") %
138
 
                                (name,))
139
 
 
140
 
 
141
 
class cmd_launchpad_logout(Command):
142
 
    __doc__ = """Unset the Launchpad user ID.
143
 
 
144
 
    When communicating with Launchpad, some commands need to know your
145
 
    Launchpad user ID.  This command will log you out from Launchpad.
146
 
    This means that communication with Launchpad will happen over
147
 
    HTTPS, and will not require one of your SSH keys to be available.
148
 
    """
149
 
    aliases = ['lp-logout']
150
 
    takes_options = ['verbose']
151
 
 
152
 
    def run(self, verbose=False):
153
 
        from . import account
154
 
        old_username = account.get_lp_login()
155
 
        if old_username is None:
156
 
            self.outf.write(gettext('Not logged into Launchpad.\n'))
157
 
            return 1
158
 
        account.set_lp_login(None)
159
 
        if verbose:
160
 
            self.outf.write(gettext(
161
 
                "Launchpad user ID %s logged out.\n") %
162
 
                old_username)
 
249
                                                                        (name,))
 
250
 
 
251
 
 
252
# XXX: cmd_launchpad_mirror is untested
 
253
class cmd_launchpad_mirror(Command):
 
254
    __doc__ = """Ask Launchpad to mirror a branch now."""
 
255
 
 
256
    aliases = ['lp-mirror']
 
257
    takes_args = ['location?']
 
258
 
 
259
    def run(self, location='.'):
 
260
        from brzlib.plugins.launchpad import lp_api
 
261
        from brzlib.plugins.launchpad.lp_registration import LaunchpadService
 
262
        branch, _ = _mod_branch.Branch.open_containing(location)
 
263
        service = LaunchpadService()
 
264
        launchpad = lp_api.login(service)
 
265
        lp_branch = lp_api.LaunchpadBranch.from_bzr(launchpad, branch,
 
266
                create_missing=False)
 
267
        lp_branch.lp.requestMirror()
163
268
 
164
269
 
165
270
class cmd_lp_propose_merge(Command):
177
282
    The parameter the launchpad account name of the desired reviewer.  This
178
283
    may optionally be followed by '=' and the review type.  For example:
179
284
 
180
 
      brz lp-propose-merge --review jrandom --review review-team=qa
 
285
      bzr lp-propose-merge --review jrandom --review review-team=qa
181
286
 
182
287
    This will propose a merge,  request "jrandom" to perform a review of
183
288
    unspecified type, and request "review-team" to perform a "qa" review.
184
289
    """
185
290
 
186
 
    hidden = True
187
291
    takes_options = [Option('staging',
188
292
                            help='Propose the merge on staging.'),
189
 
                     Option('message', short_name='m', type=str,
 
293
                     Option('message', short_name='m', type=unicode,
190
294
                            help='Commit message.'),
191
295
                     Option('approve',
192
296
                            help=('Mark the proposal as approved immediately, '
193
297
                                  'setting the approved revision to tip.')),
194
298
                     Option('fixes', 'The bug this proposal fixes.', str),
195
 
                     ListOption('review', short_name='R', type=str,
196
 
                                help='Requested reviewer and optional type.')]
 
299
                     ListOption('review', short_name='R', type=unicode,
 
300
                            help='Requested reviewer and optional type.')]
197
301
 
198
302
    takes_args = ['submit_branch?']
199
303
 
201
305
 
202
306
    def run(self, submit_branch=None, review=None, staging=False,
203
307
            message=None, approve=False, fixes=None):
204
 
        from . import lp_propose
 
308
        from brzlib.plugins.launchpad import lp_propose
205
309
        tree, branch, relpath = controldir.ControlDir.open_containing_tree_or_branch(
206
310
            '.')
207
311
        if review is None:
239
343
 
240
344
    So, to find the merge proposal that reviewed line 1 of README::
241
345
 
242
 
      brz lp-find-proposal -r mainline:annotate:README:1
 
346
      bzr lp-find-proposal -r mainline:annotate:README:1
243
347
    """
244
348
 
245
349
    takes_options = ['revision']
246
350
 
247
351
    def run(self, revision=None):
248
 
        from ... import ui
249
 
        from . import lp_api
 
352
        from brzlib import ui
 
353
        from brzlib.plugins.launchpad import lp_api
250
354
        import webbrowser
251
355
        b = _mod_branch.Branch.open_containing('.')[0]
252
 
        with ui.ui_factory.nested_progress_bar() as pb, b.lock_read():
 
356
        pb = ui.ui_factory.nested_progress_bar()
 
357
        b.lock_read()
 
358
        try:
253
359
            if revision is None:
254
360
                revision_id = b.last_revision()
255
361
            else:
260
366
            trace.note(gettext('%d proposals(s) found.') % len(merged))
261
367
            for mp in merged:
262
368
                webbrowser.open(lp_api.canonical_url(mp))
 
369
        finally:
 
370
            b.unlock()
 
371
            pb.finished()
263
372
 
264
373
    def _find_proposals(self, revision_id, pb):
265
 
        from launchpadlib import uris
266
 
        from . import lp_api
 
374
        from brzlib.plugins.launchpad import (lp_api, lp_registration)
267
375
        # "devel" because branches.getMergeProposals is not part of 1.0 API.
268
 
        lp_base_url = uris.LPNET_SERVICE_ROOT
269
 
        launchpad = lp_api.connect_launchpad(lp_base_url, version='devel')
 
376
        launchpad = lp_api.login(lp_registration.LaunchpadService(),
 
377
                                 version='devel')
270
378
        pb.update(gettext('Finding proposals'))
271
379
        return list(launchpad.branches.getMergeProposals(
272
 
                    merged_revision=revision_id.decode('utf-8')))
 
380
                    merged_revision=revision_id))