Files
bj_power/bj_power_wms/bj_power_wms.go
T
SunYF d92ca803d5 feat: 来料检处置项实体与复检、日排产达成对比、PLC/WMS 传输日志
- WMS 新增「检验处置项」实体(schema + ent 生成码),配套检验记录实体调整与复检接口,完善来料检/不良退货/入库检验前端
- MES 日排产:新增达成率统计与计划对比逻辑,调整日排产前端与流程卡/工序流
- 日志与传输:MES 新增 PLC 日志与 WMS 客户端传输日志,WMS 新增 MES 客户端传输日志
- MES 其他:扫码、工单/工件、AGV 客户端与告警、产品导入等逻辑完善及前端调整
- 工位终端:上线面板/作业面板、工件 handler 与 MES 客户端调整
- 配置与文档:更新 mes-api.yaml、三端构建产物与问题记录文档
2026-11-16 16:42:44 +08:00

788 lines
28 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_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)
})
}