Skip to content

Modern Docker Management, Designed for Everyone

refactor: cleanup and simplify application bootstrap (#651)

Kyle Mendelle5994ce51448
diff --git a/backend/.air.toml b/backend/.air.toml
index 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 = true
delay = 500
diff --git a/backend/cmd/main.go b/backend/cmd/main.go
index e84701067..51d9eb8e4 100644
--- a/backend/cmd/main.go
+++ b/backend/cmd/main.go
@@ -1,16 +1,15 @@
package main
import (
+ "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.go
index 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.go
index 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.Level
switch strings.ToLower(cfg.LogLevel) {
case "debug":
diff --git a/backend/internal/utils/bootstrap_util.go b/backend/internal/utils/bootstrap_util.go
new file mode 100644
index 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.go
new file mode 100644
index 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,
+ }
+}