← 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: Canonical.com Patch Queue Manager
  • Date: 2006-08-17 13:33:28 UTC
  • mfrom: (1908.4.15 commit-perf)
  • Revision ID: pqm@pqm.ubuntu.com-20060817133328-ba4026886ad6a107
(jam) small tuning of gzip, more commit benchmarks

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugins/launchpad/lp_registration.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006 by 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
from __future__ import absolute_import
18
 
 
19
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
from getpass import getpass
20
19
import os
21
 
import socket
22
20
from urlparse import urlsplit, urlunsplit
23
21
import urllib
24
22
import xmlrpclib
25
23
 
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
 
 
 
24
import bzrlib.config
 
25
import bzrlib.errors as errors
34
26
 
35
27
# for testing, do
36
28
'''
37
29
export BZR_LP_XMLRPC_URL=http://xmlrpc.staging.launchpad.net/bazaar/
38
30
'''
39
31
 
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
 
 
79
32
class LaunchpadService(object):
80
33
    """A service to talk to Launchpad via XMLRPC.
81
 
 
82
 
    See http://wiki.bazaar.canonical.com/Specs/LaunchpadRpc for the methods we can call.
 
34
    
 
35
    See http://bazaar-vcs.org/Specs/LaunchpadRpc for the methods we can call.
83
36
    """
84
37
 
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
 
38
    # NB: this should always end in a slash to avoid xmlrpclib appending
94
39
    # '/RPC2'
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]
 
40
    DEFAULT_SERVICE_URL = 'https://xmlrpc.launchpad.net/bazaar/'
103
41
 
104
42
    transport = None
105
43
    registrant_email = None
106
44
    registrant_password = None
107
45
 
108
46
 
109
 
    def __init__(self, transport=None, lp_instance=None):
 
47
    def __init__(self, transport=None):
110
48
        """Construct a new service talking to the launchpad rpc server"""
111
 
        self._lp_instance = lp_instance
112
49
        if transport is None:
113
50
            uri_type = urllib.splittype(self.service_url)[0]
114
 
            transport = XMLRPCTransport(uri_type)
 
51
            if uri_type == 'https':
 
52
                transport = xmlrpclib.SafeTransport()
 
53
            else:
 
54
                transport = xmlrpclib.Transport()
115
55
            transport.user_agent = 'bzr/%s (xmlrpclib/%s)' \
116
 
                    % (_bzrlib_version, xmlrpclib.__version__)
 
56
                    % (bzrlib.__version__, xmlrpclib.__version__)
117
57
        self.transport = transport
118
58
 
 
59
 
119
60
    @property
120
61
    def service_url(self):
121
62
        """Return the http or https url for the xmlrpc server.
125
66
        key = 'BZR_LP_XMLRPC_URL'
126
67
        if key in os.environ:
127
68
            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)
133
69
        else:
134
70
            return self.DEFAULT_SERVICE_URL
135
71
 
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):
 
72
    def get_proxy(self):
148
73
        """Return the proxy for XMLRPC requests."""
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
 
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, '', ''))
173
91
        return xmlrpclib.ServerProxy(url, transport=self.transport)
174
92
 
175
93
    def gather_user_credentials(self):
176
94
        """Get the password from the user."""
177
 
        the_config = config.GlobalConfig()
178
 
        self.registrant_email = the_config.user_email()
 
95
        config = bzrlib.config.GlobalConfig()
 
96
        self.registrant_email = config.user_email()
179
97
        if self.registrant_password is None:
180
 
            auth = config.AuthenticationConfig()
181
 
            scheme, hostinfo = urlsplit(self.service_url)[:2]
182
98
            prompt = 'launchpad.net password for %s: ' % \
183
99
                    self.registrant_email
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)
 
100
            self.registrant_password = getpass(prompt)
189
101
 
190
 
    def send_request(self, method_name, method_params, authenticated):
191
 
        proxy = self.get_proxy(authenticated)
 
102
    def send_request(self, method_name, method_params):
 
103
        proxy = self.get_proxy()
 
104
        assert method_name
192
105
        method = getattr(proxy, method_name)
193
106
        try:
194
107
            result = method(*method_params)
205
118
                # TODO: print more headers to help in tracking down failures
206
119
                raise errors.BzrError("xmlrpc protocol error connecting to %s: %s %s"
207
120
                        % (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)
212
121
        return result
213
122
 
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
 
 
252
123
 
253
124
class BaseRequest(object):
254
125
    """Base request for talking to a XMLRPC server."""
255
126
 
256
127
    # Set this to the XMLRPC method name.
257
128
    _methodname = None
258
 
    _authenticated = True
259
129
 
260
130
    def _request_params(self):
261
131
        """Return the arguments to pass to the method"""
267
137
        :param service: LaunchpadService indicating where to send
268
138
            the request and the authentication credentials.
269
139
        """
270
 
        return service.send_request(self._methodname, self._request_params(),
271
 
                                    self._authenticated)
 
140
        return service.send_request(self._methodname, self._request_params())
272
141
 
273
142
 
274
143
class DryRunLaunchpadService(LaunchpadService):
275
144
    """Service that just absorbs requests without sending to server.
276
 
 
 
145
    
277
146
    The dummy service does not need authentication.
278
147
    """
279
148
 
280
 
    def send_request(self, method_name, method_params, authenticated):
 
149
    def send_request(self, method_name, method_params):
281
150
        pass
282
151
 
283
152
    def gather_user_credentials(self):
296
165
                 author_email='',
297
166
                 product_name='',
298
167
                 ):
299
 
        if not branch_url:
300
 
            raise errors.InvalidURL(branch_url, "You need to specify a non-empty branch URL.")
 
168
        assert branch_url
301
169
        self.branch_url = branch_url
302
170
        if branch_name:
303
171
            self.branch_name = branch_name
331
199
    _methodname = 'link_branch_to_bug'
332
200
 
333
201
    def __init__(self, branch_url, bug_id):
 
202
        assert branch_url
334
203
        self.bug_id = bug_id
335
204
        self.branch_url = branch_url
336
205
 
339
208
        # This must match the parameter tuple expected by Launchpad for this
340
209
        # method
341
210
        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,)