from __future__ import annotations import ctypes import json import re import hashlib import os import shutil import subprocess import tempfile import time import urllib.request import zipfile from dataclasses import dataclass from pathlib import Path from typing import BinaryIO, Callable from .scanner import ScanResult JDK_PACKAGES = { "8": "EclipseAdoptium.Temurin.8.JDK", "11": "EclipseAdoptium.Temurin.11.JDK", "17": "EclipseAdoptium.Temurin.17.JDK", "21": "EclipseAdoptium.Temurin.21.JDK", } WINGET_PACKAGES = { "Gradle": "Gradle.Gradle", "Node.js": "OpenJS.NodeJS.LTS", "Git": "Git.Git", } MAVEN_VERSION = "3.10.0" MAVEN_ARCHIVE_NAME = f"apache-maven-{MAVEN_VERSION}-bin.zip" MAVEN_DOWNLOAD_BASE = f"https://dlcdn.apache.org/maven/maven-3/{MAVEN_VERSION}/binaries" TOMCAT_VERSION = "9.0.122" TOMCAT_ARCHIVE_NAME = f"apache-tomcat-{TOMCAT_VERSION}-windows-x64.zip" TOMCAT_DOWNLOAD_BASE = f"https://dlcdn.apache.org/tomcat/tomcat-9/v{TOMCAT_VERSION}/bin" MYSQL_VERSION = "8.0.43" MYSQL_ROOT_PASSWORD = "123456" MYSQL_INITIAL_ROOT_PASSWORD = "AutoDeploy#2026" MYSQL_INSTALLER_ARCHIVE_NAME = f"mysql-installer-community-{MYSQL_VERSION}.0.msi" MYSQL_INSTALLER_URL = ( "https://downloads.mysql.com/archives/get/p/25/file/" f"{MYSQL_INSTALLER_ARCHIVE_NAME}" ) MYSQL_INSTALLER_SHA256 = "F60502EB1EE10A9C1D0A26706A627D224DFAE466D82EF3EB9D76A8A718DB9D80" NODE_DIST_BASE = "https://nodejs.org/dist" ANSI_PATTERN = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]") PERCENT_PATTERN = re.compile(r"(\d{1,3})\s*%") PROGRESS_CHARS = "█▓▒░▏▎▍▌▋▊▉■□▪▫▬─━═|/-\\" @dataclass(frozen=True) class JdkRecommendation: version: str reason: str @dataclass(frozen=True) class NodeRecommendation: requirements: tuple[str, ...] reason: str @property def display_requirement(self) -> str: return " 且 ".join(self.requirements) @dataclass(frozen=True) class NodeRelease: version: str lts: str | bool def recommend_jdk_version(scan: ScanResult | None) -> JdkRecommendation: if not scan or not scan.backend: return JdkRecommendation("8", "\u672a\u626b\u63cf\u5230\u540e\u7aef\u7248\u672c\u4fe1\u606f\uff0c\u9ed8\u8ba4\u63a8\u8350 JDK 8\u3002") metadata = scan.backend.metadata java_version = metadata.get("java_version") if java_version: mapped = _map_java_version(java_version) source = metadata.get("java_version_source", "\u9879\u76ee\u914d\u7f6e") return JdkRecommendation(mapped, f"\u6839\u636e {source}={java_version} \u63a8\u8350 JDK {mapped}\u3002") boot_version = metadata.get("spring_boot_version", "") if boot_version.startswith("3."): return JdkRecommendation("17", f"Spring Boot 3.x \u9700\u8981 Java 17+\uff0c\u68c0\u6d4b\u5230 Spring Boot {boot_version}\uff0c\u63a8\u8350 JDK 17\u3002") if boot_version.startswith("2."): return JdkRecommendation("8", f"\u68c0\u6d4b\u5230 Spring Boot {boot_version}\uff0c\u9ed8\u8ba4\u63a8\u8350\u517c\u5bb9\u6027\u66f4\u597d\u7684 JDK 8\u3002") return JdkRecommendation("8", "\u672a\u53d1\u73b0\u660e\u786e Java \u7248\u672c\uff0c\u9ed8\u8ba4\u63a8\u8350 JDK 8\u3002") def recommend_node_version(scan: ScanResult | None) -> NodeRecommendation: if not scan or not scan.detected_frontends: return NodeRecommendation(("lts",), "未扫描到前端版本信息,使用 Node.js 最新 LTS。") requirements: list[str] = [] reasons: list[str] = [] for frontend in scan.detected_frontends: requirement = frontend.metadata.get("node_requirement", "").strip() source = frontend.metadata.get("node_requirement_source", "").strip() if requirement and requirement not in requirements: requirements.append(requirement) if requirement: name = frontend.metadata.get("display_name", frontend.path.name) reasons.append(f"{name}: {source or '项目配置'} → {requirement}") if not requirements: return NodeRecommendation(("lts",), "项目未声明 Node.js 版本,使用最新 LTS。") return NodeRecommendation(tuple(requirements), ";".join(reasons)) def build_install_command(tool_name: str, version: str | None = None) -> list[str]: if tool_name == "JDK": package_id = JDK_PACKAGES.get(version or "8") if not package_id: raise ValueError(f"\u4e0d\u652f\u6301\u7684 JDK \u7248\u672c: {version}") else: package_id = WINGET_PACKAGES.get(tool_name) if not package_id: raise ValueError(f"\u4e0d\u652f\u6301\u81ea\u52a8\u5b89\u88c5: {tool_name}") command = [ "winget", "install", "--exact", "--id", package_id, ] command.extend([ "--accept-source-agreements", "--accept-package-agreements", "--disable-interactivity", ]) return command def build_mysql_installer_command(installer_path: Path, log_path: Path) -> list[str]: return [ "msiexec.exe", "/i", str(installer_path), "/passive", "/norestart", "/L*V", str(log_path), ] def build_mysql_server_install_command(console_path: Path) -> list[str]: server = ( f"server;{MYSQL_VERSION};x64:*:" "type=config;open_win_firewall=false;tcp_ip=true;port=3306;" f"root_passwd={MYSQL_INITIAL_ROOT_PASSWORD}" ) return [ str(console_path), "--install", server, "--silent", "--auto-handle-prereqs", ] def default_mysql_install_log_path() -> Path: local_app_data = os.environ.get("LOCALAPPDATA", "").strip() base = Path(local_app_data) if local_app_data else Path.home() / ".autodeploy" return base / "AutoDeploy" / "logs" / "mysql-install.log" def find_mysql_executable() -> Path | None: discovered = shutil.which("mysql") if discovered: return Path(discovered) roots = [ Path(os.environ.get("ProgramFiles", r"C:\Program Files")), Path(os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)")), ] for root in roots: for relative in ( Path("MySQL") / "MySQL Server 8.0" / "bin" / "mysql.exe", Path("MySQL") / "MySQL Server 8.4" / "bin" / "mysql.exe", ): candidate = root / relative if candidate.exists(): return candidate return None def find_mysql_installer_console() -> Path | None: discovered = shutil.which("MySQLInstallerConsole") if discovered: return Path(discovered) roots = [ Path(os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)")), Path(os.environ.get("ProgramFiles", r"C:\Program Files")), ] for root in roots: candidate = root / "MySQL" / "MySQL Installer for Windows" / "MySQLInstallerConsole.exe" if candidate.exists(): return candidate return None def wait_for_mysql_installer_console(timeout: float = 30.0, poll_interval: float = 1.0) -> Path: deadline = time.monotonic() + timeout while True: executable = find_mysql_installer_console() if executable is not None: return executable if time.monotonic() >= deadline: raise RuntimeError("MySQL Installer 已结束,但未找到 MySQLInstallerConsole.exe。") time.sleep(poll_interval) def wait_for_mysql_executable(timeout: float = 90.0, poll_interval: float = 1.0) -> Path: deadline = time.monotonic() + timeout while True: executable = find_mysql_executable() if executable is not None: return executable if time.monotonic() >= deadline: raise RuntimeError("MySQL 安装命令已结束,但未找到 mysql.exe。") time.sleep(poll_interval) def configure_mysql_weak_password_policy( mysql_executable: Path, on_output: Callable[[str], None], initial_password: str = MYSQL_INITIAL_ROOT_PASSWORD, final_password: str = MYSQL_ROOT_PASSWORD, attempts: int = 30, retry_delay: float = 2.0, ) -> None: on_output("正在连接 MySQL,并永久启用 6 位弱密码策略...") variables_result: subprocess.CompletedProcess[str] | None = None for attempt in range(max(attempts, 1)): variables_result = _run_mysql_sql( mysql_executable, "SHOW VARIABLES LIKE 'validate_password%';", initial_password, ) if variables_result.returncode == 0: break if attempt + 1 < max(attempts, 1): time.sleep(retry_delay) assert variables_result is not None if variables_result.returncode != 0: detail = _process_error(variables_result) raise RuntimeError(f"无法使用 root 账号连接 MySQL,不能写入弱密码策略。{detail}") variable_names = variables_result.stdout.lower() statements: list[str] = [] if "validate_password.policy" in variable_names: statements.extend( [ "SET PERSIST validate_password.policy = 'LOW'", "SET PERSIST validate_password.length = 6", "SET PERSIST validate_password.mixed_case_count = 0", "SET PERSIST validate_password.number_count = 0", "SET PERSIST validate_password.special_char_count = 0", ] ) elif "validate_password_policy" in variable_names: statements.extend( [ "SET PERSIST validate_password_policy = 'LOW'", "SET PERSIST validate_password_length = 6", "SET PERSIST validate_password_mixed_case_count = 0", "SET PERSIST validate_password_number_count = 0", "SET PERSIST validate_password_special_char_count = 0", ] ) else: on_output("MySQL 未启用 validate_password 组件,当前已允许 6 位弱密码。") escaped_password = final_password.replace("'", "''") statements.append(f"ALTER USER 'root'@'localhost' IDENTIFIED BY '{escaped_password}'") configure_result = _run_mysql_sql( mysql_executable, ";\n".join(statements) + ";\n", initial_password, ) if configure_result.returncode != 0: detail = _process_error(configure_result) raise RuntimeError(f"MySQL 弱密码策略配置失败。{detail}") verify_result = _run_mysql_sql(mysql_executable, "SELECT 1;", final_password) if verify_result.returncode != 0: detail = _process_error(verify_result) raise RuntimeError(f"MySQL 已配置,但 root 登录验证失败。{detail}") on_output("MySQL 已永久允许 6 位弱密码,root 默认密码配置完成。") def install_mysql( on_output: Callable[[str], None], opener: Callable[..., BinaryIO] | None = None, elevated_runner: Callable[[list[str]], int] | None = None, log_path: Path | None = None, ) -> Path: open_url = opener or urllib.request.urlopen install_log = Path(log_path) if log_path is not None else default_mysql_install_log_path() console = find_mysql_installer_console() if console is None: install_log.parent.mkdir(parents=True, exist_ok=True) if install_log.exists(): install_log.unlink() with tempfile.TemporaryDirectory(prefix="autodeploy-mysql-") as temporary: installer_path = Path(temporary) / MYSQL_INSTALLER_ARCHIVE_NAME on_output(f"正在从 MySQL 官方归档地址下载 MySQL Installer {MYSQL_VERSION}...") _download_to_file(MYSQL_INSTALLER_URL, installer_path, open_url, on_output) actual_checksum = _sha256(installer_path) if actual_checksum.lower() != MYSQL_INSTALLER_SHA256.lower(): raise RuntimeError("MySQL 安装包 SHA-256 校验失败,已停止安装。") on_output("MySQL 安装包校验通过,正在请求管理员权限安装...") on_output("确认管理员授权后会显示 Windows Installer 进度窗口,请勿关闭 AutoDeploy。") on_output(f"MySQL 详细安装日志: {install_log}") command = build_mysql_installer_command(installer_path, install_log) if elevated_runner is None: exit_code = run_elevated_command( command, on_wait=lambda: on_output("MySQL Installer 正在安装,请继续等待进度窗口完成..."), ) else: exit_code = elevated_runner(command) if exit_code not in {0, 1641, 3010}: raise RuntimeError(f"MySQL Installer 安装失败,退出码: {exit_code}。详细日志: {install_log}") if exit_code in {1641, 3010}: on_output("MySQL Installer 安装完成,Windows 提示稍后需要重新启动。") console = wait_for_mysql_installer_console() on_output("MySQL Installer 已完成,正在启动 MySQL Server 安装任务...") else: on_output(f"检测到已有 MySQL Installer,将直接安装 MySQL Server: {console}") server_command = build_mysql_server_install_command(console) on_output("即将再次请求管理员权限,请在出现的窗口中确认安装 MySQL Server。") if elevated_runner is None: server_exit_code = run_elevated_command( server_command, on_wait=lambda: on_output("MySQL Server 仍在安装和配置,请继续等待..."), ) else: server_exit_code = elevated_runner(server_command) if server_exit_code not in {0, 1641, 3010}: raise RuntimeError(f"MySQL Server 安装失败,退出码: {server_exit_code}。") on_output("MySQL Server 安装任务已完成,正在检测命令行工具...") executable = wait_for_mysql_executable() configure_mysql_weak_password_policy(executable, on_output) return executable def run_elevated_command( command: list[str], on_wait: Callable[[], None] | None = None, wait_notice_interval: float = 30.0, ) -> int: if os.name != "nt": return subprocess.run(command, shell=False).returncode from ctypes import wintypes class ShellExecuteInfo(ctypes.Structure): _fields_ = [ ("cbSize", wintypes.DWORD), ("fMask", wintypes.ULONG), ("hwnd", wintypes.HWND), ("lpVerb", wintypes.LPCWSTR), ("lpFile", wintypes.LPCWSTR), ("lpParameters", wintypes.LPCWSTR), ("lpDirectory", wintypes.LPCWSTR), ("nShow", ctypes.c_int), ("hInstApp", wintypes.HINSTANCE), ("lpIDList", wintypes.LPVOID), ("lpClass", wintypes.LPCWSTR), ("hkeyClass", wintypes.HKEY), ("dwHotKey", wintypes.DWORD), ("hIcon", wintypes.HANDLE), ("hProcess", wintypes.HANDLE), ] shell_execute = ctypes.windll.shell32.ShellExecuteExW shell_execute.argtypes = [ctypes.POINTER(ShellExecuteInfo)] shell_execute.restype = wintypes.BOOL info = ShellExecuteInfo() info.cbSize = ctypes.sizeof(info) info.fMask = 0x00000040 # SEE_MASK_NOCLOSEPROCESS info.lpVerb = "runas" info.lpFile = command[0] info.lpParameters = subprocess.list2cmdline(command[1:]) info.nShow = 1 # SW_SHOWNORMAL: show the Windows Installer progress window. if not shell_execute(ctypes.byref(info)): error_code = ctypes.windll.kernel32.GetLastError() if error_code == 1223: raise RuntimeError("用户取消了 MySQL 安装所需的管理员授权。") raise OSError(error_code, "无法以管理员权限启动 MySQL 安装程序") try: wait_timeout_ms = 1000 wait_timeout = 0x00000102 wait_object_0 = 0x00000000 last_notice = time.monotonic() while True: wait_result = ctypes.windll.kernel32.WaitForSingleObject(info.hProcess, wait_timeout_ms) if wait_result == wait_object_0: break if wait_result != wait_timeout: raise OSError(ctypes.windll.kernel32.GetLastError(), "等待 MySQL 安装程序时发生错误") now = time.monotonic() if on_wait is not None and now - last_notice >= wait_notice_interval: on_wait() last_notice = now exit_code = wintypes.DWORD() if not ctypes.windll.kernel32.GetExitCodeProcess(info.hProcess, ctypes.byref(exit_code)): raise OSError(ctypes.windll.kernel32.GetLastError(), "无法读取 MySQL 安装程序退出码") return int(exit_code.value) finally: ctypes.windll.kernel32.CloseHandle(info.hProcess) def _run_mysql_sql(mysql_executable: Path, sql: str, password: str) -> subprocess.CompletedProcess[str]: environment = os.environ.copy() environment["MYSQL_PWD"] = password return subprocess.run( [ str(mysql_executable), "--protocol=TCP", "--host=127.0.0.1", "--user=root", "--batch", "--skip-column-names", ], input=sql, capture_output=True, text=True, timeout=15, shell=False, env=environment, ) def _process_error(completed: subprocess.CompletedProcess[str]) -> str: detail = (completed.stderr or completed.stdout or "").strip() return f" 错误: {detail}" if detail else "" def default_maven_install_root() -> Path: local_app_data = os.environ.get("LOCALAPPDATA", "").strip() base = Path(local_app_data) if local_app_data else Path.home() / ".autodeploy" return base / "AutoDeploy" / "tools" def resolve_node_release(index_data: bytes | str, requirements: tuple[str, ...]) -> NodeRelease: try: releases = json.loads(index_data) except (json.JSONDecodeError, UnicodeDecodeError, TypeError) as exc: raise RuntimeError("Node.js 官方版本索引格式无效。") from exc if not isinstance(releases, list): raise RuntimeError("Node.js 官方版本索引格式无效。") candidates: list[NodeRelease] = [] for item in releases: if not isinstance(item, dict) or not isinstance(item.get("version"), str): continue version = item["version"].lstrip("v") if not re.fullmatch(r"\d+\.\d+\.\d+", version): continue files = item.get("files") if isinstance(files, list) and "win-x64-zip" not in files: continue lts = item.get("lts", False) if all(_node_version_matches(version, requirement, lts) for requirement in requirements): candidates.append(NodeRelease(version, lts if isinstance(lts, str) else bool(lts))) if not candidates: joined = " 且 ".join(requirements) raise RuntimeError(f"Node.js 官方版本中找不到满足项目要求的 Windows x64 版本: {joined}") return max(candidates, key=lambda item: _version_tuple(item.version)) def install_node( requirements: tuple[str, ...], on_output: Callable[[str], None], install_root: Path | None = None, opener: Callable[..., BinaryIO] | None = None, ) -> tuple[Path, Path, str]: root = Path(install_root) if install_root is not None else default_maven_install_root() open_url = opener or urllib.request.urlopen on_output(f"正在读取 Node.js 官方版本索引,项目要求: {' 且 '.join(requirements)}") with open_url(f"{NODE_DIST_BASE}/index.json", timeout=30) as response: release = resolve_node_release(response.read(), requirements) version = release.version directory_name = f"node-v{version}-win-x64" archive_name = f"{directory_name}.zip" product_home = root / directory_name node_executable = product_home / "node.exe" npm_executable = product_home / "npm.cmd" if node_executable.exists() and npm_executable.exists(): on_output(f"Node.js {version} 已安装: {node_executable}") return node_executable, npm_executable, version archive_url = f"{NODE_DIST_BASE}/v{version}/{archive_name}" checksum_url = f"{NODE_DIST_BASE}/v{version}/SHASUMS256.txt" root.mkdir(parents=True, exist_ok=True) with tempfile.TemporaryDirectory(prefix="autodeploy-node-") as temporary: temp_dir = Path(temporary) archive_path = temp_dir / archive_name on_output(f"已自动选择 Node.js {version},正在从官方地址下载...") _download_to_file(archive_url, archive_path, open_url, on_output) expected_checksum = _download_node_checksum(checksum_url, archive_name, open_url) actual_checksum = _sha256(archive_path) if actual_checksum.lower() != expected_checksum.lower(): raise RuntimeError("Node.js 安装包 SHA-256 校验失败,已停止安装。") on_output("Node.js 安装包校验通过,正在解压...") extract_root = temp_dir / "extracted" _safe_extract_zip(archive_path, extract_root) extracted_home = extract_root / directory_name if not (extracted_home / "node.exe").exists() or not (extracted_home / "npm.cmd").exists(): raise RuntimeError("Node.js 安装包结构异常,未找到 node.exe 或 npm.cmd。") shutil.copytree(extracted_home, product_home, dirs_exist_ok=True) on_output(f"Node.js {version} 安装完成: {node_executable}") return node_executable, npm_executable, version def _download_node_checksum( url: str, archive_name: str, opener: Callable[..., BinaryIO], ) -> str: with opener(url, timeout=30) as response: text = response.read().decode("ascii", errors="strict") for line in text.splitlines(): parts = line.split() if len(parts) >= 2 and parts[-1].lstrip("*") == archive_name: checksum = parts[0] if re.fullmatch(r"[0-9a-fA-F]{64}", checksum): return checksum raise RuntimeError(f"Node.js 校验清单中未找到 {archive_name}。") def _node_version_matches(version: str, requirement: str, lts: object) -> bool: text = requirement.strip().lower() if text in {"", "*", "node", "latest"}: return True if text.startswith("lts"): requested_name = text.partition("/")[2] if requested_name in {"", "*", "-*"}: return bool(lts) return isinstance(lts, str) and lts.lower() == requested_name return any(_node_clause_matches(version, clause) for clause in text.split("||")) def _node_clause_matches(version: str, clause: str) -> bool: current = _version_tuple(version) normalized = clause.replace(",", " ").replace("(", " ").replace(")", " ") hyphen = re.fullmatch(r"\s*v?(\d+(?:\.\d+){0,2})\s+-\s+v?(\d+(?:\.\d+){0,2})\s*", normalized) if hyphen: return _compare_versions(current, ">=", _partial_version_tuple(hyphen.group(1))) and _compare_versions( current, "<=", _partial_version_tuple(hyphen.group(2), upper=True) ) tokens = re.findall(r"(?:>=|<=|>|<|=|\^|~)?\s*v?\d+(?:\.\d+){0,2}(?:\.(?:x|\*))?|(?:\d+\.)?(?:x|\*)", normalized) if not tokens: return False return all(_node_token_matches(current, token.replace(" ", "")) for token in tokens) def _node_token_matches(current: tuple[int, int, int], token: str) -> bool: match = re.fullmatch(r"(>=|<=|>|<|=|\^|~)?v?(.+)", token) if not match: return False operator = match.group(1) or "" value = match.group(2) if value in {"x", "*"}: return True parts = value.split(".") numeric = [int(part) for part in parts if part not in {"x", "*"}] if not numeric: return True target = tuple((numeric + [0, 0, 0])[:3]) if operator == "^": upper = (target[0] + 1, 0, 0) if target[0] else (0, target[1] + 1, 0) return current >= target and current < upper if operator == "~": upper = (target[0], target[1] + 1, 0) if len(numeric) > 1 else (target[0] + 1, 0, 0) return current >= target and current < upper if operator: return _compare_versions(current, operator, target) if len(numeric) == 1: return current[0] == target[0] if len(numeric) == 2: return current[:2] == target[:2] return current == target def _version_tuple(value: str) -> tuple[int, int, int]: parts = [int(part) for part in value.lstrip("v").split(".")[:3]] return tuple((parts + [0, 0, 0])[:3]) def _partial_version_tuple(value: str, upper: bool = False) -> tuple[int, int, int]: parts = [int(part) for part in value.split(".")] padded = (parts + ([999999] * 3 if upper else [0] * 3))[:3] return tuple(padded) def _compare_versions( current: tuple[int, int, int], operator: str, target: tuple[int, int, int], ) -> bool: return { ">=": current >= target, "<=": current <= target, ">": current > target, "<": current < target, "=": current == target, }.get(operator, False) def install_maven( on_output: Callable[[str], None], install_root: Path | None = None, opener: Callable[..., BinaryIO] | None = None, ) -> Path: root = Path(install_root) if install_root is not None else default_maven_install_root() archive_url = f"{MAVEN_DOWNLOAD_BASE}/{MAVEN_ARCHIVE_NAME}" return _install_verified_apache_archive( product_name="Maven", version=MAVEN_VERSION, archive_name=MAVEN_ARCHIVE_NAME, archive_url=archive_url, extracted_dir_name=f"apache-maven-{MAVEN_VERSION}", executable_relative=Path("bin") / "mvn.cmd", on_output=on_output, install_root=root, opener=opener, ) def install_tomcat( on_output: Callable[[str], None], install_root: Path | None = None, opener: Callable[..., BinaryIO] | None = None, ) -> Path: root = Path(install_root) if install_root is not None else default_maven_install_root() archive_url = f"{TOMCAT_DOWNLOAD_BASE}/{TOMCAT_ARCHIVE_NAME}" return _install_verified_apache_archive( product_name="Tomcat", version=TOMCAT_VERSION, archive_name=TOMCAT_ARCHIVE_NAME, archive_url=archive_url, extracted_dir_name=f"apache-tomcat-{TOMCAT_VERSION}", executable_relative=Path("bin") / "catalina.bat", on_output=on_output, install_root=root, opener=opener, ) def _install_verified_apache_archive( *, product_name: str, version: str, archive_name: str, archive_url: str, extracted_dir_name: str, executable_relative: Path, on_output: Callable[[str], None], install_root: Path, opener: Callable[..., BinaryIO] | None, ) -> Path: product_home = install_root / extracted_dir_name executable = product_home / executable_relative if executable.exists(): on_output(f"{product_name} {version} 已安装: {executable}") return executable open_url = opener or urllib.request.urlopen checksum_url = f"{archive_url}.sha512" install_root.mkdir(parents=True, exist_ok=True) with tempfile.TemporaryDirectory(prefix=f"autodeploy-{product_name.lower()}-") as temporary: temp_dir = Path(temporary) archive_path = temp_dir / archive_name on_output(f"正在从 Apache 官方地址下载 {product_name} {version}...") _download_to_file(archive_url, archive_path, open_url, on_output) expected_checksum = _download_checksum(checksum_url, open_url) actual_checksum = _sha512(archive_path) if actual_checksum.lower() != expected_checksum.lower(): raise RuntimeError(f"{product_name} 安装包 SHA-512 校验失败,已停止安装。") on_output(f"{product_name} 安装包校验通过,正在解压...") extract_root = temp_dir / "extracted" _safe_extract_zip(archive_path, extract_root) extracted_home = extract_root / extracted_dir_name extracted_executable = extracted_home / executable_relative if not extracted_executable.exists(): raise RuntimeError(f"{product_name} 安装包结构异常,未找到 {executable_relative}。") shutil.copytree(extracted_home, product_home, dirs_exist_ok=True) if not executable.exists(): raise RuntimeError(f"{product_name} 解压完成,但未找到 {executable_relative}。") on_output(f"{product_name} {version} 安装完成: {executable}") return executable def _download_to_file( url: str, destination: Path, opener: Callable[..., BinaryIO], on_output: Callable[[str], None], ) -> None: with opener(url, timeout=60) as response, destination.open("wb") as output: headers = getattr(response, "headers", {}) total_text = headers.get("Content-Length", "") if hasattr(headers, "get") else "" total = int(total_text) if str(total_text).isdigit() else 0 downloaded = 0 last_percent = -10 while True: chunk = response.read(1024 * 256) if not chunk: break output.write(chunk) downloaded += len(chunk) if total: percent = min(downloaded * 100 // total, 100) if percent >= last_percent + 10 or percent == 100: on_output(f"下载进度: {percent}%") last_percent = percent def _download_checksum(url: str, opener: Callable[..., BinaryIO]) -> str: with opener(url, timeout=30) as response: text = response.read().decode("ascii", errors="strict").strip() checksum = text.split()[0] if text else "" if not re.fullmatch(r"[0-9a-fA-F]{128}", checksum): raise RuntimeError("Apache Maven 校验文件格式无效。") return checksum def _sha512(path: Path) -> str: digest = hashlib.sha512() with path.open("rb") as source: for chunk in iter(lambda: source.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def _sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as source: for chunk in iter(lambda: source.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def _safe_extract_zip(archive_path: Path, destination: Path) -> None: destination.mkdir(parents=True, exist_ok=True) destination_resolved = destination.resolve() with zipfile.ZipFile(archive_path) as archive: for member in archive.infolist(): target = (destination / member.filename).resolve() if target != destination_resolved and destination_resolved not in target.parents: raise RuntimeError("ZIP 安装包包含不安全的文件路径。") archive.extractall(destination) def run_install_command(command: list[str], on_output) -> int: output_lines: list[str] = [] process = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=False, bufsize=0, ) assert process.stdout is not None last_line = "" for raw_line in process.stdout: for line in format_install_output(raw_line): if line and line != last_line: on_output(line) output_lines.append(line) last_line = line exit_code = process.wait() failure_hint = explain_install_failure(_tool_name_from_command(command), exit_code, output_lines) if failure_hint: on_output(failure_hint) return exit_code def explain_install_failure(tool_name: str | None, exit_code: int, output_lines: list[str]) -> str: if exit_code == 0: return "" output_text = "\n".join(output_lines) if tool_name == "Maven" and ("找不到与输入条件匹配的程序包" in output_text or "No package found" in output_text): return ( "winget 当前源找不到 Maven 包。请手动下载 Apache Maven,解压后在工具里选择 " "apache-maven 的 bin\\mvn.cmd,或把该 bin 目录加入 PATH。" ) return "" def format_install_output(raw: bytes) -> list[str]: text = _decode_process_bytes(raw) text = ANSI_PATTERN.sub("", text).replace("\b", "") lines: list[str] = [] for part in re.split(r"[\r\n]+", text): cleaned = _clean_install_line(part) if cleaned: lines.append(cleaned) return lines def _decode_process_bytes(raw: bytes) -> str: for encoding in ("utf-8", "utf-16", "gb18030", "mbcs"): try: return raw.decode(encoding) except (LookupError, UnicodeDecodeError): continue return raw.decode("utf-8", errors="replace") def _clean_install_line(line: str) -> str: text = line.strip() if not text: return "" percent = PERCENT_PATTERN.search(text) progress_only = _looks_like_progress_line(text) if percent and progress_only: value = min(int(percent.group(1)), 100) return f"\u5b89\u88c5\u8fdb\u5ea6: {value}%" if progress_only: return "" return text def _looks_like_progress_line(text: str) -> bool: if not text: return False progress_count = sum(1 for char in text if char in PROGRESS_CHARS) percent = bool(PERCENT_PATTERN.search(text)) if percent and progress_count: return True visible = [char for char in text if not char.isspace()] if not visible: return False return progress_count / len(visible) > 0.45 def _tool_name_from_command(command: list[str]) -> str | None: package_ids = {package_id: name for name, package_id in WINGET_PACKAGES.items()} package_ids.update({package_id: "JDK" for package_id in JDK_PACKAGES.values()}) for part in command: name = package_ids.get(part) if name: return name return None def _map_java_version(version: str) -> str: try: major = int(version.split(".", 1)[0]) except ValueError: return "8" if major <= 8: return "8" if major <= 11: return "11" if major <= 17: return "17" return "21"