Skip to content

Modern Docker Management, Designed for Everyone

7.6 KB
Raw Blame
package francis

import (
	"bytes"
	"cmp"
	"context"
	"database/sql"
	"errors"
	"fmt"
	"log/slog"
	"net/url"
	"path/filepath"
	"strings"
	"time"

	"github.com/italypaleale/francis/components"
	"github.com/italypaleale/francis/components/postgres"
	"github.com/italypaleale/francis/components/sqlite"
	"github.com/italypaleale/francis/host/local"

	sqliteutil "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/sqlite"
)

// legacyDrops remove the Francis schema that lived in the Arcane SQLite database
// before v2.16. That schema never changes again, so the list is final.
// Remove this in v3.0.0
var legacyDrops = []string{
	"DROP VIEW IF EXISTS " + TablePrefix + "_host_active_actor_count",
	"DROP TABLE IF EXISTS " + TablePrefix + "_host_actor_types",
	"DROP TABLE IF EXISTS " + TablePrefix + "_active_actors",
	"DROP TABLE IF EXISTS " + TablePrefix + "_consumed_join_tokens",
	"DROP TABLE IF EXISTS " + TablePrefix + "_hosts",
	"DROP TABLE IF EXISTS " + TablePrefix + "_actor_state",
	"DROP TABLE IF EXISTS " + TablePrefix + "_alarms",
	"DROP TABLE IF EXISTS " + TablePrefix + "_cluster_config",
	"DROP TABLE IF EXISTS " + TablePrefix + "_terminal_jobs",
	"DROP TABLE IF EXISTS " + TablePrefix + "_dead_jobs",
	"DROP TABLE IF EXISTS " + TablePrefix + "_metadata",
}

// StorePath names the dedicated Francis SQLite file beside the Arcane database.
func StorePath(databasePath string) string {
	extension := filepath.Ext(databasePath)
	return strings.TrimSuffix(databasePath, extension) + ".francis" + cmp.Or(extension, ".db")
}

// StoreURL resolves Francis storage: a sibling SQLite file with the Arcane SQLite
// settings except foreign_keys, which Francis enforces, or the Postgres URL unchanged.
func StoreURL(databaseURL string) (string, error) {
	switch {
	case strings.HasPrefix(databaseURL, "file:"):
		parsed, err := url.Parse(databaseURL)
		if err != nil {
			return "", fmt.Errorf("parse actor database URL: %w", err)
		}
		databasePath := parsed.Path
		if parsed.Opaque != "" {
			if databasePath, err = url.PathUnescape(parsed.Opaque); err != nil {
				return "", fmt.Errorf("parse actor database URL: %w", err)
			}
		}
		if databasePath == "" || strings.HasPrefix(databasePath, ":memory:") || parsed.Query().Get("mode") == "memory" {
			return "", errors.New("actor storage requires a file-backed SQLite database")
		}
		query := sqliteutil.NormalizeQuery(parsed.Query())
		// The sibling file must be creatable and writable whatever mode opens arcane.db.
		query.Del("mode")
		if !sqliteutil.HasPragma(query, "busy_timeout") {
			query.Add("_pragma", "busy_timeout(10000)")
		}
		// NORMAL stops WAL commits from holding the write lock through an fsync.
		if !sqliteutil.HasPragma(query, "synchronous") {
			query.Add("_pragma", "synchronous(NORMAL)")
		}
		if !sqliteutil.HasPragma(query, "journal_mode") {
			query.Add("_pragma", "journal_mode(WAL)")
		}
		return "file:" + (&url.URL{Path: StorePath(databasePath)}).EscapedPath() + "?" + query.Encode(), nil
	case strings.HasPrefix(databaseURL, "postgres"):
		return databaseURL, nil
	default:
		return "", errors.New("unsupported actor database URL")
	}
}

func providerOption(storeURL string) local.HostOption {
	if strings.HasPrefix(storeURL, "file:") {
		return local.WithSQLiteProvider(sqlite.SQLiteProviderOptions{ConnectionString: storeURL, TablePrefix: TablePrefix})
	}
	return local.WithPostgresProvider(postgres.PostgresProviderOptions{ConnectionString: storeURL, TablePrefix: TablePrefix})
}

