601 lines
35 KiB
Python
601 lines
35 KiB
Python
"""Durable, project-scoped SCADA playback; raw is never inserted or rewritten."""
|
||
from __future__ import annotations
|
||
|
||
from datetime import datetime, timedelta, timezone
|
||
import json
|
||
from uuid import NAMESPACE_URL, uuid4, uuid5
|
||
|
||
from fastapi import HTTPException
|
||
from app.auth.permissions import permissions_for_context
|
||
|
||
from app.domain.schemas.project_settings import ScadaMonitoringSettings
|
||
from app.domain.schemas.scada_replay import ScadaReplayCreate, ScadaReplayCommand, ScadaReplaySnapshot
|
||
from app.infra.db.postgresql.scada import ScadaInfoRepository
|
||
from app.infra.db.timescaledb.repositories.scada import ScadaRepository
|
||
from app.services.content_digest import digest
|
||
from app.services.scada_replay_processing import prepare_cleaning, detect_frame
|
||
from app.services.scada_replay_monitoring import evaluate_monitoring_period
|
||
from app.services.scada_normal_profile import current_calibration, diagnostic_signal, weighted_diagnosis
|
||
|
||
|
||
# 500 devices at 15-minute sampling need 720,000 rows for fifteen days.
|
||
# Leave headroom without allowing dense sources to make preparation unbounded.
|
||
BASELINE_PAGE_SIZE = 2000
|
||
BASELINE_MAX_ROWS = 1_000_000
|
||
BASELINE_MAX_BYTES = 512 * 1024 * 1024
|
||
|
||
|
||
class BaselineBudgetExceeded(RuntimeError):
|
||
"""The unpublished baseline exceeded its fixed preparation budget."""
|
||
|
||
|
||
def parse_time(value: str) -> datetime:
|
||
return datetime.fromisoformat(value)
|
||
|
||
|
||
def snapshot(document: dict) -> ScadaReplaySnapshot:
|
||
return ScadaReplaySnapshot(
|
||
**{key: document[key] for key in (
|
||
"replay_id", "project_id", "revision", "status", "start_time", "end_time",
|
||
"virtual_now", "created_at", "updated_at",
|
||
)},
|
||
delivered_until=document.get("delivered_until"), processed_until=document.get("processed_until"),
|
||
processed_count=document.get("processed_count", 0), anomaly_count=document.get("anomaly_count", 0),
|
||
devices=document["devices"], rules=document["config"]["rules"],
|
||
latest=list(document.get("latest", {}).values()),
|
||
active_events=[state["event"] for state in document.get("rule_states", {}).values() if state.get("event")],
|
||
error=document.get("error"),
|
||
monitoring_interval_seconds=document.get("monitoring_interval_seconds"),
|
||
step_pending=document.get("step_pending", False),
|
||
monitoring_count=document.get("monitoring_count", 0),
|
||
last_monitoring=document.get("last_monitoring"),
|
||
# Old persisted documents without a policy still use three-signal detection.
|
||
monitoring_config=({"decision_policy": "all_signals", **document["monitoring_config"]}
|
||
if document.get("monitoring_config") else None),
|
||
monitoring_calibration=document.get("monitoring_calibration"),
|
||
)
|
||
|
||
|
||
class ScadaReplayService:
|
||
def __init__(self, repository, context, timescale=None, *, clock=None):
|
||
self.repo, self.context, self.timescale = repository, context, timescale
|
||
self.clock = clock or (lambda: datetime.now(timezone.utc))
|
||
|
||
async def ensure_storage(self):
|
||
if not await self.repo.available():
|
||
raise HTTPException(503, "SCADA 回放存储未配置，需要应用 031_scada_replays.sql")
|
||
|
||
async def create(
|
||
self,
|
||
command: ScadaReplayCreate,
|
||
*,
|
||
monitoring_interval_seconds: int | None,
|
||
monitoring_config: ScadaMonitoringSettings | None = None,
|
||
):
|
||
await self.ensure_storage()
|
||
async with self.repo.control():
|
||
previous = await self.repo.by_request(command.request_id)
|
||
config = command.model_dump(mode="json")
|
||
if previous:
|
||
if previous["config"] != config:
|
||
raise HTTPException(409, "创建请求号已用于不同回放配置")
|
||
return snapshot(previous)
|
||
if monitoring_interval_seconds is None:
|
||
raise HTTPException(422, "请先配置项目 settings.scada_monitoring_interval_seconds，再创建演示")
|
||
replay_id = str(uuid4())
|
||
if await self.repo.active_other(replay_id):
|
||
raise HTTPException(409, "当前项目已有回放，请先停止原回放再新建")
|
||
metadata = {row["device_id"]: row for row in await ScadaInfoRepository.get_scadas(self.repo.connection)}
|
||
if not set(command.device_ids) <= metadata.keys():
|
||
raise HTTPException(422, "设备不属于当前项目")
|
||
for rule in command.rules:
|
||
if any(metadata[device]["measurement_unit"] != rule.unit for device in rule.device_ids):
|
||
raise HTTPException(422, "规则单位与设备单位不一致，请分组配置")
|
||
if any(metadata[device]["device_type"] == "quality" for device in rule.device_ids) and not rule.metric_name.strip():
|
||
raise HTTPException(422, "水质规则必须明确指标名称，不能仅凭单位解释读数")
|
||
if monitoring_config:
|
||
role_ids = set(monitoring_config.pressure_device_ids) | set(monitoring_config.outlet_flow_device_ids)
|
||
if not role_ids <= metadata.keys():
|
||
raise HTTPException(422, "项目 SCADA 监测角色包含不存在的设备")
|
||
if any(metadata[device]["device_type"] != "pressure" for device in monitoring_config.pressure_device_ids):
|
||
raise HTTPException(422, "压力监测角色必须引用 pressure 设备")
|
||
if any(metadata[device]["device_type"] not in {"pipe_flow", "flow"}
|
||
for device in monitoring_config.outlet_flow_device_ids):
|
||
raise HTTPException(422, "出厂边界流量角色必须引用流量设备")
|
||
now = self.clock().isoformat()
|
||
document = {
|
||
"replay_id": replay_id, "project_id": str(self.context.project_id),
|
||
"created_by": str(self.context.user_id), "config": config,
|
||
"revision": 1, "status": "ready", "start_time": config["start_time"],
|
||
"end_time": config["end_time"], "virtual_now": config["start_time"],
|
||
"created_at": now, "updated_at": now,
|
||
"monitoring_interval_seconds": monitoring_interval_seconds,
|
||
"monitoring_config": monitoring_config.model_dump(mode="json") if monitoring_config else None,
|
||
"devices": [metadata[device] for device in command.device_ids],
|
||
"batch_sequence": 0, "processed_count": 0, "anomaly_count": 0,
|
||
"monitoring_count": 0, "latest": {}, "histories": {}, "rule_states": {}, "receipts": {},
|
||
}
|
||
await self.repo.insert(document)
|
||
return snapshot(document)
|
||
|
||
async def command(self, replay_id, command: ScadaReplayCommand):
|
||
await self.ensure_storage()
|
||
async with self.repo.control():
|
||
document = await self.repo.get(replay_id)
|
||
key, body = str(command.request_id), command.model_dump(mode="json", exclude_none=True)
|
||
receipt = document.setdefault("receipts", {}).get(key)
|
||
if receipt:
|
||
if receipt != body:
|
||
raise HTTPException(409, "命令请求号已用于不同内容")
|
||
return snapshot(document)
|
||
if command.expected_revision != document["revision"]:
|
||
raise HTTPException(409, "回放控制状态已更新，请刷新后重试")
|
||
action, status = command.action, document["status"]
|
||
if (action in {"step", "monitor", "retry"} and document.get("warmed")
|
||
and weighted_diagnosis(document)
|
||
and current_calibration(document, parse_time(document["start_time"])) is None):
|
||
raise HTTPException(409, "旧回放缺少新版历史诊断校准，请停止后新建演示")
|
||
if document.get("step_pending") and action in {"step", "monitor"}:
|
||
raise HTTPException(409, "当前时间步正在处理，请完成后继续")
|
||
if action in {"step", "monitor", "retry"} and await self.repo.active_other(replay_id):
|
||
raise HTTPException(409, "当前项目已有另一条活动回放")
|
||
if action == "step" and status in {"ready", "paused"}:
|
||
interval = document.get("monitoring_interval_seconds")
|
||
if interval is None:
|
||
raise HTTPException(409, "旧回放未固定监测周期，请停止后新建演示")
|
||
start = parse_time(document["start_time"])
|
||
elapsed = (parse_time(document["virtual_now"]) - start).total_seconds()
|
||
target = start + timedelta(seconds=(int(elapsed // interval) + 1) * interval)
|
||
document["step_start"] = document["virtual_now"]
|
||
document["step_anomaly_signals"] = []
|
||
document["step_target"] = min(parse_time(document["end_time"]), target).isoformat()
|
||
document["status"], document["step_pending"] = "paused", True
|
||
elif action == "monitor" and status in {"ready", "paused", "completed"}:
|
||
target = command.at_time
|
||
if target is None:
|
||
raise HTTPException(422, "选定时刻监测需要提供 at_time")
|
||
start = parse_time(document["start_time"])
|
||
current = parse_time(document["virtual_now"])
|
||
if not start <= target <= parse_time(document["end_time"]):
|
||
raise HTTPException(422, "监测时刻必须在本轮演示区间内")
|
||
if target < current:
|
||
raise HTTPException(409, "监测历史时刻需要新建一轮回放，避免使用后续状态")
|
||
interval = document.get("monitoring_interval_seconds")
|
||
if interval is None:
|
||
raise HTTPException(409, "本轮未固定监测周期，请停止后新建演示")
|
||
previous = document.get("last_monitoring") or {}
|
||
# Reusing an immutable result must not count as another normal
|
||
# period, resolve an incident, or create another investigation.
|
||
if not previous.get("period_end") or parse_time(previous["period_end"]) != target:
|
||
document["step_start"] = (current if target > current
|
||
else max(start, target - timedelta(seconds=interval))).isoformat()
|
||
document["step_target"] = target.isoformat()
|
||
document["step_anomaly_signals"] = []
|
||
document["status"], document["step_pending"] = "paused", True
|
||
elif action == "stop" and status not in {"completed", "stopped"}:
|
||
document["status"], document["step_pending"] = "stopped", False
|
||
document.pop("step_target", None)
|
||
document.pop("step_start", None)
|
||
elif action == "retry" and status == "failed":
|
||
if "SOURCE_CHANGED" in (document.get("error") or ""):
|
||
raise HTTPException(409, "原始数据发生变化，需要停止并新建回放")
|
||
document["status"], document["error"] = "paused", None
|
||
document["step_pending"] = bool(document.get("step_target"))
|
||
else:
|
||
raise HTTPException(409, "当前回放状态不支持此操作")
|
||
document["revision"] += 1
|
||
document["receipts"][key] = body
|
||
if len(document["receipts"]) > 256:
|
||
del document["receipts"][next(iter(document["receipts"]))]
|
||
await self.repo.save(document)
|
||
return snapshot(document)
|
||
|
||
async def process_pending_step(self, replay_id):
|
||
await self.ensure_storage()
|
||
async with self.repo.processing() as owned:
|
||
if not owned:
|
||
raise HTTPException(409, "当前时间步正在由另一请求处理")
|
||
while True:
|
||
document = await self.repo.get(replay_id)
|
||
if not document.get("step_pending"):
|
||
return snapshot(document)
|
||
try:
|
||
await self._advance(document)
|
||
except Exception as exc:
|
||
# Failure never discards the prepared batch; retry resumes it.
|
||
document = await self.repo.get(replay_id)
|
||
document["status"], document["step_pending"] = "failed", False
|
||
if isinstance(exc, HTTPException):
|
||
document["error"] = str(exc.detail)
|
||
elif isinstance(exc, BaselineBudgetExceeded):
|
||
document["error"] = str(exc)
|
||
else:
|
||
document["error"] = (
|
||
"SOURCE_CHANGED: 原始观测已改变，需要新建回放"
|
||
if "SOURCE_CHANGED" in str(exc)
|
||
else "SCADA 处理失败，已保留批次与进度；请检查服务日志后重试"
|
||
)
|
||
async with self.repo.connection.transaction():
|
||
await self.repo.save(document)
|
||
raise
|
||
|
||
async def _advance(self, document):
|
||
config = ScadaReplayCreate.model_validate(document["config"])
|
||
replay_id = document["replay_id"]
|
||
if not document.get("warmed"):
|
||
await self._freeze_baseline(document, config)
|
||
if weighted_diagnosis(document) and current_calibration(document, config.start_time) is None:
|
||
raise HTTPException(409, "旧回放缺少新版历史诊断校准，请停止后新建演示")
|
||
batch = await self.repo.pending_batch(replay_id)
|
||
if batch is None:
|
||
step = document.get("step_pending", False)
|
||
virtual = parse_time(document["virtual_now"])
|
||
through = parse_time(document["step_target"]) if step else virtual
|
||
after = ((parse_time(document["cursor"][0]), document["cursor"][1])
|
||
if document.get("cursor") else None)
|
||
async with self.timescale.transaction():
|
||
rows = await ScadaRepository.get_raw_page(
|
||
self.timescale, config.device_ids, config.start_time, config.end_time,
|
||
through, 501, after, frame=True,
|
||
)
|
||
if len(rows) > 500:
|
||
raise ValueError("SCADA frame exceeds selected device bound")
|
||
at = rows[0]["time"] if rows else through
|
||
if step:
|
||
virtual = through
|
||
document["virtual_now"] = virtual.isoformat()
|
||
if not rows and document.get("processed_until") == at.isoformat() and not step:
|
||
async with self.repo.connection.transaction():
|
||
await self.repo.save(document)
|
||
return
|
||
sequence = document["batch_sequence"] + 1
|
||
refs = [{"time": row["time"].isoformat(), "device_id": row["device_id"],
|
||
"source_hash": row["source_hash"]} for row in rows]
|
||
batch = {"sequence": sequence, "stage": "selected", "at": at.isoformat(),
|
||
"refs": refs, "input_digest": digest(refs), "events": []}
|
||
async with self.repo.connection.transaction():
|
||
document["batch_sequence"] = sequence
|
||
document["delivered_until"] = at.isoformat()
|
||
await self.repo.save_batch(replay_id, batch)
|
||
await self.repo.save(document)
|
||
else:
|
||
rows = None
|
||
if batch["stage"] == "selected":
|
||
if rows is None:
|
||
# Only crash recovery reloads the selected raw frame.
|
||
at = parse_time(batch["at"])
|
||
async with self.timescale.transaction():
|
||
rows = await ScadaRepository.get_raw_page(
|
||
self.timescale, config.device_ids, at, config.end_time, at, 501,
|
||
) if batch["refs"] else []
|
||
actual = [{"time": row["time"].isoformat(), "device_id": row["device_id"],
|
||
"source_hash": row["source_hash"]} for row in rows]
|
||
if digest(actual) != batch["input_digest"]:
|
||
raise ValueError("SOURCE_CHANGED: selected raw frame differs")
|
||
batch["outputs"] = prepare_cleaning(rows, config)
|
||
batch["stage"] = "clean_prepared"
|
||
async with self.repo.connection.transaction():
|
||
await self.repo.save_batch(replay_id, batch)
|
||
if batch["stage"] == "clean_prepared":
|
||
await ScadaRepository.apply_replay_cleaning(self.timescale, batch["outputs"])
|
||
batch["stage"] = "cleaned"
|
||
async with self.repo.connection.transaction():
|
||
await self.repo.save_batch(replay_id, batch)
|
||
if batch["stage"] == "cleaned":
|
||
result, changes = detect_frame(document, batch["outputs"], config, parse_time(batch["at"]))
|
||
result["processed_until"] = batch["at"]
|
||
target = result.get("step_target")
|
||
was_step = bool(target)
|
||
result["step_pending"] = bool(target and parse_time(batch["at"]) < parse_time(target))
|
||
if was_step:
|
||
signals = {item["event_id"]: item for item in result.get("step_anomaly_signals", [])
|
||
if diagnostic_signal(result, item)}
|
||
for event in changes:
|
||
if event["change"] == "raised" and diagnostic_signal(result, event):
|
||
signals[event["event_id"]] = {key: event[key] for key in (
|
||
"event_id", "rule_id", "device_ids", "detail", "diagnostic_policy"
|
||
) if key in event}
|
||
result["step_anomaly_signals"] = list(signals.values())
|
||
monitoring = None
|
||
if was_step and not result["step_pending"]:
|
||
period_start = parse_time(result.get("step_start", result["start_time"]))
|
||
period_end = parse_time(target)
|
||
role = result.get("monitoring_config") or {}
|
||
role_ids = list(dict.fromkeys(
|
||
role.get("pressure_device_ids", []) + role.get("outlet_flow_device_ids", [])
|
||
))
|
||
previous = await self.repo.monitoring_outputs(
|
||
replay_id, role_ids, period_end - timedelta(days=15),
|
||
period_end, batch["sequence"],
|
||
) if role_ids else []
|
||
from app.mcp.analysis_service import bounded_calculation
|
||
monitoring = await bounded_calculation(
|
||
evaluate_monitoring_period,
|
||
result,
|
||
previous + batch["outputs"],
|
||
period_start=period_start,
|
||
period_end=period_end,
|
||
batch_sequence=batch["sequence"],
|
||
)
|
||
# Any configured measurement rule can enter diagnosis, including
|
||
# indicators outside the pressure/outlet roles used for burst scoring.
|
||
signals = {item["event_id"]: item for item in result.get("step_anomaly_signals", [])
|
||
if diagnostic_signal(result, item)}
|
||
for state in result.get("rule_states", {}).values():
|
||
event = state.get("event")
|
||
if event and diagnostic_signal(result, event):
|
||
signals[event["event_id"]] = {key: event[key] for key in (
|
||
"event_id", "rule_id", "device_ids", "detail", "diagnostic_policy"
|
||
) if key in event}
|
||
monitoring["anomaly_signals"] = list(signals.values())
|
||
if signals and monitoring["status"] == "normal":
|
||
monitoring["status"] = "attention"
|
||
monitoring["detail"] = "本周期曾检出测点异常，进入异常调查与爆管诊断"
|
||
result["monitoring_count"] = result.get("monitoring_count", 0) + 1
|
||
if not result["step_pending"]:
|
||
result.pop("step_target", None)
|
||
result.pop("step_start", None)
|
||
result.pop("step_anomaly_signals", None)
|
||
if batch["refs"]:
|
||
last = batch["refs"][-1]
|
||
result["cursor"] = [last["time"], last["device_id"]]
|
||
if parse_time(batch["at"]) >= config.end_time:
|
||
result["status"] = "completed"
|
||
batch["stage"], batch["events"] = "detected", changes
|
||
if monitoring is not None:
|
||
batch["monitoring"] = monitoring
|
||
async with self.repo.connection.transaction():
|
||
await self._create_investigations(result, changes, batch, create_tasks=not was_step)
|
||
if monitoring is not None:
|
||
await self._create_monitoring_task(result, monitoring, batch)
|
||
batch["monitoring"] = monitoring
|
||
result["last_monitoring"] = monitoring
|
||
await self.repo.save_batch(replay_id, batch)
|
||
await self.repo.save(result)
|
||
|
||
async def _freeze_baseline(self, document, config):
|
||
"""Stage bounded pages, then atomically publish one causal source snapshot."""
|
||
if document.get("warmed"):
|
||
return
|
||
start = config.start_time - timedelta(days=15)
|
||
batch_count, row_count, byte_count, after = 0, 0, 0, None
|
||
counts = {device_id: 0 for device_id in config.device_ids}
|
||
valid_counts = dict(counts)
|
||
histories = {device_id: [] for device_id in config.device_ids}
|
||
window = max(rule.window_samples for rule in config.rules)
|
||
calibration = None
|
||
if (document.get("monitoring_config") or {}).get("decision_policy") == "weighted":
|
||
from app.services.scada_monitoring_calibration import MonitoringCalibrationBuilder
|
||
calibration = MonitoringCalibrationBuilder(document, config)
|
||
async with self.repo.connection.transaction():
|
||
await self.repo.clear_unpublished_baseline(document["replay_id"])
|
||
# Keep only the current page in memory. Each BizDB write commits before
|
||
# the next source read; clean_prepared baseline pages remain invisible.
|
||
async with self.timescale.transaction():
|
||
await ScadaRepository.begin_replay_baseline_snapshot(self.timescale)
|
||
while True:
|
||
rows = await ScadaRepository.get_raw_page(
|
||
self.timescale, config.device_ids, start, config.start_time,
|
||
config.start_time, min(BASELINE_PAGE_SIZE, BASELINE_MAX_ROWS - row_count + 1), after,
|
||
)
|
||
if not rows:
|
||
break
|
||
if row_count + len(rows) > BASELINE_MAX_ROWS:
|
||
raise BaselineBudgetExceeded(
|
||
f"BASELINE_BUDGET_EXCEEDED: 十五天历史基线超过 {BASELINE_MAX_ROWS:,} 条准备预算，"
|
||
"尚未发布；请减少回放设备或核查历史采样密度后重试"
|
||
)
|
||
outputs = prepare_cleaning(rows, config)
|
||
if calibration is not None:
|
||
calibration.add(outputs)
|
||
batch = {
|
||
"sequence": -batch_count - 1, "stage": "clean_prepared", "kind": "baseline",
|
||
"at": outputs[-1]["time"], "outputs": outputs, "events": [],
|
||
}
|
||
batch_bytes = len(json.dumps(batch, ensure_ascii=False, allow_nan=False,
|
||
separators=(",", ":")).encode("utf-8"))
|
||
if byte_count + batch_bytes > BASELINE_MAX_BYTES:
|
||
raise BaselineBudgetExceeded(
|
||
f"BASELINE_BUDGET_EXCEEDED: 十五天历史基线超过 {BASELINE_MAX_BYTES // (1024 * 1024)} MiB 准备预算，"
|
||
"尚未发布；请减少回放设备或核查历史采样密度后重试"
|
||
)
|
||
async with self.repo.connection.transaction():
|
||
await self.repo.save_batch(document["replay_id"], batch)
|
||
batch_count += 1
|
||
row_count += len(outputs)
|
||
byte_count += batch_bytes
|
||
for row in outputs:
|
||
device_id = row["device_id"]
|
||
counts[device_id] += 1
|
||
if row["quality"] == "valid":
|
||
valid_counts[device_id] += 1
|
||
histories[device_id].append(row["cleaned_value"])
|
||
histories[device_id] = histories[device_id][-window:]
|
||
last = rows[-1]
|
||
after = (last["time"], last["device_id"])
|
||
document["baseline"] = {
|
||
"start_time": start.isoformat(), "end_time": config.start_time.isoformat(),
|
||
"end_exclusive": True, "sample_counts": counts, "valid_sample_counts": valid_counts,
|
||
"row_count": row_count, "batch_count": batch_count, "byte_count": byte_count,
|
||
}
|
||
document["histories"] = histories
|
||
if calibration is not None:
|
||
from app.mcp.analysis_service import bounded_calculation
|
||
document["monitoring_calibration"] = await bounded_calculation(calibration.fit)
|
||
document["warmed"] = True
|
||
async with self.repo.connection.transaction():
|
||
await self.repo.publish_baseline(document["replay_id"])
|
||
await self.repo.save(document)
|
||
|
||
async def _create_investigations(self, document, changes, batch, *, create_tasks=True):
|
||
from app.domain.schemas.operational_task import OperationalTaskCreate, TaskSource, TaskTrigger
|
||
from app.infra.db.postgresql.operational_tasks import OperationalTaskRepository
|
||
from app.services.operational_tasks import OperationalTaskService
|
||
from app.domain.schemas.task_alert import TaskAlertEvent
|
||
from app.infra.db.postgresql.task_alerts import TaskAlertRepository
|
||
from app.services.task_alerts import TaskAlertService
|
||
from uuid import UUID
|
||
producer = "scada-replay:" + document["replay_id"]
|
||
alerts = TaskAlertService(TaskAlertRepository(self.repo.connection, self.context.project_id),
|
||
self.context, internal_producer_id=producer)
|
||
tasks = OperationalTaskService(OperationalTaskRepository(self.repo.connection, self.context.project_id),
|
||
self.context, permissions_for_context(self.context))
|
||
for event in changes:
|
||
# Period diagnosis owns measurement notifications during manual steps.
|
||
# Retain rule events as evidence; quality alerts remain independent.
|
||
if (not create_tasks and event.get("category") != "data_quality"
|
||
and (event["change"] == "raised" or event.get("notification_suppressed"))):
|
||
if event["change"] == "raised":
|
||
event["batch_sequence"] = batch["sequence"]
|
||
event["notification_suppressed"] = True
|
||
document["rule_states"][event.get("state_key", event["rule_id"])]["event"].update(
|
||
batch_sequence=batch["sequence"], notification_suppressed=True,
|
||
)
|
||
continue
|
||
if event["change"] == "raised":
|
||
event["batch_sequence"] = batch["sequence"]
|
||
document["rule_states"][event.get("state_key", event["rule_id"])]["event"]["batch_sequence"] = batch["sequence"]
|
||
await alerts.push(TaskAlertEvent(
|
||
event_id=uuid5(NAMESPACE_URL, event["event_id"] + ":" + event["change"]),
|
||
alert_id=event["event_id"], producer_id=producer, event_type=event["change"],
|
||
occurred_at=event["occurred_at"], condition_id=None,
|
||
source={"kind": "scada_replay", "replay_id": document["replay_id"],
|
||
"rule_id": event["rule_id"], "batch_sequence": event["batch_sequence"]},
|
||
title=f"SCADA 回放异常 · {event['rule_id']}", description=event["detail"], severity="warning",
|
||
))
|
||
if event["change"] != "raised":
|
||
if event.get("task_id"):
|
||
await tasks.advance_replay_investigation(UUID(event["task_id"]), {
|
||
"replay_id": document["replay_id"], "knowledge_cutoff": batch["at"],
|
||
"batch_sequence": batch["sequence"],
|
||
}, uuid5(NAMESPACE_URL, event["event_id"] + ":recovery"))
|
||
continue
|
||
if event.get("category") == "data_quality":
|
||
continue
|
||
if not create_tasks:
|
||
continue
|
||
external = f"scada_replay:{document['replay_id']}:event:{event['event_id']}"
|
||
command = OperationalTaskCreate(
|
||
request_id=uuid5(NAMESPACE_URL, external), task_type="event_investigation",
|
||
workflow="scada_anomaly", title=f"SCADA 回放调查 · {event['rule_id']}",
|
||
summary=event["detail"], source=TaskSource(
|
||
kind="external_system", external_id=external, external_revision=1,
|
||
event_kind="scada_anomaly",
|
||
replay_context={"replay_id": document["replay_id"],
|
||
"knowledge_cutoff": batch["at"], "batch_sequence": batch["sequence"]},
|
||
),
|
||
trigger=TaskTrigger(kind="event", occurred_at=event["occurred_at"], detail="已存 SCADA 历史的回放检测信号，原因尚待调查"),
|
||
)
|
||
task = await tasks.create(command)
|
||
event["task_id"] = str(task.task_id)
|
||
document["rule_states"][event.get("state_key", event["rule_id"])]["event"]["task_id"] = event["task_id"]
|
||
|
||
async def _create_monitoring_task(self, document, monitoring, batch):
|
||
from app.services.scada_monitoring_incidents import attach_incident, update_incident
|
||
incident, action = update_incident(document, monitoring, batch["sequence"])
|
||
if incident is None:
|
||
return
|
||
if incident.get("task_id"):
|
||
if monitoring["status"] == "suspected_burst" and not incident.get("burst_diagnosed"):
|
||
from uuid import UUID
|
||
from app.infra.db.postgresql.operational_tasks import OperationalTaskRepository
|
||
from app.services.operational_tasks import OperationalTaskService
|
||
tasks = OperationalTaskService(
|
||
OperationalTaskRepository(self.repo.connection, self.context.project_id),
|
||
self.context, permissions_for_context(self.context),
|
||
)
|
||
await tasks.advance_replay_investigation(UUID(incident["task_id"]), {
|
||
"replay_id": document["replay_id"], "knowledge_cutoff": monitoring["knowledge_cutoff"],
|
||
"batch_sequence": batch["sequence"],
|
||
}, uuid5(NAMESPACE_URL, incident["incident_id"] + ":burst-evidence"))
|
||
incident["burst_diagnosed"] = True
|
||
if action == "resolved" and incident.get("alert"):
|
||
await self._publish_monitoring_alert(document, incident, "resolved")
|
||
attach_incident(monitoring, incident, action)
|
||
return
|
||
from app.domain.schemas.operational_task import OperationalTaskCreate, TaskSource, TaskTrigger
|
||
from app.infra.db.postgresql.operational_tasks import OperationalTaskRepository
|
||
from app.services.operational_tasks import OperationalTaskService
|
||
tasks = OperationalTaskService(
|
||
OperationalTaskRepository(self.repo.connection, self.context.project_id),
|
||
self.context,
|
||
permissions_for_context(self.context),
|
||
)
|
||
external = incident["external_id"]
|
||
pressure = monitoring["pressure"]
|
||
flow = monitoring["outlet_flow"]
|
||
detector = monitoring["burst_detection"]
|
||
score = detector.get("target_score")
|
||
score_text = f"{score:.4f}" if score is not None else "数据不足"
|
||
summary = (
|
||
f"SCADA 数据诊断发现指标异常，进入异常调查与爆管诊断。"
|
||
f"爆管侦测得分 {score_text}；"
|
||
f"压力下降测点 {len(pressure.get('hit_device_ids', []))} 个；"
|
||
f"出厂边界流量增加测点 {len(flow.get('hit_device_ids', []))} 个。"
|
||
"任一指标异常即启动调查，加权分仅用于评估爆管嫌疑，不能据此提前确诊。"
|
||
)
|
||
if monitoring.get("anomaly_signals"):
|
||
signals = monitoring["anomaly_signals"]
|
||
devices = {device for item in signals for device in item.get("device_ids", [])}
|
||
summary += f" 单项异常 {len(signals)} 项，涉及 {len(devices)} 个测点；明细通过冻结 SCADA 查询核验。"
|
||
if monitoring.get("weighted"):
|
||
weighted = monitoring["weighted"]
|
||
weights = weighted["weights"]
|
||
summary += (
|
||
f" 综合评分 {weighted['score']:.2f}，爆管嫌疑门槛 {weighted['threshold']:.2f}"
|
||
f"（侦测 {weights['burst_detection']:.0%}、压力 {weights['pressure']:.0%}、"
|
||
f"流量 {weights['outlet_flow']:.0%}）。"
|
||
)
|
||
if detector.get("score_threshold") is not None:
|
||
summary += f" 侦测动态阈值 {detector['score_threshold']:.4f}。"
|
||
command = OperationalTaskCreate(
|
||
request_id=uuid5(NAMESPACE_URL, external),
|
||
task_type="event_investigation",
|
||
workflow="scada_anomaly",
|
||
title=f"SCADA 异常调查 · {monitoring['period_end']}",
|
||
summary=summary,
|
||
source=TaskSource(
|
||
kind="external_system",
|
||
external_id=external,
|
||
external_revision=1,
|
||
event_kind="scada_anomaly",
|
||
replay_context={
|
||
"replay_id": document["replay_id"],
|
||
"knowledge_cutoff": monitoring["knowledge_cutoff"],
|
||
"batch_sequence": batch["sequence"],
|
||
},
|
||
),
|
||
trigger=TaskTrigger(
|
||
kind="event",
|
||
occurred_at=monitoring["period_end"],
|
||
detail="SCADA 任一指标异常启动调查，核验数据后进行爆管诊断；异常不等于已确诊爆管",
|
||
),
|
||
)
|
||
task = await tasks.create(command)
|
||
incident["task_id"] = str(task.task_id)
|
||
incident["burst_diagnosed"] = monitoring["status"] == "suspected_burst"
|
||
incident["alert"] = {
|
||
"alert_id": incident["incident_id"],
|
||
"producer_id": "scada-replay:" + document["replay_id"],
|
||
"occurred_at": incident["started_at"],
|
||
"condition_id": f"operational-task:{task.task_id}",
|
||
"source": {"kind": "scada_replay", "replay_id": document["replay_id"],
|
||
"rule_id": "scada_diagnosis", "batch_sequence": batch["sequence"]},
|
||
"title": "SCADA 指标异常", "description": "已启动调查，详细诊断见调查报告。", "severity": "warning",
|
||
}
|
||
await self._publish_monitoring_alert(document, incident, "raised")
|
||
attach_incident(monitoring, incident, action)
|
||
|
||
async def _publish_monitoring_alert(self, document, incident, change):
|
||
from app.domain.schemas.task_alert import TaskAlertEvent
|
||
from app.infra.db.postgresql.task_alerts import TaskAlertRepository
|
||
from app.services.task_alerts import TaskAlertService
|
||
alerts = TaskAlertService(
|
||
TaskAlertRepository(self.repo.connection, self.context.project_id), self.context,
|
||
internal_producer_id="scada-replay:" + document["replay_id"],
|
||
)
|
||
await alerts.push(TaskAlertEvent(
|
||
**incident["alert"], event_type=change,
|
||
event_id=uuid5(NAMESPACE_URL, incident["incident_id"] + ":" + change),
|
||
))
|