176 lines
9.7 KiB
Python
176 lines
9.7 KiB
Python
"""Read-only checks for knowledge-batch-20261007: baseline / candidate / deployed / backup.
|
|
|
|
Prints hashes, counts and status only; never reads chat content, knowledge text, users or credentials.
|
|
`backup` records knowledge table row counts (no content) to knowledge-before.json.
|
|
"""
|
|
from pathlib import Path
|
|
import argparse, hashlib, json, os, subprocess, urllib.error, urllib.request
|
|
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('mode', choices=['baseline', 'candidate', 'deployed', 'backup'])
|
|
args = parser.parse_args()
|
|
RELEASE = 'knowledge-batch-20261007'
|
|
folder = Path(__file__).resolve().parent
|
|
project = Path('/opt/im-admin')
|
|
base = json.loads((folder / 'server-baseline.json').read_text())
|
|
plan = json.loads((folder / 'release-plan.json').read_text())
|
|
manifest = json.loads((folder / 'manifest.json').read_text())
|
|
payload_rows = [row for row in manifest if row['path'].startswith('payload/')]
|
|
frontend = plan['frontendDir']
|
|
added = [frontend + '/' + rel for rel in plan['frontendAdded']]
|
|
sha = lambda data: hashlib.sha256(data).hexdigest()
|
|
image = lambda ref: subprocess.check_output(['docker', 'image', 'inspect', ref, '--format', '{{.Id}}'], text=True).strip()
|
|
SERVICES = {'api': 'im-admin-api-1', 'gateway': 'im-admin-gateway-1', 'knowledge-worker': 'im-admin-knowledge-worker-1'}
|
|
HEALTHCHECKED = {'api', 'gateway'}
|
|
|
|
# The unpacked bundle itself must be intact.
|
|
for row in manifest:
|
|
path = (folder / row['path']).resolve()
|
|
assert path.is_relative_to(folder), row['path']
|
|
assert path.stat().st_size == row['bytes'] and sha(path.read_bytes()) == row['sha256'], row['path']
|
|
|
|
# project-relative path -> expected sha256
|
|
if args.mode == 'baseline':
|
|
expected = dict(base['expected'])
|
|
else:
|
|
expected = {row['path'][len('payload/'):]: row['sha256'] for row in payload_rows}
|
|
backend_expected = {k: v for k, v in expected.items() if k.startswith('wechat_rpa/')}
|
|
|
|
HASHES = ('from pathlib import Path;import hashlib,json,sys;names=json.load(sys.stdin);'
|
|
'print(json.dumps({n:(hashlib.sha256((Path("/app")/n).read_bytes()).hexdigest() '
|
|
'if (Path("/app")/n).is_file() else None) for n in names}))')
|
|
|
|
|
|
def in_container(code, target, container=None, ref=None):
|
|
command = (['docker', 'run', '--rm', '-i', '--network=none', '--entrypoint', 'python', ref, '-c', code]
|
|
if ref else ['docker', 'exec', '-i', container, 'python', '-c', code])
|
|
return json.loads(subprocess.check_output(command, input=json.dumps(target).encode()))
|
|
|
|
|
|
def inspect(container):
|
|
raw = json.loads(subprocess.check_output(['docker', 'inspect', container]))[0]
|
|
return {'id': raw['Id'], 'image': raw['Image'], 'running': raw['State']['Running'], 'started': raw['State']['StartedAt'],
|
|
'restarts': raw['RestartCount'], 'health': raw['State'].get('Health', {}).get('Status', 'not_configured')}
|
|
|
|
|
|
def healthy(name, state):
|
|
return state['running'] and (state['health'] == 'healthy' if name in HEALTHCHECKED else True)
|
|
|
|
|
|
# 知识表的行数和结构(只读,只数数)
|
|
KNOWLEDGE_STATS = r'''
|
|
import json, sqlite3
|
|
db = sqlite3.connect("file:/data/backend.db?mode=ro", uri=True)
|
|
tables = {r[0] for r in db.execute("SELECT name FROM sqlite_master WHERE type='table'")}
|
|
cols = lambda t: sorted(r[1] for r in db.execute(f"PRAGMA table_info({t})"))
|
|
out = {
|
|
"items": dict(db.execute("SELECT status, COUNT(*) FROM knowledge_item GROUP BY status").fetchall()),
|
|
"jobs": dict(db.execute("SELECT status, COUNT(*) FROM knowledge_job GROUP BY status").fetchall()),
|
|
"sources": db.execute("SELECT COUNT(*) FROM knowledge_source").fetchone()[0],
|
|
"watches": db.execute("SELECT COUNT(*) FROM knowledge_watch WHERE enabled=1").fetchone()[0],
|
|
"has_run_table": "knowledge_run" in tables, "has_config_table": "knowledge_config" in tables,
|
|
"job_has_run_id": "run_id" in cols("knowledge_job"), "item_has_source_key": "source_key" in cols("knowledge_item"),
|
|
}
|
|
if out["item_has_source_key"]:
|
|
out["missing_source_key"] = db.execute("SELECT COUNT(*) FROM knowledge_item WHERE source_key='' AND EXISTS("
|
|
"SELECT 1 FROM knowledge_source s WHERE s.item_id=knowledge_item.id)").fetchone()[0]
|
|
print(json.dumps(out, ensure_ascii=False))
|
|
'''
|
|
|
|
current = image('zyt/wecom-admin:current')
|
|
result = {'mode': args.mode, 'release': RELEASE, 'image': current}
|
|
|
|
|
|
def knowledge_stats():
|
|
return json.loads(subprocess.check_output(['docker', 'exec', '-i', SERVICES['api'], 'python', '-c', KNOWLEDGE_STATS]))
|
|
|
|
|
|
if args.mode == 'backup':
|
|
target = folder / 'knowledge-before.json'
|
|
assert not target.exists(), 'snapshot already taken'
|
|
stats = knowledge_stats()
|
|
fd = os.open(target, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
|
with os.fdopen(fd, 'w') as handle:
|
|
json.dump(stats, handle, ensure_ascii=False)
|
|
result['knowledge'] = stats
|
|
result['status'] = 'passed'
|
|
print(json.dumps(result, ensure_ascii=False))
|
|
raise SystemExit(0)
|
|
|
|
if args.mode == 'baseline':
|
|
states = {name: inspect(container) for name, container in SERVICES.items()}
|
|
for name, state in states.items():
|
|
assert state['image'] == base['images'][name], f'{name} is not on the recorded image'
|
|
assert healthy(name, state), 'Not healthy: ' + name
|
|
assert states['api']['image'] == current, 'current tag moved'
|
|
result['services'] = states
|
|
for name in added:
|
|
assert not (project / name).exists(), 'Would overwrite an existing file: ' + name
|
|
|
|
if args.mode in ('baseline', 'deployed'):
|
|
for name, wanted in expected.items():
|
|
assert sha((project / name).read_bytes()) == wanted, 'Host drift: ' + name
|
|
actual = in_container(HASHES, sorted(expected), container=SERVICES['api'])
|
|
assert actual == expected, 'Running api container differs from expected code'
|
|
for service in ('gateway', 'knowledge-worker'):
|
|
actual = in_container(HASHES, sorted(backend_expected), container=SERVICES[service])
|
|
assert actual == backend_expected, f'Running {service} container differs from expected code'
|
|
result['files'] = len(expected)
|
|
|
|
if args.mode == 'candidate':
|
|
candidate = 'zyt/wecom-admin:' + RELEASE
|
|
actual = in_container(HASHES, sorted(expected), ref=candidate)
|
|
assert actual == expected, 'Candidate image differs from manifest'
|
|
result['candidate'] = image(candidate)
|
|
result['files'] = len(expected)
|
|
|
|
if args.mode == 'deployed':
|
|
wanted = image('zyt/wecom-admin:' + RELEASE)
|
|
assert current == wanted, 'current tag does not point at the release image'
|
|
states = {}
|
|
for service, container in SERVICES.items():
|
|
state = inspect(container)
|
|
assert state['image'] == wanted and state['restarts'] == 0 and healthy(service, state), (service, state)
|
|
states[service] = state
|
|
for url in ['http://127.0.0.1:18766/api/v2/health', 'http://127.0.0.1:18770/health']:
|
|
with urllib.request.urlopen(url, timeout=15) as response:
|
|
assert response.status == 200, url
|
|
entry = next(rel for rel in plan['frontendAdded'] if rel.startswith('jse/index-index-'))
|
|
with urllib.request.urlopen('http://127.0.0.1:18766/', timeout=15) as response:
|
|
assert entry.encode() in response.read(), 'admin index.html is not the new build'
|
|
# 新接口不登录一律 401。不尝试登录。
|
|
for method, path in [('GET', '/api/v2/knowledge/runs'), ('GET', '/api/v2/knowledge/config'),
|
|
('POST', '/api/v2/knowledge/runs'), ('POST', '/api/v2/knowledge/runs/preview'),
|
|
('POST', '/api/v2/knowledge/models/test'), ('PUT', '/api/v2/knowledge/config')]:
|
|
request = urllib.request.Request('http://127.0.0.1:18766' + path, method=method,
|
|
data=b'{}' if method != 'GET' else None, headers={'Content-Type': 'application/json'})
|
|
try:
|
|
urllib.request.urlopen(request, timeout=15)
|
|
except urllib.error.HTTPError as exc:
|
|
assert exc.code == 401, (path, exc.code)
|
|
else:
|
|
raise AssertionError('Accessible without authentication: ' + path)
|
|
code = ("import json,knowledge_processing as p,knowledge_worker as w,knowledge_models as m;"
|
|
"o=type('O',(),{'kind':'openai','id':'x','config':{'base_url':'https://ark.cn-beijing.volces.com/api/v3','model':'doubao-seed'}})();"
|
|
"print(json.dumps({'pipeline':p.PIPELINE_VERSION,'batch':w.DEFAULT_BATCH,'retries':w.MAX_TRANSIENT,"
|
|
"'pages':w.MAX_SCAN_PAGES,'thinking':m.thinking_switch(o),'timeout_retry':m.is_transient('超过单路时限 90s')}))")
|
|
expected_behaviour = {'pipeline': 'chat-knowledge-v2', 'batch': 8, 'retries': 6, 'pages': 25,
|
|
'thinking': {'thinking': {'type': 'disabled'}}, 'timeout_retry': True}
|
|
for service in ('api', 'knowledge-worker'):
|
|
behaviour = json.loads(subprocess.check_output(['docker', 'exec', '-i', SERVICES[service], 'python', '-c', code]))
|
|
assert behaviour == expected_behaviour, (service, behaviour)
|
|
stats = knowledge_stats()
|
|
assert stats['has_run_table'] and stats['has_config_table'] and stats['job_has_run_id'] and stats['item_has_source_key'], stats
|
|
assert stats['missing_source_key'] == 0, stats
|
|
before = json.loads((folder / 'knowledge-before.json').read_text())
|
|
assert sum(stats['items'].values()) >= sum(before['items'].values()), (before['items'], stats['items'])
|
|
logs = subprocess.run(['docker', 'logs', '--since', states['knowledge-worker']['started'], SERVICES['knowledge-worker']],
|
|
capture_output=True, text=True)
|
|
worker_log = logs.stdout + logs.stderr
|
|
assert '知识加工 Worker 已启动' in worker_log and 'Traceback' not in worker_log, 'knowledge worker did not start cleanly'
|
|
result['behaviour'] = behaviour
|
|
result['knowledge'] = stats
|
|
|
|
result['status'] = 'passed'
|
|
print(json.dumps(result, ensure_ascii=False))
|