You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

355 lines
10 KiB
Go

package peermigration
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"time"
)
type Store struct {
root string
stagingRoot string
storageRoots []string
}
const (
staleTargetSessionAge = 8 * 24 * time.Hour
maxTargetSessionScan = 128
maxTargetSessionFiles = MaxArtifacts*2 + 2
maxTargetPrune = 32
)
func NewStore(root string, storageRoots []string, stagingRoot string) (*Store, error) {
if root == "" || !filepath.IsAbs(root) || filepath.Clean(root) != root {
return nil, errors.New("peer migration state directory must be a clean absolute path")
}
if !cleanPathWithinRoots(stagingRoot, storageRoots) {
return nil, errors.New("peer migration staging directory must be a clean child of a storage root")
}
store := &Store{
root: root, stagingRoot: stagingRoot,
storageRoots: append([]string(nil), storageRoots...),
}
if err := os.MkdirAll(store.sourceDir(), 0700); err != nil {
return nil, fmt.Errorf("create peer migration source state: %w", err)
}
if err := os.MkdirAll(store.targetDir(), 0700); err != nil {
return nil, fmt.Errorf("create peer migration target state: %w", err)
}
if err := store.pruneExpiredTargets(time.Now()); err != nil {
return nil, fmt.Errorf("prune peer migration target state: %w", err)
}
if err := os.MkdirAll(store.targetReceiptDir(), 0700); err != nil {
return nil, fmt.Errorf("create peer migration target receipts: %w", err)
}
return store, nil
}
func (s *Store) sourceDir() string { return filepath.Join(s.root, "source") }
func (s *Store) targetDir() string { return filepath.Join(s.stagingRoot, "target") }
func (s *Store) targetReceiptDir() string { return filepath.Join(s.root, "target-receipts") }
func (s *Store) SourcePath(migrationID string) (string, error) {
if !idPattern.MatchString(migrationID) {
return "", errors.New("invalid peer migration identity")
}
return filepath.Join(s.sourceDir(), migrationID+".json"), nil
}
func (s *Store) SourceIntentPath(migrationID string) (string, error) {
if !idPattern.MatchString(migrationID) {
return "", errors.New("invalid peer migration identity")
}
return filepath.Join(s.sourceDir(), migrationID+".intent.json"), nil
}
func (s *Store) SaveSourceIntent(intent SourceIntent) error {
if err := ValidateSourceIntent(intent, s.storageRoots); err != nil {
return err
}
path, _ := s.SourceIntentPath(intent.MigrationID)
return s.saveJSON(path, intent.MigrationID+"-intent-", intent)
}
func (s *Store) LoadSourceIntent(migrationID string) (SourceIntent, error) {
path, err := s.SourceIntentPath(migrationID)
if err != nil {
return SourceIntent{}, err
}
var intent SourceIntent
if err := s.loadJSON(path, &intent); err != nil {
return SourceIntent{}, err
}
if err := ValidateSourceIntent(intent, s.storageRoots); err != nil {
return SourceIntent{}, err
}
return intent, nil
}
func (s *Store) SaveSource(manifest StoredManifest) error {
if err := ValidateStoredManifest(manifest, s.storageRoots, time.Now()); err != nil {
return err
}
path, _ := s.SourcePath(manifest.MigrationID)
return s.saveJSON(path, manifest.MigrationID+"-", manifest)
}
func (s *Store) saveJSON(path, prefix string, value any) error {
encoded, err := json.Marshal(value)
if err != nil {
return fmt.Errorf("encode peer migration state: %w", err)
}
if int64(len(encoded)) > maxManifestBytes {
return errors.New("peer migration state is too large")
}
temporary, err := os.CreateTemp(s.sourceDir(), prefix+"*.tmp")
if err != nil {
return fmt.Errorf("create peer migration state: %w", err)
}
temporaryPath := temporary.Name()
defer os.Remove(temporaryPath)
if err := temporary.Chmod(0600); err != nil {
temporary.Close()
return fmt.Errorf("protect peer migration state: %w", err)
}
if _, err := temporary.Write(encoded); err != nil {
temporary.Close()
return fmt.Errorf("write peer migration state: %w", err)
}
if err := temporary.Sync(); err != nil {
temporary.Close()
return fmt.Errorf("sync peer migration state: %w", err)
}
if err := temporary.Close(); err != nil {
return fmt.Errorf("close peer migration state: %w", err)
}
if err := os.Rename(temporaryPath, path); err != nil {
return fmt.Errorf("publish peer migration state: %w", err)
}
if err := syncDirectory(filepath.Dir(path)); err != nil {
return fmt.Errorf("sync peer migration state directory: %w", err)
}
return nil
}
func (s *Store) LoadSource(migrationID string) (StoredManifest, error) {
path, err := s.SourcePath(migrationID)
if err != nil {
return StoredManifest{}, err
}
var manifest StoredManifest
if err := s.loadJSON(path, &manifest); err != nil {
return StoredManifest{}, err
}
if err := ValidateStoredManifest(manifest, s.storageRoots, time.Now()); err != nil {
return StoredManifest{}, err
}
return manifest, nil
}
func (s *Store) loadJSON(path string, value any) error {
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
raw, err := io.ReadAll(io.LimitReader(file, maxManifestBytes+1))
if err != nil || int64(len(raw)) > maxManifestBytes {
return errors.New("read bounded peer migration state")
}
decoder := json.NewDecoder(bytes.NewReader(raw))
decoder.DisallowUnknownFields()
if err := decoder.Decode(value); err != nil {
return errors.New("decode peer migration state")
}
var trailing any
if err := decoder.Decode(&trailing); !errors.Is(err, io.EOF) {
return errors.New("peer migration state contains trailing data")
}
return nil
}
func (s *Store) RemoveSource(migrationID string) error {
path, err := s.SourcePath(migrationID)
if err != nil {
return err
}
intentPath, _ := s.SourceIntentPath(migrationID)
for _, candidate := range []string{path, intentPath} {
err = os.Remove(candidate)
if err != nil && !errors.Is(err, os.ErrNotExist) {
return err
}
}
return nil
}
func (s *Store) TargetSessionDir(migrationID string) (string, error) {
path, err := s.targetSessionPath(migrationID)
if err != nil {
return "", err
}
if err := os.MkdirAll(path, 0700); err != nil {
return "", fmt.Errorf("create peer migration target session: %w", err)
}
return path, nil
}
func (s *Store) RemoveTarget(migrationID string) error {
path, err := s.targetSessionPath(migrationID)
if err != nil {
return err
}
return os.RemoveAll(path)
}
func (s *Store) RemoveTargetReceipt(migrationID string) error {
path, err := s.TargetReceiptPath(migrationID)
if err != nil {
return err
}
err = os.Remove(path)
if errors.Is(err, os.ErrNotExist) {
return nil
}
return err
}
func (s *Store) targetSessionPath(migrationID string) (string, error) {
if !idPattern.MatchString(migrationID) {
return "", errors.New("invalid peer migration identity")
}
return filepath.Join(s.targetDir(), migrationID), nil
}
// pruneExpiredTargets bounds abandoned transfer storage without interpreting
// it as operation evidence. Active sessions refresh a partial file on every
// successful chunk; only small, well-shaped directories older than the
// maximum ticket lifetime plus one day are removed.
func (s *Store) pruneExpiredTargets(now time.Time) error {
directory, err := os.Open(s.targetDir())
if err != nil {
return err
}
entries, readErr := directory.Readdir(maxTargetSessionScan + 1)
closeErr := directory.Close()
if readErr != nil && !errors.Is(readErr, io.EOF) {
return readErr
}
if closeErr != nil {
return closeErr
}
removed := 0
for _, entry := range entries {
if removed >= maxTargetPrune || !idPattern.MatchString(entry.Name()) ||
entry.Mode()&os.ModeSymlink != 0 || !entry.IsDir() {
continue
}
path := filepath.Join(s.targetDir(), entry.Name())
session, openErr := os.Open(path)
if openErr != nil {
continue
}
children, childErr := session.Readdir(maxTargetSessionFiles + 1)
_ = session.Close()
if childErr != nil && !errors.Is(childErr, io.EOF) ||
len(children) > maxTargetSessionFiles {
continue
}
latest := entry.ModTime()
valid := true
for _, child := range children {
name := child.Name()
base := strings.TrimSuffix(strings.TrimSuffix(name, ".partial"), ".ready")
if !idPattern.MatchString(base) || base == name ||
child.Mode()&os.ModeSymlink != 0 || !child.Mode().IsRegular() {
valid = false
break
}
if child.ModTime().After(latest) {
latest = child.ModTime()
}
}
if valid && now.Sub(latest) > staleTargetSessionAge {
if err := os.RemoveAll(path); err != nil {
return err
}
removed++
}
}
return nil
}
func (s *Store) TargetReceiptPath(migrationID string) (string, error) {
if !idPattern.MatchString(migrationID) {
return "", errors.New("invalid peer migration identity")
}
return filepath.Join(s.targetReceiptDir(), migrationID+".json"), nil
}
func (s *Store) SaveTargetReceipt(receipt TargetReceipt) error {
if err := ValidateTargetReceipt(receipt); err != nil {
return err
}
path, _ := s.TargetReceiptPath(receipt.MigrationID)
encoded, err := json.Marshal(receipt)
if err != nil || int64(len(encoded)) > maxManifestBytes {
return errors.New("encode peer migration target receipt")
}
temporary, err := os.CreateTemp(s.targetReceiptDir(), receipt.MigrationID+"-*.tmp")
if err != nil {
return err
}
temporaryPath := temporary.Name()
defer os.Remove(temporaryPath)
if err := temporary.Chmod(0600); err != nil {
temporary.Close()
return err
}
if _, err := temporary.Write(encoded); err != nil {
temporary.Close()
return err
}
if err := temporary.Sync(); err != nil {
temporary.Close()
return err
}
if err := temporary.Close(); err != nil {
return err
}
if err := os.Rename(temporaryPath, path); err != nil {
return err
}
return syncDirectory(filepath.Dir(path))
}
func (s *Store) LoadTargetReceipt(migrationID string) (TargetReceipt, error) {
path, err := s.TargetReceiptPath(migrationID)
if err != nil {
return TargetReceipt{}, err
}
var receipt TargetReceipt
if err := s.loadJSON(path, &receipt); err != nil {
return TargetReceipt{}, err
}
if err := ValidateTargetReceipt(receipt); err != nil {
return TargetReceipt{}, err
}
return receipt, nil
}
func syncDirectory(path string) error {
directory, err := os.Open(path)
if err != nil {
return err
}
defer directory.Close()
return directory.Sync()
}