files/cmd/server/main.go

package main

import (
	"context"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	commondb "gitea.estateliga.work/admin/portal-common/db"
	commonmw "gitea.estateliga.work/admin/portal-common/middleware"
	"github.com/go-chi/chi/v5"
	chimw "github.com/go-chi/chi/v5/middleware"

	"files-service/internal/config"
	"files-service/internal/handler"
	"files-service/internal/migrate"
	"files-service/internal/repository"
	"files-service/internal/storage"
)

func main() {
	slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo})))

	cfg := config.Load()
	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()

	pool, err := commondb.ConnectWithRetry(ctx, cfg.DatabaseURL, 10*time.Minute)
	if err != nil {
		slog.Error("connect database", "error", err)
		os.Exit(1)
	}
	defer pool.Close()

	if err := migrate.Run(context.Background(), pool, cfg.MigrationsDir); err != nil {
		slog.Error("run migrations", "error", err)
		os.Exit(1)
	}

	store, err := storage.New(storage.Config{
		Endpoint:  cfg.MinIOEndpoint,
		AccessKey: cfg.MinIOAccessKey,
		SecretKey: cfg.MinIOSecretKey,
		Bucket:    cfg.MinIOBucket,
		UseSSL:    cfg.MinIOUseSSL,
	})
	if err != nil {
		slog.Error("init storage", "error", err)
		os.Exit(1)
	}
	if err := store.EnsureBucket(ctx); err != nil {
		slog.Warn("ensure bucket failed", "error", err)
	}

	healthH := handler.NewHealthHandler(pool)
	nodeRepo := repository.NewNodeRepository(pool)
	nodeH := handler.NewNodeHandler(cfg, nodeRepo, store)
	go runTrashPurger(ctx, nodeRepo, store)

	r := chi.NewRouter()
	r.Use(chimw.RequestID)
	r.Use(chimw.RealIP)
	r.Use(chimw.Recoverer)

	r.Get("/healthz", healthH.Healthz)
	r.Get("/readyz", healthH.Readyz)

	mountFilesAPI := func(r chi.Router) {
		r.Get("/nodes", nodeH.List)
		r.Post("/folders", nodeH.CreateFolder)
		r.Post("/files", nodeH.UploadFile)
		r.Route("/nodes/{id}", func(r chi.Router) {
			r.Get("/", nodeH.Get)
			r.Patch("/", nodeH.Update)
			r.Post("/move", nodeH.Move)
			r.Delete("/", nodeH.Delete)
			r.Get("/download", nodeH.Download)
			r.Get("/access", nodeH.ListAccess)
			r.Put("/access", nodeH.ReplaceAccess)
			r.Post("/public-links", nodeH.CreatePublicLink)
		})
	}

	r.Route("/api", func(r chi.Router) {
		r.Use(commonmw.InternalAuth(cfg.InternalAPIKey))
		mountFilesAPI(r)
	})
	r.Group(func(r chi.Router) {
		r.Use(commonmw.InternalAuth(cfg.InternalAPIKey))
		mountFilesAPI(r)
	})

	r.Get("/public/{token}", nodeH.PublicMeta)
	r.Get("/public/{token}/download", nodeH.PublicDownload)

	srv := &http.Server{
		Addr:         ":" + cfg.ServerPort,
		Handler:      r,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 10 * time.Minute,
		IdleTimeout:  60 * time.Second,
	}

	go func() {
		slog.Info("files server starting", "port", cfg.ServerPort, "pod", cfg.PodName)
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			slog.Error("server error", "error", err)
			os.Exit(1)
		}
	}()

	<-ctx.Done()
	shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err := srv.Shutdown(shutdownCtx); err != nil {
		slog.Error("server shutdown error", "error", err)
	}
}

func runTrashPurger(ctx context.Context, repo *repository.NodeRepository, store *storage.Storage) {
	ticker := time.NewTicker(time.Hour)
	defer ticker.Stop()
	for {
		purgeExpiredTrash(ctx, repo, store)
		select {
		case <-ctx.Done():
			return
		case <-ticker.C:
		}
	}
}

func purgeExpiredTrash(ctx context.Context, repo *repository.NodeRepository, store *storage.Storage) {
	keys, err := repo.ListPurgeableStorageKeys(ctx)
	if err != nil {
		slog.Warn("list purgeable files failed", "error", err)
		return
	}
	for _, key := range keys {
		if err := store.RemoveObject(ctx, key); err != nil {
			slog.Warn("remove purged file object failed", "key", key, "error", err)
		}
	}
	count, err := repo.PurgeExpired(ctx)
	if err != nil {
		slog.Warn("purge expired trash failed", "error", err)
		return
	}
	if count > 0 {
		slog.Info("purged expired trash", "nodes", count, "objects", len(keys))
	}
}