← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Patch Queue Manager
  • Date: 2012-10-25 11:13:27 UTC
  • mfrom: (6570.1.6 rubberstamp)
  • Revision ID: pqm@pqm.ubuntu.com-20121025111327-p0ylql0nh9fla0rs
(gz) Set approved revision and vote "Approve" when using lp-propose
 --approve (Jonathan Lange)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugins/launchpad/lp_registration.py
1
 
# Copyright (C) 2006 by Canonical Ltd
 
1
# Copyright (C) 2006-2011 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
7
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
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.
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
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
16
 
 
17
 
 
18
 
from getpass import getpass
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
 
18
 
 
19
 
19
20
import os
 
21
import socket
20
22
from urlparse import urlsplit, urlunsplit
21
23
import urllib
22
24
import xmlrpclib
23
25
 
24
 
import bzrlib.config
25
 
import bzrlib.errors as errors
 
26
from bzrlib import (
 
27
    config,
 
28
    errors,
 
29
    urlutils,
 
30
    __version__ as _bzrlib_version,
 
31
    )
 
32
from bzrlib.transport.http import _urllib2_wrappers
 
33
 
26
34
 
27
35
# for testing, do
28
36
'''
29
37
export BZR_LP_XMLRPC_URL=http://xmlrpc.staging.launchpad.net/bazaar/
30
38
'''
31
39
 
 
40
class InvalidLaunchpadInstance(errors.BzrError):
 
41
 
 
42
    _fmt = "%(lp_instance)s is not a valid Launchpad instance."
 
43
 
 
44
    def __init__(self, lp_instance):
 
45
        errors.BzrError.__init__(self, lp_instance=lp_instance)
 
46
 
 
47
 
 
48
class NotLaunchpadBranch(errors.BzrError):
 
49
 
 
50
    _fmt = "%(url)s is not registered on Launchpad."
 
51
 
 
52
    def __init__(self, url):
 
53
        errors.BzrError.__init__(self, url=url)
 
54
 
 
55
 
 
56
class XMLRPCTransport(xmlrpclib.Transport):
 
57
 
 
58
    def __init__(self, scheme):
 
59
        xmlrpclib.Transport.__init__(self)
 
60
        self._scheme = scheme
 
61
        self._opener = _urllib2_wrappers.Opener()
 
62
        self.verbose = 0
 
63
 
 
64
    def request(self, host, handler, request_body, verbose=0):
 
65
        self.verbose = verbose
 
66
        url = self._scheme + "://" + host + handler
 
67
        request = _urllib2_wrappers.Request("POST", url, request_body)
 
68
        # FIXME: _urllib2_wrappers will override user-agent with its own
 
69
        # request.add_header("User-Agent", self.user_agent)
 
70
        request.add_header("Content-Type", "text/xml")
 
71
 
 
72
        response = self._opener.open(request)
 
73
        if response.code != 200:
 
74
            raise xmlrpclib.ProtocolError(host + handler, response.code,
 
75
                                          response.msg, response.info())
 
76
        return self.parse_response(response)
 
77
 
 
78
 
32
79
class LaunchpadService(object):
33
80
    """A service to talk to Launchpad via XMLRPC.
34
 
    
35
 
    See http://bazaar-vcs.org/Specs/LaunchpadRpc for the methods we can call.
 
81
 
 
82
    See http://wiki.bazaar.canonical.com/Specs/LaunchpadRpc for the methods we can call.
36
83
    """
37
84
 
38
 
    # NB: this should always end in a slash to avoid xmlrpclib appending
 
85
    LAUNCHPAD_DOMAINS = {
 
86
        'production': 'launchpad.net',
 
87
        'staging': 'staging.launchpad.net',
 
88
        'qastaging': 'qastaging.launchpad.net',
 
89
        'demo': 'demo.launchpad.net',
 
90
        'dev': 'launchpad.dev',
 
91
        }
 
92
 
 
93
    # NB: these should always end in a slash to avoid xmlrpclib appending
39
94
    # '/RPC2'
40
 
    DEFAULT_SERVICE_URL = 'https://xmlrpc.launchpad.net/bazaar/'
 
95
    LAUNCHPAD_INSTANCE = {}
 
96
    for instance, domain in LAUNCHPAD_DOMAINS.iteritems():
 
97
        LAUNCHPAD_INSTANCE[instance] = 'https://xmlrpc.%s/bazaar/' % domain
 
98
 
 
99
    # We use production as the default because edge has been deprecated circa
 
100
    # 2010-11 (see bug https://bugs.launchpad.net/bzr/+bug/583667)
 
101
    DEFAULT_INSTANCE = 'production'
 
102
    DEFAULT_SERVICE_URL = LAUNCHPAD_INSTANCE[DEFAULT_INSTANCE]
41
103
 
42
104
    transport = None
43
105
    registrant_email = None
44
106
    registrant_password = None
45
107
 
46
108
 
47
 
    def __init__(self, transport=None):
 
109
    def __init__(self, transport=None, lp_instance=None):
48
110
        """Construct a new service talking to the launchpad rpc server"""
 
111
        self._lp_instance = lp_instance
