VED-79:setup script in the pipeline

Author: Akol125

azure/templates/post-deploy.yml

@@ -68,16 +68,26 @@ steps:
         DYNAMODB_TABLE_NAME=$(make -s output name=dynamodb_table_name)
         AWS_SQS_QUEUE_NAME=$(make -s output name=aws_sqs_queue_name)
         AWS_SNS_TOPIC_NAME=$(make -s output name=aws_sns_topic_name)
+        SQS_QUEUE_ARN=$(make -s output name=id_sync_queue_arn)
         echo "##vso[task.setvariable variable=DYNAMODB_TABLE_NAME]$DYNAMODB_TABLE_NAME"
         echo "##vso[task.setvariable variable=AWS_DOMAIN_NAME]$AWS_DOMAIN_NAME"
         echo "##vso[task.setvariable variable=IMMS_DELTA_TABLE_NAME]$IMMS_DELTA_TABLE_NAME"
         echo "##vso[task.setvariable variable=AWS_SQS_QUEUE_NAME]$AWS_SQS_QUEUE_NAME"
         echo "##vso[task.setvariable variable=AWS_SNS_TOPIC_NAME]$AWS_SNS_TOPIC_NAME"
+        echo "##vso[task.setvariable variable=SQS_QUEUE_ARN]$SQS_QUEUE_ARN"
       fi
     displayName: Apply Terraform
     workingDirectory: "$(Pipeline.Workspace)/s/$(SERVICE_NAME)/$(SERVICE_ARTIFACT_NAME)"
     retryCountOnTaskFailure: 2
 
+  - bash: |
+      echo "Subscribing SQS to MNS via Lambda-compatible client..."
+      poetry run python mns_subscription/src/subscribe_mns.py
+    displayName: "Run MNS Subscription"
+    workingDirectory: "$(Pipeline.Workspace)/s/$(SERVICE_NAME)/$(SERVICE_ARTIFACT_NAME)"
+    env:
+      SQS_ARN: "$(SQS_ARN)"
+
   - bash: |
       set -ex
 

mns_subscription/.coverage

@@ -1,7 +1,6 @@
 import uuid
 from dataclasses import dataclass
 from enum import Enum
-from typing import Union
 
 
 class Severity(str, Enum):
@@ -70,7 +69,7 @@ def to_operation_outcome(self) -> dict:
 class UnhandledResponseError(RuntimeError):
     """Use this error when the response from an external service (ex: dynamodb) can't be handled"""
 
-    response: Union[dict, str]
+    response: dict | str
     message: str
 
     def __str__(self):

mns_subscription/models/errors.py

@@ -11,24 +11,24 @@ def __init__(self, directory):
             self.cache_file.seek(0)
             content = self.cache_file.read()
         if len(content) == 0:
-            self.cache = {}
+            self.store = {}
         else:
-            self.cache = json.loads(content)
+            self.store = json.loads(content)
 
     def put(self, key: str, value: dict):
-        self.cache[key] = value
+        self.store[key] = value
         self._overwrite()
 
     def get(self, key: str) -> Optional[dict]:
-        return self.cache.get(key, None)
+        return self.store.get(key, None)
 
     def delete(self, key: str):
-        if key not in self.cache:
+        if key not in self.store:
             return
-        del self.cache[key]
+        del self.store[key]
 
     def _overwrite(self):
         with open(self.cache_file.name, "w") as self.cache_file:
             self.cache_file.seek(0)
-            self.cache_file.write(json.dumps(self.cache))
+            self.cache_file.write(json.dumps(self.store))
             self.cache_file.truncate()

mns_subscription/src/cache.py

@@ -1,18 +1,19 @@
 import requests
+import os
 import uuid
 import json
 from authentication import AppRestrictedAuth
 from models.errors import UnhandledResponseError
 
-SQS_ARN = "arn:aws:sqs:eu-west-2:345594581768:imms-pr-655-id-sync-queue"
+SQS_ARN = os.getenv("SQS_QUEUE_ARN")
 MNS_URL = "https://int.api.service.nhs.uk/multicast-notification-service/subscriptions"
 
 
 class MnsService:
     def __init__(self, authenticator: AppRestrictedAuth):
         self.authenticator = authenticator
 
