Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
refactor: cleanup and simplify application bootstrap (#651)
Kyle Mendelle5994ce51448
diff --git a/backend/.air.toml b/backend/.air.tomlindex bea86ec95..c9f853ee2 100644--- a/backend/.air.toml+++ b/backend/.air.toml@@ -3,7 +3,7 @@ tmp_dir = ".bin"[build]bin = "./.bin/arcane"- cmd = "CGO_ENABLED=0 go build -tags 'exclude_frontend' -ldflags='-buildid=' -o ./.bin/arcane ./cmd"+ cmd = "CGO_ENABLED=1 go build -tags 'exclude_frontend' -ldflags='-buildid=' -o ./.bin/arcane ./cmd"exclude_dir = [".bin", "data", "node_modules", ".git"]stop_on_error = truedelay = 500diff --git a/backend/cmd/main.go b/backend/cmd/main.goindex e84701067..51d9eb8e4 100644--- a/backend/cmd/main.go+++ b/backend/cmd/main.go@@ -1,16 +1,15 @@package mainimport (+ "context""log""github.com/ofkm/arcane-backend/internal/bootstrap")func main() {- app, err := bootstrap.InitializeApp()- if err != nil {- log.Fatalf("Failed to initialize application: %v", err)+ ctx := context.Background()+ if err := bootstrap.Bootstrap(ctx); err != nil {+ log.Fatalf("Failed to run application: %v", err)}-- app.Start()}diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.goindex 25905c2b5..70cb60d84 100644--- a/backend/internal/bootstrap/bootstrap.go+++ b/backend/internal/bootstrap/bootstrap.go@@ -11,192 +11,125 @@ import ("syscall""time"- "github.com/gin-gonic/gin""github.com/joho/godotenv""github.com/ofkm/arcane-backend/internal/config"- "github.com/ofkm/arcane-backend/internal/database"- "github.com/ofkm/arcane-backend/internal/job""github.com/ofkm/arcane-backend/internal/utils"+ httputils "github.com/ofkm/arcane-backend/internal/utils/http")-type App struct {- Config *config.Config- DB *database.DB- Router *gin.Engine- Scheduler *job.Scheduler- Services *Services- AppCtx context.Context- CancelApp context.CancelFunc-}--//nolint:gocognit-func InitializeApp() (*App, error) {- ctx := context.Background()- loadErr := godotenv.Load()+func Bootstrap(ctx context.Context) error {+ _ = godotenv.Load()cfg := config.Load()- SetupLogger(cfg)+ SetupGinLogger(cfg)ConfigureGormLogger(cfg)-- if loadErr != nil {- slog.InfoContext(ctx, "No .env file found, using environment variables")- }+ slog.InfoContext(ctx, "Arcane is starting")appCtx, cancelApp := context.WithCancel(ctx)+ defer cancelApp()db, err := initializeDBAndMigrate(cfg)if err != nil {- cancelApp()- return nil, fmt.Errorf("db initialization failed: %w", err)+ return fmt.Errorf("failed to initialize database: %w", err)}+ defer func(ctx context.Context) {+ // Use background context for shutdown as appCtx is already canceled+ shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second) //nolint:contextcheck+ defer shutdownCancel()+ if err := db.Close(); err != nil {+ slog.ErrorContext(shutdownCtx, "Error closing database", slog.Any("error", err)) //nolint:contextcheck+ }+ }(appCtx)- httpClient := newHTTPClient()+ httpClient := httputils.NewHTTPClient()appServices, dockerClientService, err := initializeServices(appCtx, db, cfg, httpClient)if err != nil {- db.Close()- cancelApp()- return nil, fmt.Errorf("services initialization failed: %w", err)- }-- if cfg.AgentMode && cfg.AgentToken == "" {- if tok := appServices.Settings.GetStringSetting(appCtx, "agentToken", ""); tok != "" {- cfg.AgentToken = tok- slog.InfoContext(appCtx, "Loaded agent token from database")- }+ return fmt.Errorf("failed to initialize services: %w", err)}- if cfg.AgentMode || cfg.Environment != "production" {- if key, err := appServices.Settings.EnsureEncryptionKey(appCtx); err != nil {- slog.WarnContext(appCtx, "Failed to ensure encryption key; falling back to derived behavior",- slog.String("error", err.Error()))- } else {- cfg.EncryptionKey = key- }- }+ utils.LoadAgentToken(appCtx, cfg, appServices.Settings.GetStringSetting)+ utils.EnsureEncryptionKey(appCtx, cfg, appServices.Settings.EnsureEncryptionKey)utils.InitEncryption(cfg)+ utils.InitializeDefaultSettings(appCtx, cfg, appServices.Settings)- slog.InfoContext(appCtx, "Ensuring default settings are initialized")- if cfg.AgentMode || cfg.UIConfigurationDisabled {- if err := appServices.Settings.PersistEnvSettingsIfMissing(appCtx); err != nil {- slog.WarnContext(appCtx, "Failed to persist env-driven settings", slog.String("error", err.Error()))- } else {- slog.DebugContext(appCtx, "Persisted env-driven settings if missing")- }-- if err := appServices.Settings.SetBoolSetting(appCtx, "onboardingCompleted", true); err != nil {- slog.WarnContext(appCtx, "Failed to mark onboarding as completed", slog.String("error", err.Error()))- } else {- slog.InfoContext(appCtx, "Onboarding automatically completed (UI configuration disabled)")+ utils.TestDockerConnection(appCtx, func(ctx context.Context) error {+ dockerClient, err := dockerClientService.CreateConnection(ctx)+ if err != nil {+ return err}- }+ dockerClient.Close()+ return nil+ })- if err := appServices.Settings.EnsureDefaultSettings(appCtx); err != nil {- slog.WarnContext(appCtx, "Failed to initialize default settings", slog.String("error", err.Error()))- } else {- slog.InfoContext(appCtx, "Default settings initialized successfully")- }+ utils.InitializeNonAgentFeatures(appCtx, cfg,+ appServices.User.CreateDefaultAdmin,+ func(ctx context.Context) error {+ _, err := appServices.Settings.SyncOidcEnvToDatabase(ctx)+ return err+ })scheduler, err := initializeScheduler()if err != nil {- db.Close()- cancelApp()- return nil, fmt.Errorf("scheduler initialization failed: %w", err)+ return fmt.Errorf("failed to create job scheduler: %w", err)}+ registerJobs(appCtx, scheduler, appServices, cfg)- router := setupRouter(cfg, appServices)+ router := setupRouter(cfg, appServices) //nolint:contextcheck- if dockerClient, err := dockerClientService.CreateConnection(appCtx); err != nil {- slog.WarnContext(appCtx, "Docker connection failed during init, local Docker features may be unavailable",- slog.String("error", err.Error()))- } else {- dockerClient.Close()- }-- if !cfg.AgentMode {- if err := appServices.User.CreateDefaultAdmin(); err != nil {- slog.WarnContext(appCtx, "Failed to create default admin user",- slog.String("error", err.Error()))- }-- if cfg.OidcEnabled {- if _, err := appServices.Settings.SyncOidcEnvToDatabase(appCtx); err != nil {- slog.WarnContext(appCtx, "Failed to sync OIDC environment variables to database",- slog.String("error", err.Error()))- }- }+ err = runServices(appCtx, cfg, router, scheduler)+ if err != nil {+ return fmt.Errorf("failed to run services: %w", err)}- return &App{- Config: cfg,- DB: db,- Router: router,- Scheduler: scheduler,- Services: appServices,- AppCtx: appCtx,- CancelApp: cancelApp,- }, nil+ slog.InfoContext(appCtx, "Arcane shutdown complete")+ return nil}-func (app *App) Start() {- defer app.DB.Close()- defer app.CancelApp()-- registerJobs(app.AppCtx, app.Scheduler, app.Services, app.Config)-+func runServices(appCtx context.Context, cfg *config.Config, router http.Handler, scheduler interface{ Run(context.Context) error }) error {go func() {- slog.InfoContext(app.AppCtx, "Starting scheduler goroutine")- if err := app.Scheduler.Run(app.AppCtx); err != nil {+ slog.InfoContext(appCtx, "Starting scheduler")+ if err := scheduler.Run(appCtx); err != nil {if !errors.Is(err, context.Canceled) {- slog.ErrorContext(app.AppCtx, "Job scheduler exited with error", slog.Any("error", err))+ slog.ErrorContext(appCtx, "Job scheduler exited with error", slog.Any("error", err))}}- slog.InfoContext(app.AppCtx, "Scheduler goroutine finished")+ slog.InfoContext(appCtx, "Scheduler stopped")}()srv := &http.Server{- Addr: ":" + app.Config.Port,- Handler: app.Router,+ Addr: ":" + cfg.Port,+ Handler: router,ReadHeaderTimeout: 5 * time.Second,}go func() {- slog.InfoContext(app.AppCtx, "Starting server", slog.String("port", app.Config.Port))- if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {- slog.ErrorContext(app.AppCtx, "Failed to start server", slog.String("error", err.Error()))- os.Exit(1)+ slog.InfoContext(appCtx, "Starting HTTP server", slog.String("port", cfg.Port))+ if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {+ slog.ErrorContext(appCtx, "Failed to start server", slog.Any("error", err))}}()quit := make(chan os.Signal, 1)signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)- <-quit- slog.InfoContext(app.AppCtx, "Shutting down server and scheduler")-- app.CancelApp()-- shutdownCtx, cancelShutdown := context.WithTimeout(context.Background(), 10*time.Second)- defer cancelShutdown()- if err := srv.Shutdown(shutdownCtx); err != nil {- slog.ErrorContext(shutdownCtx, "Server forced to shutdown", slog.String("error", err.Error()))+ select {+ case <-quit:+ slog.InfoContext(appCtx, "Received shutdown signal")+ case <-appCtx.Done():+ slog.InfoContext(appCtx, "Context canceled")}- slog.InfoContext(app.AppCtx, "Server exiting")-}+ // Use background context for shutdown as appCtx is already canceled+ shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second) //nolint:contextcheck+ defer shutdownCancel()-// newHTTPClient returns a shared HTTP client for outbound requests.-func newHTTPClient() *http.Client {- transport := &http.Transport{- Proxy: http.ProxyFromEnvironment,- MaxIdleConns: 100,- IdleConnTimeout: 90 * time.Second,- TLSHandshakeTimeout: 5 * time.Second,- ExpectContinueTimeout: 1 * time.Second,- }- return &http.Client{- Transport: transport,- Timeout: 10 * time.Second,+ if err := srv.Shutdown(shutdownCtx); err != nil { //nolint:contextcheck+ slog.ErrorContext(shutdownCtx, "Server forced to shutdown", slog.Any("error", err)) //nolint:contextcheck+ return err}++ slog.InfoContext(shutdownCtx, "Server stopped gracefully") //nolint:contextcheck+ return nil}diff --git a/backend/internal/bootstrap/logger_bootstrap.go b/backend/internal/bootstrap/logger_bootstrap.goindex 08a2ac686..b21296dd8 100644--- a/backend/internal/bootstrap/logger_bootstrap.go+++ b/backend/internal/bootstrap/logger_bootstrap.go@@ -14,7 +14,7 @@ import ("gorm.io/gorm/logger")-func SetupLogger(cfg *config.Config) {+func SetupGinLogger(cfg *config.Config) {var lvl slog.Levelswitch strings.ToLower(cfg.LogLevel) {case "debug":diff --git a/backend/internal/utils/bootstrap_util.go b/backend/internal/utils/bootstrap_util.gonew file mode 100644index 000000000..c06b2252e--- /dev/null+++ b/backend/internal/utils/bootstrap_util.go@@ -0,0 +1,84 @@+package utils++import (+ "context"+ "log/slog"++ "github.com/ofkm/arcane-backend/internal/config"+)++func LoadAgentToken(ctx context.Context, cfg *config.Config, 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 *config.Config, 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",+ slog.String("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+}++func InitializeDefaultSettings(ctx context.Context, cfg *config.Config, settingsMgr SettingsManager) {+ slog.InfoContext(ctx, "Ensuring default settings are initialized")++ if cfg.AgentMode || cfg.UIConfigurationDisabled {+ if err := settingsMgr.PersistEnvSettingsIfMissing(ctx); err != nil {+ slog.WarnContext(ctx, "Failed to persist env-driven settings", slog.String("error", err.Error()))+ } else {+ slog.DebugContext(ctx, "Persisted env-driven settings if missing")+ }++ if err := settingsMgr.SetBoolSetting(ctx, "onboardingCompleted", true); err != nil {+ slog.WarnContext(ctx, "Failed to mark onboarding as completed", slog.String("error", err.Error()))+ } else {+ slog.InfoContext(ctx, "Onboarding automatically completed (UI configuration disabled)")+ }+ }++ if err := settingsMgr.EnsureDefaultSettings(ctx); err != nil {+ slog.WarnContext(ctx, "Failed to initialize default settings", slog.String("error", err.Error()))+ } else {+ slog.InfoContext(ctx, "Default settings initialized successfully")+ }+}++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",+ slog.String("error", err.Error()))+ }+}++func InitializeNonAgentFeatures(ctx context.Context, cfg *config.Config, createAdminFunc func() error, syncOidcFunc func(context.Context) error) {+ if cfg.AgentMode {+ return+ }++ if err := createAdminFunc(); err != nil {+ slog.WarnContext(ctx, "Failed to create default admin user",+ slog.String("error", err.Error()))+ }++ if cfg.OidcEnabled {+ if err := syncOidcFunc(ctx); err != nil {+ slog.WarnContext(ctx, "Failed to sync OIDC environment variables to database",+ slog.String("error", err.Error()))+ }+ }+}diff --git a/backend/internal/utils/http/client.go b/backend/internal/utils/http/client.gonew file mode 100644index 000000000..21bd48f68--- /dev/null+++ b/backend/internal/utils/http/client.go@@ -0,0 +1,20 @@+package http++import (+ "net/http"+ "time"+)++func NewHTTPClient() *http.Client {+ transport := &http.Transport{+ Proxy: http.ProxyFromEnvironment,+ MaxIdleConns: 100,+ IdleConnTimeout: 90 * time.Second,+ TLSHandshakeTimeout: 5 * time.Second,+ ExpectContinueTimeout: 1 * time.Second,+ }+ return &http.Client{+ Transport: transport,+ Timeout: 10 * time.Second,+ }+}