← 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: Ian Clatworthy
  • Date: 2007-11-28 00:18:10 UTC
  • mto: (3054.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3055.
  • Revision ID: ian.clatworthy@internode.on.net-20071128001810-978qqnjpd12u4we2
change Makefile to support tutorials

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 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
from getpass import getpass
18
19
import os
19
 
import socket
20
20
from urlparse import urlsplit, urlunsplit
21
21
import urllib
22
22
import xmlrpclib
24
24
from bzrlib import (
25
25
    config,
26
26
    errors,
27
 
    urlutils,
28
27
    __version__ as _bzrlib_version,
29
28
    )
30
 
from bzrlib.transport.http import _urllib2_wrappers
31
 
 
32
29
 
33
30
# for testing, do
34
31
'''
35
32
export BZR_LP_XMLRPC_URL=http://xmlrpc.staging.launchpad.net/bazaar/
36
33
'''
37
34
 
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
 
 
81
35
class LaunchpadService(object):
82
36
    """A service to talk to Launchpad via XMLRPC.
83
 
 
84
 
    See http://wiki.bazaar.canonical.com/Specs/LaunchpadRpc for the methods we can call.
 
37
    
 
38
    See http://bazaar-vcs.org/Specs/LaunchpadRpc for the methods we can call.
85
39
    """
86
40
 
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
 
41
    # NB: this should always end in a slash to avoid xmlrpclib appending
96
42
    # '/RPC2'
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]
 
43
    DEFAULT_SERVICE_URL = 'https://xmlrpc.launchpad.net/bazaar/'
105
44
 
106
45
    transport = None
107
46
    registrant_email = None
108
47
    registrant_password = None
109
48
 
110
49
 
111
 
    def __init__(self, transport=None, lp_instance=None):
 
50
    def __init__(self, transport=None):
112
51
        """Construct a new service talking to the launchpad rpc server"""
113
 
        self._lp_instance = lp_instance
114
52
        if transport is None:
115
53
            uri_type = urllib.splittype(self.service_url)[0]
116
 
            transport = XMLRPCTransport(uri_type)
 
54
            if uri_type == 'https':
 
55
                transport = xmlrpclib.SafeTransport()
 
56
            else:
 
57
                transport = xmlrpclib.Transport()
117
58
            transport.user_agent = 'bzr/%s (xmlrpclib/%s)' \
118
59
                    % (_bzrlib_version, xmlrpclib.__version__)
119
60
        self.transport = transport
120
61
 
 
62
 
121
63
    @property
122
64
    def service_url(self):
123
65
        """Return the http or https url for the xmlrpc server.
127
69
        key = 'BZR_LP_XMLRPC_URL'
128
70
        if key in os.environ:
129
71
            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)
135
72
        else:
136
73
            return self.DEFAULT_SERVICE_URL
137
74
 
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
75
    def get_proxy(self, authenticated):
150
76
        """Return the proxy for XMLRPC requests."""
151
77
        if authenticated:
153
79
            # TODO: if there's no registrant email perhaps we should
154
80
            # just connect anonymously?
155
81
            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()
 
82
            assert '@' not in hostinfo
 
83
            assert self.registrant_email is not None
 
84
            assert self.registrant_password is not None
162
85
            # TODO: perhaps fully quote the password to make it very slightly
163
86
            # obscured
164
87
            # TODO: can we perhaps add extra Authorization headers
191
114
 
192
115
    def send_request(self, method_name, method_params, authenticated):
193
116
        proxy = self.get_proxy(authenticated)
 
117
        assert method_name
194
118
        method = getattr(proxy, method_name)
195
119
        try:
196
120
            result = method(*method_params)
207
131
                # TODO: print more headers to help in tracking down failures
208
132
                raise errors.BzrError("xmlrpc protocol error connecting to %s: %s %s"
209
133
                        % (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)
214
134
        return result
215
135
 
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
 
 
254
136
 
255
137
class BaseRequest(object):
256
138
    """Base request for talking to a XMLRPC server."""
275
157
 
276
158
class DryRunLaunchpadService(LaunchpadService):
277
159
    """Service that just absorbs requests without sending to server.
278
 
 
 
160
    
279
161
    The dummy service does not need authentication.
280
162
    """
281
163
 
298
180
                 author_email='',
299
181
                 product_name='',
300
182
                 ):
301
 
        if not branch_url:
302
 
            raise errors.InvalidURL(branch_url, "You need to specify a non-empty branch URL.")
 
183
        assert branch_url
303
184
        self.branch_url = branch_url
304
185
        if branch_name:
305
186
            self.branch_name = branch_name
333
214
    _methodname = 'link_branch_to_bug'
334
215
 
335
216
    def __init__(self, branch_url, bug_id):
 
217
        assert branch_url
336
218
        self.bug_id = bug_id
337
219
        self.branch_url = branch_url
338
220
 
350
232
    _authenticated = False
351
233
 
352
234
    def __init__(self, path):
353
 
        if not path:
354
 
            raise errors.InvalidURL(path=path,
355
 
                                    extra="You must specify a project.")
 
235
        assert path
356
236
        self.path = path
357
237
 
358
238
    def _request_params(self):