Initial curated ITWorx_MCP_Hub source from 368fba691ea8d23403b4d56b53b5ec670d7c5020

services/control_api/knowledge/jobs.py

@@ -0,0 +1,63 @@
+"""Bounded background refresh orchestration for registered knowledge sources."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable, Iterable
+from uuid import UUID
+
+from packages.connector_kit.knowledge import (
+    IndexReport,
+    InMemoryKnowledgeIndex,
+)
+from packages.connector_kit.knowledge import (
+    KnowledgeRefreshJob as SingleRefreshJob,
+)
+
+
+class KnowledgeRefreshScheduler:
+    """Cooperative scheduler; it never accepts a caller-supplied physical path."""
+
+    def __init__(
+        self,
+        index: InMemoryKnowledgeIndex,
+        source_ids: Iterable[UUID],
+        *,
+        interval_seconds: float = 300.0,
+        on_refresh: Callable[[tuple[IndexReport, ...]], Awaitable[None]] | None = None,
+    ) -> None:
+        if not 1 <= interval_seconds <= 86_400:
+            raise ValueError("refresh interval is outside bounds")
+        self.index = index
+        self.source_ids = tuple(source_ids)
+        self.interval_seconds = interval_seconds
+        self.on_refresh = on_refresh
+        self._task: asyncio.Task[None] | None = None
+        self._stop = asyncio.Event()
+
+    async def run_once(self) -> tuple[IndexReport, ...]:
+        reports = SingleRefreshJob(self.index, self.source_ids).run_once()
+        if self.on_refresh is not None:
+            await self.on_refresh(reports)
+        return reports
+
+    async def start(self) -> None:
+        if self._task is not None and not self._task.done():
+            return
+        self._stop.clear()
+        self._task = asyncio.create_task(self._loop())
+
+    async def stop(self) -> None:
+        self._stop.set()
+        task = self._task
+        self._task = None
+        if task is not None:
+            await task
+
+    async def _loop(self) -> None:
+        while not self._stop.is_set():
+            await self.run_once()
+            try:
+                await asyncio.wait_for(self._stop.wait(), timeout=self.interval_seconds)
+            except TimeoutError:
+                continue