AppServer/xNIX/

适配 PVE 7/8/9 的优化脚本

发布
修订
未修订
字数
10012
阅读
21 分钟

之前在帖子中提供了一个脚本,可以对 PVE 进行如下优化:
取消订阅弹窗
添加温度和硬件信息显示等。

但这个脚本有一些兼容性问题,在新版本的 PVE 中运行效果并不好。后面找 AI 对这个脚本进行了优化,最终生成了一个适配 PVE 7/8/9 的脚本,代码如下:

bash
#!/usr/bin/env bash
# =============================================================================
# pve-optimize —— Proxmox VE 7 / 8 / 9 界面增强
#   * 节点「概要」页显示:CPU 温度、主板/其它温度、CPU 频率、硬盘 SMART 信息
#   * 去除「无有效订阅」弹窗
#   * 状态面板高度自适应,并与同一行的图表等高
#   * APT 升级后自动重新打补丁;可完整还原
#
# 用法:
#   bash pve-optimize.sh apply      [--repair] [--no-sensors-detect] [--force]
#   bash pve-optimize.sh restore    [--purge]
#   bash pve-optimize.sh check      # 自检(PASS/WARN/FAIL)
#   bash pve-optimize.sh collect    # 立即采集一次并打印摘要
#   安装后也可直接使用命令: pve-optimize <子命令>
#
# 设计要点:
#   - 采集由 root 常驻服务完成并写入 /run/pve-optimize/hwinfo.json;
#     Web 接口(以 www-data 运行)只读取该文件,不 fork 任何进程,不需要 suid。
#   - 所有补丁都带标记,可精确逆向;还原后用 dpkg 的 md5 校验确认文件回到原样。
#   - 前端以 Ext.define override 方式注入,不依赖上游代码的缩进/换行格式。
# =============================================================================
set -Eeuo pipefail

VERSION="1.0.1"

INSTALL_BIN=/usr/local/sbin/pve-optimize
LIB_DIR=/usr/local/lib/pve-optimize
COLLECTOR=$LIB_DIR/hwinfo-collect.pl
STATE_DIR=/var/lib/pve-optimize
BACKUP_DIR=$STATE_DIR/backup
HOOK_LOG=$STATE_DIR/hook.log
CONF=/etc/pve-optimize.conf
SERVICE=pve-optimize-hwinfo.service
SERVICE_FILE=/etc/systemd/system/$SERVICE
APT_HOOK=/etc/apt/apt.conf.d/99-pve-optimize
MODLOAD=/etc/modules-load.d/pve-optimize.conf
RUN_DIR=/run/pve-optimize
RUN_JSON=$RUN_DIR/hwinfo.json

NODES_PM=/usr/share/perl5/PVE/API2/Nodes.pm
MANAGER_JS=/usr/share/pve-manager/js/pvemanagerlib.js
TOOLKIT_JS=/usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js

MODE_HOOK=0
OPT_REPAIR=0
OPT_FORCE=0
OPT_NO_SENSORS_DETECT=0
OPT_PURGE=0
TMP_FILES=()

# ----------------------------------------------------------------------------- 输出
if [[ -t 1 ]]; then
    C_RED=$'\033[31m'; C_GRN=$'\033[32m'; C_YEL=$'\033[33m'; C_BLU=$'\033[36m'; C_OFF=$'\033[0m'
else
    C_RED=''; C_GRN=''; C_YEL=''; C_BLU=''; C_OFF=''
fi
log()  { if [[ $MODE_HOOK == 1 ]]; then echo "$(date '+%F %T') $*" >>"$HOOK_LOG" 2>/dev/null || true; else echo -e "${C_BLU}==>${C_OFF} $*"; fi; }
warn() { if [[ $MODE_HOOK == 1 ]]; then log "WARN: $*"; else echo -e "${C_YEL}[警告]${C_OFF} $*" >&2; fi; }
err()  { if [[ $MODE_HOOK == 1 ]]; then log "ERROR: $*"; else echo -e "${C_RED}[错误]${C_OFF} $*" >&2; fi; }
die()  { err "$*"; exit 1; }

cleanup() { local f; for f in "${TMP_FILES[@]:-}"; do [[ -n $f ]] && rm -f "$f"; done; }
trap cleanup EXIT
new_tmp() { local _t; _t=$(mktemp /tmp/pve-optimize.XXXXXX); TMP_FILES+=("$_t"); printf -v "$1" '%s' "$_t"; }

# ----------------------------------------------------------------------------- 配置
conf_get() { # conf_get KEY DEFAULT
    local v=''
    if [[ -r $CONF ]]; then
        v=$(sed -nE "s/^[[:space:]]*$1[[:space:]]*=[[:space:]]*\"?([^\"#]*)\"?.*$/\1/p" "$CONF" | tail -n1 | sed -E 's/[[:space:]]+$//')
    fi
    echo "${v:-$2}"
}

write_default_conf() {
    [[ -e $CONF ]] && return 0
    cat >"$CONF" <<'EOF'
# pve-optimize 配置文件。修改后执行: pve-optimize apply
# 去除订阅弹窗 (1=去除, 0=保留官方行为)
NO_NAG=1
# 显示内容开关
SHOW_TEMP=1
SHOW_FREQ=1
SHOW_DISKS=1
# 温度/频率采集间隔(秒, >=5)
COLLECT_INTERVAL=15
# 硬盘 SMART 采集间隔(秒, >=30)。休眠中的硬盘不会被唤醒
DISK_INTERVAL=60
# 单块硬盘 smartctl 超时(秒)
SMART_TIMEOUT=20
# 不采集的硬盘(Perl 正则, 匹配设备名), 例如: ^/dev/sd[xy]$
DISK_EXCLUDE=""
EOF
    chmod 0644 "$CONF"
}

# ----------------------------------------------------------------------------- 环境检测
need_root() { [[ $EUID -eq 0 ]] || die "请以 root 身份运行"; }

pve_version() { pveversion 2>/dev/null | sed -nE 's#^pve-manager/([0-9][0-9.]*)/.*#\1#p' | head -n1; }
pve_major()   { local v; v=$(pve_version); echo "${v%%.*}"; }

check_pve() {
    command -v pveversion >/dev/null 2>&1 || die "未检测到 Proxmox VE (缺少 pveversion 命令)"
    local major; major=$(pve_major)
    [[ -n $major ]] || die "无法识别 PVE 版本"
    if (( major < 7 || major > 9 )); then
        if [[ $OPT_FORCE == 1 ]]; then
            warn "PVE $major 未经测试,--force 强制继续"
        else
            die "本脚本支持 PVE 7/8/9,当前为 PVE $(pve_version)。如需强制尝试请加 --force"
        fi
    fi
    local f
    for f in "$NODES_PM" "$MANAGER_JS" "$TOOLKIT_JS"; do
        [[ -f $f ]] || die "缺少文件: $f"
    done
}

# ----------------------------------------------------------------------------- dpkg 校验
file_pkg() { dpkg-query -S "$1" 2>/dev/null | head -n1 | cut -d: -f1; }
pkg_ver()  { dpkg-query -W -f='${Version}' "$1" 2>/dev/null; }
expected_md5() {
    local f=$1 pkg ms
    pkg=$(file_pkg "$f"); [[ -n $pkg ]] || return 0
    ms=$(dpkg-query --control-path "$pkg" md5sums 2>/dev/null || true)
    [[ -r $ms ]] || ms=/var/lib/dpkg/info/$pkg.md5sums
    [[ -r $ms ]] || return 0
    awk -v p="${f#/}" '$2==p {print $1; exit}' "$ms"
}
md5_of() { md5sum "$1" | cut -d' ' -f1; }

# ----------------------------------------------------------------------------- 补丁内容
read -r -d '' NODES_BLOCK <<'PM_EOF' || true
# PVE-OPTIMIZE BEGIN (managed by /usr/local/sbin/pve-optimize, do not edit)
eval {
    my $pveopt_f = '/run/pve-optimize/hwinfo.json';
    if (-r $pveopt_f && open(my $pveopt_fh, '<', $pveopt_f)) {
        local $/;
        $res->{hwinfo} = <$pveopt_fh>;
        close($pveopt_fh);
        $res->{hwinfoage} = int(CORE::time()) - (CORE::stat($pveopt_f))[9];
    }
};
# PVE-OPTIMIZE END
PM_EOF

read -r -d '' JS_BLOCK <<'JS_EOF' || true
/* PVE-OPTIMIZE BEGIN v@VERSION@ (managed by /usr/local/sbin/pve-optimize, do not edit) */
(function () {
    // 注意: 不能启用 'use strict',ExtJS 的 me.callParent() 依赖 Function.prototype.caller
    if (typeof Ext === 'undefined' || !Ext.define) {
        return;
    }
    var VERSION = '@VERSION@';
    var C_RED = '#d9534f', C_ORG = '#f0ad4e', C_GRN = '#3c9d4c', C_GRY = '#888';

    var num = function (v) { return typeof v === 'number' && isFinite(v); };
    var enc = function (s) { return Ext.String.htmlEncode(s === undefined || s === null ? '' : String(s)); };
    var color = function (c, s, bold) {
        return '<span style="color:' + c + (bold ? ';font-weight:bold' : '') + '">' + s + '</span>';
    };
    var grey = function (s) { return color(C_GRY, s); };

    function parseInfo(v) {
        if (!v) { return null; }
        if (typeof v === 'object') { return v; }
        try {
            var o = JSON.parse(v);
            return o && typeof o === 'object' ? o : null;
        } catch (e) {
            return null;
        }
    }
    function fmtTemp(t, warnAt, critAt) {
        if (!num(t)) { return grey('?'); }
        var s = (Math.round(t * 10) / 10) + '°C';
        if (num(critAt) && t >= critAt) { return color(C_RED, s, true); }
        if (num(warnAt) && t >= warnAt) { return color(C_ORG, s); }
        return s;
    }
    function fmtBytes(b) {
        if (!num(b) || b <= 0) { return ''; }
        var u = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB'], i = 0;
        while (b >= 1000 && i < u.length - 1) { b /= 1000; i++; }
        return (i === 0 || b >= 100 ? b.toFixed(0) : b.toFixed(b >= 10 ? 1 : 2)) + ' ' + u[i];
    }
    function fmtAge(sec) {
        if (!num(sec) || sec < 0) { return ''; }
        if (sec < 90) { return Math.round(sec) + ' 秒'; }
        if (sec < 5400) { return Math.round(sec / 60) + ' 分钟'; }
        if (sec < 172800) { return Math.round(sec / 3600) + ' 小时'; }
        return Math.round(sec / 86400) + ' 天';
    }
    function ghz(mhz) { return (mhz / 1000).toFixed(2); }

    function cpuTempLines(chips) {
        var lines = [];
        var cpus = chips.filter(function (c) { return c && c.kind === 'cpu' && Array.isArray(c.sensors); });
        cpus.forEach(function (chip, ci) {
            var ss = chip.sensors.filter(function (s) { return s && num(s.value); });
            if (!ss.length) { return; }
            var tag = cpus.length > 1 ? 'CPU' + ci : 'CPU';
            var crit = null;
            ss.forEach(function (s) { if (num(s.crit) && (crit === null || s.crit < crit)) { crit = s.crit; } });
            var warnAt = crit !== null ? crit - 10 : 80, critAt = crit !== null ? crit : 95;
            var name = String(chip.name || '');
            var main, extra = '';
            if (/^coretemp/.test(name)) {
                var pkg = ss.filter(function (s) { return /^Package id/i.test(s.label || ''); });
                var cores = ss.filter(function (s) { return /^Core\s*\d+/i.test(s.label || ''); });
                var cv = cores.map(function (s) { return s.value; });
                var mx = cv.length ? Math.max.apply(null, cv) : null;
                var mn = cv.length ? Math.min.apply(null, cv) : null;
                main = pkg.length ? pkg[0].value : (mx !== null ? mx : ss[0].value);
                if (cv.length) {
                    extra = ' (' + cv.length + ' 核: ' + fmtTemp(mn, warnAt, critAt) + ' ~ ' + fmtTemp(mx, warnAt, critAt) + ')';
                }
            } else if (/^(k10temp|k8temp|zenpower)/.test(name)) {
                var pick = function (re) { return ss.filter(function (s) { return re.test(s.label || ''); }); };
                var m = pick(/^Tdie$/i).concat(pick(/^Tctl$/i));
                main = m.length ? m[0].value : ss[0].value;
                var ccd = pick(/^Tccd\d+$/i);
                if (ccd.length) {
                    extra = ' (' + ccd.map(function (s) { return enc(s.label) + ' ' + fmtTemp(s.value, warnAt, critAt); }).join(', ') + ')';
                }
            } else {
                main = Math.max.apply(null, ss.map(function (s) { return s.value; }));
            }
            lines.push(enc(tag) + ': ' + fmtTemp(main, warnAt, critAt) + extra +
                (crit !== null ? grey(' · 临界 ' + crit + '°C') : ''));
        });
        return lines;
    }

    function otherTemps(chips, includeDisks) {
        var out = [];
        chips.forEach(function (chip) {
            if (!chip || !Array.isArray(chip.sensors) || chip.kind === 'cpu') { return; }
            if (chip.kind === 'disk' && !includeDisks) { return; }
            var cname = String(chip.name || '?').toUpperCase();
            chip.sensors.forEach(function (s) {
                if (!s || !num(s.value)) { return; }
                var generic = !s.label || /^temp\d+$/i.test(s.label);
                var label = generic ? cname + (chip.sensors.length > 1 ? ' ' + (s.label || '') : '') : cname + ' ' + s.label;
                out.push(enc(label) + ' ' + fmtTemp(s.value, num(s.crit) ? s.crit - 10 : 80, num(s.crit) ? s.crit : null));
            });
        });
        return out;
    }

    function renderFreq(f) {
        if (!f || !num(f.cur_avg)) { return grey('无法读取'); }
        var s;
        if (num(f.count) && f.count > 1 && num(f.cur_min) && num(f.cur_max)) {
            s = '平均 <b>' + ghz(f.cur_avg) + '</b> GHz (' + ghz(f.cur_min) + ' ~ ' + ghz(f.cur_max) + ', ' + f.count + ' 线程)';
        } else {
            s = '<b>' + ghz(f.cur_avg) + '</b> GHz';
        }
        if (Array.isArray(f.cores) && f.cores.length > 1) {
            var tip = f.cores.map(function (m, i) { return 'CPU' + i + ': ' + ghz(m) + ' GHz'; }).join('<br>');
            s = '<span style="border-bottom:1px dotted" data-qtip="' + enc(tip) + '">' + s + '</span>';
        }
        if (num(f.hw_min) && num(f.hw_max)) { s += ' | 范围 ' + ghz(f.hw_min) + ' ~ ' + ghz(f.hw_max) + ' GHz'; }
        if (f.governor) { s += ' | 调速器 ' + enc(f.governor) + (f.driver ? grey(' (' + enc(f.driver) + ')') : ''); }
        if (f.source === 'cpuinfo') { s += grey(' (来源 /proc/cpuinfo)'); }
        return s;
    }

    var KIND_LABEL = { nvme: 'NVMe', ssd: 'SSD', hdd: 'HDD' };
    var KIND_TEMP = { nvme: [70, 80], ssd: [60, 70], hdd: [50, 60] };

    function diskTitle(d) {
        return enc((KIND_LABEL[d.kind] || '硬盘') + ' ' + (d.name || d.dev || ''));
    }

    function renderDisk(d, nowTs) {
        var head = '<b>' + enc(d.model || d.dev || '未知型号') + '</b>';
        if (num(d.capacity) && d.capacity > 0) { head += ' · ' + fmtBytes(d.capacity); }
        var parts = [head];
        if (d.standby) {
            parts.push(grey('休眠中' + (num(d.ts) && num(nowTs) ? ', 以下为 ' + fmtAge(nowTs - d.ts) + '前的数据' : ', 暂无数据(不唤醒硬盘)')));
        }
        if (d.error) {
            parts.push(d.unsupported ? grey(enc(d.error)) : color(C_RED, enc(d.error)));
            return parts.join(' | ');
        }
        var th = KIND_TEMP[d.kind] || [60, 70];
        if (num(d.temp)) { parts.push(fmtTemp(d.temp, th[0], th[1])); }
        if (num(d.health)) {
            var hs = '健康 ' + d.health + '%';
            parts.push(d.health <= 10 ? color(C_RED, hs, true) : d.health <= 30 ? color(C_ORG, hs) : hs);
        }
        if (num(d.power_on_hours)) {
            var h = d.power_on_hours;
            parts.push('通电 ' + h + ' 小时' + (h >= 48 ? grey(' (' + Math.round(h / 24) + ' 天)') : '') +
                (num(d.power_cycles) ? ' / ' + d.power_cycles + ' 次' : ''));
        }
        if (num(d.read_bytes) || num(d.written_bytes)) {
            parts.push('读/写 ' + (fmtBytes(d.read_bytes) || '-') + ' / ' + (fmtBytes(d.written_bytes) || '-'));
        }
        var bad = [];
        if (num(d.critical_warning) && d.critical_warning > 0) { bad.push(color(C_RED, '严重警告 0x' + d.critical_warning.toString(16), true)); }
        if (num(d.media_errors) && d.media_errors > 0) { bad.push(color(C_RED, '介质错误 ' + d.media_errors, true)); }
        if (num(d.reallocated) && d.reallocated > 0) { bad.push(color(C_ORG, '重映射扇区 ' + d.reallocated)); }
        if (num(d.pending) && d.pending > 0) { bad.push(color(C_RED, '待映射扇区 ' + d.pending, true)); }
        if (num(d.uncorrectable) && d.uncorrectable > 0) { bad.push(color(C_RED, '不可修复 ' + d.uncorrectable, true)); }
        parts = parts.concat(bad);
        if (d.smart_passed === true) {
            parts.push('SMART ' + color(C_GRN, '正常'));
        } else if (d.smart_passed === false) {
            parts.push('SMART ' + color(C_RED, '失败!', true));
        } else if (!d.standby) {
            parts.push(grey('SMART 不可用'));
        }
        return parts.join(' | ');
    }

    function buildHtml(raw, age) {
        var info = parseInfo(raw);
        if (!info) {
            if (raw === '' || raw === undefined || raw === null) {
                return grey('未获取到硬件信息: 该节点未安装 pve-optimize, 或采集服务尚未运行');
            }
            return color(C_RED, '硬件信息格式无法解析');
        }
        var rows = [];
        var interval = num(info.interval) ? info.interval : 15;
        var a = Number(age);
        if (age !== '' && age !== null && age !== undefined && isFinite(a) && a > Math.max(90, interval * 4)) {
            rows.push(['状态', color(C_RED, '采集数据已过期 ' + fmtAge(a) + ', 请检查服务 pve-optimize-hwinfo', true)]);
        }
        if (Array.isArray(info.temps)) {
            var cl = cpuTempLines(info.temps);
            rows.push(['CPU 温度', cl.length ? cl.join('<br>') : grey('未检测到 CPU 温度传感器 (虚拟机或驱动未加载)')]);
            var ot = otherTemps(info.temps, !Array.isArray(info.disks));
            if (ot.length) { rows.push(['其它温度', ot.join(' | ')]); }
        }
        if (info.freq !== undefined && info.freq !== null) {
            rows.push(['CPU 频率', renderFreq(info.freq)]);
        }
        if (Array.isArray(info.disks)) {
            if (!info.disks.length) {
                rows.push(['硬盘', grey('未发现可读取 SMART 的硬盘')]);
            }
            info.disks.forEach(function (d) {
                if (d && typeof d === 'object') { rows.push([diskTitle(d), renderDisk(d, info.ts)]); }
            });
        }
        if (!rows.length) { return grey('所有显示项均已在 /etc/pve-optimize.conf 中关闭'); }
        return '<table style="width:100%;border-collapse:collapse">' + rows.map(function (r) {
            return '<tr><td style="white-space:nowrap;vertical-align:top;padding:2px 12px 2px 0;font-weight:600">' + r[0] +
                '</td><td style="vertical-align:top;padding:2px 0;word-break:break-word;line-height:1.5">' + r[1] + '</td></tr>';
        }).join('') + '</table>';
    }

    function updateHw(sv) {
        var cmp = sv.down('#pveOptimizeHwInfo');
        if (!cmp) { return; }
        var html;
        try {
            html = buildHtml(sv.getRecordValue('hwinfo'), sv.getRecordValue('hwinfoage'));
        } catch (e) {
            html = color(C_RED, '硬件信息渲染出错: ' + enc(e && e.message ? e.message : e));
        }
        if (cmp.pveOptimizeHtml === html) { return; }
        cmp.pveOptimizeHtml = html;
        cmp.update(html);
        sv.updateLayout();
    }

    // 让与状态面板同一行的图表与其等高,避免 column 布局浮动错位
    function syncRow(sv) {
        if (!sv || sv.destroyed || sv.isDestroyed) { return; }
        var ct = sv.ownerCt;
        if (!ct || !ct.items || !ct.items.getRange) { return; }
        var items = ct.items.getRange();
        if (items[0] !== sv) { return; }
        var cw = sv.columnWidth;
        var factor = num(cw) && cw > 0 && cw < 1 ? Math.round(1 / cw) : 1;
        var h = sv.getHeight();
        if (!num(h) || h <= 0) { return; }
        // 同一行里若有图表的 minHeight 更高,先把状态面板撑到同样高度(之后会再次触发 resize)
        var target = h;
        for (var j = 1; j < Math.min(factor, items.length); j++) {
            if (items[j] && num(items[j].minHeight) && items[j].minHeight > target) { target = items[j].minHeight; }
        }
        if (target > h) {
            if (sv.minHeight !== target) { sv.minHeight = target; sv.updateLayout(); }
            return;
        }
        for (var i = 1; i < items.length; i++) {
            var it = items[i];
            if (!it || it.destroyed || it.isDestroyed) { continue; }
            if (i < factor) {
                if (it.pveOptimizeH !== h) { it.pveOptimizeH = h; it.setHeight(h); }
            } else if (it.pveOptimizeH !== undefined) {
                it.pveOptimizeH = undefined;
                it.setHeight(null);
            }
        }
    }

    Ext.define('PVE.optimize.NodeStatusOverride', {
        override: 'PVE.node.StatusView',

        initComponent: function () {
            var me = this;
            var ok = false;
            try {
                var h = me.height;
                me.items = (me.items || []).concat([
                    { xtype: 'box', colspan: 2, padding: '0 0 10 0' },
                    { xtype: 'component', itemId: 'pveOptimizeHwInfo', colspan: 2, padding: '0 10 5 10', html: '' },
                ]);
                if (num(h)) { me.minHeight = Math.max(num(me.minHeight) ? me.minHeight : 0, h); }
                me.height = undefined; // 高度随内容自适应
                ok = true;
            } catch (e) {
                if (window.console) { console.warn('pve-optimize init', e); }
            }
            me.callParent(arguments);
            if (ok) {
                me.on('resize', function () { Ext.defer(syncRow, 10, null, [me]); });
            }
        },

        updateValues: function (store, records, success) {
            var me = this;
            me.callParent(arguments);
            if (success === false) { return; }
            try {
                updateHw(me);
            } catch (e) {
                if (window.console) { console.warn('pve-optimize update', e); }
            }
        },
    });

    Ext.ns('PVE.optimize');
    PVE.optimize.version = VERSION;
    PVE.optimize.buildHtml = buildHtml;
}());
/* PVE-OPTIMIZE END */
JS_EOF
JS_BLOCK=${JS_BLOCK//@VERSION@/$VERSION}

# 精确、可逆的补丁器: MODE(strip|apply) KIND(nodes|manager|toolkit) FILE
read -r -d '' PATCHER <<'PATCHER_EOF' || true
use strict;
use warnings;
my ($mode, $kind, $file) = @ARGV;
open(my $fh, '<:raw', $file) or die "cannot read $file: $!\n";
my $c = do { local $/; <$fh> };
close($fh);

# 1) 去掉本工具的补丁(精确逆向)
if ($kind eq 'nodes') {
    $c =~ s/^[ \t]*# PVE-OPTIMIZE BEGIN[^\n]*\n.*?^[ \t]*# PVE-OPTIMIZE END[^\n]*\n//gms;
} elsif ($kind eq 'manager') {
    $c =~ s{\n/\* PVE-OPTIMIZE BEGIN .*?/\* PVE-OPTIMIZE END \*/\n}{}gs;
} elsif ($kind eq 'toolkit') {
    $c =~ s{ === 'NoMoreNagging' /\*PVE-OPTIMIZE-NONAG<<(.*?)>>\*/}{$1}gs;
} else {
    die "unknown kind $kind\n";
}

# 2) 重新打补丁
if ($mode eq 'apply') {
    if ($kind eq 'nodes') {
        my $block = $ENV{PVEOPT_NODES_BLOCK} // die "no block\n";
        my $n = () = $c =~ /^[ \t]*\$res->\{pveversion\}\s*=/mg;
        die "ANCHOR: Nodes.pm 中 \$res->{pveversion} 锚点数量为 $n (期望 1)\n" if $n != 1;
        my $ok = $c =~ s{^([ \t]*)(\$res->\{pveversion\}\s*=[^;]*;[^\n]*\n)}{
            my ($ind, $line) = ($1, $2);
            $ind . $line . join('', map { "$ind$_\n" } split(/\n/, $block));
        }me;
        die "ANCHOR: Nodes.pm 锚点行无法解析\n" if !$ok;
    } elsif ($kind eq 'manager') {
        die "ANCHOR: pvemanagerlib.js 中找不到 PVE.node.StatusView\n"
            if $c !~ /Ext\.define\(\s*['"]PVE\.node\.StatusView['"]/;
        my $block = $ENV{PVEOPT_JS_BLOCK} // die "no block\n";
        $c .= "\n" . $block . "\n";
    } elsif ($kind eq 'toolkit') {
        if ($ENV{PVEOPT_NONAG}) {
            my $n = ($c =~ s{(data\.status(?:\.toLowerCase\(\))?)(\s*!==\s*'(?:active|Active)')}{$1 === 'NoMoreNagging' /*PVE-OPTIMIZE-NONAG<<$2>>*/}g);
            die "ANCHOR: proxmoxlib.js 中找不到订阅检查代码\n" if !$n;
        }
    }
} elsif ($mode ne 'strip') {
    die "unknown mode $mode\n";
}
binmode(STDOUT, ':raw');
print $c;
PATCHER_EOF

file_kind() {
    case "$1" in
        "$NODES_PM") echo nodes ;;
        "$MANAGER_JS") echo manager ;;
        "$TOOLKIT_JS") echo toolkit ;;
    esac
}

run_patcher() { # run_patcher MODE FILE  -> stdout
    local nonag; nonag=$(conf_get NO_NAG 1); [[ $nonag == 1 ]] || nonag=''
    PVEOPT_NODES_BLOCK="$NODES_BLOCK" PVEOPT_JS_BLOCK="$JS_BLOCK" PVEOPT_NONAG="$nonag" \
        perl -e "$PATCHER" "$1" "$(file_kind "$2")" "$2"
}

# 判断文件状态: pristine | ours | foreign | unknown
classify() {
    local f=$1 exp cur stripped
    exp=$(expected_md5 "$f")
    [[ -n $exp ]] || { echo unknown; return; }
    cur=$(md5_of "$f")
    [[ $cur == "$exp" ]] && { echo pristine; return; }
    stripped=$(mktemp /tmp/pve-optimize.XXXXXX)
    if run_patcher strip "$f" >"$stripped" 2>/dev/null && [[ $(md5_of "$stripped") == "$exp" ]]; then
        echo ours
    else
        echo foreign
    fi
    rm -f "$stripped"
}

backup_pristine() {
    local f=$1 pkg ver dir
    pkg=$(file_pkg "$f"); ver=$(pkg_ver "$pkg")
    [[ -n $pkg && -n $ver ]] || return 0
    dir="$BACKUP_DIR/${pkg}_${ver}"
    mkdir -p "$dir"
    [[ -e "$dir/$(basename "$f")" ]] || cp -p "$f" "$dir/$(basename "$f")"
}

