~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/plugins/launchpad/lp_directory.py

  • Committer: John Arbash Meinel
  • Date: 2011-05-11 11:35:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5851.
  • Revision ID: john@arbash-meinel.com-20110511113528-qepibuwxicjrbb2h
Break compatibility with python <2.6.

This includes auditing the code for places where we were doing
explicit 'sys.version' checks and removing them as appropriate.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007-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
24
24
    debug,
25
25
    errors,
26
26
    trace,
27
 
    )
28
 
from bzrlib.transport import (
29
 
    get_transport,
30
 
    register_urlparse_netloc_protocol,
 
27
    transport,
31
28
    )
32
29
 
33
30
from bzrlib.plugins.launchpad.lp_registration import (
37
34
 
38
35
# As bzrlib.transport.remote may not be loaded yet, make sure bzr+ssh
39
36
# is counted as a netloc protocol.
40
 
register_urlparse_netloc_protocol('bzr+ssh')
41
 
register_urlparse_netloc_protocol('lp')
 
37
transport.register_urlparse_netloc_protocol('bzr+ssh')
 
38
transport.register_urlparse_netloc_protocol('lp')
 
39
 
 
40
_ubuntu_series_shortcuts = {
 
41
    'n': 'natty',
 
42
    'm': 'maverick',
 
43
    'l': 'lucid',
 
44
    'k': 'karmic',
 
45
    'j': 'jaunty',
 
46
    'h': 'hardy',
 
47
    'd': 'dapper',
 
48
    }
42
49
 
43
50
 
44
51
class LaunchpadDirectory(object):
58
65
        """See DirectoryService.look_up"""
59
66
        return self._resolve(url)
60
67
 
61
 
    def _resolve(self, url,
62
 
                 _request_factory=ResolveLaunchpadPathRequest,
63
 
                 _lp_login=None):
64
 
        """Resolve the base URL for this transport."""
 
68
    def _resolve_locally(self, path, url, _request_factory):
 
69
        # This is the best I could work out about XMLRPC. If an lp: url
 
70
        # includes ~user, then it is specially validated. Otherwise, it is just
 
71
        # sent to +branch/$path.
 
72
        _, netloc, _, _, _ = urlsplit(url)
 
73
        if netloc == '':
 
74
            netloc = LaunchpadService.DEFAULT_INSTANCE
 
75
        base_url = LaunchpadService.LAUNCHPAD_DOMAINS[netloc]
 
76
        base = 'bzr+ssh://bazaar.%s/' % (base_url,)
 
77
        maybe_invalid = False
 
78
        if path.startswith('~'):
 
79
            # A ~user style path, validate it a bit.
 
80
            # If a path looks fishy, fall back to asking XMLRPC to
 
81
            # resolve it for us. That way we still get their nicer error
 
82
            # messages.
 
83
            parts = path.split('/')
 
84
            if (len(parts) < 3
 
85
                or (parts[1] in ('ubuntu', 'debian') and len(parts) < 5)):
 
86
                # This special case requires 5-parts to be valid.
 
87
                maybe_invalid = True
 
88
        else:
 
89
            base += '+branch/'
 
90
        if maybe_invalid:
 
91
            return self._resolve_via_xmlrpc(path, url, _request_factory)
 
92
        return {'urls': [base + path]}
 
93
 
 
94
    def _resolve_via_xmlrpc(self, path, url, _request_factory):
65
95
        service = LaunchpadService.for_url(url)
66
 
        result = urlsplit(url)
67
 
        if _lp_login is None:
68
 
            _lp_login = get_lp_login()
69
 
        path = result[2].strip('/')
70
 
        if path.startswith('~/'):
71
 
            if _lp_login is None:
72
 
                raise errors.InvalidURL(path=url,
73
 
                    extra='Cannot resolve "~" to your username.'
74
 
                          ' See "bzr help launchpad-login"')
75
 
            path = '~' + _lp_login + path[1:]
76
96
        resolve = _request_factory(path)
77
97
        try:
78
98
            result = resolve.submit(service)
79
99
        except xmlrpclib.Fault, fault:
80
100
            raise errors.InvalidURL(
81
101
                path=url, extra=fault.faultString)
 
102
        return result
 
103
 
 
104
    def _update_url_scheme(self, url):
 
105
        # Do ubuntu: and debianlp: expansions.
 
106
        scheme, netloc, path, query, fragment = urlsplit(url)
 
107
        if scheme in ('ubuntu', 'debianlp'):
 
108
            if scheme == 'ubuntu':
 
109
                distro = 'ubuntu'
 
110
                distro_series = _ubuntu_series_shortcuts
 
111
            elif scheme == 'debianlp':
 
112
                distro = 'debian'
 
113
                # No shortcuts for Debian distroseries.
 
114
                distro_series = {}
 
115
            else:
 
116
                raise AssertionError('scheme should be ubuntu: or debianlp:')
 
117
            # Split the path.  It's either going to be 'project' or
 
118
            # 'series/project', but recognize that it may be a series we don't
 
119
            # know about.
 
120
            path_parts = path.split('/')
 
121
            if len(path_parts) == 1:
 
122
                # It's just a project name.
 
123
                lp_url_template = 'lp:%(distro)s/%(project)s'
 
124
                project = path_parts[0]
 
125
                series = None
 
126
            elif len(path_parts) == 2:
 
127
                # It's a series and project.
 
128
                lp_url_template = 'lp:%(distro)s/%(series)s/%(project)s'
 
129
                series, project = path_parts
 
130
            else:
 
131
                # There are either 0 or > 2 path parts, neither of which is
 
132
                # supported for these schemes.
 
133
                raise errors.InvalidURL('Bad path: %s' % result.path)
 
134
            # Expand any series shortcuts, but keep unknown series.
 
135
            series = distro_series.get(series, series)
 
136
            # Hack the url and let the following do the final resolution.
 
137
            url = lp_url_template % dict(
 
138
                distro=distro,
 
139
                series=series,
 
140
                project=project)
 
141
            scheme, netloc, path, query, fragment = urlsplit(url)
 
142
        return url, path
 
143
 
 
144
    def _expand_user(self, path, url, lp_login):
 
145
        if path.startswith('~/'):
 
146
            if lp_login is None:
 
147
                raise errors.InvalidURL(path=url,
 
148
                    extra='Cannot resolve "~" to your username.'
 
149
                          ' See "bzr help launchpad-login"')
 
150
            path = '~' + lp_login + path[1:]
 
151
        return path
 
152
 
 
153
    def _resolve(self, url,
 
154
                 _request_factory=ResolveLaunchpadPathRequest,
 
155
                 _lp_login=None):
 
156
        """Resolve the base URL for this transport."""
 
157
        url, path = self._update_url_scheme(url)
 
158
        if _lp_login is None:
 
159
            _lp_login = get_lp_login()
 
160
        path = path.strip('/')
 
161
        path = self._expand_user(path, url, _lp_login)
 
162
        if _lp_login is not None:
 
163
            result = self._resolve_locally(path, url, _request_factory)
 
164
            if 'launchpad' in debug.debug_flags:
 
165
                local_res = result
 
166
                result = self._resolve_via_xmlrpc(path, url, _request_factory)
 
167
                trace.note('resolution for %s\n  local: %s\n remote: %s'
 
168
                           % (url, local_res['urls'], result['urls']))
 
169
        else:
 
170
            result = self._resolve_via_xmlrpc(path, url, _request_factory)
82
171
 
83
172
        if 'launchpad' in debug.debug_flags:
84
173
            trace.mutter("resolve_lp_path(%r) == %r", url, result)
101
190
            else:
102
191
                # Use the URL if we can create a transport for it.
103
192
                try:
104
 
                    get_transport(url)
 
193
                    transport.get_transport(url)
105
194
                except (errors.PathError, errors.TransportError):
106
195
                    pass
107
196
                else: