feat: 补齐第一批已知缺口(关闭握手 / 定时备份 / Origin 白名单 / DTO 收敛)

- httpapi:新增 POST /api/shutdown(admin 会话或 X-Shutdown-Token 常量时间比对)
  与 GET /api/rules/switches(recorder 可读,只回布尔开关);settings/standings 的
  重复 DTO 收敛到 internal/dto;standings.showIndividualMedals 贯通到设置读写与前端
- export:抽出 export.Service,新增自动备份定时任务(backup.intervalMinutes/keep),
  自动、手动、发布前三类备份共用同一把互斥锁与滚动清理
- realtime:/ws 去掉 InsecureSkipVerify,改用 OriginPatterns(同源与无 Origin 放行,
  跨站需命中 server.allowedOrigins)
- console:停止服务改走 POST /api/shutdown 优雅关闭(5 秒宽限后回退强杀),
  服务管理器新增「已连接的大屏实例」卡片
- deploy:build.bat 改用 for /f 读内部署名——set /p 在 chcp 65001 下返回空,
  导致最近这次构建的 exe 里根本没注入署名
- docs:备份策略、关闭超时、Origin 配置的说明与实现对齐
This commit is contained in:
AskaEth committed 2026-09-09 21:41:08 +08:00
1 parent 4d56c73ae6
commit 2c9ff65fc4
42 files changed
+1271 -275

No files matched your search

