- WMS 新增「检验处置项」实体(schema + ent 生成码),配套检验记录实体调整与复检接口,完善来料检/不良退货/入库检验前端 - MES 日排产:新增达成率统计与计划对比逻辑,调整日排产前端与流程卡/工序流 - 日志与传输:MES 新增 PLC 日志与 WMS 客户端传输日志,WMS 新增 MES 客户端传输日志 - MES 其他:扫码、工单/工件、AGV 客户端与告警、产品导入等逻辑完善及前端调整 - 工位终端:上线面板/作业面板、工件 handler 与 MES 客户端调整 - 配置与文档:更新 mes-api.yaml、三端构建产物与问题记录文档
788 lines
28 KiB
Go
788 lines
28 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_wms/internal/config"
|
||
"bj_power_wms/internal/db"
|
||
"bj_power_wms/internal/eventlog"
|
||
"bj_power_wms/internal/handler"
|
||
"bj_power_wms/internal/logdaily"
|
||
"bj_power_wms/internal/mesclient"
|
||
"bj_power_wms/internal/scanbridge"
|
||
"bj_power_wms/internal/svc"
|
||
"bj_power_wms/internal/tray"
|
||
|
||
"golang.org/x/crypto/bcrypt"
|
||
"golang.org/x/sys/windows"
|
||
"bj_power_wms/ent/alert"
|
||
"bj_power_wms/ent/user"
|
||
"github.com/zeromicro/go-zero/core/conf"
|
||
"github.com/zeromicro/go-zero/core/logx"
|
||
"github.com/zeromicro/go-zero/rest"
|
||
)
|
||
|
||
// 前端静态资源(Vue 构建产物,由 frontend/ npm run build 输出到 web/static)。
|
||
// 原由 bj_power_wms_client(8891) 托管并反代 API,2026-09-07 合并进主服务:
|
||
// 一个 exe、一个端口(8890)同时提供页面与 API。
|
||
//
|
||
//go:embed all:web/static
|
||
var webFS embed.FS
|
||
|
||
var configFile = flag.String("f", "etc/bj_power_wms-api.yaml", "the config file")
|
||
|
||
// newStaticHandler 嵌入式静态文件:命中则直接返回;未命中的非 /api 路径
|
||
// 回退到 index.html(SPA history 路由),由浏览器端 Vue Router 接管。
|
||
func newStaticHandler(fsys embed.FS) http.Handler {
|
||
sub, err := fs.Sub(fsys, "web/static")
|
||
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(仅本机开发使用,服务器部署时 Web.OpenBrowser=false)
|
||
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)
|
||
}
|
||
_ = cmd.Start()
|
||
}
|
||
|
||
// 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 句柄,
|
||
// 已有控制台不重复处理,失败静默返回不阻断 CLI 流程(2026-11-11 修复,对齐 MES)。
|
||
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 修复,对齐 MES):GUI 子系统从 cmd/PowerShell 启动时 std 句柄常为
|
||
// 「继承来的死管道」(GetFileType 仍报 PIPE)。
|
||
// - stdin:非控制台一律重建 CONIN$;stdout/stderr:WriteFile 0 字节探活,死管道重建 CONOUT$。
|
||
consoleStd := func(h windows.Handle) bool {
|
||
var mode uint32
|
||
return h != 0 && windows.GetConsoleMode(h, &mode) == nil
|
||
}
|
||
rebind := func(std uint32, file **os.File, name string, conName string, access uint32, probe func(windows.Handle) bool) {
|
||
h, _ := windows.GetStdHandle(std)
|
||
if consoleStd(h) || (probe != nil && probe(h)) {
|
||
return
|
||
}
|
||
ch := openConsole(conName, access)
|
||
if ch == 0 {
|
||
return
|
||
}
|
||
_ = windows.SetStdHandle(std, ch)
|
||
*file = os.NewFile(uintptr(ch), name)
|
||
}
|
||
writeProbe := func(h windows.Handle) bool {
|
||
if h == 0 {
|
||
return false
|
||
}
|
||
var n uint32
|
||
return windows.WriteFile(h, nil, &n, nil) == nil
|
||
}
|
||
rebind(windows.STD_OUTPUT_HANDLE, &os.Stdout, "stdout", "CONOUT$", windows.GENERIC_WRITE|windows.GENERIC_READ, writeProbe)
|
||
rebind(windows.STD_ERROR_HANDLE, &os.Stderr, "stderr", "CONOUT$", windows.GENERIC_WRITE|windows.GENERIC_READ, writeProbe)
|
||
rebind(windows.STD_INPUT_HANDLE, &os.Stdin, "stdin", "CONIN$", windows.GENERIC_READ, nil)
|
||
}
|
||
|
||
// adminGate 敏感命令行操作(migrate/seed/reset-all)授权闸门(对齐 MES,2026-11-11 最终策略):
|
||
// 管理员权限运行免密放行(提权即授权,零交互);非管理员走 BJ_POWER_CLI_PASSWORD 或终端输入。
|
||
func adminGate(c config.Config) bool {
|
||
if runtime.GOOS == "windows" && windows.GetCurrentProcessToken().IsElevated() {
|
||
logx.Infof("敏感命令 [%s] 以管理员权限运行,免密放行", flag.Arg(0))
|
||
fmt.Println("以管理员权限运行,免密执行 [" + flag.Arg(0) + "]")
|
||
return true
|
||
}
|
||
pwd := cliPasswordArg()
|
||
if pwd == "" {
|
||
pwd = strings.TrimSpace(os.Getenv("BJ_POWER_CLI_PASSWORD"))
|
||
}
|
||
if pwd == "" {
|
||
pwd = promptPassword("请输入管理员密码以执行 [" + flag.Arg(0) + "]: ")
|
||
}
|
||
if subtle.ConstantTimeCompare([]byte(pwd), []byte(c.Cli.AdminPassword)) != 1 {
|
||
logx.Errorf("敏感命令 [%s] 因管理员密码校验失败被终止", flag.Arg(0))
|
||
fmt.Println("管理员密码不正确,已终止该操作。")
|
||
return false
|
||
}
|
||
logx.Infof("敏感命令 [%s] 已通过管理员密码校验", flag.Arg(0))
|
||
return true
|
||
}
|
||
|
||
// cliPasswordArg 解析子命令后的 -p/--password 参数(Go flag 只解析子命令前的参数)。
|
||
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 在终端里控制台输出可能不可见,敏感命令结果一律弹窗。
|
||
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
|
||
}
|
||
|
||
// dbConf 从服务配置构造数据库连接配置
|
||
func dbConf(c config.Config) db.DatabaseConf {
|
||
return db.DatabaseConf{
|
||
Host: c.Postgres.Host,
|
||
Port: c.Postgres.Port,
|
||
User: c.Postgres.User,
|
||
Password: c.Postgres.Password,
|
||
Dbname: c.Postgres.DBName,
|
||
}
|
||
}
|
||
|
||
// autoRegisterShortcuts 管理员运行 exe 时自动注册开机自启 + 桌面快捷方式(2026-11-11 拍板):
|
||
// WMS 依赖系统托盘与浏览器会话,不注册为 Windows 服务,走「公共启动文件夹 + 公共桌面」。
|
||
// 幂等:快捷方式已存在则跳过;非管理员跳过并提示,正常启动不影响业务。
|
||
func autoRegisterShortcuts(name, arguments string) {
|
||
if runtime.GOOS != "windows" {
|
||
return
|
||
}
|
||
if !windows.GetCurrentProcessToken().IsElevated() {
|
||
fmt.Println("当前非管理员权限运行,跳过开机自启/桌面快捷方式注册(如需自启,请以管理员身份运行一次本程序)。")
|
||
logx.Infof("非管理员运行,跳过自启动注册")
|
||
return
|
||
}
|
||
exe, err := os.Executable()
|
||
if err != nil {
|
||
logx.Errorf("获取 exe 路径失败,跳过自启动注册: %v", err)
|
||
return
|
||
}
|
||
if realPath, rerr := filepath.EvalSymlinks(exe); rerr == nil {
|
||
exe = realPath
|
||
}
|
||
workDir := filepath.Dir(exe)
|
||
startupDir := filepath.Join(os.Getenv("ProgramData"), "Microsoft", "Windows", "Start Menu", "Programs", "StartUp")
|
||
desktopDir := filepath.Join(os.Getenv("PUBLIC"), "Desktop")
|
||
targets := map[string]string{
|
||
filepath.Join(startupDir, name+".lnk"): "开机自启快捷方式",
|
||
filepath.Join(desktopDir, name+".lnk"): "桌面快捷方式",
|
||
}
|
||
for lnk, kind := range targets {
|
||
if _, err := os.Stat(lnk); err == nil {
|
||
logx.Infof("%s 已存在,跳过重复创建:%s", kind, lnk)
|
||
continue
|
||
}
|
||
if err := createShortcut(lnk, exe, arguments, workDir); err != nil {
|
||
logx.Errorf("创建%s失败 %s: %v", kind, lnk, err)
|
||
continue
|
||
}
|
||
logx.Infof("已创建%s:%s → %s %s", kind, lnk, exe, arguments)
|
||
}
|
||
}
|
||
|
||
// createShortcut 用 PowerShell(WScript.Shell COM)创建 .lnk 快捷方式(不引第三方依赖)。
|
||
// HideWindow 避免从 GUI 程序拉起 powershell 时闪黑框。
|
||
func createShortcut(linkPath, targetPath, arguments, workDir string) error {
|
||
script := fmt.Sprintf(
|
||
`$s=(New-Object -ComObject WScript.Shell).CreateShortcut('%s'); $s.TargetPath='%s'; $s.Arguments='%s'; $s.WorkingDirectory='%s'; $s.Save()`,
|
||
linkPath, targetPath, arguments, workDir)
|
||
cmd := exec.Command("powershell", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script)
|
||
cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
|
||
out, err := cmd.CombinedOutput()
|
||
if err != nil {
|
||
return fmt.Errorf("%v: %s", err, strings.TrimSpace(string(out)))
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// ==================== 进程守护(2026-11-11 拍板:三端 exe 常驻存活) ====================
|
||
// 双进程互守(同一 exe 自举):guardian(隐形监督进程)+ worker(业务进程)。
|
||
// - 启动先抢 Local\BJP_WMS_GUARDIAN 互斥体:抢到=guardian;抢不到=worker;
|
||
// - worker 持 Local\BJP_WMS_WORKER 互斥体(防重复实例),每 5s TCP 探活本机端口,
|
||
// 探活成功才写心跳文件 %TEMP%\bj_power_wms.guard.json(pid/ts/listening);
|
||
// - guardian:worker 退出码 0(托盘主动退出)→ 跟随退出;非 0(崩溃)→ 3s 后重拉;
|
||
// 心跳过期 30s(卡死)→ 校验进程映像后杀掉重拉;连续 5 次秒退 → 退避 60s;
|
||
// - worker 每 10s 检查 guardian 互斥体:消失 → 拉起新 guardian 继续监视自己(收养模式)。
|
||
const (
|
||
guardMutexName = `Local\BJP_WMS_GUARDIAN`
|
||
workerMutexName = `Local\BJP_WMS_WORKER`
|
||
guardHeartbeatTTL = 30 * time.Second
|
||
guardSpawnGrace = 90 * time.Second
|
||
)
|
||
|
||
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_wms.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_wms.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 探活本机端口,成功才写心跳文件。
|
||
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 {
|
||
time.Sleep(15 * time.Second) // 等新 guardian 就位(收养模式),防重复拉起
|
||
}
|
||
}
|
||
}
|
||
|
||
// 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 子进程并盯防:正常退出返回退出码;心跳异常则杀掉。
|
||
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 主循环。
|
||
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
|
||
guardianLoop(exe)
|
||
return
|
||
} else {
|
||
// 关键:未抢到 guardian 身份必须立即关闭观察句柄,否则 worker 会一直持有
|
||
// guardian 互斥体对象,guardian 死后自愈检测失效(2026-11-11 实测踩坑,对齐 MES)。
|
||
windows.CloseHandle(gm)
|
||
}
|
||
wm, workerOwned := createOwnedMutex(workerMutexName)
|
||
if !workerOwned {
|
||
return // 已有 worker 在运行,静默退出防重复实例
|
||
}
|
||
_ = wm
|
||
go workerWatchGuardian(exe)
|
||
go guardianHeartbeat(port)
|
||
guardianLog("worker 启动 pid=%d", os.Getpid())
|
||
runWorker()
|
||
}
|
||
|
||
// runMigrate 仅建表/补列(只增,不删任何数据)
|
||
func runMigrate(c config.Config) error {
|
||
dbc := dbConf(c)
|
||
if err := db.EnsureDB(dbc); err != nil {
|
||
logx.Errorf("ensure database failed: %v", err)
|
||
return fmt.Errorf("准备数据库失败:%v", err)
|
||
}
|
||
client := db.MustNewDB(dbc)
|
||
defer client.Close()
|
||
if err := db.AutoMigrate(client); err != nil {
|
||
logx.Errorf("migrate failed: %v", err)
|
||
return fmt.Errorf("结构迁移失败:%v", err)
|
||
}
|
||
fmt.Println("migrate: 数据库结构迁移成功(只增/补列,未删除任何数据)。")
|
||
return nil
|
||
}
|
||
|
||
// runSeed 对齐基础主数据 + 权限角色(不删数据;表不存在则先建)
|
||
func runSeed(c config.Config) error {
|
||
dbc := dbConf(c)
|
||
if err := db.EnsureDB(dbc); err != nil {
|
||
logx.Errorf("ensure database failed: %v", err)
|
||
return fmt.Errorf("准备数据库失败:%v", err)
|
||
}
|
||
client := db.MustNewDB(dbc)
|
||
defer client.Close()
|
||
if err := db.AutoMigrate(client); err != nil {
|
||
logx.Errorf("seed migrate failed: %v", err)
|
||
return fmt.Errorf("结构迁移失败:%v", err)
|
||
}
|
||
if err := db.SeedIfEmpty(client); err != nil {
|
||
logx.Errorf("seed failed: %v", err)
|
||
return fmt.Errorf("写入基础数据失败:%v", err)
|
||
}
|
||
svcCtx := &svc.ServiceContext{EntClient: client, EventLog: eventlog.NewWriter(client)}
|
||
p, r, b := handler.SeedRBAC(svcCtx, "system")
|
||
// 与 MES 对齐(2026-11-11):生产已有库的 admin 密码失忆时,跑 seed 即可重置回
|
||
// admin/123456——只重置 admin 账号本身,不动其他用户与任何业务数据(对齐 MES seed.go:79-87)。
|
||
adminHash, _ := bcrypt.GenerateFromPassword([]byte("123456"), bcrypt.DefaultCost)
|
||
if n, err := client.User.Update().Where(user.Username("admin")).SetPassword(string(adminHash)).Save(context.Background()); err != nil {
|
||
logx.Errorf("重置 admin 密码失败: %v", err)
|
||
} else if n > 0 {
|
||
fmt.Println("seed: 已重置 admin 账号密码为 123456(仅 admin 账号,不动业务数据)。")
|
||
}
|
||
logx.Infof("seed: 基础数据与权限已对齐(新增权限 %d、角色 %d、绑定用户 %d);管理员 admin/123456", p, r, b)
|
||
fmt.Printf("seed: 基础数据与权限已对齐(新增权限 %d、角色 %d、绑定用户 %d);管理员 admin/123456。\n", p, r, b)
|
||
return nil
|
||
}
|
||
|
||
// runResetAll 清空并重建全部表 + 重灌全部种子(基础主数据 + 权限角色)。此操作不可恢复!
|
||
func runResetAll(c config.Config) error {
|
||
dbc := dbConf(c)
|
||
if err := db.EnsureDB(dbc); err != nil {
|
||
logx.Errorf("ensure database failed: %v", err)
|
||
return fmt.Errorf("准备数据库失败:%v", err)
|
||
}
|
||
if err := db.DropAllTables(dbc); err != nil {
|
||
logx.Errorf("reset-all drop failed: %v", err)
|
||
return fmt.Errorf("删表失败:%v", err)
|
||
}
|
||
client := db.MustNewDB(dbc)
|
||
defer client.Close()
|
||
if err := db.AutoMigrate(client); err != nil {
|
||
logx.Errorf("reset-all migrate failed: %v", err)
|
||
return fmt.Errorf("重建表失败:%v", err)
|
||
}
|
||
if err := db.SeedIfEmpty(client); err != nil {
|
||
logx.Errorf("reset-all seed failed: %v", err)
|
||
return fmt.Errorf("写入基础数据失败:%v", err)
|
||
}
|
||
svcCtx := &svc.ServiceContext{EntClient: client, EventLog: eventlog.NewWriter(client)}
|
||
p, r, b := handler.SeedRBAC(svcCtx, "system")
|
||
logx.Infof("reset-all 完成:新增权限 %d、角色 %d、绑定用户 %d", p, r, b)
|
||
fmt.Println("reset-all: 已清空并重建全部表,写入基础主数据与权限(管理员 admin/123456)。")
|
||
return nil
|
||
}
|
||
|
||
// logRuntimeBinaryFingerprint 在启动早期打印当前运行 EXE 的指纹(真实路径/大小/MD5/修改时间),
|
||
// 走本项目 logx(go-zero)落盘,与业务日志同文件,便于生产机直接翻日志核对运行版本。
|
||
// 任何环节失败仅记错误日志并继续,绝不中断启动。
|
||
func logRuntimeBinaryFingerprint() {
|
||
exePath, err := os.Executable()
|
||
if err != nil {
|
||
logx.Errorf("svc: runtime binary fingerprint skipped: os.Executable failed: %v", err)
|
||
return
|
||
}
|
||
realPath, err := filepath.EvalSymlinks(exePath)
|
||
if err != nil {
|
||
// 解析软链接失败:降级用原始路径,仅记日志不影响启动
|
||
logx.Errorf("svc: runtime binary fingerprint: EvalSymlinks failed, fallback to raw path: %v", err)
|
||
realPath = exePath
|
||
}
|
||
info, err := os.Stat(realPath)
|
||
if err != nil {
|
||
logx.Errorf("svc: runtime binary fingerprint skipped: os.Stat failed: %v", err)
|
||
return
|
||
}
|
||
f, err := os.Open(realPath)
|
||
if err != nil {
|
||
logx.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 {
|
||
logx.Errorf("svc: runtime binary fingerprint skipped: read failed: %v", err)
|
||
return
|
||
}
|
||
logx.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()
|
||
|
||
var c config.Config
|
||
conf.MustLoad(*configFile, &c)
|
||
|
||
// 日志按天存储:logs/bj_power_wms-2026-01-02.log,保留 30 天
|
||
if c.Log.Mode == "file" {
|
||
logx.SetUp(c.Log)
|
||
w := logdaily.New(c.Log.Path, c.Name, 30)
|
||
defer w.Close()
|
||
logx.SetWriter(logx.NewWriter(w))
|
||
}
|
||
|
||
// 启动指纹:打印当前 EXE 真实路径/大小/MD5/修改时间,便于核对运行版本
|
||
logRuntimeBinaryFingerprint()
|
||
|
||
// 命令行子命令:DDL/删库/种子等敏感操作一律显式触发 + 管理员密码门禁,
|
||
// 绝不随服务启动自动执行(对齐 MES: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: 即将清空并重建 WMS 全部表,此操作不可恢复!")
|
||
if !adminGate(c) {
|
||
cliNotifyError("reset-all 未执行", "未通过管理员校验。\n\n任选一种方式重试:\n① 右键「以管理员身份运行」cmd\n② 带密码参数:bj_power_wms.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_wms.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 完成", "基础数据与权限已对齐;admin 密码已重置为 123456。")
|
||
return
|
||
case "migrate":
|
||
if !adminGate(c) {
|
||
cliNotifyError("migrate 未执行", "未通过管理员校验。\n\n任选一种方式重试:\n① 右键「以管理员身份运行」cmd\n② 带密码参数:bj_power_wms.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":
|
||
// 正常启动服务:管理员运行时先自注册开机自启 + 桌面快捷方式(见 autoRegisterShortcuts)
|
||
autoRegisterShortcuts("BJ Power WMS", "serve")
|
||
// 进程守护(2026-11-11 拍板):guardian+worker 双进程互守,崩溃/卡死自动拉起
|
||
runGuarded(func() { runServeWMS(c) }, c.Port)
|
||
return
|
||
default:
|
||
fmt.Println("未知命令: " + cmd + ";可用命令: migrate / seed / reset-all / serve")
|
||
os.Exit(1)
|
||
}
|
||
}
|
||
|
||
// runServeWMS 启动 WMS 服务 + 托盘(由 runGuarded 的 worker 调用)。
|
||
func runServeWMS(c config.Config) {
|
||
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))
|
||
defer server.Stop()
|
||
|
||
ctx := svc.NewServiceContext(c)
|
||
|
||
// MES 通讯失败预警(2026-11-16):WMS→MES 传输层失败(连不上/超时)触发,
|
||
// 10 分钟窗口去重防轮询风暴;HTTP 业务错误(服务在但拒绝)不算通讯异常、不触发。
|
||
mesclient.FailHook = func(hookCtx context.Context, method, url string, hookErr error) {
|
||
fc, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||
defer cancel()
|
||
since := time.Now().Add(-10 * time.Minute)
|
||
cnt, cerr := ctx.EntClient.Alert.Query().Where(
|
||
alert.RuleCodeEQ("mes_unreachable"),
|
||
alert.StatusEQ("unread"),
|
||
alert.TargetEQ("MES"),
|
||
alert.CreatedAtGTE(since.Unix()),
|
||
).Count(fc)
|
||
if cerr == nil && cnt > 0 {
|
||
return
|
||
}
|
||
_, aerr := ctx.EntClient.Alert.Create().
|
||
SetRuleCode("mes_unreachable").SetLevel("warning").SetTarget("MES").
|
||
SetTitle("MES 通讯失败:" + hookErr.Error()).
|
||
SetContent(fmt.Sprintf("WMS→MES %s %s(%v),备料回写/工单查询/成品反查将失败,请检查 MES 服务。", method, url, hookErr)).
|
||
SetStatus("unread").Save(fc)
|
||
if aerr != nil {
|
||
logx.Errorf("MES 通讯失败落预警异常: %v", aerr)
|
||
}
|
||
}
|
||
|
||
// 扫码中间件(键盘 HID 注入):Enable=true 时随 WMS 启动监听 7757,接收网络型扫码枪推送并模拟键盘注入当前光标窗口。
|
||
// 7757 被占用时仅记日志、不影响主程序(与 MES 同机同开时谁先启动谁监听,后到的只记日志)。
|
||
if c.Scanner.Enabled {
|
||
go func() {
|
||
if err := scanbridge.Start(context.Background(), scanbridge.Options{}); err != nil {
|
||
logx.Errorf("扫码中间件启动失败(不影响主程序): %v", err)
|
||
}
|
||
}()
|
||
}
|
||
|
||
handler.RegisterHandlers(server, ctx)
|
||
|
||
// 磁盘空间监控:每天 07:00 检测附件根目录剩余空间(<20% 告警、<10% 提示清理)
|
||
handler.StartDiskMonitor(ctx)
|
||
|
||
// 预警中心扫描器:立即跑一次,之后每 5 分钟一轮(后台协程,仅启动一次)
|
||
handler.StartAlertScanner(ctx)
|
||
|
||
fmt.Printf("Starting bj_power_wms server at %s:%d...\n", c.Host, c.Port)
|
||
logx.Infof("Starting bj_power_wms server at %s:%d...", c.Host, c.Port)
|
||
|
||
// 服务起来后自动打开浏览器访问前端(本机开发便利;Web.OpenBrowser=false 关闭)
|
||
if c.Web.OpenBrowser {
|
||
go func() {
|
||
time.Sleep(time.Second)
|
||
host := c.Host
|
||
if host == "0.0.0.0" || host == "" {
|
||
host = "127.0.0.1"
|
||
}
|
||
openBrowser(fmt.Sprintf("http://%s:%d", host, c.Port))
|
||
}()
|
||
}
|
||
|
||
// HTTP 服务放到 goroutine;系统托盘必须占住主 goroutine(Windows 消息循环要求)。
|
||
go func() {
|
||
server.Start()
|
||
}()
|
||
|
||
runtime.LockOSThread()
|
||
tray.Run("WMS 仓储管理", fmt.Sprintf("WMS 仓储管理 · 端口 %d", c.Port),
|
||
fmt.Sprintf("http://127.0.0.1:%d/", c.Port), func() {
|
||
server.Stop()
|
||
os.Exit(0)
|
||
})
|
||
}
|