WMS_MAIN/script/deploy-watchdog.cjs
liufumingren 1fbc24c904 chore(deploy): 运维命令收敛为 install/uninstall,移除失效的 deploy:gateway-probe
- watchdog 部署工具只保留 install / uninstall:uninstall 先备份到
  /tmp/qimen-watchdog-uninstall-<时间戳>/(cp -a 保留权限/时间),再**注销调度**
  —— 删除 /etc/cron.d/qimen-watchdog 并清理 root crontab 中残留的 qimen-watchdog 行
  (历史手工安装可能留过,双跑会并发 kill/start 同一实例),随后删除服务器副本
  <部署根>/script/qimen-watchdog.sh 及其 .prev-* / .legacy-* 与历史根目录副本;
  不碰日志、锁文件与接口服务进程;支持 --dry-run 只打印计划。
  原 precheck 的只读环境快照改为 install 开头自动打印;status / dry-run / run
  三个命令删除(需要时直接 ssh 执行 <部署根>/script/qimen-watchdog.sh --dry-run)。
- 移除失效的 deploy:gateway-probe:npm 脚本未传必需的 method 位置参数,而
  gatewayProbe() 在缺参时直接抛错,命令必然 exit 1(CLI 契约与 npm 接线不匹配,
  该命令从未能成功)。删除 npm 命令与 script/deploy-ops.cjs 中的 gatewayProbe 实现;
  需要网关真实探活时直连活跃端口(current.md:v1→6061 / v2→6062)。
- 两份发布 agent 文档中的 "npm run deploy:gateway-probe -- releaseProbe.ping {}"
  已删除 —— 其中的 releaseProbe.ping 这个 method 在应用内并不存在(双重失效),
  改为「直连活跃端口」的说明;README 同步运维命令清单与 watchdog 卸载说明。
- 顺手修掉 script/deploy-ops.cjs 两处历史 lint 问题(模板字符串改单引号、
  文件末尾补换行),该文件 lint 现已干净。
2026-09-28 01:21:55 +08:00

476 lines
20 KiB
JavaScript
Raw Permalink 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.

