[ELI-619] - adding a cache with a function to bypass it with headers

Author: TOEL2

src/eligibility_signposting_api/config/constants.py

@@ -6,3 +6,11 @@
 CONSUMER_ID = "NHSE-Product-ID"
 ALLOWED_CONDITIONS = Literal["COVID", "FLU", "MMR", "RSV"]
 CONSUMER_MAPPING_FILE_NAME = "consumer_mapping_config.json"
+
+ttl = {
+    "local": 0,
+    "test": 300,
+    "dev": 300,
+    "preprod": 300,
+    "prod": 300,
+}

src/eligibility_signposting_api/repos/campaign_repo.py

@@ -1,4 +1,7 @@
 import json
+import logging
+import os
+import time
 from collections.abc import Generator
 from typing import Annotated, NewType
 
@@ -7,9 +10,11 @@
 from wireup import Inject, service
 
 from eligibility_signposting_api.model.campaign_config import CampaignConfig, Rules
+from eligibility_signposting_api.config.constants import ttl
 
 BucketName = NewType("BucketName", str)
 
+logger = logging.getLogger(__name__)
 
 @service
 class CampaignRepo:
@@ -25,13 +30,55 @@ def __init__(
         super().__init__()
         self.s3_client = s3_client
         self.bucket_name = bucket_name
+        self._campaign_configs_cache: list[CampaignConfig] | None = None
+        self._cache_expiry_epoch: float = 0.0
+        self._cache_ttl_seconds: int = int(ttl.get(os.getenv("ENVIRONMENT"), 0))
+
+    def get_campaign_configs(self, bypass_cache: bool = False) -> Generator[CampaignConfig, None, None]:
+        now = time.time()
+        cache_enabled = self._cache_ttl_seconds > 0
+        cache_valid = (
+            cache_enabled
+            and not bypass_cache
+            and self._campaign_configs_cache is not None
+            and now < self._cache_expiry_epoch
+        )
 
-    def get_campaign_configs(self) -> Generator[CampaignConfig]:
         with xray_recorder.in_subsegment("CampaignRepo.get_campaign_configs"):
+            if cache_valid:
+                logger.info("Using cached campaign configs")
+                yield from self._campaign_configs_cache
+                return
+
+            logger.info(
+                "Refreshing campaign configs from S3 (bypass_cache=%s, ttl_seconds=%s)",
+                bypass_cache,
+                self._cache_ttl_seconds,
+            )
+            campaign_configs = self._load_campaign_configs_from_s3()
+
+            if cache_enabled and not bypass_cache:
+                self._campaign_configs_cache = campaign_configs
+                self._cache_expiry_epoch = now + self._cache_ttl_seconds
+
+            yield from campaign_configs
+
+    def _load_campaign_configs_from_s3(self) -> list[CampaignConfig]:
+        campaign_configs: list[CampaignConfig] = []
+
+        with xray_recorder.in_subsegment("CampaignRepo.load_campaign_configs_from_s3"):
             with xray_recorder.in_subsegment("list_objects"):
                 campaign_objects = self.s3_client.list_objects(Bucket=self.bucket_name)
+
             with xray_recorder.in_subsegment("get_objects"):
-                for campaign_object in campaign_objects["Contents"]:
-                    response = self.s3_client.get_object(Bucket=self.bucket_name, Key=f"{campaign_object['Key']}")
+                for campaign_object in campaign_objects.get("Contents", []):
+                    response = self.s3_client.get_object(
+                        Bucket=self.bucket_name,
+                        Key=f"{campaign_object['Key']}",
+                    )
                     body = response["Body"].read()
-                    yield Rules.model_validate(json.loads(body)).campaign_config
+                    campaign_configs.append(
+                        Rules.model_validate(json.loads(body)).campaign_config
+                    )
+
+        return campaign_configs

src/eligibility_signposting_api/services/eligibility_services.py

@@ -42,6 +42,7 @@ def get_eligibility_status(
         conditions: list[str],
         category: str,
         consumer_id: str,
+        bypass_campaign_config_cache: bool = False,
     ) -> eligibility_status.EligibilityStatus:
         """Calculate a person's eligibility for vaccination given an NHS number."""
         if nhs_number:
@@ -50,7 +51,11 @@ def get_eligibility_status(
             except NotFoundError as e:
                 raise UnknownPersonError from e
             else:
-                campaign_configs: list[CampaignConfig] = list(self.campaign_repo.get_campaign_configs())
+                campaign_configs: list[CampaignConfig] = list(
+                    self.campaign_repo.get_campaign_configs(
+                        bypass_cache=bypass_campaign_config_cache
+                    )
+                )
                 permitted_campaign_configs = self.__collect_permitted_campaign_configs(
                     campaign_configs, ConsumerId(consumer_id)
                 )

src/eligibility_signposting_api/views/eligibility.py

@@ -28,6 +28,8 @@
     Status.not_eligible: eligibility_response.Status.not_eligible,
 }
 
+BYPASS_CAMPAIGN_CONFIG_CACHE_HEADER = "X-Bypass-Campaign-Config-Cache"
+
 logger = logging.getLogger(__name__)
 
 eligibility_blueprint = Blueprint("eligibility", __name__)
@@ -53,6 +55,7 @@ def check_eligibility(
 
     query_params = _get_or_default_query_params()
     consumer_id = _get_consumer_id_from_headers()
+    bypass_campaign_config_cache = _should_bypass_campaign_config_cache()
 
     try:
         eligibility_status = eligibility_service.get_eligibility_status(
@@ -61,6 +64,7 @@ def check_eligibility(
             query_params["conditions"],
             query_params["category"],
             consumer_id,
+            bypass_campaign_config_cache=bypass_campaign_config_cache,
         )
     except UnknownPersonError:
         return handle_unknown_person_error(nhs_number)
@@ -77,6 +81,11 @@ def _get_consumer_id_from_headers() -> ConsumerId:
     return ConsumerId(request.headers.get(CONSUMER_ID, ""))
 
 
+def _should_bypass_campaign_config_cache() -> bool:
+    value = request.headers.get(BYPASS_CAMPAIGN_CONFIG_CACHE_HEADER, "")
+    return value.lower() == "true"
+
+
 def _get_or_default_query_params() -> dict[str, Any]:
     default_query_params = {"category": "ALL", "conditions": ["ALL"], "includeActions": "Y"}
 

tests/integration/lambda/test_app_running_as_lambda.py

@@ -726,3 +726,36 @@ def test_status_end_point(invoke_with_mock_apigw_request):
             )
         ),
     )
