118 lines
2.9 KiB
Go
118 lines
2.9 KiB
Go
package swoosh
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
)
|
|
|
|
// Snapshot captures a serialized view of the orchestrator state and replay cursor.
|
|
type Snapshot struct {
|
|
State OrchestratorState `json:"state"`
|
|
LastAppliedHLC string `json:"last_applied_hlc"`
|
|
LastAppliedIndex uint64 `json:"last_applied_index"`
|
|
}
|
|
|
|
// SnapshotStore persists and loads orchestrator snapshots.
|
|
type SnapshotStore interface {
|
|
Save(s Snapshot) error
|
|
LoadLatest() (Snapshot, error)
|
|
}
|
|
|
|
// ErrSnapshotNotFound indicates there is no stored snapshot.
|
|
var ErrSnapshotNotFound = errors.New("snapshot not found")
|
|
|
|
// FileSnapshotStore stores snapshots using atomic file replacement.
|
|
type FileSnapshotStore struct {
|
|
path string
|
|
}
|
|
|
|
// NewFileSnapshotStore creates a snapshot store at the supplied path.
|
|
func NewFileSnapshotStore(path string) *FileSnapshotStore {
|
|
return &FileSnapshotStore{path: path}
|
|
}
|
|
|
|
// Save writes the snapshot with atomic replace semantics.
|
|
func (s *FileSnapshotStore) Save(snapshot Snapshot) error {
|
|
dir := filepath.Dir(s.path)
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
return fmt.Errorf("create snapshot directory: %w", err)
|
|
}
|
|
|
|
payload, err := canonicalJSON(snapshot)
|
|
if err != nil {
|
|
return fmt.Errorf("marshal snapshot: %w", err)
|
|
}
|
|
|
|
temp, err := os.CreateTemp(dir, "snapshot-*.tmp")
|
|
if err != nil {
|
|
return fmt.Errorf("create temp snapshot: %w", err)
|
|
}
|
|
tempName := temp.Name()
|
|
|
|
if _, err := temp.Write(payload); err != nil {
|
|
temp.Close()
|
|
os.Remove(tempName)
|
|
return fmt.Errorf("write snapshot: %w", err)
|
|
}
|
|
|
|
if err := temp.Sync(); err != nil {
|
|
temp.Close()
|
|
os.Remove(tempName)
|
|
return fmt.Errorf("sync snapshot: %w", err)
|
|
}
|
|
|
|
if err := temp.Close(); err != nil {
|
|
os.Remove(tempName)
|
|
return fmt.Errorf("close snapshot temp file: %w", err)
|
|
}
|
|
|
|
if err := os.Rename(tempName, s.path); err != nil {
|
|
os.Remove(tempName)
|
|
return fmt.Errorf("rename snapshot: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// LoadLatest returns the persisted snapshot or ErrSnapshotNotFound if absent.
|
|
func (s *FileSnapshotStore) LoadLatest() (Snapshot, error) {
|
|
payload, err := os.ReadFile(s.path)
|
|
if err != nil {
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
return Snapshot{}, ErrSnapshotNotFound
|
|
}
|
|
return Snapshot{}, fmt.Errorf("read snapshot: %w", err)
|
|
}
|
|
|
|
var snapshot Snapshot
|
|
if err := json.Unmarshal(payload, &snapshot); err != nil {
|
|
return Snapshot{}, fmt.Errorf("decode snapshot: %w", err)
|
|
}
|
|
|
|
return snapshot, nil
|
|
}
|
|
|
|
// InMemorySnapshotStore fulfills SnapshotStore in memory for testing.
|
|
type InMemorySnapshotStore struct {
|
|
snapshot Snapshot
|
|
has bool
|
|
}
|
|
|
|
// Save stores the snapshot in memory.
|
|
func (s *InMemorySnapshotStore) Save(snapshot Snapshot) error {
|
|
s.snapshot = snapshot
|
|
s.has = true
|
|
return nil
|
|
}
|
|
|
|
// LoadLatest retrieves the stored snapshot or ErrSnapshotNotFound.
|
|
func (s *InMemorySnapshotStore) LoadLatest() (Snapshot, error) {
|
|
if !s.has {
|
|
return Snapshot{}, ErrSnapshotNotFound
|
|
}
|
|
return s.snapshot, nil
|
|
}
|