Files
AutoDeploy/deploy_tool/installer.py

975 lines
37 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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=main;open_win_firewall=false;tcp_ip=true;port=3306;"
f"rootpasswd={MYSQL_INITIAL_ROOT_PASSWORD}"
)
return [
str(console_path),
"community",
"--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 default_mysql_server_install_log_path() -> Path:
return default_mysql_install_log_path().with_name("mysql-server-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
active_password = initial_password
total_attempts = max(attempts, 1)
for attempt in range(total_attempts):
variables_result = _run_mysql_sql(
mysql_executable,
"SHOW VARIABLES LIKE 'validate_password%';",
initial_password,
)
if variables_result.returncode == 0:
break
error_text = f"{variables_result.stderr}\n{variables_result.stdout}".lower()
if "access denied" in error_text or "error 1045" in error_text:
configured_result = _run_mysql_sql(
mysql_executable,
"SHOW VARIABLES LIKE 'validate_password%';",
final_password,
)
if configured_result.returncode == 0:
variables_result = configured_result
active_password = final_password
on_output("检测到 root 已使用默认密码,继续校验弱密码策略...")
break
if attempt + 1 < total_attempts:
if attempt == 0 or (attempt + 1) % 5 == 0:
on_output(f"MySQL 服务尚未就绪,正在后台重试({attempt + 1}/{total_attempts})...")
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",
active_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()
server_install_log = install_log.with_name("mysql-server-install.log")
existing_executable = find_mysql_executable()
if existing_executable is not None:
on_output(f"检测到已安装的 MySQL,跳过 Server 安装: {existing_executable}")
configure_mysql_weak_password_policy(existing_executable, on_output)
return existing_executable
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:
on_output(f"MySQL Server 安装日志: {server_install_log}")
server_exit_code = run_elevated_command_with_log(
server_command,
server_install_log,
on_wait=lambda: on_output("MySQL Server 仍在安装和配置,请继续等待..."),
)
else:
server_exit_code = elevated_runner(server_command)
if server_exit_code not in {0, 1641, 3010}:
detail = _read_install_log_tail(server_install_log)
if detail:
on_output("MySQL Installer Console 报错详情:")
for line in detail.splitlines():
on_output(line)
suffix = f" 详细日志: {server_install_log}"
if detail:
suffix += f"\n{detail}"
raise RuntimeError(f"MySQL Server 安装失败,退出码: {server_exit_code}。{suffix}")
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_elevated_command_with_log(
command: list[str],
log_path: Path,
on_wait: Callable[[], None] | None = None,
) -> int:
"""Run an elevated native command and preserve its stdout/stderr."""
log_path = Path(log_path)
log_path.parent.mkdir(parents=True, exist_ok=True)
if log_path.exists():
log_path.unlink()
def ps_literal(value: str) -> str:
return "'" + value.replace("'", "''") + "'"
arguments = " ".join(ps_literal(argument) for argument in command[1:])
invocation = f"& {ps_literal(command[0])}"
if arguments:
invocation += f" {arguments}"
script = (
"$ErrorActionPreference = 'Continue'\n"
f"$output = {invocation} 2>&1\n"
"$exitCode = $LASTEXITCODE\n"
f"$output | Out-File -LiteralPath {ps_literal(str(log_path))} -Encoding utf8\n"
"if ($null -eq $exitCode) { $exitCode = 1 }\n"
"exit $exitCode\n"
)
with tempfile.TemporaryDirectory(prefix="autodeploy-elevated-") as temporary:
script_path = Path(temporary) / "run-command.ps1"
script_path.write_text(script, encoding="utf-8-sig")
return run_elevated_command(
[
"powershell.exe",
"-NoProfile",
"-NonInteractive",
"-ExecutionPolicy",
"Bypass",
"-File",
str(script_path),
],
on_wait=on_wait,
)
def _read_install_log_tail(log_path: Path, max_lines: int = 20) -> str:
try:
raw = Path(log_path).read_bytes()
except OSError:
return ""
lines = format_install_output(raw)
return "\n".join(lines[-max_lines:])
def _run_mysql_sql(mysql_executable: Path, sql: str, password: str) -> subprocess.CompletedProcess[str]:
environment = os.environ.copy()
environment["MYSQL_PWD"] = password
creation_flags = getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0
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,
creationflags=creation_flags,
)
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"