+
+def test_cache_bypass(  # noqa: PLR0913
+    lambda_client: BaseClient,  # noqa:ARG001
+    persisted_person: NHSNumber,
+    rsv_campaign_config: CampaignConfig,
+    consumer_to_active_rsv_campaign_mapping: ConsumerMapping,  # noqa: ARG001
+    consumer_id: ConsumerId,
+    s3_client: BaseClient,
+    audit_bucket: BucketName,
+    invoke_with_mock_apigw_request,
+    lambda_logs: Callable[[], list[str]],
+    secretsmanager_client: BaseClient,  # noqa:ARG001
+):
+    # Given
+    invoke_path = f"/patient-check/{persisted_person}"
+    headers = {
+        "nhs-login-nhs-number": str(persisted_person),
+        "x_request_id": "x_request_id",
+        "x_correlation_id": "x_correlation_id",
+        "nhsd_end_user_organisation_ods": "nhsd_end_user_organisation_ods",
+        "nhsd-application-id": "nhsd-application-id",
+        "NHSE-Product-ID": consumer_id,
+    }
+    params = {"includeActions": "Y"}
+
+    # When
+    response = invoke_with_mock_apigw_request(path=invoke_path, headers=headers, params=params)
+
+    # Then
+    assert_that(
+        response,
+        is_response().with_status_code(HTTPStatus.OK).and_body(is_json_that(has_key("processedSuggestions"))),
+    )

tests/unit/views/test_eligibility.py

@@ -62,6 +62,7 @@ def get_eligibility_status(
         _conditions: list[str],
         _category: str,
         _consumer_id: str,
+        bypass_campaign_config_cache: bool = False,
     ) -> EligibilityStatus:
         return EligibilityStatusFactory.build()
 
@@ -77,6 +78,7 @@ def get_eligibility_status(
         _conditions: list[str],
         _category: str,
         _consumer_id: str,
+        bypass_campaign_config_cache: bool = False,
     ) -> EligibilityStatus:
         raise UnknownPersonError
 
@@ -91,6 +93,8 @@ def get_eligibility_status(
         _include_actions: str,
         _conditions: list[str],
         _category: str,
+        _consumer_id: str,
+        bypass_campaign_config_cache: bool = False,
     ) -> EligibilityStatus:
         raise ValueError