Merge lp:~jelmer/brz/kill-pycurl into lp:brz

[Jelmer Vernooij]

Remove pycurl support.

Remove pycurl, go back to a single http implementation.

Remove the http+urllib:// bits, just use plain http URLs everywhere. This addresses several bugs.

[Martin Packman (gz)]

Looks good. If we want ntlm support again seems there are different python packages we could optional depend on instead.

review: Approve

[The Breezy Bot (the-breezy-bot)]

A commit message must be set
http://10.242.247.184:8080/job/brz-dev/95/

=== modified file 'breezy/tests/features.py'
--- breezy/tests/features.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/features.py	2017-06-08 20:56:03 +0000
@@ -350,7 +350,6 @@
 lzma = ModuleAvailableFeature('lzma')
 meliae = ModuleAvailableFeature('meliae.scanner')
 paramiko = ModuleAvailableFeature('paramiko')
-pycurl = ModuleAvailableFeature('pycurl')
 pywintypes = ModuleAvailableFeature('pywintypes')
 subunit = ModuleAvailableFeature('subunit')
 testtools = ModuleAvailableFeature('testtools')

=== modified file 'breezy/tests/http_server.py'
--- breezy/tests/http_server.py	2017-05-24 20:47:30 +0000
+++ breezy/tests/http_server.py	2017-06-08 20:56:03 +0000
@@ -67,14 +67,6 @@
                 self.headers.get('referer', '-'),
                 self.headers.get('user-agent', '-'))
 