49
112
        if transport is None:
50
113
            uri_type = urllib.splittype(self.service_url)[0]
51
 
            if uri_type == 'https':
52
 
                transport = xmlrpclib.SafeTransport()
53
 
            else:
54
 
                transport = xmlrpclib.Transport()
 
114
            transport = XMLRPCTransport(uri_type)
55
115
            transport.user_agent = 'bzr/%s (xmlrpclib/%s)' \
56
 
                    % (bzrlib.__version__, xmlrpclib.__version__)
 
116
                    % (_bzrlib_version, xmlrpclib.__version__)
57
117
        self.transport = transport
58
118
 
59
 
 
60
119
    @property
61
120
    def service_url(self):
62
121
        """Return the http or https url for the xmlrpc server.
66
125
        key = 'BZR_LP_XMLRPC_URL'
67
126
        if key in os.environ:
68
127
            return os.environ[key]
 
128
        elif self._lp_instance is not None:
 
129
            try:
 
130
                return self.LAUNCHPAD_INSTANCE[self._lp_instance]
 
131
            except KeyError:
 
132
                raise InvalidLaunchpadInstance(self._lp_instance)
69
133
        else:
70
134
            return self.DEFAULT_SERVICE_URL
71
135
 
72
 
    def get_proxy(self):
 
136
    @classmethod
 
137
    def for_url(cls, url, **kwargs):
 
138
        """Return the Launchpad service corresponding to the given URL."""
 
139
        result = urlsplit(url)
 
140
        lp_instance = result[1]
 
141
        if lp_instance == '':
 
142
            lp_instance = None
 
143
        elif lp_instance not in cls.LAUNCHPAD_INSTANCE:
 
144
            raise errors.InvalidURL(path=url)
 
145
        return cls(lp_instance=lp_instance, **kwargs)
 
146
 
 
147
    def get_proxy(self, authenticated):
73
148
        """Return the proxy for XMLRPC requests."""
74
 
        # auth info must be in url
75
 
        # TODO: if there's no registrant email perhaps we should just connect
76
 
        # anonymously?
77
 
        scheme, hostinfo, path = urlsplit(self.service_url)[:3]
78
 
        assert '@' not in hostinfo
79
 
        assert self.registrant_email is not None
80
 
        assert self.registrant_password is not None
81
 
        # TODO: perhaps fully quote the password to make it very slightly
82
 
        # obscured
83
 
        # TODO: can we perhaps add extra Authorization headers directly to the 
84
 
        # request, rather than putting this into the url?  perhaps a bit more 
85
 
        # secure against accidentally revealing it.  std66 s3.2.1 discourages putting
86
 
        # the password in the url.
87
 
        hostinfo = '%s:%s@%s' % (urllib.quote(self.registrant_email),
88
 
                                 urllib.quote(self.registrant_password),
89
 
                                 hostinfo)
90
 
        url = urlunsplit((scheme, hostinfo, path, '', ''))
 
149
        if authenticated:
 
150
            # auth info must be in url
 
151
            # TODO: if there's no registrant email perhaps we should
 
152
            # just connect anonymously?
 
153
            scheme, hostinfo, path = urlsplit(self.service_url)[:3]
 
154
            if '@' in hostinfo:
 
155
                raise AssertionError(hostinfo)
 
156
            if self.registrant_email is None:
 
157
                raise AssertionError()
 
158
            if self.registrant_password is None:
 
159
                raise AssertionError()
 
160
            # TODO: perhaps fully quote the password to make it very slightly
 
161
            # obscured
 
162
            # TODO: can we perhaps add extra Authorization headers
 
163
            # directly to the request, rather than putting this into
 
164
            # the url?  perhaps a bit more secure against accidentally
 
165
            # revealing it.  std66 s3.2.1 discourages putting the
 
166
            # password in the url.
 
167
            hostinfo = '%s:%s@%s' % (urlutils.quote(self.registrant_email),
 
168
                                     urlutils.quote(self.registrant_password),
 
169
                                     hostinfo)
 
170
            url = urlunsplit((scheme, hostinfo, path, '', ''))
 
171
        else:
 
172
            url = self.service_url
91
173
        return xmlrpclib.ServerProxy(url, transport=self.transport)
92
174
 
93
175
    def gather_user_credentials(self):
94
176
        """Get the password from the user."""
95
 
        config = bzrlib.config.GlobalConfig()
96
 
        self.registrant_email = config.user_email()
 
177
        the_config = config.GlobalConfig()
 
178
        self.registrant_email = the_config.user_email()
97
179
        if self.registrant_password is None:
 
180
            auth = config.AuthenticationConfig()
 
181
            scheme, hostinfo = urlsplit(self.service_url)[:2]
98
182
            prompt = 'launchpad.net password for %s: ' % \
99
183
                    self.registrant_email
100
 
            self.registrant_password = getpass(prompt)
 
184
            # We will reuse http[s] credentials if we can, prompt user
 
185
            # otherwise
 
186
            self.registrant_password = auth.get_password(scheme, hostinfo,
 
187
                                                         self.registrant_email,
 
188
                                                         prompt=prompt)
101
189
 
102
 
    def send_request(self, method_name, method_params):
103
 
        proxy = self.get_proxy()
104
 
        assert method_name
 
190
    def send_request(self, method_name, method_params, authenticated):
 
191
        proxy = self.get_proxy(authenticated)
105
192
        method = getattr(proxy, method_name)
106
193
        try:
107
194
            result = method(*method_params)
118
205
                # TODO: print more headers to help in tracking down failures
119
206
                raise errors.BzrError("xmlrpc protocol error connecting to %s: %s %s"
120
207
                        % (self.service_url, e.errcode, e.errmsg))
 
208
        except socket.gaierror, e:
 
209
            raise errors.ConnectionError(
 
210
                "Could not resolve '%s'" % self.domain,
 
211
                orig_error=e)
121
212
        return result
122
213
 
 
214
    @property
 
215
    def domain(self):
 
216
        if self._lp_instance is None:
 
217
            instance = self.DEFAULT_INSTANCE
 
218
        else:
 
219
            instance = self._lp_instance
 
220
        return self.LAUNCHPAD_DOMAINS[instance]
 
221
 
 
222
    def _guess_branch_path(self, branch_url, _request_factory=None):
 
223
        scheme, hostinfo, path = urlsplit(branch_url)[:3]
 
224
        if _request_factory is None:
 
225
            _request_factory = ResolveLaunchpadPathRequest
 
226
        if scheme == 'lp':
 
227
            resolve = _request_factory(path)
 
228
            try:
 
229
                result = resolve.submit(self)
 
230
            except xmlrpclib.Fault, fault:
 
231
                raise errors.InvalidURL(branch_url, str(fault))
 
232
            branch_url = result['urls'][0]
 
233
            path = urlsplit(branch_url)[2]
 
234
        else:
 
235
            domains = (
 
236
                'bazaar.%s' % domain
 
237
                for domain in self.LAUNCHPAD_DOMAINS.itervalues())
 
238
            if hostinfo not in domains:
 
239
                raise NotLaunchpadBranch(branch_url)
 
240
        return path.lstrip('/')
 
241
 
 
242
    def get_web_url_from_branch_url(self, branch_url, _request_factory=None):
 
243
        """Get the Launchpad web URL for the given branch URL.
 
