Files
bj_power/bj_power_workstation/internal/syncer/syncer.go
T

266 lines
9.4 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 syncer
import (
"context"
"encoding/json"
"errors"
"strings"
"time"
"bj_power_workstation/internal/mes"
"bj_power_workstation/internal/store"
"github.com/zeromicro/go-zero/core/logx"
)
const (
reportBatchLimit = 200 // 单轮最多处理条数
defaultInterval = 15 * time.Second
// maxQueueRetry / maxTorqueRetry 重试上报上限:超过该次数不再累加 retry_count、不再刷错误日志,
// 但仍在每轮继续尝试发送(失败数据留本地等待人工/网络恢复处理,不丢弃、不删除)。
maxQueueRetry = 10
maxTorqueRetry = 10
// defaultBacklogWarnThreshold 待上报积压告警默认阈值(建议1:可由 config.Backlog.WarnThreshold 覆盖)。
defaultBacklogWarnThreshold = 50
// localRetentionSec 本地数据保留时长(30 天):超过该时长的离线数据由后台定时清理。
localRetentionSec = 30 * 24 * 3600
)
// Syncer 后台同步器:每 15 秒把「当前登录人」未同步的 report_queue 与 torque_results 上报 MES。
// 设计原则(2026-10-06 简化):操作工手动点发送 → 用当前登录这人的身份 → 发不出去就是发不出去
// (报错、留在本地 SQLite 等人处理),绝不由系统自动决定「等下次有人登录自动补传」。
// 数据按 operator_id 隔离:仅当前登录人自己的未同步数据会被发送;其他人录入的数据静默保留,
// 不被别人代发,也不对别人可见;同一人重登后可继续发送 / 仅展示失败。
type Syncer struct {
st *store.Store
mes *mes.Client
interval time.Duration
// backlogWarnThreshold 待上报积压告警阈值(建议1):队列+拧紧未同步合计超过该值打 WARN;
// 可由 SetBacklogThreshold 从配置注入,<=0 回退默认 50。
backlogWarnThreshold int
}
// SetBacklogThreshold 从配置注入积压告警阈值(建议1);n<=0 不改(保留默认 50)。
func (s *Syncer) SetBacklogThreshold(n int) {
if n > 0 {
s.backlogWarnThreshold = n
}
}
func New(st *store.Store, mc *mes.Client) *Syncer {
return &Syncer{st: st, mes: mc, interval: defaultInterval, backlogWarnThreshold: defaultBacklogWarnThreshold}
}
// Run 周期冲刷循环,随 ctx 取消退出。
func (s *Syncer) Run(ctx context.Context) {
logx.Infof("后台同步协程已启动:每 %s 冲刷一次未上报数据", s.interval)
ticker := time.NewTicker(s.interval)
defer ticker.Stop()
cleanTicker := time.NewTicker(time.Hour)
defer cleanTicker.Stop()
for {
select {
case <-ctx.Done():
logx.Info("后台同步协程已停止")
return
case <-ticker.C:
if n := s.RunOnce(ctx); n > 0 {
logx.Infof("本轮同步成功 %d 条", n)
}
case <-cleanTicker.C:
if deleted, err := s.st.CleanupOld(localRetentionSec); err != nil {
logx.Errorf("清理本地过期数据失败: %v", err)
} else if deleted > 0 {
logx.Infof("已清理本地 %d 条超过 30 天的离线数据", deleted)
}
}
}
}
// RunOnce 立即执行一轮同步(先队列后拧紧结果),返回本次成功条数。
func (s *Syncer) RunOnce(ctx context.Context) int {
n := s.flushQueue(ctx)
n += s.flushTorque(ctx)
// 积压监控(建议1):待上报总量超阈值打 WARN,供日志采集/告警。
// 区分两类积压,输出固定可匹配的日志标记(BACKLOG_ALERT_IDENTITY / BACKLOG_ALERT_NETWORK):
// - IDENTITY:当前未登录 → 数据等待当前操作人登录后继续发送(可恢复,不阻断产线);
// - NETWORK:已登录仍堆积 → 疑似 MES 网络/业务拒绝,需排查 MES 连通性与返回。
if qc, err := s.st.PendingQueueCount(); err == nil {
if tc, err2 := s.st.PendingTorqueCount(); err2 == nil {
if total := qc + tc; total > int64(s.backlogWarnThreshold) {
hasSession := false
if ss, e := s.st.GetStationSession(); e == nil && ss != nil && ss.Token != "" {
if ss.ExpireAt <= 0 || time.Now().Unix() < ss.ExpireAt {
hasSession = true
}
}
if hasSession {
logx.Errorf("BACKLOG_ALERT_NETWORK 离线队列积压 %d 条(队列 %d / 拧紧 %d):存在有效登录态仍堆积,疑似 MES 网络或业务拒绝,请检查 MES 连通性与业务返回", total, qc, tc)
} else {
logx.Errorf("BACKLOG_ALERT_IDENTITY 离线队列积压 %d 条(队列 %d / 拧紧 %d):当前未登录,等待当前操作人登录后继续发送", total, qc, tc)
}
}
}
}
return n
}
// currentSession 取当前有效的在岗登录态;无登录态或凭证已过期返回 nil。
func (s *Syncer) currentSession() *store.StationSession {
ss, err := s.st.GetStationSession()
if err != nil || ss == nil || ss.Token == "" {
return nil
}
if ss.ExpireAt > 0 && time.Now().Unix() >= ss.ExpireAt {
return nil
}
return ss
}
// flushTorque 上报「当前登录人」未同步拧紧结果:POST /api/internal/torque/report;
// 成功标记 synced=1,失败保持 0 等待下轮重试(同一登录人重登后续发)。
func (s *Syncer) flushTorque(ctx context.Context) int {
ss := s.currentSession()
if ss == nil {
return 0
}
rows, err := s.st.PendingTorqueResultsForOperator(ss.UserID, reportBatchLimit)
if err != nil {
logx.Errorf("查询未同步拧紧结果失败: %v", err)
return 0
}
var done []int64
count := 0
for _, t := range rows {
select {
case <-ctx.Done():
return count
default:
}
// MES 内部接口以 stationNo(数字工位号)落库,并据此做应拧/实拧分组统计;
// 本地存的是 DOCK 编码(DOCK01 ↔ 工位1),上报前换算为工位号。
stationNo := strings.TrimLeft(strings.TrimPrefix(t.DockCode, "DOCK"), "0")
if stationNo == "" {
stationNo = "0"
}
body := map[string]any{
"workOrderNo": t.WorkOrderNo,
"sn": t.Sn,
"dockCode": t.DockCode,
"stationNo": stationNo,
"screwNo": t.ScrewNo,
"torque": t.Torque,
"angle": t.Angle,
"result": t.Result,
"operator": t.Operator,
}
// 用当前登录态(即当前在岗操作人)的身份发送,失败即留本地。
if _, _, err := s.mes.Post("/api/internal/torque/report", body); err != nil {
if errors.Is(err, mes.ErrAuth) {
// 当前登录态失效(理论上 currentSession 已拦截):跳过,等待重新登录后续传。
continue
}
var bizErr *mes.BizError
if errors.As(err, &bizErr) {
// MES 业务拒绝:数据本身不合法,重传不可能成功 → 标记死信(synced=2)停止重传
logx.Errorf("拧紧结果被 MES 拒绝已死信(id=%d sn=%s): %v", t.ID, t.Sn, err)
_ = s.st.MarkTorqueDead(t.ID)
continue
}
logx.Errorf("上报拧紧结果失败(id=%d sn=%s 第 %d 次): %v", t.ID, t.Sn, t.RetryCount+1, err)
if t.RetryCount+1 < maxTorqueRetry {
_ = s.st.BumpTorqueRetry(t.ID)
}
continue
}
done = append(done, t.ID)
count++
}
if len(done) > 0 {
if err := s.st.MarkTorqueSynced(done); err != nil {
logx.Errorf("标记拧紧结果已同步失败: %v", err)
}
}
return count
}
// flushQueue 上报「当前登录人」未同步的离线缓存队列,payload 原样透传:
// - kind=process_done → POST /api/internal/station/report
// - kind=temp_store → POST /api/internal/station/checkin
// - kind=online_register → POST /api/internal/workpiece/online(上线建档)
// - kind=offline_finish → POST /api/internal/workpiece/done(下线完工入库)
//
// 每条使用当前在岗登录态 JWT 发送;成功标记 synced=1;失败 synced 保持 0 并累计 retry_count,
// 留本地等待同一操作人重新登录后续传或人工排查。仅发送「当前登录人自己」的数据,他人数据不被代发。
func (s *Syncer) flushQueue(ctx context.Context) int {
ss := s.currentSession()
if ss == nil {
return 0
}
items, err := s.st.PendingQueueItemsForOperator(ss.UserID, reportBatchLimit)
if err != nil {
logx.Errorf("查询待上报队列失败: %v", err)
return 0
}
count := 0
for _, it := range items {
select {
case <-ctx.Done():
return count
default:
}
var path string
switch it.Kind {
case "process_done":
path = "/api/internal/station/report"
case "temp_store":
path = "/api/internal/station/checkin"
case "online_register":
path = "/api/internal/workpiece/online"
case "offline_finish":
path = "/api/internal/workpiece/done"
default:
logx.Errorf("未知队列类型(kind=%s id=%d),跳过", it.Kind, it.ID)
_ = s.st.BumpQueueRetry(it.ID)
continue
}
if _, _, err := s.mes.Post(path, json.RawMessage(it.Payload)); err != nil {
if errors.Is(err, mes.ErrAuth) {
continue
}
var bizErr *mes.BizError
if errors.As(err, &bizErr) {
// MES 业务拒绝:数据本身不合法,重传不可能成功 → 标记死信(synced=2)停止自动重传,
// 失败原因落 last_error 供「重传处理」查看(如「工件位置 END-U 已被工件 xxx 占用」)。
reason := strings.TrimSpace(bizErr.Message)
if reason == "" {
reason = err.Error()
}
logx.Errorf("队列条目被 MES 拒绝已死信(kind=%s id=%d): %v", it.Kind, it.ID, err)
_ = s.st.MarkQueueDead(it.ID, reason)
continue
}
logx.Errorf("上报队列失败(kind=%s id=%d 第 %d 次): %v", it.Kind, it.ID, it.RetryCount+1, err)
if it.RetryCount+1 < maxQueueRetry {
_ = s.st.BumpQueueRetry(it.ID)
}
continue
}
if err := s.st.MarkQueueSynced(it.ID); err != nil {
logx.Errorf("标记队列已同步失败(id=%d): %v", it.ID, err)
continue
}
count++
}
return count
}