-    def handle(self):
-        SimpleHTTPServer.SimpleHTTPRequestHandler.handle(self)
-        # Some client (pycurl, I'm looking at you) are more picky than others
-        # and require that the socket itself is closed
-        # (SocketServer.StreamRequestHandler only close the two associated
-        # 'makefile' objects)
-        self.connection.close()
-
     def handle_one_request(self):
         """Handle a single HTTP request.
 
@@ -502,17 +494,3 @@
 
     # urls returned by this server should require the urllib client impl
     _url_protocol = 'http+urllib'
-
-
-class HttpServer_PyCurl(HttpServer):
-    """Subclass of HttpServer that gives http+pycurl urls.
-
-    This is for use in testing: connections to this server will always go
-    through pycurl where possible.
-    """
-
-    # We don't care about checking the pycurl availability as
-    # this server will be required only when pycurl is present
-
-    # urls returned by this server should require the pycurl client impl
-    _url_protocol = 'http+pycurl'

=== modified file 'breezy/tests/https_server.py'
--- breezy/tests/https_server.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/https_server.py	2017-06-08 20:56:03 +0000
@@ -134,17 +134,3 @@
 
     # urls returned by this server should require the urllib client impl
     _url_protocol = 'https+urllib'
-
-
-class HTTPSServer_PyCurl(HTTPSServer):
-    """Subclass of HTTPSServer that gives http+pycurl urls.
-
-    This is for use in testing: connections to this server will always go
-    through pycurl where possible.
-    """
-
-    # We don't care about checking the pycurl availability as
-    # this server will be required only when pycurl is present
-
-    # urls returned by this server should require the pycurl client impl
-    _url_protocol = 'https+pycurl'

=== modified file 'breezy/tests/test_bzrdir.py'
--- breezy/tests/test_bzrdir.py	2017-06-04 22:57:11 +0000
+++ breezy/tests/test_bzrdir.py	2017-06-08 20:56:03 +0000
@@ -61,7 +61,6 @@
     http_server,
     http_utils,
     )
-from .test_http import TestWithTransport_pycurl
 from ..transport import (
     memory,
     pathfilter,
@@ -1179,17 +1178,6 @@
 
 
 
-class TestHTTPRedirections_pycurl(TestWithTransport_pycurl,
-                                  TestHTTPRedirections,
-                                  http_utils.TestCaseWithTwoWebservers):
-    """Tests redirections for pycurl implementation"""
-
-    def _qualified_url(self, host, port):
-        result = 'http+pycurl://%s:%s' % (host, port)
-        self.permit_url(result)
-        return result
-
-
 class TestHTTPRedirections_nosmart(TestHTTPRedirections,
                                   http_utils.TestCaseWithTwoWebservers):
     """Tests redirections for the nosmart decorator"""

=== modified file 'breezy/tests/test_http.py'
--- breezy/tests/test_http.py	2017-05-25 01:35:55 +0000
+++ breezy/tests/test_http.py	2017-06-08 20:56:03 +0000
@@ -63,25 +63,16 @@
     )
 
 
-if features.pycurl.available():
-    from ..transport.http._pycurl import PyCurlTransport
-
-
 load_tests = load_tests_apply_scenarios
 
 
 def vary_by_http_client_implementation():
-    """Test the two libraries we can use, pycurl and urllib."""
+    """Test the libraries we can use, currently just urllib."""
     transport_scenarios = [
         ('urllib', dict(_transport=_urllib.HttpTransport_urllib,
                         _server=http_server.HttpServer_urllib,
                         _url_protocol='http+urllib',)),
         ]
-    if features.pycurl.available():
-        transport_scenarios.append(
-            ('pycurl', dict(_transport=PyCurlTransport,
-                            _server=http_server.HttpServer_PyCurl,
-                            _url_protocol='http+pycurl',)))
     return transport_scenarios
 
 
@@ -128,14 +119,10 @@
         ('urllib,http', dict(_activity_server=ActivityHTTPServer,
                             _transport=_urllib.HttpTransport_urllib,)),
         ]
-    if features.pycurl.available():
-        activity_scenarios.append(
-            ('pycurl,http', dict(_activity_server=ActivityHTTPServer,
-                                _transport=PyCurlTransport,)),)
     if features.HTTPSServerFeature.available():
         # FIXME: Until we have a better way to handle self-signed certificates
         # (like allowing them in a test specific authentication.conf for
-        # example), we need some specialized pycurl/urllib transport for tests.
+        # example), we need some specialized urllib transport for tests.
         # -- vila 2012-01-20
         from . import (
             ssl_certs,
@@ -150,17 +137,6 @@
         activity_scenarios.append(
             ('urllib,https', dict(_activity_server=ActivityHTTPSServer,
                                   _transport=HTTPS_urllib_transport,)),)
-        if features.pycurl.available():
-            class HTTPS_pycurl_transport(PyCurlTransport):
-
-                def __init__(self, base, _from_transport=None):
-                    super(HTTPS_pycurl_transport, self).__init__(
-                        base, _from_transport)
-                    self.cabundle = str(ssl_certs.build_path('ca.crt'))
-
-            activity_scenarios.append(
-                ('pycurl,https', dict(_activity_server=ActivityHTTPSServer,
-                                    _transport=HTTPS_pycurl_transport,)),)
     return activity_scenarios
 
 
@@ -385,16 +361,6 @@
                               http_server.TestingHTTPServer)
 
 
-class TestWithTransport_pycurl(object):
-    """Test case to inherit from if pycurl is present"""
-
-    def _get_pycurl_maybe(self):
-        self.requireFeature(features.pycurl)
-        return PyCurlTransport
-
-    _transport = property(_get_pycurl_maybe)
-
-
 class TestHttpTransportUrls(tests.TestCase):
     """Test the http urls."""
 
@@ -435,42 +401,6 @@
             server.stop_server()
 
 
-class TestHttps_pycurl(TestWithTransport_pycurl, tests.TestCase):
-
-    # TODO: This should really be moved into another pycurl
-    # specific test. When https tests will be implemented, take
-    # this one into account.
-    def test_pycurl_without_https_support(self):
-        """Test that pycurl without SSL do not fail with a traceback.
-
-        For the purpose of the test, we force pycurl to ignore
-        https by supplying a fake version_info that do not
-        support it.
-        """
-        self.requireFeature(features.pycurl)
-        # Import the module locally now that we now it's available.
-        pycurl = features.pycurl.module
-
-        self.overrideAttr(pycurl, 'version_info',
-                          # Fake the pycurl version_info This was taken from
-                          # a windows pycurl without SSL (thanks to bialix)
-                          lambda : (2,
-                                    '7.13.2',
-                                    462082,
-                                    'i386-pc-win32',
-                                    2576,
-                                    None,
-                                    0,
-                                    None,
-                                    ('ftp', 'gopher', 'telnet',
-                                     'dict', 'ldap', 'http', 'file'),
-                                    None,
-                                    0,
-                                    None))
-        self.assertRaises(errors.DependencyNotPresent, self._transport,
-                          'https://launchpad.net')
-
-
 class TestHTTPConnections(http_utils.TestCaseWithWebserver):
     """Test the http connections."""
 
@@ -613,11 +543,6 @@
         server._url_protocol = self._url_protocol
         return server
 
-    def _testing_pycurl(self):
-        # TODO: This is duplicated for lots of the classes in this file
-        return (features.pycurl.available()
-                and self._transport == PyCurlTransport)
-
 
 class WallRequestHandler(http_server.TestingHTTPRequestHandler):
     """Whatever request comes in, close the connection"""
@@ -638,10 +563,9 @@
         # for details) make no distinction between a closed
         # socket and badly formatted status line, so we can't
         # just test for ConnectionError, we have to test
-        # InvalidHttpResponse too. And pycurl may raise ConnectionReset
-        # instead of ConnectionError too.
-        self.assertRaises(( errors.ConnectionError, errors.ConnectionReset,
-                            errors.InvalidHttpResponse),
+        # InvalidHttpResponse too.
+        self.assertRaises((errors.ConnectionError,
+                           errors.InvalidHttpResponse),
                           t.has, 'foo/bar')
 
     def test_http_get(self):
@@ -733,12 +657,6 @@
 
     _req_handler_class = BadProtocolRequestHandler
 
-    def setUp(self):
-        if self._testing_pycurl():
-            raise tests.TestNotApplicable(
-                "pycurl doesn't check the protocol version")
-        super(TestBadProtocolServer, self).setUp()
-
     def test_http_has(self):
         t = self.get_readonly_transport()
         self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
@@ -1047,16 +965,12 @@
         ireadv = iter(t.readv('a', ((0, 1), (2, 1), (4, 2), (9, 1))))
         self.assertEqual((0, '0'), next(ireadv))
         self.assertEqual((2, '2'), next(ireadv))
-        if not self._testing_pycurl():
-            # Only one request have been issued so far (except for pycurl that
-            # try to read the whole response at once)
-            self.assertEqual(1, server.GET_request_nb)
+        # Only one request have been issued so far
+        self.assertEqual(1, server.GET_request_nb)
         self.assertEqual((4, '45'), next(ireadv))
         self.assertEqual((9, '9'), next(ireadv))
-        # Both implementations issue 3 requests but:
-        # - urllib does two multiple (4 ranges, then 2 ranges) then a single
-        #   range,
-        # - pycurl does two multiple (4 ranges, 4 ranges) then a single range
+        # We issue 3 requests: two multiple (4 ranges, then 2 ranges) then a
+        # single range.
         self.assertEqual(3, server.GET_request_nb)
         # Finally the client have tried a single range request and stays in
         # that mode
@@ -1276,21 +1190,9 @@
         # Let's setup some attributes for tests
         server = self.get_readonly_server()
         self.server_host_port = '%s:%d' % (server.host, server.port)
-        if self._testing_pycurl():
-            # Oh my ! pycurl does not check for the port as part of
-            # no_proxy :-( So we just test the host part
-            self.no_proxy_host = server.host
-        else:
-            self.no_proxy_host = self.server_host_port
+        self.no_proxy_host = self.server_host_port
         # The secondary server is the proxy
         self.proxy_url = self.get_secondary_url()
-        if self._testing_pycurl():
-            self.proxy_url = self.proxy_url.replace('+pycurl', '')
-
-    def _testing_pycurl(self):
-        # TODO: This is duplicated for lots of the classes in this file
-        return (features.pycurl.available()
-                and self._transport == PyCurlTransport)
 
     def assertProxied(self):
         t = self.get_readonly_transport()
@@ -1305,12 +1207,6 @@
         self.assertProxied()
 
     def test_HTTP_PROXY(self):
-        if self._testing_pycurl():
-            # pycurl does not check HTTP_PROXY for security reasons
-            # (for use in a CGI context that we do not care
-            # about. Should we ?)
-            raise tests.TestNotApplicable(
-                'pycurl does not check HTTP_PROXY for security reasons')
         self.overrideEnv('HTTP_PROXY', self.proxy_url)
         self.assertProxied()
 
@@ -1328,9 +1224,6 @@
         self.assertNotProxied()
 
     def test_HTTP_PROXY_with_NO_PROXY(self):
-        if self._testing_pycurl():
-            raise tests.TestNotApplicable(
-                'pycurl does not check HTTP_PROXY for security reasons')
         self.overrideEnv('NO_PROXY', self.no_proxy_host)
         self.overrideEnv('HTTP_PROXY', self.proxy_url)
         self.assertNotProxied()
@@ -1347,13 +1240,7 @@
 
     def test_http_proxy_without_scheme(self):
         self.overrideEnv('http_proxy', self.server_host_port)
-        if self._testing_pycurl():
-            # pycurl *ignores* invalid proxy env variables. If that ever change
-            # in the future, this test will fail indicating that pycurl do not
-            # ignore anymore such variables.
-            self.assertNotProxied()
-        else:
-            self.assertRaises(errors.InvalidURL, self.assertProxied)
+        self.assertRaises(errors.InvalidURL, self.assertProxied)
 
 
 class TestRanges(http_utils.TestCaseWithWebserver):
@@ -1475,11 +1362,6 @@
     do not redirect at all in fact). The mechanism is still in
     place at the _urllib2_wrappers.Request level and these tests
     exercise it.
-
-    For the pycurl implementation
-    the redirection have been deleted as we may deprecate pycurl
-    and I have no place to keep a working implementation.
-    -- vila 20070212
     """
 
     scenarios = multiply_scenarios(
@@ -1488,10 +1370,6 @@
         )
 
     def setUp(self):
