Files
bj_power/bj_power_workstation/main.go
T
SunYF 7e8066ab66 feat: 同步失败(SyncFailure)实体化与 ent 全量重生成
- 新增 SyncFailure 实体:MES/WMS 两端 schema 源 + ent 生成码(create/delete/query/update 及子包)
- ent 框架文件全量重生成:client/ent/hook/migrate/mutation/predicate/runtime/tx
- 清理旧代码生成入口:删除 schema/gen.go 与 schema/tools/generate.go
- 同步失败页面调整:MES/WMS SyncFailure.vue 接入新实体,MES 产品工艺页同步调整
- 主程序入口注册新实体:bj_power_mes.go / bj_power_wms.go,工作站 main.go 同步调整
- 更新文档:WMS README、案例、问题记录;刷新 MES/WMS 前端构建产物
2026-11-12 15:52:51 +08:00

531 lines
19 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 (
"context"
"crypto/md5"
"embed"
"encoding/hex"
"encoding/json"
"flag"
"fmt"
"io"
"io/fs"
"net"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"syscall"
"time"
"golang.org/x/sys/windows"
"bj_power_workstation/internal/alertstream"
"bj_power_workstation/internal/auth"
"bj_power_workstation/internal/config"
"bj_power_workstation/internal/handler"
"bj_power_workstation/internal/mes"
"bj_power_workstation/internal/pdfcache"
"bj_power_workstation/internal/store"
"bj_power_workstation/internal/svc"
"bj_power_workstation/internal/tightening"
"bj_power_workstation/internal/tray"
"bj_power_workstation/internal/scanbridge"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest"
)
//go:embed all:web/static
var webFS embed.FS
var configFile = flag.String("f", "etc/bj_power_workstation.yaml", "the config file")
// 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 {
logx.Errorf("自动打开浏览器失败(%s): %v", url, err)
}
}
// 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"))
}
// autoRegisterShortcuts 管理员运行 exe 时自动注册开机自启 + 桌面快捷方式(2026-11-11 拍板):
// 工位终端有系统托盘、需要桌面会话,不注册为 Windows 服务,走「公共启动文件夹 + 公共桌面」。
// 幂等:快捷方式已存在则跳过;非管理员跳过并提示,正常启动不影响业务。
func autoRegisterShortcuts(name 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, "", workDir); err != nil {
logx.Errorf("创建%s失败 %s: %v", kind, lnk, err)
continue
}
logx.Infof("已创建%s:%s → %s", kind, lnk, exe)
}
}
// 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_WS_GUARDIAN 互斥体:抢到=guardian;抢不到=worker;
// - worker 持 Local\BJP_WS_WORKER 互斥体(防重复实例),每 5s TCP 探活本机端口,
// 探活成功才写心跳文件 %TEMP%\bj_power_workstation.guard.json(pid/ts/listening);
// - guardian:worker 退出码 0(托盘主动退出)→ 跟随退出;非 0(崩溃)→ 3s 后重拉;
// 心跳过期 30s(卡死)→ 校验进程映像后杀掉重拉;连续 5 次秒退 → 退避 60s;
// - worker 每 10s 检查 guardian 互斥体:消失 → 拉起新 guardian 继续监视自己(收养模式)。
const (
guardMutexName = `Local\BJP_WS_GUARDIAN`
workerMutexName = `Local\BJP_WS_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_workstation.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_workstation.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()
}
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
// 启动指纹:打印当前 EXE 真实路径/大小/MD5/修改时间,便于核对运行版本
logRuntimeBinaryFingerprint()
// 管理员运行时自动注册开机自启 + 桌面快捷方式(2026-11-11 拍板;非管理员跳过不影响启动)
autoRegisterShortcuts("工位终端")
// 进程守护(2026-11-11 拍板「一直存活」):guardian+worker 双进程互守,崩溃/卡死自动拉起
runGuarded(func() { runServeWS(c) }, c.Port)
}
// runServeWS 启动终端服务 + 托盘(由 runGuarded 的 worker 调用)。
func runServeWS(c config.Config) {
// 工位号:由服务端配置文件加载(终端不允许修改)。0=上线位、13=下线位为虚拟工位
// (PAD 上线建档 / 下线完工),1~12 为物理装配工位;启动时强校验 >= 0(工位数以数据库/配置为准,不写死 12)。
if c.Station.StationNo < 0 {
panic(fmt.Sprintf("Station.StationNo 必须 >= 0,当前配置为 %d(请修改 yaml 后重启)", c.Station.StationNo))
}
logx.Infof("固定工位号: %d", c.Station.StationNo)
staticFS, err := fs.Sub(webFS, "web/static")
if err != nil {
panic(fmt.Sprintf("加载内嵌前端资源失败: %v", err))
}
// 本地 SQLite:操作日志 + 内置账号 + 登录态(2026-11-05 拍板:断网即失败,无离线队列/重试缓存)
st, err := store.Open(c.Sqlite.Path)
if err != nil {
panic(fmt.Sprintf("打开本地 SQLite(%s) 失败: %v", c.Sqlite.Path, err))
}
defer st.Close()
if err := store.SeedIfEmpty(st); err != nil {
panic(fmt.Sprintf("初始化内置用户失败: %v", err))
}
rootCtx, cancel := context.WithCancel(context.Background())
defer cancel()
mc := mes.New(c.Mes.BaseURL, c.Internal.Token)
// 核实4(多会话版):绑定空闲计时回调——每次以有效登录态发起的 MES 调用按其 Bearer
// 刷新对应会话的 last_active_at,证明当前操作人仍活跃在岗,后台 sweeper 逐会话判断超时。
mc.Touch = func(bearer string) { _ = st.TouchSessionByToken(bearer) }
// 核实4(多会话版):空闲自动登出 sweeper——周期性逐会话检查空闲时长,超过 IdleLogoutSeconds
// 则删除该会话行,该用户下一次请求即被 401 踢下线;其他工位会话不受影响。
go func() {
ticker := time.NewTicker(60 * time.Second)
defer ticker.Stop()
for {
select {
case <-rootCtx.Done():
return
case <-ticker.C:
cleared, err := st.ClearExpiredSessions(c.Station.IdleLogoutSeconds)
if err != nil {
logx.Errorf("检查工位登录态空闲超时失败: %v", err)
continue
}
for _, ss := range cleared {
logx.Infof("工位%d 会话(%s/%s)空闲超过 %d 秒,已自动登出",
ss.StationNo, ss.Username, ss.Name, c.Station.IdleLogoutSeconds)
}
}
}
}()
// 拧紧枪 OP 接入(阿特拉斯 Open Protocol):Enable=true 时后台长连接控制器,接收拧紧结果暂存,
// 操作工在界面点「完成」才经 POST /api/tightening/record 实时直连上报 MES(断网即失败报错);Enable=false 时仍走人工录入。
tm := tightening.NewManager(c.Tightening)
go tm.Run(rootCtx)
// 拧紧枪配置快照上报 MES(2026-11-09):只用于 MES「拧紧枪配置」页展示本终端 yaml 里配了什么,
// 不下发控制指令、不改变本终端控制器连接与拧紧数据采集;best-effort,失败只记日志、不影响终端启动。
// 登录时还会补报一次(auth.go),防终端启动时 MES 未就绪导致配置显示不出来。
if c.Station.StationNo > 0 {
go func() {
time.Sleep(3 * time.Second) // 等 MES 就绪,不阻塞本终端启动
if err := mc.ReportTighteningConfig(c.Tightening, c.Station.StationNo); err != nil {
logx.Infof("拧紧枪配置上报 MES 失败(仅展示记录,不影响本终端): %v", err)
}
}()
}
// 工位报警事件流(谁受影响谁播报,2026-10-20;多会话版 2026-11-11):长连接 MES SSE,
// 按每个前端订阅方自带的工位号过滤后分发(一台终端实例可同时服务多个虚拟工位会话);
// 断线自动重连;前端 EventSource 订阅 /api/alerts/stream?stationNo=N,断线重连后一次性补拉 /api/alerts/station。
am := alertstream.New(mc)
go am.Run(rootCtx)
// 扫码中间件(键盘 HID 注入):Enable=true 时后台监听 7757,接收网络型扫码枪(iData PAD / 新大陆手机)
// 推送并模拟键盘注入当前光标窗口(任意输入框自动填入,前端无需轮询)。7757 被占用时仅记日志、不影响主程序。
if c.Scanner.Enabled {
go func() {
if err := scanbridge.Start(rootCtx, scanbridge.Options{Addrs: c.Scanner.Addrs}); err != nil {
logx.Errorf("扫码中间件启动失败(不影响主程序): %v", err)
}
}()
}
// 工艺文件 PDF 本地预缓存
pdc := pdfcache.New(c.PdfCache.Dir)
ctx := &svc.ServiceContext{
Config: c,
Store: st,
Mes: mc,
PdfCache: pdc,
WebFS: staticFS,
Tightening: tm,
AlertStream: am,
}
// 在线态校验(多会话版,2026-11-11):请求 token 必须存在于任一登录会话;
// 同工位被新登录踢掉 / 空闲超时清掉后,旧 token 下一次请求即被判为「登录已失效」。
// 滑动续签重签 token 时按旧 token 定位会话同步写回,避免续签后前后端 token 不一致被误判。
auth.SessionValidator = func(token string) bool {
ok, err := st.HasSessionToken(token)
return err == nil && ok
}
auth.SessionTokenSync = func(oldToken, newToken string) {
_ = st.UpdateSessionTokenByToken(oldToken, newToken)
}
server := rest.MustNewServer(c.RestConf)
defer server.Stop()
handler.RegisterHandlers(server, ctx)
fmt.Printf("Starting bj_power_workstation server at %s:%d...\n", c.Host, c.Port)
logx.Infof("Starting bj_power_workstation server at %s:%d...", c.Host, c.Port)
// 启动后自动打开终端页面(等 1 秒让端口就绪;Host=0.0.0.0 时用 127.0.0.1 访问)
go func() {
time.Sleep(time.Second)
openBrowser(fmt.Sprintf("http://127.0.0.1:%d", c.Port))
}()
// HTTP 服务放到 goroutine;系统托盘必须占住主 goroutine(Windows 消息循环要求)。
go func() {
server.Start()
}()
runtime.LockOSThread()
tray.Run("工位终端", fmt.Sprintf("工位终端 · 端口 %d", c.Port),
fmt.Sprintf("http://127.0.0.1:%d/", c.Port), func() {
server.Stop()
os.Exit(0)
})
}