From 48437686946d2b23bc45a7c91d332ee79580ab6d Mon Sep 17 00:00:00 2001 From: lyun Date: Thu, 5 Nov 2026 14:40:33 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=EF=BC=9AWindows=20=E6=9B=B4?= =?UTF-8?q?=E6=96=B0=E6=A3=80=E6=9F=A5=E4=BB=85=E6=8E=A2=E6=B5=8B=E7=A8=8B?= =?UTF-8?q?=E5=BA=8F=E8=B7=AF=E5=BE=84=EF=BC=8C=E9=81=BF=E5=85=8D=E6=85=A2?= =?UTF-8?q?=E7=A3=81=E7=9B=98=E6=A0=A1=E9=AA=8C=E8=B6=85=E6=97=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- deploy/offline/README.md | 6 + deploy/offline/repair_windows_update_check.py | 131 ++++++++++++++++++ deploy/offline/test_update_manager.py | 20 +++ .../test_windows_update_check_repair.py | 117 ++++++++++++++++ deploy/offline/update_manager.py | 5 +- 5 files changed, 278 insertions(+), 1 deletion(-) create mode 100644 deploy/offline/repair_windows_update_check.py create mode 100644 deploy/offline/test_windows_update_check_repair.py diff --git a/deploy/offline/README.md b/deploy/offline/README.md index ab68ca6..ec03482 100644 --- a/deploy/offline/README.md +++ b/deploy/offline/README.md @@ -52,3 +52,9 @@ python3 deploy/offline/publish_update.py \ 工具只在本地产生 `quality-update-.zip` 和签名 `latest.json`,不会上传或发布文件。每个版本请使用新的输出目录;发布到更新服务器由维护人员另行完成。 参考:[Java 21 官方发行](https://adoptium.net/temurin/releases?version=21)、[MySQL Windows 安装要求](https://dev.mysql.com/doc/refman/8.4/en/windows-installation.html)、[MySQL Linux 二进制安装](https://dev.mysql.com/doc/refman/8.4/en/binary-installation.html)、[Python standalone](https://github.com/astral-sh/python-build-standalone)、[nao-core 0.3.26](https://pypi.org/project/nao-core/0.3.26/)、[Microsoft 运行库](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist/)。 + +### Windows 检查更新校验超时修复(2026-11-05) + +旧版检查会逐个探测完整运行环境清单的磁盘路径,慢磁盘上可能超过接口等待时间。新版仅探测会替换、删除或备份的程序路径;完整清单语法、重复项、运行环境指纹、公钥及签名验证仍保留。 + +已有部署若无法通过界面更新,将生成的“修复更新检查.cmd”放入原 QualityCenter 文件夹双击,再回到“任务与监控 → 系统更新”检查更新。修复只接受已知程序摘要,备份后原子替换更新检查程序及其清单摘要;保留版本、数据、配置、缓存修复和信任公钥,不重启服务、不导入数据库。更新或恢复任务运行期间拒绝修复。 diff --git a/deploy/offline/repair_windows_update_check.py b/deploy/offline/repair_windows_update_check.py new file mode 100644 index 0000000..10e68cc --- /dev/null +++ b/deploy/offline/repair_windows_update_check.py @@ -0,0 +1,131 @@ +"""原地修复 Windows 更新检查超时,只替换已知版本的检查程序及清单摘要。""" +from __future__ import annotations +from contextlib import contextmanager +from datetime import datetime +import base64 +import hashlib +import json +import os +from pathlib import Path +import tempfile +import uuid + +SCRIPT = 'deploy/offline/update_manager.py' +OLD_SHA = '29512f15a9ee329bc7c7777454bdd79aa7ffd11c3cffa9400b8a4585bdabf35b' +NEW_SHA = 'b91cb7fec10e183d2904d86f032ff0ffcf7f19f7cb27aecd2d803d3448685482' +PATCHED_SCRIPT = base64.b64decode('#!/usr/bin/env python3
"""Signed Windows standalone application updates. No caller-supplied URLs or paths.

The release envelope signs the *decoded payload bytes* with Ed25519. Runtime
identity is SHA256(canonical({runtimes, pythonWheels})). Program files are a full
snapshot; private data and runtimes are never update destinations.
"""
from __future__ import annotations

import argparse
import base64
import contextlib
from datetime import datetime, timezone
import hashlib
import json
import os
from pathlib import Path, PurePosixPath
import re
import secrets
import shutil
import stat
import subprocess
import sys
import time
import zipfile
from urllib.request import ProxyHandler, HTTPRedirectHandler, build_opener

import psutil
from cryptography.hazmat.primitives.serialization import load_pem_public_key
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

ROOT = Path(__file__).resolve().parents[2]
BASE = 'https://quality.lyunlab.me/quality-updates/windows-x64/'
LATEST = BASE + 'latest.json'
KEY = 'deploy/offline/update-public-key.pem'
MAX_MANIFEST = 16 * 1024 * 1024
MAX_ARCHIVE = 2 * 1024**3
MAX_EXPANDED = 4 * 1024**3
ACTIVE = {'queued', 'downloading', 'backingUp', 'installing', 'restarting', 'rollingBack'}
SHA = re.compile(r'[a-f0-9]{64}')


class UpdateError(RuntimeError):
    pass


class BusyUpdate(UpdateError):
    pass


def canonical(value):
    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(',', ':')).encode('utf-8')


def unique_object(pairs):
    value = {}
    for key, item in pairs:
        if key in value:
            raise UpdateError('更新清单包含重复字段。')
        value[key] = item
    return value


def decode(raw):
    return json.loads(raw, object_pairs_hook=unique_object)


def digest(path):
    with path.open('rb') as stream:
        return hashlib.file_digest(stream, 'sha256').hexdigest()