244
 
 
245
        :raise errors.InvalidURL: if 'branch_url' cannot be identified as a
 
246
            Launchpad branch URL.
 
247
        :return: The URL of the branch on Launchpad.
 
248
        """
 
249
        path = self._guess_branch_path(branch_url, _request_factory)
 
250
        return urlutils.join('https://code.%s' % self.domain, path)
 
251
 
123
252
 
124
253
class BaseRequest(object):
125
254
    """Base request for talking to a XMLRPC server."""
126
255
 
127
256
    # Set this to the XMLRPC method name.
128
257
    _methodname = None
 
258
    _authenticated = True
129
259
 
130
260
    def _request_params(self):
131
261
        """Return the arguments to pass to the method"""
137
267
        :param service: LaunchpadService indicating where to send
138
268
            the request and the authentication credentials.
139
269
        """
140
 
        return service.send_request(self._methodname, self._request_params())
 
270
        return service.send_request(self._methodname, self._request_params(),
 
271
                                    self._authenticated)
141
272
 
142
273
 
143
274
class DryRunLaunchpadService(LaunchpadService):
144
275
    """Service that just absorbs requests without sending to server.
145
 
    
 
276
 
146
277
    The dummy service does not need authentication.
147
278
    """
148
279
 
149
 
    def send_request(self, method_name, method_params):
 
280
    def send_request(self, method_name, method_params, authenticated):
150
281
        pass
151
282
 
152
283
    def gather_user_credentials(self):
165
296
                 author_email='',
166
297
                 product_name='',
167
298
                 ):
168
 
        assert branch_url
 
299
        if not branch_url:
 
300
            raise errors.InvalidURL(branch_url, "You need to specify a non-empty branch URL.")
169
301
        self.branch_url = branch_url
170
302
        if branch_name:
171
303
            self.branch_name = branch_name
199
331
    _methodname = 'link_branch_to_bug'
200
332
 
201
333
    def __init__(self, branch_url, bug_id):
202
 
        assert branch_url
203
334
        self.bug_id = bug_id
204
335
        self.branch_url = branch_url
205
336
 
208
339
        # This must match the parameter tuple expected by Launchpad for this
209
340
        # method
210
341
        return (self.branch_url, self.bug_id, '')
 
342
 
 
343
 
 
344
class ResolveLaunchpadPathRequest(BaseRequest):
 
345
    """Request to resolve the path component of an lp: URL."""
 
346
 
 
347
    _methodname = 'resolve_lp_path'
 
348
    _authenticated = False
 
349
 
 
350
    def __init__(self, path):
 
351
        if not path:
 
352
            raise errors.InvalidURL(path=path,
 
353
                                    extra="You must specify a project.")
 
354
        self.path = path
 
355
 
 
356
    def _request_params(self):
 
357
        """Return xmlrpc request parameters"""
 
358
        return (self.path,)