Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion pyproject.toml
Original file line number Diff line number Diff line change
Expand Up @@ -31,6 +31,7 @@ dependencies = [
"websockets",
"tqdm",
"packaging",
"authlib>=1.9.6",
]
dynamic = ["version"]
license.file = "LICENSE"
Expand Down Expand Up @@ -82,7 +83,6 @@ dev = [
"mock",
"jwcrypto",
"deepdiff",
"respx",
"pytest-xdist[psutil]",
"httpx2>=2.5.0",
"playwright>=1.63.0",
Expand Down
96 changes: 52 additions & 44 deletions src/blueapi/client/session.py
Original file line number Diff line number Diff line change
Expand Up @@ -5,13 +5,15 @@
import time
import webbrowser
from abc import ABC, abstractmethod
from collections.abc import Mapping
from functools import cached_property
from http import HTTPStatus
from pathlib import Path
from typing import Any, cast

import jwt
import requests
from authlib.integrations.requests_client import OAuth2Session, OAuthError
from authlib.oauth2.rfc8628 import DEVICE_CODE_GRANT_TYPE
from pydantic import TypeAdapter
from requests.auth import AuthBase

Expand Down Expand Up @@ -154,47 +156,62 @@ def logout(self) -> None:
f"to log out from the server.{e}"
)

