生产部署整改阶段检查点
This commit is contained in:
1 parent
f3348cf95d
commit
92d4b3d398
56 files changed
+4178
-240
No files matched your search
@@ -0,0 +1,675 @@
|
||||
package cli
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/fs"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
|
||||
)
|
||||
|
||||
const backupManifestVersion = 1
|
||||
|
||||
type backupManifest struct {
|
||||
Version int `json:"version"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
Files []backupManifestFile `json:"files"`
|
||||
}
|
||||
|
||||
type backupManifestFile struct {
|
||||
Path string `json:"path"`
|
||||
Mode uint32 `json:"mode"`
|
||||
Size int64 `json:"size"`
|
||||
SHA256 string `json:"sha256"`
|
||||
}
|
||||
|
||||
func createBackup(ctx context.Context, cfg config.Config, configPath, output string) error {
|
||||
output = filepath.Clean(output)
|
||||
if err := ensureBackupDestination(output); err != nil {
|
||||
return err
|
||||
}
|
||||
parent := filepath.Dir(output)
|
||||
if err := os.MkdirAll(parent, 0o700); err != nil {
|
||||
return fmt.Errorf("创建备份父目录失败:%w", err)
|
||||
}
|
||||
parentInfo, err := os.Lstat(parent)
|
||||
if err != nil {
|
||||
return fmt.Errorf("检查备份父目录失败:%w", err)
|
||||
}
|
||||
if parentInfo.Mode()&os.ModeSymlink != 0 || !parentInfo.IsDir() {
|
||||
return errors.New("备份父路径必须是普通目录")
|
||||
}
|
||||
staging, err := os.MkdirTemp(parent, ".scert-backup-")
|
||||
if err != nil {
|
||||
return fmt.Errorf("创建备份暂存目录失败:%w", err)
|
||||
}
|
||||
completed := false
|
||||
defer func() {
|
||||
if !completed {
|
||||
_ = os.RemoveAll(staging)
|
||||
}
|
||||
}()
|
||||
if err := os.Chmod(staging, 0o700); err != nil {
|
||||
return fmt.Errorf("设置备份暂存目录权限失败:%w", err)
|
||||
}
|
||||
|
||||
if err := copyFileExclusive(configPath, filepath.Join(staging, "scert.json"), 0o600); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := validateBackupSecretStore(ctx, cfg.Paths.Config, cfg); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, name := range []string{"master.key", "secrets.json"} {
|
||||
source := filepath.Join(cfg.Paths.Config, name)
|
||||
info, statErr := os.Lstat(source)
|
||||
if statErr == nil {
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
|
||||
return fmt.Errorf("敏感配置文件不是普通文件:%s", name)
|
||||
}
|
||||
if err := copyFileExclusive(source, filepath.Join(staging, name), 0o600); err != nil {
|
||||
return err
|
||||
}
|
||||
continue
|
||||
}
|
||||
if !errors.Is(statErr, os.ErrNotExist) {
|
||||
return fmt.Errorf("检查敏感配置文件失败:%w", statErr)
|
||||
}
|
||||
if cfg.SetupReady {
|
||||
return fmt.Errorf("已初始化配置缺少敏感配置文件:%s", name)
|
||||
}
|
||||
}
|
||||
|
||||
if cfg.Database.Driver == "sqlite" {
|
||||
_, memory, err := sqliteDatabasePath(cfg.Database.DSN)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !memory {
|
||||
if err := backupSQLiteDatabase(ctx, cfg, filepath.Join(staging, "scert.db")); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
if cfg.Database.Driver == "mysql" {
|
||||
if err := backupMySQL(ctx, cfg, filepath.Join(staging, "scert.sql")); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
if info, err := os.Lstat(cfg.Paths.Certificate); err == nil {
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
|
||||
return errors.New("证书根目录必须是普通目录,不能使用符号链接")
|
||||
}
|
||||
if pathsOverlap(cfg.Paths.Certificate, output) {
|
||||
return errors.New("备份目录不能位于证书根目录内,也不能包含证书根目录")
|
||||
}
|
||||
if err := copyDirectoryExclusive(cfg.Paths.Certificate, filepath.Join(staging, "certificates")); err != nil {
|
||||
return fmt.Errorf("备份证书目录失败:%w", err)
|
||||
}
|
||||
} else if !errors.Is(err, os.ErrNotExist) {
|
||||
return fmt.Errorf("检查证书根目录失败:%w", err)
|
||||
}
|
||||
|
||||
if err := writeBackupManifest(staging); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := syncDirectory(staging); err != nil {
|
||||
return fmt.Errorf("同步备份暂存目录失败:%w", err)
|
||||
}
|
||||
if err := os.Rename(staging, output); err != nil {
|
||||
return fmt.Errorf("发布备份目录失败:%w", err)
|
||||
}
|
||||
if err := syncDirectory(parent); err != nil {
|
||||
return fmt.Errorf("同步备份父目录失败:%w", err)
|
||||
}
|
||||
completed = true
|
||||
return nil
|
||||
}
|
||||
|
||||
func backupSQLiteDatabase(ctx context.Context, cfg config.Config, output string) error {
|
||||
if _, memory, err := sqliteDatabasePath(cfg.Database.DSN); err != nil {
|
||||
return err
|
||||
} else if memory {
|
||||
return errors.New("内存 SQLite 数据库不能创建文件备份")
|
||||
}
|
||||
db, err := database.Open(ctx, cfg.Database)
|
||||
if err != nil {
|
||||
return fmt.Errorf("打开 SQLite 数据库失败:%w", err)
|
||||
}
|
||||
defer db.Close()
|
||||
absOutput, err := filepath.Abs(output)
|
||||
if err != nil {
|
||||
return fmt.Errorf("解析 SQLite 备份路径失败:%w", err)
|
||||
}
|
||||
if _, err := os.Lstat(absOutput); err == nil {
|
||||
return errors.New("SQLite 备份文件已存在")
|
||||
} else if !errors.Is(err, os.ErrNotExist) {
|
||||
return fmt.Errorf("检查 SQLite 备份文件失败:%w", err)
|
||||
}
|
||||
statement := "VACUUM INTO '" + strings.ReplaceAll(filepath.ToSlash(absOutput), "'", "''") + "'"
|
||||
if _, err := db.DB.ExecContext(ctx, statement); err != nil {
|
||||
return fmt.Errorf("创建 SQLite 一致性快照失败:%w", err)
|
||||
}
|
||||
if err := os.Chmod(absOutput, 0o600); err != nil {
|
||||
return fmt.Errorf("设置 SQLite 备份权限失败:%w", err)
|
||||
}
|
||||
if err := validateSQLiteDatabase(ctx, absOutput); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateSQLiteDatabase(ctx context.Context, path string) error {
|
||||
if !isRegularFile(path) {
|
||||
return errors.New("SQLite 备份不是普通文件")
|
||||
}
|
||||
db, err := sql.Open("sqlite", path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("打开 SQLite 备份失败:%w", err)
|
||||
}
|
||||
defer db.Close()
|
||||
var result string
|
||||
if err := db.QueryRowContext(ctx, "PRAGMA quick_check").Scan(&result); err != nil {
|
||||
return fmt.Errorf("检查 SQLite 备份完整性失败:%w", err)
|
||||
}
|
||||
if !strings.EqualFold(strings.TrimSpace(result), "ok") {
|
||||
return fmt.Errorf("SQLite 备份完整性检查失败:%s", result)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func sqliteDatabasePath(dsn string) (string, bool, error) {
|
||||
dsn = strings.TrimSpace(dsn)
|
||||
if dsn == ":memory:" || strings.HasPrefix(dsn, "file::memory:") {
|
||||
return "", true, nil
|
||||
}
|
||||
if strings.HasPrefix(dsn, "file:") {
|
||||
dsn = strings.TrimPrefix(strings.SplitN(dsn, "?", 2)[0], "file:")
|
||||
}
|
||||
if dsn == "" {
|
||||
return "", false, errors.New("SQLite 数据库路径不能为空")
|
||||
}
|
||||
return filepath.Clean(filepath.FromSlash(dsn)), false, nil
|
||||
}
|
||||
|
||||
func validateRestoreCompatibility(current, backup config.Config) error {
|
||||
if current.Database.Driver != backup.Database.Driver {
|
||||
return fmt.Errorf("备份数据库类型(%s)与当前配置数据库类型(%s)不一致,拒绝恢复", backup.Database.Driver, current.Database.Driver)
|
||||
}
|
||||
for name, values := range map[string][2]string{
|
||||
"配置目录": {current.Paths.Config, backup.Paths.Config},
|
||||
"数据目录": {current.Paths.Data, backup.Paths.Data},
|
||||
"证书目录": {current.Paths.Certificate, backup.Paths.Certificate},
|
||||
"备份目录": {current.Paths.Backup, backup.Paths.Backup},
|
||||
} {
|
||||
if !samePath(values[0], values[1]) {
|
||||
return fmt.Errorf("备份%s与当前配置不一致,拒绝跨目录恢复", name)
|
||||
}
|
||||
}
|
||||
if backup.Database.Driver == "sqlite" {
|
||||
currentPath, currentMemory, err := sqliteDatabasePath(current.Database.DSN)
|
||||
if err != nil {
|
||||
return fmt.Errorf("解析当前 SQLite 数据库路径失败:%w", err)
|
||||
}
|
||||
backupPath, backupMemory, err := sqliteDatabasePath(backup.Database.DSN)
|
||||
if err != nil {
|
||||
return fmt.Errorf("解析备份 SQLite 数据库路径失败:%w", err)
|
||||
}
|
||||
if currentMemory != backupMemory || (!currentMemory && !samePath(currentPath, backupPath)) {
|
||||
return errors.New("备份 SQLite 数据库路径与当前配置不一致,拒绝跨数据库恢复")
|
||||
}
|
||||
}
|
||||
if backup.Database.Driver == "mysql" && strings.TrimSpace(current.Database.DSN) != strings.TrimSpace(backup.Database.DSN) {
|
||||
return errors.New("备份 MySQL 连接配置与当前配置不一致,拒绝跨数据库恢复")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateBackupSecretStore(ctx context.Context, directory string, cfg config.Config) error {
|
||||
masterPath := filepath.Join(directory, "master.key")
|
||||
secretsPath := filepath.Join(directory, "secrets.json")
|
||||
masterExists := isRegularFile(masterPath)
|
||||
secretsExists := isRegularFile(secretsPath)
|
||||
if !masterExists {
|
||||
if secretsExists {
|
||||
return errors.New("敏感配置包含 secrets.json,但缺少 master.key")
|
||||
}
|
||||
if cfg.SetupReady {
|
||||
return errors.New("已初始化配置缺少 master.key")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
store, err := secretstore.Open(directory)
|
||||
if err != nil {
|
||||
return fmt.Errorf("校验敏感配置主密钥失败:%w", err)
|
||||
}
|
||||
metadata, err := store.List(ctx, "")
|
||||
if err != nil {
|
||||
return fmt.Errorf("校验敏感配置文件失败:%w", err)
|
||||
}
|
||||
available := make(map[string]struct{}, len(metadata))
|
||||
for _, item := range metadata {
|
||||
if _, err := store.Get(ctx, item.Reference); err != nil {
|
||||
return fmt.Errorf("校验敏感配置引用失败:%s:%w", item.Reference, err)
|
||||
}
|
||||
available[item.Reference] = struct{}{}
|
||||
}
|
||||
for _, reference := range []string{cfg.DNS.CredentialRef, cfg.Notification.HTTPCredentialRef, cfg.Notification.SMTPCredentialRef} {
|
||||
reference = strings.TrimSpace(reference)
|
||||
if reference == "" {
|
||||
continue
|
||||
}
|
||||
if _, exists := available[reference]; !exists {
|
||||
return fmt.Errorf("敏感配置缺少配置引用:%s", reference)
|
||||
}
|
||||
}
|
||||
if cfg.SetupReady && !secretsExists {
|
||||
return errors.New("已初始化配置缺少 secrets.json")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func restoreAdditionalAssets(cfg config.Config, input string) error {
|
||||
timestamp := time.Now().UTC().Format("20060102-150405.000000000")
|
||||
rollbacks := make([]func() error, 0, 3)
|
||||
rollbackAll := func() error {
|
||||
var rollbackErr error
|
||||
for index := len(rollbacks) - 1; index >= 0; index-- {
|
||||
rollbackErr = errors.Join(rollbackErr, rollbacks[index]())
|
||||
}
|
||||
return rollbackErr
|
||||
}
|
||||
for _, name := range []string{"master.key", "secrets.json"} {
|
||||
source := filepath.Join(input, name)
|
||||
target := filepath.Join(cfg.Paths.Config, name)
|
||||
info, err := os.Lstat(source)
|
||||
if err == nil {
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
|
||||
return errors.Join(fmt.Errorf("备份敏感配置文件不是普通文件:%s", name), rollbackAll())
|
||||
}
|
||||
rollback, restoreErr := restoreFileWithRollback(source, target, 0o600, timestamp)
|
||||
if restoreErr != nil {
|
||||
return errors.Join(restoreErr, rollbackAll())
|
||||
}
|
||||
rollbacks = append(rollbacks, rollback)
|
||||
continue
|
||||
}
|
||||
if !errors.Is(err, os.ErrNotExist) {
|
||||
return errors.Join(fmt.Errorf("检查备份敏感配置文件失败:%w", err), rollbackAll())
|
||||
}
|
||||
rollback, removeErr := removeFileWithRollback(target, 0o600, timestamp)
|
||||
if removeErr != nil {
|
||||
return errors.Join(removeErr, rollbackAll())
|
||||
}
|
||||
rollbacks = append(rollbacks, rollback)
|
||||
}
|
||||
certificateSource := filepath.Join(input, "certificates")
|
||||
if info, err := os.Lstat(certificateSource); err == nil {
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
|
||||
return errors.Join(errors.New("备份证书路径必须是普通目录"), rollbackAll())
|
||||
}
|
||||
rollback, err := restoreDirectoryWithRollback(certificateSource, cfg.Paths.Certificate, timestamp)
|
||||
if err != nil {
|
||||
return errors.Join(err, rollbackAll())
|
||||
}
|
||||
rollbacks = append(rollbacks, rollback)
|
||||
} else if errors.Is(err, os.ErrNotExist) {
|
||||
rollback, removeErr := removeDirectoryWithRollback(cfg.Paths.Certificate, timestamp)
|
||||
if removeErr != nil {
|
||||
return errors.Join(removeErr, rollbackAll())
|
||||
}
|
||||
rollbacks = append(rollbacks, rollback)
|
||||
} else {
|
||||
return errors.Join(fmt.Errorf("检查备份证书目录失败:%w", err), rollbackAll())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func restoreFileWithRollback(source, target string, mode os.FileMode, timestamp string) (func() error, error) {
|
||||
if !isRegularFile(source) {
|
||||
return nil, errors.New("恢复源文件必须是普通文件")
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(target), 0o700); err != nil {
|
||||
return nil, fmt.Errorf("创建恢复目标目录失败:%w", err)
|
||||
}
|
||||
backupPath := ""
|
||||
if info, err := os.Lstat(target); err == nil {
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
|
||||
return nil, errors.New("恢复目标文件不是普通文件")
|
||||
}
|
||||
backupPath = target + ".before-restore-" + timestamp
|
||||
if err := copyFileExclusive(target, backupPath, mode); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
} else if !errors.Is(err, os.ErrNotExist) {
|
||||
return nil, fmt.Errorf("检查恢复目标文件失败:%w", err)
|
||||
}
|
||||
if err := copyFile(source, target, mode); err != nil {
|
||||
if backupPath != "" {
|
||||
_ = copyFile(backupPath, target, mode)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
return func() error {
|
||||
if backupPath != "" {
|
||||
return copyFile(backupPath, target, mode)
|
||||
}
|
||||
return os.Remove(target)
|
||||
}, nil
|
||||
}
|
||||
|
||||
func removeFileWithRollback(target string, mode os.FileMode, timestamp string) (func() error, error) {
|
||||
info, err := os.Lstat(target)
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
return func() error { return nil }, nil
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("检查恢复目标文件失败:%w", err)
|
||||
}
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
|
||||
return nil, errors.New("恢复目标文件不是普通文件")
|
||||
}
|
||||
backupPath := target + ".before-restore-" + timestamp
|
||||
if err := copyFileExclusive(target, backupPath, mode); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := os.Remove(target); err != nil {
|
||||
return nil, fmt.Errorf("移除备份中不存在的当前文件失败:%w", err)
|
||||
}
|
||||
return func() error { return copyFile(backupPath, target, mode) }, nil
|
||||
}
|
||||
|
||||
func removeDirectoryWithRollback(target, timestamp string) (func() error, error) {
|
||||
info, err := os.Lstat(target)
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
return func() error { return nil }, nil
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("检查证书恢复目标失败:%w", err)
|
||||
}
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
|
||||
return nil, errors.New("证书恢复目标必须是普通目录")
|
||||
}
|
||||
backupPath := target + ".before-restore-" + timestamp
|
||||
if err := os.Rename(target, backupPath); err != nil {
|
||||
return nil, fmt.Errorf("保留现有证书目录失败:%w", err)
|
||||
}
|
||||
return func() error { return os.Rename(backupPath, target) }, nil
|
||||
}
|
||||
|
||||
func restoreDirectoryWithRollback(source, target, timestamp string) (func() error, error) {
|
||||
if pathsOverlap(source, target) {
|
||||
return nil, errors.New("证书恢复源目录和目标目录不能互相包含")
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(target), 0o750); err != nil {
|
||||
return nil, fmt.Errorf("创建证书恢复父目录失败:%w", err)
|
||||
}
|
||||
backupPath := ""
|
||||
if info, err := os.Lstat(target); err == nil {
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
|
||||
return nil, errors.New("证书恢复目标必须是普通目录")
|
||||
}
|
||||
backupPath = target + ".before-restore-" + timestamp
|
||||
if err := os.Rename(target, backupPath); err != nil {
|
||||
return nil, fmt.Errorf("保留现有证书目录失败:%w", err)
|
||||
}
|
||||
} else if !errors.Is(err, os.ErrNotExist) {
|
||||
return nil, fmt.Errorf("检查证书恢复目标失败:%w", err)
|
||||
}
|
||||
if err := copyDirectoryExclusive(source, target); err != nil {
|
||||
_ = os.RemoveAll(target)
|
||||
if backupPath != "" {
|
||||
_ = os.Rename(backupPath, target)
|
||||
}
|
||||
return nil, fmt.Errorf("恢复证书目录失败:%w", err)
|
||||
}
|
||||
return func() error {
|
||||
if err := os.RemoveAll(target); err != nil {
|
||||
return err
|
||||
}
|
||||
if backupPath != "" {
|
||||
return os.Rename(backupPath, target)
|
||||
}
|
||||
return nil
|
||||
}, nil
|
||||
}
|
||||
|
||||
func copyDirectoryExclusive(source, target string) error {
|
||||
if pathsOverlap(source, target) {
|
||||
return errors.New("复制源目录和目标目录不能互相包含")
|
||||
}
|
||||
rootInfo, err := os.Lstat(source)
|
||||
if err != nil {
|
||||
return fmt.Errorf("检查源目录失败:%w", err)
|
||||
}
|
||||
if rootInfo.Mode()&os.ModeSymlink != 0 || !rootInfo.IsDir() {
|
||||
return errors.New("复制源路径必须是普通目录")
|
||||
}
|
||||
if _, err := os.Lstat(target); err == nil {
|
||||
return errors.New("复制目标目录已存在")
|
||||
} else if !errors.Is(err, os.ErrNotExist) {
|
||||
return fmt.Errorf("检查复制目标目录失败:%w", err)
|
||||
}
|
||||
return filepath.WalkDir(source, func(path string, entry fs.DirEntry, walkErr error) error {
|
||||
if walkErr != nil {
|
||||
return walkErr
|
||||
}
|
||||
info, err := entry.Info()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if info.Mode()&os.ModeSymlink != 0 {
|
||||
return fmt.Errorf("目录中不允许包含符号链接:%s", path)
|
||||
}
|
||||
relative, err := filepath.Rel(source, path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
destination := filepath.Join(target, relative)
|
||||
if entry.IsDir() {
|
||||
mode := info.Mode().Perm()
|
||||
if mode == 0 {
|
||||
mode = 0o750
|
||||
}
|
||||
return os.Mkdir(destination, mode)
|
||||
}
|
||||
if !info.Mode().IsRegular() {
|
||||
return fmt.Errorf("目录中包含不支持的文件类型:%s", path)
|
||||
}
|
||||
return copyFileExclusive(path, destination, info.Mode().Perm())
|
||||
})
|
||||
}
|
||||
|
||||
func pathsOverlap(left, right string) bool {
|
||||
leftAbs, leftErr := filepath.Abs(filepath.Clean(left))
|
||||
rightAbs, rightErr := filepath.Abs(filepath.Clean(right))
|
||||
if leftErr != nil || rightErr != nil {
|
||||
return true
|
||||
}
|
||||
return pathContains(leftAbs, rightAbs) || pathContains(rightAbs, leftAbs)
|
||||
}
|
||||
|
||||
func pathContains(parent, child string) bool {
|
||||
relative, err := filepath.Rel(parent, child)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return relative == "." || (relative != ".." && !strings.HasPrefix(relative, ".."+string(filepath.Separator)))
|
||||
}
|
||||
|
||||
func writeBackupManifest(directory string) error {
|
||||
manifest, err := buildBackupManifest(directory)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
data, err := json.MarshalIndent(manifest, "", " ")
|
||||
if err != nil {
|
||||
return fmt.Errorf("生成备份清单失败:%w", err)
|
||||
}
|
||||
data = append(data, '\n')
|
||||
path := filepath.Join(directory, "manifest.json")
|
||||
file, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
|
||||
if err != nil {
|
||||
return fmt.Errorf("创建备份清单失败:%w", err)
|
||||
}
|
||||
if _, err := file.Write(data); err != nil {
|
||||
_ = file.Close()
|
||||
return fmt.Errorf("写入备份清单失败:%w", err)
|
||||
}
|
||||
if err := file.Sync(); err != nil {
|
||||
_ = file.Close()
|
||||
return fmt.Errorf("同步备份清单失败:%w", err)
|
||||
}
|
||||
if err := file.Close(); err != nil {
|
||||
return fmt.Errorf("关闭备份清单失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func syncDirectory(path string) error {
|
||||
if runtime.GOOS == "windows" {
|
||||
return nil
|
||||
}
|
||||
directory, err := os.Open(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer directory.Close()
|
||||
return directory.Sync()
|
||||
}
|
||||
|
||||
func buildBackupManifest(directory string) (backupManifest, error) {
|
||||
manifest := backupManifest{Version: backupManifestVersion, CreatedAt: time.Now().UTC()}
|
||||
err := filepath.WalkDir(directory, func(path string, entry fs.DirEntry, walkErr error) error {
|
||||
if walkErr != nil {
|
||||
return walkErr
|
||||
}
|
||||
if path == directory || entry.IsDir() {
|
||||
return nil
|
||||
}
|
||||
if entry.Type()&os.ModeSymlink != 0 {
|
||||
return fmt.Errorf("备份中不允许包含符号链接:%s", path)
|
||||
}
|
||||
info, err := entry.Info()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !info.Mode().IsRegular() {
|
||||
return fmt.Errorf("备份中包含不支持的文件类型:%s", path)
|
||||
}
|
||||
relative, err := filepath.Rel(directory, path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
digest, err := fileSHA256(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
manifest.Files = append(manifest.Files, backupManifestFile{
|
||||
Path: filepath.ToSlash(relative), Mode: uint32(info.Mode().Perm()), Size: info.Size(), SHA256: digest,
|
||||
})
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return backupManifest{}, fmt.Errorf("生成备份文件清单失败:%w", err)
|
||||
}
|
||||
sort.Slice(manifest.Files, func(i, j int) bool { return manifest.Files[i].Path < manifest.Files[j].Path })
|
||||
return manifest, nil
|
||||
}
|
||||
|
||||
func validateBackupManifest(directory string) error {
|
||||
path := filepath.Join(directory, "manifest.json")
|
||||
info, err := os.Lstat(path)
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
return errors.New("备份目录缺少 manifest.json,拒绝恢复未校验的备份")
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("检查备份清单失败:%w", err)
|
||||
}
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
|
||||
return errors.New("备份清单必须是普通文件")
|
||||
}
|
||||
if info.Size() > 8<<20 {
|
||||
return errors.New("备份清单超过 8 MiB 安全上限")
|
||||
}
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("读取备份清单失败:%w", err)
|
||||
}
|
||||
var expected backupManifest
|
||||
if err := json.Unmarshal(data, &expected); err != nil {
|
||||
return fmt.Errorf("解析备份清单失败:%w", err)
|
||||
}
|
||||
if expected.Version != backupManifestVersion {
|
||||
return fmt.Errorf("不支持的备份清单版本:%d", expected.Version)
|
||||
}
|
||||
if expected.CreatedAt.IsZero() {
|
||||
return errors.New("备份清单缺少创建时间")
|
||||
}
|
||||
if len(expected.Files) == 0 {
|
||||
return errors.New("备份清单不包含任何文件")
|
||||
}
|
||||
actual, err := buildBackupManifestExcludingManifest(directory)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(actual.Files) != len(expected.Files) {
|
||||
return errors.New("备份文件数量与清单不一致")
|
||||
}
|
||||
for index := range expected.Files {
|
||||
left, right := expected.Files[index], actual.Files[index]
|
||||
if left.Path != right.Path || left.Mode != right.Mode || left.Size != right.Size || !strings.EqualFold(left.SHA256, right.SHA256) {
|
||||
return fmt.Errorf("备份文件校验失败:%s", left.Path)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func buildBackupManifestExcludingManifest(directory string) (backupManifest, error) {
|
||||
manifest, err := buildBackupManifest(directory)
|
||||
if err != nil {
|
||||
return backupManifest{}, err
|
||||
}
|
||||
filtered := manifest.Files[:0]
|
||||
for _, item := range manifest.Files {
|
||||
if item.Path != "manifest.json" {
|
||||
filtered = append(filtered, item)
|
||||
}
|
||||
}
|
||||
manifest.Files = filtered
|
||||
return manifest, nil
|
||||
}
|
||||
|
||||
func fileSHA256(path string) (string, error) {
|
||||
file, err := os.Open(path)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
defer file.Close()
|
||||
hash := sha256.New()
|
||||
if _, err := io.Copy(hash, file); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return hex.EncodeToString(hash.Sum(nil)), nil
|
||||
}
|
||||
|
||||
func removeIfExists(path string) error {
|
||||
if err := os.Remove(path); err != nil && !errors.Is(err, os.ErrNotExist) {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,493 @@
|
||||
package cli
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
|
||||
)
|
||||
|
||||
func TestCreateBackupIncludesSecretsCertificatesAndSQLiteSnapshot(t *testing.T) {
|
||||
base := t.TempDir()
|
||||
cfg := config.Default(base)
|
||||
for _, directory := range []string{cfg.Paths.Config, cfg.Paths.Data, cfg.Paths.Certificate, cfg.Paths.Backup} {
|
||||
if err := os.MkdirAll(directory, 0o700); err != nil {
|
||||
t.Fatalf("创建测试目录失败:%v", err)
|
||||
}
|
||||
}
|
||||
configPath := filepath.Join(cfg.Paths.Config, "scert.json")
|
||||
if err := cfg.Save(configPath); err != nil {
|
||||
t.Fatalf("保存测试配置失败:%v", err)
|
||||
}
|
||||
if err := createTestSecretStore(cfg.Paths.Config); err != nil {
|
||||
t.Fatalf("创建敏感配置失败:%v", err)
|
||||
}
|
||||
versionDirectory := filepath.Join(cfg.Paths.Certificate, "example.com", "20260831-V1.0")
|
||||
if err := os.MkdirAll(versionDirectory, 0o750); err != nil {
|
||||
t.Fatalf("创建证书版本目录失败:%v", err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(versionDirectory, "fullchain.pem"), []byte("certificate"), 0o644); err != nil {
|
||||
t.Fatalf("写入证书失败:%v", err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(versionDirectory, "privkey.pem"), []byte("private-key"), 0o600); err != nil {
|
||||
t.Fatalf("写入私钥失败:%v", err)
|
||||
}
|
||||
|
||||
db, err := database.Open(context.Background(), cfg.Database)
|
||||
if err != nil {
|
||||
t.Fatalf("打开测试数据库失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
if err := database.Migrate(context.Background(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("迁移测试数据库失败:%v", err)
|
||||
}
|
||||
if _, err := db.DB.Exec(`INSERT INTO audit_logs (action, resource_type, resource_id, status, message, created_at) VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`, "backup_test", "test", "1", "success", "备份测试"); err != nil {
|
||||
t.Fatalf("写入测试数据失败:%v", err)
|
||||
}
|
||||
|
||||
output := filepath.Join(base, "backup-output")
|
||||
if err := createBackup(context.Background(), cfg, configPath, output); err != nil {
|
||||
t.Fatalf("创建完整备份失败:%v", err)
|
||||
}
|
||||
if err := validateBackupManifest(output); err != nil {
|
||||
t.Fatalf("备份清单校验失败:%v", err)
|
||||
}
|
||||
for _, relative := range []string{
|
||||
"scert.json",
|
||||
"master.key",
|
||||
"secrets.json",
|
||||
"scert.db",
|
||||
"manifest.json",
|
||||
filepath.Join("certificates", "example.com", "20260831-V1.0", "fullchain.pem"),
|
||||
filepath.Join("certificates", "example.com", "20260831-V1.0", "privkey.pem"),
|
||||
} {
|
||||
if _, err := os.Stat(filepath.Join(output, relative)); err != nil {
|
||||
t.Fatalf("完整备份缺少文件 %s:%v", relative, err)
|
||||
}
|
||||
}
|
||||
|
||||
snapshot, err := sql.Open("sqlite", filepath.Join(output, "scert.db"))
|
||||
if err != nil {
|
||||
t.Fatalf("打开 SQLite 快照失败:%v", err)
|
||||
}
|
||||
defer snapshot.Close()
|
||||
var count int
|
||||
if err := snapshot.QueryRow(`SELECT COUNT(*) FROM audit_logs WHERE action = 'backup_test'`).Scan(&count); err != nil {
|
||||
t.Fatalf("读取 SQLite 快照失败:%v", err)
|
||||
}
|
||||
if count != 1 {
|
||||
t.Fatalf("SQLite 快照缺少备份时数据:%d", count)
|
||||
}
|
||||
if runtime.GOOS != "windows" {
|
||||
for _, relative := range []string{"master.key", "secrets.json", "scert.db", "manifest.json"} {
|
||||
info, err := os.Stat(filepath.Join(output, relative))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if info.Mode().Perm() != 0o600 {
|
||||
t.Fatalf("敏感备份文件权限不正确 %s:%o", relative, info.Mode().Perm())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBackupManifestRejectsTampering(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(directory, "scert.json"), []byte("original"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := writeBackupManifest(directory); err != nil {
|
||||
t.Fatalf("写入备份清单失败:%v", err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(directory, "scert.json"), []byte("tampered"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := validateBackupManifest(directory); err == nil || !strings.Contains(err.Error(), "校验失败") {
|
||||
t.Fatalf("被篡改的备份未被拒绝:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBackupManifestIsRequired(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(directory, "scert.json"), []byte("{}"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := validateBackupManifest(directory); err == nil || !strings.Contains(err.Error(), "缺少 manifest.json") {
|
||||
t.Fatalf("缺少清单的备份未被拒绝:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateBackupDoesNotChangeExistingParentPermissions(t *testing.T) {
|
||||
if runtime.GOOS == "windows" {
|
||||
t.Skip("Windows 不提供 POSIX 目录权限语义")
|
||||
}
|
||||
base := t.TempDir()
|
||||
parent := filepath.Join(base, "shared")
|
||||
if err := os.Mkdir(parent, 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg := config.Default(filepath.Join(base, "scert"))
|
||||
for _, directory := range []string{cfg.Paths.Config, cfg.Paths.Data} {
|
||||
if err := os.MkdirAll(directory, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
configPath := filepath.Join(cfg.Paths.Config, "scert.json")
|
||||
if err := cfg.Save(configPath); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := createSQLiteTestDatabase(cfg.Database.DSN, "parent_mode"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := createBackup(context.Background(), cfg, configPath, filepath.Join(parent, "backup")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
info, err := os.Stat(parent)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if info.Mode().Perm() != 0o755 {
|
||||
t.Fatalf("备份操作修改了既有父目录权限:%o", info.Mode().Perm())
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateBackupRequiresSecretsWhenInitialized(t *testing.T) {
|
||||
base := t.TempDir()
|
||||
cfg := config.Default(base)
|
||||
for _, directory := range []string{cfg.Paths.Config, cfg.Paths.Data} {
|
||||
if err := os.MkdirAll(directory, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
configPath := filepath.Join(cfg.Paths.Config, "scert.json")
|
||||
if err := cfg.Save(configPath); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := createSQLiteTestDatabase(cfg.Database.DSN, "missing_secrets"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cfg.SetupReady = true
|
||||
if err := createBackup(context.Background(), cfg, configPath, filepath.Join(base, "backup")); err == nil || !strings.Contains(err.Error(), "缺少 master.key") {
|
||||
t.Fatalf("已初始化系统缺少敏感文件时仍创建了备份:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRestoreAdditionalAssetsKeepsRollbackCopies(t *testing.T) {
|
||||
base := t.TempDir()
|
||||
cfg := config.Default(filepath.Join(base, "target"))
|
||||
input := filepath.Join(base, "backup")
|
||||
if err := os.MkdirAll(filepath.Join(input, "certificates", "example.com"), 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.MkdirAll(cfg.Paths.Config, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Join(cfg.Paths.Certificate, "old.example.com"), 0o750); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for path, value := range map[string]string{
|
||||
filepath.Join(input, "master.key"): "new-master",
|
||||
filepath.Join(input, "secrets.json"): "new-secrets",
|
||||
filepath.Join(input, "certificates", "example.com", "privkey.pem"): "new-private-key",
|
||||
filepath.Join(cfg.Paths.Config, "master.key"): "old-master",
|
||||
filepath.Join(cfg.Paths.Config, "secrets.json"): "old-secrets",
|
||||
filepath.Join(cfg.Paths.Certificate, "old.example.com", "cert.pem"): "old-certificate",
|
||||
} {
|
||||
if err := os.WriteFile(path, []byte(value), 0o600); err != nil {
|
||||
t.Fatalf("写入测试恢复文件失败:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
if err := restoreAdditionalAssets(cfg, input); err != nil {
|
||||
t.Fatalf("恢复敏感配置和证书失败:%v", err)
|
||||
}
|
||||
for path, expected := range map[string]string{
|
||||
filepath.Join(cfg.Paths.Config, "master.key"): "new-master",
|
||||
filepath.Join(cfg.Paths.Config, "secrets.json"): "new-secrets",
|
||||
filepath.Join(cfg.Paths.Certificate, "example.com", "privkey.pem"): "new-private-key",
|
||||
} {
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil || string(data) != expected {
|
||||
t.Fatalf("恢复结果不正确 %s:data=%q err=%v", path, data, err)
|
||||
}
|
||||
}
|
||||
for _, pattern := range []string{
|
||||
filepath.Join(cfg.Paths.Config, "master.key.before-restore-*"),
|
||||
filepath.Join(cfg.Paths.Config, "secrets.json.before-restore-*"),
|
||||
cfg.Paths.Certificate + ".before-restore-*",
|
||||
} {
|
||||
matches, err := filepath.Glob(pattern)
|
||||
if err != nil || len(matches) != 1 {
|
||||
t.Fatalf("恢复前副本不正确 %s:matches=%v err=%v", pattern, matches, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRestoreAdditionalAssetsRestoresAbsentState(t *testing.T) {
|
||||
base := t.TempDir()
|
||||
cfg := config.Default(filepath.Join(base, "target"))
|
||||
input := filepath.Join(base, "backup")
|
||||
if err := os.MkdirAll(input, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.MkdirAll(cfg.Paths.Config, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.MkdirAll(cfg.Paths.Certificate, 0o750); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, path := range []string{
|
||||
filepath.Join(cfg.Paths.Config, "master.key"),
|
||||
filepath.Join(cfg.Paths.Config, "secrets.json"),
|
||||
filepath.Join(cfg.Paths.Certificate, "current.pem"),
|
||||
} {
|
||||
if err := os.WriteFile(path, []byte("current"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if err := restoreAdditionalAssets(cfg, input); err != nil {
|
||||
t.Fatalf("恢复缺失状态失败:%v", err)
|
||||
}
|
||||
for _, path := range []string{
|
||||
filepath.Join(cfg.Paths.Config, "master.key"),
|
||||
filepath.Join(cfg.Paths.Config, "secrets.json"),
|
||||
cfg.Paths.Certificate,
|
||||
} {
|
||||
if _, err := os.Lstat(path); !errors.Is(err, os.ErrNotExist) {
|
||||
t.Fatalf("备份中不存在的资产仍保留在当前路径:%s err=%v", path, err)
|
||||
}
|
||||
}
|
||||
for _, pattern := range []string{
|
||||
filepath.Join(cfg.Paths.Config, "master.key.before-restore-*"),
|
||||
filepath.Join(cfg.Paths.Config, "secrets.json.before-restore-*"),
|
||||
cfg.Paths.Certificate + ".before-restore-*",
|
||||
} {
|
||||
matches, err := filepath.Glob(pattern)
|
||||
if err != nil || len(matches) != 1 {
|
||||
t.Fatalf("缺失状态恢复未保留恢复前副本 %s:matches=%v err=%v", pattern, matches, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateRestoreCompatibilityRejectsCrossDatabase(t *testing.T) {
|
||||
current := config.Default(t.TempDir())
|
||||
backup := current
|
||||
backup.Database.DSN = filepath.Join(t.TempDir(), "other.db")
|
||||
if err := validateRestoreCompatibility(current, backup); err == nil || !strings.Contains(err.Error(), "跨数据库") {
|
||||
t.Fatalf("跨数据库恢复未被拒绝:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRestoreCommandRestoresCompleteSQLiteBackup(t *testing.T) {
|
||||
cfg, currentPath, input := prepareRestoreCommandFixture(t, false)
|
||||
expectedMaster, err := os.ReadFile(filepath.Join(input, "master.key"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
expectedSecrets, err := os.ReadFile(filepath.Join(input, "secrets.json"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
expectedConfig, err := os.ReadFile(filepath.Join(input, "scert.json"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
previousConfigPath := configPath
|
||||
configPath = currentPath
|
||||
defer func() { configPath = previousConfigPath }()
|
||||
|
||||
command := newRestoreCommand()
|
||||
var output strings.Builder
|
||||
command.SetOut(&output)
|
||||
command.SetErr(&output)
|
||||
command.SetArgs([]string{"--input", input})
|
||||
if err := command.Execute(); err != nil {
|
||||
t.Fatalf("执行完整恢复失败:%v\n%s", err, output.String())
|
||||
}
|
||||
restored, err := config.Load(currentPath)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if restored.Server.Port != 9005 {
|
||||
t.Fatalf("配置未恢复:%d", restored.Server.Port)
|
||||
}
|
||||
actualConfig, err := os.ReadFile(currentPath)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(actualConfig) != string(expectedConfig) {
|
||||
t.Fatal("恢复后的配置文件与备份内容不一致")
|
||||
}
|
||||
for path, expected := range map[string][]byte{
|
||||
filepath.Join(cfg.Paths.Config, "master.key"): expectedMaster,
|
||||
filepath.Join(cfg.Paths.Config, "secrets.json"): expectedSecrets,
|
||||
filepath.Join(cfg.Paths.Certificate, "example.com", "cert.pem"): []byte("new-certificate"),
|
||||
} {
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil || string(data) != string(expected) {
|
||||
t.Fatalf("恢复文件不正确 %s:data=%q err=%v", path, data, err)
|
||||
}
|
||||
}
|
||||
if count, err := auditActionCount(cfg.Database.DSN, "restored"); err != nil || count != 1 {
|
||||
t.Fatalf("SQLite 数据未恢复:count=%d err=%v", count, err)
|
||||
}
|
||||
if count, err := auditActionCount(cfg.Database.DSN, "current"); err != nil || count != 0 {
|
||||
t.Fatalf("恢复后仍存在当前数据:count=%d err=%v", count, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRestoreCommandRollsBackCoreAndSecretsOnCertificateFailure(t *testing.T) {
|
||||
cfg, currentPath, input := prepareRestoreCommandFixture(t, true)
|
||||
previousConfigPath := configPath
|
||||
configPath = currentPath
|
||||
defer func() { configPath = previousConfigPath }()
|
||||
|
||||
command := newRestoreCommand()
|
||||
var output strings.Builder
|
||||
command.SetOut(&output)
|
||||
command.SetErr(&output)
|
||||
command.SetArgs([]string{"--input", input})
|
||||
err := command.Execute()
|
||||
if err == nil || !strings.Contains(err.Error(), "证书恢复目标必须是普通目录") {
|
||||
t.Fatalf("证书恢复失败未触发:err=%v output=%s", err, output.String())
|
||||
}
|
||||
restored, loadErr := config.Load(currentPath)
|
||||
if loadErr != nil {
|
||||
t.Fatal(loadErr)
|
||||
}
|
||||
if restored.Server.Port != 9004 {
|
||||
t.Fatalf("失败后配置未回滚:%d", restored.Server.Port)
|
||||
}
|
||||
master, readErr := os.ReadFile(filepath.Join(cfg.Paths.Config, "master.key"))
|
||||
if readErr != nil || string(master) != "old-master" {
|
||||
t.Fatalf("失败后主密钥未回滚:data=%q err=%v", master, readErr)
|
||||
}
|
||||
certificateTarget, readErr := os.ReadFile(cfg.Paths.Certificate)
|
||||
if readErr != nil || string(certificateTarget) != "blocked-certificate-target" {
|
||||
t.Fatalf("失败后证书目标被破坏:data=%q err=%v", certificateTarget, readErr)
|
||||
}
|
||||
if count, countErr := auditActionCount(cfg.Database.DSN, "current"); countErr != nil || count != 1 {
|
||||
t.Fatalf("失败后 SQLite 数据未回滚:count=%d err=%v", count, countErr)
|
||||
}
|
||||
if count, countErr := auditActionCount(cfg.Database.DSN, "restored"); countErr != nil || count != 0 {
|
||||
t.Fatalf("失败后仍残留恢复数据:count=%d err=%v", count, countErr)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteDatabasePathSupportsFileURI(t *testing.T) {
|
||||
path, memory, err := sqliteDatabasePath("file:/var/lib/scert/scert.db?_pragma=busy_timeout(5000)")
|
||||
if err != nil || memory {
|
||||
t.Fatalf("SQLite 文件 URI 解析失败:path=%s memory=%t err=%v", path, memory, err)
|
||||
}
|
||||
if filepath.ToSlash(path) != "/var/lib/scert/scert.db" {
|
||||
t.Fatalf("SQLite 文件 URI 路径不正确:%s", path)
|
||||
}
|
||||
if _, memory, err := sqliteDatabasePath("file::memory:?cache=shared"); err != nil || !memory {
|
||||
t.Fatalf("SQLite 内存 URI 识别失败:memory=%t err=%v", memory, err)
|
||||
}
|
||||
}
|
||||
|
||||
func createSQLiteTestDatabase(path, action string) error {
|
||||
db, err := sql.Open("sqlite", path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer db.Close()
|
||||
if err := database.Migrate(context.Background(), db, "sqlite"); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = db.Exec(`INSERT INTO audit_logs (action, resource_type, resource_id, status, message, created_at) VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`, action, "test", "1", "success", action)
|
||||
return err
|
||||
}
|
||||
|
||||
func prepareRestoreCommandFixture(t *testing.T, blockedCertificate bool) (config.Config, string, string) {
|
||||
t.Helper()
|
||||
base := t.TempDir()
|
||||
cfg := config.Default(filepath.Join(base, "target"))
|
||||
for _, directory := range []string{cfg.Paths.Config, cfg.Paths.Data, cfg.Paths.Backup} {
|
||||
if err := os.MkdirAll(directory, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if blockedCertificate {
|
||||
if err := os.MkdirAll(filepath.Dir(cfg.Paths.Certificate), 0o750); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(cfg.Paths.Certificate, []byte("blocked-certificate-target"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
} else {
|
||||
if err := os.MkdirAll(filepath.Join(cfg.Paths.Certificate, "old.example.com"), 0o750); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(cfg.Paths.Certificate, "old.example.com", "cert.pem"), []byte("old-certificate"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
cfg.Server.Port = 9004
|
||||
currentPath := filepath.Join(cfg.Paths.Config, "scert.json")
|
||||
if err := cfg.Save(currentPath); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := createSQLiteTestDatabase(cfg.Database.DSN, "current"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for path, value := range map[string]string{
|
||||
filepath.Join(cfg.Paths.Config, "master.key"): "old-master",
|
||||
filepath.Join(cfg.Paths.Config, "secrets.json"): "old-secrets",
|
||||
} {
|
||||
if err := os.WriteFile(path, []byte(value), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
input := filepath.Join(base, "restore-input")
|
||||
if err := os.MkdirAll(filepath.Join(input, "certificates", "example.com"), 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
backupConfig := cfg
|
||||
backupConfig.Server.Port = 9005
|
||||
if err := backupConfig.Save(filepath.Join(input, "scert.json")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := createSQLiteTestDatabase(filepath.Join(input, "scert.db"), "restored"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := createTestSecretStore(input); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(input, "certificates", "example.com", "cert.pem"), []byte("new-certificate"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := writeBackupManifest(input); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return cfg, currentPath, input
|
||||
}
|
||||
|
||||
func auditActionCount(path, action string) (int, error) {
|
||||
db, err := sql.Open("sqlite", path)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
defer db.Close()
|
||||
var count int
|
||||
err = db.QueryRow(`SELECT COUNT(*) FROM audit_logs WHERE action = ?`, action).Scan(&count)
|
||||
return count, err
|
||||
}
|
||||
|
||||
func createTestSecretStore(directory string) error {
|
||||
store, err := secretstore.Open(directory)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return store.Put(context.Background(), "secret://test/backup", map[string]string{"token": "encrypted-test-value"})
|
||||
}
|
||||
@@ -17,6 +17,7 @@ import (
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/app"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/processlock"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
|
||||
)
|
||||
|
||||
@@ -330,29 +331,18 @@ func newBackupCommand() *cobra.Command {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
lock, err := acquireProcessLock(cfg, "服务正在运行或另一个备份恢复任务正在执行;请先停止 Scert 服务")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer lock.Close()
|
||||
if strings.TrimSpace(output) == "" {
|
||||
output = filepath.Join(cfg.Paths.Backup, "scert-"+time.Now().UTC().Format("20060102-150405.000000000"))
|
||||
}
|
||||
output = filepath.Clean(output)
|
||||
if err := ensureBackupDestination(output); err != nil {
|
||||
if err := createBackup(cmd.Context(), cfg, resolveConfigPath(), output); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.MkdirAll(output, 0o700); err != nil {
|
||||
return fmt.Errorf("创建备份目录失败:%w", err)
|
||||
}
|
||||
if err := copyFileExclusive(resolveConfigPath(), filepath.Join(output, "scert.json"), 0o600); err != nil {
|
||||
return err
|
||||
}
|
||||
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" {
|
||||
if err := copyFileExclusive(cfg.Database.DSN, filepath.Join(output, "scert.db"), 0o600); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if cfg.Database.Driver == "mysql" {
|
||||
if err := backupMySQL(cmd.Context(), cfg, filepath.Join(output, "scert.sql")); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
_, err = fmt.Fprintf(cmd.OutOrStdout(), "备份已创建:%s\n", output)
|
||||
return err
|
||||
},
|
||||
@@ -371,21 +361,42 @@ func newRestoreCommand() *cobra.Command {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := validateBackupManifest(input); err != nil {
|
||||
return err
|
||||
}
|
||||
configFile := filepath.Join(input, "scert.json")
|
||||
cfg, err := config.Load(configFile)
|
||||
if err != nil {
|
||||
return fmt.Errorf("读取备份配置失败:%w", err)
|
||||
}
|
||||
if err := validateBackupSecretStore(cmd.Context(), input, cfg); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
currentPath := filepath.Clean(resolveConfigPath())
|
||||
expectedConfigPath := filepath.Join(cfg.Paths.Config, "scert.json")
|
||||
if !samePath(currentPath, expectedConfigPath) {
|
||||
return fmt.Errorf("恢复目标配置路径必须与备份配置目录一致:%s", expectedConfigPath)
|
||||
}
|
||||
currentConfig, currentConfigErr := config.Load(currentPath)
|
||||
if currentConfigErr != nil && !errors.Is(currentConfigErr, os.ErrNotExist) {
|
||||
return fmt.Errorf("读取当前配置失败:%w", currentConfigErr)
|
||||
}
|
||||
if currentConfigErr == nil && currentConfig.Database.Driver != cfg.Database.Driver {
|
||||
return fmt.Errorf("备份数据库类型(%s)与当前配置数据库类型(%s)不一致,拒绝恢复", cfg.Database.Driver, currentConfig.Database.Driver)
|
||||
if currentConfigErr == nil {
|
||||
if err := validateRestoreCompatibility(currentConfig, cfg); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if info, statErr := os.Stat(currentPath); statErr == nil && !info.Mode().IsRegular() {
|
||||
lockConfig := cfg
|
||||
if currentConfigErr == nil {
|
||||
lockConfig = currentConfig
|
||||
}
|
||||
lock, err := acquireProcessLock(lockConfig, "服务正在运行或另一个备份恢复任务正在执行;请先停止 Scert 服务")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer lock.Close()
|
||||
if info, statErr := os.Lstat(currentPath); statErr == nil && (info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular()) {
|
||||
return errors.New("当前配置路径不是普通文件")
|
||||
} else if statErr != nil && !errors.Is(statErr, os.ErrNotExist) {
|
||||
return fmt.Errorf("检查当前配置失败:%w", statErr)
|
||||
@@ -397,25 +408,36 @@ func newRestoreCommand() *cobra.Command {
|
||||
}
|
||||
|
||||
databaseSource := filepath.Join(input, "scert.db")
|
||||
databaseSourceInfo, databaseSourceErr := os.Stat(databaseSource)
|
||||
databaseSourceExists := databaseSourceErr == nil
|
||||
databaseSourceInfo, databaseSourceErr := os.Lstat(databaseSource)
|
||||
databaseSourceExists := databaseSourceErr == nil && databaseSourceInfo.Mode().IsRegular()
|
||||
if databaseSourceErr != nil && !errors.Is(databaseSourceErr, os.ErrNotExist) {
|
||||
return fmt.Errorf("检查备份数据库失败:%w", databaseSourceErr)
|
||||
}
|
||||
if databaseSourceExists && !databaseSourceInfo.Mode().IsRegular() {
|
||||
if databaseSourceErr == nil && !databaseSourceInfo.Mode().IsRegular() {
|
||||
return errors.New("备份数据库不是普通文件")
|
||||
}
|
||||
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" && !databaseSourceExists {
|
||||
databaseTarget := ""
|
||||
sqliteMemory := false
|
||||
if cfg.Database.Driver == "sqlite" {
|
||||
databaseTarget, sqliteMemory, err = sqliteDatabasePath(cfg.Database.DSN)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if cfg.Database.Driver == "sqlite" && !sqliteMemory && !databaseSourceExists {
|
||||
return errors.New("SQLite 备份目录缺少有效的 scert.db 文件")
|
||||
}
|
||||
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" && databaseSourceExists {
|
||||
if samePath(databaseSource, cfg.Database.DSN) {
|
||||
if cfg.Database.Driver == "sqlite" && !sqliteMemory && databaseSourceExists {
|
||||
if err := validateSQLiteDatabase(cmd.Context(), databaseSource); err != nil {
|
||||
return err
|
||||
}
|
||||
if samePath(databaseSource, databaseTarget) {
|
||||
return errors.New("备份数据库与当前数据库路径相同")
|
||||
}
|
||||
if err := ensureParentDirectory(cfg.Database.DSN); err != nil {
|
||||
if err := ensureParentDirectory(databaseTarget); err != nil {
|
||||
return fmt.Errorf("创建当前数据库父目录失败:%w", err)
|
||||
}
|
||||
if databaseTargetInfo, statErr := os.Stat(cfg.Database.DSN); statErr == nil && !databaseTargetInfo.Mode().IsRegular() {
|
||||
if databaseTargetInfo, statErr := os.Lstat(databaseTarget); statErr == nil && (databaseTargetInfo.Mode()&os.ModeSymlink != 0 || !databaseTargetInfo.Mode().IsRegular()) {
|
||||
return errors.New("当前数据库不是普通文件")
|
||||
} else if statErr != nil && !errors.Is(statErr, os.ErrNotExist) {
|
||||
return fmt.Errorf("检查当前数据库失败:%w", statErr)
|
||||
@@ -431,9 +453,9 @@ func newRestoreCommand() *cobra.Command {
|
||||
}
|
||||
|
||||
databaseBackupPath := ""
|
||||
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" && databaseSourceExists && isRegularFile(cfg.Database.DSN) {
|
||||
databaseBackupPath = cfg.Database.DSN + ".before-restore-" + time.Now().UTC().Format("20060102-150405.000000000")
|
||||
if err := copyFileExclusive(cfg.Database.DSN, databaseBackupPath, 0o600); err != nil {
|
||||
if cfg.Database.Driver == "sqlite" && !sqliteMemory && databaseSourceExists && isRegularFile(databaseTarget) {
|
||||
databaseBackupPath = databaseTarget + ".before-restore-" + time.Now().UTC().Format("20060102-150405.000000000")
|
||||
if err := copyFileExclusive(databaseTarget, databaseBackupPath, 0o600); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -446,34 +468,50 @@ func newRestoreCommand() *cobra.Command {
|
||||
}
|
||||
}
|
||||
|
||||
if err := cfg.Save(currentPath); err != nil {
|
||||
return err
|
||||
}
|
||||
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" && databaseSourceExists {
|
||||
if err := copyFile(databaseSource, cfg.Database.DSN, 0o600); err != nil {
|
||||
if configBackupPath != "" {
|
||||
_ = copyFile(configBackupPath, currentPath, 0o600)
|
||||
}
|
||||
configRestoreAttempted := false
|
||||
sqliteRestoreAttempted := false
|
||||
mysqlRestoreAttempted := false
|
||||
rollbackCore := func() error {
|
||||
var rollbackErr error
|
||||
if mysqlRestoreAttempted && mysqlBackupPath != "" {
|
||||
rollbackErr = errors.Join(rollbackErr, restoreMySQL(cmd.Context(), cfg, mysqlBackupPath))
|
||||
}
|
||||
if sqliteRestoreAttempted {
|
||||
if databaseBackupPath != "" {
|
||||
_ = copyFile(databaseBackupPath, cfg.Database.DSN, 0o600)
|
||||
rollbackErr = errors.Join(rollbackErr, copyFileAtomic(databaseBackupPath, databaseTarget, 0o600))
|
||||
} else {
|
||||
rollbackErr = errors.Join(rollbackErr, removeIfExists(databaseTarget))
|
||||
}
|
||||
return fmt.Errorf("恢复 SQLite 数据库失败:%w", err)
|
||||
}
|
||||
if configRestoreAttempted {
|
||||
if configBackupPath != "" {
|
||||
rollbackErr = errors.Join(rollbackErr, copyFileAtomic(configBackupPath, currentPath, 0o600))
|
||||
} else {
|
||||
rollbackErr = errors.Join(rollbackErr, removeIfExists(currentPath))
|
||||
}
|
||||
}
|
||||
return rollbackErr
|
||||
}
|
||||
|
||||
configRestoreAttempted = true
|
||||
if err := copyFileAtomic(configFile, currentPath, 0o600); err != nil {
|
||||
return errors.Join(err, rollbackCore())
|
||||
}
|
||||
if cfg.Database.Driver == "sqlite" && !sqliteMemory && databaseSourceExists {
|
||||
sqliteRestoreAttempted = true
|
||||
if err := copyFileAtomic(databaseSource, databaseTarget, 0o600); err != nil {
|
||||
return errors.Join(fmt.Errorf("恢复 SQLite 数据库失败:%w", err), rollbackCore())
|
||||
}
|
||||
}
|
||||
if cfg.Database.Driver == "mysql" {
|
||||
mysqlRestoreAttempted = true
|
||||
if err := restoreMySQL(cmd.Context(), cfg, mysqlSource); err != nil {
|
||||
restoreFailure := fmt.Errorf("恢复 MySQL 数据库失败:%w", err)
|
||||
if mysqlBackupPath != "" {
|
||||
if rollbackErr := restoreMySQL(cmd.Context(), cfg, mysqlBackupPath); rollbackErr != nil {
|
||||
restoreFailure = fmt.Errorf("%w;MySQL 数据库回滚失败:%v", restoreFailure, rollbackErr)
|
||||
}
|
||||
}
|
||||
if configBackupPath != "" {
|
||||
_ = copyFile(configBackupPath, currentPath, 0o600)
|
||||
}
|
||||
return restoreFailure
|
||||
return errors.Join(fmt.Errorf("恢复 MySQL 数据库失败:%w", err), rollbackCore())
|
||||
}
|
||||
}
|
||||
if err := restoreAdditionalAssets(cfg, input); err != nil {
|
||||
return errors.Join(fmt.Errorf("恢复敏感配置或证书失败:%w", err), rollbackCore())
|
||||
}
|
||||
_, err = fmt.Fprintf(cmd.OutOrStdout(), "恢复已完成:%s\n", input)
|
||||
return err
|
||||
},
|
||||
@@ -491,6 +529,17 @@ func openApp(ctx context.Context) (*app.App, error) {
|
||||
return app.NewWithConfigPath(ctx, cfg, resolveConfigPath())
|
||||
}
|
||||
|
||||
func acquireProcessLock(cfg config.Config, busyMessage string) (*processlock.Lock, error) {
|
||||
lock, err := processlock.Acquire(filepath.Join(cfg.Paths.Data, "scert.lock"))
|
||||
if errors.Is(err, processlock.ErrLocked) {
|
||||
return nil, errors.New(busyMessage)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return lock, nil
|
||||
}
|
||||
|
||||
func tailLines(reader io.Reader, count int) ([]string, error) {
|
||||
values := make([]string, 0, count)
|
||||
scanner := bufio.NewScanner(reader)
|
||||
@@ -687,12 +736,59 @@ func copyFile(source, target string, mode os.FileMode) error {
|
||||
_ = output.Close()
|
||||
return fmt.Errorf("复制文件失败:%w", err)
|
||||
}
|
||||
if err := output.Sync(); err != nil {
|
||||
_ = output.Close()
|
||||
return fmt.Errorf("同步目标文件失败:%w", err)
|
||||
}
|
||||
if err := output.Close(); err != nil {
|
||||
return fmt.Errorf("关闭目标文件失败:%w", err)
|
||||
}
|
||||
return os.Chmod(target, mode)
|
||||
}
|
||||
|
||||
func copyFileAtomic(source, target string, mode os.FileMode) error {
|
||||
input, err := os.Open(source)
|
||||
if err != nil {
|
||||
return fmt.Errorf("打开文件失败:%w", err)
|
||||
}
|
||||
defer input.Close()
|
||||
if err := os.MkdirAll(filepath.Dir(target), 0o700); err != nil {
|
||||
return fmt.Errorf("创建目标目录失败:%w", err)
|
||||
}
|
||||
output, err := os.CreateTemp(filepath.Dir(target), ".scert-restore-")
|
||||
if err != nil {
|
||||
return fmt.Errorf("创建恢复暂存文件失败:%w", err)
|
||||
}
|
||||
temporaryPath := output.Name()
|
||||
completed := false
|
||||
defer func() {
|
||||
if !completed {
|
||||
_ = output.Close()
|
||||
_ = os.Remove(temporaryPath)
|
||||
}
|
||||
}()
|
||||
if err := output.Chmod(mode); err != nil {
|
||||
return fmt.Errorf("设置恢复暂存文件权限失败:%w", err)
|
||||
}
|
||||
if _, err := io.Copy(output, input); err != nil {
|
||||
return fmt.Errorf("复制文件失败:%w", err)
|
||||
}
|
||||
if err := output.Sync(); err != nil {
|
||||
return fmt.Errorf("同步恢复暂存文件失败:%w", err)
|
||||
}
|
||||
if err := output.Close(); err != nil {
|
||||
return fmt.Errorf("关闭恢复暂存文件失败:%w", err)
|
||||
}
|
||||
if err := os.Rename(temporaryPath, target); err != nil {
|
||||
return fmt.Errorf("原子替换恢复文件失败:%w", err)
|
||||
}
|
||||
if err := syncDirectory(filepath.Dir(target)); err != nil {
|
||||
return fmt.Errorf("同步恢复目标目录失败:%w", err)
|
||||
}
|
||||
completed = true
|
||||
return nil
|
||||
}
|
||||
|
||||
func copyFileExclusive(source, target string, mode os.FileMode) error {
|
||||
input, err := os.Open(source)
|
||||
if err != nil {
|
||||
@@ -706,14 +802,27 @@ func copyFileExclusive(source, target string, mode os.FileMode) error {
|
||||
if err != nil {
|
||||
return fmt.Errorf("创建目标文件失败:%w", err)
|
||||
}
|
||||
completed := false
|
||||
defer func() {
|
||||
if !completed {
|
||||
_ = output.Close()
|
||||
_ = os.Remove(target)
|
||||
}
|
||||
}()
|
||||
if _, err := io.Copy(output, input); err != nil {
|
||||
_ = output.Close()
|
||||
return fmt.Errorf("复制文件失败:%w", err)
|
||||
}
|
||||
if err := output.Sync(); err != nil {
|
||||
return fmt.Errorf("同步目标文件失败:%w", err)
|
||||
}
|
||||
if err := output.Close(); err != nil {
|
||||
return fmt.Errorf("关闭目标文件失败:%w", err)
|
||||
}
|
||||
return os.Chmod(target, mode)
|
||||
if err := os.Chmod(target, mode); err != nil {
|
||||
return err
|
||||
}
|
||||
completed = true
|
||||
return nil
|
||||
}
|
||||
|
||||
func ensureBackupDestination(path string) error {
|
||||
@@ -733,12 +842,12 @@ func validateRestoreInput(path string) (string, error) {
|
||||
if path == "." || path == "" {
|
||||
return "", errors.New("备份目录不能为空")
|
||||
}
|
||||
info, err := os.Stat(path)
|
||||
info, err := os.Lstat(path)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("检查备份目录失败:%w", err)
|
||||
}
|
||||
if !info.IsDir() {
|
||||
return "", errors.New("备份路径必须是目录")
|
||||
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
|
||||
return "", errors.New("备份路径必须是普通目录,不能使用符号链接")
|
||||
}
|
||||
configFile := filepath.Join(path, "scert.json")
|
||||
if !isRegularFile(configFile) {
|
||||
|
||||
@@ -56,6 +56,17 @@ func TestCopyFileExclusiveRefusesOverwrite(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestCopyFileExclusiveRemovesPartialTargetOnCopyFailure(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
target := filepath.Join(dir, "target")
|
||||
if err := copyFileExclusive(dir, target, 0o600); err == nil {
|
||||
t.Fatal("复制目录时没有返回错误")
|
||||
}
|
||||
if _, err := os.Lstat(target); !os.IsNotExist(err) {
|
||||
t.Fatalf("复制失败后残留了不完整目标文件:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSamePathNormalizesAbsolutePaths(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "file")
|
||||
|
||||
@@ -653,6 +653,11 @@ func newServeCommand() *cobra.Command {
|
||||
if cfg.SetupReady && !cfg.Web.Enabled {
|
||||
return fmt.Errorf("管理页面已关闭")
|
||||
}
|
||||
lock, err := acquireProcessLock(cfg, "Scert 服务已在运行或备份恢复任务正在执行")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer lock.Close()
|
||||
service, err := app.NewWithConfigPath(cmd.Context(), cfg, resolveConfigPath())
|
||||
if err != nil {
|
||||
return err
|
||||
|
||||
@@ -3,6 +3,7 @@ package cli
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
@@ -60,6 +61,9 @@ func newServerAddCommand() *cobra.Command {
|
||||
}
|
||||
defer service.Close()
|
||||
item := value.server()
|
||||
now := time.Now().UTC()
|
||||
item.CreatedAt = now
|
||||
item.UpdatedAt = now
|
||||
item.ID = domain.NewID()
|
||||
if _, err := service.SSHKeys.ValidateReference(cmd.Context(), item.PrivateKeyRef); err != nil {
|
||||
return fmt.Errorf("SSH 私钥引用无效:%w", err)
|
||||
@@ -89,6 +93,7 @@ func newServerEditCommand() *cobra.Command {
|
||||
item := value.server()
|
||||
item.ID = existing.ID
|
||||
item.CreatedAt = existing.CreatedAt
|
||||
item.UpdatedAt = time.Now().UTC()
|
||||
if _, err := service.SSHKeys.ValidateReference(cmd.Context(), item.PrivateKeyRef); err != nil {
|
||||
return fmt.Errorf("SSH 私钥引用无效:%w", err)
|
||||
}
|
||||
@@ -180,7 +185,7 @@ func newDomainServersSetCommand() *cobra.Command {
|
||||
type serverFlags struct {
|
||||
name, address, username, privateKeyRef, fingerprint string
|
||||
certificatePath, privateKeyPath, chainPath, webServer string
|
||||
reloadCommand []string
|
||||
validationCommand, reloadCommand []string
|
||||
port int
|
||||
}
|
||||
|
||||
@@ -195,6 +200,7 @@ func (f *serverFlags) bind(command *cobra.Command) {
|
||||
command.Flags().StringVar(&f.privateKeyPath, "private-key-path", deployment.DefaultPrivateKeyPath, "远程私钥文件路径模板")
|
||||
command.Flags().StringVar(&f.chainPath, "chain-path", deployment.DefaultCertificateChainPath, "远程完整证书链路径模板")
|
||||
command.Flags().StringVar(&f.webServer, "web-server", string(deployment.WebServerNginx), "Web 服务类型:nginx、caddy、apache、custom")
|
||||
command.Flags().StringSliceVar(&f.validationCommand, "validation-command", nil, "自定义配置校验命令及参数")
|
||||
command.Flags().StringSliceVar(&f.reloadCommand, "reload-command", nil, "自定义 reload 命令及参数")
|
||||
for _, name := range []string{"name", "address", "username", "private-key-ref", "host-key-fingerprint"} {
|
||||
_ = command.MarkFlagRequired(name)
|
||||
@@ -202,20 +208,24 @@ func (f *serverFlags) bind(command *cobra.Command) {
|
||||
}
|
||||
|
||||
func (f serverFlags) server() deployment.Server {
|
||||
command := make([]string, 0, len(f.reloadCommand))
|
||||
for _, value := range f.reloadCommand {
|
||||
if value = strings.TrimSpace(value); value != "" {
|
||||
command = append(command, value)
|
||||
}
|
||||
}
|
||||
return deployment.Server{
|
||||
Name: f.name, Address: f.address, Port: f.port, Username: f.username,
|
||||
PrivateKeyRef: f.privateKeyRef, HostKeyFingerprint: f.fingerprint,
|
||||
CertificatePath: f.certificatePath, PrivateKeyPath: f.privateKeyPath,
|
||||
CertificateChainPath: f.chainPath, WebServer: deployment.WebServer(f.webServer), ReloadCommand: command,
|
||||
CertificateChainPath: f.chainPath, WebServer: deployment.WebServer(f.webServer),
|
||||
ValidationCommand: normalizeCommand(f.validationCommand), ReloadCommand: normalizeCommand(f.reloadCommand),
|
||||
}
|
||||
}
|
||||
|
||||
func normalizeCommand(values []string) []string {
|
||||
command := make([]string, 0, len(values))
|
||||
for _, value := range values {
|
||||
if value = strings.TrimSpace(value); value != "" {
|
||||
command = append(command, value)
|
||||
}
|
||||
}
|
||||
return command
|
||||
}
|
||||
func openApplication(cmd *cobra.Command) (*app.App, error) {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
|
||||
Reference in new issue
Block a user