Skip to content

Modern Docker Management, Designed for Everyone

5.7 KB
Raw Blame
package startup

import (
	"context"
	"log/slog"
	"os"
	"runtime/debug"

	"github.com/distribution/reference"
	"go.getarcane.app/sys/cgroup"

	"github.com/getarcaneapp/arcane/backend/v2/buildables"
)

type RuntimeConfig struct {
	AgentMode         bool
	AgentToken        string
	Environment       string
	EncryptionKey     string
	AutoLoginUsername string
	AdminStaticAPIKey string
}

// ApplyMemoryLimit sets the Go soft memory limit to 90% of the cgroup memory
// limit so the GC tightens before the container is OOM-killed. GOMEMLIMIT wins.
func ApplyMemoryLimit(ctx context.Context) {
	if os.Getenv("GOMEMLIMIT") != "" {
		return
	}
	limits, err := cgroup.DetectLimits()
	// cgroup v1 reports "no limit" as a page-aligned value near MaxInt64.
	if err != nil || limits.MemoryLimit <= 0 || limits.MemoryLimit >= 1<<62 {
		return
	}
	limit := limits.MemoryLimit / 10 * 9
	debug.SetMemoryLimit(limit)
	slog.InfoContext(ctx, "Set Go memory limit from cgroup", "cgroupLimitBytes", limits.MemoryLimit, "goMemoryLimitBytes", limit)
}

func LoadAgentToken(ctx context.Context, cfg *RuntimeConfig, getSettingFunc func(context.Context, string, string) string) {
	if cfg.AgentMode && cfg.AgentToken == "" {
		if tok := getSettingFunc(ctx, "agentToken", ""); tok != "" {
			cfg.AgentToken = tok
			slog.InfoContext(ctx, "Loaded agent token from database")
		}
	}
}

func EnsureEncryptionKey(ctx context.Context, cfg *RuntimeConfig, ensureKeyFunc func(context.Context) (string, error)) {
	if cfg.AgentMode || cfg.Environment != "production" {
		key, err := ensureKeyFunc(ctx)
		if err != nil {
			slog.WarnContext(ctx, "Failed to ensure encryption key; falling back to derived behavior", "error", err.Error())
			return
		}
		cfg.EncryptionKey = key
	}
}

type SettingsManager interface {
	PersistEnvSettingsIfMissing(ctx context.Context) error
	SetBoolSetting(ctx context.Context, key string, value bool) error
	EnsureDefaultSettings(ctx context.Context) error
}

type SettingsPruner interface {
	PruneUnknownSettings(ctx context.Context) error
}

func InitializeDefaultSettings(ctx context.Context, cfg *RuntimeConfig, settingsMgr SettingsManager) {
	slog.InfoContext(ctx, "Ensuring default settings are initialized")

	if err := settingsMgr.EnsureDefaultSettings(ctx); err != nil {
		slog.WarnContext(ctx, "Failed to initialize default settings", "error", err.Error())
	} else {
		slog.InfoContext(ctx, "Default settings initialized successfully")
	}

	if err := settingsMgr.PersistEnvSettingsIfMissing(ctx); err != nil {
		slog.WarnContext(ctx, "Failed to persist env-driven settings", "error", err.Error())
	} else {
		slog.DebugContext(ctx, "Persisted env-driven settings")
	}
}

func CleanupUnknownSettings(ctx context.Context, settingsMgr SettingsPruner) {
	if err := settingsMgr.PruneUnknownSettings(ctx); err != nil {
		slog.ErrorContext(ctx, "Failed to prune unknown settings", "error", err.Error())
	}
}

func TestDockerConnection(ctx context.Context, testFunc func(context.Context) error) {
	if err := testFunc(ctx); err != nil {
		slog.WarnContext(ctx, "Docker connection failed during init, local Docker features may be unavailable", "error", err.Error())
	}
}

var deprecatedImageReplacements = map[string]string{
	"ghcr.io/getarcaneapp/arcane":          "ghcr.io/getarcaneapp/manager",
	"ghcr.io/getarcaneapp/arcane-headless": "ghcr.io/getarcaneapp/agent",
}

func WarnDeprecatedImage(ctx context.Context, imageFunc func(context.Context) (string, error)) {
	imageRef, err := imageFunc(ctx)
	if err != nil {
		slog.DebugContext(ctx, "Could not detect Arcane container image for deprecation check", "error", err)
		return
	}

	named, err := reference.ParseNormalizedNamed(imageRef)
	if err != nil {
		return
	}

	if replacement, ok := deprecatedImageReplacements[named.Name()]; ok {
		slog.WarnContext(ctx, "This Arcane image is deprecated and will be removed in v3; switch to the replacement image", "image", imageRef, "replacement", replacement)
	}
}

func CleanupOrphanedVolumeHelpers(ctx context.Context, cleanupFunc func(context.Context) (int, error)) {
	if cleanupFunc == nil {
		return
	}

	slog.InfoContext(ctx, "Checking for orphaned volume helper containers from previous runs")

	removedCount, err := cleanupFunc(ctx)
	if err != nil {
		slog.WarnContext(ctx, "Failed to clean up orphaned volume helper containers during startup", "error", err.Error())
		return
	}

	slog.InfoContext(ctx, "Orphaned volume helper cleanup completed", "removedCount", removedCount)
}

func InitializeNonAgentFeatures(
	ctx context.Context,
	cfg *RuntimeConfig,
	ensureBuiltInRolesFunc func(context.Context) error,
	createAdminFunc func(context.Context) error,
	reconcileDefaultAdminAPIKeyFunc func(context.Context) error,
	autoLoginInitFunc func(context.Context) error,
) {
	if cfg.AgentMode {
		return
	}

	if ensureBuiltInRolesFunc != nil {
		if err := ensureBuiltInRolesFunc(ctx); err != nil {
			slog.ErrorContext(ctx, "Failed to seed built-in roles before admin bootstrap", "error", err.Error())
		}
	}

	if err := createAdminFunc(ctx); err != nil {
		slog.WarnContext(ctx, "Failed to create default admin user", "error", err.Error())
	}

	if reconcileDefaultAdminAPIKeyFunc != nil {
		if err := reconcileDefaultAdminAPIKeyFunc(ctx); err != nil {
			slog.WarnContext(ctx, "Failed to reconcile default admin API key", "error", err.Error())
		}
	}

	if err := autoLoginInitFunc(ctx); err != nil {
		slog.WarnContext(ctx, "Failed to initialize auto-login", "error", err.Error())
	}
}

func InitializeAutoLogin(ctx context.Context, cfg *RuntimeConfig) {
	if !buildables.HasBuildFeature("autologin") {
		return
	}
	slog.WarnContext(ctx, "⚠️  AUTO-LOGIN IS ENABLED - This is a security risk! Do NOT use in production.", "username", cfg.AutoLoginUsername)
	slog.WarnContext(ctx, "⚠️  Auto-login will automatically authenticate users without requiring credentials.")
}