// 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) }