969 lines
38 KiB
Go
969 lines
38 KiB
Go
package main
|
||
|
||
import (
|
||
"bufio"
|
||
"context"
|
||
"crypto/md5"
|
||
"crypto/subtle"
|
||
"embed"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"flag"
|
||
"fmt"
|
||
"io"
|
||
"io/fs"
|
||
"net"
|
||
"net/http"
|
||
"os"
|
||
"os/exec"
|
||
"path"
|
||
"path/filepath"
|
||
"runtime"
|
||
"strings"
|
||
"syscall"
|
||
"time"
|
||
"unsafe"
|
||
|
||
"bj_power_mes/common/logx"
|
||
"bj_power_mes/internal/config"
|
||
"bj_power_mes/internal/db"
|
||
"bj_power_mes/internal/eventlog"
|
||
"bj_power_mes/internal/handler"
|
||
"bj_power_mes/internal/logic"
|
||
"bj_power_mes/internal/scanbridge"
|
||
"bj_power_mes/internal/svc"
|
||
"bj_power_mes/internal/tray"
|
||
"bj_power_mes/internal/wmsclient"
|
||
|
||
"golang.org/x/sys/windows"
|
||
winsvc "golang.org/x/sys/windows/svc"
|
||
winmgr "golang.org/x/sys/windows/svc/mgr"
|
||
"github.com/zeromicro/go-zero/core/conf"
|
||
gologx "github.com/zeromicro/go-zero/core/logx"
|
||
"github.com/zeromicro/go-zero/rest"
|
||
)
|
||
|
||
// 前端静态资源(Vue 构建产物:frontend/ npm run build 输出到 public/)。
|
||
// 8888 一个端口同时提供管理后台页面与 API。
|
||
//
|
||
//go:embed all:public
|
||
var webFS embed.FS
|
||
|
||
var configFile = flag.String("f", "etc/bj_power_mes-api.yaml", "the config file")
|
||
|
||
// promptPassword 从终端读取一行输入(不隐藏回显,用于运维终端操作)
|
||
func promptPassword(msg string) string {
|
||
fmt.Print(msg)
|
||
line, _ := bufio.NewReader(os.Stdin).ReadString('\n')
|
||
return strings.TrimRight(line, "\r\n")
|
||
}
|
||
|
||
// attachCLIConsole Windows GUI 子系统(-H windowsgui 打包)默认没有控制台:
|
||
// migrate/seed/reset-all 等子命令需要终端交互(管理员密码提示可见、可输入)。
|
||
// 从 cmd/PowerShell 启动 → AttachConsole(ATTACH_PARENT_PROCESS) 复用父控制台;
|
||
// 双击启动(无父控制台)→ AllocConsole 弹出新控制台窗口。
|
||
// 只补「缺失」的 std 句柄(CONIN$/CONOUT$),已有有效句柄(如被调用方重定向的管道)原样保留;
|
||
// 已有控制台(console 构建调试/go run)则不重复处理。全程失败静默返回,不阻断 CLI 流程
|
||
// (2026-11-11 修复:GUI exe 下密码提示不可见、stdin 读空,导致 migrate/seed 全部被门禁静默终止)。
|
||
func attachCLIConsole() {
|
||
if runtime.GOOS != "windows" {
|
||
return
|
||
}
|
||
if h, _ := windows.GetStdHandle(windows.STD_OUTPUT_HANDLE); h != 0 {
|
||
var mode uint32
|
||
if gerr := windows.GetConsoleMode(h, &mode); gerr == nil {
|
||
return // 已有控制台,不重复附加
|
||
}
|
||
}
|
||
kernel32 := windows.NewLazySystemDLL("kernel32.dll")
|
||
attach := kernel32.NewProc("AttachConsole")
|
||
alloc := kernel32.NewProc("AllocConsole")
|
||
// ATTACH_PARENT_PROCESS = (DWORD)-1
|
||
if r, _, _ := attach.Call(^uintptr(0)); r == 0 {
|
||
alloc.Call()
|
||
}
|
||
openConsole := func(name string, access uint32) windows.Handle {
|
||
p, _ := windows.UTF16PtrFromString(name)
|
||
h, err := windows.CreateFile(p, access, windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE, nil, windows.OPEN_EXISTING, 0, 0)
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
return h
|
||
}
|
||
// 句柄重建规则(2026-11-11 生产实测修正):GUI 子系统从 cmd/PowerShell 启动时 std 句柄
|
||
// 常为「继承来的死管道」;WriteFile 0 字节探活对断开管道可能返回成功(不可靠,曾导致
|
||
// 生产环境 reset-all 读密码秒空)。最终规则:
|
||
// - 控制台句柄(GetConsoleMode 成功)→ 保留;
|
||
// - 磁盘文件重定向(GetFileType=DISK,输出落盘日志)→ 保留;
|
||
// - 其余(管道/死句柄/NULL)→ 一律重建 CONIN$/CONOUT$ 并 SetStdHandle 回写。
|
||
// 管道重定向(如 | Select-Object)会改走控制台输出——CLI 子命令为交互场景,可接受。
|
||
rebind := func(std uint32, file **os.File, name string, conName string, access uint32) {
|
||
h, _ := windows.GetStdHandle(std)
|
||
var mode uint32
|
||
if h != 0 && windows.GetConsoleMode(h, &mode) == nil {
|
||
return // 控制台句柄,保留
|
||
}
|
||
if h != 0 {
|
||
if ft, ferr := windows.GetFileType(h); ferr == nil && ft == windows.FILE_TYPE_DISK {
|
||
return // 磁盘文件重定向,保留
|
||
}
|
||
}
|
||
ch := openConsole(conName, access)
|
||
if ch == 0 {
|
||
return
|
||
}
|
||
_ = windows.SetStdHandle(std, ch)
|
||
*file = os.NewFile(uintptr(ch), name)
|
||
}
|
||
rebind(windows.STD_OUTPUT_HANDLE, &os.Stdout, "stdout", "CONOUT$", windows.GENERIC_WRITE|windows.GENERIC_READ)
|
||
rebind(windows.STD_ERROR_HANDLE, &os.Stderr, "stderr", "CONOUT$", windows.GENERIC_WRITE|windows.GENERIC_READ)
|
||
rebind(windows.STD_INPUT_HANDLE, &os.Stdin, "stdin", "CONIN$", windows.GENERIC_READ)
|
||
}
|
||
|
||
// adminGate 敏感命令行操作(migrate/seed/reset-all)授权闸门。
|
||
// 2026-11-11 生产环境反复踩坑后的最终策略:
|
||
//
|
||
// ① Windows 提权(管理员运行)= 已授权,直接放行、零交互——服务端机器上 GUI 子系统进程的
|
||
// 控制台/stdin 行为不可靠,敏感命令的"可用性"优先于形式化的二次密码(提权本身就是更强的授权);
|
||
// ② 非管理员:用环境变量 BJ_POWER_CLI_PASSWORD,或终端输入(attachCLIConsole 已补控制台);
|
||
// ③ 结果一律写日志(logs/bj_power_mes-*.log),即使控制台输出不可见也能追溯。
|
||
func adminGate(c config.Config) bool {
|
||
if runtime.GOOS == "windows" && windows.GetCurrentProcessToken().IsElevated() {
|
||
gologx.Infof("敏感命令 [%s] 以管理员权限运行,免密放行", flag.Arg(0))
|
||
fmt.Println("以管理员权限运行,免密执行 [" + flag.Arg(0) + "]")
|
||
return true
|
||
}
|
||
// 非管理员:优先 -p 命令行密码(任意环境可用,不依赖控制台),其次环境变量,最后终端输入
|
||
pwd := cliPasswordArg()
|
||
if pwd == "" {
|
||
pwd = strings.TrimSpace(os.Getenv("BJ_POWER_CLI_PASSWORD"))
|
||
}
|
||
if pwd == "" {
|
||
pwd = promptPassword("请输入管理员密码以执行 [" + flag.Arg(0) + "]: ")
|
||
}
|
||
if pwd == "" {
|
||
// 未读到任何输入:明确指路(2026-11-11 生产反馈:GUI 子系统的控制台 stdin 不可靠)
|
||
gologx.Errorf("敏感命令 [%s] 未读取到终端输入,被终止", flag.Arg(0))
|
||
fmt.Println("未读取到终端输入。任选一种方式重试:")
|
||
fmt.Println(" ① 右键「以管理员身份运行」cmd 后执行(管理员免密)")
|
||
fmt.Println(" ② 带密码参数:bj_power_mes.exe seed -p 管理员密码")
|
||
fmt.Println(" ③ 先设环境变量:$env:BJ_POWER_CLI_PASSWORD='管理员密码'")
|
||
return false
|
||
}
|
||
if subtle.ConstantTimeCompare([]byte(pwd), []byte(c.Cli.AdminPassword)) != 1 {
|
||
gologx.Errorf("敏感命令 [%s] 因管理员密码校验失败被终止", flag.Arg(0))
|
||
fmt.Println("管理员密码不正确,已终止该操作。")
|
||
return false
|
||
}
|
||
gologx.Infof("敏感命令 [%s] 已通过管理员密码校验", flag.Arg(0))
|
||
return true
|
||
}
|
||
|
||
// cliPasswordArg 解析子命令后的 -p/--password 参数(Go flag 只解析子命令前的参数,
|
||
// 故 seed -p xxx 需手工扫描 flag.Args())。
|
||
func cliPasswordArg() string {
|
||
args := flag.Args()
|
||
for i := 1; i < len(args); i++ {
|
||
if (args[i] == "-p" || args[i] == "--password") && i+1 < len(args) {
|
||
return strings.TrimSpace(args[i+1])
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// cliNotify 结果弹窗(MessageBox):GUI 子系统 exe 在 Windows 终端/批处理里控制台输出
|
||
// 可能完全不可见,敏感命令(migrate/seed/reset-all)执行结果一律弹窗,保证操作人看到。
|
||
func cliNotify(title, msg string) {
|
||
if runtime.GOOS != "windows" {
|
||
return
|
||
}
|
||
user32 := windows.NewLazySystemDLL("user32.dll")
|
||
mb := user32.NewProc("MessageBoxW")
|
||
t, terr := windows.UTF16PtrFromString(title)
|
||
m, merr := windows.UTF16PtrFromString(msg)
|
||
if terr != nil || merr != nil {
|
||
return
|
||
}
|
||
mb.Call(0, uintptr(unsafe.Pointer(m)), uintptr(unsafe.Pointer(t)), 0x40) // MB_OK | MB_ICONINFORMATION
|
||
}
|
||
|
||
// cliNotifyError 失败弹窗(红叉图标)
|
||
func cliNotifyError(title, msg string) {
|
||
if runtime.GOOS != "windows" {
|
||
return
|
||
}
|
||
user32 := windows.NewLazySystemDLL("user32.dll")
|
||
mb := user32.NewProc("MessageBoxW")
|
||
t, terr := windows.UTF16PtrFromString(title)
|
||
m, merr := windows.UTF16PtrFromString(msg)
|
||
if terr != nil || merr != nil {
|
||
return
|
||
}
|
||
mb.Call(0, uintptr(unsafe.Pointer(m)), uintptr(unsafe.Pointer(t)), 0x10) // MB_ICONERROR
|
||
}
|
||
|
||
// ==================== 进程守护(2026-11-11 拍板:三端 exe 常驻存活,越极致越好) ====================
|
||
// 双进程互守(同一 exe 自举):guardian(隐形监督进程,无托盘无窗口)+ worker(业务进程)。
|
||
// - 启动先抢 Local\BJP_MES_GUARDIAN 互斥体:抢到=guardian;抢不到=worker;
|
||
// - worker 持 Local\BJP_MES_WORKER 互斥体(防重复实例),每 5s 心跳:TCP 探活本机端口,
|
||
// 探活成功才写心跳文件 %TEMP%\bj_power_mes.guard.json(pid/ts/listening);
|
||
// - guardian 三重盯防:
|
||
// ① worker 退出码 0(托盘主动退出)→ guardian 跟随退出;非 0(崩溃)→ 3s 后重拉;
|
||
// ② 心跳缺失/过期 30s(服务卡死)→ 校验进程映像确为本 exe 后杀掉重拉(防 PID 复用误杀);
|
||
// ③ 连续 5 次 10s 内秒退(配置错误等)→ 退避 60s 再试,修复后自动恢复;
|
||
// - worker 每 10s 检查 guardian 互斥体:消失(guardian 崩溃)→ 拉起新 guardian 继续
|
||
// 监视自己(收养模式);guardian 与 worker 同时死亡的极端场景由开机自启兜底。
|
||
// - 服务模式(SCM 拉起)不走守护:由 SCM 恢复动作负责崩溃重启(见 autoRegisterService),
|
||
// 并内置端口自检自愈(连续失败主动退出交由 SCM 重启)。
|
||
const (
|
||
guardMutexName = `Local\BJP_MES_GUARDIAN`
|
||
workerMutexName = `Local\BJP_MES_WORKER`
|
||
guardHeartbeatTTL = 30 * time.Second // 心跳过期=worker 卡死
|
||
guardSpawnGrace = 90 * time.Second // 启动宽限期(worker 尚未监听端口属正常)
|
||
)
|
||
|
||
func exePathGuard() string {
|
||
exe, err := os.Executable()
|
||
if err != nil {
|
||
return os.Args[0]
|
||
}
|
||
if rp, rerr := filepath.EvalSymlinks(exe); rerr == nil {
|
||
exe = rp
|
||
}
|
||
return exe
|
||
}
|
||
|
||
func createOwnedMutex(name string) (windows.Handle, bool) {
|
||
h, err := windows.CreateMutex(nil, false, windows.StringToUTF16Ptr(name))
|
||
if h == 0 {
|
||
return 0, false
|
||
}
|
||
return h, err == nil // 已存在时 err=ERROR_ALREADY_EXISTS
|
||
}
|
||
|
||
func mutexExists(name string) bool {
|
||
h, err := windows.OpenMutex(windows.SYNCHRONIZE, false, windows.StringToUTF16Ptr(name))
|
||
if err == nil {
|
||
windows.CloseHandle(h)
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
type guardInfo struct {
|
||
PID int `json:"pid"`
|
||
TS time.Time `json:"ts"`
|
||
Listening bool `json:"listening"`
|
||
}
|
||
|
||
func guardHeartbeatFile() string {
|
||
return filepath.Join(os.TempDir(), "bj_power_mes.guard.json")
|
||
}
|
||
|
||
func readGuardInfo() (guardInfo, bool) {
|
||
var gi guardInfo
|
||
data, err := os.ReadFile(guardHeartbeatFile())
|
||
if err != nil || json.Unmarshal(data, &gi) != nil {
|
||
return gi, false
|
||
}
|
||
return gi, true
|
||
}
|
||
|
||
func guardianLog(format string, args ...any) {
|
||
f, err := os.OpenFile(filepath.Join(os.TempDir(), "bj_power_mes.guardian.log"),
|
||
os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
|
||
if err != nil {
|
||
return
|
||
}
|
||
defer f.Close()
|
||
fmt.Fprintf(f, time.Now().Format("2006-01-02 15:04:05 ")+"guardian: "+fmt.Sprintf(format, args...)+"\n")
|
||
}
|
||
|
||
// guardianHeartbeat worker 心跳:每 5s TCP 探活本机端口,成功才写心跳文件
|
||
//(服务卡死时探活失败 → 心跳停更 → guardian 判过期杀掉重拉)。
|
||
func guardianHeartbeat(port int) {
|
||
for {
|
||
listening := false
|
||
if conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", port), 3*time.Second); err == nil {
|
||
conn.Close()
|
||
listening = true
|
||
}
|
||
if data, err := json.Marshal(guardInfo{PID: os.Getpid(), TS: time.Now(), Listening: listening}); err == nil {
|
||
_ = os.WriteFile(guardHeartbeatFile(), data, 0644)
|
||
}
|
||
time.Sleep(5 * time.Second)
|
||
}
|
||
}
|
||
|
||
// workerWatchGuardian worker 监督 guardian:guardian 崩溃(互斥体消失)→ 拉起新 guardian 继续监视自己。
|
||
func workerWatchGuardian(exe string) {
|
||
for {
|
||
time.Sleep(10 * time.Second)
|
||
if mutexExists(guardMutexName) {
|
||
continue
|
||
}
|
||
guardianLog("guardian 消失,worker(%d) 重新拉起监督进程", os.Getpid())
|
||
cmd := exec.Command(exe, os.Args[1:]...)
|
||
cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
|
||
if err := cmd.Start(); err == nil {
|
||
// 新 guardian 进入收养模式接管本 worker
|
||
time.Sleep(15 * time.Second) // 等其就位,防重复拉起
|
||
}
|
||
}
|
||
}
|
||
|
||
// killWorker 按 PID 杀 worker;先校验进程映像确为本 exe(防 PID 复用误杀无辜进程)。
|
||
func killWorker(pid int, expectExe string) {
|
||
if pid <= 0 {
|
||
return
|
||
}
|
||
h, err := windows.OpenProcess(windows.PROCESS_TERMINATE|windows.SYNCHRONIZE|
|
||
windows.PROCESS_QUERY_LIMITED_INFORMATION, false, uint32(pid))
|
||
if err != nil {
|
||
return
|
||
}
|
||
defer windows.CloseHandle(h)
|
||
buf := make([]uint16, 32768)
|
||
size := uint32(len(buf))
|
||
if err := windows.QueryFullProcessImageName(h, 0, &buf[0], &size); err != nil {
|
||
return // 查不到映像,不杀
|
||
}
|
||
if !strings.EqualFold(filepath.Base(windows.UTF16ToString(buf[:size])), filepath.Base(expectExe)) {
|
||
return // 映像不符,不杀
|
||
}
|
||
windows.TerminateProcess(h, 1)
|
||
}
|
||
|
||
// supervise 拉起 worker 子进程并盯防:正常退出返回退出码;心跳异常则杀掉(Wait 随即返回 1)。
|
||
func supervise(exe string) (int, time.Duration) {
|
||
start := time.Now()
|
||
cmd := exec.Command(exe, os.Args[1:]...)
|
||
if err := cmd.Start(); err != nil {
|
||
guardianLog("拉起 worker 失败: %v", err)
|
||
return -1, 0
|
||
}
|
||
done := make(chan int, 1)
|
||
go func() {
|
||
_ = cmd.Wait()
|
||
if cmd.ProcessState != nil {
|
||
done <- cmd.ProcessState.ExitCode()
|
||
} else {
|
||
done <- -1
|
||
}
|
||
}()
|
||
ticker := time.NewTicker(5 * time.Second)
|
||
defer ticker.Stop()
|
||
for {
|
||
select {
|
||
case code := <-done:
|
||
return code, time.Since(start)
|
||
case <-ticker.C:
|
||
gi, ok := readGuardInfo()
|
||
if !ok {
|
||
continue
|
||
}
|
||
if (gi.Listening && time.Since(gi.TS) > guardHeartbeatTTL) ||
|
||
(!gi.Listening && time.Since(start) > guardSpawnGrace) {
|
||
guardianLog("worker(%d) 心跳异常(listening=%v,距上次心跳 %v),杀掉重拉",
|
||
gi.PID, gi.Listening, time.Since(gi.TS).Round(time.Second))
|
||
killWorker(gi.PID, exe)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// guardianLoop guardian 主循环:拉起 / 收养 worker,崩溃重拉、卡死杀重拉、主动退出跟随退出。
|
||
func guardianLoop(exe string) {
|
||
guardianLog("guardian 启动 pid=%d args=%v", os.Getpid(), os.Args[1:])
|
||
failStreak := 0
|
||
for {
|
||
if mutexExists(workerMutexName) {
|
||
// 收养模式:worker 已在运行(worker 检测到 guardian 死亡后拉起了本进程)
|
||
if gi, ok := readGuardInfo(); ok && gi.Listening && time.Since(gi.TS) > guardHeartbeatTTL {
|
||
guardianLog("收养模式:worker(%d) 心跳过期,杀掉重拉", gi.PID)
|
||
killWorker(gi.PID, exe)
|
||
}
|
||
time.Sleep(3 * time.Second)
|
||
continue
|
||
}
|
||
if failStreak >= 5 {
|
||
guardianLog("连续 %d 次 10s 内秒退(多为配置/环境错误),退避 60s 后继续尝试", failStreak)
|
||
time.Sleep(60 * time.Second)
|
||
failStreak = 0
|
||
}
|
||
code, lived := supervise(exe)
|
||
if code == 0 {
|
||
guardianLog("worker 主动退出(code=0),guardian 跟随退出")
|
||
return
|
||
}
|
||
if lived >= time.Minute {
|
||
failStreak = 0
|
||
} else {
|
||
failStreak++
|
||
}
|
||
guardianLog("worker 异常退出(code=%d,存活 %v),3s 后重拉(failStreak=%d)", code, lived.Round(time.Second), failStreak)
|
||
time.Sleep(3 * time.Second)
|
||
}
|
||
}
|
||
|
||
// runGuarded 进程守护入口:决定本进程是 guardian 还是 worker。
|
||
func runGuarded(runWorker func(), port int) {
|
||
if runtime.GOOS != "windows" {
|
||
runWorker()
|
||
return
|
||
}
|
||
exe := exePathGuard()
|
||
if gm, owned := createOwnedMutex(guardMutexName); owned {
|
||
_ = gm // 持有至进程退出,OS 自动清理
|
||
guardianLoop(exe)
|
||
return
|
||
} else {
|
||
// 关键:未抢到 guardian 身份必须立即关闭观察句柄——否则 worker 会一直持有
|
||
// guardian 互斥体对象,guardian 进程死后对象销毁不了,worker 就永远检测不到
|
||
// guardian 已死(2026-11-11 实测踩坑:guardian 被杀后互斥体仍存在,自愈失效)。
|
||
windows.CloseHandle(gm)
|
||
}
|
||
wm, workerOwned := createOwnedMutex(workerMutexName)
|
||
if !workerOwned {
|
||
// 已有 worker 在运行(用户重复双击/重复登录启动),静默退出防重复实例
|
||
return
|
||
}
|
||
_ = wm
|
||
go workerWatchGuardian(exe)
|
||
go guardianHeartbeat(port)
|
||
guardianLog("worker 启动 pid=%d", os.Getpid())
|
||
runWorker()
|
||
}
|
||
|
||
// newSvc 最小 ServiceContext(CLI 场景:只连库 + 事件日志写入器)
|
||
func newSvc(c config.Config) *svc.ServiceContext {
|
||
client, _ := db.MustNewDB(c.Database)
|
||
return &svc.ServiceContext{
|
||
Config: c,
|
||
EntClient: client,
|
||
EventLog: eventlog.NewWriter(client),
|
||
}
|
||
}
|
||
|
||
// runMigrate 建库(若不存在)+ 建表/补列/清理旧结构(幂等,不删业务数据)
|
||
func runMigrate(c config.Config) error {
|
||
if err := db.EnsureDB(c.Database); err != nil {
|
||
gologx.Errorf("ensure database failed: %v", err)
|
||
return fmt.Errorf("准备数据库失败:%v", err)
|
||
}
|
||
client, sqlDB := db.MustNewDB(c.Database)
|
||
defer client.Close()
|
||
defer sqlDB.Close()
|
||
if err := db.EnsureSchema(client, sqlDB); err != nil {
|
||
gologx.Errorf("migrate failed: %v", err)
|
||
return fmt.Errorf("结构迁移失败:%v", err)
|
||
}
|
||
gologx.Infof("migrate: 数据库结构迁移成功(建表/补列/清理退役结构,未删除业务数据)")
|
||
fmt.Println("migrate: 数据库结构迁移成功(建表/补列/清理退役结构,未删除业务数据)。")
|
||
return nil
|
||
}
|
||
|
||
// runSeed 建库建表(若不存在)+ 灌基础种子(工位/接驳台/权限等,不删数据)
|
||
func runSeed(c config.Config) error {
|
||
if err := db.EnsureDB(c.Database); err != nil {
|
||
gologx.Errorf("ensure database failed: %v", err)
|
||
return fmt.Errorf("准备数据库失败:%v", err)
|
||
}
|
||
client, sqlDB := db.MustNewDB(c.Database)
|
||
defer client.Close()
|
||
defer sqlDB.Close()
|
||
if err := db.EnsureSchema(client, sqlDB); err != nil {
|
||
gologx.Errorf("seed migrate failed: %v", err)
|
||
return fmt.Errorf("结构迁移失败:%v", err)
|
||
}
|
||
s := logic.New(newSvc(c))
|
||
if err := s.Seed(context.Background()); err != nil {
|
||
gologx.Errorf("seed failed: %v", err)
|
||
return fmt.Errorf("写入基础数据失败:%v", err)
|
||
}
|
||
gologx.Infof("seed: 基础数据已对齐(工位/接驳台/权限等);管理员 admin/123456")
|
||
fmt.Println("seed: 基础数据已对齐(工位/接驳台/权限等);管理员 admin/123456。")
|
||
return nil
|
||
}
|
||
|
||
// runResetAll 清空并重建全部表 + 重灌全部种子。此操作不可恢复!
|
||
func runResetAll(c config.Config) error {
|
||
if err := db.EnsureDB(c.Database); err != nil {
|
||
gologx.Errorf("ensure database failed: %v", err)
|
||
return fmt.Errorf("准备数据库失败:%v", err)
|
||
}
|
||
if err := db.DropAllTables(c.Database); err != nil {
|
||
gologx.Errorf("reset-all drop failed: %v", err)
|
||
return fmt.Errorf("删表失败:%v", err)
|
||
}
|
||
client, sqlDB := db.MustNewDB(c.Database)
|
||
defer client.Close()
|
||
defer sqlDB.Close()
|
||
if err := db.EnsureSchema(client, sqlDB); err != nil {
|
||
gologx.Errorf("reset-all migrate failed: %v", err)
|
||
return fmt.Errorf("重建表失败:%v", err)
|
||
}
|
||
s := logic.New(newSvc(c))
|
||
if err := s.Seed(context.Background()); err != nil {
|
||
gologx.Errorf("reset-all seed failed: %v", err)
|
||
return fmt.Errorf("写入基础数据失败:%v", err)
|
||
}
|
||
gologx.Infof("reset-all: 已清空并重建全部表,写入基础数据(管理员 admin/123456)")
|
||
fmt.Println("reset-all: 已清空并重建全部表,写入基础数据(管理员 admin/123456)。")
|
||
return nil
|
||
}
|
||
|
||
// newStaticHandler 嵌入式静态文件:命中则直接返回;未命中的非 /api 路径
|
||
// 回退到 index.html(SPA history 路由),由浏览器端 Vue Router 接管。
|
||
func newStaticHandler(fsys embed.FS) http.Handler {
|
||
sub, err := fs.Sub(fsys, "public")
|
||
if err != nil {
|
||
panic(fmt.Sprintf("嵌入静态目录不可用: %v", err))
|
||
}
|
||
fileServer := http.FileServer(http.FS(sub))
|
||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
name := strings.TrimPrefix(path.Clean(r.URL.Path), "/")
|
||
if name == "" {
|
||
name = "index.html"
|
||
}
|
||
if f, openErr := sub.Open(name); openErr == nil {
|
||
f.Close()
|
||
fileServer.ServeHTTP(w, r)
|
||
return
|
||
}
|
||
r2 := r.Clone(r.Context())
|
||
r2.URL.Path = "/"
|
||
fileServer.ServeHTTP(w, r2)
|
||
})
|
||
}
|
||
|
||
// openBrowser 用系统默认浏览器打开 url(Windows/macOS/Linux)
|
||
func openBrowser(url string) {
|
||
var cmd *exec.Cmd
|
||
switch runtime.GOOS {
|
||
case "windows":
|
||
cmd = exec.Command("rundll32", "url.dll,FileProtocolHandler", url)
|
||
case "darwin":
|
||
cmd = exec.Command("open", url)
|
||
default:
|
||
cmd = exec.Command("xdg-open", url)
|
||
}
|
||
if err := cmd.Start(); err != nil {
|
||
gologx.Errorf("自动打开浏览器失败(%s): %v", url, err)
|
||
}
|
||
}
|
||
|
||
// logRuntimeBinaryFingerprint 在启动早期打印当前运行 EXE 的指纹(真实路径/大小/MD5/修改时间),
|
||
// 走本项目 logx(go-zero)落盘,与业务日志同文件,便于生产机直接翻日志核对运行版本。
|
||
// 任何环节失败仅记错误日志并继续,绝不中断启动。
|
||
func logRuntimeBinaryFingerprint() {
|
||
exePath, err := os.Executable()
|
||
if err != nil {
|
||
gologx.Errorf("svc: runtime binary fingerprint skipped: os.Executable failed: %v", err)
|
||
return
|
||
}
|
||
realPath, err := filepath.EvalSymlinks(exePath)
|
||
if err != nil {
|
||
// 解析软链接失败:降级用原始路径,仅记日志不影响启动
|
||
gologx.Errorf("svc: runtime binary fingerprint: EvalSymlinks failed, fallback to raw path: %v", err)
|
||
realPath = exePath
|
||
}
|
||
info, err := os.Stat(realPath)
|
||
if err != nil {
|
||
gologx.Errorf("svc: runtime binary fingerprint skipped: os.Stat failed: %v", err)
|
||
return
|
||
}
|
||
f, err := os.Open(realPath)
|
||
if err != nil {
|
||
gologx.Errorf("svc: runtime binary fingerprint skipped: open failed: %v", err)
|
||
return
|
||
}
|
||
defer f.Close()
|
||
h := md5.New()
|
||
if _, err := io.Copy(h, f); err != nil {
|
||
gologx.Errorf("svc: runtime binary fingerprint skipped: read failed: %v", err)
|
||
return
|
||
}
|
||
gologx.Infof("svc: runtime binary fingerprint path=%s size=%d md5=%s modTime=%s",
|
||
realPath, info.Size(), hex.EncodeToString(h.Sum(nil)), info.ModTime().Format("2006-01-02 15:04:05"))
|
||
}
|
||
|
||
func main() {
|
||
flag.Parse()
|
||
|
||
// Windows 服务模式:由服务管理器拉起(服务名 bj_power_mes,由 autoRegisterService 注册)。
|
||
// SCM 启动目录为 System32,配置文件相对路径在 runAsWindowsService 内按 exe 目录解析。
|
||
if runtime.GOOS == "windows" {
|
||
if isSvc, _ := winsvc.IsWindowsService(); isSvc {
|
||
runAsWindowsService(*configFile)
|
||
return
|
||
}
|
||
}
|
||
|
||
var c config.Config
|
||
conf.MustLoad(*configFile, &c)
|
||
|
||
// 按天日志:logs/bj_power_mes-2026-01-02.log,保留 30 天(go-zero logx Writer 适配 slog)
|
||
if c.Logger.Filename != "" {
|
||
logger := logx.NewLogger(c.Logger)
|
||
logx.SetDefault(logger)
|
||
gologx.SetWriter(logger)
|
||
}
|
||
|
||
// 启动指纹:打印当前 EXE 真实路径/大小/MD5/修改时间,便于核对运行版本
|
||
logRuntimeBinaryFingerprint()
|
||
|
||
// 命令行子命令:DDL/删库/种子等敏感操作一律显式触发 + 管理员密码门禁,
|
||
// 绝不随服务启动自动执行(migrate / seed / reset-all / serve)。
|
||
// GUI 子系统打包(-H windowsgui)无控制台:CLI 子命令先补控制台(见 attachCLIConsole)。
|
||
switch flag.Arg(0) {
|
||
case "migrate", "seed", "reset-all":
|
||
attachCLIConsole()
|
||
}
|
||
switch cmd := flag.Arg(0); cmd {
|
||
case "reset-all":
|
||
fmt.Println("reset-all: 即将清空并重建 MES 全部表,此操作不可恢复!")
|
||
if !adminGate(c) {
|
||
cliNotifyError("reset-all 未执行", "未通过管理员校验。\n\n任选一种方式重试:\n① 右键「以管理员身份运行」cmd\n② 带密码参数:bj_power_mes.exe reset-all -p 管理员密码\n③ 先设环境变量 BJ_POWER_CLI_PASSWORD")
|
||
os.Exit(1)
|
||
}
|
||
if err := runResetAll(c); err != nil {
|
||
cliNotifyError("reset-all 失败", err.Error())
|
||
os.Exit(1)
|
||
}
|
||
cliNotify("reset-all 完成", "已清空并重建全部表,已写入基础数据。\n管理员账号:admin / 123456")
|
||
return
|
||
case "seed":
|
||
if !adminGate(c) {
|
||
cliNotifyError("seed 未执行", "未通过管理员校验。\n\n任选一种方式重试:\n① 右键「以管理员身份运行」cmd\n② 带密码参数:bj_power_mes.exe seed -p 管理员密码\n③ 先设环境变量 BJ_POWER_CLI_PASSWORD")
|
||
os.Exit(1)
|
||
}
|
||
if err := runSeed(c); err != nil {
|
||
cliNotifyError("seed 失败", err.Error())
|
||
os.Exit(1)
|
||
}
|
||
cliNotify("seed 完成", "基础数据已对齐(工位/接驳台/权限等)。\n管理员账号:admin / 123456")
|
||
return
|
||
case "migrate":
|
||
if !adminGate(c) {
|
||
cliNotifyError("migrate 未执行", "未通过管理员校验。\n\n任选一种方式重试:\n① 右键「以管理员身份运行」cmd\n② 带密码参数:bj_power_mes.exe migrate -p 管理员密码\n③ 先设环境变量 BJ_POWER_CLI_PASSWORD")
|
||
os.Exit(1)
|
||
}
|
||
if err := runMigrate(c); err != nil {
|
||
cliNotifyError("migrate 失败", err.Error())
|
||
os.Exit(1)
|
||
}
|
||
cliNotify("migrate 完成", "数据库结构迁移成功(建表/补列,未删除业务数据)。")
|
||
return
|
||
case "", "serve":
|
||
// 正常启动服务(交互前台/托盘模式);管理员运行时顺带自注册 Windows 服务(开机自启)
|
||
autoRegisterService()
|
||
// 进程守护(2026-11-11 拍板):guardian+worker 双进程互守,崩溃/卡死自动拉起
|
||
runGuarded(func() { runServe(c, false) }, c.Port)
|
||
return
|
||
default:
|
||
fmt.Println("未知命令: " + cmd + ";可用命令: migrate / seed / reset-all / serve")
|
||
os.Exit(1)
|
||
}
|
||
}
|
||
|
||
// runServe 启动 HTTP 服务 + 后台任务;交互模式(asService=false)末尾进入系统托盘消息循环。
|
||
// asService=true(Windows 服务模式):无交互桌面,跳过自动开浏览器与托盘,阻塞运行等待 SCM 停止。
|
||
func runServe(c config.Config, asService bool) {
|
||
staticHandler := newStaticHandler(webFS)
|
||
|
||
// 兜底路由:已注册的 /api/* 走正常匹配;未注册的非 /api 路径走嵌入式静态资源
|
||
//(/api 下未注册的路径仍返回 404,不回退页面)
|
||
notFound := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
if strings.HasPrefix(r.URL.Path, "/api/") || r.URL.Path == "/api" {
|
||
http.NotFound(w, r)
|
||
return
|
||
}
|
||
staticHandler.ServeHTTP(w, r)
|
||
})
|
||
|
||
server := rest.MustNewServer(c.RestConf,
|
||
rest.WithNotFoundHandler(notFound),
|
||
// JWT 鉴权失败统一回调(条17):401 业务码 JSON,前端据此跳登录页。
|
||
// 仅作用于 JWT 保护路由(/api/v1 业务组),内部 X-API-TOKEN 路由不走此回调。
|
||
rest.WithUnauthorizedCallback(func(w http.ResponseWriter, r *http.Request, err error) {
|
||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||
w.WriteHeader(http.StatusUnauthorized)
|
||
_, _ = w.Write([]byte(`{"code":401,"message":"登录已过期,请重新登录"}`))
|
||
}),
|
||
)
|
||
defer server.Stop()
|
||
|
||
// 2026-11-16 联调:rest.MustNewServer 内部 logx.SetUp(RestConf.Log) 会用 console writer
|
||
// 覆盖 main 里 SetWriter 装的按天文件 writer(setupOnce 全程只此一次,之后无人再覆盖),
|
||
// 导致服务启动后所有业务日志只进控制台不落文件(实验复现实锤)。
|
||
// 必须在 server 创建后把文件 writer 装回去,此后全量业务日志正常落 logs/。
|
||
if c.Logger.Filename != "" {
|
||
gologx.SetWriter(logx.NewLogger(c.Logger))
|
||
}
|
||
|
||
ctx := svc.NewServiceContext(c)
|
||
|
||
// 扫码中间件(键盘 HID 注入):默认关闭(Scanner.Enabled=false),需在 yaml 启用并重启。
|
||
// 与 WMS 同机且都开时,7757 谁先启动谁监听,后到的只记日志、不影响主程序。
|
||
if c.Scanner.Enabled {
|
||
go func() {
|
||
if err := scanbridge.Start(context.Background(), scanbridge.Options{}); err != nil {
|
||
gologx.Errorf("扫码中间件启动失败(不影响主程序): %v", err)
|
||
}
|
||
}()
|
||
}
|
||
|
||
// PLC↔MES 对账(#8 T6):PLC 通讯恢复回调——连续失败后首次成功沿触发一次全量对账。
|
||
// mock 模式无失败,不触发;真实 S7 连接恢复时触发 CheckAllMismatch(落预警中心)。
|
||
ctx.PLC.SetOnRecover(func(recoverCtx context.Context) {
|
||
if _, err := logic.New(ctx).CheckAllMismatch(recoverCtx, "plc_recover", "system"); err != nil {
|
||
gologx.Errorf("PLC 恢复全量对账失败: %v", err)
|
||
}
|
||
})
|
||
|
||
// PLC 通讯失败预警(2026-11-16):连续失败首次沿触发(持续断连不重复触发),
|
||
// 预警侧 10 分钟窗口去重兜底防风暴;恢复后下次再断会重新触发。
|
||
ctx.PLC.SetOnFail(func(failCtx context.Context, failErr error) {
|
||
fc, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||
defer cancel()
|
||
_, aerr := logic.New(ctx).CreateAlertDedup(fc, "plc_offline", "严重", "PLC",
|
||
"PLC 通讯失败:产线控制信号读写异常,点位状态可能与台账不一致,请检查 PLC 网络与电源。详情:"+failErr.Error(), 10)
|
||
if aerr != nil {
|
||
gologx.Errorf("PLC 通讯失败落预警异常: %v", aerr)
|
||
}
|
||
})
|
||
|
||
// WMS 通讯失败预警(2026-11-16):MES→WMS 传输层失败(连不上/超时)触发,
|
||
// 10 分钟窗口去重;HTTP 业务错误(服务在但拒绝)不算通讯异常、不触发。
|
||
wmsclient.FailHook = func(hookCtx context.Context, method, url string, hookErr error) {
|
||
fc, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||
defer cancel()
|
||
_, aerr := logic.New(ctx).CreateAlertDedup(fc, "wms_unreachable", "警告", "WMS",
|
||
fmt.Sprintf("WMS 通讯失败:%s %s(%v),在制品/成品库存联动将失败,请检查 WMS 服务。", method, url, hookErr), 10)
|
||
if aerr != nil {
|
||
gologx.Errorf("WMS 通讯失败落预警异常: %v", aerr)
|
||
}
|
||
}
|
||
|
||
// 断电恢复启动对账(#8 T8,2026-11-03 补全):服务(含产线断电重启后)冷启动时,
|
||
// 若 PLC 首连即成功则没有"失败→成功沿",T6 不会触发——这里延迟 15 秒补一次全量对账,
|
||
// 比对 PLC 托盘位实读与 MES 在制工件记录,命中落预警中心(trigger=boot),不阻断启动。
|
||
// 与 T7 管理员手动核对、T6 恢复沿互为补充:断电场景靠本兜底自动发现"PLC 有件、MES 无记录"。
|
||
go func() {
|
||
time.Sleep(15 * time.Second)
|
||
bctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||
defer cancel()
|
||
if hits, err := logic.New(ctx).CheckAllMismatch(bctx, "boot", "system"); err != nil {
|
||
gologx.Errorf("启动全量对账失败(PLC 未接入或未就绪属正常): %v", err)
|
||
} else if len(hits) > 0 {
|
||
gologx.Infof("启动全量对账发现 %d 处 PLC↔MES 不一致,已落预警中心", len(hits))
|
||
}
|
||
}()
|
||
|
||
// 滑动续签(条17):全局挂载 RenewalMiddleware——每个携带有效 Bearer token 的请求
|
||
// 重签新 token 写入响应头 X-Renewed-Token,前端/工位终端据此滚动续期;
|
||
// 无 Bearer 头的请求(登录、内部 X-API-TOKEN、静态资源)原样放行。
|
||
server.Use(handler.RenewalMiddleware(ctx))
|
||
|
||
handler.RegisterRoutes(server, ctx)
|
||
handler.RegisterProductionRoutes(server, ctx)
|
||
|
||
// 磁盘空间监控:每天 DiskCheckHour 点检测附件根目录剩余空间
|
||
handler.StartDiskMonitor(ctx)
|
||
|
||
// 事件日志保留期清理:每小时检查,保留天数在「基础设置」页配置(0=不清理)
|
||
handler.StartEventLogRetention(ctx)
|
||
|
||
// 预警定时扫描器:每小时扫描工单超期(task_overdue),启用规则后才落预警
|
||
handler.StartAlertScanner(ctx)
|
||
|
||
// AGV 卸货超时扫描(2026-11-03 拍板):每分钟巡检一次,发现派发超过阈值(基础设置
|
||
// CfgAgvUnloadTimeoutMinutes,默认 5 分钟)仍未「卸货完成(状态9)」的 AGV 任务,落预警通知人工干预。
|
||
// AGV 只有把货卸到目标点位才算完成任务;若接驳台满载/设备故障无处卸货,必须报警而非靠人工确认。
|
||
go func() {
|
||
time.Sleep(20 * time.Second)
|
||
ticker := time.NewTicker(60 * time.Second)
|
||
defer ticker.Stop()
|
||
for range ticker.C {
|
||
bctx := context.Background()
|
||
timeoutMin := logic.New(ctx).CfgInt(bctx, logic.CfgAgvUnloadTimeoutMinutes, 5)
|
||
if _, err := logic.New(ctx).ScanAgvUnloadTimeout(bctx, timeoutMin); err != nil {
|
||
gologx.Errorf("AGV 卸货超时扫描失败: %v", err)
|
||
}
|
||
}
|
||
}()
|
||
|
||
// 退料 AGV 自动派车扫描(2026-11-04 口径定稿):每 10 秒一轮,拉取 WMS「PENDING+运输方式=AGV+未派车」
|
||
// 退料单,传感器检测到退料接驳台有托盘且 JBT21 有空位才自动派车(JBT21 无空位等待,库管不点派车)。
|
||
// PLC 托盘传感器为被动读取,物理上必须轮询才能"检测到";每轮仅查未派退料单,开销极小。
|
||
go func() {
|
||
time.Sleep(15 * time.Second)
|
||
ticker := time.NewTicker(10 * time.Second)
|
||
defer ticker.Stop()
|
||
for range ticker.C {
|
||
bctx := context.Background()
|
||
if _, err := logic.New(ctx).AutoDispatchReturnAGV(bctx); err != nil {
|
||
gologx.Errorf("退料 AGV 自动派车扫描失败(WMS 不可达属正常): %v", err)
|
||
}
|
||
}
|
||
}()
|
||
|
||
fmt.Printf("Starting bj_power_mes server at %s:%d...\n", c.Host, c.Port)
|
||
gologx.Infof("Starting bj_power_mes server at %s:%d...", c.Host, c.Port)
|
||
|
||
// 启动后自动打开管理后台(等 1 秒让端口就绪;Host=0.0.0.0 时用 127.0.0.1 访问);
|
||
// 服务模式(Session 0 无交互桌面)跳过。
|
||
if !asService {
|
||
go func() {
|
||
time.Sleep(time.Second)
|
||
openBrowser(fmt.Sprintf("http://127.0.0.1:%d", c.Port))
|
||
}()
|
||
}
|
||
|
||
// HTTP 服务放到 goroutine。
|
||
go func() {
|
||
server.Start()
|
||
}()
|
||
|
||
if asService {
|
||
// 端口自检自愈(2026-11-11 拍板「一直存活」):服务卡死不退出时 SCM 恢复动作不会触发,
|
||
// 这里每 30s 自拨本机端口(等价于探活 HTTP accept loop),连续 3 次失败即主动退出,
|
||
// 交由 SCM 恢复动作 5s 内重启服务。
|
||
go func() {
|
||
time.Sleep(60 * time.Second) // 启动宽限
|
||
fails := 0
|
||
for range time.Tick(30 * time.Second) {
|
||
conn, err := net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", c.Port), 3*time.Second)
|
||
if err == nil {
|
||
conn.Close()
|
||
fails = 0
|
||
continue
|
||
}
|
||
fails++
|
||
gologx.Errorf("服务自检(127.0.0.1:%d)连续 %d 次失败: %v", c.Port, fails, err)
|
||
if fails >= 3 {
|
||
gologx.Errorf("服务自检连续失败,主动退出交由 SCM 自动重启服务")
|
||
os.Exit(2)
|
||
}
|
||
}
|
||
}()
|
||
// 服务模式:无交互桌面,托盘不可用;阻塞运行,由 mesServiceHandler.Execute
|
||
// 收到 SCM 停止/关机请求后结束进程。
|
||
select {}
|
||
}
|
||
|
||
// 系统托盘必须占住主 goroutine(Windows 消息循环要求)。
|
||
runtime.LockOSThread()
|
||
tray.Run("MES 产线控制", fmt.Sprintf("MES 产线控制 · 端口 %d", c.Port),
|
||
fmt.Sprintf("http://127.0.0.1:%d/", c.Port), func() {
|
||
server.Stop()
|
||
os.Exit(0)
|
||
})
|
||
}
|
||
|
||
// mesServiceName MES 注册的 Windows 服务名(autoRegisterService / runAsWindowsService 共用)
|
||
const mesServiceName = "bj_power_mes"
|
||
|
||
// autoRegisterService 管理员运行 exe 时自动注册为 Windows 服务(开机自启,2026-11-11 拍板):
|
||
// - 仅管理员(提权令牌)执行;非管理员打印提示后跳过,正常启动;
|
||
// - 服务已注册则跳过(幂等,不重复注册);
|
||
// - 服务名 bj_power_mes,路径=当前 exe 绝对路径,参数 serve,启动类型 AUTO_START;
|
||
// - 注册成功不启动服务,当前进程继续按前台/托盘方式运行。
|
||
func autoRegisterService() {
|
||
if runtime.GOOS != "windows" {
|
||
return
|
||
}
|
||
if !windows.GetCurrentProcessToken().IsElevated() {
|
||
fmt.Println("当前非管理员权限运行,跳过开机自启服务注册(如需自启,请以管理员身份运行一次本程序)。")
|
||
gologx.Infof("非管理员运行,跳过服务注册")
|
||
return
|
||
}
|
||
m, err := winmgr.Connect()
|
||
if err != nil {
|
||
gologx.Errorf("连接服务管理器失败,跳过服务注册: %v", err)
|
||
return
|
||
}
|
||
defer m.Disconnect()
|
||
if s, err := m.OpenService(mesServiceName); err == nil {
|
||
// 已注册:刷新 SCM 恢复动作(崩溃 5s 后自动重启,幂等)
|
||
_ = s.SetRecoveryActions([]winmgr.RecoveryAction{
|
||
{Type: winmgr.ServiceRestart, Delay: 5 * time.Second},
|
||
{Type: winmgr.ServiceRestart, Delay: 5 * time.Second},
|
||
{Type: winmgr.ServiceRestart, Delay: 5 * time.Second},
|
||
}, 86400)
|
||
_ = s.Close()
|
||
gologx.Infof("服务 %s 已注册,跳过重复注册", mesServiceName)
|
||
return
|
||
}
|
||
exePath, err := os.Executable()
|
||
if err != nil {
|
||
gologx.Errorf("获取 exe 路径失败,跳过服务注册: %v", err)
|
||
return
|
||
}
|
||
if realPath, rerr := filepath.EvalSymlinks(exePath); rerr == nil {
|
||
exePath = realPath
|
||
}
|
||
s, err := m.CreateService(mesServiceName, exePath, winmgr.Config{
|
||
StartType: winmgr.StartAutomatic,
|
||
DisplayName: "BJ Power MES 产线服务",
|
||
Description: "MES 产线控制服务(管理员首次运行时自动注册,开机自启)",
|
||
}, "serve")
|
||
if err != nil {
|
||
gologx.Errorf("注册 Windows 服务 %s 失败: %v", mesServiceName, err)
|
||
return
|
||
}
|
||
// SCM 恢复动作:服务进程任何失败退出 5 秒后自动重启(无限次)——崩溃自愈的兜底,
|
||
// 与 runServe 的端口自检自愈(卡死主动退出触发本动作)配合。
|
||
_ = s.SetRecoveryActions([]winmgr.RecoveryAction{
|
||
{Type: winmgr.ServiceRestart, Delay: 5 * time.Second},
|
||
{Type: winmgr.ServiceRestart, Delay: 5 * time.Second},
|
||
{Type: winmgr.ServiceRestart, Delay: 5 * time.Second},
|
||
}, 86400)
|
||
_ = s.Close()
|
||
gologx.Infof("已注册 Windows 服务 %s(自动启动+崩溃自动重启,路径 %s serve);当前进程继续以前台方式运行", mesServiceName, exePath)
|
||
}
|
||
|
||
// mesServiceHandler Windows 服务控制处理器:SCM 拉起后加载配置并跑 runServe,
|
||
// 收到停止/关机请求即结束(进程退出即服务停止,server 挂在同一进程无需优雅收尾)。
|
||
type mesServiceHandler struct {
|
||
cfgFile string
|
||
}
|
||
|
||
func (h *mesServiceHandler) Execute(args []string, r <-chan winsvc.ChangeRequest, s chan<- winsvc.Status) (bool, uint32) {
|
||
s <- winsvc.Status{State: winsvc.StartPending}
|
||
// SCM 启动目录为 System32:相对配置路径按 exe 所在目录解析
|
||
if !filepath.IsAbs(h.cfgFile) {
|
||
if exe, err := os.Executable(); err == nil {
|
||
h.cfgFile = filepath.Join(filepath.Dir(exe), h.cfgFile)
|
||
}
|
||
}
|
||
var c config.Config
|
||
conf.MustLoad(h.cfgFile, &c)
|
||
if c.Logger.Filename != "" {
|
||
logger := logx.NewLogger(c.Logger)
|
||
logx.SetDefault(logger)
|
||
gologx.SetWriter(logger)
|
||
}
|
||
logRuntimeBinaryFingerprint()
|
||
go runServe(c, true)
|
||
s <- winsvc.Status{State: winsvc.Running, Accepts: winsvc.AcceptStop | winsvc.AcceptShutdown}
|
||
for {
|
||
select {
|
||
case cr := <-r:
|
||
switch cr.Cmd {
|
||
case winsvc.Interrogate:
|
||
s <- cr.CurrentStatus
|
||
case winsvc.Stop, winsvc.Shutdown:
|
||
s <- winsvc.Status{State: winsvc.StopPending}
|
||
return false, 0
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// runAsWindowsService 以 Windows 服务模式运行(main 检测到 SCM 拉起时调用)。
|
||
func runAsWindowsService(cfgFile string) {
|
||
_ = winsvc.Run(mesServiceName, &mesServiceHandler{cfgFile: cfgFile})
|
||
}
|