// 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。 // - 不做软删、不引入 archived/deleted 标记。 package backup import ( "context" "crypto/sha256" "encoding/hex" "encoding/json" "fmt" "io" "os" "path/filepath" "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"` 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"}, {Key: "plc_send_log", Name: "PLC下发日志", Kind: "log"}, {Key: "workpiece_lifecycle_log", Name: "工件生命周期日志", Kind: "log"}, {Key: "alert", Name: "预警消息", Kind: "log"}, {Key: "attachment", Name: "业务附件", Kind: "attachment"}, } // 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 清理请求。 type CleanupRequest struct { Start int64 `json:"start"` End int64 `json:"end"` Items []string `json:"items"` Operator string `json:"operator"` } // 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"` } // CoverageResult 覆盖校验结果。 type CoverageResult struct { OK bool `json:"ok"` Missing []MissingSeg `json:"missing"` } // 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, "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, "") 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, }) 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, }) } 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("请至少选择一个数据项") } 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 校验备份覆盖(供前端预检)。 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)) for _, r := range recs { ivs = append(ivs, [2]int64{r.RangeStart, r.RangeEnd}) } missing := complement(ivs, start, end) return CoverageResult{OK: len(missing) == 0, Missing: missing}, 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 } if !cov.OK { s.failCleanup(jobID, req, fmt.Errorf("该时间窗未被完整备份,禁止清理。缺失时间段:%s", formatMissing(cov.Missing))) return } tStart := time.Unix(req.Start, 0) tEnd := time.Unix(req.End, 0) deleted := make([]ItemResult, 0, len(req.Items)) skipped := make([]ItemResult, 0, len(req.Items)) itemNames := make(map[string]string, len(MESItems)) for _, it := range MESItems { itemNames[it.Key] = it.Name } // 2) 逐表清理 for i, key := range req.Items { setStage("cleaning", int(float64(i)/float64(len(req.Items))*90), "清理 "+itemName(itemNames, key)+" …") if key == "attachment" { d, sk, e := s.cleanupAttachment(ctx, tStart, tEnd) if e != nil { s.failCleanup(jobID, req, fmt.Errorf("清理附件失败:%w", e)) return } 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 { s.failCleanup(jobID, req, fmt.Errorf("清理 %s 失败:%w", itemName(itemNames, key), e)) return } deleted = append(deleted, ItemResult{Key: key, Name: itemName(itemNames, key), Rows: n, Bytes: 0}) } } // 3) 清理动作本身写一条 event_log s.ev.Write(ctx, "backup.cleanup", "", req.Operator, "backup", "", 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)), 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() } 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) }