Files

855 lines
28 KiB
Go
Raw Permalink 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 backup 实现「备份到外部存储(U盘/移动硬盘)」与「按时间窗物理清理」两大能力。
//
// 设计要点:
// - 备份:时间窗 [start,end](end ≤ 昨天);按各表 created_at 导出(MES 为 tz-time,
// 统一在窗口层转成 time.Time);附件按 DB 记录的 filePath 取磁盘文件;zip 流式直写
// 目标路径(不落本地临时文件);包内含 manifest.json + index.html(不内嵌预览)。
// - 清理:先校验 backup_record 对该时间窗的完整覆盖(部分/无覆盖一律拒绝并列出缺失段);
// 再物理 DELETE 日志表、物理删除附件文件 + DELETE 记录;各端附件文件由各端独占写入与引用
// (UUID 文件名,物料同步不含附件),不存在跨系统共享文件,清理不依赖对端服务;
// 清理动作本身写一条 event_log。
// - 不做软删、不引入任何删除/归档标记列(deleted 仅承载界面删除留痕,归档概念已废弃)。
package backup
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"os"
"path/filepath"
"sort"
"strings"
"sync"
"time"
"bj_power_mes/ent"
"bj_power_mes/ent/alert"
"bj_power_mes/ent/attachment"
backuprecord "bj_power_mes/ent/backuprecord"
"bj_power_mes/ent/eventlog"
"bj_power_mes/ent/plcsendlog"
"bj_power_mes/ent/workpiecelifecyclelog"
evlog "bj_power_mes/internal/eventlog"
"golang.org/x/sys/windows"
)
// ItemDef 可选备份/清理数据项(质量 4 表有意不出现)。
type ItemDef struct {
Key string `json:"key"`
Name string `json:"name"`
Desc string `json:"desc"` // 业务说明(index.html 与前端展示用)
Kind string `json:"kind"` // log | attachment
}
// MESItems MES 端可选数据项(event_log/plc_send_log/workpiece_lifecycle_log/alert/attachment)。
var MESItems = []ItemDef{
{Key: "event_log", Name: "操作日志", Kind: "log",
Desc: "系统操作日志:记录用户登录及工单/设备/参数等操作流水,用于安全审计与责任追溯。"},
{Key: "plc_send_log", Name: "PLC下发日志", Kind: "log",
Desc: "PLC 下发指令流水:记录系统向 PLC/设备下发的每条指令与执行结果,用于设备动作追溯。"},
{Key: "workpiece_lifecycle_log", Name: "工件生命周期日志", Kind: "log",
Desc: "工件生命周期日志:记录工件从上线到下线在各工位的流转事件,用于生产过程追溯。"},
{Key: "alert", Name: "预警消息", Kind: "log",
Desc: "预警消息:设备与生产过程产生的异常、预警记录,用于问题回溯分析。"},
{Key: "attachment", Name: "业务附件", Kind: "attachment",
Desc: "业务附件:工单/检验等上传的图片与文档,按原始相对路径存放在包内 attachments/ 目录。"},
}
// BackupRequest 备份请求。
type BackupRequest struct {
TargetPath string `json:"targetPath"` // 服务端绝对目录(U盘/移动硬盘挂载点)
Start int64 `json:"start"` // unix 秒(含)
End int64 `json:"end"` // unix 秒(含,≤ 昨天结束)
Items []string `json:"items"` // 数据项 key
Operator string `json:"operator"`
}
// CleanupRequest 清理请求。
// Mode: ""=整窗清理(须完整备份覆盖);"covered"=仅清理已覆盖段(未备份段保留)。
// Force=true 时无视覆盖直接整窗清理,须填写 AckName/AckPhone 留痕(警示用)。
type CleanupRequest struct {
Start int64 `json:"start"`
End int64 `json:"end"`
Items []string `json:"items"`
Operator string `json:"operator"`
Mode string `json:"mode"`
Force bool `json:"force"`
AckName string `json:"ackName"`
AckPhone string `json:"ackPhone"`
}
// ItemResult 单项导出结果。
type ItemResult struct {
Name string `json:"name"`
Key string `json:"key"`
Rows int64 `json:"rows"`
Bytes int64 `json:"bytes"`
}
// BackupResult 备份结果。
type BackupResult struct {
BackupPath string `json:"backupPath"`
TotalSize int64 `json:"totalSize"`
Checksum string `json:"checksum"`
Items []ItemResult `json:"items"`
}
// CleanupResult 清理结果。
type CleanupResult struct {
RangeStart int64 `json:"rangeStart"`
RangeEnd int64 `json:"rangeEnd"`
Deleted []ItemResult `json:"deleted"`
Skipped []ItemResult `json:"skipped"` // 删除失败(文件被占用等)跳过的记录
}
// MissingSeg 缺失时间段。
type MissingSeg struct {
Start int64 `json:"start"`
End int64 `json:"end"`
}
// CoverageRecord 覆盖该时间窗的备份记录(供前端覆盖地图展示)。
type CoverageRecord struct {
ID int `json:"id"`
ExecutedAt int64 `json:"executedAt"`
RangeStart int64 `json:"rangeStart"`
RangeEnd int64 `json:"rangeEnd"`
BackupPath string `json:"backupPath"`
Operator string `json:"operator"`
TotalSize int64 `json:"totalSize"`
}
// CoverageResult 覆盖校验结果(Covered=已覆盖段,Missing=缺失段,Records=覆盖本窗的备份记录)。
type CoverageResult struct {
OK bool `json:"ok"`
Covered []MissingSeg `json:"covered"`
Missing []MissingSeg `json:"missing"`
Records []CoverageRecord `json:"records"`
}
// Progress 任务进度。
type Progress struct {
JobID string `json:"jobId"`
Phase string `json:"phase"` // backup | cleanup
Stage string `json:"stage"`
Percent int `json:"percent"`
Message string `json:"message"`
Done bool `json:"done"`
Failed bool `json:"failed"`
Result any `json:"result,omitempty"`
}
// Service 备份/清理服务。
type Service struct {
client *ent.Client
ev *evlog.Writer
attRoot string
mu sync.Mutex
jobs map[string]*Progress
}
// New 构造服务。
func New(client *ent.Client, ev *evlog.Writer, attRoot string) *Service {
return &Service{
client: client,
ev: ev,
attRoot: attRoot,
jobs: make(map[string]*Progress),
}
}
// ListItems 返回可选数据项。
func (s *Service) ListItems() []ItemDef { return MESItems }
// ---------------- 备份 ----------------
// StartBackup 启动异步备份,返回 jobID。
func (s *Service) StartBackup(req BackupRequest) (string, error) {
if strings.TrimSpace(req.TargetPath) == "" {
return "", fmt.Errorf("请选择备份目标路径")
}
if !filepath.IsAbs(req.TargetPath) {
return "", fmt.Errorf("备份目标路径必须为绝对路径")
}
if req.End <= req.Start {
return "", fmt.Errorf("时间窗不合法(结束须晚于开始)")
}
if len(req.Items) == 0 {
return "", fmt.Errorf("请至少选择一个数据项")
}
jobID := newJobID()
s.mu.Lock()
s.jobs[jobID] = &Progress{JobID: jobID, Phase: "backup", Stage: "preparing", Percent: 0}
s.mu.Unlock()
go s.runBackup(jobID, req)
return jobID, nil
}
func (s *Service) runBackup(jobID string, req BackupRequest) {
ctx := context.Background()
tStart := time.Unix(req.Start, 0)
tEnd := time.Unix(req.End, 0)
setStage := func(stage string, pct int, msg string) {
s.mu.Lock()
if j, ok := s.jobs[jobID]; ok {
j.Stage, j.Percent, j.Message = stage, pct, msg
}
s.mu.Unlock()
}
// 估算体积并检查目标盘剩余空间
est, err := s.estimateBytes(ctx, req)
if err != nil {
s.failBackup(jobID, req, err)
return
}
free, derr := diskFree(req.TargetPath)
if derr == nil && free < uint64(est) {
need := est - int64(free)
s.failBackup(jobID, req, fmt.Errorf("目标盘空间不足:需要约 %s,当前剩余 %s(还差 %s)",
humanBytes(est), humanBytes(int64(free)), humanBytes(need)))
return
}
setStage("writing", 5, "准备写入备份包…")
stamp := time.Now().Format("20060102_150405")
zipPath := filepath.Join(req.TargetPath, "backup_mes_"+stamp+".zip")
if err := os.MkdirAll(req.TargetPath, 0o755); err != nil {
s.failBackup(jobID, req, fmt.Errorf("无法创建目标目录:%w", err))
return
}
f, err := os.Create(zipPath)
if err != nil {
s.failBackup(jobID, req, fmt.Errorf("无法创建备份文件(U盘是否已拔出/无写入权限):%w", err))
return
}
h := sha256.New()
zw := newZipWriter(f, h)
results := make([]ItemResult, 0, len(req.Items))
total := int64(0)
itemNames := make(map[string]string, len(MESItems))
for _, it := range MESItems {
itemNames[it.Key] = it.Name
}
for i, key := range req.Items {
setStage("writing", 5+int(float64(i)/float64(len(req.Items))*80), "导出 "+itemName(itemNames, key)+" …")
var ir ItemResult
var e error
if key == "attachment" {
ir, e = s.exportAttachment(ctx, zw, h, tStart, tEnd)
} else {
ir, e = s.exportLog(ctx, zw, h, key, tStart, tEnd)
}
if e != nil {
_ = zw.Close()
_ = f.Close()
_ = os.Remove(zipPath)
s.failBackup(jobID, req, fmt.Errorf("导出 %s 失败(U盘是否已拔出):%w", itemName(itemNames, key), e))
return
}
ir.Key = key
ir.Name = itemName(itemNames, key)
results = append(results, ir)
total += ir.Bytes
}
// manifest.json(先哈希后写入,便于校验)
manifest := map[string]any{
"generatedAt": time.Now().Format(time.RFC3339),
"scope": "mes",
"rangeStart": req.Start,
"rangeEnd": req.End,
"rangeStartText": tStart.Format("2006-01-02 15:04:05"),
"rangeEndText": tEnd.Format("2006-01-02 15:04:05"),
"operator": req.Operator,
"targetPath": req.TargetPath,
"zipPath": zipPath,
"items": results,
"totalSize": total,
"checksum": "",
}
manifestBytes, _ := json.MarshalIndent(manifest, "", " ")
if err := zw.WriteFile("manifest.json", manifestBytes); err != nil {
_ = zw.Close()
_ = f.Close()
_ = os.Remove(zipPath)
s.failBackup(jobID, req, fmt.Errorf("写入 manifest 失败:%w", err))
return
}
// index.html(清单 + 目录/使用/恢复说明,不内嵌预览)
indexHTML := buildIndexHTML("MES 数据备份清单", manifest, "", MESItems)
if err := zw.WriteFile("index.html", []byte(indexHTML)); err != nil {
_ = zw.Close()
_ = f.Close()
_ = os.Remove(zipPath)
s.failBackup(jobID, req, fmt.Errorf("写入 index.html 失败:%w", err))
return
}
if err := zw.Close(); err != nil {
_ = f.Close()
_ = os.Remove(zipPath)
// 备份包已随 os.Remove 删除,无残留产物:状态=failed(非 partial)
s.failBackup(jobID, req, fmt.Errorf("备份写入中断(U盘是否已拔出):%w", err))
return
}
if err := f.Close(); err != nil {
_ = os.Remove(zipPath)
// 备份包已随 os.Remove 删除,无残留产物:状态=failed(非 partial)
s.failBackup(jobID, req, fmt.Errorf("备份文件关闭失败:%w", err))
return
}
fi, _ := os.Stat(zipPath)
if fi != nil {
total = fi.Size()
}
s.finishBackup(jobID, req, zipPath, results, total, hex.EncodeToString(h.Sum(nil)), false, nil)
}
func (s *Service) exportLog(ctx context.Context, zw *zipWriter, h io.Writer, key string, tStart, tEnd time.Time) (ItemResult, error) {
var rows []any
var err error
switch key {
case "event_log":
list, e := s.client.EventLog.Query().
Where(eventlog.CreatedAtGTE(tStart), eventlog.CreatedAtLTE(tEnd)).All(ctx)
rows, err = sliceToAny(list), e
case "plc_send_log":
list, e := s.client.PlcSendLog.Query().
Where(plcsendlog.CreatedAtGTE(tStart), plcsendlog.CreatedAtLTE(tEnd)).All(ctx)
rows, err = sliceToAny(list), e
case "workpiece_lifecycle_log":
list, e := s.client.WorkpieceLifecycleLog.Query().
Where(workpiecelifecyclelog.CreatedAtGTE(tStart), workpiecelifecyclelog.CreatedAtLTE(tEnd)).All(ctx)
rows, err = sliceToAny(list), e
case "alert":
list, e := s.client.Alert.Query().
Where(alert.CreatedAtGTE(tStart), alert.CreatedAtLTE(tEnd)).All(ctx)
rows, err = sliceToAny(list), e
default:
return ItemResult{}, fmt.Errorf("未知数据项 %s", key)
}
if err != nil {
return ItemResult{}, err
}
ir := ItemResult{Rows: int64(len(rows))}
if err := zw.WriteJSONL(key+"/data.jsonl", rows, &ir.Bytes); err != nil {
return ir, err
}
return ir, nil
}
func (s *Service) exportAttachment(ctx context.Context, zw *zipWriter, h io.Writer, tStart, tEnd time.Time) (ItemResult, error) {
// 全量快照:不过滤删除状态(含已删除附件),元数据标注删除信息,确保彻底清除后仍可从备份包找回
rows, err := s.client.Attachment.Query().
Where(attachment.CreatedAtGTE(tStart), attachment.CreatedAtLTE(tEnd)).All(ctx)
if err != nil {
return ItemResult{}, err
}
ir := ItemResult{Rows: int64(len(rows))}
meta := make([]map[string]any, 0, len(rows))
for _, r := range rows {
abs, ok := safeAbsPath(s.attRoot, r.FilePath)
if !ok {
continue
}
_, ferr := os.Stat(abs)
if ferr != nil {
// 文件不存在(可能已挪走):仅记录元数据
meta = append(meta, map[string]any{
"id": r.ID, "fileName": r.FileName, "filePath": r.FilePath,
"fileSize": r.FileSize, "missing": true, "deleted": r.Deleted,
})
continue
}
src, oerr := os.Open(abs)
if oerr != nil {
return ir, oerr
}
entryName := "attachments/" + strings.ReplaceAll(r.FilePath, "\\", "/")
n, cerr := zw.CopyFrom(entryName, src)
_ = src.Close()
if cerr != nil {
return ir, cerr
}
ir.Bytes += n
meta = append(meta, map[string]any{
"id": r.ID, "fileName": r.FileName, "filePath": r.FilePath,
"fileSize": r.FileSize, "bytes": n, "deleted": r.Deleted,
})
}
mb, _ := json.MarshalIndent(meta, "", " ")
if err := zw.WriteFile("attachment/data.jsonl", mb); err != nil {
return ir, err
}
ir.Bytes += int64(len(mb))
return ir, nil
}
func (s *Service) finishBackup(jobID string, req BackupRequest, zipPath string, results []ItemResult, total int64, checksum string, partial bool, runErr error) {
status := "success"
if partial {
status = "partial"
}
itemsJSON, _ := json.Marshal(results)
rec := s.client.BackupRecord.Create().
SetExecutedAt(time.Now().Unix()).
SetRangeStart(req.Start).
SetRangeEnd(req.End).
SetBackupPath(zipPath).
SetTotalSize(total).
SetItemsJSON(string(itemsJSON)).
SetStatus(status).
SetOperator(req.Operator).
SetChecksum(checksum).
SetScope("mes")
if _, e := rec.Save(context.Background()); e != nil {
// 记录写入失败不影响已生成的备份包,但需提示
s.mu.Lock()
if j, ok := s.jobs[jobID]; ok {
j.Failed = true
j.Message = "备份包已生成,但写入 backup_record 失败:" + e.Error()
j.Done = true
}
s.mu.Unlock()
return
}
// 补写 index.html 的校验和(重新打开追加不便,写入 event_log 即可体现)
s.ev.Write(context.Background(), "backup.create", "", req.Operator, "backup", "",
fmt.Sprintf("备份到 %s(范围 %s ~ %s,共 %d 项,%s,校验和 %s)",
zipPath, time.Unix(req.Start, 0).Format("2006-01-02"), time.Unix(req.End, 0).Format("2006-01-02"),
len(results), humanBytes(total), checksum), nil)
res := BackupResult{BackupPath: zipPath, TotalSize: total, Checksum: checksum, Items: results}
if runErr != nil {
res.Checksum = checksum
}
s.mu.Lock()
if j, ok := s.jobs[jobID]; ok {
j.Done = true
if partial {
j.Failed = true
j.Message = "备份部分成功(U盘可能已拔出):" + runErr.Error()
} else {
j.Message = "备份完成"
}
j.Result = res
j.Percent = 100
}
s.mu.Unlock()
}
func (s *Service) failBackup(jobID string, req BackupRequest, runErr error) {
// 备份失败:backup_record 记 failed,清理入口不出现(覆盖校验只看 success)
status := "failed"
if strings.Contains(runErr.Error(), "U盘") || strings.Contains(runErr.Error(), "空间不足") {
status = "failed"
}
rec := s.client.BackupRecord.Create().
SetExecutedAt(time.Now().Unix()).
SetRangeStart(req.Start).
SetRangeEnd(req.End).
SetBackupPath("").
SetTotalSize(0).
SetItemsJSON("[]").
SetStatus(status).
SetOperator(req.Operator).
SetChecksum("").
SetScope("mes")
_, _ = rec.Save(context.Background())
s.mu.Lock()
if j, ok := s.jobs[jobID]; ok {
j.Done = true
j.Failed = true
j.Message = runErr.Error()
j.Percent = 100
}
s.mu.Unlock()
}
func (s *Service) estimateBytes(ctx context.Context, req BackupRequest) (int64, error) {
var total int64
tStart := time.Unix(req.Start, 0)
tEnd := time.Unix(req.End, 0)
for _, key := range req.Items {
switch key {
case "attachment":
rows, err := s.client.Attachment.Query().
Where(attachment.CreatedAtGTE(tStart), attachment.CreatedAtLTE(tEnd)).All(ctx)
if err != nil {
return 0, err
}
for _, r := range rows {
total += int64(r.FileSize)
}
total += int64(len(rows)) * 256 // 元数据
default:
// 日志类按行数粗略估算(每行上限 1KB,偏高以保证有足够空间)
n, err := s.countLog(ctx, key, tStart, tEnd)
if err != nil {
return 0, err
}
total += n * 1024
}
}
total += 4096 // manifest + index
return total, nil
}
func (s *Service) countLog(ctx context.Context, key string, tStart, tEnd time.Time) (int64, error) {
var q interface{ Count(context.Context) (int, error) }
switch key {
case "event_log":
q = s.client.EventLog.Query().Where(eventlog.CreatedAtGTE(tStart), eventlog.CreatedAtLTE(tEnd))
case "plc_send_log":
q = s.client.PlcSendLog.Query().Where(plcsendlog.CreatedAtGTE(tStart), plcsendlog.CreatedAtLTE(tEnd))
case "workpiece_lifecycle_log":
q = s.client.WorkpieceLifecycleLog.Query().Where(workpiecelifecyclelog.CreatedAtGTE(tStart), workpiecelifecyclelog.CreatedAtLTE(tEnd))
case "alert":
q = s.client.Alert.Query().Where(alert.CreatedAtGTE(tStart), alert.CreatedAtLTE(tEnd))
default:
return 0, nil
}
n, err := q.Count(ctx)
return int64(n), err
}
// ---------------- 清理 ----------------
// StartCleanup 启动异步清理,返回 jobID。
func (s *Service) StartCleanup(req CleanupRequest) (string, error) {
if req.End <= req.Start {
return "", fmt.Errorf("时间窗不合法")
}
if len(req.Items) == 0 {
return "", fmt.Errorf("请至少选择一个数据项")
}
if req.Force && req.Mode == "covered" {
return "", fmt.Errorf("参数冲突:强制清理与仅清理已覆盖段不可同时选择")
}
jobID := newJobID()
s.mu.Lock()
s.jobs[jobID] = &Progress{JobID: jobID, Phase: "cleanup", Stage: "checking", Percent: 0}
s.mu.Unlock()
go s.runCleanup(jobID, req)
return jobID, nil
}
// CheckCoverage 校验备份覆盖(供前端预检)。
// 返回:Covered=已覆盖段(可用于「仅清理已覆盖部分」),Missing=缺失段,
// Records=与本时间窗相交的 success 备份记录(供覆盖地图展示)。
func (s *Service) CheckCoverage(start, end int64) (CoverageResult, error) {
recs, err := s.client.BackupRecord.Query().Where(backuprecord.StatusEQ("success")).All(context.Background())
if err != nil {
return CoverageResult{}, err
}
ivs := make([][2]int64, 0, len(recs))
outRecs := make([]CoverageRecord, 0, len(recs))
for _, r := range recs {
if r.RangeEnd < start || r.RangeStart > end {
continue
}
ivs = append(ivs, [2]int64{r.RangeStart, r.RangeEnd})
outRecs = append(outRecs, CoverageRecord{
ID: r.ID, ExecutedAt: r.ExecutedAt, RangeStart: r.RangeStart, RangeEnd: r.RangeEnd,
BackupPath: r.BackupPath, Operator: r.Operator, TotalSize: r.TotalSize,
})
}
sort.Slice(outRecs, func(i, j int) bool { return outRecs[i].RangeStart < outRecs[j].RangeStart })
covered, missing := coverageSegments(ivs, start, end)
return CoverageResult{OK: len(missing) == 0, Covered: covered, Missing: missing, Records: outRecs}, nil
}
func (s *Service) runCleanup(jobID string, req CleanupRequest) {
ctx := context.Background()
setStage := func(stage string, pct int, msg string) {
s.mu.Lock()
if j, ok := s.jobs[jobID]; ok {
j.Stage, j.Percent, j.Message = stage, pct, msg
}
s.mu.Unlock()
}
// 1) 覆盖校验
cov, err := s.CheckCoverage(req.Start, req.End)
if err != nil {
s.failCleanup(jobID, req, fmt.Errorf("覆盖校验失败:%w", err))
return
}
var deleted, skipped []ItemResult
forced := false
if cov.OK {
// 整窗均已被备份覆盖:直接清理
tStart, tEnd := time.Unix(req.Start, 0), time.Unix(req.End, 0)
if deleted, skipped, err = s.cleanWindow(ctx, tStart, tEnd, req.Items, setStage); err != nil {
s.failCleanup(jobID, req, err)
return
}
} else if req.Mode == "covered" {
// 部分清理:逐段清理已覆盖部分,未备份段保留
if len(cov.Covered) == 0 {
s.failCleanup(jobID, req, fmt.Errorf("该时间窗内没有任何已被备份的数据段,无法清理。缺失时间段:%s", formatMissing(cov.Missing)))
return
}
for i, seg := range cov.Covered {
setStage("cleaning", i*90/len(cov.Covered),
fmt.Sprintf("清理已覆盖段 %s ~ %s …", time.Unix(seg.Start, 0).Format("2006-01-02"), time.Unix(seg.End, 0).Format("2006-01-02")))
tStart, tEnd := time.Unix(seg.Start, 0), time.Unix(seg.End, 0)
var d, sk []ItemResult
if d, sk, err = s.cleanWindow(ctx, tStart, tEnd, req.Items, setStage); err != nil {
s.failCleanup(jobID, req, err)
return
}
deleted = append(deleted, d...)
skipped = append(skipped, sk...)
}
} else if req.Force {
// 强制清理:未完整备份仍坚持整窗清理,须实名留痕
if err = validateAck(req); err != nil {
s.failCleanup(jobID, req, err)
return
}
forced = true
tStart, tEnd := time.Unix(req.Start, 0), time.Unix(req.End, 0)
if deleted, skipped, err = s.cleanWindow(ctx, tStart, tEnd, req.Items, setStage); err != nil {
s.failCleanup(jobID, req, err)
return
}
} else {
s.failCleanup(jobID, req, fmt.Errorf(
"该时间窗未被完整备份,禁止清理。缺失时间段:%s。可选:① 先补齐缺失段备份;② 仅清理已覆盖部分(未备份段保留);③ 强制清理(需实名确认,风险自担)。",
formatMissing(cov.Missing)))
return
}
// 2) 清理记录 + event_log
status := "cleanup"
evKind, detail := "backup.cleanup", fmt.Sprintf("按时间窗清理(%s ~ %s):%s",
time.Unix(req.Start, 0).Format("2006-01-02"), time.Unix(req.End, 0).Format("2006-01-02"),
summaryDeleted(deleted, skipped))
if forced {
status = "cleanup_forced"
evKind = "backup.cleanup.forced"
detail = fmt.Sprintf("强制清理(该时间窗未被完整备份,缺失:%s;操作确认人:%s,手机号:%s):%s",
formatMissing(cov.Missing), req.AckName, req.AckPhone, summaryDeleted(deleted, skipped))
} else if !cov.OK { // covered 模式
detail += fmt.Sprintf("(仅清理已覆盖部分,未备份段已保留:%s)", formatMissing(cov.Missing))
}
s.writeCleanupRecord(req, status, deleted, skipped)
s.ev.Write(ctx, evKind, "", req.Operator, "backup", "", detail, nil)
setStage("done", 100, "清理完成")
s.mu.Lock()
if j, ok := s.jobs[jobID]; ok {
j.Done = true
j.Result = CleanupResult{RangeStart: req.Start, RangeEnd: req.End, Deleted: deleted, Skipped: skipped}
}
s.mu.Unlock()
}
// cleanWindow 清理单个时间窗内的指定数据项(物理删除)。
func (s *Service) cleanWindow(ctx context.Context, tStart, tEnd time.Time, keys []string, setStage func(string, int, string)) ([]ItemResult, []ItemResult, error) {
deleted := make([]ItemResult, 0, len(keys))
skipped := make([]ItemResult, 0, len(keys))
itemNames := make(map[string]string, len(MESItems))
for _, it := range MESItems {
itemNames[it.Key] = it.Name
}
for i, key := range keys {
pct := 0
if len(keys) > 0 {
pct = i * 90 / len(keys)
}
setStage("cleaning", pct, "清理 "+itemName(itemNames, key)+" …")
if key == "attachment" {
d, sk, e := s.cleanupAttachment(ctx, tStart, tEnd)
if e != nil {
return nil, nil, fmt.Errorf("清理附件失败:%w", e)
}
d.Key, d.Name = key, itemName(itemNames, key)
sk.Key, sk.Name = key, itemName(itemNames, key)
deleted = append(deleted, d)
if sk.Rows > 0 {
skipped = append(skipped, sk)
}
} else {
n, e := s.cleanupLog(ctx, key, tStart, tEnd)
if e != nil {
return nil, nil, fmt.Errorf("清理 %s 失败:%w", itemName(itemNames, key), e)
}
deleted = append(deleted, ItemResult{Key: key, Name: itemName(itemNames, key), Rows: n, Bytes: 0})
}
}
return deleted, skipped, nil
}
// writeCleanupRecord 清理成功后写一条 backup_record(status=cleanup / cleanup_forced),
// 备份记录与清理记录统一在「备份/清理历史」中展示;覆盖校验仅认 success,不受影响。
func (s *Service) writeCleanupRecord(req CleanupRequest, status string, deleted, skipped []ItemResult) {
items := make([]ItemResult, 0, len(deleted)+len(skipped))
items = append(items, deleted...)
items = append(items, skipped...)
itemsJSON, _ := json.Marshal(items)
var total int64
for _, d := range deleted {
total += d.Bytes
}
c := s.client.BackupRecord.Create().
SetExecutedAt(time.Now().Unix()).
SetRangeStart(req.Start).
SetRangeEnd(req.End).
SetBackupPath("").
SetTotalSize(total).
SetItemsJSON(string(itemsJSON)).
SetStatus(status).
SetOperator(req.Operator).
SetChecksum("").
SetScope("mes")
if status == "cleanup_forced" {
c = c.SetAckName(strings.TrimSpace(req.AckName)).SetAckPhone(strings.TrimSpace(req.AckPhone))
}
_, _ = c.Save(context.Background())
}
func (s *Service) cleanupLog(ctx context.Context, key string, tStart, tEnd time.Time) (int64, error) {
var q interface{ Exec(context.Context) (int, error) }
switch key {
case "event_log":
q = s.client.EventLog.Delete().Where(eventlog.CreatedAtGTE(tStart), eventlog.CreatedAtLTE(tEnd))
case "plc_send_log":
q = s.client.PlcSendLog.Delete().Where(plcsendlog.CreatedAtGTE(tStart), plcsendlog.CreatedAtLTE(tEnd))
case "workpiece_lifecycle_log":
q = s.client.WorkpieceLifecycleLog.Delete().Where(workpiecelifecyclelog.CreatedAtGTE(tStart), workpiecelifecyclelog.CreatedAtLTE(tEnd))
case "alert":
q = s.client.Alert.Delete().Where(alert.CreatedAtGTE(tStart), alert.CreatedAtLTE(tEnd))
default:
return 0, nil
}
n, err := q.Exec(ctx)
return int64(n), err
}
// cleanupAttachment 物理删除文件 + DELETE 记录(附件文件由本端独占写入与引用,无需跨库校验)。
// 返回 (deleted 结果, skipped 结果, error)。skipped 为删除失败(文件被占用等)跳过的记录。
func (s *Service) cleanupAttachment(ctx context.Context, tStart, tEnd time.Time) (ItemResult, ItemResult, error) {
rows, err := s.client.Attachment.Query().
Where(attachment.CreatedAtGTE(tStart), attachment.CreatedAtLTE(tEnd)).All(ctx)
if err != nil {
return ItemResult{}, ItemResult{}, err
}
del := ItemResult{}
sk := ItemResult{}
for _, r := range rows {
abs, ok := safeAbsPath(s.attRoot, r.FilePath)
if ok {
if rerr := os.Remove(abs); rerr != nil && !os.IsNotExist(rerr) {
// 删除失败(如文件被占用):跳过该记录,避免 DB 与磁盘不一致
sk.Rows++
continue
}
}
if _, derr := s.client.Attachment.Delete().Where(attachment.ID(r.ID)).Exec(ctx); derr != nil {
sk.Rows++
continue
}
del.Rows++
del.Bytes += int64(r.FileSize)
}
return del, sk, nil
}
func (s *Service) failCleanup(jobID string, req CleanupRequest, runErr error) {
s.ev.Write(context.Background(), "backup.cleanup.reject", "", req.Operator, "backup", "",
"清理被拒:"+runErr.Error(), nil)
s.mu.Lock()
if j, ok := s.jobs[jobID]; ok {
j.Done = true
j.Failed = true
j.Message = runErr.Error()
j.Percent = 100
}
s.mu.Unlock()
}
// ---------------- 进度 ----------------
// Progress 返回任务进度。
func (s *Service) Progress(jobID string) (Progress, bool) {
s.mu.Lock()
defer s.mu.Unlock()
j, ok := s.jobs[jobID]
if !ok {
return Progress{}, false
}
cp := *j
return cp, true
}
// ---------------- 工具 ----------------
func itemName(m map[string]string, key string) string {
if n, ok := m[key]; ok {
return n
}
return key
}
// safeAbsPath 把库内相对路径安全解析为根目录内的绝对路径(阻断 ../ 穿越)。
func safeAbsPath(root, rel string) (string, bool) {
rel = strings.ReplaceAll(rel, "\\", "/")
clean := filepath.Clean(filepath.Join(root, rel))
rootAbs, err := filepath.Abs(root)
if err != nil {
return "", false
}
abs, err := filepath.Abs(clean)
if err != nil {
return "", false
}
if abs != rootAbs && !strings.HasPrefix(abs, rootAbs+string(os.PathSeparator)) {
return "", false
}
return abs, true
}
func diskFree(path string) (uint64, error) {
var free uint64
p, err := windows.UTF16PtrFromString(path)
if err != nil {
return 0, err
}
if err := windows.GetDiskFreeSpaceEx(p, &free, nil, nil); err != nil {
return 0, err
}
return free, nil
}
func humanBytes(n int64) string {
const unit = 1024
if n < unit {
return fmt.Sprintf("%d B", n)
}
div, exp := int64(unit), 0
for x := n / unit; x >= unit; x /= unit {
div *= unit
exp++
}
return fmt.Sprintf("%.2f %cB", float64(n)/float64(div), "KMGTPE"[exp])
}
func newJobID() string {
b := make([]byte, 8)
_, _ = io.ReadFull(randReader(), b)
return hex.EncodeToString(b) + fmt.Sprintf("%d", time.Now().UnixNano()%100000)
}