def update_request_with_deps(request_id, deps):
"""
Update the Cachito request with the resolved dependencies.
:param int request_id: the ID of the Cachito request
:param list deps: the list of dependency dictionaries to record
:raise CachitoError: if the request to the Cachito API fails
"""
# Import this here to avoid a circular import
from cachito.workers.requests import requests_auth_session
config = get_worker_config()
request_url = f'{config.cachito_api_url.rstrip("/")}/requests/{request_id}'
log.info('Adding %d dependencies to request %d', len(deps), request_id)
payload = {'dependencies': deps}
try:
rv = requests_auth_session.patch(request_url, json=payload, timeout=30)
except requests.RequestException:
msg = f'The connection failed when setting the dependencies on request {request_id}'
log.exception(msg)
raise CachitoError(msg)
if not rv.ok:
log.error(
'The worker failed to set the dependencies on request %d. The status was %d. '
'The text was:\n%s',
request_id, rv.status_code, rv.text,
)
raise CachitoError(f'Setting the dependencies on request {request_id} failed')
def set_request_state(request_id, state, state_reason):
"""
Set the state of the request using the Cachito API.
:param int request_id: the ID of the Cachito request
:param str state: the state to set the Cachito request to
:param str state_reason: the state reason to set the Cachito request to
:raise CachitoError: if the request to the Cachito API fails
"""
# Import this here to avoid a circular import
from cachito.workers.requests import requests_auth_session
config = get_worker_config()
request_url = f'{config.cachito_api_url.rstrip("/")}/requests/{request_id}'
log.info(
'Setting the state of request %d to "%s" with the reason "%s"',
request_id, state, state_reason
)
payload = {'state': state, 'state_reason': state_reason}
try:
rv = requests_auth_session.patch(
request_url, json=payload, timeout=config.cachito_api_timeout)
except requests.RequestException:
msg = f'The connection failed when setting the state to "{state}" on request {request_id}'
log.exception(msg)
raise CachitoError(msg)
if not rv.ok:
log.error(
'The worker failed to set request %d to the "%s" state. The status was %d. '
'The text was:\n%s',
request_id, state, rv.status_code, rv.text,
)
raise CachitoError(f'Setting the state to "{state}" on request {request_id} failed')
def update_request_with_deps(request_id,
deps,
env_vars=None,
pkg_manager=None,
packages=None):
"""
Update the Cachito request with the resolved dependencies.
:param int request_id: the ID of the Cachito request
:param list deps: the list of dependency dictionaries to record
:param dict env_vars: mapping of environment variables to record
:param str pkg_manager: a package manager to add to the request if auto-detection was used
:param list packages: the list of packages that were resolved
:raise CachitoError: if the request to the Cachito API fails
"""
# Import this here to avoid a circular import
from cachito.workers.requests import requests_auth_session
config = get_worker_config()
request_url = f'{config.cachito_api_url.rstrip("/")}/requests/{request_id}'
log.info('Adding %d dependencies to request %d', len(deps), request_id)
for index in range(0, len(deps), config.cachito_deps_patch_batch_size):
batch_upper_limit = index + config.cachito_deps_patch_batch_size
payload = {'dependencies': deps[index:batch_upper_limit]}
if index == 0:
if env_vars:
log.info('Adding environment variables to the request %d: %s',
request_id, env_vars)
payload['environment_variables'] = env_vars
if pkg_manager:
log.info(
'Adding the package manager "%s" to the request %d',
pkg_manager,
request_id,
)
payload['pkg_managers'] = [pkg_manager]
if packages:
log.info('Adding the packages "%s" to the request %d',
packages, request_id)
payload['packages'] = packages
try:
log.info('Patching deps {} through {} out of {}'.format(
index + 1, min(batch_upper_limit, len(deps)), len(deps)))
rv = requests_auth_session.patch(
request_url, json=payload, timeout=config.cachito_api_timeout)
except requests.RequestException:
msg = f'The connection failed when setting the dependencies on request {request_id}'
log.exception(msg)
raise CachitoError(msg)
if not rv.ok:
log.error(
'The worker failed to set the dependencies on request %d. The status was %d. '
'The text was:\n%s',
request_id,
rv.status_code,
rv.text,
)
raise CachitoError(
f'Setting the dependencies on request {request_id} failed')
def update_request_env_vars(request_id: int,
env_vars: Dict[str, Dict[str, str]]) -> None:
"""Update environment variables of a request.
:param int request_id: the id of a request to update the environment variables.
:param dict env_vars: mapping of environment variables to record. The keys represent
the environment variable name, and its value should be another map with the "value" and
"kind" attributes, e.g. {"NAME": {"value": "VALUE", "kind": "KIND"}}.
:raise CachitoError: if the request to the Cachito API fails
"""
config = get_worker_config()
request_url = _get_request_url(request_id)
payload = {"environment_variables": env_vars}
try:
rv = requests_auth_session.patch(request_url,
json=payload,
timeout=config.cachito_api_timeout)
except requests.RequestException:
msg = (
f"The connection failed when updating environment variables on the request {request_id}"
)
log.exception(msg)
raise CachitoError(msg)
if not rv.ok:
log.error(
"The worker failed to update environment variables on the request %d. "
"The status was %d. The text was:\n%s",
request_id,
rv.status_code,
rv.text,
)
raise CachitoError(
f"Updating environment variables on request {request_id} failed")
def _patch_request_or_fail(request_id: int, payload: dict,
connect_error_msg: str,
status_error_msg: str) -> None:
"""
Try to update the specified request using the Cachito PATCH API.
Both error messages can contain the {exc} placeholder which will be replaced by the actual
exception.
:param request_id: ID of the request to get
:param payload: the JSON data to send to the PATCH endpoint
:param connect_error_msg: error message to raise if the connection fails
:param status_error_msg: error message to raise if the response status is 4xx or 5xx
:raises CachitoError: if the connection fails or the API returns an error response
"""
config = get_worker_config()
request_url = f'{config.cachito_api_url.rstrip("/")}/requests/{request_id}'
try:
rv = requests_auth_session.patch(request_url,
json=payload,
timeout=config.cachito_api_timeout)
rv.raise_for_status()
except requests.HTTPError as e:
msg = status_error_msg.format(exc=e)
log.exception(msg)
raise CachitoError(msg)
except requests.RequestException as e:
msg = connect_error_msg.format(exc=e)
log.exception(msg)
raise CachitoError(msg)
def update_request_with_package(request_id, package, env_vars=None, package_subpath=None):
"""
Update the request with the resolved packages and corresponding metadata.
:param dict package: the package that was resolved
:param dict env_vars: mapping of environment variables to record. The keys represent
the environment variable name, and its value should be another map wth the "value" and
"kind" attributes, e.g. {"NAME": {"value": "VALUE", "kind": "KIND"}}.
:param str package_subpath: relative path from root of repository to package directory
:raise CachitoError: if the request to the Cachito API fails
"""
log.info('Adding the package "%r" to the request %d', package, request_id)
payload = {"package": package}
if env_vars:
log.info("Also adding environment variables to the request %d: %s", request_id, env_vars)
payload["environment_variables"] = env_vars
if package_subpath and package_subpath != os.curdir:
log.info("Also setting a subpath for the package %r: %r", package["name"], package_subpath)
payload["package_subpath"] = package_subpath
# Import this here to avoid a circular import
from cachito.workers.requests import requests_auth_session
config = get_worker_config()
request_url = _get_request_url(request_id)
try:
rv = requests_auth_session.patch(
request_url, json=payload, timeout=config.cachito_api_timeout
)
except requests.RequestException:
msg = f"The connection failed when adding a package to the request {request_id}"
log.exception(msg)
raise CachitoError(msg)
if not rv.ok:
log.error(
"The worker failed to add a package to the request %d. The status was %d. "
"The text was:\n%s",
request_id,
rv.status_code,
rv.text,
)
raise CachitoError(f"Setting a package on request {request_id} failed")
def update_request_with_deps(request_id, package, deps):
"""
Update the Cachito request with the resolved dependencies.
:param int request_id: the ID of the Cachito request
:param dict package: the package these dependencies are associated with
:param list deps: the list of dependency dictionaries to record
:raise CachitoError: if the request to the Cachito API fails
"""
# Import this here to avoid a circular import
from cachito.workers.requests import requests_auth_session
config = get_worker_config()
request_url = _get_request_url(request_id)
log.info("Adding %d dependencies to request %d", len(deps), request_id)
for index in range(0, len(deps), config.cachito_deps_patch_batch_size):
batch_upper_limit = index + config.cachito_deps_patch_batch_size
payload = {"dependencies": deps[index:batch_upper_limit], "package": package}
try:
log.info(
"Patching deps {} through {} out of {}".format(
index + 1, min(batch_upper_limit, len(deps)), len(deps)
)
)
rv = requests_auth_session.patch(
request_url, json=payload, timeout=config.cachito_api_timeout
)
except requests.RequestException:
msg = f"The connection failed when setting the dependencies on request {request_id}"
log.exception(msg)
raise CachitoError(msg)
if not rv.ok:
log.error(
"The worker failed to set the dependencies on request %d. The status was %d. "
"The text was:\n%s",
request_id,
rv.status_code,
rv.text,
)
raise CachitoError(f"Setting the dependencies on request {request_id} failed")
