Persist metadata to DB, poll download worker, metadata service layer

cmd/music-agregator/main.go

@@ -11,7 +11,6 @@ import (
 	"github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/logging"
 	"github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/recovery"
 	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/riverqueue/river"
@@ -28,10 +27,12 @@ import (
 
 	"homelab.lan/music-agregator/internal"
 	"homelab.lan/music-agregator/internal/config"
+	"homelab.lan/music-agregator/internal/database"
 	"homelab.lan/music-agregator/internal/hello"
 	"homelab.lan/music-agregator/internal/indexer"
 	"homelab.lan/music-agregator/internal/metadata"
 	"homelab.lan/music-agregator/internal/torrent"
+	"homelab.lan/music-agregator/internal/workers"
 )
 
 func main() {
@@ -68,36 +69,54 @@ func interceptorLogger(l zerolog.Logger) logging.Logger {
 	})
 }
 
-func setupRiver(ctx context.Context, cfg config.Config) (*river.Client[pgx.Tx], *pgxpool.Pool) {
-	if !cfg.Indexer.Cache.Enabled {
-		return nil, nil
-	}
-
-	dbPool, err := pgxpool.New(ctx, cfg.Database.URL)
+func setupDatabase(ctx context.Context, cfg config.Config) *database.DB {
+	db, err := database.New(ctx, cfg.Database.URL)
 	if err != nil {
-		log.Fatal().Err(err).Msg("failed to connect to database for River")
+		log.Fatal().Err(err).Msg("failed to connect to database")
+	}
+	return db
+}
+
+type riverSetup struct {
+	client             *river.Client[pgx.Tx]
+	cacheRefreshWorker *indexer.CacheRefreshWorker
+}
+
+func setupRiver(ctx context.Context, cfg config.Config, db *database.DB) *riverSetup {
+	cacheWorker := &indexer.CacheRefreshWorker{}
+	pollWorker := &workers.PollDownloadWorker{
+		Downloads:     database.NewDownloadRepository(db.Pool),
+		DownloadFiles: database.NewDownloadFileRepository(db.Pool),
+		TorrentClient: torrent.MustNewTorrentClient(cfg),
 	}
 
-	workers := river.NewWorkers()
-	river.AddWorker(workers, &indexer.CacheRefreshWorker{})
+	riverWorkers := river.NewWorkers()
+	river.AddWorker(riverWorkers, cacheWorker)
+	river.AddWorker(riverWorkers, pollWorker)
 
-	riverClient, err := river.NewClient(riverpgxv5.New(dbPool), &river.Config{
+	riverClient, err := river.NewClient(riverpgxv5.New(db.Pool), &river.Config{
 		Queues: map[string]river.QueueConfig{
-			river.QueueDefault: {MaxWorkers: 2},
+			river.QueueDefault: {MaxWorkers: 4},
 		},
-		Workers: workers,
+		Workers: riverWorkers,
 	})
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed to create River client")
 	}
 
+	cacheWorker.RiverClient = riverClient
+	pollWorker.RiverClient = riverClient
+
 	if err := riverClient.Start(ctx); err != nil {
 		log.Fatal().Err(err).Msg("failed to start River client")
 	}
 
 	log.Info().Msg("River queue started")
 
-	return riverClient, dbPool
+	return &riverSetup{
+		client:             riverClient,
+		cacheRefreshWorker: cacheWorker,
+	}
 }
 
 func serveGrpc(config config.Config) {
@@ -132,16 +151,15 @@ func serveGrpc(config config.Config) {
 	)
 
 	ctx := context.Background()
-	riverClient, dbPool := setupRiver(ctx, config)
-	if dbPool != nil {
-		defer dbPool.Close()
-	}
+	db := setupDatabase(ctx, config)
+	defer db.Close()
+	rs := setupRiver(ctx, config, db)
 
-	musiscAgregatorSeerver, err := internal.NewMusicAgregatorServer(config, riverClient)
+	musiscAgregatorSeerver, err := internal.NewMusicAgregatorServer(config, rs.client, db)
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed to create MusicAgregatorServer")
 	}
-	indexerServer, err := indexer.NewIndexerServer(config, riverClient)
+	indexerServer, err := indexer.NewIndexerServer(config, rs.client, rs.cacheRefreshWorker)
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed to create IndexerServer")
 	}