-        if (features.pycurl.available()
-            and self._transport == PyCurlTransport):
-            raise tests.TestNotApplicable(
-                "pycurl doesn't redirect silently anymore")
         super(TestHTTPSilentRedirections, self).setUp()
         install_redirected_request(self)
         cleanup_http_redirection_connections(self)
@@ -1635,11 +1513,6 @@
         server._url_protocol = self._url_protocol
         return server
 
-    def _testing_pycurl(self):
-        # TODO: This is duplicated for lots of the classes in this file
-        return (features.pycurl.available()
-                and self._transport == PyCurlTransport)
-
     def get_user_url(self, user, password):
         """Build an url embedding user and password"""
         url = '%s://' % self.server._url_protocol
@@ -1695,11 +1568,6 @@
         self.assertEqual(2, self.server.auth_required_errors)
 
     def test_prompt_for_username(self):
-        if self._testing_pycurl():
-            raise tests.TestNotApplicable(
-                'pycurl cannot prompt, it handles auth by embedding'
-                ' user:pass in urls only')
-
         self.server.add_user('joe', 'foo')
         t = self.get_user_transport(None, None)
         ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n')
@@ -1715,11 +1583,6 @@
                                     stderr.readline())
 
     def test_prompt_for_password(self):
-        if self._testing_pycurl():
-            raise tests.TestNotApplicable(
-                'pycurl cannot prompt, it handles auth by embedding'
-                ' user:pass in urls only')
-
         self.server.add_user('joe', 'foo')
         t = self.get_user_transport('joe', None)
         ui.ui_factory = tests.TestUIFactory(stdin='foo\n')
