feat: prepare ARR for controlled public deployment

2026-07-29 16:38:05 +08:00
commit a701de9f0e
271 changed files with 48472 additions and 0 deletions
--- a/arr_web/processing_runtime.py
+++ b/arr_web/processing_runtime.py
@@ -0,0 +1,129 @@
+"""Production composition for XML upload and Open Agent dispatch."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from agent_integration import (
+    AgentConfig,
+    OpenAgentAPIClient,
+    OpenAgentService,
+    SQLiteSessionStore,
+)
+from arr_ingestion.postgres import DatabaseConfig
+from arr_ingestion.direct_postgres import PostgresDirectIngestionRepository
+from arr_processing.config import ResultVerificationConfig
+from arr_processing.open_agent import OpenAgentProcessingTransport
+from arr_processing.postgres import PostgresProcessingState, ProcessingDatabaseConfig
+from arr_processing.runner import ProcessingRunner
+from arr_processing.source_message import OssProcessingMessageBuilder
+from arr_storage.aliyun_oss_v2 import AliyunOssConfig, AliyunOssV2Client
+from arr_storage.contracts import ObjectKeyPolicy
+from arr_storage.remote import CloudObjectBackend
+from arr_storage.store import ManagedObjectStore
+from arr_web.agent_writeback_runtime import load_processor_policy
+from arr_web.services import ObjectStoreUploadCoordinator
+
+
+@dataclass
+class ProcessingInputRuntime:
+    coordinator: ObjectStoreUploadCoordinator
+    api_client: OpenAgentAPIClient
+    session_store: SQLiteSessionStore
+    oss_client: AliyunOssV2Client
+
+    def close(self) -> None:
+        errors = []
+        for close in (
+            self.api_client.close,
+            self.session_store.close,
+            self.oss_client.close,
+        ):
+            try:
+                close()
+            except Exception as error:  # pragma: no cover - best-effort shutdown
+                errors.append(error)
+        if errors:
+            raise errors[0]
+
+
+def compose_oss_processing_input(
+    *,
+    project_root: Path,
+    connect: Optional[Callable[[str], Any]] = None,
+) -> ProcessingInputRuntime:
+    oss_client: Optional[AliyunOssV2Client] = None
+    session_store: Optional[SQLiteSessionStore] = None
+    api_client: Optional[OpenAgentAPIClient] = None
+    try:
+        agent_config = AgentConfig.from_env()
+        verification = ResultVerificationConfig.from_environment()
+        processor_policy = load_processor_policy(project_root)
+        oss_config = AliyunOssConfig.from_environment()
+        oss_client = AliyunOssV2Client(oss_config)
+        oss_client.assert_immutable_writes_supported()
+        object_store = ManagedObjectStore(
+            CloudObjectBackend(oss_client),
+            ObjectKeyPolicy(os.environ.get("ARR_OBJECT_PREFIX", "arr")),
+        )
+        processing_config = (
+            ProcessingDatabaseConfig("controlled")
+            if connect is not None
+            else ProcessingDatabaseConfig.from_environment()
+        )
+        ingestion_config = (
+            DatabaseConfig("controlled")
+            if connect is not None
+            else DatabaseConfig.from_environment()
+        )
+        session_store = SQLiteSessionStore(agent_config.session_db)
+        if agent_config.api_key is None:
+            raise ValueError("Agent API key is unavailable")
+        api_client = OpenAgentAPIClient(
+            base_url=agent_config.base_url,
+            api_key=agent_config.api_key,
+            auth_mode=agent_config.auth_mode,
+            timeout=agent_config.timeout_seconds,
+            connect_timeout=agent_config.connect_timeout_seconds,
+        )
+        service = OpenAgentService(api_client, session_store)
+        processing_state = PostgresProcessingState(processing_config, connect=connect)
+        runner = ProcessingRunner(
+            OpenAgentProcessingTransport(
+                service,
+                message_builder=OssProcessingMessageBuilder(
+                    oss_config,
+                    processing_state,
+                ).message,
+            ),
+            processing_state,
+            verification.verifier(),
+        )
+        coordinator = ObjectStoreUploadCoordinator(
+            object_store=object_store,
+            ingestion_repository=PostgresDirectIngestionRepository(
+                ingestion_config,
+                connect=connect,
+            ),
+            processing_starter=runner,
+            processor_version=processor_policy.processor_version,
+            rule_set_sha256=processor_policy.rule_set_sha256,
+        )
+        return ProcessingInputRuntime(
+            coordinator,
+            api_client,
+            session_store,
+            oss_client,
+        )
+    except Exception:
+        for resource in (api_client, session_store, oss_client):
+            if resource is None:
+                continue
+            try:
+                resource.close()
+            except Exception:
+                pass
+        raise