Files
bj_power/bj_power_mes/bj_power_mes.go
T

969 lines
38 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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})
}