Files
bj_power/bj_power_workstation/main.go
T

531 lines
19 KiB
Go
Raw Normal View History

2026-08-28 15:06:01 +08:00
package main
import (
"context"
2026-10-26 16:32:35 +08:00
"crypto/md5"
2026-08-28 15:06:01 +08:00
"embed"
2026-10-26 16:32:35 +08:00
"encoding/hex"
"encoding/json"
2026-08-28 15:06:01 +08:00
"flag"
"fmt"
2026-10-26 16:32:35 +08:00
"io"
2026-08-28 15:06:01 +08:00
"io/fs"
"net"
2026-10-26 16:32:35 +08:00
"os"
"os/exec"
2026-10-26 16:32:35 +08:00
"path/filepath"
"runtime"
"strings"
"syscall"
"time"
2026-08-28 15:06:01 +08:00
"golang.org/x/sys/windows"
"bj_power_workstation/internal/alertstream"
"bj_power_workstation/internal/auth"
2026-08-28 15:06:01 +08:00
"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"
2026-08-28 15:06:01 +08:00
"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)
}
}
2026-10-26 16:32:35 +08:00
// 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()
}
2026-08-28 15:06:01 +08:00
func main() {
flag.Parse()
var c config.Config
conf.MustLoad(*configFile, &c)
2026-10-26 16:32:35 +08:00
// 启动指纹:打印当前 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)
2026-08-28 15:06:01 +08:00
staticFS, err := fs.Sub(webFS, "web/static")
if err != nil {
panic(fmt.Sprintf("加载内嵌前端资源失败: %v", err))
}
// 本地 SQLite:操作日志 + 内置账号 + 登录态(2026-11-05 拍板:断网即失败,无离线队列/重试缓存)
2026-08-28 15:06:01 +08:00
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) }
2026-08-28 15:06:01 +08:00
// 核实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)
}
}
}
}()
2026-08-28 15:06:01 +08:00
// 拧紧枪 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)
}
}()
}
2026-08-28 15:06:01 +08:00
// 工艺文件 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-08-28 15:06:01 +08:00
}
// 在线态校验(多会话版,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)
}
2026-08-28 15:06:01 +08:00
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)
})
}