← 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: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

Show diffs side-by-side

added added

removed removed

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