def _refresh_auth_token(self, refresh_token: str) -> str:
response = requests.post(
self._server_config.token_endpoint,
data={
"client_id": self._server_config.client_id,
"grant_type": "refresh_token",
"refresh_token": refresh_token,
},
headers={"Content-Type": "application/x-www-form-urlencoded"},
@cached_property
def _oauth_session(self) -> OAuth2Session:
# One pooled session per manager rather than a leaked one per call.
# Public client: client_id goes in the body, no client secret
return OAuth2Session(
self._server_config.client_id, token_endpoint_auth_method="none"
)

def _save_token(self, token: Mapping[str, Any]) -> None:
self._cache_manager.save_cache(
Cache(
oidc_config=self._server_config,
refresh_token=token["refresh_token"],
id_token=token["id_token"],
access_token=token["access_token"],
)
)
if response.status_code == HTTPStatus.OK:
token = response.json()
self._cache_manager.save_cache(
Cache(
oidc_config=self._server_config,
refresh_token=token["refresh_token"],
id_token=token["id_token"],
access_token=token["access_token"],
),

def _refresh_auth_token(self, refresh_token: str) -> str:
try:
token = self._oauth_session.refresh_token(
self._server_config.token_endpoint, refresh_token=refresh_token
)
return token["access_token"]
else:
except (OAuthError, requests.HTTPError) as e:
# Network and 5xx errors propagate so a temporary outage does not
# throw away a still-valid refresh token; a 4xx means it was rejected
response = getattr(e, "response", None)
if response is not None and response.status_code >= 500:
raise
self.delete_cache()
return ""
self._save_token(token)
return token["access_token"]

def poll_for_token(
self, device_code: str, polling_interval: float, expires_in: float
) -> dict[str, Any]:
expiry_time: float = time.time() + expires_in
while time.time() < expiry_time:
response = requests.post(
self._server_config.token_endpoint,
data={
"grant_type": "urn:ietf:params:oauth:grant-type:device_code",
"device_code": device_code,
"client_id": self._server_config.client_id,
},
headers={"Content-Type": "application/x-www-form-urlencoded"},
)
if response.status_code == HTTPStatus.OK:
return response.json()
try:
return dict(
self._oauth_session.fetch_token(
self._server_config.token_endpoint,
grant_type=DEVICE_CODE_GRANT_TYPE,
device_code=device_code,
)
)
except OAuthError as e:
# RFC 8628 3.5: keep polling while pending, back off on slow_down
if e.error == "slow_down":
polling_interval += 5
elif e.error != "authorization_pending":
raise
except (requests.HTTPError, ValueError):
# 5xx or non-JSON (e.g. gateway 429 page): transient, keep polling
pass
time.sleep(polling_interval)

raise TimeoutError("Polling timed out")
Expand All @@ -215,23 +232,14 @@ def start_device_flow(self):

response_json: dict[str, Any] = response.json()
device_code = cast(str, response_json.get("device_code"))
interval = cast(float, response_json.get("interval"))
# RFC 8628 3.2: interval is optional, default 5 seconds
interval = float(response_json.get("interval", 5))
expires_in = cast(float, response_json.get("expires_in"))
webbrowser.open_new_tab(response_json["verification_uri_complete"])
print(
f"Please login from this URL:- {response_json['verification_uri_complete']}"
)
auth_token_json: dict[str, Any] = self.poll_for_token(
device_code, interval, expires_in
)
self._cache_manager.save_cache(
Cache(
oidc_config=self._server_config,
refresh_token=auth_token_json["refresh_token"],
id_token=auth_token_json["id_token"],
access_token=auth_token_json["access_token"],
)
)
self._save_token(self.poll_for_token(device_code, interval, expires_in))
print("Logged in and cached new token")


Expand Down
44 changes: 30 additions & 14 deletions src/blueapi/service/authentication.py
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@

import httpx
import jwt
from authlib.integrations.requests_client import OAuth2Session
from fastapi import Depends, HTTPException
from fastapi.requests import HTTPConnection
from fastapi.security.utils import get_authorization_scheme_param
Expand All @@ -25,25 +26,40 @@ class TiledAuth(httpx.Auth):
def __init__(self, tiled_auth: ServiceAccount):
if tiled_auth.token_url == "":
raise RuntimeError("Token URL is not set please check oidc config")
self._tiled_auth: ServiceAccount = tiled_auth
self._client = OAuth2Session(
tiled_auth.client_id,
tiled_auth.client_secret.get_secret_value(),
token_endpoint=tiled_auth.token_url,
token_endpoint_auth_method="client_secret_post",
grant_type="client_credentials",
)
self._sync_lock = threading.RLock()

def get_access_token(self):
requires_request_body = True # body is replayed on the 401 retry

def get_access_token(self, stale: str | None = None) -> str:
"""Cached client_credentials token, re-fetched when expired or rejected"""
with self._sync_lock:
response = httpx.post(
self._tiled_auth.token_url,
data={
"client_id": self._tiled_auth.client_id,
"client_secret": self._tiled_auth.client_secret.get_secret_value(),
"grant_type": "client_credentials",
},
)
response.raise_for_status()
return response.json().get("access_token")
token = self._client.token
if (
not token
or token["access_token"] == stale
# is_expired() is None when the IdP sends no expiry: don't cache
or token.is_expired(leeway=self._client.leeway) is not False
):
token = self._client.fetch_token()
return token["access_token"]

def sync_auth_flow(self, request):
request.headers["Authorization"] = f"Bearer {self.get_access_token()}"
yield request
access_token = self.get_access_token()
request.headers["Authorization"] = f"Bearer {access_token}"
response = yield request
if response.status_code == HTTP_401_UNAUTHORIZED:
# Revoked or keys rotated before expiry: fetch a new token, retry once.
# stale= stops concurrent 401s each fetching their own replacement.
new_token = self.get_access_token(stale=access_token)
request.headers["Authorization"] = f"Bearer {new_token}"
yield request


def unchecked_bearer_token(req: HTTPConnection) -> str | None:
Expand Down
81 changes: 80 additions & 1 deletion tests/unit_tests/client/test_session.py
Original file line number Diff line number Diff line change
Expand Up @@ -4,8 +4,14 @@
from unittest.mock import patch

import pytest
import requests
import responses
from starlette.status import HTTP_403_FORBIDDEN
from authlib.integrations.requests_client import OAuthError
from starlette.status import (
HTTP_400_BAD_REQUEST,
HTTP_403_FORBIDDEN,
HTTP_503_SERVICE_UNAVAILABLE,
)

from blueapi.client.session import SessionCacheManager, SessionManager
from blueapi.config import OIDCConfig
Expand Down Expand Up @@ -112,6 +118,79 @@ def test_poll_for_token_timeout(
session_manager.poll_for_token(device_code, 0.01, 0.01)


def _token_endpoint_replies(
mock_authn_server: responses.RequestsMock, url: str, *replies: dict[str, Any]
) -> None:
"""Replace the token endpoint with replies served in order"""
mock_authn_server.stop()
mock_authn_server.remove(responses.POST, url)
for reply in replies:
mock_authn_server.post(url=url, **reply)


@patch("blueapi.client.session.time.sleep", return_value=None)
@pytest.mark.parametrize(
"first_reply,expected_sleep",
[
({"json": {"error": "slow_down"}, "status": HTTP_400_BAD_REQUEST}, 6),
({"body": "Service Unavailable", "status": HTTP_503_SERVICE_UNAVAILABLE}, 1),
({"body": "<html>rate limited</html>", "status": 429}, 1),
],
)
def test_poll_for_token_keeps_polling_after_retryable_reply(
mock_sleep,
first_reply: dict[str, Any],
expected_sleep: float,
oidc_well_known: dict[str, Any],
mock_authn_server: responses.RequestsMock,
session_manager: SessionManager,
valid_token: dict[str, Any],
device_code: str,
):
_token_endpoint_replies(
mock_authn_server,
oidc_well_known["token_endpoint"],
first_reply,
{"json": valid_token},
)
with mock_authn_server:
assert session_manager.poll_for_token(device_code, 1, 60) == valid_token
mock_sleep.assert_called_once_with(expected_sleep)


@pytest.mark.parametrize("error", ["access_denied", "expired_token"])
def test_poll_for_token_raises_on_terminal_error(
error: str,
oidc_well_known: dict[str, Any],
mock_authn_server: responses.RequestsMock,
session_manager: SessionManager,
device_code: str,
):
_token_endpoint_replies(
mock_authn_server,
oidc_well_known["token_endpoint"],
{"json": {"error": error}, "status": HTTP_400_BAD_REQUEST},
)
with pytest.raises(OAuthError, match=error), mock_authn_server:
session_manager.poll_for_token(device_code, 1, 60)


def test_refresh_network_error_keeps_cache(
oidc_well_known: dict[str, Any],
mock_authn_server: responses.RequestsMock,
session_manager: SessionManager,
cached_valid_refresh: Path,
):
_token_endpoint_replies(
mock_authn_server,
oidc_well_known["token_endpoint"],
{"body": requests.ConnectionError("unreachable")},
)
with pytest.raises(requests.ConnectionError), mock_authn_server:
session_manager.get_valid_access_token()
assert cached_valid_refresh.exists()


def test_session_cache_manager_returns_writable_file_path(tmp_path):
os.environ["XDG_CACHE_HOME"] = str(tmp_path)
cache = SessionCacheManager(token_path=None)
Expand Down
Loading
Loading