Files
bj_power/bj_power_mes/internal/backup/backup.go
T

732 lines
22 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Package 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)
}