@@ -1754,11 +1617,6 @@
                                  self.server.auth_realm))
 
     def test_no_prompt_for_password_when_using_auth_config(self):
-        if self._testing_pycurl():
-            raise tests.TestNotApplicable(
-                'pycurl does not support authentication.conf'
-                ' since it cannot prompt')
-
         user =' joe'
         password = 'foo'
         stdin_content = 'bar\n'  # Not the right password
@@ -1779,9 +1637,6 @@
         if self._auth_server not in (http_utils.HTTPDigestAuthServer,
                                      http_utils.ProxyDigestAuthServer):
             raise tests.TestNotApplicable('HTTP/proxy auth digest only test')
-        if self._testing_pycurl():
-            self.knownFailure(
-                'pycurl does not handle a nonce change')
         self.server.add_user('joe', 'foo')
         t = self.get_user_transport('joe', 'foo')
         self.assertEqual('contents of a\n', t.get('a').read())
@@ -1797,9 +1652,6 @@
         self.assertEqual(2, self.server.auth_required_errors)
 
     def test_user_from_auth_conf(self):
-        if self._testing_pycurl():
-            raise tests.TestNotApplicable(
-                'pycurl does not support authentication.conf')
         user = 'joe'
         password = 'foo'
         self.server.add_user(user, password)
@@ -1862,19 +1714,9 @@
 
     def get_user_transport(self, user, password):
         proxy_url = self.get_user_url(user, password)
-        if self._testing_pycurl():
-            proxy_url = proxy_url.replace('+pycurl', '')
         self.overrideEnv('all_proxy', proxy_url)
         return TestAuth.get_user_transport(self, user, password)
 
-    def test_empty_pass(self):
-        if self._testing_pycurl():
-            import pycurl
-            if pycurl.version_info()[1] < '7.16.0':
-                self.knownFailure(
-                    'pycurl < 7.16.0 does not handle empty proxy passwords')
-        super(TestProxyAuth, self).test_empty_pass()
-
 
 class NonClosingBytesIO(io.BytesIO):
 

=== modified file 'breezy/transport/__init__.py'
--- breezy/transport/__init__.py	2017-05-30 19:32:13 +0000
+++ breezy/transport/__init__.py	2017-06-08 20:56:03 +0000
@@ -103,10 +103,10 @@
     register_transport_provider( ) ( and the "lazy" variant )
 
     This is needed because:
