← 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: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

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
24
24
from bzrlib import (
25
25
    config,
26
26
    errors,
 
27
    urlutils,
27
28
    __version__ as _bzrlib_version,
28
29
    )
 
30
from bzrlib.transport.http import _urllib2_wrappers
 
31
 
29
32
 
30
33
# for testing, do
31
34
'''
40
43
        errors.BzrError.__init__(self, lp_instance=lp_instance)
41
44
 
42
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
 
43
81
class LaunchpadService(object):
44
82
    """A service to talk to Launchpad via XMLRPC.
45
83
 
46
 
    See http://bazaar-vcs.org/Specs/LaunchpadRpc for the methods we can call.
 
84
    See http://wiki.bazaar.canonical.com/Specs/LaunchpadRpc for the methods we can call.
47
85
    """
48
86
 
 
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
 
49
95
    # NB: these should always end in a slash to avoid xmlrpclib appending
50
96
    # '/RPC2'
51
 
    # We use edge as the default because:
52
 
    # Beta users get redirected to it
53
 
    # All users can use it
54
 
    # There is a bug in the launchpad side where redirection causes an OOPS.
55
 
    LAUNCHPAD_INSTANCE = {
56
 
        'production': 'https://xmlrpc.launchpad.net/bazaar/',
57
 
        'edge': 'https://xmlrpc.edge.launchpad.net/bazaar/',
58
 
        'staging': 'https://xmlrpc.staging.launchpad.net/bazaar/',
59
 
        'demo': 'https://xmlrpc.demo.launchpad.net/bazaar/',
60
 
        'dev': 'http://xmlrpc.launchpad.dev/bazaar/',
61
 
        }
62
 
    DEFAULT_SERVICE_URL = LAUNCHPAD_INSTANCE['edge']
 
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]
63
105
 
64
106
    transport = None
65
107
    registrant_email = None
71
113
        self._lp_instance = lp_instance
72
114
        if transport is None:
73
115
            uri_type = urllib.splittype(self.service_url)[0]
74
 
            if uri_type == 'https':
75
 
                transport = xmlrpclib.SafeTransport()
76
 
            else:
77
 
                transport = xmlrpclib.Transport()
 
116
            transport = XMLRPCTransport(uri_type)
78
117
            transport.user_agent = 'bzr/%s (xmlrpclib/%s)' \
79
118
                    % (_bzrlib_version, xmlrpclib.__version__)
80
119
        self.transport = transport
81
120
 
82
 
 
83
121
    @property
84
122
    def service_url(self):
85
123
        """Return the http or https url for the xmlrpc server.
97
135
        else:
98
136
            return self.DEFAULT_SERVICE_URL
99
137
 
 
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
 
100
149
    def get_proxy(self, authenticated):
101
150
        """Return the proxy for XMLRPC requests."""
102
151
        if authenticated:
158
207
                # TODO: print more headers to help in tracking down failures
159
208
                raise errors.BzrError("xmlrpc protocol error connecting to %s: %s %s"
160
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)
161
214
        return result
162
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
 
163
254
 
164
255
class BaseRequest(object):
165
256
    """Base request for talking to a XMLRPC server."""
184
275
 
185
276
class DryRunLaunchpadService(LaunchpadService):
186
277
    """Service that just absorbs requests without sending to server.
187
 
    
 
278
 
188
279
    The dummy service does not need authentication.
189
280
    """
190
281
 
261
352
    def __init__(self, path):
262
353
        if not path:
263
354
            raise errors.InvalidURL(path=path,
264
 
                                    extra="You must specify a product.")
 
355
                                    extra="You must specify a project.")
265
356
        self.path = path
266
357
 
267
358
    def _request_params(self):