async def authdb_start() -> None:
"""Initialize database connection."""
log.debug("Opening database connection")
await Tortoise.init(
db_url=f"sqlite:///{str(params.api.dbmain_path)}",
modules={"models": ["stats.auth.models"]},
)
await Tortoise.generate_schemas()
async def authenticate_user(username: str, password: str) -> bool:
"""Authenticate a user."""
user = await get_user(username)
valid = argon2.verify(password, user.password)
if valid:
log.debug("Authentication succeeded for user {}", username)
if not valid:
log.error("Authentication failed for user {}", username)
return valid
async def job_status(
job_id: int,
x_48ix_api_user: Optional[str] = Header(None),
x_48ix_api_key: Optional[str] = Header(None),
):
"""Get the status of a job by ID."""
await _verify_auth(x_48ix_api_user, x_48ix_api_key, "/job/*")
job = await get_job(job_id)
await job.fetch_related("requestor")
response = UpdatePolicyResponse(
id=job.id,
request_time=job.request_time,
complete_time=job.complete_time,
requestor=job.requestor.username,
detail=job.detail,
in_progress=job.in_progress,
)
log.debug("Job {} status: {}", job.id, response)
return response.dict()
async def authorize_route(username: str, route: str) -> bool:
"""Verify if a user has access to an API route."""
is_authorized = False
try:
user = await get_user(username)
await user.fetch_related("routes")
async for user_route in user.routes:
if route == user_route.name:
is_authorized = True
break
except DoesNotExist:
raise AuthError("User '{u}' does not exist.",
u=username,
status_code=401) from None
if is_authorized:
log.debug("{} is authorized to access {}", username, route)
if not is_authorized:
log.error("{} is not authorized to access {}", username, route)
return is_authorized
async def port_utilization(
port_id: str,
period: int = None,
start: str = None,
end: str = None,
):
"""Get utilization statistics for a port."""
if start is not None:
data_in = await port_utilization_range(
port_id=port_id,
direction="in",
start=start,
end=end,
limit=params.api.default_limit,
)
data_out = await port_utilization_range(
port_id=port_id,
direction="out",
start=start,
end=end,
limit=params.api.default_limit,
)
avg_in = await port_average_range(
port_id=port_id,
direction="in",
start=start,
end=end,
limit=params.api.default_limit,
)
avg_out = await port_average_range(
port_id=port_id,
direction="out",
start=start,
end=end,
limit=params.api.default_limit,
)
else:
period = period or params.api.default_period
data_in = await port_utilization_period(
port_id=port_id,
direction="in",
period=period,
limit=params.api.default_limit,
)
data_out = await port_utilization_period(
port_id=port_id,
direction="out",
period=period,
limit=params.api.default_limit,
)
avg_in = await port_average_period(
port_id=port_id,
direction="in",
period=period,
limit=params.api.default_limit,
)
avg_out = await port_average_period(
port_id=port_id,
direction="out",
period=period,
limit=params.api.default_limit,
)
location, participant_id, _ = parse_port_id(port_id)
response = {
"ingress": data_in.get("values", [[]]),
"egress": data_out.get("values", [[]]),
"participant_id": participant_id,
"location": location,
"port_id": port_id,
"ingress_average": avg_in.get("values", [["", 0]])[0][1],
"egress_average": avg_out.get("values", [["", 0]])[0][1],
}
log.debug("Response for query: {}", response)
return response
async def authdb_stop() -> None:
"""Close database connection."""
log.debug("Closing database connection")
await Tortoise.close_connections()