855 lines
28 KiB
Go
855 lines
28 KiB
Go
// 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)
|
||
}
|