init

internal/app/app.go

@@ -0,0 +1,142 @@
+package app
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"update_server/internal/apikeys"
+	"update_server/internal/auth"
+	"update_server/internal/config"
+	database "update_server/internal/db"
+	httpserver "update_server/internal/http"
+	"update_server/internal/releases"
+	"update_server/internal/storage"
+)
+
+type App struct {
+	config config.Config
+	logger *slog.Logger
+	server *http.Server
+	store  *database.Store
+}
+
+func New(cfg config.Config, logger *slog.Logger) (*App, error) {
+	if err := os.MkdirAll(cfg.DataDir, 0o750); err != nil {
+		return nil, fmt.Errorf("create data dir: %w", err)
+	}
+
+	renderer, err := httpserver.NewRenderer(cfg.TemplatesDir)
+	if err != nil {
+		return nil, fmt.Errorf("create renderer: %w", err)
+	}
+
+	sqliteDB, err := database.Open(context.Background(), cfg.SQLitePath)
+	if err != nil {
+		return nil, fmt.Errorf("open database: %w", err)
+	}
+
+	if err := database.Migrate(context.Background(), sqliteDB, cfg.MigrationsDir); err != nil {
+		sqliteDB.Close()
+		return nil, fmt.Errorf("apply migrations: %w", err)
+	}
+
+	store := database.NewStore(sqliteDB)
+	authService := auth.NewService(cfg, logger, store)
+	apiKeyService := apikeys.NewService(store)
+	if err := authService.EnsureBootstrapAdmin(context.Background()); err != nil {
+		sqliteDB.Close()
+		return nil, fmt.Errorf("bootstrap admin auth: %w", err)
+	}
+
+	artifactStore, err := storage.NewLocal(cfg.ArtifactsDir)
+	if err != nil {
+		sqliteDB.Close()
+		return nil, fmt.Errorf("create artifact storage: %w", err)
+	}
+
+	releaseService := releases.NewService(store, artifactStore)
+	router := httpserver.NewRouter(cfg, logger, renderer, store, authService, apiKeyService, releaseService)
+
+	server := &http.Server{
+		Addr:              cfg.HTTPAddr,
+		Handler:           router,
+		ReadTimeout:       cfg.ReadTimeout,
+		ReadHeaderTimeout: cfg.ReadHeaderTimeout,
+		WriteTimeout:      cfg.WriteTimeout,
+		IdleTimeout:       cfg.IdleTimeout,
+		MaxHeaderBytes:    cfg.MaxHeaderBytes,
+	}
+
+	return &App{
+		config: cfg,
+		logger: logger,
+		server: server,
+		store:  store,
+	}, nil
+}
+
+func (a *App) Run(ctx context.Context) (runErr error) {
+	defer func() {
+		if a.store == nil {
+			return
+		}
+
+		if err := a.store.Close(); err != nil {
+			closeErr := fmt.Errorf("close database: %w", err)
+			if runErr != nil {
+				runErr = errors.Join(runErr, closeErr)
+				return
+			}
+
+			runErr = closeErr
+		}
+	}()
+
+	runCtx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	serverErr := make(chan error, 1)
+
+	go func() {
+		a.logger.Info("starting server",
+			"addr", a.config.HTTPAddr,
+			"base_url", a.config.BaseURL,
+			"data_dir", a.config.DataDir,
+			"sqlite_path", a.config.SQLitePath,
+		)
+
+		serverErr <- a.server.ListenAndServe()
+	}()
+
+	select {
+	case err := <-serverErr:
+		if err != nil && !errors.Is(err, http.ErrServerClosed) {
+			return err
+		}
+
+		return nil
+	case <-runCtx.Done():
+	}
+
+	shutdownCtx, cancel := context.WithTimeout(context.Background(), a.config.ShutdownTimeout)
+	defer cancel()
+
+	a.logger.Info("shutting down server")
+
+	if err := a.server.Shutdown(shutdownCtx); err != nil {
+		return fmt.Errorf("shutdown server: %w", err)
+	}
+
+	err := <-serverErr
+	if err != nil && !errors.Is(err, http.ErrServerClosed) {
+		return err
+	}
+
+	return nil
+}