def perform_request(self, method, url, params=None, body=None, timeout=None, ignore=(), headers=None):
url_path = url
if params:
url_path = '%s?%s' % (url, urlencode(params or {}))
url = self.base_url + url_path
start = self.loop.time()
response = None
try:
with async_timeout.timeout(timeout or self.timeout, loop=self.loop):
response = yield from self.session.request(method, url, data=body, headers=headers)
raw_data = yield from response.text()
duration = self.loop.time() - start
except Exception as e:
self.log_request_fail(method, url, url_path, body, self.loop.time() - start, exception=e)
if isinstance(e, ServerFingerprintMismatch):
raise SSLError('N/A', str(e), e)
if isinstance(e, asyncio.TimeoutError):
raise ConnectionTimeout('TIMEOUT', str(e), e)
raise ConnectionError('N/A', str(e), e)
finally:
if response is not None:
yield from response.release()
# 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, url, url_path, body, duration, status_code=response.status, response=raw_data)
self._raise_error(response.status, raw_data)
self.log_request_success(method, url, url_path, body, response.status, raw_data, duration)
return response.status, response.headers, raw_data
def perform_request(self,
method,
url,
params=None,
body=None,
timeout=None,
ignore=(),
headers=None):
url = self.base_url + url
if params:
url = '%s?%s' % (url, urlencode(params or {}))
start = time.time()
request = requests.Request(method=method,
headers=headers,
url=url,
data=body)
prepared_request = self.session.prepare_request(request)
settings = self.session.merge_environment_settings(
prepared_request.url, {}, None, None, None)
send_kwargs = {'timeout': timeout or self.timeout}
send_kwargs.update(settings)
try:
response = self.session.request(prepared_request.method,
prepared_request.url,
data=prepared_request.body,
headers=prepared_request.headers,
**send_kwargs)
duration = time.time() - start
raw_data = response.text
except Exception as e:
self.log_request_fail(method,
url,
prepared_request.path_url,
body,
time.time() - start,
exception=e)
if isinstance(e, requests.exceptions.SSLError):
raise SSLError('N/A', str(e), e)
if isinstance(e, requests.Timeout):
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_code <
300) and response.status_code not in ignore:
self.log_request_fail(method, url, response.request.path_url, body,
duration, response.status_code, raw_data)
self._raise_error(response.status_code, raw_data)
self.log_request_success(method, url, response.request.path_url, body,
response.status_code, raw_data, duration)
return response.status_code, response.headers, raw_data
def perform_request(self, method, url, params=None, body=None, timeout=None, ignore=(), headers=None):
url_path = url
if params:
query_string = urlencode(params)
else:
query_string = ""
# Provide correct URL object to avoid string parsing in low-level code
url = yarl.URL.build(scheme=self.scheme,
host=self.hostname,
port=self.port,
path=url,
query_string=query_string,
encoded=True)
start = self.loop.time()
response = None
try:
request_timeout = timeout or self.timeout.total
with async_timeout.timeout(request_timeout, loop=self.loop):
# override the default session timeout explicitly
response = yield from self.session.request(method, url, data=body, headers=headers, timeout=request_timeout)
raw_data = yield from response.text()
duration = self.loop.time() - start
except asyncio.CancelledError:
raise
except Exception as e:
self.log_request_fail(method, url, url_path, body, self.loop.time() - start, exception=e)
if isinstance(e, ServerFingerprintMismatch):
raise SSLError('N/A', str(e), e)
if isinstance(e, asyncio.TimeoutError):
raise ConnectionTimeout('TIMEOUT', str(e), e)
raise ConnectionError('N/A', str(e), e)
finally:
if response is not None:
yield from response.release()
# 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, url, url_path, body, duration, status_code=response.status, response=raw_data)
self._raise_error(response.status, raw_data)
self.log_request_success(method, url, url_path, body, response.status, raw_data, duration)
return response.status, response.headers, raw_data
def perform_request(self, method, url, params=None, body=None, timeout=None, ignore=()): # noqa
url_path = url
url = (self.base_url / url.lstrip('/')).with_query(params)
start = self.loop.time()
response = None
try:
with aiohttp.Timeout(timeout or self.timeout, loop=self.loop): # noqa
response = yield from self.session.request(method, url, data=body, headers=self.headers, timeout=None) # noqa
raw_data = yield from response.text()
duration = self.loop.time() - start
except asyncio.TimeoutError as exc:
self.log_request_fail(method, url, url_path, body, self.loop.time() - start, exception=exc) # noqa
raise ConnectionTimeout('TIMEOUT', str(exc), exc)
except FingerprintMismatch as exc:
self.log_request_fail(method, url, url_path, body, self.loop.time() - start, exception=exc) # noqa
raise SSLError('N/A', str(exc), exc)
except ClientError as exc:
self.log_request_fail(method, url, url_path, body, self.loop.time() - start, exception=exc) # noqa
raise ConnectionError('N/A', str(exc), exc)
finally:
if response is not None:
yield from response.release()
# raise errors based on http status codes, let the client handle those if needed # noqa
if not (200 <= response.status < 300) and response.status not in ignore: # noqa
self.log_request_fail(method, url, url_path, body, duration, response.status, raw_data) # noqa
self._raise_error(response.status, raw_data)
self.log_request_success(method, url, url_path, body, response.status, raw_data, duration) # noqa
return response.status, response.headers, raw_data
def perform_request(self, method, url, params=None, body=None, timeout=None, ignore=()):
url = self.base_url + url
if params:
url = '%s?%s' % (url, urlencode(params or {}))
start = time.time()
headers = self.headers.copy()
try:
response = urlfetch.Fetch(url,
payload=body,
method=method,
headers=headers,
allow_truncated=False,
follow_redirects=True,
deadline=timeout,
validate_certificate=self.verify_certs)
duration = time.time() - start
raw_data = response.content
except Exception as e:
self.log_request_fail(method, url, url, body, time.time() - start, exception=e)
if isinstance(e, urlfetch_errors.SSLCertificateError):
raise SSLError('N/A', str(e), e)
if isinstance(e, urlfetch_errors.DeadlineExceededError):
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_code < 300) and response.status_code not in ignore:
self.log_request_fail(method, url, url, body, duration)
self._raise_error(response.status_code, raw_data)
self.log_request_success(method, url, url, body, response.status_code, raw_data, duration)
return response.status_code, response.headers, raw_data