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}) }