-    def subscribeNotification(self) -> dict | None:
+    def subscribe_notification(self) -> dict | None:
         access_token = self.authenticator.get_access_token()
         request_headers = {
             'Authorization': f'Bearer {access_token}',

mns_subscription/src/mns_service.py

@@ -1,25 +1,39 @@
 from authentication import AppRestrictedAuth
 import os
+import logging
 from cache import Cache
 from mns_service import MnsService
 import boto3
 from authentication import Service
 from botocore.config import Config
 
+logging.basicConfig(level=logging.INFO)
+
 
 def run_subscription():
-    mns_env: str = os.getenv("MNS_ENV", "int")
-
-    boto_config = Config(region_name="eu-west-2")
-    cache = Cache(directory="/tmp")
-    authenticator = AppRestrictedAuth(
-        service=Service.MNS,
-        secret_manager_client=boto3.client("secretsmanager", config=boto_config),
-        environment=mns_env,
-        cache=cache,
-    )
-    mns = MnsService(authenticator, mns_env)
-    return mns.subscribeNotification()
+    try:
+        mns_env: str = os.getenv("MNS_ENV", "int")
+
+        boto_config = Config(region_name="eu-west-2")
+        cache = Cache(directory="/tmp")
+        logging.info("Creating authenticator...")
+        authenticator = AppRestrictedAuth(
+            service=Service.MNS,
+            secret_manager_client=boto3.client("secretsmanager", config=boto_config),
+            environment=mns_env,
+            cache=cache,
+        )
+
+        logging.info("Creating MNS service...")
+        mns = MnsService(authenticator, mns_env)
+
+        logging.info("Subscribing to MNS...")
+        result = mns.subscribe_notification()
+        logging.info(f"Subscription Result: {result}")
+        return result
+    except Exception:
+        logging.exception("Failed to complete MNS subscription process")
+        raise
 
 
 if __name__ == "__main__":

mns_subscription/src/subscribe_mns.py

@@ -7,16 +7,16 @@
 
 class TestCache(unittest.TestCase):
     def setUp(self):
-        self.cache = Cache(tempfile.gettempdir())
+        self.store = Cache(tempfile.gettempdir())
 
     def test_cache_put(self):
         """it should store cache in specified key"""
         value = {"foo": "a-foo", "bar": 42}
         key = "a_key"
 
         # When
-        self.cache.put(key, value)
-        act_value = self.cache.get(key)
+        self.store.put(key, value)
+        act_value = self.store.get(key)
 
         # Then
         self.assertDictEqual(value, act_value)
@@ -25,45 +25,45 @@ def test_cache_put_overwrite(self):
         """it should store updated cache value"""
         value = {"foo": "a-foo", "bar": 42}
         key = "a_key"
-        self.cache.put(key, value)
+        self.store.put(key, value)
 
         new_value = {"foo": "new-foo"}
-        self.cache.put(key, new_value)
+        self.store.put(key, new_value)
 
         # When
-        updated_value = self.cache.get(key)
+        updated_value = self.store.get(key)
 
         # Then
         self.assertDictEqual(new_value, updated_value)
 
     def test_key_not_found(self):
         """it should return None if key doesn't exist"""
-        value = self.cache.get("it-does-not-exist")
+        value = self.store.get("it-does-not-exist")
         self.assertIsNone(value)
 
     def test_delete(self):
         """it should delete key"""
         key = "a_key"
-        self.cache.put(key, {"a": "b"})
-        self.cache.delete(key)
+        self.store.put(key, {"a": "b"})
+        self.store.delete(key)
 
-        value = self.cache.get(key)
+        value = self.store.get(key)
         self.assertIsNone(value)
 
     def test_write_to_file(self):
         """it should update the cache file"""
         value = {"foo": "a-long-foo-so-to-make-sure-truncate-is-working", "bar": 42}
         key = "a_key"
-        self.cache.put(key, value)
+        self.store.put(key, value)
         # Add one and delete to make sure file gets updated
-        self.cache.put("to-delete-key", {"x": "y"})
-        self.cache.delete("to-delete-key")
+        self.store.put("to-delete-key", {"x": "y"})
+        self.store.delete("to-delete-key")
 
         # When
         new_value = {"a": "b"}
-        self.cache.put(key, new_value)
+        self.store.put(key, new_value)
 
         # Then
-        with open(self.cache.cache_file.name, "r") as stored:
+        with open(self.store.cache_file.name, "r") as stored:
             content = json.loads(stored.read())
             self.assertDictEqual(content[key], new_value)

mns_subscription/tests/test_cache.py

@@ -24,7 +24,7 @@ def test_successful_subscription(self, mock_post):
         service = MnsService(self.authenticator)
 
         # Act
-        result = service.subscribeNotification()
+        result = service.subscribe_notification()
 
         # Assert
         self.assertEqual(result, {"subscriptionId": "abc123"})
@@ -38,7 +38,7 @@ def test_not_found_subscription(self, mock_post):
         mock_post.return_value = mock_response
 
         service = MnsService(self.authenticator)
-        result = service.subscribeNotification()
+        result = service.subscribe_notification()
 
         self.assertIsNone(result)
 
@@ -52,7 +52,7 @@ def test_unhandled_error(self, mock_post):
         service = MnsService(self.authenticator)
 
         with self.assertRaises(UnhandledResponseError) as context:
-            service.subscribeNotification()
+            service.subscribe_notification()
 
         self.assertIn("Please provide the correct resource type", str(context.exception))
 

mns_subscription/tests/test_mns_service.py

@@ -17,7 +17,7 @@ def test_run_subscription_success(self, mock_boto_client, mock_auth_class, mock_
         mock_auth_class.return_value = mock_auth_instance
 
         mock_mns_instance = MagicMock()
-        mock_mns_instance.subscribeNotification.return_value = {"subscriptionId": "abc123"}
+        mock_mns_instance.subscribe_notification.return_value = {"subscriptionId": "abc123"}
         mock_mns_service.return_value = mock_mns_instance
 
         # Act
@@ -27,7 +27,7 @@ def test_run_subscription_success(self, mock_boto_client, mock_auth_class, mock_
         self.assertEqual(result, {"subscriptionId": "abc123"})
         mock_auth_class.assert_called_once()
         mock_mns_service.assert_called_once_with(mock_auth_instance, "int")
-        mock_mns_instance.subscribeNotification.assert_called_once()
+        mock_mns_instance.subscribe_notification.assert_called_once()
 
 
 if __name__ == "__main__":

mns_subscription/tests/test_subscription.py

@@ -17,3 +17,8 @@ output "aws_sqs_queue_name" {
 output "aws_sns_topic_name" {
   value = aws_sns_topic.delta_sns.name
 }
+
+output "id_sync_queue_arn" {
+  description = "The ARN of the created SQS queue"
+  value       = aws_sqs_queue.id_sync_queue.arn
+}