Files
skillshare/internal/server/handler_backup.go
T
Willie a0ebbde1de refactor(ui): use raw bytes in backup API and extract shared formatSize
Return sizeBytes (int64) instead of sizeMB (float64) from backup API
so the frontend controls display formatting. CLI backup commands now
use the existing formatBytes() helper for human-friendly output.

Extract duplicate formatSize() from CollectPage and TrashPage into
shared ui/src/lib/format.ts utility.
2026-02-25 07:02:54 +08:00

186 lines
4.3 KiB
Go

package server
import (
"encoding/json"
"net/http"
"time"
"skillshare/internal/backup"
)
type backupInfoJSON struct {
Timestamp string `json:"timestamp"`
Path string `json:"path"`
Targets []string `json:"targets"`
Date string `json:"date"`
SizeBytes int64 `json:"sizeBytes"`
}
func toBackupJSON(b backup.BackupInfo) backupInfoJSON {
return backupInfoJSON{
Timestamp: b.Timestamp,
Path: b.Path,
Targets: b.Targets,
Date: b.Date.Format("2006-01-02T15:04:05Z07:00"),
SizeBytes: backup.Size(b.Path),
}
}
// handleListBackups returns all backups
func (s *Server) handleListBackups(w http.ResponseWriter, r *http.Request) {
backups, err := backup.List()
if err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
items := make([]backupInfoJSON, 0, len(backups))
for _, b := range backups {
items = append(items, toBackupJSON(b))
}
total, _ := backup.TotalSize()
writeJSON(w, map[string]any{
"backups": items,
"totalSizeBytes": total,
})
}
// handleCreateBackup creates a backup of target(s)
func (s *Server) handleCreateBackup(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body struct {
Target string `json:"target"` // empty = all targets
}
json.NewDecoder(r.Body).Decode(&body)
targets := make(map[string]string)
if body.Target != "" {
t, ok := s.cfg.Targets[body.Target]
if !ok {
writeError(w, http.StatusBadRequest, "target not found: "+body.Target)
return
}
targets[body.Target] = t.Path
} else {
for name, t := range s.cfg.Targets {
targets[name] = t.Path
}
}
var created []string
for name, path := range targets {
bp, err := backup.Create(name, path)
if err != nil {
writeError(w, http.StatusInternalServerError, "backup failed for "+name+": "+err.Error())
return
}
if bp != "" {
created = append(created, name)
}
}
s.writeOpsLog("backup", "ok", start, map[string]any{
"target": body.Target,
"targets_total": len(targets),
"targets_backed": len(created),
"scope": "ui",
}, "")
writeJSON(w, map[string]any{
"success": true,
"backedUpTargets": created,
})
}
// handleCleanupBackups removes old backups
func (s *Server) handleCleanupBackups(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
cfg := backup.DefaultCleanupConfig()
removed, err := backup.Cleanup(cfg)
if err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
s.writeOpsLog("backup", "ok", start, map[string]any{
"action": "cleanup",
"removed": removed,
"scope": "ui",
}, "")
writeJSON(w, map[string]any{
"success": true,
"removed": removed,
})
}
// handleRestore restores a backup to a target
func (s *Server) handleRestore(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body struct {
Timestamp string `json:"timestamp"`
Target string `json:"target"`
Force bool `json:"force"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
writeError(w, http.StatusBadRequest, "invalid JSON body")
return
}
if body.Timestamp == "" || body.Target == "" {
writeError(w, http.StatusBadRequest, "timestamp and target are required")
return
}
// Verify target exists in config
t, ok := s.cfg.Targets[body.Target]
if !ok {
writeError(w, http.StatusBadRequest, "target not found: "+body.Target)
return
}
// Find backup
bk, err := backup.GetBackupByTimestamp(body.Timestamp)
if err != nil {
writeError(w, http.StatusNotFound, "backup not found: "+err.Error())
return
}
opts := backup.RestoreOptions{Force: body.Force}
// Validate first
if err := backup.ValidateRestore(bk.Path, body.Target, t.Path, opts); err != nil {
writeError(w, http.StatusConflict, err.Error())
return
}
// Restore
if err := backup.RestoreToPath(bk.Path, body.Target, t.Path, opts); err != nil {
writeError(w, http.StatusInternalServerError, "restore failed: "+err.Error())
return
}
s.writeOpsLog("restore", "ok", start, map[string]any{
"target": body.Target,
"from": body.Timestamp,
"force": body.Force,
"scope": "ui",
}, "")
writeJSON(w, map[string]any{
"success": true,
"target": body.Target,
"timestamp": body.Timestamp,
})
}