-    a) a single provider can support multiple protocols ( like the ftp
-    provider which supports both the ftp:// and the aftp:// protocols )
-    b) a single protocol can have multiple providers ( like the http://
-    protocol which is supported by both the urllib and pycurl provider )
+    a) a single provider can support multiple protocols (like the ftp
+    provider which supports both the ftp:// and the aftp:// protocols)
+    b) a single protocol can have multiple providers (like the http://
+    protocol which was supported by both the urllib and pycurl providers)
     """
 
     def register_transport_provider(self, key, obj):
@@ -1752,28 +1752,14 @@
                          register_netloc=True)
 register_lazy_transport(b'https+urllib://', 'breezy.transport.http._urllib',
                         'HttpTransport_urllib')
-register_transport_proto(b'http+pycurl://',
-#                help="Read-only access of branches exported on the web."
-                         register_netloc=True)
-register_lazy_transport(b'http+pycurl://', 'breezy.transport.http._pycurl',
-                        'PyCurlTransport')
-register_transport_proto(b'https+pycurl://',
-#                help="Read-only access of branches exported on the web using SSL."
-                         register_netloc=True)
-register_lazy_transport(b'https+pycurl://', 'breezy.transport.http._pycurl',
-                        'PyCurlTransport')
 # Default http transports (last declared wins (if it can be imported))
 register_transport_proto(b'http://',
                  help="Read-only access of branches exported on the web.")
 register_transport_proto(b'https://',
             help="Read-only access of branches exported on the web using SSL.")
 # The default http implementation is urllib
-register_lazy_transport(b'http://', 'breezy.transport.http._pycurl',
-                        'PyCurlTransport')
 register_lazy_transport(b'http://', 'breezy.transport.http._urllib',
                         'HttpTransport_urllib')
-register_lazy_transport(b'https://', 'breezy.transport.http._pycurl',
-                        'PyCurlTransport')
 register_lazy_transport(b'https://', 'breezy.transport.http._urllib',
                         'HttpTransport_urllib')
 

=== modified file 'breezy/transport/http/__init__.py'
--- breezy/transport/http/__init__.py	2017-06-05 23:15:32 +0000
+++ breezy/transport/http/__init__.py	2017-06-08 20:56:03 +0000
@@ -506,7 +506,7 @@
                 # credentials (if they don't apply, the redirected to server
                 # will tell us, but if they do apply, we avoid prompting the
                 # user)
-                redir_scheme = parsed_target.scheme + '+' + self._impl_name
+                redir_scheme = parsed_target.scheme
                 new_url = self._unsplit_url(redir_scheme,
                     self._parsed_url.user,
                     self._parsed_url.password,

=== removed file 'breezy/transport/http/_pycurl.py'
--- breezy/transport/http/_pycurl.py	2017-05-22 00:56:52 +0000
+++ breezy/transport/http/_pycurl.py	1970-01-01 00:00:00 +0000
@@ -1,454 +0,0 @@
-# Copyright (C) 2006-2011, 2017 Canonical Ltd
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-"""http/https transport using pycurl"""
-
-from __future__ import absolute_import
-
-# TODO: test reporting of http errors
-#
-# TODO: Transport option to control caching of particular requests; broadly we
-# would want to offer "caching allowed" or "must revalidate", depending on
-# whether we expect a particular file will be modified after it's committed.
-# It's probably safer to just always revalidate.  mbp 20060321
-
-# TODO: Some refactoring could be done to avoid the strange idiom
-# used to capture data and headers while setting up the request
-# (and having to pass 'header' to _curl_perform to handle
-# redirections) . This could be achieved by creating a
-# specialized Curl object and returning code, headers and data
-# from _curl_perform.  Not done because we may deprecate pycurl in the
-# future -- vila 20070212
-
-import httplib
-
-import breezy
-from ... import (
-    debug,
-    errors,
-    trace,
-    )
-from ...sixish import (
-    BytesIO,
-    )
-from ...transport.http import (
-    ca_bundle,
-    HttpTransportBase,
-    response,
-    unhtml_roughly,
-    )
-
-try:
-    import pycurl
-except ImportError as e:
-    trace.mutter("failed to import pycurl: %s", e)
-    raise errors.DependencyNotPresent('pycurl', e)
-
-try:
-    # see if we can actually initialize PyCurl - sometimes it will load but
-    # fail to start up due to this bug:
-    #
-    #   32. (At least on Windows) If libcurl is built with c-ares and there's
-    #   no DNS server configured in the system, the ares_init() call fails and
-    #   thus curl_easy_init() fails as well. This causes weird effects for
-    #   people who use numerical IP addresses only.
-    #
-    # reported by Alexander Belchenko, 2006-04-26
-    pycurl.Curl()
-except pycurl.error as e:
-    trace.mutter("failed to initialize pycurl: %s", e)
-    raise errors.DependencyNotPresent('pycurl', e)
-
-
-
-
-def _get_pycurl_errcode(symbol, default):
-    """
-    Returns the numerical error code for a symbol defined by pycurl.
-
-    Different pycurl implementations define different symbols for error
-    codes. Old versions never define some symbols (wether they can return the
-    corresponding error code or not). The following addresses the problem by
-    defining the symbols we care about.  Note: this allows to define symbols
-    for errors that older versions will never return, which is fine.
-    """
-    return pycurl.__dict__.get(symbol, default)
-
-# Yes, weird but returned on weird http error (invalid status line)
-CURLE_FTP_WEIRD_SERVER_REPLY = _get_pycurl_errcode(
-    'E_FTP_WEIRD_SERVER_REPLY', 8)
-CURLE_COULDNT_CONNECT = _get_pycurl_errcode('E_COULDNT_CONNECT', 7)
-CURLE_COULDNT_RESOLVE_HOST = _get_pycurl_errcode('E_COULDNT_RESOLVE_HOST', 6)
-CURLE_COULDNT_RESOLVE_PROXY = _get_pycurl_errcode('E_COULDNT_RESOLVE_PROXY', 5)
-CURLE_GOT_NOTHING = _get_pycurl_errcode('E_GOT_NOTHING', 52)
-CURLE_PARTIAL_FILE = _get_pycurl_errcode('E_PARTIAL_FILE', 18)
-CURLE_SEND_ERROR = _get_pycurl_errcode('E_SEND_ERROR', 55)
-CURLE_RECV_ERROR = _get_pycurl_errcode('E_RECV_ERROR', 56)
-CURLE_SSL_CACERT = _get_pycurl_errcode('E_SSL_CACERT', 60)
-CURLE_SSL_CACERT_BADFILE = _get_pycurl_errcode('E_SSL_CACERT_BADFILE', 77)
-
-
-class PyCurlTransport(HttpTransportBase):
-    """http client transport using pycurl
-
-    PyCurl is a Python binding to the C "curl" multiprotocol client.
-
-    This transport can be significantly faster than the builtin
-    Python client.  Advantages include: DNS caching.
-    """
-
-    def __init__(self, base, _from_transport=None):
-        super(PyCurlTransport, self).__init__(base, 'pycurl',
-                                              _from_transport=_from_transport)
-        if self._unqualified_scheme == 'https':
-            # Check availability of https into pycurl supported
-            # protocols
-            supported = pycurl.version_info()[8]
-            if 'https' not in supported:
-                raise errors.DependencyNotPresent('pycurl', 'no https support')
-        self.cabundle = ca_bundle.get_ca_path()
-
-    def _get_curl(self):
-        connection = self._get_connection()
-        if connection is None:
-            # First connection ever. There is no credentials for pycurl, either
-            # the password was embedded in the URL or it's not needed. The
-            # connection for pycurl is just the Curl object, it will not
-            # connect to the http server until the first request (which had
-            # just called us).
-            connection = pycurl.Curl()
-            # First request, initialize credentials.
-            auth = self._create_auth()
-            # Proxy handling is out of reach, so we punt
-            self._set_connection(connection, auth)
-        return connection
-
-    def disconnect(self):
-        connection = self._get_connection()
-        if connection is not None:
-            connection.close()
-
-    def has(self, relpath):
-        """See Transport.has()"""
-        # We set NO BODY=0 in _get_full, so it should be safe
-        # to re-use the non-range curl object
-        curl = self._get_curl()
-        abspath = self._remote_path(relpath)
-        curl.setopt(pycurl.URL, abspath)
-        self._set_curl_options(curl)
-        curl.setopt(pycurl.HTTPGET, 1)
-        # don't want the body - ie just do a HEAD request
-        # This means "NO BODY" not 'nobody'
-        curl.setopt(pycurl.NOBODY, 1)
-        # But we need headers to handle redirections
-        header = BytesIO()
-        curl.setopt(pycurl.HEADERFUNCTION, header.write)
-        # In some erroneous cases, pycurl will emit text on
-        # stdout if we don't catch it (see InvalidStatus tests
-        # for one such occurrence).
-        blackhole = BytesIO()
-        curl.setopt(pycurl.WRITEFUNCTION, blackhole.write)
-        self._curl_perform(curl, header)
-        code = curl.getinfo(pycurl.HTTP_CODE)
-        if code == 404: # not found
-            return False
-        elif code == 200: # "ok"
-            return True
-        else:
-            self._raise_curl_http_error(curl)
-
-    def _get(self, relpath, offsets, tail_amount=0):
-        # This just switches based on the type of request
-        if offsets is not None or tail_amount not in (0, None):
-            return self._get_ranged(relpath, offsets, tail_amount=tail_amount)
-        else:
-            return self._get_full(relpath)
-
-    def _setup_get_request(self, curl, relpath):
-        # Make sure we do a GET request. versions > 7.14.1 also set the
-        # NO BODY flag, but we'll do it ourselves in case it is an older
-        # pycurl version
-        curl.setopt(pycurl.NOBODY, 0)
-        curl.setopt(pycurl.HTTPGET, 1)
-        return self._setup_request(curl, relpath)
-
-    def _setup_request(self, curl, relpath):
-        """Do the common setup stuff for making a request
-
-        :param curl: The curl object to place the request on
-        :param relpath: The relative path that we want to get
-        :return: (abspath, data, header)
-                 abspath: full url
-                 data: file that will be filled with the body
-                 header: file that will be filled with the headers
-        """
-        abspath = self._remote_path(relpath)
-        curl.setopt(pycurl.URL, abspath)
-        self._set_curl_options(curl)
-
-        data = BytesIO()
-        header = BytesIO()
-        curl.setopt(pycurl.WRITEFUNCTION, data.write)
-        curl.setopt(pycurl.HEADERFUNCTION, header.write)
-
-        return abspath, data, header
-
-    def _get_full(self, relpath):
-        """Make a request for the entire file"""
-        curl = self._get_curl()
-        abspath, data, header = self._setup_get_request(curl, relpath)
-        self._curl_perform(curl, header)
-
-        code = curl.getinfo(pycurl.HTTP_CODE)
-        data.seek(0)
-
-        if code == 404:
-            raise errors.NoSuchFile(abspath)
-        if code != 200:
-            self._raise_curl_http_error(
-                curl, 'expected 200 or 404 for full response.')
-
-        return code, data
-
-    # The parent class use 0 to minimize the requests, but since we can't
-    # exploit the results as soon as they are received (pycurl limitation) we'd
-    # better issue more requests and provide a more responsive UI incurring
-    # more latency costs.
-    # If you modify this, think about modifying the comment in http/__init__.py
-    # too.
-    _get_max_size = 4 * 1024 * 1024
-
-    def _get_ranged(self, relpath, offsets, tail_amount):
-        """Make a request for just part of the file."""
-        curl = self._get_curl()
-        abspath, data, header = self._setup_get_request(curl, relpath)
-
-        range_header = self._attempted_range_header(offsets, tail_amount)
-        if range_header is None:
-            # Forget ranges, the server can't handle them
-            return self._get_full(relpath)
-
-        self._curl_perform(curl, header, ['Range: bytes=%s' % range_header])
-        data.seek(0)
-
-        code = curl.getinfo(pycurl.HTTP_CODE)
-
-        if code == 404: # not found
-            raise errors.NoSuchFile(abspath)
-        elif code in (400, 416):
-            # We don't know which, but one of the ranges we specified was
-            # wrong.
-            raise errors.InvalidHttpRange(abspath, range_header,
-                                          'Server return code %d'
-                                          % curl.getinfo(pycurl.HTTP_CODE))
-        msg = self._parse_headers(header)
-        return code, response.handle_response(abspath, code, msg, data)
-
-    def _parse_headers(self, status_and_headers):
-        """Transform the headers provided by curl into an HTTPMessage"""
-        status_and_headers.seek(0)
-        # Ignore status line
-        status_and_headers.readline()
-        msg = httplib.HTTPMessage(status_and_headers)
-        return msg
-
-    def _post(self, body_bytes):
-        curl = self._get_curl()
-        abspath, data, header = self._setup_request(curl, '.bzr/smart')
-        curl.setopt(pycurl.POST, 1)
-        fake_file = BytesIO(body_bytes)
-        curl.setopt(pycurl.POSTFIELDSIZE, len(body_bytes))
-        curl.setopt(pycurl.READFUNCTION, fake_file.read)
-        # We override the Expect: header so that pycurl will send the POST
-        # body immediately.
-        try:
-            self._curl_perform(curl, header,
-                               ['Expect: ',
-                                'Content-Type: application/octet-stream'])
-        except pycurl.error as e:
-            if e[0] == CURLE_SEND_ERROR:
-                # When talking to an HTTP/1.0 server, getting a 400+ error code
-                # triggers a bug in some combinations of curl/kernel in rare
-                # occurrences. Basically, the server closes the connection
-                # after sending the error but the client (having received and
-                # parsed the response) still try to send the request body (see
-                # bug #225020 and its upstream associated bug).  Since the
-                # error code and the headers are known to be available, we just
-                # swallow the exception, leaving the upper levels handle the
-                # 400+ error.
-                trace.mutter('got pycurl error in POST: %s, %s, %s, url: %s ',
-                             e[0], e[1], e, abspath)
-            else:
-                # Re-raise otherwise
-                raise
-        data.seek(0)
-        code = curl.getinfo(pycurl.HTTP_CODE)
-        msg = self._parse_headers(header)
-        return code, response.handle_response(abspath, code, msg, data)
-
-
-    def _raise_curl_http_error(self, curl, info=None, body=None):
-        """Common curl->breezy error translation.
-
-        Some methods may choose to override this for particular cases.
-
-        The URL and code are automatically included as appropriate.
-
-        :param info: Extra information to include in the message.
-
-        :param body: File-like object from which the body of the page can be
-            read.
-        """
-        code = curl.getinfo(pycurl.HTTP_CODE)
-        url = curl.getinfo(pycurl.EFFECTIVE_URL)
-        if body is not None:
-            response_body = body.read()
-            plaintext_body = unhtml_roughly(response_body)
-        else:
-            response_body = None
-            plaintext_body = ''
-        if code == 403:
-            raise errors.TransportError(
-                'Server refuses to fulfill the request (403 Forbidden)'
-                ' for %s: %s' % (url, plaintext_body))
-        else:
-            if info is None:
-                msg = ''
-            else:
-                msg = ': ' + info
-            raise errors.InvalidHttpResponse(
-                url, 'Unable to handle http code %d%s: %s'
-                % (code, msg, plaintext_body))
-
-    def _debug_cb(self, kind, text):
-        if kind in (pycurl.INFOTYPE_HEADER_IN, pycurl.INFOTYPE_DATA_IN):
-            self._report_activity(len(text), 'read')
-            if (kind == pycurl.INFOTYPE_HEADER_IN
-                and 'http' in debug.debug_flags):
-                trace.mutter('< %s' % (text.rstrip(),))
-        elif kind in (pycurl.INFOTYPE_HEADER_OUT, pycurl.INFOTYPE_DATA_OUT):
-            self._report_activity(len(text), 'write')
-            if (kind == pycurl.INFOTYPE_HEADER_OUT
-                and 'http' in debug.debug_flags):
-                lines = []
-                for line in text.rstrip().splitlines():
-                    # People are often told to paste -Dhttp output to help
-                    # debug. Don't compromise credentials.
-                    try:
-                        header, details = line.split(':', 1)
-                    except ValueError:
-                        header = None
-                    if header in ('Authorization', 'Proxy-Authorization'):
-                        line = '%s: <masked>' % (header,)
-                    lines.append(line)
-                trace.mutter('> ' + '\n> '.join(lines))
-        elif kind == pycurl.INFOTYPE_TEXT and 'http' in debug.debug_flags:
-            trace.mutter('* %s' % text.rstrip())
-        elif (kind in (pycurl.INFOTYPE_TEXT, pycurl.INFOTYPE_SSL_DATA_IN,
-                       pycurl.INFOTYPE_SSL_DATA_OUT)
-              and 'http' in debug.debug_flags):
-            trace.mutter('* %s' % text)
-
-    def _set_curl_options(self, curl):
-        """Set options for all requests"""
-        ua_str = 'bzr/%s (pycurl: %s)' % (breezy.__version__, pycurl.version)
-        curl.setopt(pycurl.USERAGENT, ua_str)
-        curl.setopt(pycurl.VERBOSE, 1)
-        curl.setopt(pycurl.DEBUGFUNCTION, self._debug_cb)
-        if self.cabundle:
-            curl.setopt(pycurl.CAINFO, self.cabundle)
-        # Set accepted auth methods
-        curl.setopt(pycurl.HTTPAUTH, pycurl.HTTPAUTH_ANY)
-        curl.setopt(pycurl.PROXYAUTH, pycurl.HTTPAUTH_ANY)
-        auth = self._get_credentials()
-        user = auth.get('user', None)
-        password = auth.get('password', None)
-        userpass = None
-        if user is not None:
-            userpass = user + ':'
-            if password is not None: # '' is a valid password
-                userpass += password
-            curl.setopt(pycurl.USERPWD, userpass)
-
-    def _curl_perform(self, curl, header, more_headers=[]):
-        """Perform curl operation and translate exceptions."""
-        try:
-            # There's no way in http/1.0 to say "must
-            # revalidate"; we don't want to force it to always
-            # retrieve.  so just turn off the default Pragma
-            # provided by Curl.
-            headers = ['Cache-control: max-age=0',
-                       'Pragma: no-cache',
-                       'Connection: Keep-Alive']
-            curl.setopt(pycurl.HTTPHEADER, headers + more_headers)
-            curl.perform()
-        except pycurl.error as e:
-            url = curl.getinfo(pycurl.EFFECTIVE_URL)
-            trace.mutter('got pycurl error: %s, %s, %s, url: %s ',
-                         e[0], e[1], e, url)
-            if e[0] in (CURLE_COULDNT_RESOLVE_HOST,
-                        CURLE_COULDNT_RESOLVE_PROXY,
-                        CURLE_COULDNT_CONNECT,
-                        CURLE_FTP_WEIRD_SERVER_REPLY,
-                        CURLE_GOT_NOTHING,
-                        CURLE_SSL_CACERT,
-                        CURLE_SSL_CACERT_BADFILE,
-                        ):
-                raise errors.ConnectionError(
-                    'curl connection error (%s)\non %s' % (e[1], url))
-            elif e[0] == CURLE_RECV_ERROR:
-                raise errors.ConnectionReset(
-                    'curl connection error (%s)\non %s' % (e[1], url))
-            elif e[0] == CURLE_PARTIAL_FILE:
-                # Pycurl itself has detected a short read.  We do not have all
-                # the information for the ShortReadvError, but that should be
-                # enough
-                raise errors.ShortReadvError(url,
-                                             offset='unknown', length='unknown',
-                                             actual='unknown',
-                                             extra='Server aborted the request')
-            raise
-        code = curl.getinfo(pycurl.HTTP_CODE)
-        if code in (301, 302, 303, 307):
-            url = curl.getinfo(pycurl.EFFECTIVE_URL)
-            msg = self._parse_headers(header)
-            redirected_to = msg.getheader('location')
-            raise errors.RedirectRequested(url,
-                                           redirected_to,
-                                           is_permanent=(code == 301))
-
-
-def get_test_permutations():
-    """Return the permutations to be used in testing."""
-    from ...tests import features
-    from ...tests import http_server
-    permutations = [(PyCurlTransport, http_server.HttpServer_PyCurl),]
-    if features.HTTPSServerFeature.available():
-        from ...tests import (
-            https_server,
-            ssl_certs,
-            )
-
-        class HTTPS_pycurl_transport(PyCurlTransport):
-
-            def __init__(self, base, _from_transport=None):
-                super(HTTPS_pycurl_transport, self).__init__(base,
-                                                             _from_transport)
-                self.cabundle = str(ssl_certs.build_path('ca.crt'))
-
-        permutations.append((HTTPS_pycurl_transport,
-                             https_server.HTTPSServer_PyCurl))
-    return permutations

=== modified file 'doc/en/release-notes/brz-3.0.txt'
--- doc/en/release-notes/brz-3.0.txt	2017-06-07 01:26:42 +0000
+++ doc/en/release-notes/brz-3.0.txt	2017-06-08 20:56:03 +0000
@@ -34,6 +34,10 @@
    (https://help.launchpad.net/VcsImports).
    (Colin Watson, #254567, #483689)
 
+ * Support for HTTP support using "pycurl" and the associated
+   URL schemes "http+pycurl://" and "https+pycurl://" has been dropped.
+   (Jelmer Vernooij, #82086, #377389, #122258, #516222, #545776, #1696602)
+
 New Features
 ************