def atomic(path, value):
    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
    temporary = path.with_name(path.name + '.' + secrets.token_hex(6) + '.tmp')
    with temporary.open('xb') as stream:
        stream.write(canonical(value))
        stream.flush()
        os.fsync(stream.fileno())
    temporary.replace(path)


def copy_atomic(source, target):
    target.parent.mkdir(parents=True, exist_ok=True)
    temporary = target.with_name(target.name + '.update-' + 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())
        shutil.copystat(source, temporary)
        temporary.replace(target)
    finally:
        temporary.unlink(missing_ok=True)


def read(path, default=None):
    return decode(path.read_bytes()) if path.exists() else default


def runtime_fingerprint(manifest):
    return hashlib.sha256(canonical({key: manifest.get(key, []) for key in ('runtimes', 'pythonWheels')})).hexdigest()


def safe_path(name):
    if (not isinstance(name, str) or not name or len(name) > 230 or '\\' in name
            or ':' in name or '\x00' in name or name.startswith('/')
            or any(ord(c) < 32 for c in name)):
        raise UpdateError('更新文件路径无效。')
    parts = name.split('/')
    if any(p in ('', '.', '..') or p.endswith((' ', '.'))
           or re.fullmatch(r'(?i)(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?', p) for p in parts):
        raise UpdateError('更新文件路径无效。')
    return PurePosixPath(name)


def program_path(name):
    path = safe_path(name)
    if name == KEY or name.startswith('deploy/bootstrap/'):
        return False  # immutable trust anchor, even in a correctly signed release
    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 destination(root, name):
    safe_path(name)
    target = root.joinpath(*name.split('/'))
    for path in (target, *target.parents):
        if path == root:
            break
        if path.is_symlink():
            raise UpdateError('更新目录包含符号链接，已停止更新。')
        if os.name == 'nt' and path.exists() and getattr(path.lstat(), 'st_file_attributes', 0) & stat.FILE_ATTRIBUTE_REPARSE_POINT:
            raise UpdateError('更新目录包含重解析点，已停止更新。')
    if not target.resolve().is_relative_to(root.resolve()):
        raise UpdateError('更新文件超出程序目录。')
    return target


def entry_map(entries, program_only=False):
    if not isinstance(entries, list) or len(entries) > 50000:
        raise UpdateError('更新文件清单无效。')
    result, folded = {}, set()
    for entry in entries:
        if not isinstance(entry, dict):
            raise UpdateError('更新文件清单无效。')
        name = entry.get('path')
        safe_path(name)
        if name.casefold() in folded:
            raise UpdateError('更新文件路径重复。')
        folded.add(name.casefold())
        if program_only and not program_path(name):
            raise UpdateError('更新包含不允许替换的文件。')
        if entry.get('symlink') is not None or not SHA.fullmatch(str(entry.get('sha256', ''))):
            raise UpdateError('更新文件校验信息无效。')
        result[name] = entry
    return result


def validate_release(envelope, root=ROOT):
    try:
        raw = base64.b64decode(envelope['payload'], validate=True)
        signature = base64.b64decode(envelope['signature'], validate=True)
        key = load_pem_public_key(destination(root, KEY).read_bytes())
        if not isinstance(key, Ed25519PublicKey):
            raise ValueError('key type')
        key.verify(signature, raw)
        release = decode(raw)
    except Exception as error:
        raise UpdateError('更新签名验证失败。') from error
    current = read(root / 'manifest.json')
    if release.get('schema') != 1 or release.get('platform') != 'windows-x64':
        raise UpdateError('更新包不适用于此系统。')
    if not isinstance(release.get('version'), str) or not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9._-]{0,79}', release['version']):
        raise UpdateError('更新版本无效。')
    if type(release.get('sequence')) is not int or release['sequence'] <= 0:
        raise UpdateError('更新版本序号无效。')
    if release.get('runtimeFingerprint') != runtime_fingerprint(current):
        raise UpdateError('运行环境版本不同，请使用完整安装包更新。')
    archive = release.get('archive', {})
    if (not re.fullmatch(r'quality-update-[A-Za-z0-9][A-Za-z0-9._-]{0,100}\.zip', str(archive.get('file', '')))
            or type(archive.get('size')) is not int or not 0 < archive['size'] <= MAX_ARCHIVE
            or not SHA.fullmatch(str(archive.get('sha256', '')))):
        raise UpdateError('更新下载信息无效。')
    files = entry_map(release.get('files'), True)
    if not files or any(type(e.get('size')) is not int or e['size'] < 0 for e in files.values()) or sum(e['size'] for e in files.values()) > MAX_EXPANDED:
        raise UpdateError('更新文件大小无效。')
    if 'bundleManifest' in release:
        raise UpdateError('更新清单不能包含部署数据。')
    old_files = entry_map(current.get('files'))
    required = {'app/backend.jar', 'deploy/offline/control.py', 'deploy/offline/update_manager.py',
                'backend/src/main/resources/analysis-runtime-policy.json'}
    if not required.issubset(files) or not any(name.startswith('app/web/') for name in files):
        raise UpdateError('更新缺少必要程序文件。')
    if KEY not in old_files or digest(destination(root, KEY)) != old_files[KEY]['sha256']:
        raise UpdateError('更新信任公钥校验失败。')
    # 只探测本次会备份、删除或替换的程序路径；运行环境保持原样。
    # 完整清单仍逐项验证路径语法、重复项、摘要以及运行环境指纹。
    old_program = {name for name in old_files if program_path(name)}
    for name in old_program | set(files):
        destination(root, name)
    return release


