817 lines
34 KiB
Python
817 lines
34 KiB
Python
import json
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
import shutil
|
|
import json5
|
|
import glob
|
|
import fnmatch
|
|
import hashlib
|
|
from pathlib import Path
|
|
from dataclasses import dataclass, fields, field, MISSING
|
|
|
|
# 1. 使用 @dataclass 装饰器，Python 会自动为你生成 __init__, __repr__ 等方法
|
|
@dataclass
|
|
class PackageType:
|
|
type: str
|
|
name: str
|
|
encryption: str
|
|
presets: list
|
|
platform: list
|
|
guid: str
|
|
APPDATA: str
|
|
OutputBaseFilename: str
|
|
Shortcut: str
|
|
MyAppName: str
|
|
PRODUCT:str = "ENV_2025_V6_S0"
|
|
hide:bool = False
|
|
|
|
# 可选字段 (有默认值，必须放在最后)
|
|
#Shortcut: str = ""
|
|
|
|
# 假设你未来想加一个可选的数组字段，必须这样写：
|
|
# ExtraPlugins: list = field(default_factory=list)
|
|
|
|
def getInnosetupParam(self) -> str:
|
|
sRel = ""
|
|
|
|
# 1. 检查加密方式是否为 Trial
|
|
if self.encryption == "Trial":
|
|
sRel += "/dTRIAL_YEAR "
|
|
|
|
# 2. 检查平台并附加对应的宏
|
|
if "ZWCAD" in self.platform:
|
|
sRel += "/dZWCAD "
|
|
if "ACAD" in self.platform:
|
|
sRel += "/dACAD "
|
|
if "ACAD" in self.platform and "ZWCAD" in self.platform:
|
|
sRel += "/dMERGER_CAD"
|
|
|
|
# 3. 遍历 presets 数组，添加元素宏
|
|
for preset in self.presets:
|
|
sRel += f"/d{preset} "
|
|
|
|
# 4. 将需要以键值对输出的变量集中处理
|
|
kv_vars = {
|
|
"guid": self.guid,
|
|
"APPDATA": self.APPDATA,
|
|
"OutputBaseFilename": self.OutputBaseFilename,
|
|
"Shortcut": self.Shortcut,
|
|
"MyAppName": self.MyAppName,
|
|
"PRODUCT": self.PRODUCT
|
|
}
|
|
|
|
for key, value in kv_vars.items():
|
|
# 只有当值不为空时才追加（可根据您的实际业务需求调整是否容许空值）
|
|
if value:
|
|
sRel += f"/d{key}=\"{value}\" "
|
|
else:
|
|
print("❌ {key} 的值为空！")
|
|
|
|
# 返回结果，并使用 strip() 去掉字符串最末尾的一个多余空格，使其更规范
|
|
return sRel.strip()
|
|
|
|
def display(self):
|
|
print(f"=== {self.type} ===")
|
|
# dataclass 仍然可以通过 __dict__ 遍历所有属性
|
|
for key, value in self.__dict__.items():
|
|
print(f" {key.ljust(20)}: {value}")
|
|
|
|
class PackageParser:
|
|
def __init__(self, raw_data: list):
|
|
self.raw_dict = {item["type"]: item for item in raw_data}
|
|
self.resolved_cache = {}
|
|
|
|
# 提取所有定义的字段名（用于过滤 JSON 中多余的垃圾数据）
|
|
self.all_fields = [f.name for f in fields(PackageType)]
|
|
|
|
# 核心魔法：只提取没有默认值的字段作为必填校验项
|
|
self.required_fields = [
|
|
f.name for f in fields(PackageType)
|
|
if f.default is MISSING and f.default_factory is MISSING
|
|
]
|
|
|
|
def parse_all(self) -> list:
|
|
instances = []
|
|
error_logs = []
|
|
|
|
for pkg_type in self.raw_dict.keys():
|
|
resolved_data = self._resolve_inheritance(pkg_type)
|
|
|
|
# 只用 required_fields 进行缺失检查
|
|
missing_fields = [field for field in self.required_fields if field not in resolved_data]
|
|
|
|
if missing_fields:
|
|
error_logs.append(f"错误: 节点 [{pkg_type}] 缺失必填字段: {', '.join(missing_fields)}")
|
|
else:
|
|
# 使用 all_fields 进行过滤，防止把 JSON 里的无关字段塞进 dataclass 报错
|
|
filtered_data = {k: v for k, v in resolved_data.items() if k in self.all_fields}
|
|
|
|
# 解包传入。如果 JSON 里没有可选字段，这里的 filtered_data 就不包含它，
|
|
# dataclass 的 __init__ 会自动使用我们在类里定义的默认值。
|
|
instances.append(PackageType(**filtered_data))
|
|
|
|
if error_logs:
|
|
print("❌ 配置文件解析失败，发现以下必填字段缺失：")
|
|
for error in error_logs:
|
|
print(" -", error)
|
|
return []
|
|
|
|
return instances
|
|
|
|
def _resolve_inheritance(self, pkg_type: str) -> dict:
|
|
# （这里的继承逻辑完全保持不变，省略以突出重点）
|
|
if pkg_type in self.resolved_cache:
|
|
return self.resolved_cache[pkg_type]
|
|
|
|
if pkg_type not in self.raw_dict:
|
|
raise ValueError(f"找不到定义的继承基类: {pkg_type}")
|
|
|
|
raw_node = self.raw_dict[pkg_type]
|
|
merged_data = {}
|
|
|
|
if "inherits" in raw_node:
|
|
for base_type in raw_node["inherits"]:
|
|
base_resolved = self._resolve_inheritance(base_type)
|
|
for k, v in base_resolved.items():
|
|
if k == "inherits":
|
|
continue
|
|
if isinstance(v, list):
|
|
if k not in merged_data:
|
|
merged_data[k] = []
|
|
for item in v:
|
|
if item not in merged_data[k]:
|
|
merged_data[k].append(item)
|
|
else:
|
|
merged_data[k] = v
|
|
|
|
for k, v in raw_node.items():
|
|
if k == "inherits":
|
|
continue
|
|
if isinstance(v, list):
|
|
if k not in merged_data:
|
|
merged_data[k] = []
|
|
for item in v:
|
|
if item not in merged_data[k]:
|
|
merged_data[k].append(item)
|
|
else:
|
|
merged_data[k] = v
|
|
|
|
self.resolved_cache[pkg_type] = merged_data
|
|
return merged_data
|
|
|
|
def get_all_presets_union(packages: list) -> list:
|
|
"""
|
|
接收一个 PackageType 列表，返回所有 presets 的并集列表（自动去重并保持顺序）
|
|
"""
|
|
# 收集所有的 preset
|
|
all_presets = []
|
|
for pkg in packages:
|
|
all_presets.extend(pkg.presets)
|
|
|
|
# 利用 dict.fromkeys() 去重，同时利用 Python 3.7+ 字典保持插入顺序的特性
|
|
union_presets = list(dict.fromkeys(all_presets))
|
|
|
|
return union_presets
|
|
|
|
def select_packages(packages: list) -> list:
|
|
"""
|
|
在控制台显示非隐藏的 PackageType 列表，并让用户通过输入索引进行多选。
|
|
"""
|
|
# 1. 过滤掉 hide 为 True 的对象
|
|
visible_packages = [pkg for pkg in packages if getattr(pkg, 'hide', False) == False]
|
|
|
|
if not visible_packages:
|
|
print("没有可供显示的打包类型。")
|
|
return []
|
|
|
|
# 2. 检查是否有命令行参数传入
|
|
# sys.argv[0] 是脚本名称本身，sys.argv[1:] 是传入的参数列表
|
|
cli_args = sys.argv[1:]
|
|
|
|
if cli_args:
|
|
unique_indices = []
|
|
for idx_str in cli_args:
|
|
try:
|
|
idx = int(idx_str)
|
|
# 检查索引是否越界
|
|
if 0 <= idx < len(visible_packages):
|
|
if idx not in unique_indices:
|
|
unique_indices.append(idx)
|
|
else:
|
|
print(f"⚠️ 致命错误: 命令行传入的序号 '{idx}' 超出范围。")
|
|
sys.exit(1) # 命令行参数错误时，直接退出程序
|
|
except ValueError:
|
|
print(f"⚠️ 致命错误: 命令行参数 '{idx_str}' 不是有效的数字。")
|
|
sys.exit(1)
|
|
|
|
# 解析成功，直接返回结果
|
|
selected_packages = [visible_packages[i] for i in unique_indices]
|
|
print("✅ 检测到命令行参数，已自动选择:")
|
|
for p in selected_packages:
|
|
print(f" -> {p.name}")
|
|
return selected_packages
|
|
|
|
# ==========================================
|
|
# 3. 如果没有命令行参数，则进入交互模式
|
|
# ==========================================
|
|
print("\n请选择要执行的打包任务（输入数字序号，多选请用空格隔开，例如: 0 2 3）：")
|
|
print("-" * 50)
|
|
for i, pkg in enumerate(visible_packages):
|
|
print(f"[{i}] {pkg.name} (Type: {pkg.type})")
|
|
print("-" * 50)
|
|
|
|
# 3. 循环等待并处理用户输入
|
|
while True:
|
|
user_input = input("请输入您的选择: ").strip()
|
|
|
|
if not user_input:
|
|
print("输入不能为空，请重新输入。")
|
|
continue
|
|
|
|
selected_indices_str = user_input.split()
|
|
unique_indices = [] # 用来存放去重后的合法数字索引
|
|
has_error = False
|
|
|
|
for idx_str in selected_indices_str:
|
|
try:
|
|
idx = int(idx_str)
|
|
# 检查索引是否越界
|
|
if 0 <= idx < len(visible_packages):
|
|
# 在这里对索引进行去重，防止用户输入 "0 0 1"
|
|
if idx not in unique_indices:
|
|
unique_indices.append(idx)
|
|
else:
|
|
print(f"⚠️ 错误: 序号 '{idx}' 超出范围，请重新输入。")
|
|
has_error = True
|
|
break
|
|
except ValueError:
|
|
print(f"⚠️ 错误: '{idx_str}' 不是有效的数字，请重新输入。")
|
|
has_error = True
|
|
break
|
|
|
|
# 如果遍历过程中没有发生任何错误，并且用户确实做出了选择
|
|
if not has_error and unique_indices:
|
|
# 根据去重后的索引，生成对应的 PackageType 列表
|
|
selected_packages = [visible_packages[i] for i in unique_indices]
|
|
|
|
print("\n✅ 您已选择:")
|
|
for p in selected_packages:
|
|
print(f" -> {p.name}")
|
|
return selected_packages
|
|
|
|
def load_config(config_path="cmake_batch_build.json"):
|
|
if not os.path.exists(config_path):
|
|
print(f"错误: 找不到配置文件 {config_path}")
|
|
sys.exit(1)
|
|
|
|
try:
|
|
with open(config_path, "r", encoding="utf-8") as f:
|
|
return json5.load(f)
|
|
except Exception as e:
|
|
print(f"解析配置文件失败，请检查语法: {e}")
|
|
sys.exit(1)
|
|
|
|
def resolve_variables(text, context_vars):
|
|
"""递归解析字符串中的 ${variable} 变量"""
|
|
while True:
|
|
replaced = text
|
|
for k, v in context_vars.items():
|
|
if isinstance(v, str):
|
|
replaced = replaced.replace(f"${{{k}}}", v)
|
|
if replaced == text:
|
|
break
|
|
text = replaced
|
|
return text
|
|
|
|
def buildStartApp(startapp_action, definitions):
|
|
#startapp_action = actions.get("compile-startApp", {})
|
|
ss = os.getcwd()
|
|
if startapp_action:
|
|
print("--- 正在编译 startApp 工程 ---")
|
|
for cp in startapp_action.get("copy", []):
|
|
form_list = cp.get("form", [])
|
|
to_list = cp.get("to", [])
|
|
for f_item in form_list:
|
|
for t_item in to_list:
|
|
f_resolved = resolve_variables(f_item, definitions)
|
|
t_resolved = resolve_variables(t_item, definitions)
|
|
print(f"执行预处理拷贝: 从 {f_resolved} 到 {t_resolved}")
|
|
try:
|
|
# 确保目标文件夹存在，否则 copy 会报错
|
|
os.makedirs(os.path.dirname(t_resolved), exist_ok=True)
|
|
|
|
# 使用 shutil.copy2 进行复制 (相当于 copy /y，且会保留文件的修改时间等元数据)
|
|
shutil.copy2(f_resolved, t_resolved)
|
|
print(f"✅ 拷贝成功: {t_resolved}")
|
|
except FileNotFoundError:
|
|
print(f"❌ 拷贝失败: 找不到源文件 {f_resolved}")
|
|
except Exception as e:
|
|
print(f"❌ 拷贝失败: {e}")
|
|
|
|
start_cmd = resolve_variables(startapp_action.get("cmd", ""), definitions)
|
|
print(f"执行 MSBuild: {start_cmd}")
|
|
build_res = subprocess.run(start_cmd, shell=True)
|
|
if build_res.returncode == 0:
|
|
print(f"✅ startAPP 编译成功。")
|
|
if os.path.exists("startApp.log"):
|
|
try:
|
|
os.remove("startApp.log")
|
|
except Exception:
|
|
pass
|
|
|
|
def svnUpdate(update_action):
|
|
if update_action:
|
|
update_cmd = update_action.get("cmd", "svn update")
|
|
update_path = update_action.get("path", "../../")
|
|
print(f"--- 正在更新代码: {update_cmd} {update_path} ---")
|
|
subprocess.run(update_cmd + ' ' + update_path, shell=True)
|
|
|
|
def buildPresets(presets, definitions):
|
|
# 现在编译presets，先取出presets的目录，作为工作目录
|
|
work_dir = resolve_variables(definitions.get("work-dir", "."), definitions)
|
|
script_dir = os.getcwd()
|
|
|
|
failed_presets = []
|
|
|
|
print(f"\n--- 开始编译 CMake Presets，目标 Presets: {presets} ---")
|
|
for preset in presets:
|
|
print(f"\n>>> 正在处理 Preset: {preset}")
|
|
|
|
print(f"==================================================")
|
|
print(f" [1/2] 正在配置 CMake Preset: {preset}")
|
|
print(f"==================================================")
|
|
|
|
configure_cmd = f'cd /d "{work_dir}" && cmake --preset {preset}'
|
|
res = subprocess.run(configure_cmd, shell=True)
|
|
|
|
if res.returncode != 0:
|
|
print(f"❌ 错误: Preset [{preset}] 的 Configure (配置) 阶段失败！整个脚本终止。")
|
|
sys.exit(res.returncode)
|
|
|
|
print(f"\n==================================================")
|
|
print(f" [2/2] 正在编译 CMake Preset: {preset}")
|
|
print(f"==================================================")
|
|
|
|
log_filename = f"{preset}.log"
|
|
log_path = os.path.join(script_dir, log_filename)
|
|
|
|
build_cmd = f'cd /d "{work_dir}" && cmake --build --preset {preset} --config release -j 8 -- /flp1:logfile="{log_path}";errorsonly;Verbosity:quiet'
|
|
build_res = subprocess.run(build_cmd, shell=True)
|
|
|
|
if build_res.returncode == 0:
|
|
print(f"✅ Preset [{preset}] 编译成功。")
|
|
if os.path.exists(log_path):
|
|
try:
|
|
os.remove(log_path)
|
|
except Exception:
|
|
pass
|
|
else:
|
|
print(f"⚠️ 警告: Preset [{preset}] 的 Build (编译) 阶段出现错误 (返回码: {build_res.returncode})。")
|
|
print(f"错误日志已保存至 {log_path}，继续执行下一个 preset...")
|
|
failed_presets.append(preset)
|
|
|
|
if failed_presets:
|
|
print("\n" + "="*50)
|
|
print(f"❌ 致命错误: 以下 Preset 编译失败: {failed_presets}")
|
|
print("由于存在未成功编译的工程，为了防止产出损坏的安装包，已终止后续的拷贝和打包操作。")
|
|
print("请检查对应的 .log 日志文件修复代码，然后重新运行本脚本。")
|
|
print("="*50 + "\n")
|
|
sys.exit(1)
|
|
|
|
def calculate_files_sha1(file_paths: list) -> str:
|
|
"""
|
|
计算多个文件的整体 SHA1 值。
|
|
为保证每次计算结果一致，会对文件路径进行排序。
|
|
"""
|
|
if not file_paths:
|
|
return ""
|
|
|
|
sha1 = hashlib.sha1()
|
|
|
|
# 排序保证即使文件遍历顺序不同，计算出的哈希也一致
|
|
for file_path in sorted(file_paths):
|
|
if not os.path.isfile(file_path):
|
|
continue
|
|
|
|
# 记录文件名本身的信息也可以防止“同内容但改了文件名”的情况，
|
|
# 如果你只关心内容，可以把这行注释掉。
|
|
sha1.update(os.path.basename(file_path).encode('utf-8'))
|
|
|
|
# 分块读取文件内容，防止大文件撑爆内存
|
|
with open(file_path, 'rb') as f:
|
|
while chunk := f.read(8192 * 1024): # 每次读取 8MB
|
|
sha1.update(chunk)
|
|
|
|
return sha1.hexdigest()
|
|
|
|
def process_compression_tasks(compress_tasks: list, definitions: dict):
|
|
"""
|
|
处理 JSON 中定义的压缩任务
|
|
:param compress_tasks: json 中的 "compress_huge_files" 数组
|
|
:param definitions: 传递给 resolve_variables 的变量字典
|
|
"""
|
|
for task in compress_tasks:
|
|
# 1. 解析所有路径中的变量
|
|
cmd_7za = os.path.abspath(os.path.normpath(task.get("7za", "7za.exe")))
|
|
compress_file = os.path.abspath(os.path.normpath(resolve_variables(task["compress_file"], definitions)))
|
|
sh1_flag_file = os.path.abspath(os.path.normpath(resolve_variables(task["sh1_flag_file"], definitions)))
|
|
|
|
raw_zip_files = [resolve_variables(f, definitions) for f in task["zip_files"]]
|
|
|
|
# 2. 使用 glob 展开通配符（比如 *.*），找到所有真实存在的文件
|
|
actual_files = []
|
|
for pattern in raw_zip_files:
|
|
# os.path.normpath 会把路径标准化，glob 才能更好地在 Windows 下工作
|
|
pattern = os.path.normpath(pattern)
|
|
matched = glob.glob(pattern)
|
|
actual_files.extend([f for f in matched if os.path.isfile(f)])
|
|
|
|
# 去重（防止通配符和精确路径重复匹配同一文件）
|
|
actual_files = list(set(actual_files))
|
|
|
|
# ==========================================
|
|
# 核心修复：剔除输出文件，防止“自我包含”
|
|
# 使用 os.path.abspath 和 normcase 确保在 Windows 下路径比对准确（忽略大小写和正反斜杠差异）
|
|
# ==========================================
|
|
abs_compress_file = os.path.normcase(os.path.abspath(compress_file))
|
|
abs_sh1_file = os.path.normcase(os.path.abspath(sh1_flag_file))
|
|
|
|
safe_actual_files = []
|
|
for f in actual_files:
|
|
abs_f = os.path.normcase(os.path.abspath(f))
|
|
# 如果抓取到的文件是我们将要生成的 7z 或 txt，直接跳过
|
|
if abs_f == abs_compress_file or abs_f == abs_sh1_file:
|
|
continue
|
|
safe_actual_files.append(f)
|
|
|
|
actual_files = safe_actual_files
|
|
# ==========================================
|
|
|
|
if not actual_files:
|
|
print(f"⚠️ 警告: 没有找到任何文件可以压缩，匹配模式为: {raw_zip_files}")
|
|
continue
|
|
|
|
# ==========================================
|
|
# 新增：严格校验所有的文件是否在同一个目录下
|
|
# 使用 os.path.abspath 防止相对路径和绝对路径混用导致判断失误
|
|
# ==========================================
|
|
parent_dirs = set(os.path.dirname(os.path.abspath(f)) for f in actual_files)
|
|
|
|
if len(parent_dirs) > 1:
|
|
print(f"❌ 致命错误: 待压缩的文件分布在不同的目录下！")
|
|
for d in parent_dirs:
|
|
print(f" - 检测到目录: {d}")
|
|
print(f"规则要求 zip_files 里的文件必须在同一个目录。当前任务终止。")
|
|
|
|
# 这里建议直接抛出异常或者 sys.exit(1) 中断整个打包流程，因为这是一个配置错误
|
|
raise ValueError("压缩失败：被压缩的文件未处于同一目录。")
|
|
|
|
# 校验通过，拿到这个唯一的基准目录
|
|
base_dir = list(parent_dirs)[0]
|
|
|
|
# 3. 计算当前真实文件的整体 SHA1
|
|
print(f"\n正在计算 {len(actual_files)} 个文件的联合 SHA1...")
|
|
current_sha1 = calculate_files_sha1(actual_files)
|
|
print(f"当前 SHA1: {current_sha1}")
|
|
|
|
# 4. 判断是否需要重新压缩
|
|
need_compress = False
|
|
|
|
if not os.path.exists(compress_file):
|
|
print("=> 压缩文件不存在，需要重新压缩。")
|
|
need_compress = True
|
|
elif not os.path.exists(sh1_flag_file):
|
|
print("=> SHA1 标志文件不存在，需要重新压缩。")
|
|
need_compress = True
|
|
else:
|
|
# 读取旧的 SHA1 值进行比对
|
|
try:
|
|
with open(sh1_flag_file, "r", encoding="utf-8") as f:
|
|
saved_sha1 = f.read().strip()
|
|
if saved_sha1 != current_sha1:
|
|
print(f"=> SHA1 值不匹配 (旧: {saved_sha1})，文件已发生变动，需要重新压缩。")
|
|
need_compress = True
|
|
else:
|
|
print(f"✅ 文件未发生变动且压缩包已存在，跳过压缩: {compress_file}")
|
|
except Exception as e:
|
|
print(f"=> 读取标志文件失败 ({e})，安全起见进行重新压缩。")
|
|
need_compress = True
|
|
|
|
# 5. 执行压缩
|
|
if need_compress:
|
|
# 为了防止 7za.exe a 模式下“把新旧文件混进同一个压缩包”，先删除旧包
|
|
if os.path.exists(compress_file):
|
|
try:
|
|
os.remove(compress_file)
|
|
except OSError as e:
|
|
print(f"删除旧压缩包失败: {e}")
|
|
|
|
# 确保压缩文件和标志文件的输出目录存在
|
|
os.makedirs(os.path.dirname(compress_file), exist_ok=True)
|
|
os.makedirs(os.path.dirname(sh1_flag_file), exist_ok=True)
|
|
|
|
file_names_only = [os.path.basename(f) for f in actual_files]
|
|
|
|
# 组装命令行: 7za.exe a "C:/.../hugeDb.7z" Aec3DMep.db shmodel.db
|
|
command = [cmd_7za, "a", compress_file] + file_names_only
|
|
|
|
print(f"正在执行压缩 (工作目录: {base_dir})...")
|
|
# print("命令:", " ".join(command))
|
|
|
|
# 运行压缩
|
|
result = subprocess.run(command, cwd=base_dir, shell=False)
|
|
|
|
if result.returncode == 0:
|
|
# 6. 压缩成功，写入最新的 SHA1 标志
|
|
with open(sh1_flag_file, "w", encoding="utf-8") as f:
|
|
f.write(current_sha1)
|
|
print("✅ 压缩完成，已更新 SHA1 标志文件。")
|
|
else:
|
|
print(f"❌ 压缩失败，7za 返回错误码: {result.returncode}")
|
|
# 压缩失败时清理残次品，防止下次误认为压缩成功
|
|
if os.path.exists(compress_file):
|
|
os.remove(compress_file)
|
|
|
|
def copy_preset(copy_preset_dict, presets, definitions):
|
|
"""
|
|
处理针对不同编译 Preset 的批量分发拷贝操作
|
|
:param copy_preset_dict: json 中的 "copy_preset" 对象字典
|
|
:param presets: 类似于 ["R200", "R210"] 的预设数组
|
|
:param definitions: 环境变量字典，用于 resolve_variables 解析
|
|
"""
|
|
form_list = copy_preset_dict.get("form", [])
|
|
to_list = copy_preset_dict.get("to", [])
|
|
|
|
if not form_list or not to_list or not presets:
|
|
return
|
|
|
|
print(f"\n🚀 开始执行 copy_preset 批量分发，目标平台: {presets}")
|
|
|
|
# 外层循环：遍历每一个 Preset
|
|
for preset in presets:
|
|
|
|
# 遍历每一个目的地 (to)
|
|
for t_item in to_list:
|
|
# 解析目标根路径并拼接 preset
|
|
t_resolved = resolve_variables(t_item, definitions)
|
|
dst_dir = os.path.normpath(os.path.join(t_resolved, preset))
|
|
|
|
# 确保目标目录已存在
|
|
os.makedirs(dst_dir, exist_ok=True)
|
|
|
|
# 遍历每一个来源 (form)
|
|
for f_item in form_list:
|
|
f_resolved = os.path.normpath(resolve_variables(f_item, definitions))
|
|
|
|
# 情况 1: form 元素是一个明确的目录
|
|
if os.path.isdir(f_resolved):
|
|
# 行为：源目录也要加上 preset
|
|
src_dir = os.path.join(f_resolved, 'Release-x64-' + preset)
|
|
|
|
if os.path.isdir(src_dir):
|
|
print(f"📦 [目录分发] {src_dir} -> {dst_dir}")
|
|
# shutil.copytree 的 dirs_exist_ok=True (Python 3.8+)
|
|
# 能够完美实现“把目录里的所有文件(包括子目录)强行覆盖合并到目标目录”
|
|
shutil.copytree(src_dir, dst_dir, dirs_exist_ok=True)
|
|
else:
|
|
print(f"⚠️ 警告: 找不到对应的 preset 源目录，跳过: {src_dir}")
|
|
|
|
# 情况 2: form 元素是文件或通配符 (*.dll, *.* 等)
|
|
else:
|
|
# 行为：直接使用 glob 匹配，解析出所有具体文件，无需加上 preset
|
|
matched_files = glob.glob(f_resolved)
|
|
|
|
if not matched_files:
|
|
print(f"⚠️ 警告: 通配符/文件未匹配到任何内容: {f_resolved}")
|
|
continue
|
|
|
|
for f_path in matched_files:
|
|
if os.path.isfile(f_path):
|
|
print(f"📄 [文件分发] {f_path} -> {dst_dir}")
|
|
# 拷贝单文件到目标目录 (如果存在同名文件会自动覆盖)
|
|
shutil.copy2(f_path, dst_dir)
|
|
|
|
print("✅ copy_preset 批量分发完成。")
|
|
|
|
def process_general_copy(copy_actions, definitions):
|
|
"""
|
|
处理普通的批量 copy 行为
|
|
:param copy_actions: json 中的 "copy" 数组
|
|
:param definitions: 用于 resolve_variables 解析的环境变量字典
|
|
"""
|
|
|
|
# --- 辅助匹配函数（支持相对路径匹配和层级匹配） ---
|
|
def is_match(rel_path, patterns):
|
|
if not patterns:
|
|
return False
|
|
|
|
rel_path_str = str(rel_path).replace('\\', '/')
|
|
parts = rel_path.parts
|
|
|
|
for pattern in patterns:
|
|
pattern = pattern.replace('\\', '/')
|
|
# 情况 A: 路径整体匹配
|
|
if fnmatch.fnmatch(rel_path_str, pattern):
|
|
return True
|
|
# 情况 B: 逐级文件名或目录名匹配
|
|
for part in parts:
|
|
if fnmatch.fnmatch(part, pattern):
|
|
return True
|
|
return False
|
|
|
|
print("\n🚀 开始执行普通 Copy 行为...")
|
|
|
|
for action in copy_actions:
|
|
form_list = action.get("form", [])
|
|
to_list = action.get("to", [])
|
|
# 注意 JSON 里键名是 "include" 和 "exclude"
|
|
includes = action.get("include", [])
|
|
excludes = action.get("exclude", [])
|
|
|
|
# m 循环: 遍历源路径
|
|
for f_item in form_list:
|
|
f_resolved = os.path.normpath(resolve_variables(f_item, definitions))
|
|
|
|
# 判断是以通配符结尾，还是纯目录
|
|
base_dir_str, file_pattern = os.path.split(f_resolved)
|
|
is_wildcard = ('*' in file_pattern or '?' in file_pattern)
|
|
|
|
if is_wildcard:
|
|
src_dir = Path(base_dir_str).resolve()
|
|
else:
|
|
src_dir = Path(f_resolved).resolve()
|
|
|
|
if not src_dir.exists() or not src_dir.is_dir():
|
|
print(f"⚠️ 源目录不存在或无效，跳过: {src_dir}")
|
|
continue
|
|
|
|
# n 循环: 遍历目标路径
|
|
for t_item in to_list:
|
|
t_resolved = os.path.normpath(resolve_variables(t_item, definitions))
|
|
dst_dir = Path(t_resolved).resolve()
|
|
|
|
# 根据是否为通配符，决定目标输出的基准路径
|
|
if is_wildcard:
|
|
# 通配符：直接 copy 到 dst_dir，不需要再建根目录
|
|
target_base = dst_dir
|
|
print(f"📂 [通配符拷贝] {src_dir} / {file_pattern} -> {target_base}")
|
|
else:
|
|
# 纯目录：在目标文件夹中创建一个和源目录同名的子目录 (例如 xxx/yyy/ddd)
|
|
target_base = dst_dir / src_dir.name
|
|
print(f"📦 [整个目录拷贝] {src_dir} -> {target_base}")
|
|
|
|
copy_count = 0
|
|
|
|
# 开始遍历源目录最深处的所有文件
|
|
for root, dirs, files in os.walk(src_dir):
|
|
for file_name in files:
|
|
file_path = Path(root) / file_name
|
|
rel_path = file_path.relative_to(src_dir)
|
|
|
|
# 1. 如果是通配符模式，文件自身必须先符合这个通配符规则
|
|
# (例如 *.* 就是全部通过，*.dll 只有 dll 通过)
|
|
if is_wildcard:
|
|
if not fnmatch.fnmatch(file_name, file_pattern):
|
|
continue
|
|
|
|
# 2. 匹配 include / exclude 规则
|
|
matched_include = is_match(rel_path, includes)
|
|
matched_exclude = is_match(rel_path, excludes)
|
|
|
|
# 3. 核心冲突解决逻辑 (白名单优先原则)
|
|
should_copy = True
|
|
|
|
if includes:
|
|
# 如果配置了白名单，只有在白名单里才 copy
|
|
if matched_include:
|
|
should_copy = True
|
|
else:
|
|
should_copy = False
|
|
else:
|
|
# 没有配置白名单，碰到黑名单就不 copy
|
|
if matched_exclude:
|
|
should_copy = False
|
|
|
|
# 最终覆盖：如果既满足 include 又满足 exclude，以 include 为准！
|
|
if matched_include:
|
|
should_copy = True
|
|
|
|
# 4. 执行文件拷贝
|
|
if should_copy:
|
|
target_path = target_base / rel_path
|
|
|
|
# 自动创建深层级的子目录
|
|
target_path.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy2(file_path, target_path)
|
|
copy_count += 1
|
|
|
|
print(f" └─ 完成，共拷贝了 {copy_count} 个文件。")
|
|
|
|
def package(innosetup, packages, definitions):
|
|
"""
|
|
调用 Inno Setup 命令行编译器 (ISCC) 为每个选择的 PackageType 进行打包
|
|
:param innosetup: json 中的 "innosetup" 对象字典
|
|
:param packages: 用户选择的 PackageType 实例列表
|
|
:param definitions: 环境变量字典 (用于 resolve_variables)
|
|
"""
|
|
if not innosetup or not packages:
|
|
print("⚠️ 没有提供打包配置或包列表为空，跳过打包。")
|
|
return
|
|
|
|
print("\n" + "="*50)
|
|
print("🚀 开始执行 Inno Setup 终极打包流程")
|
|
print("="*50)
|
|
|
|
iscc = innosetup.get("iscc")
|
|
iss = innosetup.get("iss")
|
|
|
|
base_cmd = f"\"{iscc}\" \"{iss}\""
|
|
|
|
success_count = 0
|
|
|
|
# 3. 循环遍历用户选择的每一个 PackageType
|
|
for pkg in packages:
|
|
print(f"\n📦 正在编译安装包: {pkg.name} (Type: {pkg.type})")
|
|
|
|
# 获取属于这个包特有的宏定义参数
|
|
# 注意：这里调用的方法名是我们在前面定义的 getInnosetpParam
|
|
pkg.PRODUCT = definitions.get("product")
|
|
params = pkg.getInnosetupParam()
|
|
|
|
# 拼接最终执行的完整命令
|
|
final_cmd = f'{base_cmd} {params}'
|
|
print(f"执行命令: {final_cmd}")
|
|
|
|
# 执行命令 (ISCC 这种带双引号包裹路径的复杂命令行，使用 shell=True 兼容性最好)
|
|
try:
|
|
result = subprocess.run(final_cmd, shell=True)
|
|
|
|
if result.returncode == 0:
|
|
print(f"✅ [{pkg.name}] 打包成功！")
|
|
success_count += 1
|
|
else:
|
|
print(f"❌ [{pkg.name}] 打包失败，ISCC 编译器返回了错误码: {result.returncode}")
|
|
# 根据你的业务需求，遇到失败可以选择 break 直接终止，或者 continue 继续打下一个包
|
|
|
|
except Exception as e:
|
|
print(f"❌ 致命错误：启动 ISCC 失败，请检查路径是否正确: {e}")
|
|
|
|
# 4. 打印最终结果统计
|
|
print("\n" + "="*50)
|
|
print(f"🎉 所有的打包任务已结束！总计: {len(packages)} 个，成功: {success_count} 个。")
|
|
print("="*50)
|
|
|
|
def main():
|
|
# 设置当前脚本的路径为工作目录
|
|
script_dir = os.path.dirname(os.path.abspath(__file__))
|
|
os.chdir(script_dir)
|
|
|
|
config = load_config("cmake_batch_build.json")
|
|
definitions = config.get("definitions", {})
|
|
actions = config.get("actions", {})
|
|
|
|
# 解析出所有的PackateType
|
|
parser = PackageParser(definitions.get("package-types"))
|
|
all_packages = parser.parse_all()
|
|
|
|
# 与用户交互，得到用户选择的packageType列表
|
|
g_packages = select_packages(all_packages)
|
|
|
|
# 得到需要编译的preset列表
|
|
g_presets = get_all_presets_union(g_packages)
|
|
if not g_presets:
|
|
print("没有选择打包类型。")
|
|
return
|
|
|
|
# 更新代码
|
|
svnUpdate(actions.get("update-svn", {}))
|
|
|
|
# 编译startApp工程
|
|
buildStartApp(actions.get("compile-startApp", {}), definitions)
|
|
|
|
# 编译presets
|
|
buildPresets(g_presets, definitions)
|
|
|
|
# 压缩大文件
|
|
process_compression_tasks(actions.get("compress_huge_files"), definitions)
|
|
|
|
#copy 打包文件
|
|
dest_dir = resolve_variables(definitions.get("dest_dir", ""), definitions)
|
|
if os.path.exists(dest_dir):
|
|
print(f"[*] 清空统一输出基础目录: {dest_dir}")
|
|
shutil.rmtree(dest_dir, ignore_errors=True)
|
|
|
|
# copy 编译生成物和依赖
|
|
copy_preset(actions.get("copy_preset"), g_presets, definitions)
|
|
|
|
# copy 其他需要打包的文件
|
|
process_general_copy(actions.get("copy"), definitions)
|
|
|
|
# 打包
|
|
package(actions.get("innosetup"), g_packages, definitions)
|
|
|
|
return
|
|
|
|
if __name__ == "__main__":
|
|
main() |