统一单数据库部署并完成三种数据库云端验证

This commit is contained in:
xuans committed 2026-09-20 22:05:52 +08:00
1 parent a8e32774a8
commit 9b7479ec4c
18 files changed
+724 -66

No files matched your search

+3 -1
View File
@@ -69,7 +69,9 @@ func (m *ConfigManager) SwitchDatabase(ctx context.Context, expectedGeneration u
if err := contextError(ctx); err != nil {
return err
}
if _, _, err := m.transactions.CreateBackupIfDue(current, time.Now().UTC()); err != nil {
backupStore := *m.transactions
backupStore.database = &target
if _, _, err := backupStore.CreateBackupIfDue(current, time.Now().UTC()); err != nil {
return err
}
if err := contextError(ctx); err != nil {
+1 -8
View File
@@ -9,7 +9,7 @@ import (
"git.pcux.cn/xuans/Smail/utils/runtimepath"
)
// InitializeDeployment 为全新部署创建状态库,并自动归档已采用 ssl 布局的原有业务密钥。
// InitializeDeployment 为全新部署准备目录和密钥;选定数据库前不创建数据库文件。
// 更旧的 config/data 布局仍需完整迁移,不能只搬密钥而切断证书或数据库引用。
func InitializeDeployment(root string) error {
if runtimepath.DeploymentLayout(root) {
@@ -22,13 +22,6 @@ func InitializeDeployment(root string) error {
return err
}
}
db, err := NewTransactionStore(root, RuntimeValidationOptions{}).openState()
if err != nil {
return err
}
if err := db.Close(); err != nil {
return err
}
return initializeDeploymentKeys(root)
}
+5 -1
View File
@@ -98,8 +98,12 @@ func runtimeCompatibility(runtime RuntimeConfig) (*Config, error) {
}
func compatibilityDatabase(database DatabaseConfig, vault *credential.Vault) (string, string, error) {
return compatibilityDatabaseAt(ROOT_PATH, database, vault)
}
func compatibilityDatabaseAt(root string, database DatabaseConfig, vault *credential.Vault) (string, string, error) {
if database.Type == DatabaseTypeSQLite {
path := filepath.Join(ROOT_PATH, "data", database.LocalRef)
path := filepath.Join(root, "data", database.LocalRef)
return DBTypeSQLite, path, nil
}
password, err := OpenStoredSecret(vault, database.Password)
+9 -4
View File
@@ -121,13 +121,18 @@ func pruneManagedSSLLocked(root string, protected []SSLConfig) error {
}
}
// 恢复事务可能仍需要旧材料;恢复未完成时不能清理任何版本。
if runtimepath.DeploymentLayout(root) {
records, err := NewTransactionStore(root, RuntimeValidationOptions{HasSuperAdmin: true}).stateRecords("transaction")
if entries, err := os.ReadDir(filepath.Join(root, "data", "transaction")); err != nil && !os.IsNotExist(err) || len(entries) > 0 {
return ErrConfigRecoveryRequired
}
if _, err := os.Lstat(filepath.Join(root, "data", "smail-state.db")); err == nil {
store := NewTransactionStore(root, RuntimeValidationOptions{HasSuperAdmin: true})
store.legacyState = true
records, err := store.stateRecords("transaction")
if err != nil || len(records) != 0 {
return errors.Join(ErrConfigRecoveryRequired, err)
}
} else if entries, err := os.ReadDir(filepath.Join(root, "data", "transaction")); err != nil && !os.IsNotExist(err) || len(entries) > 0 {
return ErrConfigRecoveryRequired
} else if !os.IsNotExist(err) {
return err
}
keep := make(map[string]bool)
for _, ssl := range protected {
+182
View File
@@ -0,0 +1,182 @@
package config
import (
"context"
"database/sql"
"errors"
"fmt"
"net/url"
"os"
"path/filepath"
"strings"
"time"
"git.pcux.cn/xuans/Smail/internal/configstate"
"git.pcux.cn/xuans/Smail/utils/credential"
"git.pcux.cn/xuans/Smail/utils/runtimepath"
_ "github.com/lib/pq"
_ "modernc.org/sqlite"
)
var ErrStateDatabaseUnavailable = errors.New("配置历史数据库不可用,请检查所选数据库连接;不会回退到独立 SQLite 数据库")
type stateDatabase struct {
*sql.DB
driver string
ctx context.Context
cancel context.CancelFunc
}
func (d *stateDatabase) Close() error {
d.cancel()
return d.DB.Close()
}
func (d *stateDatabase) Begin() (*sql.Tx, error) {
return d.DB.BeginTx(d.ctx, nil)
}
func (d *stateDatabase) bind(query string) string {
if d.driver != "postgres" {
return query
}
var result strings.Builder
index := 0
for _, value := range query {
if value == '?' {
index++
fmt.Fprintf(&result, "$%d", index)
} else {
result.WriteRune(value)
}
}
return result.String()
}
func (d *stateDatabase) Exec(query string, args ...any) (sql.Result, error) {
ctx, cancel := context.WithTimeout(d.ctx, 10*time.Second)
defer cancel()
return d.DB.ExecContext(ctx, d.bind(query), args...)
}
func (d *stateDatabase) Query(query string, args ...any) (*sql.Rows, error) {
return d.DB.QueryContext(d.ctx, d.bind(query), args...)
}
func (d *stateDatabase) QueryRow(query string, args ...any) *sql.Row {
return d.DB.QueryRowContext(d.ctx, d.bind(query), args...)
}
func (d *stateDatabase) upsert() string {
query := "INSERT INTO config_records(kind,id,payload,digest) VALUES(?,?,?,?) "
if d.driver == "mysql" {
return query + "ON DUPLICATE KEY UPDATE payload=VALUES(payload),digest=VALUES(digest)"
}
return query + "ON CONFLICT(kind,id) DO UPDATE SET payload=excluded.payload,digest=excluded.digest"
}
func (s *TransactionStore) stateDatabaseConfig() (DatabaseConfig, error) {
if s.database != nil {
return *s.database, ValidateDatabaseConfig(*s.database)
}
directory, err := secureManagerConfigDirectory(s.root)
if err != nil {
return DatabaseConfig{}, err
}
data, err := readManagerConfigFile(directory, "config.json")
if err != nil {
return DatabaseConfig{}, err
}
var root RootConfig
if err := ParseStrict(data, &root); err != nil {
return DatabaseConfig{}, err
}
database := NormalizeDatabaseConfig(root.Database)
return database, ValidateDatabaseConfig(database)
}
func (s *TransactionStore) openState() (*stateDatabase, error) {
var driver, dsn string
if s.legacyState {
driver = "sqlite"
dsn = filepath.Join(s.root, "data", "smail-state.db")
} else {
database, err := s.stateDatabaseConfig()
if err != nil {
return nil, err
}
vault, err := credential.NewVault(s.root)
if err != nil {
return nil, err
}
driver, dsn, err = compatibilityDatabaseAt(s.root, database, vault)
if err != nil {
return nil, err
}
}
filename := ""
if driver == "sqlite" {
if _, err := runtimepath.Directory(s.root); err != nil {
return nil, err
}
filename = dsn
relative, err := filepath.Rel(filepath.Join(s.root, "data"), filepath.Dir(filename))
if err != nil || relative != "." && !filepath.IsLocal(relative) {
return nil, ErrManagerStorage
}
parent := filepath.Join(s.root, "data")
if relative != "." {
for _, part := range strings.Split(filepath.ToSlash(relative), "/") {
parent, err = runtimepath.SecureDirectory(parent, part)
if err != nil {
return nil, err
}
}
}
info, statErr := os.Lstat(filename)
if statErr == nil && !info.Mode().IsRegular() {
return nil, ErrManagerStorage
}
if statErr != nil && (!os.IsNotExist(statErr) || s.legacyState) {
return nil, statErr
}
path := filepath.ToSlash(filename)
if !strings.HasPrefix(path, "/") {
path = "/" + path
}
uri := url.URL{Scheme: "file", Path: path}
query := url.Values{"_pragma": {"busy_timeout(5000)", "synchronous(FULL)"}}
if s.legacyState {
query.Set("mode", "rw")
}
uri.RawQuery = query.Encode()
dsn = uri.String()
}
connection, err := sql.Open(driver, dsn)
if err != nil {
return nil, ErrStateDatabaseUnavailable
}
operationContext, operationCancel := context.WithTimeout(context.Background(), 30*time.Second)
database := &stateDatabase{DB: connection, driver: driver, ctx: operationContext, cancel: operationCancel}
database.SetMaxOpenConns(1)
database.SetMaxIdleConns(1)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := database.PingContext(ctx); err != nil {
database.Close()
return nil, ErrStateDatabaseUnavailable
}
if !s.legacyState {
if _, err := database.Exec(configstate.Schema(driver)); err != nil {
database.Close()
return nil, ErrStateDatabaseUnavailable
}
}
if filename != "" {
if err := os.Chmod(filename, 0600); err != nil {
database.Close()
return nil, err
}
}
return database, nil
}
+271
View File
@@ -0,0 +1,271 @@
package config
import (
"context"
"database/sql"
"errors"
"os"
"path/filepath"
"testing"
"time"
"git.pcux.cn/xuans/Smail/db/migration"
"git.pcux.cn/xuans/Smail/internal/configstate"
"git.pcux.cn/xuans/Smail/utils/credential"
)
func newTestStateVault(root, password string) (StoredSecret, error) {
vault, err := credential.NewVault(root)
if err != nil {
return StoredSecret{}, err
}
ciphertext, err := vault.Encrypt(password)
return StoredSecret{Ciphertext: ciphertext, Version: vault.Version(), UpdatedAt: time.Now().UTC()}, err
}
func TestSelectedSQLiteContainsConfigurationHistory(t *testing.T) {
root := t.TempDir()
if err := InitializeDeployment(root); err != nil {
t.Fatal(err)
}
entries, err := os.ReadDir(filepath.Join(root, "data"))
if err != nil {
t.Fatal(err)
}
for _, entry := range entries {
if entry.Name() != ".config-state.lock" {
t.Fatalf("选库前产生额外文件:%s", entry.Name())
}
}
current := validRuntimeConfig()
current.Root.Database.LocalRef = "selected.db"
writeRuntimeFixture(t, root, current)
store := NewTransactionStore(root, RuntimeValidationOptions{HasSuperAdmin: true})
if _, err := store.CreateBackup(current); err != nil {
t.Fatal(err)
}
database, err := store.openState()
if err != nil {
t.Fatal(err)
}
var count int
err = database.QueryRow("SELECT COUNT(*) FROM config_records WHERE kind='backup'").Scan(&count)
database.Close()
if err != nil || count != 1 {
t.Fatalf("所选数据库没有配置历史:count=%d, err=%v", count, err)
}
entries, err = os.ReadDir(filepath.Join(root, "data"))
if err != nil {
t.Fatal(err)
}
for _, entry := range entries {
if entry.Name() != ".config-state.lock" && entry.Name() != "selected.db" {
t.Fatalf("出现额外数据库或文件:%s", entry.Name())
}
}
}
func TestDatabaseSwitchBacksUpToTargetWhileSourceLocked(t *testing.T) {
root := t.TempDir()
if err := InitializeDeployment(root); err != nil {
t.Fatal(err)
}
writeRuntimeFixture(t, root, validRuntimeConfig())
manager, err := NewConfigManagerWithSecurity(root, ConfigLoaderOptions{Validation: RuntimeValidationOptions{HasSuperAdmin: true}}, ConfigSecurity{Audit: &MemoryAuditWriter{}})
if err != nil {
t.Fatal(err)
}
source, err := manager.transactions.openState()
if err != nil {
t.Fatal(err)
}
defer source.Close()
if _, err := source.Exec("BEGIN IMMEDIATE"); err != nil {
t.Fatal(err)
}
defer source.Exec("ROLLBACK")
target := manager.Snapshot().Root.Database
target.LocalRef = "next.db"
if err := manager.SwitchDatabase(context.Background(), 1, target, authorizedConfigActor()); err != nil {
t.Fatalf("源库锁定阻止了已完成复制后的配置切换:%v", err)
}
if _, err := manager.transactions.LoadBackup(1); err != nil {
t.Fatalf("切换前历史未写入目标库:%v", err)
}
var count int
if err := source.QueryRow("SELECT COUNT(*) FROM config_records").Scan(&count); err != nil || count != 0 {
t.Fatalf("切换阶段写入了源库:%d,%v", count, err)
}
}
func TestUnavailableSelectedDatabaseDoesNotCreateSQLite(t *testing.T) {
for _, kind := range []DatabaseType{DatabaseTypeMySQL, DatabaseTypePostgreSQL} {
t.Run(string(kind), func(t *testing.T) {
root := t.TempDir()
if err := InitializeDeployment(root); err != nil {
t.Fatal(err)
}
current := validMySQLRuntimeConfig(t, root)
current.Root.Database.Type = kind
current.Root.Database.Port = 1
writeRuntimeFixture(t, root, current)
store := NewTransactionStore(root, RuntimeValidationOptions{HasSuperAdmin: true})
if _, err := store.CreateBackup(current); !errors.Is(err, ErrStateDatabaseUnavailable) {
t.Fatalf("未拒绝不可用数据库:%v", err)
}
candidate := cloneRuntimeConfig(current)
setCandidateGeneration(&candidate, 2)
store.WithHooks(TransactionHooks{BeforePhase: func(phase TransactionPhase) error {
if phase == TransactionSectionsCommitted {
return errors.New("模拟进程中断")
}
return nil
}})
if err := store.Commit(current, candidate); err == nil {
t.Fatal("未注入配置提交故障")
}
if err := store.Recover(); err != nil {
t.Fatalf("数据库离线时无法恢复配置:%v", err)
}
entries, err := os.ReadDir(filepath.Join(root, "data"))
if err != nil {
t.Fatal(err)
}
for _, entry := range entries {
if entry.Name() != ".config-state.lock" && entry.Name() != "transaction" {
t.Fatalf("远程数据库失败后创建了额外文件:%s", entry.Name())
}
}
})
}
}
func TestLegacyStateImportsAndRecoversIntoSelectedDatabase(t *testing.T) {
for _, phase := range []TransactionPhase{TransactionPrepared, TransactionSectionsCommitted, TransactionRootCommitted, TransactionVerified} {
t.Run(string(phase), func(t *testing.T) {
root := t.TempDir()
if err := InitializeDeployment(root); err != nil {
t.Fatal(err)
}
current := validRuntimeConfig()
writeRuntimeFixture(t, root, current)
filename := filepath.Join(root, "data", "smail-state.db")
db, err := sql.Open("sqlite", filename)
if err != nil {
t.Fatal(err)
}
_, err = db.Exec(configstate.Schema("sqlite"))
db.Close()
if err != nil {
t.Fatal(err)
}
legacy := NewTransactionStore(root, RuntimeValidationOptions{HasSuperAdmin: true})
legacy.legacyState = true
if _, err := legacy.CreateBackup(current); err != nil {
t.Fatal(err)
}
candidate := cloneRuntimeConfig(current)
setCandidateGeneration(&candidate, 2)
legacy.WithHooks(TransactionHooks{BeforePhase: func(actual TransactionPhase) error {
if actual == phase {
return errors.New("模拟旧版中断")
}
return nil
}})
if err := legacy.commitState(current, candidate); err == nil {
t.Fatal("未注入旧版故障")
}
store := NewTransactionStore(root, RuntimeValidationOptions{HasSuperAdmin: true})
for i := 0; i < 2; i++ {
if err := store.Recover(); err != nil {
t.Fatal(err)
}
}
if _, err := os.Stat(filename); !os.IsNotExist(err) {
t.Fatal("旧状态库仍在运行路径中")
}
if _, err := store.LoadBackup(1); err != nil {
t.Fatalf("升级后历史丢失:%v", err)
}
loaded, err := NewConfigLoader(root, ConfigLoaderOptions{Validation: store.validation}).Load()
want := uint64(1)
if phase == TransactionRootCommitted || phase == TransactionVerified {
want = 2
}
if err != nil || loaded.Generation != want {
t.Fatalf("旧事务恢复代次错误:%d,%v", loaded.Generation, err)
}
})
}
}
// 云端测试必须使用预先清空的专用测试库;凭据只从进程环境读取。
func TestSelectedDatabaseLiveIntegration(t *testing.T) {
kind := DatabaseType(os.Getenv("SMAIL_TEST_STATE_DATABASE"))
if kind == "" {
t.Skip("未配置云端专用数据库")
}
if kind != DatabaseTypeMySQL && kind != DatabaseTypePostgreSQL && kind != DatabaseTypeSQLite {
t.Fatal("测试数据库类型无效")
}
root := t.TempDir()
if err := InitializeDeployment(root); err != nil {
t.Fatal(err)
}
current := validRuntimeConfig()
if kind != DatabaseTypeSQLite {
current = validMySQLRuntimeConfig(t, root)
current.Root.Database.Type = kind
current.Root.Database.Username = os.Getenv("SMAIL_TEST_STATE_USER")
current.Root.Database.Name = os.Getenv("SMAIL_TEST_STATE_NAME")
if kind == DatabaseTypePostgreSQL {
current.Root.Database.Port = DefaultPostgreSQLPort
}
vault, err := newTestStateVault(root, os.Getenv("SMAIL_TEST_STATE_PASSWORD"))
if err != nil {
t.Fatal("测试凭据初始化失败")
}
current.Root.Database.Password = vault
}
writeRuntimeFixture(t, root, current)
store := NewTransactionStore(root, RuntimeValidationOptions{HasSuperAdmin: true})
database, err := store.openState()
if err != nil {
t.Fatal(err)
}
dialect, err := migration.ParseDialect(database.driver)
if err != nil {
t.Fatal(err)
}
_, err = (migration.Runner{DB: database.DB, Dialect: dialect, Migrations: migration.DefaultMigrations()}).Run(context.Background())
database.Close()
if err != nil {
t.Fatal(err)
}
for index := 0; index < 6; index++ {
if _, err := store.createBackupAt(current, time.Now().Add(time.Duration(index)*time.Hour)); err != nil {
t.Fatal(err)
}
}
store = NewTransactionStore(root, store.validation)
if err := store.Recover(); err != nil {
t.Fatal(err)
}
items, err := store.stateBackups()
if err != nil || len(items) != 4 {
t.Fatalf("真实数据库历史读写或保留策略失败:%d,%v", len(items), err)
}
if _, err := store.LoadBackup(1); err != nil {
t.Fatal(err)
}
entries, err := os.ReadDir(filepath.Join(root, "data"))
if err != nil {
t.Fatal(err)
}
for _, entry := range entries {
if entry.Name() == ".config-state.lock" || entry.Name() == "transaction" || kind == DatabaseTypeSQLite && entry.Name() == "smail.db" {
continue
}
t.Fatalf("真实数据库模式产生额外数据库:%s", entry.Name())
}
}
+12 -41
View File
@@ -1,7 +1,6 @@
package config
import (
"database/sql"
"encoding/json"
"errors"
"os"
@@ -11,10 +10,9 @@ import (
"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"`
@@ -23,14 +21,17 @@ type stateRecord struct {
}
func (s *TransactionStore) lockState() (func(), error) {
db, err := s.openState()
directory, err := runtimepath.Directory(s.root)
if err != nil {
return nil, err
}
if err := db.Close(); err != nil {
filename := filepath.Join(directory, ".config-state.lock")
if info, err := os.Lstat(filename); err == nil && !info.Mode().IsRegular() {
return nil, ErrManagerStorage
} else if err != nil && !os.IsNotExist(err) {
return nil, err
}
file, err := os.OpenFile(filepath.Join(s.root, "data", "smail-state.db"), os.O_RDWR, 0600)
file, err := os.OpenFile(filename, os.O_CREATE|os.O_RDWR, 0600)
if err != nil {
return nil, err
}
@@ -42,40 +43,6 @@ func (s *TransactionStore) lockState() (func(), error) {
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
@@ -89,7 +56,7 @@ func (s *TransactionStore) saveState(kind, id string, record stateRecord) error
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))
_, err = db.Exec(db.upsert(), kind, id, data, SectionDigest(data))
return err
}
@@ -289,6 +256,10 @@ func (s *TransactionStore) recoverState() error {
return err
}
defer unlock()
return s.recoverStateLocked()
}
func (s *TransactionStore) recoverStateLocked() error {
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) {
+84
View File
@@ -0,0 +1,84 @@
package config
import (
"database/sql"
"encoding/json"
"errors"
"os"
"path/filepath"
"git.pcux.cn/xuans/Smail/utils/atomicfile"
"git.pcux.cn/xuans/Smail/utils/runtimepath"
)
// 旧独立状态库只用于一次性升级;校验和导入成功后退出运行路径,不覆盖冲突历史。
func (s *TransactionStore) migrateLegacyState() error {
unlock, err := s.lockState()
if err != nil {
return err
}
defer unlock()
filename := filepath.Join(s.root, "data", "smail-state.db")
info, err := os.Lstat(filename)
if os.IsNotExist(err) {
return nil
}
if err != nil || !info.Mode().IsRegular() {
return errors.Join(ErrManagerStorage, err)
}
legacy := *s
legacy.legacyState = true
if err := legacy.recoverStateLocked(); err != nil {
return err
}
records, err := legacy.stateBackups()
if err != nil {
return err
}
database, err := s.openState()
if err != nil {
return err
}
defer database.Close()
tx, err := database.Begin()
if err != nil {
return err
}
defer tx.Rollback()
for _, record := range records {
data, err := json.Marshal(record)
if err != nil {
return err
}
var digest string
var payload []byte
err = tx.QueryRow(database.bind("SELECT digest,payload FROM config_records WHERE kind=? AND id=?"), "backup", record.Backup.ID).Scan(&digest, &payload)
if err == nil {
if digest != SectionDigest(data) || SectionDigest(payload) != digest {
return ErrConfigDigestMismatch
}
continue
}
if !errors.Is(err, sql.ErrNoRows) {
return err
}
if _, err := tx.Exec(database.bind("INSERT INTO config_records(kind,id,payload,digest) VALUES(?,?,?,?)"), "backup", record.Backup.ID, data, SectionDigest(data)); err != nil {
return err
}
}
if err := tx.Commit(); err != nil {
return err
}
archive, err := runtimepath.SecureDirectory(filepath.Join(s.root, "data"), "migration-history")
if err != nil {
return err
}
target := filepath.Join(archive, "smail-state.retired")
if _, err := os.Lstat(target); !os.IsNotExist(err) {
return ErrManagerStorage
}
if err := os.Rename(filename, target); err != nil {
return err
}
return errors.Join(atomicfile.SyncDirectory(archive), atomicfile.SyncDirectory(filepath.Dir(filename)))
}
+29 -5
View File
@@ -44,9 +44,11 @@ type TransactionHooks struct {
}
type TransactionStore struct {
root string
validation RuntimeValidationOptions
hooks TransactionHooks
root string
validation RuntimeValidationOptions
hooks TransactionHooks
database *DatabaseConfig
legacyState bool
}
var transactionIDPattern = regexp.MustCompile(`^[a-f0-9]{32}$`)
@@ -78,7 +80,22 @@ func (s *TransactionStore) Commit(current, candidate RuntimeConfig) error {
return ErrManagerStorage
}
if runtimepath.DeploymentLayout(s.root) {
return s.commitState(current, candidate)
unlock, err := s.lockState()
if err != nil {
return err
}
defer unlock()
live, err := NewConfigLoader(s.root, ConfigLoaderOptions{Validation: s.validation}).Load()
if err != nil || live.Generation != current.Generation {
return errors.Join(ErrGenerationConflict, err)
}
entries, err := os.ReadDir(filepath.Join(s.root, "data", "transaction"))
if err != nil && !os.IsNotExist(err) {
return err
}
if len(entries) != 0 {
return ErrConfigRecoveryRequired
}
}
if current.Generation == 0 || candidate.Generation != current.Generation+1 {
return ErrGenerationConflict
@@ -201,7 +218,14 @@ func (s *TransactionStore) Recover() error {
return ErrManagerStorage
}
if runtimepath.DeploymentLayout(s.root) {
return s.recoverState()
if err := s.migrateLegacyState(); err != nil {
return err
}
unlock, err := s.lockState()
if err != nil {
return err
}
defer unlock()
}
directory, err := secureManagerConfigDirectory(s.root)
if err != nil {
+3
View File
@@ -101,6 +101,9 @@ func validateDatabase(database DatabaseConfig) error {
func validSQLiteLocalRef(value string) bool {
value = filepath.ToSlash(value)
if strings.EqualFold(value, "smail-state.db") {
return false
}
if value == "" || filepath.IsAbs(value) || isWindowsAbsolute(value) || strings.HasPrefix(value, "config/") || strings.ContainsAny(value, `\\:`) {
return false
}