fix(chv): 生产级审核 P1-01～P1-10 修复（堆叠于 #270 之上）
This commit is contained in:
muse-agent committed
1 parent
8c8d62f70d
commit
971e054938
12 files changed
+1545
-120
No files matched your search
@@ -0,0 +1,730 @@
|
||||
"""CHV 生产级审核 P1 修复轨（feat-chv-p1fix，堆叠于 #270 之上）测试。
|
||||
|
||||
逐项对应审核报告 §5 的 P1-01～P1-10（P1-10 是文档项，
|
||||
无代码测试；文档数字见 docs/chv-production-readiness.md
|
||||
§15 与 docs/chv-architecture.md 头范围）：
|
||||
- P1-01：生产 reconcile 失败项不进 cleaned、不清库、
|
||||
落盘保留失败项原始条目、可重试；实验池同款语义。
|
||||
- P1-02：registry 损坏与非法条目发审计并计数，损坏不
|
||||
静默返回空。
|
||||
- P1-03：残留私钥删失败发审计、写脏标记，调用方可区分
|
||||
成功与失败（failed VM 不进 cleaned）。
|
||||
- P1-04：build_ssh_command 删除回环回落，构造失败即抛；
|
||||
显式回环（CHV_SSH_HOST / CHV_SSH_FORWARD=1）仍可用。
|
||||
- P1-05：state_dir flock（locking.StateLock）——线程内
|
||||
互斥、跨进程互斥、wake 全程串行化、purge 快照遍历。
|
||||
- P1-06：单条快照超总量帽时拒绝记录，且不删旧快照、
|
||||
不落盘新条目。
|
||||
- P1-07：CHV_CPU / CHV_MEM / CHV_TASK_TIMEOUT 的 >0
|
||||
校验（config 构造层 + preflight 事后改写兜底）。
|
||||
- P1-08：快照保留期剪枝删失败发审计；snapshot_vm 失败
|
||||
路径发 vm_snapshot_failed 审计。
|
||||
- P1-09：4 处三元 else 分支——str 形态 pause/resume/
|
||||
snapshot + 非 dict spill task。
|
||||
|
||||
全部用标准库与 mock runner/launcher/api_client，绝不启动
|
||||
真实 VM（本机无 /dev/kvm，真机验证仍是未验证项）。
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import time
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest import mock
|
||||
|
||||
try:
|
||||
from cloud.chv import (
|
||||
ChvFailure,
|
||||
CloudHypervisorExecutor,
|
||||
reconcile_orphans_for_executor,
|
||||
)
|
||||
from cloud.chv.config import build_chv_config
|
||||
from cloud.chv.disk import (
|
||||
prune_snapshots,
|
||||
record_snapshot,
|
||||
)
|
||||
from cloud.chv.locking import StateLock, lock_path_for_state_dir
|
||||
except ImportError: # discover -s cloud/tests 时把项目根目录补进 sys.path
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
|
||||
from cloud.chv import (
|
||||
ChvFailure,
|
||||
CloudHypervisorExecutor,
|
||||
reconcile_orphans_for_executor,
|
||||
)
|
||||
from cloud.chv.config import build_chv_config
|
||||
from cloud.chv.disk import (
|
||||
prune_snapshots,
|
||||
record_snapshot,
|
||||
)
|
||||
from cloud.chv.locking import StateLock, lock_path_for_state_dir
|
||||
|
||||
|
||||
class FakeResult:
|
||||
def __init__(self, returncode=0, stdout="", stderr=""):
|
||||
self.returncode = returncode
|
||||
self.stdout = stdout
|
||||
self.stderr = stderr
|
||||
|
||||
|
||||
class FakeProc:
|
||||
def __init__(self, alive=True):
|
||||
self._alive = alive
|
||||
|
||||
def poll(self):
|
||||
return None if self._alive else 1
|
||||
|
||||
def terminate(self):
|
||||
self._alive = False
|
||||
|
||||
def wait(self, timeout=None):
|
||||
return 0
|
||||
|
||||
def kill(self):
|
||||
self._alive = False
|
||||
|
||||
|
||||
def _write(path, content=b"x"):
|
||||
with open(path, "wb") as fh:
|
||||
fh.write(content)
|
||||
os.chmod(path, 0o755)
|
||||
return path
|
||||
|
||||
|
||||
class P1FixCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.tmp = tempfile.TemporaryDirectory()
|
||||
self.dir = self.tmp.name
|
||||
self.binary = _write(os.path.join(self.dir, "cloud-hypervisor"))
|
||||
self.ch_remote = _write(os.path.join(self.dir, "ch-remote"))
|
||||
self.kernel = _write(os.path.join(self.dir, "vmlinux"))
|
||||
self.rootfs = _write(os.path.join(self.dir, "disk.raw"),
|
||||
b"R" * 100)
|
||||
self.ssh_key = _write(os.path.join(self.dir, "id_chv"))
|
||||
self.kvm = _write(os.path.join(self.dir, "kvm"))
|
||||
self.cpuinfo = os.path.join(self.dir, "cpuinfo")
|
||||
with open(self.cpuinfo, "w") as fh:
|
||||
fh.write("flags : fpu vmx sse\n")
|
||||
self.state_dir = os.path.join(self.dir, "state")
|
||||
self.calls = []
|
||||
self.audit = []
|
||||
|
||||
def tearDown(self):
|
||||
self.tmp.cleanup()
|
||||
|
||||
def make_exec(self, runner=None, api_client=None, launcher=None,
|
||||
env_extra=None, **overrides):
|
||||
env = {"CHV_EGRESS_PROXY": "http://10.0.0.1:8888",
|
||||
"CHV_SSH_FORWARD": "1",
|
||||
"CHV_HOST_KEY_MODE": "keyscan"}
|
||||
if env_extra:
|
||||
env.update(env_extra)
|
||||
if runner is None:
|
||||
runner = self._default_runner
|
||||
if api_client is None:
|
||||
api_client = self._default_api
|
||||
if launcher is None:
|
||||
launcher = self._default_launcher
|
||||
kwargs = dict(
|
||||
binary=self.binary, ch_remote=self.ch_remote,
|
||||
kernel=self.kernel, rootfs=self.rootfs,
|
||||
ssh_key=self.ssh_key, kvm_path=self.kvm,
|
||||
cpuinfo_path=self.cpuinfo, state_dir=self.state_dir,
|
||||
runner=runner, launcher=launcher, api_client=api_client,
|
||||
sleeper=lambda s: None, env=env)
|
||||
kwargs.update(overrides)
|
||||
ex = CloudHypervisorExecutor(**kwargs)
|
||||
ex.audit_callback = lambda *a: self.audit.append(a)
|
||||
return ex
|
||||
|
||||
def _default_runner(self, cmd, timeout=None):
|
||||
self.calls.append(list(cmd))
|
||||
return FakeResult(0, "", "")
|
||||
|
||||
def _default_api(self, socket_path, method, path, payload=None):
|
||||
return (200, {})
|
||||
|
||||
def _default_launcher(self, cmd):
|
||||
return FakeProc(alive=True)
|
||||
|
||||
def _task(self, task_id="abc123"):
|
||||
return {"id": task_id, "prompt": "x", "project_id": "proj1"}
|
||||
|
||||
def _audit_events(self):
|
||||
return [a[0] for a in self.audit]
|
||||
|
||||
|
||||
# -- P1-01 / P1-02：生产 reconcile --------------------------------------
|
||||
|
||||
class FakeProdExecutor:
|
||||
def __init__(self, state_dir, fail_vms=()):
|
||||
self.state_dir = state_dir
|
||||
self.fail_vms = set(fail_vms)
|
||||
self.shutdowns = []
|
||||
self.emits = []
|
||||
|
||||
def shutdown_vm(self, vm):
|
||||
self.shutdowns.append(vm)
|
||||
if vm in self.fail_vms:
|
||||
raise RuntimeError("shutdown down")
|
||||
|
||||
def _emit(self, event, task, detail):
|
||||
self.emits.append(event)
|
||||
|
||||
|
||||
def _write_registry(state_dir, data):
|
||||
path = os.path.join(state_dir, "warm-pool.json")
|
||||
os.makedirs(state_dir, exist_ok=True)
|
||||
if isinstance(data, str):
|
||||
with open(path, "w") as fh:
|
||||
fh.write(data)
|
||||
else:
|
||||
with open(path, "w") as fh:
|
||||
json.dump(data, fh)
|
||||
return path
|
||||
|
||||
|
||||
class ReconcileP1FixTest(unittest.TestCase):
|
||||
def test_failure_not_cleaned_registry_retained_and_retryable(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
path = _write_registry(d, {
|
||||
"a": {"state": "warm", "vm": "chv-good"},
|
||||
"b": {"state": "warm", "vm": "chv-bad"},
|
||||
})
|
||||
ex = FakeProdExecutor(d, fail_vms={"chv-bad"})
|
||||
self.assertEqual(reconcile_orphans_for_executor(ex),
|
||||
["chv-good"])
|
||||
self.assertIn("warm_pool_reconcile_failed", ex.emits)
|
||||
with open(path) as fh:
|
||||
remaining = json.load(fh)
|
||||
self.assertEqual(
|
||||
remaining,
|
||||
{"b": {"state": "warm", "vm": "chv-bad"}})
|
||||
# 修复后重试：失败项可被清理，库最终为空。
|
||||
ex.fail_vms = set()
|
||||
self.assertEqual(reconcile_orphans_for_executor(ex),
|
||||
["chv-bad"])
|
||||
with open(path) as fh:
|
||||
self.assertEqual(json.load(fh), {})
|
||||
|
||||
def test_corrupt_registry_audited_not_silent(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
path = _write_registry(d, "{not json")
|
||||
ex = FakeProdExecutor(d)
|
||||
self.assertEqual(reconcile_orphans_for_executor(ex), [])
|
||||
self.assertIn("warm_pool_registry_corrupt", ex.emits)
|
||||
self.assertTrue(os.path.exists(path + ".corrupt"))
|
||||
|
||||
def test_invalid_entries_audited_and_counted(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
path = _write_registry(d, {
|
||||
"a": {"state": "warm", "vm": "chv-a"},
|
||||
"c": {"state": "warm"},
|
||||
"e": {"state": "running", "vm": "chv-e"},
|
||||
})
|
||||
ex = FakeProdExecutor(d)
|
||||
self.assertEqual(reconcile_orphans_for_executor(ex),
|
||||
["chv-a"])
|
||||
self.assertIn("warm_pool_registry_invalid_entries",
|
||||
ex.emits)
|
||||
with open(path) as fh:
|
||||
self.assertEqual(json.load(fh), {})
|
||||
|
||||
|
||||
# -- P1-03：残留私钥删失败 ----------------------------------------------
|
||||
|
||||
class StaleSecretsP1FixTest(P1FixCase):
|
||||
def test_delete_failure_not_cleaned_audited_and_dirty_marked(self):
|
||||
from cloud.chv.hostkeys import dirty_marker_path
|
||||
ex = self.make_exec()
|
||||
vm_dir = os.path.join(self.state_dir, "chv-bad")
|
||||
os.makedirs(vm_dir, exist_ok=True)
|
||||
priv = os.path.join(vm_dir, "ssh_host_ed25519_key")
|
||||
with open(priv, "w") as fh:
|
||||
fh.write("PRIVATE")
|
||||
real_remove = os.remove
|
||||
|
||||
def remove(path):
|
||||
if path == priv:
|
||||
raise OSError("删不掉")
|
||||
return real_remove(path)
|
||||
|
||||
with mock.patch.object(os, "remove", side_effect=remove):
|
||||
cleaned = ex.cleanup_stale_secrets()
|
||||
self.assertNotIn("chv-bad", cleaned)
|
||||
self.assertIn("host_secret_residue_delete_failed",
|
||||
self._audit_events())
|
||||
self.assertTrue(os.path.exists(
|
||||
dirty_marker_path(self.state_dir, "chv-bad")))
|
||||
self.assertTrue(os.path.exists(priv))
|
||||
|
||||
def test_delete_success_cleaned(self):
|
||||
ex = self.make_exec()
|
||||
vm_dir = os.path.join(self.state_dir, "chv-ok")
|
||||
os.makedirs(vm_dir, exist_ok=True)
|
||||
with open(os.path.join(vm_dir, "ssh_host_ed25519_key"),
|
||||
"w") as fh:
|
||||
fh.write("PRIVATE")
|
||||
cleaned = ex.cleanup_stale_secrets()
|
||||
self.assertIn("chv-ok", cleaned)
|
||||
self.assertIn("host_secret_residue_cleaned",
|
||||
self._audit_events())
|
||||
|
||||
|
||||
# -- P1-04：SSH 回落删除 -------------------------------------------------
|
||||
|
||||
class SshFallbackP1FixTest(P1FixCase):
|
||||
def test_undeclared_build_raises_not_loopback(self):
|
||||
ex = self.make_exec(env_extra={"CHV_SSH_FORWARD": "0"})
|
||||
with self.assertRaises(ChvFailure) as ctx:
|
||||
ex.build_ssh_command(self._task(), ["true"])
|
||||
self.assertEqual(ctx.exception.kind, "ssh_target_undeclared")
|
||||
|
||||
def test_explicit_loopback_still_allowed(self):
|
||||
ex = self.make_exec(env_extra={"CHV_SSH_HOST": "127.0.0.1"})
|
||||
cmd = ex.build_ssh_command(self._task(), ["true"])
|
||||
self.assertIn("root@127.0.0.1", " ".join(cmd))
|
||||
ex2 = self.make_exec(env_extra={"CHV_SSH_FORWARD": "1"})
|
||||
cmd2 = ex2.build_ssh_command(self._task(), ["true"])
|
||||
self.assertIn("root@127.0.0.1", " ".join(cmd2))
|
||||
|
||||
|
||||
# -- P1-05：flock ---------------------------------------------------------
|
||||
|
||||
class StateLockP1FixTest(unittest.TestCase):
|
||||
def test_thread_mutual_exclusion(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
state_dir = os.path.join(d, "state")
|
||||
lock_a = StateLock(state_dir)
|
||||
lock_b = StateLock(state_dir)
|
||||
acquired = []
|
||||
lock_a.acquire()
|
||||
try:
|
||||
def _take():
|
||||
# RLock 须由加锁线程释放，故获取与释放同线程。
|
||||
lock_b.acquire()
|
||||
acquired.append(True)
|
||||
lock_b.release()
|
||||
|
||||
t = threading.Thread(target=_take)
|
||||
t.start()
|
||||
time.sleep(0.3)
|
||||
self.assertEqual(acquired, [])
|
||||
self.assertTrue(t.is_alive())
|
||||
finally:
|
||||
lock_a.release()
|
||||
t.join(timeout=5)
|
||||
self.assertEqual(acquired, [True])
|
||||
self.assertTrue(os.path.exists(
|
||||
lock_path_for_state_dir(state_dir)))
|
||||
|
||||
def test_cross_process_mutual_exclusion(self):
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
state_dir = os.path.join(d, "state")
|
||||
os.makedirs(state_dir, exist_ok=True)
|
||||
root = str(Path(__file__).resolve().parents[2])
|
||||
ready = os.path.join(state_dir, "child-locked")
|
||||
script = (
|
||||
"import sys, time; sys.path.insert(0, %r); "
|
||||
"from cloud.chv.locking import StateLock; "
|
||||
"lock = StateLock(%r); lock.acquire(); "
|
||||
"open(%r, 'w').write('locked'); "
|
||||
"time.sleep(10)" % (root, state_dir, ready))
|
||||
proc = subprocess.Popen(
|
||||
[sys.executable, "-c", script],
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
try:
|
||||
deadline = time.time() + 10
|
||||
while not os.path.exists(ready) and time.time() < deadline:
|
||||
time.sleep(0.05)
|
||||
self.assertTrue(os.path.exists(ready))
|
||||
self.assertIsNone(proc.poll())
|
||||
lock = StateLock(state_dir)
|
||||
acquired = []
|
||||
|
||||
def _take():
|
||||
lock.acquire()
|
||||
acquired.append(True)
|
||||
lock.release()
|
||||
|
||||
t = threading.Thread(target=_take)
|
||||
t.start()
|
||||
time.sleep(0.5)
|
||||
# 子进程持锁期间，本进程的加锁必须阻塞。
|
||||
self.assertEqual(acquired, [])
|
||||
proc.terminate()
|
||||
proc.wait(timeout=5)
|
||||
t.join(timeout=5)
|
||||
self.assertEqual(acquired, [True])
|
||||
finally:
|
||||
if proc.poll() is None:
|
||||
proc.kill()
|
||||
proc.wait(timeout=5)
|
||||
|
||||
def test_purge_snapshot_traversal_under_concurrent_mutation(self):
|
||||
# 旧无锁 pop + 持锁遍历并发可致字典迭代异常；新实现
|
||||
# 快照键列表后逐项持锁删，并发变更加锁路径下不得抛错。
|
||||
with tempfile.TemporaryDirectory():
|
||||
case = P1FixCase()
|
||||
case.setUp()
|
||||
try:
|
||||
ex = case.make_exec()
|
||||
ex.state_dir = case.state_dir
|
||||
stop = threading.Event()
|
||||
|
||||
def mutate():
|
||||
i = 0
|
||||
while not stop.is_set():
|
||||
name = "chv-m%d" % (i % 5)
|
||||
with ex._vms_lock:
|
||||
ex._vms[name] = FakeProc(alive=False)
|
||||
i += 1
|
||||
|
||||
t = threading.Thread(target=mutate)
|
||||
t.start()
|
||||
try:
|
||||
for _ in range(50):
|
||||
ex._purge_dead_registry()
|
||||
finally:
|
||||
stop.set()
|
||||
t.join(timeout=5)
|
||||
finally:
|
||||
case.tearDown()
|
||||
|
||||
|
||||
class WakeSerializationP1FixTest(P1FixCase):
|
||||
def test_concurrent_wakes_serialized_by_state_lock(self):
|
||||
# 两路并发 wake：每路 api 往返睡 0.2 秒；串行则总耗时
|
||||
# 至少 0.35 秒，并行则约 0.2 秒。阈值留足余量防抖动。
|
||||
def sleeping_api(socket_path, method, path, payload=None):
|
||||
if path == "/vmm.ping":
|
||||
time.sleep(0.2)
|
||||
return (200, {})
|
||||
|
||||
ex1 = self.make_exec(api_client=sleeping_api)
|
||||
ex2 = self.make_exec(api_client=sleeping_api)
|
||||
results = []
|
||||
start = time.time()
|
||||
|
||||
def wake(ex, task_id):
|
||||
try:
|
||||
results.append(ex.wake_vm({"id": task_id})["state"])
|
||||
except Exception as exc: # noqa: BLE001 - 失败即测试失败
|
||||
results.append("error:%s" % exc)
|
||||
|
||||
t1 = threading.Thread(target=wake, args=(ex1, "s1"))
|
||||
t2 = threading.Thread(target=wake, args=(ex2, "s2"))
|
||||
t1.start()
|
||||
t2.start()
|
||||
t1.join(timeout=30)
|
||||
t2.join(timeout=30)
|
||||
elapsed = time.time() - start
|
||||
self.assertEqual(sorted(results), ["running", "running"])
|
||||
self.assertGreaterEqual(elapsed, 0.35)
|
||||
self.assertTrue(os.path.exists(
|
||||
lock_path_for_state_dir(self.state_dir)))
|
||||
|
||||
|
||||
# -- P1-06：单条快照超帽 ---------------------------------------------------
|
||||
|
||||
class SingleSnapshotCapP1FixTest(unittest.TestCase):
|
||||
def test_single_oversize_snapshot_rejected_without_side_effects(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
old = os.path.join(tmp, "vm1", "old.snap")
|
||||
os.makedirs(os.path.join(tmp, "vm1"), exist_ok=True)
|
||||
with open(old, "wb") as fh:
|
||||
fh.write(b"O" * 100)
|
||||
from cloud.chv.disk import _save_snapshots
|
||||
_save_snapshots(tmp, "vm1", [{
|
||||
"url": "file://" + old, "path": old, "size": 100,
|
||||
"created_at": 0}])
|
||||
new = os.path.join(tmp, "vm1", "new.snap")
|
||||
with open(new, "wb") as fh:
|
||||
fh.write(b"N" * 1000)
|
||||
# 总量帽 500 字节：新单条 1000 字节本身已超帽。
|
||||
with self.assertRaises(ChvFailure) as ctx:
|
||||
record_snapshot(tmp, "vm1", "file://" + new,
|
||||
500 / (1024 ** 3))
|
||||
self.assertEqual(ctx.exception.kind,
|
||||
"snapshot_quota_exceeded")
|
||||
# 拒绝无副作用：旧快照文件仍在、登记仍只有旧条目。
|
||||
self.assertTrue(os.path.exists(old))
|
||||
from cloud.chv.disk import _load_snapshots
|
||||
entries = _load_snapshots(tmp, "vm1")
|
||||
self.assertEqual(len(entries), 1)
|
||||
self.assertEqual(entries[0]["path"], old)
|
||||
|
||||
|
||||
# -- P1-07：>0 校验 ---------------------------------------------------------
|
||||
|
||||
class PositiveConfigP1FixTest(P1FixCase):
|
||||
def test_config_layer_rejects_non_positive(self):
|
||||
base_env = {}
|
||||
for env_extra, field in (
|
||||
({"CHV_CPU": "0"}, "cpu"),
|
||||
({"CHV_CPU": "-2"}, "cpu"),
|
||||
({"CHV_MEM": "0"}, "mem"),
|
||||
({"CHV_MEM": "0G"}, "mem"),
|
||||
({"CHV_TASK_TIMEOUT": "0"}, "timeout"),
|
||||
({"CHV_TASK_TIMEOUT": "-5"}, "timeout")):
|
||||
env = dict(base_env)
|
||||
env.update(env_extra)
|
||||
with self.assertRaises(ValueError, msg=field):
|
||||
build_chv_config({}, env)
|
||||
# 合法值与 None（不限）不受影响。
|
||||
cfg = build_chv_config({}, {"CHV_TASK_TIMEOUT": "30"})
|
||||
self.assertEqual(cfg.task_timeout, 30.0)
|
||||
cfg = build_chv_config({}, {})
|
||||
self.assertIsNone(cfg.task_timeout)
|
||||
|
||||
def test_preflight_rejects_tampered_attributes(self):
|
||||
for attr, value in (("cpus", "0"), ("cpus", "-1"),
|
||||
("memory", "0"), ("task_timeout", 0),
|
||||
("task_timeout", -3)):
|
||||
ex = self.make_exec()
|
||||
setattr(ex, attr, value)
|
||||
with self.assertRaises(ChvFailure) as ctx:
|
||||
ex.preflight()
|
||||
self.assertEqual(ctx.exception.kind, "config_invalid")
|
||||
|
||||
|
||||
# -- P1-08：剪枝审计与快照失败审计 -----------------------------------------
|
||||
|
||||
class SnapshotAuditP1FixTest(P1FixCase):
|
||||
def test_retention_prune_delete_failure_audited(self):
|
||||
ex = self.make_exec()
|
||||
vm_dir = os.path.join(self.state_dir, "chv-abc123")
|
||||
os.makedirs(vm_dir, exist_ok=True)
|
||||
old = os.path.join(self.state_dir, "old.snap")
|
||||
with open(old, "wb") as fh:
|
||||
fh.write(b"O" * 10)
|
||||
with open(os.path.join(vm_dir, "snapshots.json"), "w") as fh:
|
||||
json.dump([{"url": "file://" + old, "path": old,
|
||||
"size": 10, "created_at": 0}], fh)
|
||||
new = os.path.join(self.state_dir, "new.snap")
|
||||
with open(new, "wb") as fh:
|
||||
fh.write(b"N" * 10)
|
||||
real_remove = os.remove
|
||||
|
||||
def remove(path):
|
||||
if path == old:
|
||||
raise OSError("删不掉")
|
||||
return real_remove(path)
|
||||
|
||||
with mock.patch.object(os, "remove", side_effect=remove):
|
||||
out = ex.snapshot_vm(self._task(), "file://" + new)
|
||||
self.assertEqual(out, "file://" + new)
|
||||
self.assertIn("vm_snapshot_prune_failed",
|
||||
self._audit_events())
|
||||
self.assertTrue(os.path.exists(old))
|
||||
|
||||
def test_snapshot_failure_audited(self):
|
||||
def failing_runner(cmd, timeout=None):
|
||||
if cmd and cmd[0] == "ch-remote":
|
||||
raise RuntimeError("ch-remote 挂了")
|
||||
return FakeResult(0, "", "")
|
||||
|
||||
ex = self.make_exec(runner=failing_runner)
|
||||
# 目标须在 state_dir 内才过白名单（ch-remote 失败在后）。
|
||||
target = "file://" + os.path.join(self.state_dir, "x.snap")
|
||||
with self.assertRaises(RuntimeError):
|
||||
ex.snapshot_vm(self._task(), target)
|
||||
self.assertIn("vm_snapshot_failed", self._audit_events())
|
||||
|
||||
|
||||
# -- P1-09：4 处三元 else 分支 ----------------------------------------------
|
||||
|
||||
class BranchCoverP1FixTest(P1FixCase):
|
||||
def test_pause_resume_snapshot_str_forms(self):
|
||||
ex = self.make_exec()
|
||||
os.makedirs(self.state_dir, exist_ok=True)
|
||||
self.assertTrue(ex.pause_vm("chv-abc"))
|
||||
self.assertTrue(ex.resume_vm("chv-abc"))
|
||||
snap = os.path.join(self.state_dir, "snap.raw")
|
||||
with open(snap, "wb") as fh:
|
||||
fh.write(b"S" * 10)
|
||||
out = ex.snapshot_vm("chv-abc", "file://" + snap)
|
||||
self.assertEqual(out, "file://" + snap)
|
||||
self.assertIn("vm_pause", self._audit_events())
|
||||
self.assertIn("vm_resume", self._audit_events())
|
||||
self.assertIn("vm_snapshot", self._audit_events())
|
||||
|
||||
def test_spill_audit_non_dict_task(self):
|
||||
ex = self.make_exec()
|
||||
os.makedirs(self.state_dir, exist_ok=True)
|
||||
ex._spill_audit("ev", "plain-task-id", "detail", None)
|
||||
path = os.path.join(self.state_dir, "chv-audit-spill.jsonl")
|
||||
with open(path) as fh:
|
||||
row = json.loads(fh.readline())
|
||||
self.assertEqual(row["task_id"], "plain-task-id")
|
||||
self.assertEqual(row["event"], "ev")
|
||||
|
||||
|
||||
# -- 覆盖补齐：新分支的行覆盖（诚实口径，不凑数改代码） --------
|
||||
|
||||
class CoverageCompletionP1FixTest(P1FixCase):
|
||||
def test_prune_events_no_file_and_no_delete(self):
|
||||
from cloud.chv.disk import _save_snapshots
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
_save_snapshots(tmp, "vm1", [
|
||||
{"url": "file:///gone.snap", "path": "/gone.snap",
|
||||
"size": 5, "created_at": 0},
|
||||
{"url": "https://example.invalid/x", "path": None,
|
||||
"size": 5, "created_at": 0}])
|
||||
events = []
|
||||
kept, pruned = prune_snapshots(
|
||||
tmp, "vm1", retention_days=30, now=10 ** 9,
|
||||
events=events)
|
||||
self.assertEqual(kept, [])
|
||||
self.assertEqual(len(pruned), 2)
|
||||
kinds = [e[0] for e in events]
|
||||
self.assertEqual(kinds, ["pruned_no_file", "pruned_no_file"])
|
||||
events2 = []
|
||||
_save_snapshots(tmp, "vm1", [
|
||||
{"url": "file:///gone2.snap", "path": "/gone2.snap",
|
||||
"size": 5, "created_at": 0}])
|
||||
kept2, _ = prune_snapshots(
|
||||
tmp, "vm1", retention_days=30, now=10 ** 9,
|
||||
delete_files=False, events=events2)
|
||||
self.assertEqual(kept2, [])
|
||||
self.assertEqual([e[0] for e in events2],
|
||||
["pruned_no_file"])
|
||||
|
||||
def test_record_without_cap_and_tighten_delete_failure_event(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
entries, removed = record_snapshot(
|
||||
tmp, "vm1", "https://example.invalid/new", None)
|
||||
self.assertEqual(len(entries), 1)
|
||||
self.assertEqual(removed, [])
|
||||
old = os.path.join(tmp, "vm1", "old.snap")
|
||||
os.makedirs(os.path.join(tmp, "vm1"), exist_ok=True)
|
||||
with open(old, "wb") as fh:
|
||||
fh.write(b"O" * 100)
|
||||
from cloud.chv.disk import _save_snapshots
|
||||
_save_snapshots(tmp, "vm1", [
|
||||
{"url": "file://" + old, "path": old, "size": 100,
|
||||
"created_at": 0}])
|
||||
real_remove = os.remove
|
||||
|
||||
def remove(path):
|
||||
if path == old:
|
||||
raise OSError("删不掉")
|
||||
return real_remove(path)
|
||||
|
||||
events = []
|
||||
with mock.patch.object(os, "remove", side_effect=remove):
|
||||
entries2, removed2 = record_snapshot(
|
||||
tmp, "vm1", "https://example.invalid/new2",
|
||||
0.0, events=events)
|
||||
self.assertEqual(len(removed2), 1)
|
||||
self.assertEqual([e[0] for e in events], ["delete_failed"])
|
||||
self.assertTrue(os.path.exists(old))
|
||||
|
||||
def test_tighten_no_file_entry_event(self):
|
||||
from cloud.chv.disk import _save_snapshots
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
_save_snapshots(tmp, "vm1", [
|
||||
{"url": "https://example.invalid/old", "path": None,
|
||||
"size": 100, "created_at": 0}])
|
||||
events = []
|
||||
entries, removed = record_snapshot(
|
||||
tmp, "vm1", "https://example.invalid/new",
|
||||
0.0, events=events)
|
||||
self.assertEqual(len(removed), 1)
|
||||
self.assertEqual([e[0] for e in events],
|
||||
["pruned_no_file"])
|
||||
|
||||
def test_state_lock_ctx_refreshes_on_state_dir_change(self):
|
||||
ex = self.make_exec()
|
||||
old_lock = ex._state_lock
|
||||
new_dir = os.path.join(self.dir, "state2")
|
||||
ex.state_dir = new_dir
|
||||
self.assertIsNot(ex._state_lock_ctx(), old_lock)
|
||||
self.assertEqual(ex._state_lock.state_dir, new_dir)
|
||||
|
||||
def test_gc_and_secrets_listdir_failure_returns_empty(self):
|
||||
ex = self.make_exec()
|
||||
ex.state_dir = os.path.join(self.dir, "missing-dir")
|
||||
self.assertEqual(ex.gc_stale_disks(),
|
||||
{"deleted": [], "failed": []})
|
||||
self.assertEqual(ex.cleanup_stale_secrets(), [])
|
||||
|
||||
def test_cleanup_listdir_failure_returns_empty(self):
|
||||
ex = self.make_exec()
|
||||
os.makedirs(self.state_dir, exist_ok=True)
|
||||
real_listdir = os.listdir
|
||||
calls = {"n": 0}
|
||||
|
||||
def listdir(path):
|
||||
calls["n"] += 1
|
||||
if calls["n"] >= 3:
|
||||
raise OSError("listdir 挂了")
|
||||
return real_listdir(path)
|
||||
|
||||
with mock.patch.object(os, "listdir", side_effect=listdir):
|
||||
self.assertEqual(ex.cleanup_stale_vms(), [])
|
||||
|
||||
def test_orphan_entries_compat_wrapper_and_no_emit_executor(self):
|
||||
from cloud.chv.orphans import _orphan_entries
|
||||
data = {"a": {"state": "warm", "vm": "chv-a",
|
||||
"task_id": "a", "snapshot_url": None},
|
||||
"b": {"state": "running", "vm": "chv-b"}}
|
||||
self.assertEqual(_orphan_entries(data),
|
||||
[{"vm": "chv-a", "task_id": "a",
|
||||
"snapshot_url": None}])
|
||||
|
||||
class NoEmit:
|
||||
def __init__(self, state_dir):
|
||||
self.state_dir = state_dir
|
||||
self.shutdowns = []
|
||||
|
||||
def shutdown_vm(self, vm):
|
||||
self.shutdowns.append(vm)
|
||||
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
_write_registry(d, {
|
||||
"a": {"state": "warm", "vm": "chv-a"}})
|
||||
ex = NoEmit(d)
|
||||
self.assertEqual(reconcile_orphans_for_executor(ex),
|
||||
["chv-a"])
|
||||
|
||||
def test_state_lock_flock_failure_closes_and_releases(self):
|
||||
import fcntl
|
||||
with tempfile.TemporaryDirectory() as d:
|
||||
state_dir = os.path.join(d, "state")
|
||||
lock = StateLock(state_dir)
|
||||
with mock.patch.object(fcntl, "flock",
|
||||
side_effect=OSError("flock 挂了")):
|
||||
with self.assertRaises(OSError):
|
||||
lock.acquire()
|
||||
self.assertIsNone(lock._fd)
|
||||
# 失败后锁仍可用（RLock 已释放、fd 已关闭）。
|
||||
lock.acquire()
|
||||
lock.release()
|
||||
|
||||
def test_pool_reconcile_failed_emit_failure_swallowed(self):
|
||||
from cloud.chv.experimental_pool import WarmPool
|
||||
stub = _PoolStubForP1Fix()
|
||||
pool = WarmPool(stub, registry_path=None)
|
||||
pool._entries["old-1"] = {"state": "orphan", "vm": "vm-old",
|
||||
"task": {"id": "old-1"}}
|
||||
self.assertEqual(pool.reconcile_orphans(), [])
|
||||
self.assertIn("old-1", pool._entries)
|
||||
|
||||
|
||||
class _PoolStubForP1Fix:
|
||||
"""实验池失败审计吞错测试用假执行器。"""
|
||||
|
||||
def shutdown_vm(self, task_or_name):
|
||||
raise RuntimeError("shutdown 失败")
|
||||
|
||||
def _emit(self, event, task, detail="", kind=None):
|
||||
raise RuntimeError("audit 失败")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user