def test_retry_exception_str(self): self.assertEqual( str(MaxRetryError(HTTPConnectionPool(host='localhost'), "Test.", None)), "HTTPConnectionPool(host='localhost', port=None): Max retries exceeded with url: Test.") err = SocketError("Test") self.assertEqual( str(MaxRetryError(HTTPConnectionPool(host='localhost'), "Test.", err)), "HTTPConnectionPool(host='localhost', port=None): Max retries exceeded with url: Test. (caused by <class 'socket.error'>: Test)")
def test_write(self): with patch("etcd.Client", autospec=True) as mock: client = etcd_util.EtcdClient({}) etcd_client = mock.return_value etcd_client.write.return_value = MagicMock(value="salt") self.assertEqual(client.write("/some-key", "salt"), "salt") etcd_client.write.assert_called_with( "/some-key", "salt", ttl=None, dir=False ) self.assertEqual(client.write("/some-key", "salt", ttl=5), "salt") etcd_client.write.assert_called_with("/some-key", "salt", ttl=5, dir=False) etcd_client.write.return_value = MagicMock(dir=True) self.assertEqual( client.write("/some-dir", "salt", ttl=0, directory=True), True ) etcd_client.write.assert_called_with("/some-dir", None, ttl=0, dir=True) # Check when a file is attempted to be written to a read-only root etcd_client.write.side_effect = etcd.EtcdRootReadOnly() self.assertEqual(client.write("/", "some-val", directory=False), None) # Check when a directory is attempted to be written to a read-only root etcd_client.write.side_effect = etcd.EtcdRootReadOnly() self.assertEqual(client.write("/", None, directory=True), None) # Check when a file is attempted to be written when unable to connect to the service etcd_client.write.side_effect = MaxRetryError(None, None) self.assertEqual( client.write("/some-key", "some-val", directory=False), None ) # Check when a directory is attempted to be written when unable to connect to the service etcd_client.write.side_effect = MaxRetryError(None, None) self.assertEqual(client.write("/some-dir", None, directory=True), None) # Check when a file is attempted to be written to a directory that already exists (name-collision) etcd_client.write.side_effect = etcd.EtcdNotFile() self.assertEqual( client.write("/some-dir", "some-val", directory=False), None ) # Check when a directory is attempted to be written to a file that already exists (name-collision) etcd_client.write.side_effect = etcd.EtcdNotDir() self.assertEqual(client.write("/some-key", None, directory=True), None) # Check when a directory is attempted to be written to a directory that already exists (update-ttl) etcd_client.write.side_effect = etcd.EtcdNotFile() self.assertEqual(client.write("/some-dir", None, directory=True), True) etcd_client.write.side_effect = ValueError self.assertEqual(client.write("/some-key", "some-val"), None) etcd_client.write.side_effect = Exception self.assertRaises(Exception, client.set, "some-key", "some-val")
def increment(self, method=None, url=None, response=None, error=None, _pool=None, _stacktrace=None): """Return a new Retry object with incremented retry counters.""" if self.retry_timeout < datetime.now(): raise MaxRetryError( _pool, url, error or ResponseError("max_retry_time exceeded")) new_retry = super().increment(method, url, response, error, _pool, _stacktrace) if response is not None: parsed_error = InfluxDBError(response=response) elif error is not None: parsed_error = error else: parsed_error = f"Failed request to: {url}" message = f"The retriable error occurred during request. Reason: '{parsed_error}'." if isinstance(parsed_error, InfluxDBError): message += f" Retry in {parsed_error.retry_after}s." if self.retry_callback: self.retry_callback(parsed_error) logger.warning(message) return new_retry
def test_access_token_not_in_exception_traceback(self): """Check that access token is replaced within chained request exceptions.""" backend_name = 'ibmq_qasm_simulator' backend = self.provider.get_backend(backend_name) circuit = transpile(self.qc1, backend, seed_transpiler=self.seed) qobj = assemble(circuit, backend, shots=1) client = backend._api_client exception_message = 'The access token in this exception ' \ 'message should be replaced: {}'.format(self.access_token) exception_traceback_str = '' try: with mock.patch.object(HTTPConnectionPool, 'urlopen', side_effect=MaxRetryError( HTTPConnectionPool('host'), 'url', reason=exception_message)): _ = client.job_submit(backend.name(), qobj.to_dict()) except RequestsApiError: exception_traceback_str = traceback.format_exc() self.assertTrue(exception_traceback_str) if self.access_token in exception_traceback_str: self.fail( 'Access token not replaced in request exception traceback.')
def wait_server_close(url: str, waiting_message: str, final_message: str): """ Wait for a server to close :param url: the url to close the server :type url: str :param waiting_message: this message will pop up every minute :type waiting_message: str :param final_message: this message will pop up when the connection is down :type final_message: str .. info :: if you add `%d` in your messages you can include time count in it .. warning :: Raise a MaxRetryError if the server has not closed after 10s """ count = 0 server_started = False while not server_started: if count == 10: raise MaxRetryError(url, None) try: get(url) sleep(1) logger.info(waiting_message, count) count += 1 except (RequestsConnectionError, MaxRetryError) as _: server_started = True logger.info(final_message, count)
def test_write(self): with patch('etcd.Client', autospec=True) as mock: client = etcd_util.EtcdClient({}) etcd_client = mock.return_value etcd_client.write.return_value = MagicMock(value='salt') self.assertEqual(client.write('/some-key', 'salt'), 'salt') etcd_client.write.assert_called_with('/some-key', 'salt', ttl=None, dir=False) self.assertEqual(client.write('/some-key', 'salt', ttl=5), 'salt') etcd_client.write.assert_called_with('/some-key', 'salt', ttl=5, dir=False) etcd_client.write.return_value = MagicMock(dir=True) self.assertEqual(client.write('/some-dir', 'salt', ttl=0, directory=True), True) etcd_client.write.assert_called_with('/some-dir', None, ttl=0, dir=True) etcd_client.write.side_effect = etcd.EtcdRootReadOnly() self.assertEqual(client.write('/', 'some-val'), None) etcd_client.write.side_effect = etcd.EtcdNotFile() self.assertEqual(client.write('/some-key', 'some-val'), None) etcd_client.write.side_effect = etcd.EtcdNotDir() self.assertEqual(client.write('/some-dir', 'some-val'), None) etcd_client.write.side_effect = MaxRetryError(None, None) self.assertEqual(client.write('/some-key', 'some-val'), None) etcd_client.write.side_effect = ValueError self.assertEqual(client.write('/some-key', 'some-val'), None) etcd_client.write.side_effect = Exception self.assertRaises(Exception, client.set, 'some-key', 'some-val')
def test_read(self): ''' Test to make sure we interact with etcd correctly ''' with patch('etcd.Client', autospec=True) as mock: etcd_client = mock.return_value etcd_return = MagicMock(value='salt') etcd_client.read.return_value = etcd_return client = etcd_util.EtcdClient({}) self.assertEqual(client.read('/salt'), etcd_return) etcd_client.read.assert_called_with('/salt', recursive=False, wait=False, timeout=None) client.read('salt', True, True, 10, 5) etcd_client.read.assert_called_with('salt', recursive=True, wait=True, timeout=10, waitIndex=5) etcd_client.read.side_effect = etcd.EtcdKeyNotFound self.assertRaises(etcd.EtcdKeyNotFound, client.read, 'salt') etcd_client.read.side_effect = etcd.EtcdConnectionFailed self.assertRaises(etcd.EtcdConnectionFailed, client.read, 'salt') etcd_client.read.side_effect = etcd.EtcdValueError self.assertRaises(etcd.EtcdValueError, client.read, 'salt') etcd_client.read.side_effect = ValueError self.assertRaises(ValueError, client.read, 'salt') etcd_client.read.side_effect = ReadTimeoutError(None, None, None) self.assertRaises(etcd.EtcdConnectionFailed, client.read, 'salt') etcd_client.read.side_effect = MaxRetryError(None, None) self.assertRaises(etcd.EtcdConnectionFailed, client.read, 'salt')
def test_dropbox_folder_list_handles_max_retry_error(self, mock_metadata): mock_response = mock.Mock() url = self.project.api_url_for('dropbox_folder_list', folder_id='/') mock_metadata.side_effect = MaxRetryError(mock_response, url) with mock.patch.object(type(self.node_settings), 'has_auth', True): res = self.app.get(url, auth=self.user.auth, expect_errors=True) assert_equal(res.status_code, http.REQUEST_TIMEOUT)
def test_timeout(): transport = Transport(urlparse.urlparse('http://localhost')) responses.add('POST', '/', status=202, body=MaxRetryError(None, None, reason=TimeoutError())) with pytest.raises(TransportException) as exc_info: transport.send('x', {}, timeout=5) assert 'timeout' in str(exc_info.value)
def test_dropbox_hgrid_data_contents_handles_max_retry_error( self, mock_metadata): mock_response = mock.Mock() url = self.project.api_url_for('dropbox_hgrid_data_contents') mock_metadata.side_effect = MaxRetryError(mock_response, url) res = self.app.get(url, auth=self.user.auth, expect_errors=True) assert_equal(res.status_code, httplib.REQUEST_TIMEOUT)
def test_retry_exception_str(self): assert (str( MaxRetryError( HTTPConnectionPool(host="localhost"), "Test.", None)) == "HTTPConnectionPool(host='localhost', port=None): " "Max retries exceeded with url: Test. (Caused by None)") err = SocketError("Test") # using err.__class__ here, as socket.error is an alias for OSError # since Py3.3 and gets printed as this assert (str( MaxRetryError( HTTPConnectionPool(host="localhost"), "Test.", err)) == "HTTPConnectionPool(host='localhost', port=None): " "Max retries exceeded with url: Test. " "(Caused by %r)" % err)
def test_retry_exception_str(self): self.assertEqual( str(MaxRetryError( HTTPConnectionPool(host='localhost'), "Test.", None)), "HTTPConnectionPool(host='localhost', port=None): " "Max retries exceeded with url: Test. (Caused by redirect)") err = SocketError("Test") # using err.__class__ here, as socket.error is an alias for OSError # since Py3.3 and gets printed as this self.assertEqual( str(MaxRetryError( HTTPConnectionPool(host='localhost'), "Test.", err)), "HTTPConnectionPool(host='localhost', port=None): " "Max retries exceeded with url: Test. " "(Caused by {0}: Test)".format(str(err.__class__)))
class TestPickle(object): @pytest.mark.parametrize('exception', [ HTTPError(None), MaxRetryError(None, None, None), LocationParseError(None), ConnectTimeoutError(None), HTTPError('foo'), HTTPError('foo', IOError('foo')), MaxRetryError(HTTPConnectionPool('localhost'), '/', None), LocationParseError('fake location'), ClosedPoolError(HTTPConnectionPool('localhost'), None), EmptyPoolError(HTTPConnectionPool('localhost'), None), ReadTimeoutError(HTTPConnectionPool('localhost'), '/', None), ]) def test_exceptions(self, exception): result = pickle.loads(pickle.dumps(exception)) assert isinstance(result, type(exception))
def test_timeout(): transport = Transport("http://localhost", timeout=5) try: responses.add("POST", "/", status=202, body=MaxRetryError(None, None, reason=TimeoutError())) with pytest.raises(TransportException) as exc_info: transport.send("x") assert "timeout" in str(exc_info.value) finally: transport.close()
def test_timeout(mock_urlopen): transport = Transport("http://localhost", timeout=5) mock_urlopen.side_effect = MaxRetryError(None, None, reason=TimeoutError()) try: with pytest.raises(TransportException) as exc_info: transport.send("x") assert "timeout" in str(exc_info.value) finally: transport.close()
def test_do_request_exception_args_1(self): self.mock_requests( ).post.side_effect = requests.exceptions.ConnectionError( MaxRetryError('Abc', 'http://xxx.yyy', 'too many redirects')) with self.assertRaises(RequestException) as context: self.rest_client.do_request('POST', '/test') self.assertEqual( 'UnitTest REST API cannot be reached. Please ' 'check your configuration and that the API ' 'endpoint is accessible', context.exception.message)
def test_retry_session(self, github_retry): urlpart1 = "https://uploads.github.com:443/repos/brave/brave-browser/" urlpart2 = "releases/17325413/assets?name=brave-browser-0.61.51-1.x86_64.rpm" github_retry.side_effect = MaxRetryError("retry_session_pool", urlpart1 + urlpart2, MaxRetryError) try: github_retry() except MaxRetryError as mre: print("Caught MaxRetryError: {}".format(mre))
class TestPickle(object): @pytest.mark.parametrize( "exception", [ HTTPError(None), MaxRetryError(None, None, None), LocationParseError(None), ConnectTimeoutError(None), HTTPError("foo"), HTTPError("foo", IOError("foo")), MaxRetryError(HTTPConnectionPool("localhost"), "/", None), LocationParseError("fake location"), ClosedPoolError(HTTPConnectionPool("localhost"), None), EmptyPoolError(HTTPConnectionPool("localhost"), None), ReadTimeoutError(HTTPConnectionPool("localhost"), "/", None), ], ) def test_exceptions(self, exception): result = pickle.loads(pickle.dumps(exception)) assert isinstance(result, type(exception))
def _issue_command(self, commands: str): fields = {'commands': commands.split('\n')} r = self._get_connection_pool().request( 'POST', urljoin(self.url, 'api/printer/command'), headers=self._get_connection_headers(), body=json.dumps(fields).encode('utf-8')) if r.status == 204: return True else: raise MaxRetryError("Error sending command to instance")
def test_server(self, requests): """Ensure it's possible to fetch cookies from a server and errors are handled properly""" requests.return_value = requests requests.get.return_value = requests requests.cookies = {'session': self.encoded} stdout, stderr = self.call('--decode', '--server', 'http://*****:*****@localhost:8080') self.assertEqual(stdout.read().strip(), str(self.decoded)) for call in requests.mock_calls: if call[INDEX_FN_NAME] == 'get': if 'proxies' in call[INDEX_KWARGS]: break else: raise AssertionError( 'Didn\'t find "proxies" argument in call args.') error_reason = ProxyError() error_reason.args = ('Cannot connect to proxy', OSError('Tunnel connection failed')) error = ProxyError( MaxRetryError(reason=error_reason, pool=MagicMock(), url='http://*****:*****@localhost:8080') self.assertIn('Tunnel connection failed', stderr.read().strip())
def test_do_request_exception_nested_args(self): self.mock_requests( ).delete.side_effect = requests.exceptions.ConnectionError( MaxRetryError('Xyz', 'https://foo.bar', Exception('Foo: [Errno -42] bla bla bla'))) with self.assertRaises(RequestException) as context: self.rest_client.do_request('DELETE', '/test') self.assertEqual( 'UnitTest REST API cannot be reached: bla ' 'bla bla [errno -42]. Please check your ' 'configuration and that the API endpoint ' 'is accessible', context.exception.message)
def test_exceptions_with_objects(self): assert self.cycle(HTTPError('foo')) assert self.cycle( MaxRetryError(HTTPConnectionPool('localhost'), '/', None)) assert self.cycle(LocationParseError('fake location')) assert self.cycle( ClosedPoolError(HTTPConnectionPool('localhost'), None)) assert self.cycle(EmptyPoolError(HTTPConnectionPool('localhost'), None)) assert self.cycle( HostChangedError(HTTPConnectionPool('localhost'), '/', None)) assert self.cycle( ReadTimeoutError(HTTPConnectionPool('localhost'), '/', None))
def test_wait_server_start(self, mock_get): """ Tests wait_server_start """ mock_get.side_effect = MaxRetryError(None, "http://false") with self.assertRaises(MaxRetryError): with self.assertLogs() as logs: wait_server_start("http://false", "Wait for: %ds", "") self.assertEqual( logs.output, [ "INFO:root:Wait for: 0s", "INFO:root:Wait for: 1s", "INFO:root:Wait for: 2s", "INFO:root:Wait for: 3s", "INFO:root:Wait for: 4s", "INFO:root:Wait for: 5s", "INFO:root:Wait for: 6s", "INFO:root:Wait for: 7s", "INFO:root:Wait for: 8s", "INFO:root:Wait for: 9s", ], ) mock_response = mock.Mock() mock_response.status_code.return_value = 200 mock_get.side_effect = [ MaxRetryError(None, "http://false"), mock_response ] with self.assertLogs() as logs: wait_server_start("http://false", "Wait for: %ds", "Awaited: %ds") self.assertEqual(logs.output, ["INFO:root:Wait for: 0s", "INFO:root:Awaited: 1s"]) mock_get.side_effect = mock_response with self.assertLogs() as logs: wait_server_start("http://false", "Wait for: %ds", "Awaited: %ds") self.assertEqual(logs.output, ["INFO:root:Awaited: 0s"])
def test_timeout(mock_urlopen, elasticapm_client): elasticapm_client.server_version = (8, 0 ) # avoid making server_info request transport = Transport("http://localhost", timeout=5, client=elasticapm_client) transport.start_thread() mock_urlopen.side_effect = MaxRetryError(None, None, reason=TimeoutError()) try: with pytest.raises(TransportException) as exc_info: transport.send("x") assert "timeout" in str(exc_info.value) finally: transport.close()
def increment(self, method=None, url=None, response=None, error=None, _pool=None, _stacktrace=None): if response: mashery_error = response.getheader("X-Mashery-Error-Code") if mashery_error == 'ERR_403_DEVELOPER_OVER_QPD': raise MaxRetryError(_pool, url, error) return super(WhispirRetry, self).increment(method=method, url=url, response=response, error=error, _pool=_pool, _stacktrace=_stacktrace)
def bad_minio_endpoint(mocker): 'Simulate the Minio end point not being there at all' response1 = mocker.MagicMock() response1.data = '<xml></xml>' minio_client = mocker.MagicMock(spec=minio.Minio) pool = mocker.MagicMock() pool.host = 'http://dude' pool.port = 'fork-me' minio_client.list_objects.side_effect = MaxRetryError(pool, 'http://dude') mocker.patch('servicex.minio_adaptor.Minio', return_value=minio_client) p_rename = mocker.patch('servicex.minio_adaptor.Path.rename', mocker.MagicMock()) mocker.patch('servicex.minio_adaptor.Path.mkdir', mocker.MagicMock()) return p_rename, minio_client
def test_read(): """ Test to make sure we interact with etcd correctly """ with patch("etcd.Client", autospec=True) as mock: etcd_client = mock.return_value etcd_return = MagicMock(value="salt") etcd_client.read.return_value = etcd_return client = etcd_util.EtcdClient({}) assert client.read("/salt") == etcd_return etcd_client.read.assert_called_with( "/salt", recursive=False, wait=False, timeout=None ) client.read("salt", True, True, 10, 5) etcd_client.read.assert_called_with( "salt", recursive=True, wait=True, timeout=10, waitIndex=5 ) etcd_client.read.side_effect = etcd.EtcdKeyNotFound with pytest.raises(etcd.EtcdKeyNotFound): client.read("salt") etcd_client.read.side_effect = etcd.EtcdConnectionFailed with pytest.raises(etcd.EtcdConnectionFailed): client.read("salt") etcd_client.read.side_effect = etcd.EtcdValueError with pytest.raises(etcd.EtcdValueError): client.read("salt") etcd_client.read.side_effect = ValueError with pytest.raises(ValueError): client.read("salt") etcd_client.read.side_effect = ReadTimeoutError(None, None, None) with pytest.raises(etcd.EtcdConnectionFailed): client.read("salt") etcd_client.read.side_effect = MaxRetryError(None, None) with pytest.raises(etcd.EtcdConnectionFailed): client.read("salt")
def _print_file(self, file: File): # Accepts Django File or ContentFile class file_name = ''.join( random.choices(string.ascii_uppercase + string.digits, k=10) ) + '.gcode' if file.name is None else file.name with file.open('r') as f: # We add a M400 command at the end of the file, so, we avoid problems due marlin gcode cache file_content = f.read() + '\nM400 \nM115' r = json.loads(self._get_connection_pool().request( 'POST', urljoin(self.url, 'api/files/local'), headers=self._get_connection_headers(json_content=False), fields={ 'print': True, 'file': (file_name, file_content) }).data.decode('utf-8')) if r.get('done'): return file_name else: raise MaxRetryError("Error sending command to instance")
def test_watch(self): with patch('etcd.Client', autospec=True) as client_mock: client = etcd_util.EtcdClient({}) with patch.object(client, 'read', autospec=True) as mock: mock.return_value = MagicMock(value='stack', key='/some-key', modifiedIndex=1, dir=False) self.assertDictEqual(client.watch('/some-key'), {'value': 'stack', 'key': '/some-key', 'mIndex': 1, 'changed': True, 'dir': False}) mock.assert_called_with('/some-key', wait=True, recursive=False, timeout=0, waitIndex=None) mock.side_effect = iter([etcd_util.EtcdUtilWatchTimeout, mock.return_value]) self.assertDictEqual(client.watch('/some-key'), {'value': 'stack', 'changed': False, 'mIndex': 1, 'key': '/some-key', 'dir': False}) mock.side_effect = iter([etcd_util.EtcdUtilWatchTimeout, etcd.EtcdKeyNotFound]) self.assertEqual(client.watch('/some-key'), {'value': None, 'changed': False, 'mIndex': 0, 'key': '/some-key', 'dir': False}) mock.side_effect = iter([etcd_util.EtcdUtilWatchTimeout, ValueError]) self.assertEqual(client.watch('/some-key'), {}) mock.side_effect = None mock.return_value = MagicMock(value='stack', key='/some-key', modifiedIndex=1, dir=True) self.assertDictEqual(client.watch('/some-dir', recurse=True, timeout=5, index=10), {'value': 'stack', 'key': '/some-key', 'mIndex': 1, 'changed': True, 'dir': True}) mock.assert_called_with('/some-dir', wait=True, recursive=True, timeout=5, waitIndex=10) # iter(list(Exception)) works correctly with both mock<1.1 and mock>=1.1 mock.side_effect = iter([MaxRetryError(None, None)]) self.assertEqual(client.watch('/some-key'), {}) mock.side_effect = iter([etcd.EtcdConnectionFailed()]) self.assertEqual(client.watch('/some-key'), {}) mock.side_effect = None mock.return_value = None self.assertEqual(client.watch('/some-key'), {})
def urlopen(self, method, url, redirect=True, **kw): """ Same as :meth:`urllib3.connectionpool.HTTPConnectionPool.urlopen` with custom cross-host redirect logic and only sends the request-uri portion of the ``url``. The given ``url`` parameter must be absolute, such that an appropriate :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it. """ #=============================================================================================================== # add by mz error_type = kw.get('error_type') if error_type: from urllib3.exceptions import LocationValueError, HostChangedError, LocationParseError, ConnectTimeoutError from urllib3.exceptions import ProxyError, TimeoutError, ReadTimeoutError, ProtocolError, DecodeError from urllib3.exceptions import ResponseError, ResponseNotChunked, SSLError, HTTPError, HTTPWarning, PoolError from urllib3.exceptions import RequestError, MaxRetryError, TimeoutStateError, NewConnectionError from urllib3.exceptions import EmptyPoolError, ClosedPoolError, SecurityWarning, SubjectAltNameWarning from urllib3.exceptions import InsecureRequestWarning, SystemTimeWarning, InsecurePlatformWarning from urllib3.exceptions import SNIMissingWarning, DependencyWarning, ProxySchemeUnknown, HeaderParsingError get_error = { "LocationValueError": LocationValueError(), "HostChangedError": HostChangedError(pool=1, url=2), "LocationParseError": LocationParseError(url), "ConnectTimeoutError": ConnectTimeoutError(), "ProxyError": ProxyError(), "TimeoutError": TimeoutError(), "ReadTimeoutError": ReadTimeoutError(pool=1, url=2, message="ReadTimeoutError"), "ProtocolError": ProtocolError(), "DecodeError": DecodeError(), "ResponseError": ResponseError(), "ResponseNotChunked": ResponseNotChunked(), "SSLError": SSLError(), "HTTPError": HTTPError(), "HTTPWarning": HTTPWarning(), "PoolError": PoolError(pool=1, message=2), "RequestError": RequestError(pool=1, url=2, message="RequestError"), "MaxRetryError": MaxRetryError(pool=1, url=2, reason=None), "TimeoutStateError": TimeoutStateError(), "NewConnectionError": NewConnectionError(pool=1, message="NewConnectionError"), "EmptyPoolError": EmptyPoolError(pool=1, message="EmptyPoolError"), "ClosedPoolError": ClosedPoolError(pool=1, message="ClosedPoolError"), "SecurityWarning": SecurityWarning(), "SubjectAltNameWarning": SubjectAltNameWarning(), "InsecureRequestWarning": InsecureRequestWarning(), "SystemTimeWarning": SystemTimeWarning(), "InsecurePlatformWarning": InsecurePlatformWarning(), "SNIMissingWarning": SNIMissingWarning(), "DependencyWarning": DependencyWarning(), "ProxySchemeUnknown": ProxySchemeUnknown(scheme=1), "HeaderParsingError": HeaderParsingError(defects=1, unparsed_data=2) } error_ = get_error[error_type] raise error_ #=============================================================================================================== u = parse_url(url) conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme) kw['assert_same_host'] = False kw['redirect'] = False if 'headers' not in kw: kw['headers'] = self.headers if self.proxy is not None and u.scheme == "http": response = conn.urlopen(method, url, **kw) else: response = conn.urlopen(method, u.request_uri, **kw) redirect_location = redirect and response.get_redirect_location() if not redirect_location: return response # Support relative URLs for redirecting. redirect_location = urljoin(url, redirect_location) # RFC 2616, Section 10.3.4 if response.status == 303: method = 'GET' log.info("Redirecting %s -> %s" % (url, redirect_location)) kw['retries'] = kw.get('retries', 3) - 1 # Persist retries countdown kw['redirect'] = redirect return self.urlopen(method, redirect_location, **kw)