class NoRedirect(HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        raise UpdateError('更新服务器返回了不允许的跳转。')


def download(url, target=None, expected_size=None, expected_hash=None):
    if url != LATEST and not (url.startswith(BASE) and re.fullmatch(r'quality-update-[A-Za-z0-9][A-Za-z0-9._-]{0,100}\.zip', url[len(BASE):])):
        raise UpdateError('更新下载地址无效。')
    limit = expected_size if expected_size is not None else MAX_MANIFEST
    hasher, count, chunks = hashlib.sha256(), 0, []
    with build_opener(ProxyHandler({}), NoRedirect()).open(url, timeout=30) as response:
        if response.geturl() != url or response.status != 200:
            raise UpdateError('更新服务器响应无效。')
        with target.open('xb') if target is not None else contextlib.nullcontext() as stream:
            while block := response.read(1024 * 1024):
                count += len(block)
                if count > limit:
                    raise UpdateError('更新下载大小不符合清单。')
                hasher.update(block)
                if stream is not None:
                    stream.write(block)
                else:
                    chunks.append(block)
    if expected_size is not None and (count != expected_size or hasher.hexdigest() != expected_hash):
        raise UpdateError('更新下载校验失败。')
    return b''.join(chunks)


def unpack(archive, stage, release):
    entries = {e['path']: e for e in release['files']}
    with zipfile.ZipFile(archive) as source:
        seen = set()
        for member in source.infolist():
            name = member.filename
            if name not in entries or name in seen or member.is_dir() or member.flag_bits & 1:
                raise UpdateError('更新压缩包文件清单不符。')
            seen.add(name)
            if stat.S_ISLNK(member.external_attr >> 16) or member.file_size != entries[name]['size']:
                raise UpdateError('更新压缩包文件类型或大小不符。')
            target = destination(stage, name)
            target.parent.mkdir(parents=True, exist_ok=True)
            count = 0
            with source.open(member) as reader, target.open('xb') as writer:
                while block := reader.read(1024 * 1024):
                    count += len(block)
                    if count > entries[name]['size']:
                        raise UpdateError('更新解压大小不符。')
                    writer.write(block)
            if digest(target) != entries[name]['sha256']:
                raise UpdateError('更新解压校验失败。')
        if seen != set(entries):
            raise UpdateError('更新压缩包缺少文件。')


def enabled(root=ROOT):
    return os.name == 'nt' and os.environ.get('QUALITY_UPDATE_ENABLED') == 'true' and (root / 'runtimes/python/python.exe').is_file() and (root / 'manifest.json').is_file()


def status(root=ROOT):
    manifest = read(root / 'manifest.json', {})
    value = read(root / '.runtime/update/status.json', {})
    allowed = {'state', 'message', 'checkedAt', 'version', 'available', 'startedAt', 'finishedAt'}
    result = {k: v for k, v in value.items() if k in allowed}
    result.update(enabled=enabled(root), currentVersion=manifest.get('updateVersion', manifest.get('builtAtUtc', '当前版本')))
    result.setdefault('state', 'idle')
    if result['state'] in ACTIVE and not live(read(root / '.runtime/update/worker.json', {})):
        pending = read(root / '.runtime/update/request.json', {})
        journal = read(root / '.runtime/update/journal.json', {})
        if time.time() - pending.get('created', 0) > 120:
            result.update(state='failed', available=False, message='更新进程已中断，请重新运行软件启动入口恢复。'
                          if journal.get('phase') not in (None, 'complete', 'rolledBack') else '更新进程已结束，请重新检查更新。')
    if not result['enabled']:
        result['message'] = '此部署不支持软件内更新。'
    return result


def write_status(state, message, root=ROOT, **extra):
    destination(root, '.runtime/update/status.json')
    value = read(root / '.runtime/update/status.json', {})
    value.update(extra, state=state, message=message)
    atomic(root / '.runtime/update/status.json', value)
    return status(root)


def check(root=ROOT):
    release = validate_release(decode(download(LATEST)), root)
    available = release['sequence'] > read(root / 'manifest.json').get('updateSequence', 0)
    atomic(root / '.runtime/update/checked.json', release)
    return write_status('available' if available else 'current', '发现新版本。' if available else '已是最新版本。', root,
                        version=release['version'], available=available, checkedAt=datetime.now(timezone.utc).isoformat())


def process_options():
    return {'creationflags': subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_BREAKAWAY_FROM_JOB} if os.name == 'nt' else {'start_new_session': True}


@contextlib.contextmanager
def exclusive_update(root=ROOT):
    directory = root / '.runtime/update'
    destination(root, '.runtime/update')
    directory.mkdir(parents=True, exist_ok=True)
    if live(read(directory / 'worker.json', {})):
        raise BusyUpdate('已有更新或恢复正在进行。')
    sys.path.insert(0, str(root / 'scripts'))
    from runtime_platform import fcntl
    with (directory / 'worker.lock').open('a+b') as lock:
        try:
            fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
        except (BlockingIOError, OSError):
            raise BusyUpdate('已有更新或恢复正在进行。') from None
        identity = {'pid': os.getpid(), 'created': psutil.Process().create_time()}
        atomic(directory / 'worker.json', identity)
        try:
            yield
        finally:
            if read(directory / 'worker.json', {}) == identity:
                (directory / 'worker.json').unlink(missing_ok=True)


def launch(root=ROOT):
    with exclusive_update(root):
        return launch_locked(root)


def launch_locked(root=ROOT):
    directory = root / '.runtime/update'
    destination(root, '.runtime/update')
    directory.mkdir(parents=True, exist_ok=True)
    # This short launcher MUST exit before its worker may stop Java. The worker
    # verifies launcher disappearance; DETACHED alone does not remove ancestry.
    pending = read(directory / 'request.json', {})
    if pending and time.time() - pending.get('created', 0) < 120:
        raise BusyUpdate('已有更新正在启动。')
    check(root)  # refetch and verify; do not trust browser or cached JSON
    if not status(root).get('available'):
        return status(root)
    token = secrets.token_hex(16)
    atomic(directory / 'request.json', {'token': token, 'created': time.time()})
    write_status('queued', '更新已开始，完成后将自动重新连接。', root, startedAt=datetime.now(timezone.utc).isoformat(), available=False)
    try:
        with (directory / 'worker.log').open('ab') as log:
            subprocess.Popen([sys.executable, str(Path(__file__).resolve()), 'worker', '--launcher', str(os.getpid()), '--token', token],
                             cwd=root, env=os.environ.copy(), stdin=subprocess.DEVNULL, stdout=log, stderr=log, **process_options())
    except Exception:
        (directory / 'request.json').unlink(missing_ok=True)
        raise UpdateError('独立更新进程无法启动，服务仍在运行。') from None
    return status(root)


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, KeyError, TypeError):
        return False


