保存模拟部署迁移与最新构建校验阶段成果
Security Checks / security (push) Waiting to run

This commit is contained in:
xuans committed 2026-09-08 18:33:21 +08:00
1 parent 519e2b4a5f
commit d7837de561
45 files changed
+1588 -109

No files matched your search

+5 -1
View File
@@ -46,7 +46,11 @@ func NewFileAuditWriter(root string) (*FileAuditWriter, error) {
if strings.TrimSpace(root) == "" {
return nil, ErrAuditStorageUnavailable
}
directory, err := runtimepath.Directory(root)
name := "data"
if runtimepath.DeploymentLayout(root) {
name = "log"
}
directory, err := runtimepath.SecureDirectory(root, name)
if err != nil {
return nil, err
}
+13
View File
@@ -5,6 +5,8 @@ import (
"path/filepath"
"sort"
"strings"
"git.pcux.cn/xuans/Smail/utils/runtimepath"
)
// ListBackups 枚举合法备份的代次和时间,不返回内部路径。
@@ -12,6 +14,17 @@ func (s *TransactionStore) ListBackups() ([]ConfigBackupInfo, error) {
if s == nil || s.root == "" {
return nil, ErrBackupListingUnavailable
}
if runtimepath.DeploymentLayout(s.root) {
items, err := s.stateBackups()
if err != nil {
return nil, err
}
result := make([]ConfigBackupInfo, 0, len(items))
for _, item := range items {
result = append(result, ConfigBackupInfo{Generation: item.Backup.Generation, CreatedAt: item.Backup.CreatedAt})
}
return result, nil
}
configDirectory, err := secureManagerConfigDirectory(s.root)
if err != nil {
return nil, err
+5 -5
View File
@@ -276,7 +276,7 @@ func legacyInitReady() bool {
}
func ReadPrivateKey() (*ecdsa.PrivateKey, bool, error) {
privateKey, created, err := loadOrCreateACMEPrivateKey(filepath.Join(ROOT_PATH, "data", "ssl"), "account_private.pem")
privateKey, created, err := loadOrCreateACMEPrivateKey(runtimepath.SSLDirectory(ROOT_PATH), "account_private.pem")
if err != nil {
return nil, false, err
}
@@ -332,9 +332,9 @@ func ReadConfig() (*Config, error) {
func readConfig() (*Config, error) {
configData := Config{
DkimPrivateKeyPath: ROOT_PATH + "data/dkim/dkim.priv",
SSLPrivateKeyPath: ROOT_PATH + "data/ssl/private.key",
SSLPublicKeyPath: ROOT_PATH + "data/ssl/public.crt",
DkimPrivateKeyPath: filepath.Join(runtimepath.DKIMDirectory(ROOT_PATH), "dkim.priv"),
SSLPrivateKeyPath: filepath.Join(runtimepath.SSLDirectory(ROOT_PATH), "private.key"),
SSLPublicKeyPath: filepath.Join(runtimepath.SSLDirectory(ROOT_PATH), "public.crt"),
VerificationEnabled: true,
ExternalRecoveryEnabled: true,
LoginPolicy: "new_device",
@@ -446,7 +446,7 @@ func persistControlledSSLPath(value string) string {
}
func resolvePath(value string) string {
value = runtimepath.LegacyReference(strings.TrimSpace(value))
value = runtimepath.SSLReference(ROOT_PATH, strings.TrimSpace(value))
if value == "" {
return ""
}
+96
View File
@@ -0,0 +1,96 @@
package config
import (
"errors"
"os"
"path/filepath"
fileutil "git.pcux.cn/xuans/Smail/utils/file"
"git.pcux.cn/xuans/Smail/utils/runtimepath"
)
// InitializeDeployment 仅对全新安装启用新布局,不触碰已有部署或生成替代密钥。
func InitializeDeployment(root string) error {
for _, name := range []string{"config/config.json", "data/credential.key", "config/credential.key"} {
if _, err := os.Lstat(filepath.Join(root, filepath.FromSlash(name))); err == nil {
return nil
} else if !os.IsNotExist(err) {
return err
}
}
db, err := NewTransactionStore(root, RuntimeValidationOptions{}).openState()
if err != nil {
return err
}
return db.Close()
}
// ImportDeploymentHistory 在停服迁移期间导入旧历史原始字节,原目录保持不动。
func ImportDeploymentHistory(source, target string, validation RuntimeValidationOptions) error {
if !runtimepath.DeploymentLayout(target) {
return errors.New("目标部署密钥尚未迁移到 ssl")
}
if entries, err := os.ReadDir(filepath.Join(source, "data", "transaction")); err == nil && len(entries) != 0 {
return ErrConfigRecoveryRequired
} else if err != nil && !os.IsNotExist(err) {
return err
}
store := NewTransactionStore(target, validation)
unlock, err := store.lockState()
if err != nil {
return err
}
defer unlock()
entries, err := os.ReadDir(filepath.Join(source, "data", "backups-v2"))
if os.IsNotExist(err) {
return nil
}
if err != nil {
return err
}
for _, entry := range entries {
directory := filepath.Join(source, "data", "backups-v2", entry.Name())
_, manifest, err := loadConfigBackup(directory, validation)
if err != nil {
return err
}
files := make(map[string][]byte)
for _, name := range transactionFileNames() {
files[name], err = fileutil.ReadRegularFile(filepath.Join(directory, "files", name), maxConfigFileSize)
if err != nil {
return err
}
}
if err := validateStateFiles(files, manifest.Files); err != nil {
return err
}
if err := store.saveState("backup", manifest.ID, stateRecord{Backup: &manifest, Original: files}); err != nil {
return err
}
}
_, err = store.stateBackups()
return err
}
// NormalizeDeploymentReferences 通过正常事务更新路径及摘要,不能直接编辑配置 JSON。
func NormalizeDeploymentReferences(root string, validation RuntimeValidationOptions) error {
loader := NewConfigLoader(root, ConfigLoaderOptions{Validation: validation})
current, err := loader.Load()
if err != nil {
return err
}
if !runtimepath.DeploymentLayout(root) {
return ErrManagerStorage
}
candidate := cloneRuntimeConfig(current)
ssl := &candidate.SSL.TLS
ssl.DefaultDirectory = runtimepath.SSLReference(root, ssl.DefaultDirectory)
ssl.CustomDirectory = runtimepath.SSLReference(root, ssl.CustomDirectory)
ssl.CertificateRef = runtimepath.SSLReference(root, ssl.CertificateRef)
ssl.PrivateKeyRef = runtimepath.SSLReference(root, ssl.PrivateKeyRef)
if candidate.SSL.TLS.CertificateRef == current.SSL.TLS.CertificateRef && candidate.SSL.TLS.PrivateKeyRef == current.SSL.TLS.PrivateKeyRef && candidate.SSL.TLS.DefaultDirectory == current.SSL.TLS.DefaultDirectory && candidate.SSL.TLS.CustomDirectory == current.SSL.TLS.CustomDirectory {
return nil
}
setCandidateGeneration(&candidate, current.Generation+1)
return NewTransactionStore(root, validation).Commit(current, candidate)
}
+3 -2
View File
@@ -10,6 +10,7 @@ import (
"strings"
"git.pcux.cn/xuans/Smail/utils/credential"
"git.pcux.cn/xuans/Smail/utils/runtimepath"
"github.com/go-sql-driver/mysql"
)
@@ -58,7 +59,7 @@ func runtimeCompatibility(runtime RuntimeConfig) (*Config, error) {
HttpPort: root.HTTP.Port, HttpsPort: root.HTTP.HTTPSPort,
HttpsEnabled: 2, TLSMode: root.HTTP.TLSMode,
TrustedProxyCIDRs: append([]string(nil), root.HTTP.TrustedProxyCIDRs...),
DkimPrivateKeyPath: filepath.Join(ROOT_PATH, "data", "dkim", "dkim.priv"),
DkimPrivateKeyPath: filepath.Join(runtimepath.DKIMDirectory(ROOT_PATH), "dkim.priv"),
SSLType: SSLTypeUser,
SpamFilterLevel: runtime.Email.Policy.SpamFilterLevel,
LoginPolicy: runtime.SMTP.Relay.LoginPolicy,
@@ -86,7 +87,7 @@ func runtimeCompatibility(runtime RuntimeConfig) (*Config, error) {
}
}
// 迁移器保留的旧证书引用仍走严格的只读文件校验;新托管引用沿用托管解析器。
if strings.HasPrefix(tls.CertificateRef, managedSSLRelativeRoot+"/") {
if strings.HasPrefix(tls.CertificateRef, managedSSLRelativeRoot+"/") || strings.HasPrefix(tls.CertificateRef, "ssl/managed/") {
cfg.SSL = tls
} else {
cfg.SSLPublicKeyPath = resolvePath(tls.CertificateRef)
+8 -5
View File
@@ -6,6 +6,8 @@ import (
"os"
"path/filepath"
"strings"
"git.pcux.cn/xuans/Smail/utils/runtimepath"
)
var ErrSSLFileUnavailable = errors.New("SSL certificate file is missing or unreadable")
@@ -32,7 +34,8 @@ func prepareCustomSSLPaths(root string, candidate *RuntimeConfig) (*customSSLMat
return nil, ErrInvalidSSLReference
}
// 已保存的受管引用只复验,不重复导入;普通相对路径以项目运行根目录为基准。
if strings.HasPrefix(certificatePath, managedSSLRelativeRoot+"/") && strings.HasPrefix(privateKeyPath, managedSSLRelativeRoot+"/") {
managedRoot := runtimepath.SSLReference(root, managedSSLRelativeRoot)
if strings.HasPrefix(certificatePath, managedRoot+"/") && strings.HasPrefix(privateKeyPath, managedRoot+"/") {
return nil, validateCustomSSLReferences(root, *candidate)
}
var err error
@@ -57,11 +60,11 @@ func prepareCustomSSLPaths(root string, candidate *RuntimeConfig) (*customSSLMat
return nil, err
}
ssl.Mode = ManagedSSLModeUpload
ssl.DefaultDirectory = "data/ssl"
ssl.CustomDirectory = "data/ssl"
ssl.DefaultDirectory = runtimepath.SSLReference(root, "data/ssl")
ssl.CustomDirectory = runtimepath.SSLReference(root, "data/ssl")
// 仅在内存中使用合法占位引用完成跨分区校验,最终候选必须换成独立版本。
ssl.CertificateRef = managedSSLReference(ManagedSSLModeUpload, "public.crt")
ssl.PrivateKeyRef = managedSSLReference(ManagedSSLModeUpload, "private.key")
ssl.CertificateRef = managedSSLReferenceAtRoot(root, ManagedSSLModeUpload, "public.crt")
ssl.PrivateKeyRef = managedSSLReferenceAtRoot(root, ManagedSSLModeUpload, "private.key")
return material, nil
}
+9 -5
View File
@@ -195,8 +195,8 @@ func importManagedSSLAtRoot(root string, mode string, privateKeyPEM, certificate
}
return ManagedSSLReference{
Mode: mode,
CertificateRef: managedSSLReference(mode, "public.crt"),
PrivateKeyRef: managedSSLReference(mode, "private.key"),
CertificateRef: managedSSLReferenceAtRoot(root, mode, "public.crt"),
PrivateKeyRef: managedSSLReferenceAtRoot(root, mode, "private.key"),
CertificatePath: certificatePath,
PrivateKeyPath: privateKeyPath,
}, nil
@@ -388,15 +388,19 @@ func managedSSLRootPathAtRoot(root string, mode string) (string, error) {
if mode == ManagedSSLModeUpload {
folder = "upload"
}
return filepath.Join(rootPath, managedSSLRelativeRoot, folder), nil
return filepath.Join(rootPath, runtimepath.SSLReference(root, managedSSLRelativeRoot), folder), nil
}
func managedSSLReference(mode, name string) string {
return managedSSLReferenceAtRoot(ROOT_PATH, mode, name)
}
func managedSSLReferenceAtRoot(root, mode, name string) string {
folder := "default"
if mode == ManagedSSLModeUpload {
folder = "upload"
}
return filepath.ToSlash(filepath.Join(managedSSLRelativeRoot, folder, "current", name))
return filepath.ToSlash(filepath.Join(runtimepath.SSLReference(root, managedSSLRelativeRoot), folder, "current", name))
}
func resolveManagedReference(rootPath, reference, expectedName string) (string, error) {
@@ -404,7 +408,7 @@ func resolveManagedReference(rootPath, reference, expectedName string) (string,
}
func resolveManagedReferenceAtRoot(root, rootPath, reference, expectedName string) (string, error) {
rawReference := runtimepath.LegacyReference(strings.TrimSpace(reference))
rawReference := runtimepath.SSLReference(root, strings.TrimSpace(reference))
if rawReference == "" || strings.Contains(rawReference, `\`) || filepath.IsAbs(rawReference) || isWindowsAbsolute(rawReference) {
return "", ErrInvalidSSLReference
}
+14
View File
@@ -0,0 +1,14 @@
//go:build !windows
package config
import (
"os"
"golang.org/x/sys/unix"
)
func lockStateFile(file *os.File) (func(), error) {
err := unix.Flock(int(file.Fd()), unix.LOCK_EX|unix.LOCK_NB)
return func() { _ = unix.Flock(int(file.Fd()), unix.LOCK_UN) }, err
}
+15
View File
@@ -0,0 +1,15 @@
//go:build windows
package config
import (
"os"
"golang.org/x/sys/windows"
)
func lockStateFile(file *os.File) (func(), error) {
position := &windows.Overlapped{Offset: 0x60000000}
err := windows.LockFileEx(windows.Handle(file.Fd()), windows.LOCKFILE_EXCLUSIVE_LOCK|windows.LOCKFILE_FAIL_IMMEDIATELY, 0, 1, 0, position)
return func() { _ = windows.UnlockFileEx(windows.Handle(file.Fd()), 0, 1, 0, position) }, err
}
+379
View File
@@ -0,0 +1,379 @@
package config
import (
"database/sql"
"encoding/json"
"errors"
"os"
"path/filepath"
"sort"
"time"
"git.pcux.cn/xuans/Smail/utils/atomicfile"
"git.pcux.cn/xuans/Smail/utils/runtimepath"
_ "modernc.org/sqlite"
)
// 状态数据库只保存配置历史和恢复事务,五个生效配置文件仍是配置读取来源。
type stateRecord struct {
Transaction *TransactionManifest `json:"transaction,omitempty"`
Backup *ConfigBackupManifest `json:"backup,omitempty"`
Original map[string][]byte `json:"original,omitempty"`
Candidate map[string][]byte `json:"candidate,omitempty"`
}
func (s *TransactionStore) lockState() (func(), error) {
db, err := s.openState()
if err != nil {
return nil, err
}
if err := db.Close(); err != nil {
return nil, err
}
file, err := os.OpenFile(filepath.Join(s.root, "data", "smail-state.db"), os.O_RDWR, 0600)
if err != nil {
return nil, err
}
unlock, err := lockStateFile(file)
if err != nil {
file.Close()
return nil, errors.New("配置状态正在被其他进程使用,请稍后重试")
}
return func() { unlock(); file.Close() }, nil
}
func (s *TransactionStore) openState() (*sql.DB, error) {
directory, err := runtimepath.Directory(s.root)
if err != nil {
return nil, err
}
filename := filepath.Join(directory, "smail-state.db")
info, err := os.Lstat(filename)
if err == nil && (!info.Mode().IsRegular() || info.Mode()&os.ModeSymlink != 0) {
return nil, ErrManagerStorage
}
if err != nil && !os.IsNotExist(err) {
return nil, err
}
db, err := sql.Open("sqlite", filepath.ToSlash(filename))
if err != nil {
return nil, err
}
db.SetMaxOpenConns(1)
for _, statement := range []string{
"PRAGMA busy_timeout=5000", "PRAGMA synchronous=FULL",
`CREATE TABLE IF NOT EXISTS config_records (kind TEXT NOT NULL, id TEXT NOT NULL, payload BLOB NOT NULL, digest TEXT NOT NULL, PRIMARY KEY(kind,id))`,
} {
if _, err = db.Exec(statement); err != nil {
db.Close()
return nil, err
}
}
if err = os.Chmod(filename, 0600); err != nil {
db.Close()
return nil, err
}
return db, nil
}
func (s *TransactionStore) saveState(kind, id string, record stateRecord) error {
if !transactionIDPattern.MatchString(id) {
return ErrTransactionInvalid
}
data, err := json.Marshal(record)
if err != nil {
return err
}
db, err := s.openState()
if err != nil {
return err
}
defer db.Close()
_, err = db.Exec(`INSERT INTO config_records(kind,id,payload,digest) VALUES(?,?,?,?) ON CONFLICT(kind,id) DO UPDATE SET payload=excluded.payload,digest=excluded.digest`, kind, id, data, SectionDigest(data))
return err
}
func validateStateFiles(files map[string][]byte, digests map[string]string) error {
if !validFileDigestSet(digests) || len(files) != len(digests) {
return ErrTransactionInvalid
}
for name, digest := range digests {
if len(files[name]) == 0 || len(files[name]) > maxConfigFileSize || SectionDigest(files[name]) != digest {
return ErrConfigDigestMismatch
}
}
return nil
}
func (s *TransactionStore) stateRecords(kind string) ([]stateRecord, error) {
db, err := s.openState()
if err != nil {
return nil, err
}
defer db.Close()
var oversized int
if err := db.QueryRow("SELECT count(*) FROM config_records WHERE kind=? AND length(payload)>?", kind, 16*maxConfigFileSize).Scan(&oversized); err != nil || oversized != 0 {
return nil, errors.Join(ErrTransactionInvalid, err)
}
rows, err := db.Query("SELECT id,payload,digest FROM config_records WHERE kind=? ORDER BY id", kind)
if err != nil {
return nil, err
}
defer rows.Close()
var result []stateRecord
for rows.Next() {
var id, digest string
var data []byte
if err := rows.Scan(&id, &data, &digest); err != nil {
return nil, err
}
if !transactionIDPattern.MatchString(id) || len(data) > 16*maxConfigFileSize || SectionDigest(data) != digest {
return nil, ErrConfigDigestMismatch
}
var record stateRecord
if err := ParseStrict(data, &record); err != nil {
return nil, err
}
switch kind {
case "transaction":
if record.Transaction == nil || record.Transaction.ID != id || record.Backup != nil {
return nil, ErrTransactionInvalid
}
if err := validateTransactionManifest(*record.Transaction); err != nil {
return nil, err
}
if err := validateStateFiles(record.Original, record.Transaction.OriginalFiles); err != nil {
return nil, err
}
if err := validateStateFiles(record.Candidate, record.Transaction.CandidateFiles); err != nil {
return nil, err
}
for _, item := range []struct {
files map[string][]byte
generation uint64
}{
{record.Original, record.Transaction.FromGeneration},
{record.Candidate, record.Transaction.ToGeneration},
} {
config, err := parseRuntimeFiles(item.files, s.validation)
if err != nil || config.Generation != item.generation {
return nil, errors.Join(ErrTransactionInvalid, err)
}
}
case "backup":
if record.Backup == nil || record.Backup.ID != id || record.Transaction != nil || record.Backup.CreatedAt.IsZero() {
return nil, ErrTransactionInvalid
}
if err := validateStateFiles(record.Original, record.Backup.Files); err != nil {
return nil, err
}
config, err := parseRuntimeFiles(record.Original, s.validation)
if err != nil {
return nil, err
}
if config.Generation != record.Backup.Generation {
return nil, ErrConfigGenerationMismatch
}
default:
return nil, ErrTransactionInvalid
}
result = append(result, record)
}
return result, rows.Err()
}
func (s *TransactionStore) removeState(kind, id string) error {
db, err := s.openState()
if err != nil {
return err
}
defer db.Close()
_, err = db.Exec("DELETE FROM config_records WHERE kind=? AND id=?", kind, id)
return err
}
func writeStateLive(directory string, files map[string][]byte, rootOnly bool) error {
for _, name := range transactionFileNames() {
if (name == "config.json") != rootOnly {
continue
}
target := filepath.Join(directory, name)
if info, err := os.Lstat(target); err == nil && !info.Mode().IsRegular() {
return ErrManagerStorage
} else if err != nil && !os.IsNotExist(err) {
return err
}
if err := atomicfile.Write(target, files[name], 0600); err != nil {
return err
}
}
return atomicfile.SyncDirectory(directory)
}
func (s *TransactionStore) commitState(current, candidate RuntimeConfig) error {
unlock, err := s.lockState()
if err != nil {
return err
}
defer unlock()
if current.Generation == 0 || candidate.Generation != current.Generation+1 {
return ErrGenerationConflict
}
if err := ValidateRuntimeConfig(candidate, s.validation); err != nil {
return err
}
if records, err := s.stateRecords("transaction"); err != nil || len(records) != 0 {
return errors.Join(ErrConfigRecoveryRequired, err)
}
live, err := NewConfigLoader(s.root, ConfigLoaderOptions{Validation: s.validation}).Load()
if err != nil || live.Generation != current.Generation {
return errors.Join(ErrGenerationConflict, err)
}
original, err := marshalRuntimeFiles(current)
if err != nil {
return err
}
files, err := marshalRuntimeFiles(candidate)
if err != nil {
return err
}
directory, err := secureManagerConfigDirectory(s.root)
if err != nil {
return err
}
id, err := newTransactionID()
if err != nil {
return err
}
manifest := TransactionManifest{
ID: id, FromGeneration: current.Generation, ToGeneration: candidate.Generation,
Sections: append([]Section(nil), requiredPartitionSections...), OriginalFiles: digestFiles(original),
CandidateFiles: digestFiles(files), Phase: TransactionPrepared, CreatedAt: time.Now().UTC(),
}
record := stateRecord{Transaction: &manifest, Original: original, Candidate: files}
persist := func(phase TransactionPhase) error {
manifest.Phase = phase
if err := s.saveState("transaction", id, record); err != nil {
return err
}
return s.beforePhase(phase)
}
if err := persist(TransactionPrepared); err != nil {
return err
}
if err := writeStateLive(directory, files, false); err != nil {
return err
}
if err := persist(TransactionSectionsCommitted); err != nil {
return err
}
if err := writeStateLive(directory, files, true); err != nil {
return err
}
if err := persist(TransactionRootCommitted); err != nil {
return err
}
loaded, err := NewConfigLoader(s.root, ConfigLoaderOptions{Validation: s.validation}).Load()
if err != nil || loaded.Generation != candidate.Generation {
return errors.Join(ErrConfigGenerationMismatch, err)
}
if err := persist(TransactionVerified); err != nil {
return err
}
return s.removeState("transaction", id)
}
func (s *TransactionStore) recoverState() error {
unlock, err := s.lockState()
if err != nil {
return err
}
defer unlock()
if entries, err := os.ReadDir(filepath.Join(s.root, "data", "transaction")); err == nil && len(entries) != 0 {
return ErrConfigRecoveryRequired
} else if err != nil && !os.IsNotExist(err) {
return err
}
records, err := s.stateRecords("transaction")
if err != nil {
return err
}
if len(records) > 1 {
return ErrTransactionInvalid
}
for _, record := range records {
manifest := record.Transaction
loaded, err := NewConfigLoader(s.root, ConfigLoaderOptions{Validation: s.validation}).Load()
if err == nil && loaded.Generation > manifest.ToGeneration {
return ErrConfigGenerationMismatch
}
if err != nil || loaded.Generation < manifest.ToGeneration {
if _, err := parseRuntimeFiles(record.Original, s.validation); err != nil {
return err
}
directory, err := secureManagerConfigDirectory(s.root)
if err != nil {
return err
}
if err := writeStateLive(directory, record.Original, false); err != nil {
return err
}
if err := writeStateLive(directory, record.Original, true); err != nil {
return err
}
if _, err := NewConfigLoader(s.root, ConfigLoaderOptions{Validation: s.validation}).Load(); err != nil {
return err
}
}
if err := s.removeState("transaction", manifest.ID); err != nil {
return err
}
}
return nil
}
func (s *TransactionStore) stateBackups() ([]stateRecord, error) {
items, err := s.stateRecords("backup")
sort.Slice(items, func(i, j int) bool {
if items[i].Backup.CreatedAt.Equal(items[j].Backup.CreatedAt) {
return items[i].Backup.ID > items[j].Backup.ID
}
return items[i].Backup.CreatedAt.After(items[j].Backup.CreatedAt)
})
return items, err
}
func (s *TransactionStore) createStateBackup(config RuntimeConfig, now time.Time) (string, error) {
unlock, err := s.lockState()
if err != nil {
return "", err
}
defer unlock()
if err := ValidateRuntimeConfig(config, s.validation); err != nil {
return "", err
}
files, err := marshalRuntimeFiles(config)
if err != nil {
return "", err
}
id, err := newTransactionID()
if err != nil {
return "", err
}
manifest := ConfigBackupManifest{ID: id, Generation: config.Generation, CreatedAt: now, Files: digestFiles(files)}
if err := s.saveState("backup", id, stateRecord{Backup: &manifest, Original: files}); err != nil {
return "", err
}
items, err := s.stateBackups()
if err != nil {
return "", err
}
for index, item := range items {
if index > 0 && (index >= configBackupLimit || now.Sub(item.Backup.CreatedAt) > configBackupMaxAge) {
if err := s.removeState("backup", item.Backup.ID); err != nil {
return "", err
}
}
}
return id, nil
}
+35
View File
@@ -77,6 +77,9 @@ func (s *TransactionStore) Commit(current, candidate RuntimeConfig) error {
if s == nil || s.root == "" {
return ErrManagerStorage
}
if runtimepath.DeploymentLayout(s.root) {
return s.commitState(current, candidate)
}
if current.Generation == 0 || candidate.Generation != current.Generation+1 {
return ErrGenerationConflict
}
@@ -197,6 +200,9 @@ func (s *TransactionStore) Recover() error {
if s == nil || s.root == "" {
return ErrManagerStorage
}
if runtimepath.DeploymentLayout(s.root) {
return s.recoverState()
}
directory, err := secureManagerConfigDirectory(s.root)
if err != nil {
return err
@@ -600,6 +606,9 @@ func (s *TransactionStore) CreateBackupIfDue(runtime RuntimeConfig, now time.Tim
return "", false, err
}
if found && now.Before(latest.CreatedAt.Add(configBackupInterval)) {
if runtimepath.DeploymentLayout(s.root) {
return latest.ID, false, nil
}
return filepath.Join(s.root, "data", "backups-v2", latest.ID), false, nil
}
path, err := s.createBackupAt(runtime, now)
@@ -618,6 +627,9 @@ func (s *TransactionStore) createBackupAt(runtime RuntimeConfig, createdAt time.
} else {
createdAt = createdAt.UTC()
}
if runtimepath.DeploymentLayout(s.root) {
return s.createStateBackup(runtime, createdAt)
}
files, err := marshalRuntimeFiles(runtime)
if err != nil {
return "", err
@@ -681,6 +693,13 @@ func (s *TransactionStore) latestBackup() (ConfigBackupManifest, bool, error) {
if s == nil || s.root == "" {
return latest, false, ErrManagerStorage
}
if runtimepath.DeploymentLayout(s.root) {
items, err := s.stateBackups()
if err != nil || len(items) == 0 {
return latest, false, err
}
return *items[0].Backup, true, nil
}
configDirectory, err := secureManagerConfigDirectory(s.root)
if err != nil {
return latest, false, err
@@ -717,6 +736,18 @@ func (s *TransactionStore) LoadBackup(generation uint64) (RuntimeConfig, error)
if s == nil || s.root == "" || generation == 0 {
return RuntimeConfig{}, ErrNoBackup
}
if runtimepath.DeploymentLayout(s.root) {
items, err := s.stateBackups()
if err != nil {
return RuntimeConfig{}, err
}
for _, item := range items {
if item.Backup.Generation == generation {
return parseRuntimeFiles(item.Original, s.validation)
}
}
return RuntimeConfig{}, ErrNoBackup
}
configDirectory, err := secureManagerConfigDirectory(s.root)
if err != nil {
return RuntimeConfig{}, err
@@ -864,6 +895,10 @@ func parseRuntimeFiles(files map[string][]byte, validation RuntimeValidationOpti
return RuntimeConfig{}, err
}
for _, section := range requiredPartitionSections {
name, _ := FixedSectionFile(section)
if SectionDigest(files[name]) != root.Sections[section].SHA256 {
return RuntimeConfig{}, ErrConfigDigestMismatch
}
if err := ValidateSectionMeta(section, sectionMeta(runtime, section), runtime.Generation); err != nil {
return RuntimeConfig{}, err
}