Renew broker idle waits only for encrypted current-task progress, keep an absolute deadline and binding/session/worker fences, and retain original-message reply deduplication. Add guarded prepare-update staging that reuses the active broker key material and application configuration. Validation: 216 passed, 2 skipped; guarded update and long-task routing covered with synthetic Docker configuration and loopback WebSocket tests. Real ECS build and acceptance remain pending.
103 lines
5.8 KiB
Python
103 lines
5.8 KiB
Python
from pathlib import Path
|
|
import re
|
|
from urllib.parse import urlsplit
|
|
from pydantic import model_validator
|
|
from pydantic_settings import BaseSettings, SettingsConfigDict
|
|
|
|
|
|
class Settings(BaseSettings):
|
|
model_config = SettingsConfigDict(env_prefix="HN_", extra="ignore", hide_input_in_errors=True)
|
|
environment: str = "production"
|
|
role: str = "connector"
|
|
redis_url: str = "redis://127.0.0.1:6379/0"
|
|
data_dir: Path = Path("runtime/connector")
|
|
database_url: str = ""
|
|
admin_secret: str = ""
|
|
internal_secret: str = ""
|
|
ca_cert: Path = Path("runtime/pki/ca.pem")
|
|
connector_key: Path = Path("runtime/pki/connector.key")
|
|
connector_public_key: Path = Path("runtime/pki/connector.pub")
|
|
public_url: str = "https://relay.example.invalid"
|
|
router_url: str = "wss://relay.example.invalid/device/ws"
|
|
device_domain: str = ""
|
|
feishu_api_base: str = "https://open.feishu.cn"
|
|
feishu_authorize_url: str = "https://open.feishu.cn/open-apis/authen/v1/authorize"
|
|
feishu_oauth_scopes: str = ""
|
|
feishu_app_id: str = ""
|
|
feishu_app_secret: str = ""
|
|
feishu_encrypt_key: str = ""
|
|
feishu_verification_token: str = ""
|
|
feishu_enabled: bool = False
|
|
oauth_enabled: bool = True
|
|
feishu_event_source: str = "longconn"
|
|
proxy_enabled: bool = False
|
|
# A fixed allowlist, never a user supplied upstream URL.
|
|
proxy_paths: str = "/open-apis/drive/v1/files,/open-apis/docx/v1/documents"
|
|
request_timeout: int = 45
|
|
task_tracking_timeout: int = 1800
|
|
max_body: int = 262144
|
|
max_pending: int = 1000
|
|
max_devices: int = 1000
|
|
max_connections: int = 1000
|
|
max_result: int = 16000
|
|
allow_insecure_local: bool = False
|
|
enrollment_signer_url: str = ""
|
|
credential_mode: str = "legacy"
|
|
credential_keyring_file: Path | None = None
|
|
credential_permission_profiles: dict[str, list[str]] = {}
|
|
connector_internal_url: str = "http://connector:8000"
|
|
router_admission_secret: str = ""
|
|
|
|
@model_validator(mode="after")
|
|
def validate_runtime(self):
|
|
if not 30 <= self.task_tracking_timeout <= 3600:
|
|
raise ValueError("task tracking timeout must be 30-3600 seconds")
|
|
if self.credential_mode not in {"legacy", "broker"}:
|
|
raise ValueError("invalid credential mode")
|
|
if self.credential_mode == "broker" and self.role in {"connector","router"}:
|
|
if (len(self.router_admission_secret) < 32 or self.router_admission_secret in {
|
|
self.internal_secret,self.admin_secret,self.feishu_app_secret}):
|
|
raise ValueError("broker mode requires an independent router admission credential")
|
|
for profile, scopes in self.credential_permission_profiles.items():
|
|
if (not re.fullmatch(r"[A-Za-z0-9_-]{1,64}", profile) or not scopes or len(scopes) > 128
|
|
or any(not re.fullmatch(r"[A-Za-z0-9_:.-]{1,256}", scope) for scope in scopes)):
|
|
raise ValueError("invalid credential permission profile")
|
|
if self.credential_mode == "broker" and self.role == "connector":
|
|
if self.environment == "production" and not self.database_url:
|
|
raise ValueError("production broker mode requires PostgreSQL")
|
|
if (not self.credential_keyring_file or not self.credential_permission_profiles
|
|
or not self.feishu_enabled or not self.oauth_enabled):
|
|
raise ValueError("broker mode requires keyring, product permissions and enabled platform OAuth")
|
|
authorize = urlsplit(self.feishu_authorize_url)
|
|
if (authorize.scheme != "https" or not authorize.hostname or authorize.username or authorize.password
|
|
or authorize.query or authorize.fragment):
|
|
raise ValueError("broker mode requires a fixed HTTPS authorization endpoint")
|
|
if self.credential_mode == "broker" and self.role == "router":
|
|
target = urlsplit(self.connector_internal_url)
|
|
if (not self.feishu_app_id or target.scheme not in {"http","https"}
|
|
or not target.hostname or target.username or target.password or target.query or target.fragment
|
|
or target.path not in {"","/"}):
|
|
raise ValueError("broker router requires authenticated fixed internal connector")
|
|
if self.environment not in {"production", "test", "development"}:
|
|
raise ValueError("invalid environment")
|
|
if self.role == "connector" and min(len(self.admin_secret), len(self.internal_secret)) < 32:
|
|
raise ValueError("admin/internal secrets must each be at least 32 characters")
|
|
if self.role == "longconn" and len(self.internal_secret) < 32:
|
|
raise ValueError("internal credential must be at least 32 characters")
|
|
if self.role == "connector" and self.admin_secret == self.internal_secret:
|
|
raise ValueError("admin and internal credentials must be different")
|
|
if self.environment == "production":
|
|
if self.allow_insecure_local or not self.public_url.startswith("https://"):
|
|
raise ValueError("production requires HTTPS")
|
|
if not self.router_url.startswith("wss://"):
|
|
raise ValueError("production requires WSS")
|
|
if not self.feishu_api_base.startswith("https://"):
|
|
raise ValueError("platform API requires HTTPS")
|
|
if self.feishu_event_source not in {"longconn", "webhook"}:
|
|
raise ValueError("invalid platform event source")
|
|
if self.feishu_enabled and not all((self.feishu_app_id, self.feishu_app_secret)):
|
|
raise ValueError("platform app ID and secret are required")
|
|
if self.feishu_enabled and self.feishu_event_source == "webhook" and not all((self.feishu_encrypt_key, self.feishu_verification_token)):
|
|
raise ValueError("webhook requires encryption key and verification token")
|
|
return self
|