// openProvider opens an offline Francis provider on storeURL. Close it when done.
func openProvider(ctx context.Context, storeURL string) (components.ActorProvider, error) {
	cfg := components.NewProviderConfig()
	cfg.HostHealthCheckDeadline = 90 * time.Second
	cfg.MaxHosts = 1
	var provider components.ActorProvider
	var err error
	if strings.HasPrefix(storeURL, "file:") {
		provider, err = sqlite.NewSQLiteProvider(slog.Default(), sqlite.SQLiteProviderOptions{ConnectionString: storeURL, TablePrefix: TablePrefix}, cfg)
	} else {
		provider, err = postgres.NewPostgresProvider(slog.Default(), postgres.PostgresProviderOptions{ConnectionString: storeURL, TablePrefix: TablePrefix}, cfg)
	}
	if err != nil {
		return nil, err
	}
	if err = provider.Init(ctx); err != nil {
		return nil, errors.Join(fmt.Errorf("initialize actor provider: %w", err), provider.Close())
	}
	return provider, nil
}

// ClearRestoredHosts removes copied live host ownership from an offline restored
// database. Never call this against a running Arcane database.
func ClearRestoredHosts(ctx context.Context, databaseURL string) (err error) {
	storeURL, err := StoreURL(databaseURL)
	if err != nil {
		return err
	}
	provider, err := openProvider(ctx, storeURL)
	if err != nil {
		return fmt.Errorf("open restored actor storage: %w", err)
	}
	defer func() {
		if closeErr := provider.Close(); closeErr != nil {
			err = errors.Join(err, fmt.Errorf("close restored actor provider: %w", closeErr))
		}
	}()
	hosts, err := provider.ListHosts(ctx)
	if err != nil {
		return fmt.Errorf("list restored actor hosts: %w", err)
	}
	for _, host := range hosts {
		err = provider.UnregisterHost(ctx, host.HostID, components.UnregisterHostOpts{})
		if err != nil && !errors.Is(err, components.ErrHostUnregistered) {
			return fmt.Errorf("remove restored actor host: %w", err)
		}
	}
	// Expired registrations are excluded by ListHosts and pruned by RegisterHost.
	return nil
}

// MigrateLegacyStore moves Francis state kept inside the Arcane SQLite database
// into its dedicated file, then drops the old tables. Reruns until the drop succeeds.
func MigrateLegacyStore(ctx context.Context, mainDB *sql.DB, databaseURL string) (err error) {
	if !strings.HasPrefix(databaseURL, "file:") {
		return nil
	}
	var legacy int
	var journalMode string
	err = errors.Join(
		mainDB.QueryRowContext(ctx, "SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = ?", TablePrefix+"_metadata").Scan(&legacy),
		mainDB.QueryRowContext(ctx, "PRAGMA journal_mode").Scan(&journalMode),
	)
	if err != nil || legacy == 0 {
		return err
	}
	storeURL, err := StoreURL(databaseURL)
	if err != nil {
		return err
	}
	// Francis needs its own connection with foreign keys on; keep the Arcane journal mode.
	legacyURL, _, _ := strings.Cut(databaseURL, "?")
	source, err := openProvider(ctx, legacyURL+"?_pragma="+url.QueryEscape("journal_mode("+journalMode+")"))
	if err != nil {
		return fmt.Errorf("open legacy actor storage: %w", err)
	}
	var snapshot bytes.Buffer
	err = errors.Join(source.Backup(ctx, &snapshot), source.Close())
	if err != nil {
		return fmt.Errorf("export legacy actor storage: %w", err)
	}
	target, err := openProvider(ctx, storeURL)
	if err != nil {
		return fmt.Errorf("open actor storage: %w", err)
	}
	err = errors.Join(target.Restore(ctx, &snapshot), target.Close())
	if err != nil {
		return fmt.Errorf("import legacy actor storage: %w", err)
	}
	tx, err := mainDB.BeginTx(ctx, nil)
	if err != nil {
		return fmt.Errorf("begin legacy actor storage cleanup: %w", err)
	}
	defer func() {
		if rollbackErr := tx.Rollback(); rollbackErr != nil && !errors.Is(rollbackErr, sql.ErrTxDone) {
			err = errors.Join(err, fmt.Errorf("roll back legacy actor storage cleanup: %w", rollbackErr))
		}
	}()
	// Keep the metadata marker and every source table intact until cleanup commits.
	for _, drop := range legacyDrops {
		if _, err = tx.ExecContext(ctx, drop); err != nil {
			return fmt.Errorf("drop legacy actor storage: %w", err)
		}
	}
	if err = tx.Commit(); err != nil {
		return fmt.Errorf("commit legacy actor storage cleanup: %w", err)
	}
	storePath, _, _ := strings.Cut(strings.TrimPrefix(storeURL, "file:"), "?")
	slog.InfoContext(ctx, "Migrated actor state to its dedicated database", "path", storePath)
	return nil
}