install_file() { # install_file SRC DEST  (原子替换, 0644 root)
    local tmp="$2.pve-optimize-new"
    install -m 0644 -o root -g root "$1" "$tmp"
    mv -f "$tmp" "$2"
}

nodes_load_ok() { perl -I/usr/share/perl5 -e 'require PVE::API2::Nodes;' >/dev/null 2>&1; }

# 对单个文件打补丁。返回: 0=已修改 1=失败 2=无需修改
patch_one() {
    local f=$1 state desired old
    state=$(classify "$f")
    case $state in
        pristine | ours) ;;
        unknown) warn "无法获取 $f 的 dpkg 校验值,按原样继续" ;;
        foreign)
            err "$f 已被其它脚本修改过(例如旧版 showtempcpufreq.sh 或博客中的 sed 命令)。"
            err "    请执行: $0 apply --repair  (将重装官方软件包恢复原始文件后再打补丁)"
            return 1 ;;
    esac
    new_tmp desired
    if ! run_patcher apply "$f" >"$desired" 2>"$desired.err"; then
        err "$(basename "$f"): $(cat "$desired.err")"; rm -f "$desired.err"
        return 1
    fi
    rm -f "$desired.err"
    if cmp -s "$desired" "$f"; then
        return 2
    fi
    [[ $state == pristine ]] && backup_pristine "$f"
    new_tmp old; cp -p "$f" "$old"
    if [[ $f == "$NODES_PM" ]]; then
        local was_ok=1
        nodes_load_ok || was_ok=0
        install_file "$desired" "$f"
        if [[ $was_ok == 1 ]] && ! nodes_load_ok; then
            install_file "$old" "$f"
            err "Nodes.pm 修改后无法加载,已自动回滚"
            return 1
        fi
    else
        install_file "$desired" "$f"
    fi
    return 0
}

reload_pveproxy() {
    if systemctl reload-or-restart pveproxy.service >/dev/null 2>&1; then
        date +%s >"$STATE_DIR/last_reload"
        log "已重新加载 pveproxy"
    else
        warn "pveproxy 重新加载失败,请手动执行: systemctl restart pveproxy"
    fi
}