+132 -7
View File
@@ -1,13 +1,16 @@
package export
import (
"context"
"database/sql"
"errors"
"fmt"
"log/slog"
"os"
"path/filepath"
"sort"
"strings"
"sync"
"time"
)
@@ -48,7 +51,7 @@ func Backup(db *sql.DB, opts BackupOptions) (BackupInfo, error) {
}
dir := strings.TrimSpace(opts.Dir)
if dir == "" {
return BackupInfo{}, errors.New("export: 备份目录为空")
return BackupInfo{}, ErrNoDir
}
if err := os.MkdirAll(dir, 0o755); err != nil {
return BackupInfo{}, fmt.Errorf("export: 创建备份目录 %s: %w", dir, err)
@@ -100,6 +103,113 @@ func BackupBeforePublish(db *sql.DB, opts BackupOptions) (BackupInfo, error) {
return Backup(db, opts)
}
// Service 收拢「系统库 + 赛事库」的备份,并串行化手动、发布前、定时三类触发:
// 同一时刻只允许一个 VACUUM INTO 在跑,避免并发快照互相拖慢或写入同一文件。
type Service struct {
system *sql.DB
event *sql.DB
dir string
keep int
logger *slog.Logger
mu sync.Mutex
}
// NewService 构造备份服务;keep<=0 时按 DefaultBackupKeep 滚动保留。
func NewService(system, event *sql.DB, dir string, keep int, logger *slog.Logger) *Service {
if logger == nil {
logger = slog.Default()
}
return &Service{system: system, event: event, dir: dir, keep: keep, logger: logger}
}
// Run 备份系统库与赛事库各一份(手动备份、定时备份用)。
func (s *Service) Run(reason string) ([]BackupInfo, error) {
s.mu.Lock()
defer s.mu.Unlock()
return s.snapshotAll(reason, true)
}
// RunEvent 只备份赛事库(发布前备份用);与 Run 共用同一把锁。
func (s *Service) RunEvent(reason string) ([]BackupInfo, error) {
s.mu.Lock()
defer s.mu.Unlock()
return s.snapshotAll(reason, false)
}
// StartAuto 跟随 ctx 定时备份:ctx 取消即停止,间隔 <=0 表示关闭。
//
// 定时备份不写审计:一天下来会产生几百条 system.backup,把审计表刷满;
// 手动备份与发布前备份照旧写审计。
func (s *Service) StartAuto(ctx context.Context, interval time.Duration) {
if interval <= 0 {
s.logger.Info("自动备份已关闭", "interval", interval.String())
return
}
if strings.TrimSpace(s.dir) == "" {
s.logger.Warn("未配置数据目录,跳过自动备份")
return
}
go func() {
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
if ctx.Err() != nil {
return
}
infos, err := s.Run("auto")
if err != nil {
s.logger.Error("自动备份失败", "err", err)
continue
}
for _, info := range infos {
s.logger.Info("自动备份完成", "path", info.Path, "size", info.Size)
}
}
}
}()
}
func (s *Service) snapshotAll(reason string, withSystem bool) ([]BackupInfo, error) {
if strings.TrimSpace(s.dir) == "" {
return nil, ErrNoDir
}
out := make([]BackupInfo, 0, 2)
if withSystem && s.system != nil {
info, err := s.snapshot(s.system, "system", reason)
if err != nil {
return out, err
}
out = append(out, info)
}
if s.event != nil {
info, err := s.snapshot(s.event, "event", reason)
if err != nil {
return out, err
}
out = append(out, info)
}
return out, nil
}
func (s *Service) snapshot(db *sql.DB, prefix, reason string) (BackupInfo, error) {
info, err := Backup(db, BackupOptions{Dir: s.dir, Prefix: prefix, Reason: reason, Keep: s.keep})
if err == nil {
return info, nil
}
// 快照已生成、只是滚动清理旧备份失败时 Backup 仍返回有效 info:
// 删不掉旧文件不算本次备份失败,记日志即可(下次备份会再试)。
if info.Path != "" {
s.logger.Warn("清理旧备份失败", "prefix", prefix, "err", err)
return info, nil
}
return BackupInfo{}, err
}
// ListBackups 按时间倒序列出备份;prefix 为空时列出全部 .db 备份。
// 不计算校验和(避免每次列表都全量读盘),需要校验时用 Backup 的返回值。
func ListBackups(dir, prefix string) ([]BackupInfo, error) {
@@ -150,7 +260,8 @@ func LatestBackup(dir, prefix string) (BackupInfo, bool, error) {
return list[0], true, nil
}
// PruneBackups 只保留最近 keep 份,返回被删除的文件路径。
// PruneBackups 只保留最近 keep 份,返回被删除的文件路径;
// 个别文件删不掉只汇总到返回的错误里,不影响继续清理其余旧备份。
func PruneBackups(dir, prefix string, keep int) ([]string, error) {
if keep <= 0 {
keep = DefaultBackupKeep
@@ -164,13 +275,15 @@ func PruneBackups(dir, prefix string, keep int) ([]string, error) {
}
removed := make([]string, 0, len(list)-keep)
var errs []error
for _, b := range list[keep:] {
if err := os.Remove(b.Path); err != nil && !os.IsNotExist(err) {
return removed, fmt.Errorf("export: 删除旧备份 %s: %w", b.Path, err)
errs = append(errs, fmt.Errorf("export: 删除旧备份 %s: %w", b.Path, err))
continue
}
removed = append(removed, b.Path)
}
return removed, nil
return removed, errors.Join(errs...)
}
func uniqueBackupPath(dir, prefix, reason string, now time.Time) string {
@@ -184,15 +297,27 @@ func uniqueBackupPath(dir, prefix, reason string, now time.Time) string {
}
}
// reasonFromName 从 <prefix>-<reason>-<yyyyMMdd>-<HHmmss>.db 里取回原因。
// reasonFromName 从 <prefix>-<reason>-<yyyyMMdd>-<HHmmss>[-<序号>].db 里取回原因;
// 同一秒重复备份会多一段序号,所以从右侧找「8 位日期 + 6 位时间」再截断。
func reasonFromName(name, prefix string) string {
base := strings.TrimSuffix(name, filepath.Ext(name))
if prefix != "" {
base = strings.TrimPrefix(base, prefix+"-")
}
parts := strings.Split(base, "-")
if len(parts) >= 3 {
return strings.Join(parts[:len(parts)-2], "-")
for i := len(parts) - 2; i >= 0; i-- {
if len(parts[i]) == 8 && len(parts[i+1]) == 6 && allDigits(parts[i]) && allDigits(parts[i+1]) {
return strings.Join(parts[:i], "-")
}
}
return ""
}
func allDigits(s string) bool {
for _, r := range s {
if r < '0' || r > '9' {
return false
}
}
return s != ""
}
+133
View File
@@ -1,6 +1,9 @@
package export
import (
"context"
"io"
"log/slog"
"os"
"path/filepath"
"testing"
@@ -121,3 +124,133 @@ func TestListBackupsMissingDir(t *testing.T) {
t.Errorf("空目录的最近备份: ok=%v err=%v", ok, err)
}
}
// 间隔 <=0 关闭任务;未配置备份目录时安全跳过(不 panic、不生成文件)。
func TestStartAutoDisabled(t *testing.T) {
dir := t.TempDir()
svc := NewService(nil, nil, dir, 20, testLogger())
ctx := context.Background()
svc.StartAuto(ctx, 0)
svc.StartAuto(ctx, -time.Minute)
entries, err := os.ReadDir(dir)
if err != nil {
t.Fatalf("读取备份目录: %v", err)
}
if len(entries) != 0 {
t.Fatalf("间隔 <=0 不应生成备份,实际 %d 个文件", len(entries))
}
// 未配置备份目录:只记日志并跳过,不能 panic。
NewService(nil, nil, "", 20, testLogger()).StartAuto(ctx, time.Minute)
}
// 定时任务按间隔生成 auto 备份。
func TestStartAutoBacksUp(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
dir := t.TempDir()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
NewService(nil, db, dir, 20, testLogger()).StartAuto(ctx, 10*time.Millisecond)
deadline := time.Now().Add(10 * time.Second)
for {
list, err := ListBackups(dir, "event")
if err != nil {
t.Fatalf("列出备份: %v", err)
}
if len(list) > 0 {
if list[0].Reason != "auto" {
t.Fatalf("定时备份原因 = %q,期望 auto", list[0].Reason)
}
return
}
if time.Now().After(deadline) {
t.Fatal("10 秒内未生成定时备份")
}
time.Sleep(10 * time.Millisecond)
}
}
// 超过保留份数时删除最旧的备份。
func TestServiceRunPrunesOldBackups(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
dir := t.TempDir()
base := time.Date(2026, 1, 1, 0, 0, 0, 0, time.Local)
for i := 0; i < 3; i++ {
if _, err := Backup(db, BackupOptions{
Dir: dir, Prefix: "event", Reason: "auto", SkipPrune: true,
Now: base.Add(time.Duration(i) * time.Minute),
}); err != nil {
t.Fatalf("预置第 %d 份备份: %v", i, err)
}
}
svc := NewService(nil, db, dir, 2, testLogger())
if _, err := svc.RunEvent("auto"); err != nil {
t.Fatalf("RunEvent: %v", err)
}
list, err := ListBackups(dir, "event")
if err != nil {
t.Fatalf("列出备份: %v", err)
}
if len(list) != 2 {
t.Fatalf("保留份数 = %d,期望 2", len(list))
}
if _, err := os.Stat(filepath.Join(dir, "event-auto-20260101-000000.db")); !os.IsNotExist(err) {
t.Errorf("最旧的备份应被删除,err=%v", err)
}
}
// 并发触发时必须等待同一把锁,保证同一时刻只有一个 VACUUM INTO 在跑。
func TestServiceRunMutualExclusion(t *testing.T) {
db := openEventDB(t)
seedEvent(t, db)
svc := NewService(nil, db, t.TempDir(), 20, testLogger())
svc.mu.Lock()
done := make(chan error, 1)
go func() {
_, err := svc.RunEvent("auto")
done <- err
}()
select {
case err := <-done:
t.Fatalf("RunEvent 未等待互斥锁就返回: %v", err)
case <-time.After(100 * time.Millisecond):
}
svc.mu.Unlock()
select {
case err := <-done:
if err != nil {
t.Fatalf("RunEvent: %v", err)
}
case <-time.After(10 * time.Second):
t.Fatal("RunEvent 超时未完成")
}
}
// 同一秒重复备份会带 -2 之类的序号,原因解析不能把它当成时间的一部分。
func TestReasonFromNameWithSequence(t *testing.T) {
cases := []struct{ name, prefix, want string }{
{"event-auto-20260909-213614.db", "event", "auto"},
{"event-auto-20260909-213614-2.db", "event", "auto"},
{"event-publish-20260909-213614-10.db", "event", "publish"},
{"system-manual-20260909-213614.db", "system", "manual"},
}
for _, c := range cases {
if got := reasonFromName(c.name, c.prefix); got != c.want {
t.Errorf("reasonFromName(%q) = %q,期望 %q", c.name, got, c.want)
}
}
}
func testLogger() *slog.Logger {
return slog.New(slog.NewTextHandler(io.Discard, nil))
}
+2
View File
@@ -14,6 +14,8 @@ import "errors"
var (
// ErrNoDatabase 表示调用方传入了空的数据库连接。
ErrNoDatabase = errors.New("export: 数据库连接为空")
// ErrNoDir 表示未配置备份目录。
ErrNoDir = errors.New("export: 备份目录为空")
// ErrInvalidPackage 表示赛事项目包结构非法(缺 meta.yaml、路径穿越、校验信息缺失等)。
ErrInvalidPackage = errors.New("export: 赛事项目包非法")
// ErrUnsupportedVersion 表示包内 meta.yaml 的格式版本高于当前程序能读的版本。