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}")