# ----------------------------------------------------------------------------- 采集器
write_collector() {
    mkdir -p "$LIB_DIR"
    cat >"$COLLECTOR.new" <<'COLLECTOR_EOF'
#!/usr/bin/perl
# pve-optimize hardware info collector (runs as root via systemd)
use strict;
use warnings;
use utf8;
binmode(STDOUT, ':encoding(UTF-8)');
binmode(STDERR, ':encoding(UTF-8)');
use JSON::PP;
use POSIX ();
use File::Basename qw(basename);

# 环境变量仅用于测试
my $SYS      = $ENV{PVEOPT_SYSROOT} // '';
my $OUT_DIR  = $ENV{PVEOPT_OUT_DIR} // '/run/pve-optimize';
my $OUT      = "$OUT_DIR/hwinfo.json";
my $CONF     = $ENV{PVEOPT_CONF} // '/etc/pve-optimize.conf';
my $SMARTCTL = $ENV{PVEOPT_SMARTCTL} // 'smartctl';

my %cfg = (
    SHOW_TEMP => 1, SHOW_FREQ => 1, SHOW_DISKS => 1,
    COLLECT_INTERVAL => 15, DISK_INTERVAL => 60, SMART_TIMEOUT => 20, DISK_EXCLUDE => '',
);

sub read_config {
    open(my $fh, '<', $CONF) or return;
    while (my $l = <$fh>) {
        next if $l =~ /^\s*(#|$)/;
        if ($l =~ /^\s*([A-Z_]+)\s*=\s*"?([^"#\n]*?)"?\s*(?:#.*)?$/) { $cfg{$1} = $2; }
    }
    close($fh);
    for my $k (qw(COLLECT_INTERVAL DISK_INTERVAL SMART_TIMEOUT)) { $cfg{$k} = 0 if $cfg{$k} !~ /^\d+$/; }
    $cfg{COLLECT_INTERVAL} = 15 if $cfg{COLLECT_INTERVAL} < 5;
    $cfg{DISK_INTERVAL}    = 60 if $cfg{DISK_INTERVAL} < 30;
    $cfg{SMART_TIMEOUT}    = 20 if $cfg{SMART_TIMEOUT} < 5;
}

sub slurp {
    my ($f) = @_;
    open(my $fh, '<', $f) or return undef;
    my $c = do { local $/; <$fh> };
    close($fh);
    return undef if !defined $c;
    $c =~ s/\s+\z//;
    return $c;
}

sub r1 { my $v = shift; return int($v * 10 + ($v < 0 ? -0.5 : 0.5)) / 10; }

sub run_cmd {
    my @cmd = @_;
    my $pid = open(my $fh, '-|');
    return (undef, -1) if !defined $pid;
    if (!$pid) {
        open(STDERR, '>', '/dev/null');
        exec(@cmd) or POSIX::_exit(127);
    }
    my $out = do { local $/; <$fh> };
    close($fh);
    return ($out, $? >> 8);
}

# ---------------------------------------------------------------- 温度 (直接读 hwmon)
sub chip_kind {
    my $n = shift;
    return 'cpu'  if $n =~ /^(coretemp|k10temp|k8temp|zenpower|cpu_thermal|cpu-thermal|soc_thermal|x86_pkg_temp)/;
    return 'disk' if $n =~ /^(nvme|drivetemp)$/;
    return 'acpi' if $n eq 'acpitz';
    return 'other';
}

sub collect_temps {
    my @chips;
    my @hw = sort { (($a =~ /(\d+)$/)[0] // 0) <=> (($b =~ /(\d+)$/)[0] // 0) } glob("$SYS/sys/class/hwmon/hwmon*");
    for my $hw (@hw) {
        my $name = slurp("$hw/name") // basename($hw);
        my $base = $hw;
        my @inputs = glob("$hw/temp*_input");
        if (!@inputs && -d "$hw/device") { $base = "$hw/device"; @inputs = glob("$base/temp*_input"); }
        my @sensors;
        for my $in (@inputs) {
            my ($idx) = $in =~ /temp(\d+)_input$/ or next;
            my $raw = slurp($in);
            next if !defined $raw || $raw !~ /^-?\d+$/;
            my $t = $raw / 1000;
            next if $t <= -40 || $t >= 150;    # 无效读数
            my %s = (idx => $idx + 0, label => (slurp("$base/temp${idx}_label") // "temp$idx"), value => r1($t));
            for my $k (qw(crit max)) {
                my $v = slurp("$base/temp${idx}_$k");
                $s{$k} = r1($v / 1000) if defined $v && $v =~ /^\d+$/ && $v > 20000 && $v < 150000;
            }
            push @sensors, \%s;
        }
        next if !@sensors;
        @sensors = sort { $a->{idx} <=> $b->{idx} } @sensors;
        my $dev = readlink("$hw/device");
        push @chips, { name => $name, device => (defined $dev ? basename($dev) : ''), kind => chip_kind($name), sensors => \@sensors };
    }
    if (!@chips) {    # 退路: thermal zone
        for my $z (glob("$SYS/sys/class/thermal/thermal_zone*")) {
            my $raw = slurp("$z/temp");
            next if !defined $raw || $raw !~ /^-?\d+$/ || $raw <= 0;
            my $type = slurp("$z/type") // basename($z);
            push @chips, { name => $type, device => basename($z), kind => chip_kind($type),
                sensors => [{ idx => 1, label => $type, value => r1($raw / 1000) }] };
        }
    }
    return \@chips;
}

# ---------------------------------------------------------------- 频率
sub collect_freq {
    my @cur;
    my $src = 'cpufreq';
    for my $d (glob("$SYS/sys/devices/system/cpu/cpu[0-9]*")) {
        my ($n) = $d =~ /cpu(\d+)$/ or next;
        my $f = slurp("$d/cpufreq/scaling_cur_freq");
        push @cur, [$n + 0, $f / 1000] if defined $f && $f =~ /^\d+$/ && $f > 0;
    }
    if (!@cur && open(my $fh, '<', "$SYS/proc/cpuinfo")) {
        $src = 'cpuinfo';
        my ($proc, $i) = (undef, 0);
        while (my $l = <$fh>) {
            $proc = $1 if $l =~ /^processor\s*:\s*(\d+)/;
            if ($l =~ /^cpu MHz\s*:\s*([\d.]+)/i) { push @cur, [($proc // $i), $1 + 0]; $i++; }
        }
        close($fh);
    }
    return undef if !@cur;
    @cur = sort { $a->[0] <=> $b->[0] } @cur;
    my @mhz = map { int($_->[1] + 0.5) } @cur;
    my ($min, $max, $sum) = ($mhz[0], $mhz[0], 0);
    for (@mhz) { $min = $_ if $_ < $min; $max = $_ if $_ > $max; $sum += $_; }
    my %r = (source => $src, count => scalar(@mhz), cur_min => $min, cur_max => $max,
        cur_avg => int($sum / @mhz + 0.5), cores => \@mhz);
    my $c0 = "$SYS/sys/devices/system/cpu/cpu0/cpufreq";
    my $hmin = slurp("$c0/cpuinfo_min_freq");
    my $hmax = slurp("$c0/cpuinfo_max_freq");
    $r{hw_min} = int($hmin / 1000) if defined $hmin && $hmin =~ /^\d+$/ && $hmin > 0;
    $r{hw_max} = int($hmax / 1000) if defined $hmax && $hmax =~ /^\d+$/ && $hmax > 0;
    my $g = slurp("$c0/scaling_governor"); $r{governor} = $g if defined $g && length $g;
    my $dr = slurp("$c0/scaling_driver"); $r{driver} = $dr if defined $dr && length $dr;
    return \%r;
}

# ---------------------------------------------------------------- 硬盘
sub scan_disks {
    my ($out) = run_cmd($SMARTCTL, '--scan');
    my (@list, %seen);
    for my $l (split /\n/, ($out // '')) {
        next if $l !~ m{^(/dev/\S+)\s+-d\s+(\S+)};
        my ($dev, $type) = ($1, $2);
        next if $cfg{DISK_EXCLUDE} ne '' && eval { $dev =~ /$cfg{DISK_EXCLUDE}/ };
        next if $seen{"$dev|$type"}++;
        push @list, [$dev, $type];
    }
    return \@list;
}

sub need_type_arg { my $t = shift; return $t =~ /,/ || $t =~ /^(megaraid|cciss|aacraid|areca|3ware|hpt|sssraid|jmb39x|jms56x)/; }

sub disk_name {
    my ($dev, $type) = @_;
    my $n = basename($dev);
    return $n if !need_type_arg($type);
    $n = "bus$n" if $dev =~ m{^/dev/bus/};
    return "$n:$type";
}

sub attr_bytes {
    my ($at, $lbs) = @_;
    my $nm = $at->{name} // '';
    my $raw = $at->{raw}{value};
    return undef if !defined $raw || $raw !~ /^\d+$/ || $raw == 0;
    return $raw * ($lbs || 512)   if $nm =~ /LBAs?_(Written|Read)/i;
    return $raw * 32 * 1024**2    if $nm =~ /32MiB/i;
    return $raw * 1024**3         if $nm =~ /GiB|_GB$|Host_(Writes|Reads)_GB/i;
    return undef;
}

sub summarize_disk {
    my ($dev, $type, $j, $rc) = @_;
    my %d = (dev => $dev, name => disk_name($dev, $type), ts => time());

    my @msgs = map { $_->{string} // '' } @{ $j->{smartctl}{messages} // [] };
    my $msg = join('; ', @msgs);

    my $proto = $j->{device}{protocol} // '';
    my $model = $j->{model_name} // $j->{scsi_model_name};
    $model //= join(' ', grep { defined && length } ($j->{scsi_vendor}, $j->{scsi_product})) || undef;
    $d{model}  = $model if defined $model;
    $d{serial} = $j->{serial_number} if defined $j->{serial_number};
    my $cap = $j->{user_capacity}{bytes} // $j->{nvme_total_capacity};
    $d{capacity} = $cap + 0 if defined $cap && $cap =~ /^\d+$/ && $cap > 0;

    if ($proto eq 'NVMe' || $type eq 'nvme') {
        $d{kind} = 'nvme';
    } elsif (defined $j->{rotation_rate} && $j->{rotation_rate} =~ /^\d+$/) {
        $d{kind} = $j->{rotation_rate} == 0 ? 'ssd' : 'hdd';
    } else {
        my $rot = slurp("$SYS/sys/block/" . basename($dev) . '/queue/rotational');
        $d{kind} = defined $rot ? ($rot ? 'hdd' : 'ssd') : 'disk';
    }

    if (!defined $model) {
        if ($msg =~ /Unknown USB bridge|not supported|unsupported|Unavailable/i) {
            $d{unsupported} = JSON::PP::true;
            $d{error} = "不支持 SMART: $msg";
        } elsif ($rc & 2) {
            $d{error} = $msg ne '' ? "无法读取: $msg" : '无法打开设备 (可能已直通给虚拟机或已移除)';
        } else {
            $d{error} = $msg ne '' ? "无法识别: $msg" : '无法识别设备';
        }
        return \%d;
    }

    my $t = $j->{temperature}{current};
    $d{temp} = $t + 0 if defined $t && $t =~ /^-?\d+$/ && $t > 0 && $t < 150;
    my $poh = $j->{power_on_time}{hours};
    $d{power_on_hours} = $poh + 0 if defined $poh && $poh =~ /^\d+$/;
    my $pc = $j->{power_cycle_count};
    $d{power_cycles} = $pc + 0 if defined $pc && $pc =~ /^\d+$/;
    if (ref($j->{smart_status}) eq 'HASH' && exists $j->{smart_status}{passed}) {
        $d{smart_passed} = $j->{smart_status}{passed} ? JSON::PP::true : JSON::PP::false;
    }

    if (my $n = $j->{nvme_smart_health_information_log}) {
        $d{health} = ($n->{percentage_used} >= 100 ? 0 : 100 - $n->{percentage_used}) if defined $n->{percentage_used};
        $d{read_bytes}    = $n->{data_units_read} * 512000    if defined $n->{data_units_read};
        $d{written_bytes} = $n->{data_units_written} * 512000 if defined $n->{data_units_written};
        $d{media_errors}  = $n->{media_errors} + 0            if defined $n->{media_errors};
        $d{critical_warning} = $n->{critical_warning} + 0     if defined $n->{critical_warning};
        $d{temp} //= $n->{temperature} if defined $n->{temperature} && $n->{temperature} > 0;
    }

    my $lbs = $j->{logical_block_size} || 512;
    my %life;
    for my $at (@{ $j->{ata_smart_attributes}{table} // [] }) {
        my $id = $at->{id} // next;
        my $raw = $at->{raw}{value};
        if    ($id == 5   && defined $raw) { $d{reallocated}   = $raw + 0; }
        elsif ($id == 197 && defined $raw) { $d{pending}       = $raw + 0; }
        elsif ($id == 198 && defined $raw) { $d{uncorrectable} = $raw + 0; }
        elsif ($id == 241) { my $by = attr_bytes($at, $lbs); $d{written_bytes} = $by if defined $by; }
        elsif ($id == 242) { my $by = attr_bytes($at, $lbs); $d{read_bytes}    = $by if defined $by; }
        if ($d{kind} ne 'hdd' && grep { $id == $_ } (231, 233, 177, 202, 169)) {
            my $v = $at->{value};
            $life{$id} = $v + 0 if defined $v && $v =~ /^\d+$/ && $v <= 100;
        }
    }
    for my $id (231, 233, 177, 202, 169) { if (defined $life{$id}) { $d{health} //= $life{$id}; last; } }
    if (defined $j->{scsi_grown_defect_list}) { $d{reallocated} = $j->{scsi_grown_defect_list} + 0; }
    return \%d;
}

sub collect_disks {
    my ($prev) = @_;
    my %prev = map { ($_->{dev} // '') . '|' . ($_->{name} // '') => $_ } @{ $prev // [] };
    my @disks;
    for my $e (@{ scan_disks() }) {
        my ($dev, $type) = @$e;
        my @cmd = ('timeout', '-k', '5', $cfg{SMART_TIMEOUT}, $SMARTCTL, '-j', '-a', '-n', 'standby');
        push @cmd, '-d', $type if need_type_arg($type);
        push @cmd, $dev;
        my ($out, $rc) = run_cmd(@cmd);
        my $j = eval { JSON::PP->new->utf8->decode($out // '') };
        my $name = disk_name($dev, $type);
        if (!$j) {
            push @disks, { dev => $dev, name => $name, ts => time(),
                error => ($rc == 124 ? 'smartctl 超时' : 'smartctl 输出无法解析') };
            next;
        }
        my $msg = join(' ', map { $_->{string} // '' } @{ $j->{smartctl}{messages} // [] });
        if (($rc & 2) && $msg =~ /STANDBY|SLEEP/i) {
            my $p = $prev{"$dev|$name"};
            my %d = $p ? %$p : (dev => $dev, name => $name);
            delete $d{error};
            $d{standby} = JSON::PP::true;
            if (!$p) {
                my $rot = slurp("$SYS/sys/block/" . basename($dev) . '/queue/rotational');
                $d{kind} = defined $rot ? ($rot ? 'hdd' : 'ssd') : 'disk';
            }
            push @disks, \%d;
            next;
        }
        push @disks, summarize_disk($dev, $type, $j, $rc);
    }
    my %ord = (nvme => 0, ssd => 1, hdd => 2, disk => 3);
    @disks = sort { ($ord{ $a->{kind} // 'disk' } // 3) <=> ($ord{ $b->{kind} // 'disk' } // 3) || $a->{dev} cmp $b->{dev} } @disks;
    return \@disks;
}

# ---------------------------------------------------------------- 输出
sub write_json {
    my ($data) = @_;
    mkdir($OUT_DIR, 0755) if !-d $OUT_DIR;
    chmod(0755, $OUT_DIR);
    my $tmp = "$OUT.tmp.$$";
    open(my $fh, '>', $tmp) or die "cannot write $tmp: $!\n";
    print $fh JSON::PP->new->ascii->canonical->encode($data);
    close($fh) or die "close $tmp: $!\n";
    chmod(0644, $tmp);
    rename($tmp, $OUT) or die "rename: $!\n";
}

sub load_prev {
    my $c = slurp($OUT) // return undef;
    return eval { JSON::PP->new->decode($c) };
}

my %state = (disks => undef, disks_ts => 0);

sub collect_once {
    read_config();
    my $now = time();
    my %data = (v => 1, ts => $now, interval => $cfg{COLLECT_INTERVAL} + 0, disk_interval => $cfg{DISK_INTERVAL} + 0);
    $data{temps} = eval { collect_temps() } // [] if $cfg{SHOW_TEMP};
    $data{freq}  = eval { collect_freq() }        if $cfg{SHOW_FREQ};
    if ($cfg{SHOW_DISKS}) {
        if (!defined $state{disks} || $now - $state{disks_ts} >= $cfg{DISK_INTERVAL}) {
            my $prev = $state{disks};
            if (!defined $prev) { my $p = load_prev(); $prev = $p->{disks} if ref($p) eq 'HASH'; }
            $state{disks} = eval { collect_disks($prev) } // [];
            $state{disks_ts} = $now;
        }
        $data{disks} = $state{disks};
        $data{disks_ts} = $state{disks_ts};
    }
    write_json(\%data);
    return \%data;
}

sub summary {
    my $p = load_prev();
    if (ref($p) ne 'HASH') { print "NO_DATA\n"; return 1; }
    my $age = time() - ((stat($OUT))[9] // 0);
    my @cpu = grep { ($_->{kind} // '') eq 'cpu' } @{ $p->{temps} // [] };
    my @oth = grep { ($_->{kind} // '') ne 'cpu' } @{ $p->{temps} // [] };
    my $ncpu = 0; $ncpu += scalar(@{ $_->{sensors} // [] }) for @cpu;
    my $noth = 0; $noth += scalar(@{ $_->{sensors} // [] }) for @oth;
    my @d = @{ $p->{disks} // [] };
    print "age=$age\n";
    print "interval=", ($p->{interval} // 15), "\n";
    print "temps=", (defined $p->{temps} ? 'on' : 'off'), "\n";
    print "cpu_temp_sensors=$ncpu\n";
    print "other_temp_sensors=$noth\n";
    print "freq=", (defined $p->{freq} ? ($p->{freq}{cur_avg} // '?') . "MHz/" . ($p->{freq}{source} // '?') : 'none'), "\n";
    print "disks=", (defined $p->{disks} ? scalar(@d) : 'off'), "\n";
    print "disks_standby=", scalar(grep { $_->{standby} } @d), "\n";
    print "disks_error=", scalar(grep { $_->{error} } @d), "\n";
    for my $x (@d) {
        printf "disk: %-14s %-5s %s%s%s\n", $x->{name} // '?', $x->{kind} // '?', $x->{model} // '-',
            ($x->{standby} ? ' [standby]' : ''), ($x->{error} ? " [error: $x->{error}]" : '');
    }
    return 0;
}

my $arg = $ARGV[0] // '--once';
if ($arg eq '--daemon') {
    $SIG{TERM} = $SIG{INT} = sub { unlink("$OUT.tmp.$$"); exit 0; };
    $0 = 'pve-optimize-hwinfo';
    while (1) {
        eval { collect_once(); 1 } or warn "collect failed: $@";
        sleep($cfg{COLLECT_INTERVAL} || 15);
    }
} elsif ($arg eq '--summary') {
    exit(summary());
} elsif ($arg eq '--stdout') {
    print JSON::PP->new->pretty->canonical->encode(collect_once());
} else {
    collect_once();
    exit(summary());
}
COLLECTOR_EOF
    perl -c "$COLLECTOR.new" >/dev/null 2>&1 || { rm -f "$COLLECTOR.new"; die "采集器语法检查失败"; }
    chmod 0755 "$COLLECTOR.new"
    mv -f "$COLLECTOR.new" "$COLLECTOR"
}

write_service() {
    cat >"$SERVICE_FILE" <<EOF
[Unit]
Description=pve-optimize hardware info collector (CPU temperature/frequency, disk SMART)
After=local-fs.target systemd-modules-load.service

[Service]
Type=simple
ExecStart=/usr/bin/perl $COLLECTOR --daemon
Restart=always
RestartSec=10
Nice=10

[Install]
WantedBy=multi-user.target
EOF
    systemctl daemon-reload
    systemctl enable "$SERVICE" >/dev/null 2>&1
    systemctl restart "$SERVICE"
}

write_apt_hook() {
    cat >"$APT_HOOK" <<EOF
// pve-optimize: 软件包升级后自动重新打补丁 (删除本文件即可停用)
DPkg::Post-Invoke { "if [ -x $INSTALL_BIN ]; then $INSTALL_BIN apply --hook >/dev/null 2>&1 || true; fi"; };
EOF
}

setup_sensors() {
    local mods=() vendor out m
    vendor=$(awk -F: '/^vendor_id/ {gsub(/[[:space:]]/, "", $2); print $2; exit}' /proc/cpuinfo 2>/dev/null || true)
    case "$vendor" in
        GenuineIntel) mods+=(coretemp) ;;
        AuthenticAMD | HygonGenuine) mods+=(k10temp) ;;
    esac
    if [[ $OPT_NO_SENSORS_DETECT != 1 ]]; then
        if ! command -v sensors-detect >/dev/null 2>&1; then
            log "安装 lm-sensors (用于探测主板传感器驱动)"
            DEBIAN_FRONTEND=noninteractive apt-get install -y lm-sensors >/dev/null 2>&1 \
                || warn "lm-sensors 安装失败,跳过主板传感器探测 (CPU 温度不受影响)"
        fi
        if command -v sensors-detect >/dev/null 2>&1; then
            log "运行 sensors-detect --auto 探测传感器驱动 (可能需要几十秒)"
            out=$(timeout 180 sensors-detect --auto </dev/null 2>/dev/null || true)
            while IFS= read -r m; do
                [[ $m =~ ^[a-z0-9_]+$ ]] && mods+=("$m")
            done < <(awk '/^#----cut here----/ {f = !f; next} f && !/^#/ {print $1}' <<<"$out")
        fi
    fi
    if ((${#mods[@]})); then
        printf '%s\n' "${mods[@]}" | awk '!seen[$0]++' >"$MODLOAD.new"
        mv -f "$MODLOAD.new" "$MODLOAD"
        while IFS= read -r m; do modprobe "$m" >/dev/null 2>&1 || true; done <"$MODLOAD"
        log "传感器驱动: $(tr '\n' ' ' <"$MODLOAD")(已写入 $MODLOAD)"
    fi
}

remove_suid() {
    local s=/usr/sbin/smartctl
    if [[ -e $s ]] && [[ -u $s || -g $s ]]; then
        chmod u-s,g-s "$s"
        log "已移除旧脚本给 smartctl 加的 suid 权限"
    fi
}

repair_packages() {
    log "重装 pve-manager 与 proxmox-widget-toolkit 以恢复原始文件 (pveproxy 等服务会被重启)"
    rm -f "$APT_HOOK.disabled"
    [[ -e $APT_HOOK ]] && mv -f "$APT_HOOK" "$APT_HOOK.disabled"
    local rc=0
    DEBIAN_FRONTEND=noninteractive apt-get install --reinstall -y pve-manager proxmox-widget-toolkit || rc=$?
    [[ -e "$APT_HOOK.disabled" ]] && mv -f "$APT_HOOK.disabled" "$APT_HOOK"
    return $rc
}

lock() {
    mkdir -p "$STATE_DIR"
    exec 9>"$STATE_DIR/lock"
    if ! flock -n 9; then
        [[ $MODE_HOOK == 1 ]] && exit 0
        die "另一个 pve-optimize 实例正在运行"
    fi
}

# ----------------------------------------------------------------------------- 子命令
cmd_apply() {
    need_root
    lock
    if [[ $MODE_HOOK == 1 ]]; then
        [[ -e $CONF ]] || exit 0
        command -v pveversion >/dev/null 2>&1 || exit 0
    else
        check_pve
        log "pve-optimize v$VERSION,PVE $(pve_version)"
    fi

    local f bad=()
    for f in "$NODES_PM" "$MANAGER_JS" "$TOOLKIT_JS"; do
        [[ $(classify "$f") == foreign ]] && bad+=("$f")
    done
    if ((${#bad[@]})); then
        if [[ $OPT_REPAIR == 1 ]]; then
            repair_packages || die "重装软件包失败,请检查 APT 源后重试"
            for f in "${bad[@]}"; do
                [[ $(classify "$f") == foreign ]] && die "重装后 $f 仍与官方版本不一致"
            done
        elif [[ $MODE_HOOK != 1 ]]; then
            err "以下文件已被其它脚本修改过 (可能是旧版 showtempcpufreq.sh 或博客中的 sed 命令):"
            printf '      %s\n' "${bad[@]}" >&2
            die "请执行: $0 apply --repair  (重装官方软件包恢复原始文件,然后再打补丁)"
        fi
    fi

    if [[ $MODE_HOOK != 1 ]]; then
        log "安装文件"
        mkdir -p "$LIB_DIR" "$BACKUP_DIR"
        local self; self=$(readlink -f "${BASH_SOURCE[0]}")
        if [[ $self != "$INSTALL_BIN" ]]; then install -m 0755 "$self" "$INSTALL_BIN"; fi
        write_default_conf
        write_collector
        remove_suid
        setup_sensors
        log "启动采集服务 $SERVICE"
        write_service
        write_apt_hook
        # 等待第一次采集完成(包含硬盘)
        local i
        for i in $(seq 1 30); do [[ -s $RUN_JSON ]] && break; sleep 1; done
    fi

    local changed=0 failed=0 rc
    for f in "$NODES_PM" "$MANAGER_JS" "$TOOLKIT_JS"; do
        if [[ $MODE_HOOK == 1 && $(classify "$f") == foreign ]]; then
            log "跳过被第三方修改的文件: $f"; continue
        fi
        rc=0; patch_one "$f" || rc=$?
        case $rc in
            0) changed=1; log "已修改: $f" ;;
            2) [[ $MODE_HOOK == 1 ]] || log "无需修改: $f" ;;
            *) failed=1 ;;
        esac
    done
    echo "pve-manager=$(pkg_ver pve-manager) proxmox-widget-toolkit=$(pkg_ver proxmox-widget-toolkit)" \
        >"$STATE_DIR/patched_versions" 2>/dev/null || true

    if [[ $changed == 1 ]]; then
        reload_pveproxy
    elif [[ ! -e $STATE_DIR/last_reload ]] && [[ $MODE_HOOK != 1 ]]; then
        reload_pveproxy
    fi

    if [[ $MODE_HOOK != 1 ]]; then
        echo
        if [[ $failed == 1 ]]; then
            warn "部分修改失败,详见上方错误信息。下面是自检结果:"
        else
            echo -e "${C_GRN}完成。${C_OFF}请在浏览器中按 ${C_RED}Ctrl+F5${C_OFF} (macOS: Cmd+Shift+R) 强制刷新 PVE 页面。"
        fi
        echo
        cmd_check || true
    fi
    [[ $failed == 0 ]]
}

restore_one() { # 恢复单个文件到官方原样
    local f=$1 state exp out pkg ver bk
    state=$(classify "$f")
    case $state in
        pristine) log "已是原始文件: $f"; return 0 ;;
        ours)
            new_tmp out
            run_patcher strip "$f" >"$out"
            install_file "$out" "$f"
            log "已还原: $f"; return 0 ;;
    esac
    exp=$(expected_md5 "$f")
    pkg=$(file_pkg "$f"); ver=$(pkg_ver "$pkg")
    bk="$BACKUP_DIR/${pkg}_${ver}/$(basename "$f")"
    if [[ -n $exp && -f $bk && $(md5_of "$bk") == "$exp" ]]; then
        install_file "$bk" "$f"
        log "已从备份还原: $f"; return 0
    fi
    warn "$f 含有非本工具的修改,无法精确还原"
    return 1
}

cmd_restore() {
    need_root
    lock
    command -v pveversion >/dev/null 2>&1 || die "未检测到 Proxmox VE"
    log "停用 APT 钩子与采集服务"
    rm -f "$APT_HOOK"
    systemctl disable --now "$SERVICE" >/dev/null 2>&1 || true
    rm -f "$SERVICE_FILE"
    systemctl daemon-reload || true
    rm -rf "$RUN_DIR"

    local f need_repair=0
    for f in "$NODES_PM" "$MANAGER_JS" "$TOOLKIT_JS"; do
        restore_one "$f" || need_repair=1
    done
    if [[ $need_repair == 1 ]]; then
        repair_packages || warn "重装失败,请手动执行: apt-get install --reinstall pve-manager proxmox-widget-toolkit"
    fi
    reload_pveproxy

    rm -f "$MODLOAD"
    rm -rf "$LIB_DIR"
    if [[ $OPT_PURGE == 1 ]]; then
        rm -f "$CONF"
        rm -rf "$STATE_DIR"
    fi
    rm -f "$INSTALL_BIN"
    echo
    echo -e "${C_GRN}已还原。${C_OFF}请在浏览器中按 ${C_RED}Ctrl+F5${C_OFF} 强制刷新。"
    echo "提示: lm-sensors 软件包与已加载的内核模块未卸载,重启后模块不再自动加载。"
}

cmd_collect() {
    need_root
    [[ -x $COLLECTOR ]] || die "尚未安装,请先执行 apply"
    perl "$COLLECTOR" --once
}

cmd_check() {
    local pass=0 wcount=0 fcount=0
    p() { echo -e "  ${C_GRN}PASS${C_OFF}  $*"; pass=$((pass + 1)); }
    w() { echo -e "  ${C_YEL}WARN${C_OFF}  $*"; wcount=$((wcount + 1)); }
    f() { echo -e "  ${C_RED}FAIL${C_OFF}  $*"; fcount=$((fcount + 1)); }

    echo "pve-optimize v$VERSION 自检"
    echo "---------------------------------------------------------------"
    # 1. 版本
    local ver major
    ver=$(pve_version); major=${ver%%.*}
    if [[ -z $ver ]]; then f "未检测到 PVE"; elif ((major >= 7 && major <= 9)); then p "PVE 版本 $ver (受支持)"; else w "PVE 版本 $ver (未经测试)"; fi
    echo "      pve-manager $(pkg_ver pve-manager) / proxmox-widget-toolkit $(pkg_ver proxmox-widget-toolkit) / smartmontools $(pkg_ver smartmontools)"

    # 2. 安装文件
    local x
    for x in "$INSTALL_BIN" "$COLLECTOR" "$SERVICE_FILE" "$APT_HOOK" "$CONF"; do
        [[ -e $x ]] && p "已安装 $x" || f "缺少 $x"
    done

    # 3. 补丁状态
    local st
    st=$(classify "$NODES_PM")
    case $st in
        ours) if grep -q 'PVE-OPTIMIZE BEGIN' "$NODES_PM"; then p "Nodes.pm 已打补丁,且无其它第三方修改"; else f "Nodes.pm 未打补丁"; fi ;;
        pristine) f "Nodes.pm 未打补丁 (可能被升级覆盖,执行 pve-optimize apply)" ;;
        *) f "Nodes.pm 状态: $st (含非本工具的修改)" ;;
    esac
    if nodes_load_ok; then p "Nodes.pm 可正常加载 (perl require)"; else f "Nodes.pm 无法加载!Web 界面可能异常,请执行 pve-optimize restore"; fi

    st=$(classify "$MANAGER_JS")
    if [[ $st == ours ]] && grep -q "PVE-OPTIMIZE BEGIN v$VERSION " "$MANAGER_JS"; then
        p "pvemanagerlib.js 已注入界面代码 v$VERSION,且无其它第三方修改"
    elif [[ $st == ours ]] && grep -q 'PVE-OPTIMIZE BEGIN' "$MANAGER_JS"; then
        w "pvemanagerlib.js 中是旧版本的注入代码,执行 pve-optimize apply 更新"
    elif [[ $st == pristine ]]; then
        f "pvemanagerlib.js 未打补丁"
    else
        f "pvemanagerlib.js 状态: $st"
    fi
    local nblk; nblk=$(grep -c 'PVE-OPTIMIZE BEGIN' "$MANAGER_JS" || true)
    [[ $nblk -le 1 ]] && p "pvemanagerlib.js 注入块数量 = $nblk (无重复注入)" || f "pvemanagerlib.js 注入块数量 = $nblk (重复注入)"

    st=$(classify "$TOOLKIT_JS")
    if [[ $(conf_get NO_NAG 1) == 1 ]]; then
        local left; left=$(grep -cE "data\.status(\.toLowerCase\(\))?[[:space:]]*!==[[:space:]]*'(active|Active)'" "$TOOLKIT_JS" || true)
        if [[ $st == ours ]] && grep -q 'NoMoreNagging' "$TOOLKIT_JS" && [[ $left == 0 ]]; then
            p "订阅弹窗已去除 (proxmoxlib.js),且无其它第三方修改"
        else
            f "订阅弹窗未去除 (proxmoxlib.js 状态: $st,剩余检查点 $left 处)"
        fi
    else
        [[ $st == pristine ]] && p "按配置保留订阅弹窗 (NO_NAG=0)" || w "NO_NAG=0 但 proxmoxlib.js 状态为 $st"
    fi

    # 4. 服务与数据
    if systemctl is-active --quiet "$SERVICE"; then p "采集服务 $SERVICE 运行中"; else f "采集服务 $SERVICE 未运行 (journalctl -u $SERVICE 查看原因)"; fi
    systemctl is-enabled --quiet "$SERVICE" 2>/dev/null && p "采集服务已设为开机自启" || f "采集服务未设为开机自启"

    if [[ -s $RUN_JSON && -x $COLLECTOR ]]; then
        local sum age interval cput otht freq disks dstb derr
        sum=$(perl "$COLLECTOR" --summary 2>/dev/null || true)
        kv() { sed -n "s/^$1=//p" <<<"$sum" | head -n1; }
        age=$(kv age); interval=$(kv interval); cput=$(kv cpu_temp_sensors); otht=$(kv other_temp_sensors)
        freq=$(kv freq); disks=$(kv disks); dstb=$(kv disks_standby); derr=$(kv disks_error)
        if [[ -n $age && $age -le $(( ${interval:-15} * 3 + 10 )) ]]; then p "数据文件新鲜 (${age}s 前更新,间隔 ${interval}s)"; else f "数据文件过期 (${age:-?}s 前更新)"; fi
        if [[ $(kv temps) == off ]]; then p "温度显示已按配置关闭"
        elif [[ ${cput:-0} -gt 0 ]]; then p "CPU 温度传感器 $cput 个,其它温度传感器 ${otht:-0} 个"
        else w "未读到 CPU 温度 (虚拟机/驱动未加载/硬件不支持),其它温度传感器 ${otht:-0} 个"; fi
        if [[ $freq == none ]]; then w "未读到 CPU 频率"; else p "CPU 频率: $freq"; fi
        if [[ $disks == off ]]; then p "硬盘显示已按配置关闭"
        elif [[ ${disks:-0} -gt 0 ]]; then p "检测到硬盘 $disks 块 (休眠 ${dstb:-0},读取失败 ${derr:-0})"
        else w "未检测到可读取 SMART 的硬盘"; fi
        [[ ${derr:-0} -gt 0 ]] && w "有 $derr 块硬盘读取失败,详见下方列表"
        grep '^disk:' <<<"$sum" | sed 's/^disk:/        /' || true
    else
        f "数据文件 $RUN_JSON 不存在"
    fi

    # 5. API 输出
    local api
    api=$(timeout 30 pvesh get /nodes/localhost/status --output-format json 2>/dev/null || true)
    if grep -q '"hwinfo"' <<<"$api"; then p "API /nodes/localhost/status 已包含 hwinfo 字段"; else f "API 输出中没有 hwinfo 字段"; fi

    # 6. pveproxy 是否已加载新代码
    local lr mt
    lr=$(cat "$STATE_DIR/last_reload" 2>/dev/null || echo 0); mt=$(stat -c %Y "$NODES_PM" 2>/dev/null || echo 0)
    if ((lr >= mt)); then p "pveproxy 在最近一次修改之后已重新加载"; else w "Nodes.pm 修改后 pveproxy 尚未重新加载,执行: systemctl reload-or-restart pveproxy"; fi

    # 7. 安全
    if [[ -u /usr/sbin/smartctl || -g /usr/sbin/smartctl ]]; then f "/usr/sbin/smartctl 仍带有 suid/sgid 位"; else p "smartctl 无 suid 位"; fi

    # 8. 其它被修改的官方文件(仅提示)
    local other
    other=$(dpkg --verify pve-manager proxmox-widget-toolkit 2>/dev/null | awk '$1 ~ /^..5/ {print $NF}' \
        | grep -vxF -e "$NODES_PM" -e "$MANAGER_JS" -e "$TOOLKIT_JS" || true)
    if [[ -z $other ]]; then p "pve-manager / widget-toolkit 中无其它被修改的文件"; else w "以下官方文件也被修改过(非本工具):"; sed 's/^/        /' <<<"$other"; fi

    echo "---------------------------------------------------------------"
    echo -e "结果: ${C_GRN}PASS $pass${C_OFF}  ${C_YEL}WARN $wcount${C_OFF}  ${C_RED}FAIL $fcount${C_OFF}"
    [[ $fcount == 0 ]]
}

usage() {
    cat <<EOF
pve-optimize v$VERSION  —— PVE 7/8/9 界面增强 (温度/频率/硬盘信息、去订阅弹窗)

用法: $0 <命令> [选项]
  apply      安装/更新并打补丁 (可重复执行,幂等)
               --repair             文件已被其它脚本改过时,先重装官方软件包再打补丁
               --no-sensors-detect  不运行 sensors-detect (仅加载 coretemp/k10temp)
               --force              允许在未测试的 PVE 版本上运行
  restore    完整还原 (移除补丁、服务、APT 钩子)
               --purge              同时删除配置文件与备份
  check      自检,输出 PASS/WARN/FAIL (有 FAIL 时退出码为 1)
  collect    立即采集一次并打印摘要
  version    显示版本
配置文件: $CONF
EOF
}

main() {
    local cmd=${1:-}
    [[ $# -gt 0 ]] && shift
    while [[ $# -gt 0 ]]; do
        case $1 in
            --hook) MODE_HOOK=1 ;;
            --repair) OPT_REPAIR=1 ;;
            --force) OPT_FORCE=1 ;;
            --no-sensors-detect) OPT_NO_SENSORS_DETECT=1 ;;
            --purge) OPT_PURGE=1 ;;
            *) die "未知选项: $1" ;;
        esac
        shift
    done
    case $cmd in
        apply | install) cmd_apply ;;
        restore | uninstall) cmd_restore ;;
        check | status) cmd_check ;;
        collect) cmd_collect ;;
        version | -v | --version) echo "$VERSION" ;;
        '' | help | -h | --help) usage ;;
        *) usage; exit 1 ;;
    esac
}

main "$@"

评论

正在载入评论…

留下评论

人机验证
四位数字,看不清可点击图片刷新

评论经审核后显示。

回到顶部 ↑