From e890eb463f9212b42e2eb1419d45bd97ae26104d Mon Sep 17 00:00:00 2001 From: Zoheb Shaikh <26975142+ZohebShaikh@users.noreply.github.com> Date: Sat, 14 Nov 2026 23:12:57 +0000 Subject: [PATCH] refactor: use authlib for oauth2 --- pyproject.toml | 2 +- src/blueapi/client/session.py | 96 ++++++++++--------- src/blueapi/service/authentication.py | 44 ++++++--- tests/unit_tests/client/test_session.py | 81 +++++++++++++++- .../unit_tests/service/test_authentication.py | 71 ++++++++++++-- uv.lock | 41 +++++--- 6 files changed, 253 insertions(+), 82 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index fe2f73838..4f509dae9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -31,6 +31,7 @@ dependencies = [ "websockets", "tqdm", "packaging", + "authlib>=1.9.6", ] dynamic = ["version"] license.file = "LICENSE" @@ -82,7 +83,6 @@ dev = [ "mock", "jwcrypto", "deepdiff", - "respx", "pytest-xdist[psutil]", "httpx2>=2.5.0", "playwright>=1.63.0", diff --git a/src/blueapi/client/session.py b/src/blueapi/client/session.py index 07ca6a7ae..25f8a77fb 100644 --- a/src/blueapi/client/session.py +++ b/src/blueapi/client/session.py @@ -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 @@ -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") @@ -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") diff --git a/src/blueapi/service/authentication.py b/src/blueapi/service/authentication.py index 57e357c6f..b5519bf20 100644 --- a/src/blueapi/service/authentication.py +++ b/src/blueapi/service/authentication.py @@ -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 @@ -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: diff --git a/tests/unit_tests/client/test_session.py b/tests/unit_tests/client/test_session.py index f54334fdc..ea05db26b 100644 --- a/tests/unit_tests/client/test_session.py +++ b/tests/unit_tests/client/test_session.py @@ -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 @@ -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": "rate limited", "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) diff --git a/tests/unit_tests/service/test_authentication.py b/tests/unit_tests/service/test_authentication.py index 9e117b92f..8d6bf7202 100644 --- a/tests/unit_tests/service/test_authentication.py +++ b/tests/unit_tests/service/test_authentication.py @@ -1,13 +1,12 @@ +from typing import Any from unittest.mock import Mock, patch -import httpx import jwt import pytest import responses -import respx from fastapi import HTTPException from pydantic import SecretStr -from starlette.status import HTTP_200_OK +from starlette.status import HTTP_200_OK, HTTP_401_UNAUTHORIZED from blueapi import service from blueapi.client.session import SessionManager @@ -102,17 +101,26 @@ def test_tiled_auth_raises_exception(): TiledAuth(tiled_auth=auth) -@respx.mock +@responses.activate def test_tiled_auth_sync_auth_flow(): client_id = "client" client_secret = SecretStr("secret") token_url = "http://keycloak.com/token" access_token = "access_token" - respx.post(token_url).mock( - return_value=httpx.Response( - status_code=HTTP_200_OK, json={"access_token": access_token} - ) + token_request = responses.post( + token_url, + json={"access_token": access_token, "expires_in": 300}, + status=HTTP_200_OK, + match=[ + responses.matchers.urlencoded_params_matcher( + { + "grant_type": "client_credentials", + "client_id": client_id, + "client_secret": client_secret.get_secret_value(), + } + ) + ], ) tiled_auth = TiledAuth( @@ -130,3 +138,50 @@ def test_tiled_auth_sync_auth_flow(): result = next(flow) assert result.headers["Authorization"] == f"Bearer {access_token}" + + # Token is cached until it expires rather than fetched per request + next(tiled_auth.sync_auth_flow(request)) + assert token_request.call_count == 1 + + +def _tiled_auth(token_url: str) -> TiledAuth: + return TiledAuth( + tiled_auth=ServiceAccount( + client_id="client", client_secret=SecretStr("secret"), token_url=token_url + ) + ) + + +@responses.activate +@pytest.mark.parametrize( + "token_reply", + [ + {"access_token": "token", "expires_in": 30}, # inside the 60s leeway + {"access_token": "token"}, # no expiry given: never cache + ], +) +def test_tiled_auth_refetches_expired_or_undated_token(token_reply: dict[str, Any]): + token_url = "http://keycloak.com/token" + token_request = responses.post(token_url, json=token_reply) + tiled_auth = _tiled_auth(token_url) + + tiled_auth.get_access_token() + tiled_auth.get_access_token() + + assert token_request.call_count == 2 + + +@responses.activate +def test_tiled_auth_retries_once_with_new_token_on_401(): + token_url = "http://keycloak.com/token" + responses.post(token_url, json={"access_token": "old", "expires_in": 300}) + responses.post(token_url, json={"access_token": "new", "expires_in": 300}) + tiled_auth = _tiled_auth(token_url) + request = Mock(headers={}) + + flow = tiled_auth.sync_auth_flow(request) + assert next(flow).headers["Authorization"] == "Bearer old" + retried = flow.send(Mock(status_code=HTTP_401_UNAUTHORIZED)) + assert retried.headers["Authorization"] == "Bearer new" + with pytest.raises(StopIteration): + flow.send(Mock(status_code=HTTP_401_UNAUTHORIZED)) diff --git a/uv.lock b/uv.lock index 6ddebe63f..5dc7eb08f 100644 --- a/uv.lock +++ b/uv.lock @@ -309,6 +309,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, ] +[[package]] +name = "authlib" +version = "1.9.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "joserfc" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/08/49/d174a1bcd2b62c261d68cd6dce10ef5f50a2bd4f8144bedeb5b6fa119ac2/authlib-1.9.6.tar.gz", hash = "sha256:1caa0791c0ea6bde6b4ef91b1731f720a97a0f00d3955878d4a493b4ce673247", size = 183687, upload-time = "2026-11-14T19:47:45.858Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/76/3c4315d5e0e64a5e7676a88e4ed4c55b365142581501dd8f5af9b3c09f80/authlib-1.9.6-py2.py3-none-any.whl", hash = "sha256:96564699a43281b9e3473717a135407a1170bdc850ebe21313539d672c2a6682", size = 267181, upload-time = "2026-11-14T19:47:44.074Z" }, +] + [[package]] name = "awkward" version = "2.14.0" @@ -481,6 +494,7 @@ wheels = [ name = "blueapi" source = { editable = "." } dependencies = [ + { name = "authlib" }, { name = "bluesky", extra = ["plotting"] }, { name = "bluesky-stomp" }, { name = "click" }, @@ -544,7 +558,6 @@ dev = [ { name = "pytest-httpx" }, { name = "pytest-xdist", extra = ["psutil"] }, { name = "responses" }, - { name = "respx" }, { name = "ruff" }, { name = "semver" }, { name = "sphinx-autobuild" }, @@ -563,6 +576,7 @@ dev = [ requires-dist = [ { name = "aioca", marker = "extra == 'server'" }, { name = "aiohttp", marker = "extra == 'server'", specifier = ">=3.13.5" }, + { name = "authlib", specifier = ">=1.9.6" }, { name = "bluesky", extras = ["plotting"], specifier = ">=1.14.0" }, { name = "bluesky-stomp", specifier = ">=0.1.6" }, { name = "click", specifier = ">=8.2.0" }, @@ -619,7 +633,6 @@ dev = [ { name = "pytest-httpx", specifier = ">=0.35.0" }, { name = "pytest-xdist", extras = ["psutil"] }, { name = "responses" }, - { name = "respx" }, { name = "ruff" }, { name = "semver" }, { name = "sphinx-autobuild", specifier = ">=2024.4.16" }, @@ -2808,6 +2821,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/72/b9/313e8f2f2e9517ae050a692ae7b3e4b3f17cc5e6dfea0db51fe14e586580/jinja2_ansible_filters-1.3.2-py3-none-any.whl", hash = "sha256:e1082f5564917649c76fed239117820610516ec10f87735d0338688800a55b34", size = 18975, upload-time = "2022-06-30T14:08:49.571Z" }, ] +[[package]] +name = "joserfc" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/31/5c3f27e82c92a7bbe1f028033ff19e0251540395c9be244c01a50de42bdb/joserfc-1.8.0.tar.gz", hash = "sha256:cbf03cb2c6db8cc5289f1ef8718842e53dba244b4c0de5fefa0c0eaee4bde8db", size = 241023, upload-time = "2026-11-03T10:45:57.948Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5e/7e/7ffaae13415e8f51c8e8d5d1845f2de7a27ebf2717e97a38d7e7446d6030/joserfc-1.8.0-py3-none-any.whl", hash = "sha256:176b836ac7ed9a46a88629e24076314b475f33a75d0bad7f26146e572eed7c79", size = 73147, upload-time = "2026-11-03T10:45:56.531Z" }, +] + [[package]] name = "json-merge-patch" version = "0.3.0" @@ -5697,18 +5722,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6d/86/ca7958de70cb0752350575e98229368a3a2f746a2942034b3364e17312bb/responses-0.26.3-py3-none-any.whl", hash = "sha256:74474f799334ac4f37d93b6437ecc3bb1bb5c77a8d31780a338643be2dce0af8", size = 36289, upload-time = "2026-08-26T19:17:23.176Z" }, ] -[[package]] -name = "respx" -version = "0.23.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "httpx" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/43/98/4e55c9c486404ec12373708d015ebce157966965a5ebe7f28ff2c784d41b/respx-0.23.1.tar.gz", hash = "sha256:242dcc6ce6b5b9bf621f5870c82a63997e8e82bc7c947f9ffe272b8f3dd5a780", size = 29243, upload-time = "2026-04-08T14:37:16.008Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/4a/221da6ca167db45693d8d26c7dc79ccfc978a440251bf6721c9aaf251ac0/respx-0.23.1-py2.py3-none-any.whl", hash = "sha256:b18004b029935384bccfa6d7d9d74b4ec9af73a081cc28600fffc0447f4b8c1a", size = 25557, upload-time = "2026-04-08T14:37:14.613Z" }, -] - [[package]] name = "rich" version = "15.0.0"