完善:同月多文件导入与当前用户离线迁移更新

This commit is contained in:
2026-11-04 11:35:24 +08:00
parent 147b56d0fd
commit f04d4e96e3
89 changed files with 6634 additions and 201 deletions
+357
View File
@@ -0,0 +1,357 @@
"""Immutable stage-zero recovery. Installed under deploy/bootstrap, never updated."""
from __future__ import annotations
import hashlib
import importlib.util
import json
import os
from pathlib import Path
import re
import secrets
import shutil
import subprocess
import sys
import time
import psutil # Bundled immutable Python environment, not an application module.
ROOT = Path(__file__).resolve().parents[2]
def read(path, default=None):
return json.loads(path.read_text(encoding='utf-8')) if path.exists() else default
def digest(path):
with path.open('rb') as stream:
return hashlib.file_digest(stream, 'sha256').hexdigest()
def atomic_copy(source, target):
target.parent.mkdir(parents=True, exist_ok=True)
temporary = target.with_name(target.name + '.recover-' + secrets.token_hex(6))
try:
with source.open('rb') as reader, temporary.open('xb') as writer:
shutil.copyfileobj(reader, writer)
writer.flush()
os.fsync(writer.fileno())
temporary.replace(target)
finally:
temporary.unlink(missing_ok=True)
def safe(root, name):
if (not isinstance(name, str) or not name or '\\' in name or ':' in name or name.startswith('/')
or any(part in ('', '.', '..') or part.endswith((' ', '.')) for part in name.split('/'))):
raise RuntimeError('更新恢复路径无效。')
target = root.joinpath(*name.split('/'))
for path in (target, *target.parents):
if path == root:
break
if path.is_symlink() or (path.exists() and getattr(path.lstat(), 'st_file_attributes', 0) & 0x400):
raise RuntimeError('更新恢复目录包含无效链接。')
if not target.resolve().is_relative_to(root.resolve()):
raise RuntimeError('更新恢复路径越界。')
return target
def program(name):
if name == 'deploy/offline/update-public-key.pem' or name.startswith('deploy/bootstrap/'):
return False
path = Path(name)
return (name == 'app/backend.jar' or name.startswith('app/web/')
or name == 'backend/src/main/resources/analysis-runtime-policy.json'
or name.startswith('scripts/') and path.suffix == '.py'
or name.startswith('ai/nao-quality/')
or name.startswith('deploy/offline/') and path.suffix in ('.py', '.ps1', '.md'))
def atomic_json(path, value):
temporary = path.with_name(path.name + '.stop-' + secrets.token_hex(6))
try:
with temporary.open('x', encoding='utf-8') as stream:
json.dump(value, stream)
stream.flush()
os.fsync(stream.fileno())
temporary.replace(path)
finally:
temporary.unlink(missing_ok=True)
def same_path(left, right):
return os.path.normcase(str(Path(left).resolve())) == os.path.normcase(str(Path(right).resolve()))
def runtime_executable(root, role):
suffix = '.exe' if os.name == 'nt' else ''
relative = {'supervisor': 'runtimes/python/' + ('python.exe' if os.name == 'nt' else 'bin/python3'),
'backend': 'runtimes/java/bin/java' + suffix, 'mysql': 'runtimes/mysql/bin/mysqld' + suffix}[role]
return root / relative
def bound_to_root(root, role, args):
if not isinstance(args, list) or not all(isinstance(arg, str) for arg in args):
return False
if role == 'supervisor':
return (len(args) in (2, 3) and same_path(args[0], root / 'deploy/offline/control.py')
and args[1] == 'serve' and (len(args) == 2 or args[2] == '--database-only'))
if role == 'backend':
return len(args) >= 2 and args[-2] == '-jar' and same_path(args[-1], root / 'app/backend.jar')
datadirs = [arg.split('=', 1)[1] for arg in args if arg.startswith('--datadir=')]
return len(datadirs) == 1 and same_path(datadirs[0], root / 'runtimedata/mysql')
def current_user(process):
if os.name == 'nt':
return process.username().casefold() == psutil.Process().username().casefold()
return process.uids().real == os.getuid()
def owned_process(root, role, info):
"""Return a fully verified owned PID, None for a dead PID, never guess."""
if (not isinstance(info, dict) or type(info.get('pid')) is not int or info['pid'] <= 0
or not isinstance(info.get('created'), (int, float))
or not isinstance(info.get('executable'), str) or not isinstance(info.get('args'), list)):
raise RuntimeError('本包服务进程记录无效,未停止任何不明进程。')
try:
process = psutil.Process(info['pid'])
if not process.is_running() or process.status() == psutil.STATUS_ZOMBIE:
return None
forbidden = {os.getpid(), *(parent.pid for parent in psutil.Process().parents())}
if (process.pid in forbidden or abs(process.create_time() - info['created']) >= .01
or not current_user(process) or not same_path(process.exe(), info['executable'])
or process.cmdline()[1:] != info['args']
or not same_path(info['executable'], runtime_executable(root, role))
or not bound_to_root(root, role, info['args'])):
raise RuntimeError('无法确认本包服务进程归属,未停止任何不明进程。')
return process
except psutil.NoSuchProcess:
return None
except psutil.Error:
raise RuntimeError('当前用户无法核验本包服务进程,恢复已安全停止。') from None
def root_markers(root, args):
"""Detect unregistered package processes without inspecting unrelated data."""
for arg in args:
if arg.startswith('--datadir='):
if same_path(arg.split('=', 1)[1], root / 'runtimedata/mysql'):
return True
elif Path(arg).is_absolute() and (same_path(arg, root / 'app/backend.jar')
or same_path(arg, root / 'deploy/offline/control.py')):
return True
return False
def refuse_unregistered(root, expected):
for process in psutil.process_iter():
try:
if process.pid == os.getpid() or process.status() == psutil.STATUS_ZOMBIE:
continue
args = process.cmdline()[1:]
if not root_markers(root, args):
continue
if process.pid not in expected:
raise RuntimeError('发现未登记的本包服务进程,已保留现场,请先检查该进程。')
except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
continue
def wait_owned(root, role, info, seconds):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
if owned_process(root, role, info) is None:
return True
time.sleep(.05)
return owned_process(root, role, info) is None
def terminate_owned(root, role, info, seconds):
process = owned_process(root, role, info)
if process is None:
return
try:
process.terminate()
if wait_owned(root, role, info, seconds):
return
process = owned_process(root, role, info)
if process is not None:
process.kill()
if not wait_owned(root, role, info, 10):
raise RuntimeError('本包服务尚未退出,未替换任何程序文件。')
except psutil.NoSuchProcess:
return
except psutil.Error:
raise RuntimeError('当前用户无法停止本包服务,未替换任何程序文件。') from None
def shutdown_owned_mysql(root, info):
process = owned_process(root, 'mysql', info)
if process is None:
return
value = read(safe(root, '.runtime/deployment.json'), {})
port = value.get('mysqlPort')
if (type(port) is not int or not 1024 <= port <= 65535
or not re.fullmatch(r'[A-Za-z0-9_-]{20,100}', str(value.get('rootPassword', '')))
or info['args'].count('--port=' + str(port)) != 1):
raise RuntimeError('无法核验本包数据库关闭配置,未替换任何程序文件。')
executable = root / 'runtimes/mysql/bin' / ('mysqladmin.exe' if os.name == 'nt' else 'mysqladmin')
env = os.environ.copy()
env['MYSQL_PWD'] = value['rootPassword']
# Only the immutable bundled MySQL client is executed; no application code
# is loaded, and the current user's privileges are never elevated.
command = [str(executable), '--no-defaults', '--protocol=TCP', '--host=127.0.0.1',
'--port=' + str(port), '--user=root', '--connect-timeout=3', 'shutdown']
try:
subprocess.run(command, env=env, cwd=root, stdin=subprocess.DEVNULL,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=20)
except (OSError, subprocess.SubprocessError):
raise RuntimeError('本包数据库无法安全关闭,未替换任何程序文件。') from None
if not wait_owned(root, 'mysql', info, 120):
raise RuntimeError('本包数据库仍在关闭,未替换任何程序文件,请稍后重新启动。')
def stop_owned_services(root, grace_seconds=200):
"""Immutable implementation of service.json + stop-request token contract.
A crashed worker can leave a healthy new supervisor/Java behind. Validate
every recorded identity before requesting shutdown; a live stale/reused PID
is an error rather than permission to terminate it. Java must be gone before
a JAR is replaced. An orphaned MySQL is shut down through its immutable
client, never forcibly killed on Windows.
"""
state = read(safe(root, '.runtime/service.json'), {})
if not isinstance(state, dict) or not isinstance(state.get('children', []), list):
raise RuntimeError('本包服务状态无效,未替换任何程序文件。')
entries = []
supervisor = state.get('supervisor')
if supervisor:
entries.append(('supervisor', supervisor))
for info in state.get('children', []):
if not isinstance(info, dict) or info.get('name') not in ('backend', 'mysql'):
raise RuntimeError('本包服务子进程记录无效,未替换任何程序文件。')
entries.append((info['name'], info))
if len(entries) > 20 or len({info.get('pid') for _, info in entries}) != len(entries):
raise RuntimeError('本包服务进程记录重复,未替换任何程序文件。')
# Validate all owners before the first stop request or signal is sent.
active = {(role, info['pid']): owned_process(root, role, info) for role, info in entries}
refuse_unregistered(root, {pid for (_, pid), process in active.items() if process is not None})
if supervisor and active.get(('supervisor', supervisor['pid'])) is not None:
token = state.get('token')
if not isinstance(token, str) or not re.fullmatch(r'[a-f0-9]{48}', token):
raise RuntimeError('本包服务停止令牌无效,未停止任何进程。')
atomic_json(safe(root, '.runtime/stop-request.json'), {'token': token})
if not wait_owned(root, 'supervisor', supervisor, grace_seconds):
terminate_owned(root, 'supervisor', supervisor, 10)
# A dead supervisor cannot finish its own finally block. Only independently
# verified package children may be stopped; unrelated/reused PIDs are refused.
for role, info in entries:
if role == 'backend':
terminate_owned(root, role, info, 35)
for role, info in entries:
if role == 'mysql':
shutdown_owned_mysql(root, info)
for role, info in entries:
if owned_process(root, role, info) is not None:
raise RuntimeError('本包服务尚未完全退出,未替换任何程序文件。')
refuse_unregistered(root, set())
stop = safe(root, '.runtime/stop-request.json')
if isinstance(state.get('token'), str) and read(stop, {}).get('token') == state['token']:
stop.unlink(missing_ok=True)
def restore_program_before_import(root, directory, journal):
name = journal.get('backup', '')
if not re.fullmatch(r'backup-[0-9]{8}T[0-9]{6}Z-[a-f0-9]{8}', name):
raise RuntimeError('更新恢复记录无效。')
backup = safe(directory, name)
manifest_file, inventory_file = backup / 'manifest.json', backup / 'program.json'
if (digest(manifest_file) != journal.get('backupManifestSha256')
or digest(inventory_file) != journal.get('programInventorySha256')):
raise RuntimeError('本机更新备份校验失败,请保留目录并联系管理员。')
manifest = read(manifest_file)
old = {entry['path']: entry for entry in manifest['files'] if program(entry['path'])}
inventory = read(inventory_file)
all_names, present = inventory['all'], set(inventory['present'])
if (not isinstance(all_names, list) or len(all_names) > 50000
or len(set(all_names)) != len(all_names) or not present.issubset(all_names)):
raise RuntimeError('更新恢复清单无效。')
for name in all_names:
if not program(name):
raise RuntimeError('更新恢复清单包含受保护路径。')
target = safe(root, name)
if name in present:
source = safe(backup / 'program', name)
if name not in old or not source.is_file() or digest(source) != old[name]['sha256']:
raise RuntimeError('原程序备份缺失或损坏。')
elif name in old:
raise RuntimeError('原程序备份不完整。')
# All backups are validated before any application file is replaced.
stop_owned_services(root)
for name in all_names:
target = safe(root, name)
if name in present:
atomic_copy(safe(backup / 'program', name), target)
else:
target.unlink(missing_ok=True)
atomic_copy(manifest_file, root / 'manifest.json')
def live(info):
try:
process = psutil.Process(info['pid'])
return (process.is_running() and process.status() != psutil.STATUS_ZOMBIE
and abs(process.create_time() - info['created']) < .01)
except (psutil.Error, ValueError, TypeError, KeyError):
return False
def recover(root=ROOT):
directory = safe(root, '.runtime/update')
journal = read(directory / 'journal.json', {})
if journal.get('phase') in (None, 'complete', 'rolledBack'):
return {'recovered': False}
if live(read(directory / 'worker.json', {})):
raise RuntimeError('更新正在进行,请等待原窗口完成。')
with (directory / 'worker.lock').open('a+b') as lock:
try:
if os.name == 'nt':
import msvcrt
lock.seek(0)
msvcrt.locking(lock.fileno(), msvcrt.LK_NBLCK, 1)
else:
import fcntl
fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
except OSError:
raise RuntimeError('已有更新恢复正在进行,请等待完成。') from None
identity = {'pid': os.getpid(), 'created': psutil.Process().create_time()}
worker = directory / 'worker.json'
temporary = worker.with_suffix('.bootstrap.tmp')
temporary.write_text(json.dumps(identity), encoding='utf-8')
temporary.replace(worker)
try:
journal = read(directory / 'journal.json', {})
if journal.get('phase') == 'installing':
restore_program_before_import(root, directory, journal)
elif journal.get('phase') == 'stopping':
stop_owned_services(root)
else:
raise RuntimeError('更新恢复阶段无效,未替换任何程序文件。')
# This import occurs only after restoring a complete, verified old
# program set; no mutable application module was imported above.
path = safe(root, 'deploy/offline/update_manager.py')
spec = importlib.util.spec_from_file_location('quality_recovered_updater', path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module.recover_locked(root)
finally:
if read(worker, {}) == identity:
worker.unlink(missing_ok=True)
if __name__ == '__main__':
try:
print(json.dumps(recover(), ensure_ascii=False))
except Exception as error:
print(json.dumps({'error': str(error) if isinstance(error, RuntimeError) else '更新恢复未完成,请保留本机备份并联系管理员。'}, ensure_ascii=False))
raise SystemExit(1)