async def check_response(response: aiohttp.ClientResponse, ) -> None: """ Check for specialised K8s errors, and raise with extended information. """ if response.status >= 400: # Read the response's body before it is closed by raise_for_status(). payload: Optional[RawStatus] try: payload = await response.json() except (json.JSONDecodeError, aiohttp.ContentTypeError, aiohttp.ClientConnectionError): payload = None # Better be safe: who knows which sensitive information can be dumped unless kind==Status. if not isinstance( payload, collections.abc.Mapping) or payload.get('kind') != 'Status': payload = None cls = (APIUnauthorizedError if response.status == 401 else APIForbiddenError if response.status == 403 else APINotFoundError if response.status == 404 else APIError) # Raise the framework-specific error while keeping the original error in scope. # This call also closes the response's body, so it cannot be read afterwards. try: response.raise_for_status() except aiohttp.ClientResponseError as e: raise cls(payload, status=response.status) from e
async def _raise_for_status(resp: aiohttp.ClientResponse) -> None: """Check resp for status and if error log additional info.""" try: resp.raise_for_status() except aiohttp.ClientResponseError: log.exception('Error body: %s', await resp.text()) raise
async def _extract_response_data( resp: aiohttp.ClientResponse, ) -> list | dict: """Checks the correctness of the response. Args: resp: Response instance. Returns: resp['data'] field if expected data. Raises: aiohttp.ClientResponseError: if response status >= 400. aiohttp.ClientPayloadError: if failure result of the request. #TODO: refactor for process HTTP statuses! """ resp.raise_for_status() json = await resp.json() if json.get("success"): _LOG.debug( "Successfully response", extra={ "url": resp.url, }, ) return json.get("data", {}) raise aiohttp.ClientPayloadError(f"Failure server result: {resp.url} {json}")
async def _raise_for_status(resp: aiohttp.ClientResponse) -> None: """Check resp for status and if error log additional info.""" body = await resp.text(errors='replace') try: resp.raise_for_status() except aiohttp.ClientResponseError: log.exception('got http error response: %s', body) raise
def _check_status(r: aiohttp.ClientResponse, expected_status): r.raise_for_status() if r.status != expected_status: raise DSWCommunicationError( reason='Unexpected response status', message=f'Server responded with unexpected HTTP status {r.status}: ' f'{r.reason} (expecting {expected_status})' )
async def parse_api_response(resp: ClientResponse): """ Checks for response status, parses the json and checks for API error """ resp.raise_for_status() resp = json.loads(await resp.text()) if "error" in resp: raise APIError(resp["error"]) return resp
def _raise_error_from_response( self, resp: aiohttp.ClientResponse, ) -> None: if resp.status in [401, 403]: abort(403, "request rejected by backend") if resp.status == 400: abort(500, "request rejected by backend") if not 200 <= resp.status < 300: resp.raise_for_status()
def raise_for_status( resp: aiohttp.ClientResponse) -> aiohttp.ClientResponse: """Raise exceptions on failure methods.""" try: resp.raise_for_status() except ClientResponseError as err: if err.status == HTTP_UNAUTHORIZED: raise AuthException( f"Unable to authenticate with API: {err}") from err raise ApiException(f"Error from API: {err}") from err except ClientError as err: raise ApiException(f"Error from API: {err}") from err return resp
async def check_error(resp: ClientResponse) -> Any: try: resp_data = await resp.json() except ContentTypeError: resp.raise_for_status() return except json.JSONDecodeError: resp.raise_for_status() raise if not isinstance(resp_data, dict) or "errors" not in resp_data: resp.raise_for_status() return resp_data try: error = resp_data["errors"][0] code = error["code"] message = error["message"] except (KeyError, IndexError): resp.raise_for_status() raise if code == 88: raise RateLimitError(code, message, resp.headers) elif code == 32: raise TwitterAuthError(code, message) raise TwitterError(code, message)
async def raise_for_status(response: ClientResponse): if response.ok: return response try: result = await response.json() message = result["message"] detail = result["detail"] message = f"{message}: {detail}" except Exception: message = await response.text() or response.reason log.exception(message) else: log.error(message) response.raise_for_status()
async def raise_for_status(response: ClientResponse): if response.ok: return response try: result = await response.json() except Exception: message = response.reason log.exception(message) else: message = result["message"] detail = result.get("detail") message = f"{message}" + f": {detail}" if detail else "" log.error(message) response.raise_for_status()
async def raise_response_error(resp: aiohttp.ClientResponse, reason: str): # We raise a TransportServerError if the status code is 400 or higher # We raise a TransportProtocolError in the other cases try: # Raise a ClientResponseError if response status is 400 or higher resp.raise_for_status() except ClientResponseError as e: raise TransportServerError(str(e), e.status) from e result_text = await resp.text() raise TransportProtocolError( f"Server did not return a GraphQL result: " f"{reason}: " f"{result_text}")
async def wrap_and_raise_for_error(response: aiohttp.ClientResponse, body: Any = None) -> None: """Check if the response failed with a non-2XX status code. If the response has a non-2XX error code, wrap it in the appropriate client exception and re-raise. Otherwise, do nothing. Args: response: The response to check for a non-OK status. body: The data which provides context for the error. If this is not specified, the function will attempt to load it from response.text(), and fall back to response.reason. Note that this behavior is undesirable in some cases, such as for handling streamed responses, as calling response.text() will prevent the content from being loaded correctly. In such cases, a non-None body must be provided. Raises: SynseError: The response had a non-2XX error code. """ if body is None: try: body = await response.text() except Exception as e: log.info('unable to get response text: {}'.format(e)) body = response.reason try: response.raise_for_status() except aiohttp.ClientResponseError as e: log.error( f'request to {response.url} responded with {response.status}: {e}') error_cls = code_to_err.get(response.status) if error_cls is not None: try: data = json.loads(body) except Exception as e: log.error(f'failed to parse response JSON: {e}') raise error_cls(f'error: {body}') from e else: raise error_cls(data.get('context')) from e raise SynseError from e
async def check_response(response: aiohttp.ClientResponse, ) -> None: """ Check for specialised K8s errors, and raise with extended information. Built-in aiohttp's errors only provide the rudimentary titles of the status codes, but not the explanation why that error happened. K8s API provides this information in the bodies of non-2xx responses. That information can replace aiohttp's error messages to be more helpful. However, the same error classes are used for now, to meet the expectations if some routines in their ``except:`` clauses analysing for specific HTTP statuses: e.g. 401 for re-login activities, 404 for patching/deletion, etc. """ if response.status >= 400: try: payload = await response.json() except (json.JSONDecodeError, aiohttp.ContentTypeError, aiohttp.ClientConnectionError): payload = None # Better be safe: who knows which sensitive information can be dumped unless kind==Status. if not isinstance( payload, collections.abc.Mapping) or payload.get('kind') != 'Status': payload = None # If no information can be retrieved, fall back to the original error. if payload is None: response.raise_for_status() else: details = payload.get('details') message = payload.get('message') or f"{details}" raise APIClientResponseError(response.request_info, response.history, status=response.status, headers=response.headers, message=message)
def raise_for_status(result: ClientResponse): result.raise_for_status()
async def default_on_finish(resp: ClientResponse): resp.raise_for_status() return await resp.text()
async def __get_json_or_raise_for_status(response: ClientResponse): try: return await response.json() except ContentTypeError as e: # if no json available in response then use raise_for_status() to raise exception response.raise_for_status()
def raise_for_status(result: ClientResponse): # 400 Bad Request status is used by Bitfinex to indicate wrong ticker if result.status > 400: result.raise_for_status()
async def __handle(self, resp: ClientResponse) -> dict: resp.raise_for_status() return await resp.json()