From e2e64150947eaa0f8de54086c59eecc26a9a7296 Mon Sep 17 00:00:00 2001
From: demo-bot <demo-bot@kyndryl.com>
Date: Sun, 9 Aug 2026 15:54:54 +0000
Subject: [PATCH] decomposer: generate deliverable files for Define the service
 contract and project architecture for the FastAPI endpoint monitoring
 service.; Implement the typed monitor CRUD API and concurrency-safe in-memory
 state according to the service design.; Implement secure on-demand endpoint
 checks with status updates, latency measurement, robust error handling, and
 redacted structured logs.; Add operational API endpoints and
 environment-driven runtime configuration to the monitoring service.; Create
 automated tests for the monitoring service.; Package the service with Docker
 and developer documentation.; Validate the complete project.

---
 app/store.py | 61 ++++++++++++++++++++++++----------------------------
 1 file changed, 28 insertions(+), 33 deletions(-)

diff --git a/app/store.py b/app/store.py
index e9c4c71..630cbca 100644
--- a/app/store.py
+++ b/app/store.py
@@ -1,63 +1,58 @@
 import asyncio
 from uuid import UUID, uuid4
 
-from app.models import CurrentStatus, Monitor, MonitorCreate, MonitorUpdate, utc_now
+from .models import CheckSnapshot, Monitor, MonitorInput, now
+
+
+class StoreFullError(Exception):
+    pass
 
 
 class MonitorStore:
-    def __init__(self) -> None:
-        self._lock = asyncio.Lock()
+    def __init__(self, max_monitors: int) -> None:
         self._items: dict[UUID, Monitor] = {}
+        self._lock = asyncio.Lock()
+        self._max = max_monitors
 
-    async def create(self, value: MonitorCreate) -> Monitor:
-        now = utc_now()
-        item = Monitor(
-            id=uuid4(), name=value.name, url=value.url, created_at=now, updated_at=now, revision=1
-        )
+    async def create(self, data: MonitorInput) -> Monitor:
         async with self._lock:
+            if len(self._items) >= self._max:
+                raise StoreFullError
+            timestamp = now()
+            item = Monitor(id=uuid4(), **data.model_dump(), created_at=timestamp,
+                           updated_at=timestamp, revision=1, status=CheckSnapshot())
             self._items[item.id] = item
-        return item.model_copy(deep=True)
+            return item
 
     async def list(self) -> list[Monitor]:
         async with self._lock:
-            values = sorted(self._items.values(), key=lambda item: item.created_at)
-            return [item.model_copy(deep=True) for item in values]
+            return sorted(self._items.values(), key=lambda item: item.created_at)
 
     async def get(self, monitor_id: UUID) -> Monitor | None:
         async with self._lock:
-            item = self._items.get(monitor_id)
-            return item.model_copy(deep=True) if item else None
+            return self._items.get(monitor_id)
 
-    async def update(self, monitor_id: UUID, value: MonitorUpdate) -> Monitor | None:
+    async def replace(self, monitor_id: UUID, data: MonitorInput) -> Monitor | None:
         async with self._lock:
             old = self._items.get(monitor_id)
             if old is None:
                 return None
-            changed_url = old.url != value.url
-            item = old.model_copy(
-                update={
-                    "name": value.name,
-                    "url": value.url,
-                    "updated_at": utc_now(),
-                    "revision": old.revision + 1,
-                    "current_status": None if changed_url else old.current_status,
-                }
-            )
+            item = old.model_copy(update={**data.model_dump(), "updated_at": now(),
+                                          "revision": old.revision + 1,
+                                          "status": CheckSnapshot()})
             self._items[monitor_id] = item
-            return item.model_copy(deep=True)
+            return item
 
     async def delete(self, monitor_id: UUID) -> bool:
         async with self._lock:
             return self._items.pop(monitor_id, None) is not None
 
-    async def set_status_if_current(
-        self, monitor_id: UUID, revision: int, status: CurrentStatus
-    ) -> bool:
+    async def set_status(self, monitor_id: UUID, revision: int,
+                         status: CheckSnapshot) -> Monitor | None:
         async with self._lock:
             old = self._items.get(monitor_id)
             if old is None or old.revision != revision:
-                return False
-            self._items[monitor_id] = old.model_copy(
-                update={"current_status": status, "updated_at": utc_now()}
-            )
-            return True
+                return None
+            item = old.model_copy(update={"status": status, "updated_at": now()})
+            self._items[monitor_id] = item
+            return item