def controller(root, action, database_only=False, timeout=1100):
    python = root / 'runtimes/python' / ('python.exe' if os.name == 'nt' else 'bin/python3')
    command = [str(python), str(root / 'deploy/offline/control.py'), action]
    if database_only:
        command += ['--database-only']
    if action == 'serve':
        with (root / '.runtime/update/service.log').open('ab') as log:
            return subprocess.Popen(command, cwd=root, env=os.environ.copy(), stdin=subprocess.DEVNULL, stdout=log, stderr=log, **process_options())
    result = subprocess.run(command, cwd=root, env=os.environ.copy(), stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout)
    if result.returncode:
        raise UpdateError('服务启停失败，请查看本机更新日志。')
    return result


def wait_ready(root, process, database_only=False):
    deadline = time.monotonic() + (180 if database_only else 1000)
    while time.monotonic() < deadline:
        state = read(root / '.runtime/service.json', {})
        if state.get('ready') and state.get('databaseOnly', False) == database_only and state.get('supervisor', {}).get('pid') == process.pid:
            return
        if process.poll() is not None:
            raise UpdateError('更新后服务启动失败，正在恢复旧版本。')
        time.sleep(.5)
    raise UpdateError('更新后服务启动超时，正在恢复旧版本。')


def mysql(root, config, binary='mysql', database=None, stdin=None, stdout=subprocess.PIPE):
    exe = '.exe' if os.name == 'nt' else ''
    command = [str(root / 'runtimes/mysql/bin' / (binary + exe)), '--no-defaults', '--protocol=TCP', '--host=127.0.0.1',
               '--port=' + str(config['mysqlPort']), '--user=root', '--default-character-set=utf8mb4']
    if binary == 'mysqldump':
        command += ['--single-transaction', '--routines', '--events', '--triggers', '--hex-blob', '--no-tablespaces', '--set-gtid-purged=OFF', config.get('mysqlDatabase', 'quality_platform')]
    elif database:
        command.append(database)
    if binary == 'mysql':
        command.append('--connect-timeout=10')
    env = os.environ.copy()
    env['MYSQL_PWD'] = config['rootPassword']
    result = subprocess.run(command, cwd=root, env=env, stdin=stdin, stdout=stdout, stderr=subprocess.PIPE, timeout=3600)
    if result.returncode:
        error_log = destination(root, '.runtime/update/database-error.log')
        with error_log.open('ab') as log:
            log.write((binary + ' failed\n').encode() + result.stderr[-16384:] + b'\n')
        raise UpdateError('数据库备份或恢复失败，已保留本机备份和原数据库。')


def sql(root, config, query):
    # stdin must be a real file on Windows; do not place passwords in arguments.
    path = root / '.runtime/update/query.sql'
    try:
        path.write_text(query, encoding='utf-8')
        with path.open('rb') as source:
            mysql(root, config, stdin=source)
    finally:
        path.unlink(missing_ok=True)


def backup_program(root, backup, release):
    current = read(root / 'manifest.json')
    names = sorted({e['path'] for e in current['files'] if program_path(e['path'])} | {e['path'] for e in release['files']})
    present = []
    for name in names:
        source = destination(root, name)
        if source.exists():
            target = destination(backup / 'program', name)
            target.parent.mkdir(parents=True, exist_ok=True)
            copy_atomic(source, target)
            present.append(name)
    copy_atomic(root / 'manifest.json', backup / 'manifest.json')
    # All private configuration (AI keys, deployment credentials and bootstrap
    # flags) is backed up locally, but never becomes a release payload.
    shutil.copytree(root / '.runtime', backup / 'private', ignore=shutil.ignore_patterns('update', '*.lock', '*.log', 'service.json', 'stop-request.json'), symlinks=False)
    for path in (backup / 'private').rglob('*'):
        if path.is_file():
            with path.open('rb') as stream:
                os.fsync(stream.fileno())
    atomic(backup / 'program.json', {'all': names, 'present': present})


def replace_program(root, stage, backup, release):
    current = read(root / 'manifest.json')
    names = read(backup / 'program.json')['all']
    wanted = {e['path'] for e in release['files']}
    for name in names:
        target = destination(root, name)
        if name in wanted:
            copy_atomic(stage / name, target)
        else:
            target.unlink(missing_ok=True)
    current['files'] = ([e for e in current['files'] if not program_path(e['path'])]
                        + [{'path': e['path'], 'sha256': e['sha256']} for e in release['files']])
    current.update(updateSequence=release['sequence'], updateVersion=release['version'])
    atomic(root / 'manifest.json', current)


def restore_program(root, backup):
    names = read(backup / 'program.json')
    for name in names['all']:
        target = destination(root, name)
        if name in names['present']:
            copy_atomic(backup / 'program' / name, target)
        else:
            target.unlink(missing_ok=True)
    copy_atomic(backup / 'manifest.json', destination(root, 'manifest.json'))
    for source in (backup / 'private').rglob('*'):
        if source.is_file():
            relative = source.relative_to(backup / 'private').as_posix()
            copy_atomic(source, destination(root, '.runtime/' + relative))


