← 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: 2008-04-07 07:52:50 UTC
  • mfrom: (3340.1.1 208418-1.4)
  • Revision ID: pqm@pqm.ubuntu.com-20080407075250-phs53xnslo8boaeo
Return the correct knit serialisation method in _StreamAccess.
        (Andrew Bennetts, Martin Pool, Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugins/launchpad/lp_registration.py
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
'''
43
40
        errors.BzrError.__init__(self, lp_instance=lp_instance)
44
41
 
45
42
 
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
43
class LaunchpadService(object):
82
44
    """A service to talk to Launchpad via XMLRPC.
83
45
 
84
46
    See http://bazaar-vcs.org/Specs/LaunchpadRpc for the methods we can call.
85
47
    """
86
48
 
87
 
    LAUNCHPAD_DOMAINS = {
88
 
        'production': 'launchpad.net',
89
 
        'edge': 'edge.launchpad.net',
90
 
        'staging': 'staging.launchpad.net',
91
 
        'demo': 'demo.launchpad.net',
92
 
        'dev': 'launchpad.dev',
93
 
        }
94
 
 
95
49
    # NB: these should always end in a slash to avoid xmlrpclib appending
96
50
    # '/RPC2'
97
 
    LAUNCHPAD_INSTANCE = {}
98
 
    for instance, domain in LAUNCHPAD_DOMAINS.iteritems():
99
 
        LAUNCHPAD_INSTANCE[instance] = 'https://xmlrpc.%s/bazaar/' % domain
100
 
 
101
51
    # We use edge as the default because:
102
52
    # Beta users get redirected to it
103
53
    # All users can use it
104
54
    # There is a bug in the launchpad side where redirection causes an OOPS.
105
 
    DEFAULT_INSTANCE = 'edge'
106
 
    DEFAULT_SERVICE_URL = LAUNCHPAD_INSTANCE[DEFAULT_INSTANCE]
 
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']
107
63
 
108
64
    transport = None
109
65
    registrant_email = None
115
71
        self._lp_instance = lp_instance
116
72
        if transport is None:
117
73
            uri_type = urllib.splittype(self.service_url)[0]
118
 
            transport = XMLRPCTransport(uri_type)
 
74
            if uri_type == 'https':
 
75
                transport = xmlrpclib.SafeTransport()
 
76
            else:
 
77
                transport = xmlrpclib.Transport()
119
78
            transport.user_agent = 'bzr/%s (xmlrpclib/%s)' \
120
79
                    % (_bzrlib_version, xmlrpclib.__version__)
121
80
        self.transport = transport
122
81
 
 
82
 
123
83
    @property
124
84
    def service_url(self):
125
85
        """Return the http or https url for the xmlrpc server.
137
97
        else:
138
98
            return self.DEFAULT_SERVICE_URL
139
99
 
140
 
    @classmethod
141
 
    def for_url(cls, url, **kwargs):
142
 
        """Return the Launchpad service corresponding to the given URL."""
143
 
        result = urlsplit(url)
144
 
        lp_instance = result[1]
145
 
        if lp_instance == '':
146
 
            lp_instance = None
147
 
        elif lp_instance not in cls.LAUNCHPAD_INSTANCE:
148
 
            raise errors.InvalidURL(path=url)
149
 
        return cls(lp_instance=lp_instance, **kwargs)
150
 
 
151
100
    def get_proxy(self, authenticated):
152
101
        """Return the proxy for XMLRPC requests."""
153
102
        if authenticated:
155
104
            # TODO: if there's no registrant email perhaps we should
156
105
            # just connect anonymously?
157
106
            scheme, hostinfo, path = urlsplit(self.service_url)[:3]
158
 
            if '@' in hostinfo:
159
 
                raise AssertionError(hostinfo)
160
 
            if self.registrant_email is None:
161
 
                raise AssertionError()
162
 
            if self.registrant_password is None:
163
 
                raise AssertionError()
 
107
            assert '@' not in hostinfo
 
108
            assert self.registrant_email is not None
 
109
            assert self.registrant_password is not None
164
110
            # TODO: perhaps fully quote the password to make it very slightly
165
111
            # obscured
166
112
            # TODO: can we perhaps add extra Authorization headers
193
139
 
194
140
    def send_request(self, method_name, method_params, authenticated):
195
141
        proxy = self.get_proxy(authenticated)
 
142
        assert method_name
196
143
        method = getattr(proxy, method_name)
197
144
        try:
198
145
            result = method(*method_params)
209
156
                # TODO: print more headers to help in tracking down failures
210
157
                raise errors.BzrError("xmlrpc protocol error connecting to %s: %s %s"
211
158
                        % (self.service_url, e.errcode, e.errmsg))
212
 
        except socket.gaierror, e:
213
 
            raise errors.ConnectionError(
214
 
                "Could not resolve '%s'" % self.domain,
215
 
                orig_error=e)
216
159
        return result
217
160
 
218
 
    @property
219
 
    def domain(self):
220
 
        if self._lp_instance is None:
221
 
            instance = self.DEFAULT_INSTANCE
222
 
        else:
223
 
            instance = self._lp_instance
224
 
        return self.LAUNCHPAD_DOMAINS[instance]
225
 
 
226
 
    def _guess_branch_path(self, branch_url, _request_factory=None):
227
 
        scheme, hostinfo, path = urlsplit(branch_url)[:3]
228
 
        if _request_factory is None:
229
 
            _request_factory = ResolveLaunchpadPathRequest
230
 
        if scheme == 'lp':
231
 
            resolve = _request_factory(path)
232
 
            try:
233
 
                result = resolve.submit(self)
234
 
            except xmlrpclib.Fault, fault:
235
 
                raise errors.InvalidURL(branch_url, str(fault))
236
 
            branch_url = result['urls'][0]
237
 
            path = urlsplit(branch_url)[2]
238
 
        else:
239
 
            domains = (
240
 
                'bazaar.%s' % domain
241
 
                for domain in self.LAUNCHPAD_DOMAINS.itervalues())
242
 
            if hostinfo not in domains:
243
 
                raise NotLaunchpadBranch(branch_url)
244
 
        return path.lstrip('/')
245
 
 
246
 
    def get_web_url_from_branch_url(self, branch_url, _request_factory=None):
247
 
        """Get the Launchpad web URL for the given branch URL.
248
 
 
249
 
        :raise errors.InvalidURL: if 'branch_url' cannot be identified as a
250
 
            Launchpad branch URL.
251
 
        :return: The URL of the branch on Launchpad.
252
 
        """
253
 
        path = self._guess_branch_path(branch_url, _request_factory)
254
 
        return urlutils.join('https://code.%s' % self.domain, path)
255
 
 
256
161
 
257
162
class BaseRequest(object):
258
163
    """Base request for talking to a XMLRPC server."""
277
182
 
278
183
class DryRunLaunchpadService(LaunchpadService):
279
184
    """Service that just absorbs requests without sending to server.
280
 
 
 
185
    
281
186
    The dummy service does not need authentication.
282
187
    """
283
188
 
335
240
    _methodname = 'link_branch_to_bug'
336
241
 
337
242
    def __init__(self, branch_url, bug_id):
 
243
        assert branch_url
338
244
        self.bug_id = bug_id
339
245
        self.branch_url = branch_url
340
246
 
354
260
    def __init__(self, path):
355
261
        if not path:
356
262
            raise errors.InvalidURL(path=path,
357
 
                                    extra="You must specify a project.")
 
263
                                    extra="You must specify a product.")
358
264
        self.path = path
359
265
 
360
266
    def _request_params(self):