同步已上线的智能分析执行协议、来源查询、图表报告与管理页面配套代码。 补齐数据库迁移、运行依赖和回归测试,保留原有指标计算口径。 统一午夜黑及其他主题的控件细节、中文和业务数字字体。 排除本地业务数据、凭据、预览、发布与验收产物。 验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
431 lines
23 KiB
Python
431 lines
23 KiB
Python
"""Offline isolation checks for concurrent NAO actor sessions; never calls a model."""
|
|
from __future__ import annotations
|
|
|
|
import contextlib
|
|
import json
|
|
import os
|
|
import sqlite3
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
import unittest
|
|
import uuid
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
|
|
import nao_quality_runtime as runtime
|
|
import nao_quality_runtime_mcp as runtime_mcp
|
|
|
|
|
|
class WaitingResponse:
|
|
def __init__(self):
|
|
self.closed = threading.Event()
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, *_):
|
|
self.close()
|
|
|
|
def __iter__(self):
|
|
self.closed.wait(0.5)
|
|
return iter(())
|
|
|
|
def close(self):
|
|
self.closed.set()
|
|
|
|
|
|
class WaitingClient:
|
|
def open(self, *_args, **_kwargs):
|
|
return WaitingResponse()
|
|
|
|
|
|
class SessionIsolationTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temp = tempfile.TemporaryDirectory(prefix="test-nao-users-")
|
|
self.users = Path(self.temp.name).resolve()
|
|
self.manager = runtime.RuntimeManager(users_root=self.users)
|
|
self.actor_id = str(uuid.uuid4())
|
|
self.actor_b = str(uuid.uuid4())
|
|
self.session_a = str(uuid.uuid4())
|
|
self.session_b = str(uuid.uuid4())
|
|
self.release_a = str(uuid.uuid4())
|
|
self.release_b = str(uuid.uuid4())
|
|
|
|
def tearDown(self):
|
|
self.temp.cleanup()
|
|
|
|
def test_same_actor_sessions_have_independent_roots_locks_credentials_and_mcp_paths(self):
|
|
root_a, lock_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
root_b, lock_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
|
try:
|
|
self.assertEqual(root_a, self.users / self.actor_id / "sessions" / self.session_a)
|
|
self.assertEqual(root_b, self.users / self.actor_id / "sessions" / self.session_b)
|
|
self.assertNotEqual(root_a, root_b)
|
|
self.assertNotEqual(root_a / "active.lock", root_b / "active.lock")
|
|
|
|
access_a = runtime.write_access_file(root_a, "token-session-A", self.release_a,
|
|
expected_actor_id=self.actor_id,
|
|
expected_session_id=self.session_a)
|
|
access_b = runtime.write_access_file(root_b, "token-session-B", self.release_b,
|
|
expected_actor_id=self.actor_id,
|
|
expected_session_id=self.session_b)
|
|
snapshot_a = runtime.load_access_snapshot(
|
|
access_a, runtime_root=self.users, expected_actor_id=self.actor_id,
|
|
expected_session_id=self.session_a,
|
|
)
|
|
snapshot_b = runtime.load_access_snapshot(
|
|
access_b, runtime_root=self.users, expected_actor_id=self.actor_id,
|
|
expected_session_id=self.session_b,
|
|
)
|
|
self.assertEqual((snapshot_a.actor_id, snapshot_a.token, snapshot_a.release_id),
|
|
(self.actor_id, "token-session-A", self.release_a))
|
|
self.assertEqual((snapshot_b.actor_id, snapshot_b.token, snapshot_b.release_id),
|
|
(self.actor_id, "token-session-B", self.release_b))
|
|
self.assertNotEqual(access_a, access_b)
|
|
|
|
runtime._write_private_state(root_a)
|
|
runtime._write_private_state(root_b)
|
|
runtime._write_project(root_a, self.session_a, "test-model", refresh_templates=True,
|
|
refresh_mcp=True, backup_schema=False,
|
|
expected_actor_id=self.actor_id)
|
|
runtime._write_project(root_b, self.session_b, "test-model", refresh_templates=True,
|
|
refresh_mcp=True, backup_schema=False,
|
|
expected_actor_id=self.actor_id)
|
|
mcp_a = json.loads((root_a / "project/agent/mcps/mcp.json").read_text())
|
|
mcp_b = json.loads((root_b / "project/agent/mcps/mcp.json").read_text())
|
|
env_a = mcp_a["mcpServers"]["quality"]["env"]
|
|
env_b = mcp_b["mcpServers"]["quality"]["env"]
|
|
self.assertEqual(env_a["QUALITY_AGENT_ACTOR_ID"], self.actor_id)
|
|
self.assertEqual(env_b["QUALITY_AGENT_ACTOR_ID"], self.actor_id)
|
|
self.assertEqual(env_a["QUALITY_AGENT_SESSION_ID"], self.session_a)
|
|
self.assertEqual(env_b["QUALITY_AGENT_SESSION_ID"], self.session_b)
|
|
self.assertEqual(env_a["QUALITY_AGENT_ACCESS_FILE"], str(access_a))
|
|
self.assertEqual(env_b["QUALITY_AGENT_ACCESS_FILE"], str(access_b))
|
|
self.assertNotEqual(env_a["QUALITY_AGENT_SESSION_STATE_FILE"],
|
|
env_b["QUALITY_AGENT_SESSION_STATE_FILE"])
|
|
self.assertNotEqual(runtime._write_private_state(root_a), runtime._write_private_state(root_b))
|
|
finally:
|
|
self.manager.release_actor(lock_a)
|
|
self.manager.release_actor(lock_b)
|
|
# flock files are stable coordination objects and are never unlinked.
|
|
self.assertTrue((root_a / "active.lock").is_file())
|
|
self.assertTrue((root_b / "active.lock").is_file())
|
|
|
|
def test_same_session_is_mutually_exclusive_but_other_session_and_actor_can_run(self):
|
|
_root_a, lock_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
root_b, lock_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
|
root_c, lock_c = self.manager.acquire_actor(self.actor_b, self.session_a)
|
|
try:
|
|
self.assertNotEqual(root_b, root_c)
|
|
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "另一轮分析"):
|
|
self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
finally:
|
|
self.manager.release_actor(lock_c)
|
|
self.manager.release_actor(lock_b)
|
|
self.manager.release_actor(lock_a)
|
|
_again, lock_again = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
self.manager.release_actor(lock_again)
|
|
|
|
def test_access_snapshot_rejects_actor_session_mismatch_and_symlink(self):
|
|
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
try:
|
|
access = runtime.write_access_file(root_a, "strict-token", self.release_a,
|
|
expected_actor_id=self.actor_id,
|
|
expected_session_id=self.session_a)
|
|
with self.assertRaisesRegex(ValueError, "当前会话"):
|
|
runtime.load_access_snapshot(access, runtime_root=self.users,
|
|
expected_actor_id=self.actor_b,
|
|
expected_session_id=self.session_a)
|
|
with self.assertRaisesRegex(ValueError, "路径与当前会话"):
|
|
runtime.load_access_snapshot(access, runtime_root=self.users,
|
|
expected_actor_id=self.actor_id,
|
|
expected_session_id=self.session_b)
|
|
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "actor/session"):
|
|
runtime.write_access_file(root_a, "wrong-owner", self.release_a,
|
|
expected_actor_id=self.actor_b,
|
|
expected_session_id=self.session_a)
|
|
link = root_a / "linked-access.json"
|
|
link.symlink_to(access)
|
|
with self.assertRaisesRegex(ValueError, "路径无效"):
|
|
runtime.load_access_snapshot(link, runtime_root=self.users,
|
|
expected_actor_id=self.actor_id,
|
|
expected_session_id=self.session_a)
|
|
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "actor/session"):
|
|
runtime._write_project(root_a, self.session_a, "test-model", refresh_templates=False,
|
|
refresh_mcp=False, backup_schema=False,
|
|
expected_actor_id=self.actor_b)
|
|
finally:
|
|
self.manager.release_actor(fd_a)
|
|
|
|
def test_mcp_shim_accepts_only_fixed_actor_session_paths(self):
|
|
fake_root = self.users / "fake-project"
|
|
users_root = fake_root / ".runtime" / "nao-users"
|
|
session_root = users_root / self.actor_id / "sessions" / self.session_a
|
|
session_root.mkdir(parents=True)
|
|
environment = {
|
|
"QUALITY_AGENT_USERS_ROOT": str(users_root),
|
|
"QUALITY_AGENT_ACCESS_FILE": str(session_root / "access.json"),
|
|
"QUALITY_AGENT_EVIDENCE_DIR": str(session_root / "evidence"),
|
|
"QUALITY_AGENT_SESSION_STATE_FILE": str(session_root / "private" / "current-session.json"),
|
|
"QUALITY_AGENT_ACTOR_ID": self.actor_id,
|
|
"QUALITY_AGENT_SESSION_ID": self.session_a,
|
|
}
|
|
with patch.object(runtime_mcp, "ROOT", fake_root), patch.dict(os.environ, environment, clear=False):
|
|
access, evidence, state, actor, session, root = runtime_mcp._paths()
|
|
self.assertEqual(access, session_root / "access.json")
|
|
self.assertEqual(evidence, session_root / "evidence")
|
|
self.assertEqual(state, session_root / "private" / "current-session.json")
|
|
self.assertEqual((actor, session), (self.actor_id, self.session_a))
|
|
self.assertEqual(root, users_root.resolve())
|
|
os.environ["QUALITY_AGENT_ACCESS_FILE"] = str(users_root / self.actor_id / "access.json")
|
|
with self.assertRaisesRegex(ValueError, "路径无效"):
|
|
runtime_mcp._paths()
|
|
|
|
def test_cancel_stops_only_the_current_session_chat(self):
|
|
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
|
try:
|
|
state_a = runtime.SessionState(root_a, self.actor_id, self.session_a)
|
|
state_b = runtime.SessionState(root_b, self.actor_id, self.session_b)
|
|
state_a.set_chat_id(self.session_a, "native-chat-A")
|
|
state_b.set_chat_id(self.session_b, "native-chat-B")
|
|
cancel = threading.Event()
|
|
cancel.set()
|
|
stopped = []
|
|
|
|
def stop_native(_client, _base, chat_id):
|
|
stopped.append(chat_id)
|
|
return True
|
|
|
|
with patch.object(runtime, "_stop_native",
|
|
side_effect=lambda _client, _base, chat_id: stopped.append(chat_id) or True):
|
|
result = runtime._sse_request(
|
|
client=WaitingClient(), base_url="http://127.0.0.1:10000", model="offline-test",
|
|
question="q", release_id=self.release_a, context=None,
|
|
chat_id=state_a.get_chat_id(self.session_a), session_state=state_a,
|
|
session_id=self.session_a, actor_root=root_a, emit=lambda _event: None,
|
|
cancel_event=cancel, timeout=5,
|
|
)
|
|
self.assertEqual(result[1], "CANCELLED")
|
|
self.assertEqual(stopped, ["native-chat-A"])
|
|
self.assertEqual(state_b.get_chat_id(self.session_b), "native-chat-B")
|
|
self.assertFalse((root_b / "instance.json").exists())
|
|
finally:
|
|
self.manager.release_actor(fd_b)
|
|
self.manager.release_actor(fd_a)
|
|
|
|
def test_stop_instance_only_targets_processes_recorded_in_that_session(self):
|
|
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
|
try:
|
|
for root, session_id, pids, port in (
|
|
(root_a, self.session_a, [10101, 10102], 41001),
|
|
(root_b, self.session_b, [20201, 20202], 42001),
|
|
):
|
|
runtime._atomic_json(root / "instance.json", {
|
|
"actorId": self.actor_id, "sessionId": session_id,
|
|
"processes": [{"pid": pid, "pgid": pid, "lstart": "simulated",
|
|
"kind": "server", "port": port + index}
|
|
for index, pid in enumerate(pids)],
|
|
})
|
|
killed = []
|
|
|
|
def matches(record, runtime_root):
|
|
return runtime_root == root_a and record.get("pid") in (10101, 10102)
|
|
|
|
with patch.object(runtime, "_process_matches", side_effect=matches), \
|
|
patch.object(runtime, "_ps_value", return_value="simulated process"), \
|
|
patch.object(runtime.os, "killpg", side_effect=lambda pgid, _sig: killed.append(pgid)), \
|
|
patch.object(runtime.time, "sleep"):
|
|
runtime._stop_instance(root_a, grace_seconds=0)
|
|
self.assertEqual(set(killed), {10101, 10102})
|
|
self.assertTrue((root_b / "instance.json").is_file())
|
|
finally:
|
|
self.manager.release_actor(fd_b)
|
|
self.manager.release_actor(fd_a)
|
|
|
|
def test_stop_all_skips_active_session_and_scans_legacy_and_idle_sessions(self):
|
|
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
|
legacy = self.users / self.actor_b
|
|
legacy.mkdir(parents=True)
|
|
runtime._atomic_json(legacy / "instance.json", {"actorId": self.actor_b, "processes": []})
|
|
for root in (root_a, root_b, legacy):
|
|
runtime._atomic_json(root / "access.json", {"token": "private"})
|
|
self.manager.release_actor(fd_b)
|
|
try:
|
|
stopped = []
|
|
manager = self.manager
|
|
with patch.object(runtime, "_stop_instance", side_effect=lambda root: stopped.append(root) or True):
|
|
count = manager.stop_idle_all()
|
|
self.assertEqual(count, 2)
|
|
self.assertEqual(set(stopped), {root_b, legacy})
|
|
self.assertTrue((root_a / "access.json").exists())
|
|
self.assertFalse((root_b / "access.json").exists())
|
|
self.assertFalse((legacy / "access.json").exists())
|
|
self.assertIn(legacy, runtime._runtime_roots(self.users))
|
|
self.assertIn(root_a, runtime._runtime_roots(self.users))
|
|
finally:
|
|
self.manager.release_actor(fd_a)
|
|
|
|
def test_project_template_symlink_cannot_write_into_another_session(self):
|
|
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
|
try:
|
|
project_a = root_a / "project"
|
|
project_a.mkdir()
|
|
project_b = root_b / "project"
|
|
project_b.mkdir()
|
|
protected_config = project_b / "nao_config.yaml"
|
|
protected_config.write_text("session B config", encoding="utf-8")
|
|
(project_a / "nao_config.yaml").symlink_to(protected_config)
|
|
with self.assertRaisesRegex(ValueError, "运行路径无效"):
|
|
runtime._write_project(root_a, self.session_a, "test-model", refresh_templates=True,
|
|
refresh_mcp=True, backup_schema=False,
|
|
expected_actor_id=self.actor_id)
|
|
self.assertEqual(protected_config.read_text(encoding="utf-8"), "session B config")
|
|
finally:
|
|
self.manager.release_actor(fd_b)
|
|
self.manager.release_actor(fd_a)
|
|
|
|
def test_server_log_open_rejects_symlink_and_non_regular_files(self):
|
|
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
|
try:
|
|
logs_a = root_a / "logs"
|
|
logs_b = root_b / "logs"
|
|
logs_a.mkdir()
|
|
logs_b.mkdir()
|
|
protected_log = logs_b / "server.log"
|
|
protected_log.write_text("session B log", encoding="utf-8")
|
|
(logs_a / "server.log").symlink_to(protected_log)
|
|
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "日志文件路径无效"):
|
|
runtime._open_server_log(logs_a / "server.log", root_a)
|
|
self.assertEqual(protected_log.read_text(encoding="utf-8"), "session B log")
|
|
|
|
(logs_a / "server.log").unlink()
|
|
fifo = logs_a / "server.log"
|
|
os.mkfifo(fifo)
|
|
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "日志文件路径无效"):
|
|
runtime._open_server_log(fifo, root_a)
|
|
finally:
|
|
self.manager.release_actor(fd_b)
|
|
self.manager.release_actor(fd_a)
|
|
|
|
def test_legacy_session_history_is_copied_to_private_root_without_changing_source(self):
|
|
actor_root = self.users / self.actor_id
|
|
legacy_private = actor_root / "private"
|
|
legacy_private.mkdir(parents=True)
|
|
mapping = legacy_private / "sessions.json"
|
|
runtime._atomic_json(mapping, {
|
|
"actorId": self.actor_id,
|
|
"sessions": {self.session_a: "old-native-chat-A", self.session_b: "old-native-chat-B"},
|
|
})
|
|
mapping_before = mapping.read_bytes()
|
|
runtime._atomic_json(legacy_private / "credentials.json", {
|
|
"authSecret": "legacy-auth", "email": "legacy@example.invalid", "password": "legacy-password",
|
|
})
|
|
legacy_project = actor_root / "project"
|
|
legacy_project.mkdir(parents=True)
|
|
source_db = legacy_private / "nao.sqlite"
|
|
with contextlib.closing(sqlite3.connect(source_db)) as database:
|
|
with database:
|
|
# Mirrors NAO's actual SQLite project.path and chat.project_id
|
|
# relationship used by agent routes and MCP project lookup.
|
|
database.executescript("""
|
|
CREATE TABLE project (
|
|
id TEXT PRIMARY KEY NOT NULL,
|
|
org_id TEXT,
|
|
name TEXT NOT NULL,
|
|
type TEXT NOT NULL,
|
|
path TEXT,
|
|
agent_settings TEXT,
|
|
enabled_tools TEXT NOT NULL DEFAULT '[]',
|
|
known_mcp_servers TEXT NOT NULL DEFAULT '[]',
|
|
disabled_mcp_servers TEXT NOT NULL DEFAULT '[]',
|
|
disabled_mcp_tools TEXT NOT NULL DEFAULT '[]',
|
|
env_vars TEXT NOT NULL DEFAULT '{}',
|
|
CONSTRAINT local_project_path_required
|
|
CHECK(CASE WHEN type = 'local' THEN path IS NOT NULL ELSE TRUE END)
|
|
);
|
|
CREATE TABLE chat (
|
|
id TEXT PRIMARY KEY NOT NULL,
|
|
user_id TEXT NOT NULL,
|
|
project_id TEXT NOT NULL REFERENCES project(id),
|
|
title TEXT DEFAULT 'New Conversation' NOT NULL,
|
|
is_starred INTEGER DEFAULT false NOT NULL,
|
|
deleted_at INTEGER,
|
|
slack_thread_id TEXT,
|
|
teams_thread_id TEXT,
|
|
telegram_thread_id TEXT,
|
|
mattermost_thread_id TEXT,
|
|
discord_thread_id TEXT,
|
|
whatsapp_thread_id TEXT,
|
|
fork_metadata TEXT,
|
|
created_at INTEGER NOT NULL,
|
|
updated_at INTEGER NOT NULL
|
|
);
|
|
""")
|
|
database.execute(
|
|
"INSERT INTO project(id,name,type,path) VALUES (?,?,?,?)",
|
|
("legacy-project-id", "Quality", "local", str(legacy_project)),
|
|
)
|
|
database.executemany(
|
|
"INSERT INTO chat(id,user_id,project_id,created_at,updated_at) VALUES (?,?,?,?,?)",
|
|
(("old-native-chat-A", "legacy-user", "legacy-project-id", 1, 1),
|
|
("old-native-chat-B", "legacy-user", "legacy-project-id", 2, 2)),
|
|
)
|
|
source_db.chmod(0o600)
|
|
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
|
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
|
try:
|
|
self.assertTrue(self.manager._migrate_legacy_session(self.actor_id, self.session_a, root_a))
|
|
self.assertTrue(self.manager._migrate_legacy_session(self.actor_id, self.session_b, root_b))
|
|
state = runtime.SessionState(root_a, self.actor_id, self.session_a)
|
|
other_state = runtime.SessionState(root_b, self.actor_id, self.session_b)
|
|
self.assertEqual(state.get_chat_id(self.session_a), "old-native-chat-A")
|
|
self.assertEqual(other_state.get_chat_id(self.session_b), "old-native-chat-B")
|
|
self.assertNotEqual(root_a / "private" / "nao.sqlite", source_db)
|
|
with contextlib.closing(sqlite3.connect(root_a / "private" / "nao.sqlite")) as database:
|
|
self.assertEqual(database.execute(
|
|
"SELECT id,path FROM project WHERE id='legacy-project-id'"
|
|
).fetchone(), ("legacy-project-id", str(root_a / "project")))
|
|
self.assertEqual(database.execute(
|
|
"SELECT id,project_id FROM chat WHERE id='old-native-chat-A'"
|
|
).fetchone(), ("old-native-chat-A", "legacy-project-id"))
|
|
self.assertEqual(database.execute(
|
|
"SELECT id,project_id FROM chat WHERE id='old-native-chat-B'"
|
|
).fetchone(), ("old-native-chat-B", "legacy-project-id"))
|
|
with contextlib.closing(sqlite3.connect(root_b / "private" / "nao.sqlite")) as database:
|
|
with database:
|
|
database.execute(
|
|
"INSERT INTO chat(id,user_id,project_id,created_at,updated_at) VALUES (?,?,?,?,?)",
|
|
("session-B-only", "legacy-user", "legacy-project-id", 3, 3),
|
|
)
|
|
self.assertEqual(database.execute(
|
|
"SELECT id,path FROM project WHERE id='legacy-project-id'"
|
|
).fetchone(), ("legacy-project-id", str(root_b / "project")))
|
|
with contextlib.closing(sqlite3.connect(root_a / "private" / "nao.sqlite")) as database:
|
|
rows = database.execute("SELECT id FROM chat ORDER BY id").fetchall()
|
|
self.assertEqual(rows, [("old-native-chat-A",), ("old-native-chat-B",)])
|
|
with contextlib.closing(sqlite3.connect(source_db)) as database:
|
|
self.assertEqual(database.execute(
|
|
"SELECT id,path FROM project WHERE id='legacy-project-id'"
|
|
).fetchone(), ("legacy-project-id", str(legacy_project)))
|
|
self.assertEqual(database.execute(
|
|
"SELECT id,project_id FROM chat WHERE id='old-native-chat-A'"
|
|
).fetchone(), ("old-native-chat-A", "legacy-project-id"))
|
|
self.assertEqual(mapping.read_bytes(), mapping_before)
|
|
self.assertTrue(source_db.is_file())
|
|
self.assertEqual(runtime._read_json(root_a / "private" / "credentials.json")["authSecret"],
|
|
"legacy-auth")
|
|
finally:
|
|
self.manager.release_actor(fd_b)
|
|
self.manager.release_actor(fd_a)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|