def check_response(response: Response): if response.is_error: try: debug(response.json()) except JSONDecodeError: pass response.raise_for_status()
def __check_not_found(self, path: Url, response: httpx.Response) -> None: try: response.raise_for_status() except httpx.HTTPStatusError as e: if e.response.status_code in {403, 404}: raise DownloadNotFoundError(path) from e raise
def response_handler(r: httpx.Response) -> dict: try: r.raise_for_status() except httpx.HTTPStatusError as e: detail = r.json().get("detail", None) cause = "\n".join((detail, str(e))) if detail else str(e) raise Exception(cause).with_traceback(e.__traceback__) return r.json()
def _done(_item, _res: Response): _key, _fields = _item _res.raise_for_status() ident = ( f"ipaddr {_fields['hostname']}, {_fields['interface']}, {_fields['ipaddr']}" ) print( f"CREATE:OK: {ident}", flush=True, )
def raise_errors(self, resp: httpx.Response, hint: Any) -> None: """ By default, raise errors if HTTP statuses are error status but you could do any kind of inspection you want here. The hint is there in case you need different mechanisms for different paths, the hint is provided through the decorator. """ resp.raise_for_status()
def _parse_response(self, response: Response) -> Any: try: response.raise_for_status() except httpx.HTTPStatusError as error: body = error.response.json() code = body.get("code") if code and is_api_error_code(code): raise APIResponseError(response, body["message"], code) raise HTTPResponseError(error.response) body = response.json() self.logger.debug(f"=> {body}") return body
def handle_resp(self, resp: Response, json: bool = True, read: bool = True ) -> Union[bool, bytes, dict, None]: """Handles resp response. Parameters ---------- resp : Response json : bool, optional by default True read : bool, optional by default True """ if resp.status_code == 200: if json: return resp.json() elif read: return resp.read() else: return True else: try: message = resp.json() except JSONDecodeError: message = None else: logging.error(message) if resp.status_code == 404: raise NotFound(message) elif resp.status_code == 400: raise BadRequest(message) elif resp.status_code == 507: raise ExceededStorage(message) elif resp.status_code == 500: raise ServerStart(message) else: resp.raise_for_status()
def _do_raise_for_status(self, response: httpx.Response) -> None: try: response.raise_for_status() except httpx.HTTPError as error: content: ty.List[object] = [] try: decoder: encoding.Json = encoding.get_encoding("json") for chunk in response.iter_bytes(): content += list(decoder.parse_partial(chunk)) content += list(decoder.parse_finalize()) except exceptions.DecodingError: pass # If we have decoded an error response from the server, # use that as the exception message; otherwise, just pass # the exception on to the caller. if len(content) == 1 \ and isinstance(content[0], dict) \ and "Message" in content[0]: msg: str = content[0]["Message"] raise exceptions.ErrorResponse(msg, error) from error else: raise exceptions.StatusError(error) from error
def _done(_item, res: Response): _key, _changes = _item _hostname, _ifname = _key res.raise_for_status() log.info(f"UPDATE:OK: ipaddr {_hostname}, {_ifname}")
def _done(_item, _res: Response): _key, _fields = _item _res.raise_for_status() ident = f"ipaddr {_fields['hostname']}, {_fields['interface']}, {_fields['ipaddr']}" log.info(f"CREATE:OK: {ident}")
def _done(_item, res: Response): _key, _changes = _item _hostname, _ifname = _key res.raise_for_status() print(f"UPDATE:OK: ipaddr {_hostname}, {_ifname}", flush=True)
async def _die_on_bad_status(response: Response): response.raise_for_status()
def _handle_declaration_response(self, setting: Setting, response: Response): """ Inner utility method to handle a setting declaration response Args: setting: the setting declared response: the http response from the service """ if response.status_code == 409: # we have encountered an upgrade conflict. We report it and attempt to cope logger.error('conflict when declaring setting', extra={ 'setting_name': setting.name, 'response_content': response.content }) elif response.is_error: logger.error('error when declaring setting', extra={ 'setting_name': setting.name, 'response_content': response.content }) response.raise_for_status() try: response_data = response.json() except ValueError: # if the content is not json, it's probably an error response, do nothing (we already reported error # responses) if response.is_success: logger.warning('unexpected response from service', extra={'response_content': response.content}) return outcome = response_data.get('outcome') if outcome == 'outdated': latest_version_str = response_data.get('latest_version') if latest_version_str is None: logger.error('outdated setting without latest version', extra={'setting_name': setting.name}) latest_version: Tuple[int, int] = (float('inf'), float('inf') ) # type: ignore[assignment] else: latest_version = tuple( map(int, latest_version_str.split( '.', 1))) # type: ignore[assignment] if latest_version[0] != setting.version[0]: logger.warning('setting is outdated by a major version', extra={ 'setting_name': setting.name, 'differences': response_data.get('differences'), 'latest_version': latest_version_str, 'current_version': setting.version_str }) else: logger.info('setting is outdated', extra={ 'setting_name': setting.name, 'differences': response_data.get('differences'), 'latest_version': latest_version_str, 'declared_version': setting.version_str }) for difference in response_data.get('differences', ()): apply_difference(setting, difference) elif outcome in ('created', 'uptodate', 'upgraded', 'mismatch', 'outofdate', 'rejected'): # no special behaviour for these cases pass else: logger.warning('unexpected outcome from service', extra={ 'setting_name': setting.name, 'outcome': outcome }) self._tracked_settings[setting.name] = setting
def _done(_item, _res: Response): _key, _ch_fields = _item _fields = nb_col.inventory[_key] _hostname, _ifname = fields_fn(_fields) _res.raise_for_status() print(f"CHANGE:OK: interface {_hostname}, {_ifname}", flush=True)
def _done(change, res: Response): # res: Response = task.result() _hostname, _ifname = fields_fn(change.fingerprint) res.raise_for_status() print(f"CHANGE:OK: interface {_hostname}, {_ifname}", flush=True)
def _done(_item, res: Response): _key, _fields = _item _hostname, _ipaddr = fields_fn(_fields) res.raise_for_status() log.info(f"DELETE:OK: ipaddr {_hostname}, {_ipaddr}")
def raise_for_status(response: Response) -> None: try: response.raise_for_status() except HTTPStatusError as e: raise HTTPException(detail=str(e), status_code=response.status_code)
def _done(item, _res: Response): # _res: Response = task.result() _res.raise_for_status() _hostname, _if_name = fields_fn(item) print(f"CREATE:OK: interface {_hostname}, {_if_name}", flush=True)
def _done(item, _res: Response): _res.raise_for_status() print( f"CREATE:OK: ipaddr {item['hostname']}, {item['interface']}, {item['ipaddr']}", flush=True, )
def _done(_item, _res: Response): _key, _fields = _item _res.raise_for_status() _hostname, _if_name = fields_fn(_fields) print(f"CREATE:OK: interface {_hostname}, {_if_name}", flush=True)
def _done(_key, res: Response): # res: Response = _task.result() _hostname, _ifname = _key res.raise_for_status() print(f"UPDATE:OK: ipaddr {_hostname}, {_ifname}", flush=True)
async def raise_on_4xx_5xx(response: httpx.Response) -> None: if 400 <= response.status_code <= 599: response.raise_for_status()
def _done(_item, _res: Response): _key, _ch_fields = _item _fields = nb_col.items[_key] _hostname, _ifname = fields_fn(_fields) _res.raise_for_status() log.info(f"DELETE:OK: interface {_hostname}, {_ifname}")