'use strict';
/**
* qimen 接口服务看门狗(keep-alive)的安装与运维工具。
*
* 与 script/deploy-cert-sync.cjs 同源思路,但对象完全不同:
* - 安装对象:script/qimen-watchdog.sh(仓库源)→ <部署根>/script/qimen-watchdog.sh(服务器稳定副本)
* - 调度载体:/etc/cron.d/qimen-watchdog(系统级 cron.d)
* **刻意不放 root crontab**:宝塔面板会整体重写 root crontab,放那儿会被冲掉。
* - 日志:/www/wwwlogs/wms/qimen-watchdog.log
*
* 为什么副本放部署根下的 script/ 目录而不是 v1/v2:
* 与证书同步脚本同理——不受版本切换与发布清理影响,版本目录里没有它的位置;
* 同时与 warehouse-cert-sync.sh / warehouse-cert-sync.cjs 收口在同一目录,运维只需看一处。
* install 会把历史位置(部署根)的同名副本一次性挪成 script/<name>.legacy-<时间戳> 备份。
*
* 设计要点:
* 1. 幂等:可重复 install;cron.d 文件用「临时文件 + mv」原子覆盖,不会出现半截配置;
* 2. 备份:覆盖前把既有副本 cp -a 成 <path>.prev-<时间戳>,保留回滚余地;
* 3. 去重:若 root crontab 里存在历史 watchdog 行(早期手工装的),install 会删掉,
* 避免与 cron.d 条目双跑——看门狗双跑会并发 kill/start 同一实例,风险很高;
* 4. 校验三连:bash -n 语法校验 + sha256 与本地源比对(不一致直接失败)+
* 远端 --dry-run 冒烟(只探活、绝不启动/杀进程);
* 5. 不碰服务:install 不重启 qimen、不 reload nginx、不动任何数据库。
*
* 用法(npm 命令仅 install / uninstall 两条):
* node script/deploy-watchdog.cjs production install
* node script/deploy-watchdog.cjs production uninstall [--dry-run]
*
* uninstall 做什么(先备份再删除):
* 1. 备份到 /tmp/qimen-watchdog-uninstall-<时间戳>/(cp -a 保留权限/时间);
* 2. **注销调度**:删除 /etc/cron.d/qimen-watchdog,并清理 root crontab 中残留的
* qimen-watchdog 行(历史手工安装可能留过,双跑会并发 kill/start 同一实例);
* 3. 删除服务器副本 <部署根>/script/qimen-watchdog.sh 及其 .prev-* / .legacy-* 备份,
* 以及历史位置 <部署根>/qimen-watchdog.sh;
* 4. **不碰**:日志 /www/wwwlogs/wms/qimen-watchdog.log、锁 /var/lock/qimen-watchdog.lock、
* 接口服务进程、nginx 与数据库(日志保留作排查线索)。
* 支持 --dry-run:只打印计划,不备份、不删除、不改 crontab。
*
* 退出码:0 成功;非 0 失败(参数非法 / 本地文件缺失 / sha 不一致 / 远端命令失败)。
*/
const fs = require('node:fs');
const path = require('node:path');
const crypto = require('node:crypto');
const {
ROOT,
getNowStamp,
loadDeployConfig,
quoteForBash,
runScp,
runSsh,
} = require('./deploy-lib.cjs');
const COMMANDS = new Set([ 'install', 'uninstall' ]);
/** 仓库源文件(脚本本体)。 */
const LOCAL_WATCHDOG = path.join(ROOT, 'script', 'qimen-watchdog.sh');
/** 服务器副本文件名(落在部署根的 script/ 目录下,与 cert-sync 脚本同目录)。 */
const REMOTE_FILENAME = 'qimen-watchdog.sh';
/** 服务器副本相对部署根的路径。 */
const REMOTE_RELATIVE = `script/${REMOTE_FILENAME}`;
/** cron.d 文件名 / 路径(名称不含点,避免被 cron 忽略)。 */
const CRON_D_NAME = 'qimen-watchdog';
const CRON_D_PATH = `/etc/cron.d/${CRON_D_NAME}`;
const LOG_PATH = '/www/wwwlogs/wms/qimen-watchdog.log';
const LOCK_PATH = '/var/lock/qimen-watchdog.lock';
const CRON_SCHEDULE = '*/5 * * * *';
const CRON_USER = 'root';
/**
* 打印本工具用法(仅 install / uninstall 两条 npm 命令)。
*/
function printUsage() {
console.error([
'usage: node script/deploy-watchdog.cjs [env] <command> [--dry-run]',
' env: production | development(默认 production)',
' command: install 上传看门狗脚本 + 写 /etc/cron.d/qimen-watchdog(含语法/哈希/冒烟校验)',
' uninstall 注销 cron.d 与 root crontab 行,备份后删除服务器副本(支持 --dry-run)',
'运行期手动排查:直接执行服务器上的 <deployRoot>/script/qimen-watchdog.sh --dry-run',
].join('\n'));
}
/**
* 解析命令行参数。
* @param {string[]} argv process.argv.slice(2)。
* @return {{envName: string, command: string, dryRun: boolean}} 解析结果。
* @throws {Error} 缺少/非法命令时抛出。
*/
function parseArgs(argv) {
const options = { envName: 'production', command: '', dryRun: false };
const tokens = [ ...argv ];
options.dryRun = tokens.includes('--dry-run');
const positional = tokens.filter(token => token !== '--dry-run');
if (positional.length === 0) {
printUsage();
throw new Error('missing command: install | uninstall');
}
if (!COMMANDS.has(positional[0])) {
options.envName = positional[0];
positional.shift();
}
if (positional.length === 0 || !COMMANDS.has(positional[0])) {
printUsage();
throw new Error('missing command: install | uninstall');
}
options.command = positional[0];
return options;
}
/**
* 计算本地文件 sha256(十六进制,小写)。
* @param {string} filePath 文件绝对路径。
* @return {string} sha256 摘要。
*/
function localSha256(filePath) {
return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
}
/**
* 目标服务器上的看门狗脚本绝对路径。
* @param {Object} config deploy 配置对象。
* @return {string} 绝对路径。
*/
function remoteWatchdogPath(config) {
return `${config.deployRoot}/${REMOTE_RELATIVE}`;
}
/**
* 生成 /etc/cron.d/qimen-watchdog 的完整内容。
* @param {string} watchdogPath 服务器上的看门狗脚本绝对路径。
* @return {string} cron.d 文件内容(含首部注释与 env 声明)。
*/
function buildCronFileContent(watchdogPath) {
return [
'# qimen 接口服务看门狗(保活)',
'# 由 npm run deploy:watchdog:install 维护,请勿手工编辑(会被下次安装覆盖)。',
'# 仓库源:script/qimen-watchdog.sh;服务器稳定副本:<部署根>/script/qimen-watchdog.sh',
'# 放在 /etc/cron.d 而非 root crontab:宝塔面板会整体重写 root crontab,会把它冲掉。',
'# 手动验证:bash <部署根>/script/qimen-watchdog.sh --dry-run',
'SHELL=/bin/bash',
'PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
`${CRON_SCHEDULE} ${CRON_USER} ${watchdogPath} >> ${LOG_PATH} 2>&1`,
'',
].join('\n');
}
/**
* 安装前只读打印目标机环境快照(部署根、current.md、cron.d、实例与端口等),
* 让安装日志保留一份「安装前」现场;只读,不启动 / 不杀任何进程。
* @param {Object} config deploy 配置对象。
* @return {void}
*/
function printTargetEnvInfo(config) {
const deployRoot = config.deployRoot;
const remoteScript = [
'set -uo pipefail',
`DEPLOY_ROOT=${quoteForBash(deployRoot)}`,
`TARGET="$DEPLOY_ROOT/${REMOTE_FILENAME}"`,
'echo "[WHOAMI] $(id -un)"',
'echo "[UNAME] $(uname -a)"',
'echo "[DEPLOY_ROOT_LS]"; ls -la "$DEPLOY_ROOT" | awk \'{print $1, $3, $4, $9}\'',
'echo "[CURRENT_MD] $(cat "$DEPLOY_ROOT/current.md" 2>/dev/null | tr -d "[:space:]" || echo MISSING)"',
'echo "[UPSTREAM_CONF]"; cat "$DEPLOY_ROOT/nginx-upstream.conf" 2>/dev/null || echo "(missing)"',
'echo "[WATCHDOG_FILE]"; if [ -f "$TARGET" ]; then ls -l --time-style=full-iso "$TARGET"; sha256sum "$TARGET"; else echo "MISSING"; fi',
'echo "[CRON_D]"; if [ -f ' + quoteForBash(CRON_D_PATH) + ' ]; then cat ' + quoteForBash(CRON_D_PATH) + '; else echo "MISSING"; fi',
'echo "[CRON_SERVICE]"; systemctl is-active cron 2>/dev/null || (service cron status 2>/dev/null | head -1) || echo unknown',
'echo "[ROOT_CRONTAB_MATCH]"; crontab -l 2>/dev/null | grep -n "qimen-watchdog" || echo NONE',
'echo "[LOG]"; ls -l ' + quoteForBash(LOG_PATH) + ' 2>/dev/null || echo "log missing"; tail -5 ' + quoteForBash(LOG_PATH) + ' 2>/dev/null',
'echo "[LOCK]"; ls -l ' + quoteForBash(LOCK_PATH) + ' 2>/dev/null || echo "lock not created yet"',
'echo "[INSTANCES]"; ps -eo pid=,etime=,args= | grep "[e]gg-scripts start" | head -6 || true',
'echo "[PORTS]"; ss -lntp 2>/dev/null | grep -E ":6061|:6062" || echo "no 6061/6062 listener"',
].join('\n');
console.log('[INSTALL] 目标机环境快照(只读,不启动/不杀进程)');
console.log(String(runSsh(config, remoteScript, { stdio: 'pipe' }) || '').trim());
}
/**
* 安装:备份旧副本 → 上传脚本 → 写 cron.d → 清理历史 root crontab 行 → 语法/哈希/冒烟校验。
* @param {Object} config deploy 配置对象。
* @return {void}
*/
function runInstall(config) {
const deployRoot = config.deployRoot;
printTargetEnvInfo(config);
if (!fs.existsSync(LOCAL_WATCHDOG)) {
throw new Error(`local file missing: ${LOCAL_WATCHDOG} (script/qimen-watchdog.sh)`);
}
const localSha = localSha256(LOCAL_WATCHDOG);
const target = remoteWatchdogPath(config);
console.log(`[INSTALL] local source: ${LOCAL_WATCHDOG} sha256=${localSha}`);
const remoteDirScript = [
'set -euo pipefail',
`DEPLOY_ROOT=${quoteForBash(deployRoot)}`,
`TARGET="$DEPLOY_ROOT/${REMOTE_RELATIVE}"`,
`STAMP=${quoteForBash(getNowStamp())}`,
'mkdir -p "$DEPLOY_ROOT/script" /www/wwwlogs/wms',
'# 历史位置(部署根)一次性迁移:旧副本挪进 script/ 留作回滚备份,避免根目录残留孤儿',
'LEGACY="$DEPLOY_ROOT/qimen-watchdog.sh"',
'if [ -f "$LEGACY" ]; then mv "$LEGACY" "$DEPLOY_ROOT/script/qimen-watchdog.sh.legacy-$STAMP" && echo "LEGACY_MOVED $LEGACY -> $DEPLOY_ROOT/script/qimen-watchdog.sh.legacy-$STAMP"; fi',
'if [ -f "$TARGET" ]; then cp -a "$TARGET" "$TARGET.prev-$STAMP" && echo "BACKED_UP $TARGET -> $TARGET.prev-$STAMP"; else echo "NO_EXISTING_COPY"; fi',
`touch ${quoteForBash(LOG_PATH)} && chmod 644 ${quoteForBash(LOG_PATH)} && echo "LOG_FILE_OK"`,
].join('\n');
console.log('[INSTALL] remote dir prep + backup of existing copy');
console.log(String(runSsh(config, remoteDirScript, { stdio: 'pipe' }) || '').trim());
runScp(config, LOCAL_WATCHDOG, target);
console.log(`[INSTALL] uploaded -> ${target}`);
const finalizeScript = [
'set -euo pipefail',
`TARGET=${quoteForBash(target)}`,
`CRON_D=${quoteForBash(CRON_D_PATH)}`,
'chmod 755 "$TARGET" && echo "CHMOD_OK"',
'bash -n "$TARGET" && echo "WATCHDOG_SYNTAX_OK"',
`LOCAL_SHA=${quoteForBash(localSha)}`,
'REMOTE_SHA_LINE=$(sha256sum "$TARGET")',
'REMOTE_SHA=${REMOTE_SHA_LINE%% *}',
'if [ "$REMOTE_SHA" = "$LOCAL_SHA" ]; then echo "SHA_MATCH $REMOTE_SHA"; else echo "SHA_MISMATCH local=$LOCAL_SHA remote=$REMOTE_SHA"; exit 1; fi',
'TMP=$(mktemp /tmp/qimen-watchdog.cron.XXXXXX)',
'cat > "$TMP" <<\'QIMEN_WATCHDOG_CRON_EOF\'',
buildCronFileContent(target).replace(/\n+$/, ''),
'QIMEN_WATCHDOG_CRON_EOF',
'chown root:root "$TMP" && chmod 644 "$TMP"',
'mv "$TMP" "$CRON_D" && echo "CRON_D_WRITTEN $CRON_D"',
'echo "[CRON_D_CONTENT]"',
'cat "$CRON_D"',
'if crontab -l 2>/dev/null | grep -q "qimen-watchdog"; then',
' crontab -l 2>/dev/null | grep -v "qimen-watchdog" | crontab -',
' echo "ROOT_CRONTAB_DEDUPED (legacy watchdog line removed)"',
'else',
' echo "ROOT_CRONTAB_CLEAN"',
'fi',
'echo "[CRON_SERVICE] $(systemctl is-active cron 2>/dev/null || echo unknown)"',
'echo "[SMOKE] bash $TARGET --dry-run (probe only, never starts/kills)"',
'bash "$TARGET" --dry-run 2>&1 | tail -15 || true',
].join('\n');
console.log('[INSTALL] write cron.d + verify (syntax / sha256 / dry-run smoke)');
console.log(String(runSsh(config, finalizeScript, { stdio: 'pipe' }) || '').trim());
}
/**
* 生成卸载目标清单:服务器副本 + 历史位置 + 备份 glob(.prev-* / .legacy-*)。
* @param {string} deployRoot 部署根目录。
* @return {{ exactPaths: string[], globPatterns: string[] }} 目标清单。
*/
function buildUninstallTargets(deployRoot) {
const exactPaths = [
`${deployRoot}/${REMOTE_RELATIVE}`,
`${deployRoot}/${REMOTE_FILENAME}`,
];
const globPatterns = [];
for (const base of exactPaths) {
globPatterns.push(`${base}.prev-*`, `${base}.legacy-*`);
}
return { exactPaths, globPatterns };
}
/**
* 生成 dry-run 计划脚本(只读:只打印将备份/将删除的目标与将注销的 cron 项)。
* @param {Object} config deploy 配置对象。
* @param {string} backupDir 计划使用的备份目录(dry-run 不创建)。
* @return {string} 远端 bash 脚本。
*/
function buildUninstallDryRunScript(config, backupDir) {
const { exactPaths, globPatterns } = buildUninstallTargets(config.deployRoot);
return [
'set -uo pipefail',
`B_DIR=${quoteForBash(backupDir)}`,
'echo "PLAN_BACKUP_DIR=$B_DIR"',
`for T in ${exactPaths.map(quoteForBash).join(' ')}; do`,
' if [ -f "$T" ]; then echo "WOULD_BACKUP_AND_DELETE $T"; else echo "MISSING_SKIP $T"; fi',
'done',
`for G in ${globPatterns.map(quoteForBash).join(' ')}; do`,
' for F in $G; do',
' [ -f "$F" ] || continue',
' echo "WOULD_BACKUP_AND_DELETE $F"',
' done',
'done',
`CRON_D=${quoteForBash(CRON_D_PATH)}`,
'if [ -f "$CRON_D" ]; then echo "WOULD_BACKUP_AND_DELETE $CRON_D"; else echo "MISSING_SKIP $CRON_D"; fi',
'CRON_BEFORE=$(crontab -l 2>/dev/null | wc -l)',
'CRON_HIT=$(crontab -l 2>/dev/null | grep -c "qimen-watchdog" || true)',
'if [ "$CRON_HIT" -gt 0 ]; then',
' crontab -l 2>/dev/null | grep "qimen-watchdog" | sed "s|^|WOULD_REMOVE_CRON_LINE |" || true',
' echo "CRONTAB_WOULD_GO before=$CRON_BEFORE after=$((CRON_BEFORE - CRON_HIT))"',
'else',
' echo "CRONTAB_UNTOUCHED_NO_MATCH"',
'fi',
].join('\n');
}
/**
* 生成真实卸载脚本:先备份(cp -a 保留权限/时间)再删除,并注销调度:
* - 删除 /etc/cron.d/qimen-watchdog(先备份);
* - 清理 root crontab 中残留的 qimen-watchdog 行(历史手工安装可能留过)。
* 单项失败不中断(HAD_ERRORS 标记);日志 / 锁 / 服务 / nginx / 数据库一律不触碰。
* @param {Object} config deploy 配置对象。
* @param {string} backupDir 备份目录(/tmp/qimen-watchdog-uninstall-<时间戳>/)。
* @return {string} 远端 bash 脚本。
*/
function buildUninstallScript(config, backupDir) {
const { exactPaths, globPatterns } = buildUninstallTargets(config.deployRoot);
return [
'set -u',
`BACKUP_DIR=${quoteForBash(backupDir)}`,
'HAD_ERRORS=0',
'mkdir -p "$BACKUP_DIR" && echo "BACKUP_DIR=$BACKUP_DIR" || { echo "BACKUP_DIR_CREATE_FAILED $BACKUP_DIR"; HAD_ERRORS=1; }',
`for T in ${exactPaths.map(quoteForBash).join(' ')}; do`,
' if [ -f "$T" ]; then',
' BASE=$(basename "$T")',
' if cp -a "$T" "$BACKUP_DIR/$BASE"; then echo "BACKED_UP $T -> $BACKUP_DIR/$BASE"; else echo "BACKUP_FAILED $T (保留未删)"; HAD_ERRORS=1; continue; fi',
' if rm -f "$T"; then echo "DELETED $T"; else echo "DELETE_FAILED $T"; HAD_ERRORS=1; fi',
' else',
' echo "MISSING_SKIP $T"',
' fi',
'done',
`for G in ${globPatterns.map(quoteForBash).join(' ')}; do`,
' for F in $G; do',
' [ -f "$F" ] || continue',
' BASE=$(basename "$F")',
' if cp -a "$F" "$BACKUP_DIR/$BASE"; then echo "BACKED_UP $F -> $BACKUP_DIR/$BASE"; else echo "BACKUP_FAILED $F (保留未删)"; HAD_ERRORS=1; continue; fi',
' if rm -f "$F"; then echo "DELETED $F"; else echo "DELETE_FAILED $F"; HAD_ERRORS=1; fi',
' done',
'done',
`CRON_D=${quoteForBash(CRON_D_PATH)}`,
'if [ -f "$CRON_D" ]; then',
' if cp -a "$CRON_D" "$BACKUP_DIR/qimen-watchdog.cron.d"; then echo "BACKED_UP $CRON_D -> $BACKUP_DIR/qimen-watchdog.cron.d"; else echo "BACKUP_FAILED $CRON_D (保留未删)"; HAD_ERRORS=1; fi',
' if rm -f "$CRON_D"; then echo "CRON_D_REMOVED $CRON_D"; else echo "CRON_D_REMOVE_FAILED $CRON_D"; HAD_ERRORS=1; fi',
'else',
' echo "MISSING_SKIP $CRON_D"',
'fi',
'CRON_BEFORE=$(crontab -l 2>/dev/null | wc -l)',
'CRON_HIT=$(crontab -l 2>/dev/null | grep -c "qimen-watchdog" || true)',
'if [ "$CRON_HIT" -gt 0 ]; then',
' crontab -l 2>/dev/null | grep "qimen-watchdog" | sed "s|^|CRON_REMOVED_LINE |" || true',
' if ( crontab -l 2>/dev/null | grep -v "qimen-watchdog" || true ) | crontab -; then',
' echo "CRONTAB_REWRITTEN before=$CRON_BEFORE after=$(crontab -l 2>/dev/null | wc -l)"',
' else',
' echo "CRONTAB_REWRITE_FAILED"',
' HAD_ERRORS=1',
' fi',
'else',
' echo "CRONTAB_UNTOUCHED_NO_MATCH"',
'fi',
'echo "HAD_ERRORS=$HAD_ERRORS"',
].join('\n');
}
/**
* 打印卸载结果(三段:备份 / 已删除(含调度注销)/ 未触碰)。
* @param {string} output 远端脚本输出。
* @param {boolean} dryRun 是否 dry-run(只打印计划)。
* @param {string} backupDir 备份目录路径。
* @return {void}
*/
function printUninstallReport(output, dryRun, backupDir) {
const lines = String(output || '')
.split(/\r?\n/)
.map(line => line.trim())
.filter(Boolean);
const planned = [];
const backedUp = [];
const deleted = [];
const untouched = [];
const failures = [];
for (const line of lines) {
if (line === 'HAD_ERRORS=0' || line === 'HAD_ERRORS=1') {
continue;
}
if (/^(WOULD_BACKUP_AND_DELETE|WOULD_REMOVE_CRON_LINE|CRONTAB_WOULD_GO|PLAN_BACKUP_DIR)/.test(line)) {
planned.push(line);
continue;
}
if (/^(BACKED_UP|BACKUP_DIR=)/.test(line)) {
backedUp.push(line);
continue;
}
if (/^(DELETED|CRON_D_REMOVED|CRON_REMOVED_LINE|CRONTAB_REWRITTEN)/.test(line)) {
deleted.push(line);
continue;
}
if (/^(MISSING_SKIP|CRONTAB_UNTOUCHED_NO_MATCH)/.test(line)) {
untouched.push(line);
continue;
}
if (/FAIL|ERROR/.test(line)) {
failures.push(line);
continue;
}
failures.push(`UNCLASSIFIED ${line}`);
}
const suffix = dryRun ? '(计划)' : '';
const backupLines = dryRun ? planned : backedUp;
const deleteLines = dryRun
? planned.filter(line => !line.startsWith('PLAN_BACKUP_DIR'))
: deleted;
console.log(`[UNINSTALL] 备份${suffix}`);
for (const line of (backupLines.length > 0 ? backupLines : [ '(无)' ])) {
console.log(` ${line}`);
}
console.log(`[UNINSTALL] 已删除 / 已注销调度${suffix}`);
for (const line of (deleteLines.length > 0 ? deleteLines : [ '(无)' ])) {
console.log(` ${line}`);
}
console.log('[UNINSTALL] 未触碰(原因)');
for (const line of untouched) {
console.log(` ${line}`);
}
console.log(` 日志(保留作排查线索):${LOG_PATH}`);
console.log(` 锁文件(空闲时本就不存在):${LOCK_PATH}`);
console.log(' 接口服务进程 / nginx / 数据库:本工具从不触碰');
if (failures.length > 0) {
console.error('[UNINSTALL] 失败项');
for (const line of failures) {
console.error(` ${line}`);
}
}
console.log(`[UNINSTALL] 备份目录:${backupDir}`);
}
/**
* 卸载:备份 → 注销调度(/etc/cron.d 与 root crontab 残留行)→ 删除服务器副本。
* @param {Object} config deploy 配置对象。
* @param {{dryRun: boolean}} options 解析后的参数。
* @return {void}
*/
function runUninstall(config, options) {
const backupDir = `/tmp/qimen-watchdog-uninstall-${getNowStamp()}/`;
const script = options.dryRun
? buildUninstallDryRunScript(config, backupDir)
: buildUninstallScript(config, backupDir);
if (options.dryRun) {
console.log('[UNINSTALL] dry-run(只读:只打印计划,不备份、不删除、不改 crontab)');
} else {
console.log('[UNINSTALL] 开始卸载(先备份再删除,并注销 /etc/cron.d 与 root crontab 行)');
}
const output = String(runSsh(config, script, { stdio: 'pipe' }) || '');
printUninstallReport(output, options.dryRun, backupDir);
if (options.dryRun) {
console.log('[UNINSTALL] dry-run 结束(未做任何变更)');
return;
}
if (/(^|\n)HAD_ERRORS=1/.test(output)) {
console.error('[UNINSTALL] 存在失败项(见上),可从备份目录恢复');
process.exitCode = 1;
}
}
function main() {
const options = parseArgs(process.argv.slice(2));
const config = loadDeployConfig(options.envName);
if (options.command === 'install') {
runInstall(config);
return;
}
if (options.command === 'uninstall') {
runUninstall(config, options);
return;
}
throw new Error(`unsupported command: ${options.command}`);
}
main();