server

package
v0.4.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 8, 2026 License: MIT Imports: 37 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var Cmd = &cobra.Command{
	Use:     "serve",
	Aliases: []string{"run"},
	Short:   "Starts the DRS Object API server",
	RunE: func(cmd *cobra.Command, args []string) error {
		logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
		slog.SetDefault(logger)

		cfg, err := config.LoadConfig(configFile)
		if err != nil {
			return fmt.Errorf("failed to load config: %w", err)
		}
		if cfg.Auth.Mode == config.AuthModeGen3 && cfg.Database.Postgres == nil && !isMockAuthEnabled() {
			return fmt.Errorf("auth.mode=gen3 requires postgres database")
		}

		// Init DB
		var backend serverBackend
		var errDb error

		if cfg.Database.Sqlite != nil {
			dbPath := cfg.Database.Sqlite.File
			if dbPath == "" {
				dbPath = "drs.db"
				cfg.Database.Sqlite.File = dbPath
			}
			logger.Info("initializing sqlite database", "file", dbPath)
			var database *sqlite.SqliteDB
			database, errDb = sqlite.NewSqliteDB(dbPath)
			if errDb == nil {
				backend = sqliteServerBackend(database)
			}
		} else if cfg.Database.Postgres != nil {
			dsn := fmt.Sprintf("postgres://%s:%s@%s:%d/%s?sslmode=%s",
				cfg.Database.Postgres.User,
				cfg.Database.Postgres.Password,
				cfg.Database.Postgres.Host,
				cfg.Database.Postgres.Port,
				cfg.Database.Postgres.Database,
				cfg.Database.Postgres.SSLMode,
			)
			logger.Info("initializing postgres database", "host", cfg.Database.Postgres.Host, "database", cfg.Database.Postgres.Database)
			var database *postgres.PostgresDB
			database, errDb = postgres.NewPostgresDB(dsn)
			if errDb == nil {
				backend = postgresServerBackend(database)
			}
		} else {
			return fmt.Errorf("no database configuration provided")
		}

		if errDb != nil {
			return fmt.Errorf("failed to initialize database: %w", errDb)
		}

		applyCredentialEncryptionConfig(cfg)

		needsStorage := cfg.Routes.Ga4gh || cfg.Routes.Internal || cfg.Routes.LFS
		var invalidator *storageInvalidator
		var storageManager *storage.Manager
		if needsStorage {
			invalidator = &storageInvalidator{}
		}
		bucketDependencies := backend.bucketDependencies
		bucketDependencies.Fallback = newBucketVisibilityFallback(
			backend.objectDependencies.Scope,
			backend.objectDependencies.Reader,
		)
		bucketService, err := buckets.NewService(bucketDependencies, invalidator)
		if err != nil {
			return fmt.Errorf("failed to initialize bucket service: %w", err)
		}
		if needsStorage {
			var storageErr error
			storageManager, storageErr = newStorageManager(bucketService, "/", logger)
			if storageErr != nil {
				return fmt.Errorf("failed to initialize storage manager: %w", storageErr)
			}
			invalidator.manager = storageManager
		}

		if len(cfg.Buckets) > 0 {
			encryptionEnabled, encErr := credentialcipher.CredentialEncryptionEnabled()
			if encErr != nil {
				return fmt.Errorf("invalid credential encryption configuration for %s: %w", credentialcipher.CredentialMasterKeyEnv, encErr)
			}
			if !encryptionEnabled {
				return fmt.Errorf("s3 credential encryption key is required: %s", credentialcipher.CredentialMasterKeyEnv)
			}

			logger.Info("loading configured bucket credentials", "count", len(cfg.Buckets))

			for _, c := range cfg.Buckets {
				cred := &buckets.Credential{
					CredentialID: c.CredentialID,
					Bucket:       c.Bucket,
					Provider:     c.Provider,
					Region:       c.Region,
					AccessKey:    c.AccessKey,
					SecretKey:    c.SecretKey,
					Endpoint:     c.Endpoint,
				}
				if err := bucketService.SaveS3Credential(cmd.Context(), cred); err != nil {
					logger.Error("failed to save s3 credential", "bucket", c.Bucket, "err", err)
				}
			}
		}
		if err := loadConfiguredBucketScopes(cmd.Context(), bucketService, bucketService, cfg.BucketScopes, logger); err != nil {
			return fmt.Errorf("failed to load configured bucket scopes: %w", err)
		}

		objectService := objectrecords.NewService(backend.objectDependencies)
		usageService := usage.NewService(usage.Dependencies{
			Reports: backend.usageReports,
			Objects: objectService,
		})
		transferService := transfers.NewService(transfers.Dependencies{
			Access:      storageManager,
			Multipart:   storageManager,
			Scopes:      bucketService,
			Credentials: bucketService,
			Events:      backend.usageIngest,
		})
		projectStorageService := projectstorage.NewService(
			projectstorage.Dependencies{
				Scopes:         bucketService,
				Credentials:    bucketService,
				Visibility:     bucketService,
				Inventory:      storageManager,
				Probe:          storageManager,
				Delete:         storageManager,
				Physical:       objectService,
				CleanupObjects: objectService,
				CleanupScopes:  bucketService,
			},
		)
		scopeRepairService := newScopeRepairService(objectService, bucketService, storageManager)

		app := fiber.New(fiber.Config{
			ReadTimeout:    30 * time.Second,
			WriteTimeout:   120 * time.Second,
			IdleTimeout:    120 * time.Second,
			ReadBufferSize: 64 * 1024,
			AppName:        "Syfon DRS Server",
			ErrorHandler:   middleware.FiberErrorHandler,
		})
		app.Use(recover.New())

		slogLogger := logger
		authRuntime := authentication.NewRuntime(
			slogLogger,
			cfg.Auth.Mode,
			cfg.Auth.Basic.Username,
			cfg.Auth.Basic.Password,
		)
		authzMiddleware := middleware.NewAuthzMiddleware(slogLogger, middleware.Options{
			Mode:      cfg.Auth.Mode,
			Evaluator: authRuntime,
		})
		requestIDMiddleware := middleware.NewRequestIDMiddleware(slogLogger)

		rt := &serverRuntime{
			app:                 app,
			cfg:                 cfg,
			serviceInfo:         serviceInfoForBackend(cfg.Database.Sqlite != nil),
			objectService:       objectService,
			transferService:     transferService,
			lfsPending:          backend.pending,
			usageService:        usageService,
			usageIngest:         backend.usageIngest,
			projectInspector:    projectStorageService.Inspector,
			projectCleanup:      projectStorageService.ProjectCleanup,
			scopeRepairService:  scopeRepairService,
			bucketService:       bucketService,
			authzMiddleware:     authzMiddleware,
			requestIDMiddleware: requestIDMiddleware,
		}
		registerServerRoutes(rt)

		addr := fmt.Sprintf(":%d", cfg.Port)
		logger.Info("server starting", "addr", addr)

		errCh := make(chan error, 1)
		go func() {
			if err := app.Listen(addr); err != nil {
				errCh <- err
			}
		}()

		sigCh := make(chan os.Signal, 1)
		signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
		defer signal.Stop(sigCh)

		select {
		case err := <-errCh:
			return fmt.Errorf("server listen failed: %w", err)
		case sig := <-sigCh:
			logger.Info("shutdown signal received", "signal", sig.String())
		case <-cmd.Context().Done():
			logger.Info("shutdown requested by context cancellation")
		}

		shutdownCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
		defer cancel()
		if err := app.ShutdownWithContext(shutdownCtx); err != nil {
			return fmt.Errorf("server shutdown failed: %w", err)
		}
		logger.Info("server shutdown complete")
		return nil
	},
}

Functions

This section is empty.

Types

This section is empty.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL