~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: 2010-01-15 05:43:42 UTC
  • mfrom: (4734.4.13 bug-440952-bzrdir)
  • Revision ID: pqm@pqm.ubuntu.com-20100115054342-o6ar5y4ch9tcnzyi
(andrew) Give 'location is a repository' hint for NotBranchError
        (#440952).

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
    
 
83
 
35
84
    See http://bazaar-vcs.org/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
        'edge': 'edge.launchpad.net',
 
90
        'staging': 'staging.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 edge as the default because:
 
102
    # Beta users get redirected to it
 
103
    # All users can use it
 
104
    # 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]
41
107
 
42
108
    transport = None
43
109
    registrant_email = None
44
110
    registrant_password = None
45
111
 
46
112
 
47
 
    def __init__(self, transport=None):
 
113
    def __init__(self, transport=None, lp_instance=None):
48
114
        """Construct a new service talking to the launchpad rpc server"""
 
115
        self._lp_instance = lp_instance
49
116
        if transport is None:
50
117
            uri_type = urllib.splittype(self.service_url)[0]
51
 
            if uri_type == 'https':
52
 
                transport = xmlrpclib.SafeTransport()
53
 
            else:
54
 
                transport = xmlrpclib.Transport()
 
118
            transport = XMLRPCTransport(uri_type)
55
119
            transport.user_agent = 'bzr/%s (xmlrpclib/%s)' \
56
 
                    % (bzrlib.__version__, xmlrpclib.__version__)
 
120
                    % (_bzrlib_version, xmlrpclib.__version__)
57
121
        self.transport = transport
58
122
 
59
 
 
60
123
    @property
61
124
    def service_url(self):
62
125
        """Return the http or https url for the xmlrpc server.
66
129
        key = 'BZR_LP_XMLRPC_URL'
67
130
        if key in os.environ:
68
131
            return os.environ[key]
 
132
        elif self._lp_instance is not None:
 
133
            try:
 
134
                return self.LAUNCHPAD_INSTANCE[self._lp_instance]
 
135
            except KeyError:
 
136
                raise InvalidLaunchpadInstance(self._lp_instance)
69
137
        else:
70
138
            return self.DEFAULT_SERVICE_URL
71
139
 
72
 
    def get_proxy(self):
 
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
    def get_proxy(self, authenticated):
73
152
        """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, '', ''))
 
153
        if authenticated:
 
154
            # auth info must be in url
 
155
            # TODO: if there's no registrant email perhaps we should
 
156
            # just connect anonymously?
 
157
            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()
 
164
            # TODO: perhaps fully quote the password to make it very slightly
 
165
            # obscured
 
166
            # TODO: can we perhaps add extra Authorization headers
 
167
            # directly to the request, rather than putting this into
 
168
            # the url?  perhaps a bit more secure against accidentally
 
169
            # revealing it.  std66 s3.2.1 discourages putting the
 
170
            # password in the url.
 
171
            hostinfo = '%s:%s@%s' % (urllib.quote(self.registrant_email),
 
172
                                     urllib.quote(self.registrant_password),
 
173
                                     hostinfo)
 
174
            url = urlunsplit((scheme, hostinfo, path, '', ''))
 
175
        else:
 
176
            url = self.service_url
91
177
        return xmlrpclib.ServerProxy(url, transport=self.transport)
92
178
 
93
179
    def gather_user_credentials(self):
94
180
        """Get the password from the user."""
95
 
        config = bzrlib.config.GlobalConfig()
96
 
        self.registrant_email = config.user_email()
 
181
        the_config = config.GlobalConfig()
 
182
        self.registrant_email = the_config.user_email()
97
183
        if self.registrant_password is None:
 
184
            auth = config.AuthenticationConfig()
 
185
            scheme, hostinfo = urlsplit(self.service_url)[:2]
98
186
            prompt = 'launchpad.net password for %s: ' % \
99
187
                    self.registrant_email
100
 
            self.registrant_password = getpass(prompt)
 
188
            # We will reuse http[s] credentials if we can, prompt user
 
189
            # otherwise
 
190
            self.registrant_password = auth.get_password(scheme, hostinfo,
 
191
                                                         self.registrant_email,
 
192
                                                         prompt=prompt)
101
193
 
102
 
    def send_request(self, method_name, method_params):
103
 
        proxy = self.get_proxy()
104
 
        assert method_name
 
194
    def send_request(self, method_name, method_params, authenticated):
 
195
        proxy = self.get_proxy(authenticated)
105
196
        method = getattr(proxy, method_name)
106
197
        try:
107
198
            result = method(*method_params)
118
209
                # TODO: print more headers to help in tracking down failures
119
210
                raise errors.BzrError("xmlrpc protocol error connecting to %s: %s %s"
120
211
                        % (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)
121
216
        return result
122
217
 
 
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
 
123
256
 
124
257
class BaseRequest(object):
125
258
    """Base request for talking to a XMLRPC server."""
126
259
 
127
260
    # Set this to the XMLRPC method name.
128
261
    _methodname = None
 
262
    _authenticated = True
129
263
 
130
264
    def _request_params(self):
131
265
        """Return the arguments to pass to the method"""
137
271
        :param service: LaunchpadService indicating where to send
138
272
            the request and the authentication credentials.
139
273
        """
140
 
        return service.send_request(self._methodname, self._request_params())
 
274
        return service.send_request(self._methodname, self._request_params(),
 
275
                                    self._authenticated)
141
276
 
142
277
 
143
278
class DryRunLaunchpadService(LaunchpadService):
144
279
    """Service that just absorbs requests without sending to server.
145
 
    
 
280
 
146
281
    The dummy service does not need authentication.
147
282
    """
148
283
 
149
 
    def send_request(self, method_name, method_params):
 
284
    def send_request(self, method_name, method_params, authenticated):
150
285
        pass
151
286
 
152
287
    def gather_user_credentials(self):
165
300
                 author_email='',
166
301
                 product_name='',
167
302
                 ):
168
 
        assert branch_url
 
303
        if not branch_url:
 
304
            raise errors.InvalidURL(branch_url, "You need to specify a non-empty branch URL.")
169
305
        self.branch_url = branch_url
170
306
        if branch_name:
171
307
            self.branch_name = branch_name
199
335
    _methodname = 'link_branch_to_bug'
200
336
 
201
337
    def __init__(self, branch_url, bug_id):
202
 
        assert branch_url
203
338
        self.bug_id = bug_id
204
339
        self.branch_url = branch_url
205
340
 
208
343
        # This must match the parameter tuple expected by Launchpad for this
209
344
        # method
210
345
        return (self.branch_url, self.bug_id, '')
 
346
 
 
347
 
 
348
class ResolveLaunchpadPathRequest(BaseRequest):
 
349
    """Request to resolve the path component of an lp: URL."""
 
350
 
 
351
    _methodname = 'resolve_lp_path'
 
352
    _authenticated = False
 
353
 
 
354
    def __init__(self, path):
 
355
        if not path:
 
356
            raise errors.InvalidURL(path=path,
 
357
                                    extra="You must specify a project.")
 
358
        self.path = path
 
359
 
 
360
    def _request_params(self):
 
361
        """Return xmlrpc request parameters"""
 
362
        return (self.path,)