def rollback(root, backup, database_backed_up):
    write_status('rollingBack', '更新未完成，正在恢复原版本。', root)
    controller(root, 'stop', timeout=180)
    restore_program(root, backup)
    if database_backed_up:
        config = read(root / '.runtime/deployment.json')
        process = controller(root, 'serve', True)
        wait_ready(root, process, True)
        database = 'quality_restore_' + secrets.token_hex(12)
        sql(root, config, f'CREATE DATABASE `{database}` CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;')
        with (backup / 'database.sql').open('rb') as source:
            mysql(root, config, database=database, stdin=source)
        sql(root, config, f"GRANT ALL PRIVILEGES ON `{database}`.* TO 'quality_app'@'127.0.0.1';")
        controller(root, 'stop', timeout=180)
        config['mysqlDatabase'] = database
        atomic(root / '.runtime/deployment.json', config)
        receipt_path = root / '.runtime/migration-receipt.json'
        receipt = read(receipt_path, {})
        if receipt and receipt.get('migrationId') == config.get('restoredFromMigration'):
            receipt['database'] = database
            atomic(receipt_path, receipt)
    process = controller(root, 'serve')
    wait_ready(root, process)


def worker(launcher, token, root=ROOT):
    directory = root / '.runtime/update'
    for _ in range(300):
        if not psutil.pid_exists(launcher):
            break
        time.sleep(.1)
    else:
        raise UpdateError('更新启动器未退出，已安全停止。')
    if any('java' in p.name().lower() for p in psutil.Process().parents()):
        raise UpdateError('更新进程未独立启动，已安全停止。')
    if read(directory / 'request.json', {}).get('token') != token:
        raise UpdateError('更新请求已失效。')
    with exclusive_update(root):
        backup = directory / ('backup-' + datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ') + '-' + secrets.token_hex(4))
        stopped = backed_up = program_saved = changed = False
        try:
            envelope = decode(download(LATEST))
            release = validate_release(envelope, root)
            if release['sequence'] <= read(root / 'manifest.json').get('updateSequence', 0):
                raise UpdateError('此更新版本已安装。')
            backup.mkdir()
            archive, stage = backup / 'update.zip', backup / 'stage'
            expanded = sum(entry['size'] for entry in release['files'])
            # Keep enough headroom for extraction, old program files and a
            # logical dump; the dump itself must complete before replacement.
            db_size = sum(p.stat().st_size for p in (root / 'runtimedata/mysql').rglob('*') if p.is_file())
            old_program_size = sum((root / entry['path']).stat().st_size for entry in read(root / 'manifest.json')['files'] if program_path(entry['path']) and (root / entry['path']).is_file())
            private_size = sum(p.stat().st_size for p in (root / '.runtime').rglob('*') if p.is_file() and not p.is_relative_to(directory))
            if shutil.disk_usage(root).free < release['archive']['size'] + expanded + old_program_size + private_size + db_size * 3 + 512 * 1024**2:
                raise UpdateError('磁盘剩余空间不足，请释放空间后重试。')
            write_status('downloading', '正在下载并校验更新。', root)
            info = release['archive']
            download(BASE + info['file'], archive, info['size'], info['sha256'])
            unpack(archive, stage, release)
            # Revalidate immediately before any service or disk mutation.
            validate_release(envelope, root)
            write_status('backingUp', '正在备份，服务即将重新启动。', root)
            atomic(directory / 'journal.json', {'backup': backup.name, 'phase': 'stopping', 'databaseBackedUp': False})
            controller(root, 'stop', timeout=180)
            stopped = True
            backup_program(root, backup, release)
            program_saved = True
            config = read(root / '.runtime/deployment.json')
            database = controller(root, 'serve', True)
            wait_ready(root, database, True)
            with (backup / 'database.sql').open('xb') as output:
                mysql(root, config, 'mysqldump', stdout=output)
                output.flush()
                os.fsync(output.fileno())
            if (backup / 'database.sql').stat().st_size < 100:
                raise UpdateError('数据库备份为空，已停止更新。')
            backed_up = True
            controller(root, 'stop', timeout=180)
            # The actual dump can exceed the source's physical storage. Do not
            # replace anything unless a separate rollback database still fits.
            required_recovery = max(db_size, (backup / 'database.sql').stat().st_size * 3) + 512 * 1024**2
            if shutil.disk_usage(root).free < required_recovery:
                raise UpdateError('备份已完成，但剩余磁盘空间不足以安全回退，已停止更新。')
            atomic(directory / 'journal.json', {'backup': backup.name, 'phase': 'installing', 'databaseBackedUp': True,
                   'backupManifestSha256': digest(backup / 'manifest.json'),
                   'programInventorySha256': digest(backup / 'program.json')})
            write_status('installing', '正在安装更新。', root)
            changed = True
            replace_program(root, stage, backup, release)
            controller(root, 'verify', timeout=180)
            write_status('restarting', '正在重新启动，请稍候。', root)
            process = controller(root, 'serve')
            wait_ready(root, process)
            atomic(directory / 'journal.json', {'backup': backup.name, 'phase': 'complete', 'databaseBackedUp': True})
            write_status('completed', '更新完成。', root, version=release['version'], finishedAt=datetime.now(timezone.utc).isoformat(), available=False)
        except Exception as error:
            message = str(error) if isinstance(error, UpdateError) else '更新未完成，请查看本机更新日志。'
            if stopped:
                try:
                    if program_saved and changed:
                        rollback(root, backup, backed_up)
                    else:
                        controller(root, 'stop', timeout=180)
                        process = controller(root, 'serve')
                        wait_ready(root, process)
                    atomic(directory / 'journal.json', {'backup': backup.name, 'phase': 'rolledBack', 'databaseBackedUp': backed_up})
                    message += ' 已恢复原版本。'
                except Exception:
                    message += ' 自动恢复未完成，请联系管理员使用本机更新备份恢复。'
            write_status('failed', message, root, available=False, finishedAt=datetime.now(timezone.utc).isoformat())
        finally:
            (directory / 'request.json').unlink(missing_ok=True)


def recover(root=ROOT):
    with exclusive_update(root):
        return recover_locked(root)


def recover_locked(root=ROOT):
    directory = root / '.runtime/update'
    journal = read(directory / 'journal.json', {})
    if journal.get('phase') in (None, 'complete', 'rolledBack'):
        return status(root)
    name = journal.get('backup', '')
    if not re.fullmatch(r'backup-[0-9]{8}T[0-9]{6}Z-[a-f0-9]{8}', name):
        raise UpdateError('更新恢复记录无效。')
    backup = directory / name
    if journal.get('phase') == 'installing':
        if (digest(backup / 'manifest.json') != journal.get('backupManifestSha256')
                or digest(backup / 'program.json') != journal.get('programInventorySha256')):
            raise UpdateError('更新恢复备份校验失败，已保留现场。')
        rollback(root, backup, journal.get('databaseBackedUp') is True)
    else:
        controller(root, 'stop', timeout=180)
        process = controller(root, 'serve')
        wait_ready(root, process)
    atomic(directory / 'journal.json', {**journal, 'phase': 'rolledBack'})
    return write_status('failed', '上次更新中断，已恢复原版本。', root, available=False)


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('action', choices=('status', 'check', 'launch', 'worker', 'recover'))
    parser.add_argument('--launcher', type=int)
    parser.add_argument('--token')
    args = parser.parse_args()
    if args.action == 'status':
        return status()
    if not enabled():
        raise UpdateError('此部署不支持软件内更新。')
    if args.action == 'worker':
        if not args.launcher or not re.fullmatch(r'[a-f0-9]{32}', args.token or ''):
            raise UpdateError('更新请求无效。')
        worker(args.launcher, args.token)
        return status()
    if args.action == 'recover':
        return recover()
    journal = read(ROOT / '.runtime/update/journal.json', {})
    if journal.get('phase') not in (None, 'complete', 'rolledBack'):
        raise UpdateError('上次更新中断，请重新运行软件启动入口恢复。')
    if live(read(ROOT / '.runtime/update/worker.json', {})):
        raise BusyUpdate('已有更新正在进行。')
    return check() if args.action == 'check' else launch()


if __name__ == '__main__':
    try:
        print(json.dumps(main(), ensure_ascii=False))
    except Exception as error:
        message = str(error) if isinstance(error, UpdateError) else '更新服务暂不可用，请稍后重试。'
        if enabled() and not isinstance(error, BusyUpdate) and sys.argv[1:2] != ['status'] and not live(read(ROOT / '.runtime/update/worker.json', {})):
            write_status('failed', message)
        print(json.dumps({'error': message}, ensure_ascii=False))
        raise SystemExit(1)
') + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def local(root, name): + path = root / name + if path.is_symlink() or not path.resolve().is_relative_to(root): + raise RuntimeError('修复路径异常,已停止。') + return path + + +def atomic(path, data): + fd, name = tempfile.mkstemp(prefix=path.name + '.repair-', suffix='.tmp', dir=path.parent) + try: + with os.fdopen(fd, 'wb') as stream: + stream.write(data) + stream.flush() + os.fsync(stream.fileno()) + os.replace(name, path) + finally: + Path(name).unlink(missing_ok=True) + + +@contextmanager +def update_lock(root): + root = Path(root).resolve() + private = local(root, '.runtime') + private.mkdir(exist_ok=True) + local(root, '.runtime/update').mkdir(exist_ok=True) + with local(root, '.runtime/update/worker.lock').open('a+b') as stream: + if os.name == 'nt': + import msvcrt + stream.seek(0) + try: + msvcrt.locking(stream.fileno(), msvcrt.LK_NBLCK, 1) + except OSError: + raise RuntimeError('更新任务仍在运行,请等待结束后再运行本修复。') from None + try: + yield + finally: + stream.seek(0) + msvcrt.locking(stream.fileno(), msvcrt.LK_UNLCK, 1) + else: + import fcntl + try: + fcntl.flock(stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) + except BlockingIOError: + raise RuntimeError('更新任务仍在运行,请等待结束后再运行本修复。') from None + yield + + +def repair(root): + root = Path(root).resolve() + manifest_path = local(root, 'manifest.json') + script = local(root, SCRIPT) + if not manifest_path.is_file() or not script.is_file() or not local(root, 'deploy/bootstrap/windows-start.ps1').is_file(): + raise RuntimeError('请将本文件放到原 QualityCenter 目录,与“一键部署启动.cmd”并列后运行。') + with update_lock(root): + if local(root, '.runtime/update/worker.json').exists(): + raise RuntimeError('存在更新或恢复任务,请等待任务结束;不要在更新中运行修复。') + journal = local(root, '.runtime/update/journal.json') + if journal.exists() and json.loads(journal.read_text(encoding='utf-8')).get('phase') not in (None, 'complete', 'rolledBack'): + raise RuntimeError('上次更新尚未恢复完成,请先使用原启动入口恢复。') + before_manifest, before_script = manifest_path.read_bytes(), script.read_bytes() + manifest = json.loads(before_manifest.decode('utf-8-sig')) + if manifest.get('platform') != 'windows': + raise RuntimeError('本修复仅适用于 Windows 离线包。') + entries = manifest['files'] + if len({entry['path'] for entry in entries}) != len(entries): + raise RuntimeError('文件清单存在重复路径,未修改。') + selected = [entry for entry in entries if entry['path'] == SCRIPT] + actual = sha(before_script) + if len(selected) != 1 or selected[0].get('sha256') not in {OLD_SHA, NEW_SHA} or actual not in {OLD_SHA, NEW_SHA}: + raise RuntimeError('更新检查脚本版本与本修复不匹配,未覆盖现有程序。') + if actual == NEW_SHA and selected[0]['sha256'] == NEW_SHA: + return {'alreadyRepaired': True, 'changedFiles': 0} + after_script = PATCHED_SCRIPT + if sha(after_script) != NEW_SHA: + raise RuntimeError('修复内容校验失败,未修改。') + selected[0]['sha256'] = NEW_SHA + after_manifest = (json.dumps(manifest, ensure_ascii=False, indent=2) + '\n').encode('utf-8') + backup = local(root, '.runtime/update-check-repair-backups') / (datetime.now().strftime('%Y%m%d-%H%M%S') + '-' + uuid.uuid4().hex[:8]) + backup.mkdir(parents=True, mode=0o700) + (backup / 'manifest.json').write_bytes(before_manifest) + (backup / 'update_manager.py').write_bytes(before_script) + if manifest_path.read_bytes() != before_manifest or script.read_bytes() != before_script: + raise RuntimeError('文件正被其他进程更新,未执行修复。') + try: + atomic(script, after_script) + atomic(manifest_path, after_manifest) + except BaseException: + atomic(script, before_script) + atomic(manifest_path, before_manifest) + raise + return {'changedFiles': 2, 'backup': str(backup.relative_to(root)), 'updateCheckRepaired': True} + + +def command_file(): + header = '@echo off\nsetlocal\nchcp 65001 >nul\nset "PYTHONUTF8=1"\nset "PYTHONIOENCODING=utf-8"\nset "PYTHONDONTWRITEBYTECODE=1"\nif not exist "%~dp0runtimes\\python\\python.exe" (\n echo 请将本文件放入原 QualityCenter 文件夹,与一键部署启动放在一起。\n pause\n exit /b 1\n)\n"%~dp0runtimes\\python\\python.exe" -I -S -B -X utf8 -c "import sys;from pathlib import Path;p=Path(sys.argv[1]);s=p.read_text(encoding=\'utf-8\').split(chr(10)+\'# QUALITY_UPDATE_CHECK_REPAIR_PYTHON\'+chr(10),1)[1];n={\'__name__\':\'quality_update_check_repair\'};exec(compile(s,str(p),\'exec\'),n);print(n[\'repair\'](p.parent))" "%~f0"\nif errorlevel 1 (\n echo 修复未完成,请保留上方报错;数据库及私有配置未覆盖。\n pause\n exit /b 1\n)\necho 更新检查已修复,无需停止服务或重新导入数据库。\necho 返回浏览器:任务与监控 → 系统更新 → 检查更新 → 更新并重启。\npause\nexit /b\n# QUALITY_UPDATE_CHECK_REPAIR_PYTHON\n' + return header.replace('\n', '\r\n').encode('utf-8') + Path(__file__).read_bytes() + + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--root', type=Path) + parser.add_argument('--write-command', type=Path) + args = parser.parse_args() + if args.write_command: + args.write_command.write_bytes(command_file()) + elif args.root: + print(json.dumps(repair(args.root), ensure_ascii=False)) + else: + parser.error('请选择 --root 或 --write-command') diff --git a/deploy/offline/test_update_manager.py b/deploy/offline/test_update_manager.py index d3392df..ece98ef 100644 --- a/deploy/offline/test_update_manager.py +++ b/deploy/offline/test_update_manager.py @@ -83,6 +83,26 @@ class UpdateTests(unittest.TestCase): self.assertEqual('2026.11.04', self.validate()['version']) self.assertEqual(update.runtime_fingerprint(self.manifest), update.runtime_fingerprint(copy.deepcopy(self.manifest))) + def test_check_does_not_probe_fourteen_thousand_immutable_runtime_paths(self): + self.manifest['files'] += [{'path': f'runtimes/python/Lib/library-{i}.py', 'sha256': 'a' * 64} + for i in range(14000)] + update.atomic(self.root / 'manifest.json', self.manifest) + with patch.object(update, 'destination', wraps=update.destination) as probe: + self.validate() + names = [call.args[1] for call in probe.call_args_list] + self.assertFalse(any(name.startswith('runtimes/') for name in names)) + self.assertLess(len(names), 100) + self.assertIn(update.KEY, names) + self.assertIn('app/web/obsolete.js', names) + + def test_obsolete_program_symlink_is_still_rejected_before_replacement(self): + target = self.root / 'app/web/obsolete-link' + target.symlink_to(Path(self.temp.name), target_is_directory=True) + self.manifest['files'].append({'path': 'app/web/obsolete-link/file.js', 'sha256': 'a' * 64}) + update.atomic(self.root / 'manifest.json', self.manifest) + with self.assertRaises(update.UpdateError): + self.validate() + def test_wrong_signature_key_and_modified_payload_are_rejected(self): with self.assertRaises(update.UpdateError): update.validate_release(self.envelope(private=Ed25519PrivateKey.generate()), self.root) diff --git a/deploy/offline/test_windows_update_check_repair.py b/deploy/offline/test_windows_update_check_repair.py new file mode 100644 index 0000000..57b5127 --- /dev/null +++ b/deploy/offline/test_windows_update_check_repair.py @@ -0,0 +1,117 @@ +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest +from unittest.mock import patch + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import repair_windows_update_check as fix +ORIGINAL_SHA = fix.OLD_SHA + + +class UpdateCheckRepairTest(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(prefix='quality source path repair ') + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) / '中文 QualityCenter & files' + self.root.mkdir() + self.original = b'original source fixture\n' + self.old_sha = hashlib.sha256(self.original).hexdigest() + self.guard = patch.object(fix, 'OLD_SHA', self.old_sha) + self.guard.start() + self.addCleanup(self.guard.stop) + for name, value in {fix.SCRIPT: self.original, + 'deploy/bootstrap/windows-start.ps1': b'original bootstrap', + 'migration/database.sql.gz': b'existing migration payload', + '.runtime/deployment.json': b'original private configuration', + 'runtimedata/mysql/retained-database': b'imported database data'}.items(): + target = self.root / name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(value) + self.manifest = {'platform': 'windows', 'updateVersion': '2026.11.04.1', 'updateSequence': 1, + 'runtimeFingerprint': 'unchanged', 'otherMetadata': {'keep': True}, + 'files': [{'path': fix.SCRIPT, 'sha256': self.old_sha}, + {'path': 'deploy/bootstrap/windows-start.ps1', 'sha256': 'unchanged'}]} + self.manifest_path = self.root / 'manifest.json' + self.manifest_path.write_text(json.dumps(self.manifest), encoding='utf-8') + + def test_backup_manifest_and_script_only_preserving_database_and_configuration(self): + private = {name: (self.root / name).read_bytes() for name in + ['migration/database.sql.gz', '.runtime/deployment.json', 'runtimedata/mysql/retained-database']} + result = fix.repair(self.root) + self.assertTrue(result['updateCheckRepaired']) + self.assertEqual((self.root / fix.SCRIPT).read_bytes(), fix.PATCHED_SCRIPT) + expected = json.loads(json.dumps(self.manifest)) + expected['files'][0]['sha256'] = fix.NEW_SHA + self.assertEqual(json.loads(self.manifest_path.read_text()), expected) + backup = self.root / result['backup'] + self.assertEqual((backup / 'update_manager.py').read_bytes(), self.original) + self.assertEqual(json.loads((backup / 'manifest.json').read_text()), self.manifest) + for name, value in private.items(): + self.assertEqual((self.root / name).read_bytes(), value) + self.assertTrue(fix.repair(self.root)['alreadyRepaired']) + + def test_modified_script_or_manifest_is_not_approved_as_a_repair(self): + before = self.manifest_path.read_bytes() + (self.root / fix.SCRIPT).write_bytes(b'unrecognized source') + with self.assertRaisesRegex(RuntimeError, '版本'): + fix.repair(self.root) + self.assertEqual(self.manifest_path.read_bytes(), before) + + def test_failed_second_write_restores_original_program_and_manifest(self): + before = self.manifest_path.read_bytes() + original_atomic = fix.atomic + calls = [] + def failing(path, data): + calls.append(path) + if len(calls) == 2: + raise OSError('simulated manifest write failure') + original_atomic(path, data) + with patch.object(fix, 'atomic', side_effect=failing), self.assertRaises(OSError): + fix.repair(self.root) + self.assertEqual((self.root / fix.SCRIPT).read_bytes(), self.original) + self.assertEqual(self.manifest_path.read_bytes(), before) + + def test_retry_completes_an_interrupted_script_manifest_pair(self): + (self.root / fix.SCRIPT).write_bytes(fix.PATCHED_SCRIPT) + fix.repair(self.root) + self.assertEqual(json.loads(self.manifest_path.read_text())['files'][0]['sha256'], fix.NEW_SHA) + + def test_cmd_payload_runs_with_bundled_standard_library_without_service_restart(self): + # 真实原包脚本由交付包集成验证;此单元测试使用受控旧源码摘要。 + command = self.root / '修复更新检查.cmd' + body = fix.command_file().decode('utf-8').replace(ORIGINAL_SHA, self.old_sha) + command.write_bytes(body.encode('utf-8')) + code = body.split(' -c "', 1)[1].split('" "%~f0"', 1)[0] + result = subprocess.run([sys.executable, '-I', '-S', '-B', '-X', 'utf8', '-c', code, str(command)], capture_output=True, text=True) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual((self.root / fix.SCRIPT).read_bytes(), fix.PATCHED_SCRIPT) + self.assertNotIn('powershell.exe', body) + self.assertIn('无需停止服务或重新导入数据库', body) + + def test_active_update_lock_blocks_patching(self): + before = self.manifest_path.read_bytes() + with fix.update_lock(self.root), self.assertRaisesRegex(RuntimeError, '仍在运行'): + fix.repair(self.root) + self.assertEqual(self.manifest_path.read_bytes(), before) + + def test_worker_or_unfinished_journal_blocks_repair(self): + for name, data in [('worker.json', {}), ('journal.json', {'phase': 'installing'})]: + path = self.root / '.runtime/update' / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(data)) + with self.assertRaises(RuntimeError): + fix.repair(self.root) + self.assertEqual((self.root / fix.SCRIPT).read_bytes(), self.original) + path.unlink() + + def test_embedded_program_matches_reviewed_source(self): + self.assertEqual(fix.PATCHED_SCRIPT, (HERE / 'update_manager.py').read_bytes()) + + +if __name__ == '__main__': + unittest.main() diff --git a/deploy/offline/update_manager.py b/deploy/offline/update_manager.py index 656cc3d..2683f2b 100644 --- a/deploy/offline/update_manager.py +++ b/deploy/offline/update_manager.py @@ -197,7 +197,10 @@ def validate_release(envelope, root=ROOT): raise UpdateError('更新缺少必要程序文件。') if KEY not in old_files or digest(destination(root, KEY)) != old_files[KEY]['sha256']: raise UpdateError('更新信任公钥校验失败。') - for name in set(old_files) | set(files): + # 只探测本次会备份、删除或替换的程序路径;运行环境保持原样。 + # 完整清单仍逐项验证路径语法、重复项、摘要以及运行环境指纹。 + old_program = {name for name in old_files if program_path(name)} + for name in old_program | set(files): destination(root, name) return release