Python urllib3.exceptions.ReadTimeoutError() Examples
The following are 27
code examples of urllib3.exceptions.ReadTimeoutError().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
urllib3.exceptions
, or try the search function
.
Example #1
Source File: response.py From bash-lambda-layer with MIT License | 6 votes |
def read(self, amt=None): """Read at most amt bytes from the stream. If the amt argument is omitted, read all data. """ try: chunk = self._raw_stream.read(amt) except URLLib3ReadTimeoutError as e: # TODO: the url will be None as urllib3 isn't setting it yet raise ReadTimeoutError(endpoint_url=e.url, error=e) self._amount_read += len(chunk) if amt is None or (not chunk and amt > 0): # If the server sends empty contents or # we ask to read all of the contents, then we know # we need to verify the content length. self._verify_content_length() return chunk
Example #2
Source File: builder.py From polyaxon with Apache License 2.0 | 6 votes |
def push(destination, docker=None, max_retries=3, sleep_interval=1): docker_pusher = DockerPusher(destination=destination, docker=docker) retry = 0 is_done = False while retry < max_retries and not is_done: try: if not docker_pusher.push(): raise PolyaxonBuildException("The docker image could not be pushed.") else: is_done = True except ReadTimeoutError: retry += 1 time.sleep(sleep_interval) if not is_done: raise PolyaxonBuildException( "The docker image could not be pushed, client timed out." )
Example #3
Source File: response.py From AWS-Transit-Gateway-Demo-MultiAccount with MIT License | 6 votes |
def read(self, amt=None): """Read at most amt bytes from the stream. If the amt argument is omitted, read all data. """ try: chunk = self._raw_stream.read(amt) except URLLib3ReadTimeoutError as e: # TODO: the url will be None as urllib3 isn't setting it yet raise ReadTimeoutError(endpoint_url=e.url, error=e) self._amount_read += len(chunk) if amt is None or (not chunk and amt > 0): # If the server sends empty contents or # we ask to read all of the contents, then we know # we need to verify the content length. self._verify_content_length() return chunk
Example #4
Source File: response.py From AWS-Transit-Gateway-Demo-MultiAccount with MIT License | 6 votes |
def read(self, amt=None): """Read at most amt bytes from the stream. If the amt argument is omitted, read all data. """ try: chunk = self._raw_stream.read(amt) except URLLib3ReadTimeoutError as e: # TODO: the url will be None as urllib3 isn't setting it yet raise ReadTimeoutError(endpoint_url=e.url, error=e) self._amount_read += len(chunk) if amt is None or (not chunk and amt > 0): # If the server sends empty contents or # we ask to read all of the contents, then we know # we need to verify the content length. self._verify_content_length() return chunk
Example #5
Source File: response.py From deepWordBug with Apache License 2.0 | 6 votes |
def read(self, amt=None): """Read at most amt bytes from the stream. If the amt argument is omitted, read all data. """ try: chunk = self._raw_stream.read(amt) except URLLib3ReadTimeoutError as e: # TODO: the url will be None as urllib3 isn't setting it yet raise ReadTimeoutError(endpoint_url=e.url, error=e) self._amount_read += len(chunk) if amt is None or (not chunk and amt > 0): # If the server sends empty contents or # we ask to read all of the contents, then we know # we need to verify the content length. self._verify_content_length() return chunk
Example #6
Source File: kubernetes_executor.py From airflow with Apache License 2.0 | 6 votes |
def run(self) -> None: """Performs watching""" kube_client: client.CoreV1Api = get_kube_client() if not self.worker_uuid: raise AirflowException(NOT_STARTED_MESSAGE) while True: try: self.resource_version = self._run(kube_client, self.resource_version, self.worker_uuid, self.kube_config) except ReadTimeoutError: self.log.warning("There was a timeout error accessing the Kube API. " "Retrying request.", exc_info=True) time.sleep(1) except Exception: self.log.exception('Unknown error in KubernetesJobWatcher. Failing') raise else: self.log.warning('Watch died gracefully, starting back up with: ' 'last resource_version: %s', self.resource_version)
Example #7
Source File: download_single_item.py From ISIC-Archive-Downloader with Apache License 2.0 | 6 votes |
def fetch_description(url: str) -> list: """ :param id: Id of the image whose description will be downloaded :return: Json """ # Sometimes their site isn't responding well, and than an error occurs, # So we will retry 10 seconds later and repeat until it succeeds while True: try: # Download the description response_desc = requests.get(url, stream=True, timeout=20) # Validate the download status is ok response_desc.raise_for_status() # Parse the description parsed_description = response_desc.json() return parsed_description except (RequestException, ReadTimeoutError): time.sleep(5)
Example #8
Source File: response.py From aws-builders-fair-projects with Apache License 2.0 | 6 votes |
def read(self, amt=None): """Read at most amt bytes from the stream. If the amt argument is omitted, read all data. """ try: chunk = self._raw_stream.read(amt) except URLLib3ReadTimeoutError as e: # TODO: the url will be None as urllib3 isn't setting it yet raise ReadTimeoutError(endpoint_url=e.url, error=e) self._amount_read += len(chunk) if amt is None or (not chunk and amt > 0): # If the server sends empty contents or # we ask to read all of the contents, then we know # we need to verify the content length. self._verify_content_length() return chunk
Example #9
Source File: http_urllib3.py From watchmen with Apache License 2.0 | 5 votes |
def perform_request(self, method, url, params=None, body=None, timeout=None, ignore=()): url = self.url_prefix + url if params: url = '%s?%s' % (url, urlencode(params)) full_url = self.host + url start = time.time() try: kw = {} if timeout: kw['timeout'] = timeout # in python2 we need to make sure the url and method are not # unicode. Otherwise the body will be decoded into unicode too and # that will fail (#133, #201). if not isinstance(url, str): url = url.encode('utf-8') if not isinstance(method, str): method = method.encode('utf-8') response = self.pool.urlopen(method, url, body, retries=False, headers=self.headers, **kw) duration = time.time() - start raw_data = response.data.decode('utf-8') except Exception as e: self.log_request_fail(method, full_url, url, body, time.time() - start, exception=e) if isinstance(e, UrllibSSLError): raise SSLError('N/A', str(e), e) if isinstance(e, ReadTimeoutError): raise ConnectionTimeout('TIMEOUT', str(e), e) raise ConnectionError('N/A', str(e), e) # raise errors based on http status codes, let the client handle those if needed if not (200 <= response.status < 300) and response.status not in ignore: self.log_request_fail(method, full_url, url, body, duration, response.status, raw_data) self._raise_error(response.status, raw_data) self.log_request_success(method, full_url, url, body, response.status, raw_data, duration) return response.status, response.getheaders(), raw_data
Example #10
Source File: test_etcd.py From patroni with MIT License | 5 votes |
def http_request(method, url, **kwargs): if url == 'http://localhost:2379/timeout': raise ReadTimeoutError(None, None, None) ret = MockResponse() if url == 'http://localhost:2379/v2/machines': ret.content = 'http://localhost:2379,http://localhost:4001' elif url == 'http://localhost:4001/v2/machines': ret.content = '' elif url != 'http://localhost:2379/': raise socket.error return ret
Example #11
Source File: etcd.py From patroni with MIT License | 5 votes |
def _do_http_request(self, retry, machines_cache, request_executor, method, path, fields=None, **kwargs): some_request_failed = False for i, base_uri in enumerate(machines_cache): if i > 0: logger.info("Retrying on %s", base_uri) try: response = request_executor(method, base_uri + path, fields=fields, **kwargs) response.data.decode('utf-8') self._check_cluster_id(response) if some_request_failed: self.set_base_uri(base_uri) self._refresh_machines_cache() return response except (HTTPError, HTTPException, socket.error, socket.timeout) as e: self.http.clear() # switch to the next etcd node because we don't know exactly what happened, # whether the key didn't received an update or there is a network problem. if not retry and i + 1 < len(machines_cache): self.set_base_uri(machines_cache[i + 1]) if (isinstance(fields, dict) and fields.get("wait") == "true" and isinstance(e, (ReadTimeoutError, ProtocolError))): logger.debug("Watch timed out.") raise etcd.EtcdWatchTimedOut("Watch timed out: {0}".format(e), cause=e) logger.error("Request to server %s failed: %r", base_uri, e) logger.info("Reconnection allowed, looking for another server.") if not retry: raise etcd.EtcdException('{0} {1} request failed'.format(method, path)) some_request_failed = True raise etcd.EtcdConnectionFailed('No more machines in the cluster')
Example #12
Source File: test_builder.py From polyaxon with Apache License 2.0 | 5 votes |
def test_push_raise_timeout(self, build_mock, push_mock): push_mock.side_effect = ReadTimeoutError(None, "foo", "error") with self.assertRaises(PolyaxonBuildException): build_and_push( context=".", destination="image_name:image_tag", nocache=True, max_retries=1, sleep_interval=0, ) assert build_mock.call_count == 1
Example #13
Source File: download_single_item.py From ISIC-Archive-Downloader with Apache License 2.0 | 5 votes |
def download_img(cls, img_url, img_name, dir, max_tries=None): """ Download the image from the given url and save it in the given dir, naming it using img_name with an jpg extension :param img_name: :param img_url: Url to download the image through :param dir: Directory in which to save the image :return Whether the image was downloaded successfully """ # Sometimes their site isn't responding well, and than an error occurs, # So we will retry a few seconds later and repeat until it succeeds tries = 0 while max_tries is None or tries <= max_tries: try: # print('Attempting to download image {0}'.format(img_name)) response = requests.get(img_url, stream=True, timeout=20) # Validate the download status is ok response.raise_for_status() # Find the format of the image format = response.headers['Content-Type'].split('/')[1] # Write the image into a file image_string = response.raw img_path = join(dir, '{0}.{1}'.format(img_name, format)) with open(img_path, 'wb') as imageFile: shutil.copyfileobj(image_string, imageFile) # Validate the image was downloaded correctly cls.validate_image(img_path) # print('Finished Downloading image {0}'.format(img_name)) return True except (RequestException, ReadTimeoutError, IOError): tries += 1 time.sleep(5) return False
Example #14
Source File: core.py From mars with Apache License 2.0 | 5 votes |
def watch(self): from urllib3.exceptions import ReadTimeoutError from kubernetes import watch cur_pods = set(self.get(True)) w = watch.Watch() while True: # when some schedulers are not ready, we refresh faster linger = 10 if self.is_all_ready() else 1 streamer = w.stream(self._client.list_namespaced_pod, namespace=self._k8s_namespace, label_selector=self._label_selector, timeout_seconds=linger) while True: try: event = self._pool.spawn(next, streamer, StopIteration).result() if event is StopIteration: raise StopIteration except (ReadTimeoutError, StopIteration): new_pods = set(self.get(True)) if new_pods != cur_pods: cur_pods = new_pods yield self.get(False) break except: # noqa: E722 logger.exception('Unexpected error when watching on kubernetes') break obj_dict = event['object'].to_dict() pod_name, endpoint = self._extract_pod_name_ep(obj_dict) self._pod_to_ep[pod_name] = endpoint \ if endpoint and self._extract_pod_ready(obj_dict) else None yield self.get(False)
Example #15
Source File: http_urllib3.py From splunk-elasticsearch with Apache License 2.0 | 5 votes |
def perform_request(self, method, url, params=None, body=None, timeout=None, ignore=()): url = self.url_prefix + url if params: url = '%s?%s' % (url, urlencode(params)) full_url = self.host + url start = time.time() try: kw = {} if timeout: kw['timeout'] = timeout # in python2 we need to make sure the url is not unicode. Otherwise # the body will be decoded into unicode too and that will fail (#133). if not isinstance(url, str): url = url.encode('utf-8') response = self.pool.urlopen(method, url, body, retries=False, headers=self.headers, **kw) duration = time.time() - start raw_data = response.data.decode('utf-8') except UrllibSSLError as e: self.log_request_fail(method, full_url, body, time.time() - start, exception=e) raise SSLError('N/A', str(e), e) except ReadTimeoutError as e: self.log_request_fail(method, full_url, body, time.time() - start, exception=e) raise ConnectionTimeout('TIMEOUT', str(e), e) except Exception as e: self.log_request_fail(method, full_url, body, time.time() - start, exception=e) raise ConnectionError('N/A', str(e), e) if not (200 <= response.status < 300) and response.status not in ignore: self.log_request_fail(method, url, body, duration, response.status) self._raise_error(response.status, raw_data) self.log_request_success(method, full_url, url, body, response.status, raw_data, duration) return response.status, response.getheaders(), raw_data
Example #16
Source File: http_urllib3.py From sublime-elasticsearch-client with MIT License | 5 votes |
def perform_request(self, method, url, params=None, body=None, timeout=None, ignore=()): url = self.url_prefix + url if params: url = '%s?%s' % (url, urlencode(params)) full_url = self.host + url start = time.time() try: kw = {} if timeout: kw['timeout'] = timeout # in python2 we need to make sure the url and method are not # unicode. Otherwise the body will be decoded into unicode too and # that will fail (#133, #201). if not isinstance(url, str): url = url.encode('utf-8') if not isinstance(method, str): method = method.encode('utf-8') response = self.pool.urlopen(method, url, body, retries=False, headers=self.headers, **kw) duration = time.time() - start raw_data = response.data.decode('utf-8') except UrllibSSLError as e: self.log_request_fail(method, full_url, body, time.time() - start, exception=e) raise SSLError('N/A', str(e), e) except ReadTimeoutError as e: self.log_request_fail(method, full_url, body, time.time() - start, exception=e) raise ConnectionTimeout('TIMEOUT', str(e), e) except Exception as e: self.log_request_fail(method, full_url, body, time.time() - start, exception=e) raise ConnectionError('N/A', str(e), e) if not (200 <= response.status < 300) and response.status not in ignore: self.log_request_fail(method, url, body, duration, response.status) self._raise_error(response.status, raw_data) self.log_request_success(method, full_url, url, body, response.status, raw_data, duration) return response.status, response.getheaders(), raw_data
Example #17
Source File: test_builder.py From polyaxon with Apache License 2.0 | 5 votes |
def test_build_raise_timeout(self, build_mock): build_mock.side_effect = ReadTimeoutError(None, "foo", "error") with self.assertRaises(PolyaxonBuildException): build( context=".", destination="image_name:image_tag", nocache=True, max_retries=1, sleep_interval=0, )
Example #18
Source File: builder.py From polyaxon with Apache License 2.0 | 5 votes |
def build( context, destination, nocache, docker=None, credstore_env=None, registries=None, max_retries=3, sleep_interval=1, ): """Build necessary code for a job to run""" retry = 0 is_done = False while retry < max_retries and not is_done: try: docker_builder = _build( context=context, destination=destination, docker=docker, nocache=nocache, credstore_env=credstore_env, registries=registries, ) is_done = True return docker_builder except ReadTimeoutError: retry += 1 time.sleep(sleep_interval) if not is_done: raise PolyaxonBuildException( "The docker image could not be built, client timed out." )
Example #19
Source File: httpsession.py From AWS-Transit-Gateway-Demo-MultiAccount with MIT License | 4 votes |
def send(self, request): try: proxy_url = self._proxy_config.proxy_url_for(request.url) manager = self._get_connection_manager(request.url, proxy_url) conn = manager.connection_from_url(request.url) self._setup_ssl_cert(conn, request.url, self._verify) request_target = self._get_request_target(request.url, proxy_url) urllib_response = conn.urlopen( method=request.method, url=request_target, body=request.body, headers=request.headers, retries=False, assert_same_host=False, preload_content=False, decode_content=False, ) http_response = botocore.awsrequest.AWSResponse( request.url, urllib_response.status, urllib_response.headers, urllib_response, ) if not request.stream_output: # Cause the raw stream to be exhausted immediately. We do it # this way instead of using preload_content because # preload_content will never buffer chunked responses http_response.content return http_response except URLLib3SSLError as e: raise SSLError(endpoint_url=request.url, error=e) except (NewConnectionError, socket.gaierror) as e: raise EndpointConnectionError(endpoint_url=request.url, error=e) except ProxyError as e: raise ProxyConnectionError(proxy_url=proxy_url, error=e) except URLLib3ConnectTimeoutError as e: raise ConnectTimeoutError(endpoint_url=request.url, error=e) except URLLib3ReadTimeoutError as e: raise ReadTimeoutError(endpoint_url=request.url, error=e) except ProtocolError as e: raise ConnectionClosedError( error=e, request=request, endpoint_url=request.url ) except Exception as e: message = 'Exception received when sending urllib3 HTTP request' logger.debug(message, exc_info=True) raise HTTPClientError(error=e)
Example #20
Source File: httpsession.py From aws-builders-fair-projects with Apache License 2.0 | 4 votes |
def send(self, request): try: proxy_url = self._proxy_config.proxy_url_for(request.url) manager = self._get_connection_manager(request.url, proxy_url) conn = manager.connection_from_url(request.url) self._setup_ssl_cert(conn, request.url, self._verify) request_target = self._get_request_target(request.url, proxy_url) urllib_response = conn.urlopen( method=request.method, url=request_target, body=request.body, headers=request.headers, retries=False, assert_same_host=False, preload_content=False, decode_content=False, chunked=self._chunked(request.headers), ) http_response = botocore.awsrequest.AWSResponse( request.url, urllib_response.status, urllib_response.headers, urllib_response, ) if not request.stream_output: # Cause the raw stream to be exhausted immediately. We do it # this way instead of using preload_content because # preload_content will never buffer chunked responses http_response.content return http_response except URLLib3SSLError as e: raise SSLError(endpoint_url=request.url, error=e) except (NewConnectionError, socket.gaierror) as e: raise EndpointConnectionError(endpoint_url=request.url, error=e) except ProxyError as e: raise ProxyConnectionError(proxy_url=proxy_url, error=e) except URLLib3ConnectTimeoutError as e: raise ConnectTimeoutError(endpoint_url=request.url, error=e) except URLLib3ReadTimeoutError as e: raise ReadTimeoutError(endpoint_url=request.url, error=e) except ProtocolError as e: raise ConnectionClosedError( error=e, request=request, endpoint_url=request.url ) except Exception as e: message = 'Exception received when sending urllib3 HTTP request' logger.debug(message, exc_info=True) raise HTTPClientError(error=e)
Example #21
Source File: etcd_db_driver.py From dragonflow with Apache License 2.0 | 4 votes |
def _error_catcher(self): """ Catch low-level python exceptions, instead re-raising urllib3 variants, so that low-level exceptions are not leaked in the high-level api. On exit, release the connection back to the pool. """ try: try: yield except SocketTimeout: # FIXME: Ideally we'd like to include the url in the # ReadTimeoutError but there is yet no clean way to # get at it from this context. raise exceptions.ReadTimeoutError( self._pool, None, 'Read timed out.') except connection.BaseSSLError as e: # FIXME: Is there a better way to differentiate between SSLErrors? if 'read operation timed out' not in str(e): # Defensive: # This shouldn't happen but just in case we're missing an edge # case, let's avoid swallowing SSL errors. raise raise exceptions.ReadTimeoutError( self._pool, None, 'Read timed out.') except connection.HTTPException as e: # This includes IncompleteRead. raise exceptions.ProtocolError('Connection broken: %r' % e, e) except Exception: # The response may not be closed but we're not going to use it anymore # so close it now to ensure that the connection is released back to the # pool. if self._original_response and not self._original_response.isclosed(): self._original_response.close() # Before returning the socket, close it. From the server's # point of view, # this socket is in the middle of handling an SSL handshake/HTTP # request so it we were to try and re-use the connection later, # we'd see undefined behaviour. # # Still return the connection to the pool (it will be # re-established next time it is used). self._connection.close() raise finally: if self._original_response and self._original_response.isclosed(): self.release_conn()
Example #22
Source File: httpsession.py From AWS-Transit-Gateway-Demo-MultiAccount with MIT License | 4 votes |
def send(self, request): try: proxy_url = self._proxy_config.proxy_url_for(request.url) manager = self._get_connection_manager(request.url, proxy_url) conn = manager.connection_from_url(request.url) self._setup_ssl_cert(conn, request.url, self._verify) request_target = self._get_request_target(request.url, proxy_url) urllib_response = conn.urlopen( method=request.method, url=request_target, body=request.body, headers=request.headers, retries=False, assert_same_host=False, preload_content=False, decode_content=False, ) http_response = botocore.awsrequest.AWSResponse( request.url, urllib_response.status, urllib_response.headers, urllib_response, ) if not request.stream_output: # Cause the raw stream to be exhausted immediately. We do it # this way instead of using preload_content because # preload_content will never buffer chunked responses http_response.content return http_response except URLLib3SSLError as e: raise SSLError(endpoint_url=request.url, error=e) except (NewConnectionError, socket.gaierror) as e: raise EndpointConnectionError(endpoint_url=request.url, error=e) except ProxyError as e: raise ProxyConnectionError(proxy_url=proxy_url, error=e) except URLLib3ConnectTimeoutError as e: raise ConnectTimeoutError(endpoint_url=request.url, error=e) except URLLib3ReadTimeoutError as e: raise ReadTimeoutError(endpoint_url=request.url, error=e) except ProtocolError as e: raise ConnectionClosedError( error=e, request=request, endpoint_url=request.url ) except Exception as e: message = 'Exception received when sending urllib3 HTTP request' logger.debug(message, exc_info=True) raise HTTPClientError(error=e)
Example #23
Source File: httpsession.py From bash-lambda-layer with MIT License | 4 votes |
def send(self, request): try: proxy_url = self._proxy_config.proxy_url_for(request.url) manager = self._get_connection_manager(request.url, proxy_url) conn = manager.connection_from_url(request.url) self._setup_ssl_cert(conn, request.url, self._verify) request_target = self._get_request_target(request.url, proxy_url) urllib_response = conn.urlopen( method=request.method, url=request_target, body=request.body, headers=request.headers, retries=False, assert_same_host=False, preload_content=False, decode_content=False, chunked=self._chunked(request.headers), ) http_response = botocore.awsrequest.AWSResponse( request.url, urllib_response.status, urllib_response.headers, urllib_response, ) if not request.stream_output: # Cause the raw stream to be exhausted immediately. We do it # this way instead of using preload_content because # preload_content will never buffer chunked responses http_response.content return http_response except URLLib3SSLError as e: raise SSLError(endpoint_url=request.url, error=e) except (NewConnectionError, socket.gaierror) as e: raise EndpointConnectionError(endpoint_url=request.url, error=e) except ProxyError as e: raise ProxyConnectionError(proxy_url=proxy_url, error=e) except URLLib3ConnectTimeoutError as e: raise ConnectTimeoutError(endpoint_url=request.url, error=e) except URLLib3ReadTimeoutError as e: raise ReadTimeoutError(endpoint_url=request.url, error=e) except ProtocolError as e: raise ConnectionClosedError( error=e, request=request, endpoint_url=request.url ) except Exception as e: message = 'Exception received when sending urllib3 HTTP request' logger.debug(message, exc_info=True) raise HTTPClientError(error=e)
Example #24
Source File: http.py From OpenDoor with GNU General Public License v3.0 | 4 votes |
def request(self, url): """ Client request HTTP :param str url: request uri :return: urllib3.HTTPResponse """ if self._HTTP_DBG_LEVEL <= self.__debug.level: self.__debug.debug_request(self._headers, url, self.__cfg.method) try: if self.__cfg.DEFAULT_SCAN == self.__cfg.scan: response = self.__pool.request(self.__cfg.method, helper.parse_url(url).path, headers=self._headers, retries=self.__cfg.retries, assert_same_host=True, redirect=False) self.cookies_middleware(is_accept=self.__cfg.accept_cookies, response=response) else: response = PoolManager().request(self.__cfg.method, url, headers=self._headers, retries=self.__cfg.retries, assert_same_host=False, redirect=False) return response except MaxRetryError: if self.__cfg.DEFAULT_SCAN == self.__cfg.scan: self.__tpl.warning(key='max_retry_error', url=helper.parse_url(url).path) pass except HostChangedError as error: self.__tpl.warning(key='host_changed_error', details=error) pass except ReadTimeoutError: self.__tpl.warning(key='read_timeout_error', url=url) pass except ConnectTimeoutError: self.__tpl.warning(key='connection_timeout_error', url=url) pass
Example #25
Source File: httpsession.py From deepWordBug with Apache License 2.0 | 4 votes |
def send(self, request): try: proxy_url = self._proxy_config.proxy_url_for(request.url) manager = self._get_connection_manager(request.url, proxy_url) conn = manager.connection_from_url(request.url) self._setup_ssl_cert(conn, request.url, self._verify) request_target = self._get_request_target(request.url, proxy_url) urllib_response = conn.urlopen( method=request.method, url=request_target, body=request.body, headers=request.headers, retries=False, assert_same_host=False, preload_content=False, decode_content=False, ) http_response = botocore.awsrequest.AWSResponse( request.url, urllib_response.status, urllib_response.headers, urllib_response, ) if not request.stream_output: # Cause the raw stream to be exhausted immediately. We do it # this way instead of using preload_content because # preload_content will never buffer chunked responses http_response.content return http_response except URLLib3SSLError as e: raise SSLError(endpoint_url=request.url, error=e) except (NewConnectionError, socket.gaierror) as e: raise EndpointConnectionError(endpoint_url=request.url, error=e) except ProxyError as e: raise ProxyConnectionError(proxy_url=proxy_url, error=e) except URLLib3ConnectTimeoutError as e: raise ConnectTimeoutError(endpoint_url=request.url, error=e) except URLLib3ReadTimeoutError as e: raise ReadTimeoutError(endpoint_url=request.url, error=e) except ProtocolError as e: raise ConnectionClosedError( error=e, request=request, endpoint_url=request.url ) except Exception as e: message = 'Exception received when sending urllib3 HTTP request' logger.debug(message, exc_info=True) raise HTTPClientError(error=e)
Example #26
Source File: http_urllib3.py From Mastering-Elasticsearch-7.0 with MIT License | 4 votes |
def perform_request( self, method, url, params=None, body=None, timeout=None, ignore=(), headers=None ): url = self.url_prefix + url if params: url = "%s?%s" % (url, urlencode(params)) full_url = self.host + url start = time.time() try: kw = {} if timeout: kw["timeout"] = timeout # in python2 we need to make sure the url and method are not # unicode. Otherwise the body will be decoded into unicode too and # that will fail (#133, #201). if not isinstance(url, str): url = url.encode("utf-8") if not isinstance(method, str): method = method.encode("utf-8") request_headers = self.headers if headers: request_headers = request_headers.copy() request_headers.update(headers) if self.http_compress and body: try: body = gzip.compress(body) except AttributeError: # oops, Python2.7 doesn't have `gzip.compress` let's try # again body = gzip.zlib.compress(body) response = self.pool.urlopen( method, url, body, retries=Retry(False), headers=request_headers, **kw ) duration = time.time() - start raw_data = response.data.decode("utf-8") except Exception as e: self.log_request_fail( method, full_url, url, body, time.time() - start, exception=e ) if isinstance(e, UrllibSSLError): raise SSLError("N/A", str(e), e) if isinstance(e, ReadTimeoutError): raise ConnectionTimeout("TIMEOUT", str(e), e) raise ConnectionError("N/A", str(e), e) # raise errors based on http status codes, let the client handle those if needed if not (200 <= response.status < 300) and response.status not in ignore: self.log_request_fail( method, full_url, url, body, duration, response.status, raw_data ) self._raise_error(response.status, raw_data) self.log_request_success( method, full_url, url, body, response.status, raw_data, duration ) return response.status, response.getheaders(), raw_data
Example #27
Source File: test_tasker.py From atomic-reactor with BSD 3-Clause "New" or "Revised" License | 4 votes |
def test_retry_generator(exc, in_init, retry_times): def simplegen(): yield "log line" my_args = ('some', 'new') if not in_init: my_kwargs = {'one': 'first', 'two': 'second', 'retry_times': retry_times} else: my_kwargs = {'one': 'first', 'two': 'second'} if in_init: t = DockerTasker(retry_times=retry_times) else: t = DockerTasker() (flexmock(time) .should_receive('sleep') .and_return(None)) if not exc: cr = CommandResult() cr._error = "cmd_error" cr._error_detail = {"message": "error_detail"} if exc == APIError: error_message = 'api_error' response = flexmock(content=error_message, status_code=408) (flexmock(atomic_reactor.util) .should_receive('wait_for_command') .times(retry_times + 1) .and_raise(APIError, error_message, response)) elif exc == ProtocolError: error_message = 'protocol_error' (flexmock(atomic_reactor.util) .should_receive('wait_for_command') .times(retry_times + 1) .and_raise(ProtocolError, error_message)) elif exc == ReadTimeoutError: pool = 'pool' message = 'read_timeout_error' error_message = '{}: {}'.format(pool, message) (flexmock(atomic_reactor.util) .should_receive('wait_for_command') .times(retry_times + 1) .and_raise(ReadTimeoutError, pool, 'url', message)) else: (flexmock(atomic_reactor.util) .should_receive('wait_for_command') .times(retry_times + 1) .and_return(cr)) error_message = 'cmd_error' if retry_times >= 0: with pytest.raises(RetryGeneratorException) as ex: t.retry_generator(lambda *args, **kwargs: simplegen(), *my_args, **my_kwargs) assert repr(error_message) in repr(ex.value) else: t.retry_generator(lambda *args, **kwargs: simplegen(), *my_args, **my_kwargs)