main.go

package main

import (
	"context"
	valkeyq "linkra/queue/valkey"
	"linkra/server"
	"linkra/server/components"
	"linkra/services"
	"linkra/storage"
	gormStorage "linkra/storage/gorm"
	"linkra/utils"
	"log/slog"
	"net"
	"os"
	"os/signal"
	"runtime"
	"strings"
	"syscall"
	"time"

	"github.com/labstack/echo/v5"
	"github.com/valkey-io/valkey-go"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func main() {
	e := echo.New()

	// Use echo logger
	log := e.Logger

	const defaultDBPath = "storage.db"
	sqlitePath, ok := os.LookupEnv("DB_PATH")
	if !ok {
		log.Warn("the database path is not set, using default " + defaultDBPath)
		sqlitePath = defaultDBPath
	}

	// Prepare db connection.
	db, err := gorm.Open(sqlite.Open(sqlitePath), &gorm.Config{})
	if err != nil {
		log.Error("could not open database connection", slog.String("error", err.Error()))
		os.Exit(1)
	}

	// Prepare queue client
	valkeyOptions := valkeyq.NewValkeyOptionsFromEnv()
	client, err := valkey.NewClient(valkey.ClientOption{InitAddress: []string{net.JoinHostPort(valkeyOptions.Addr, valkeyOptions.Port)}})
	if err != nil {
		log.Error("failed to create valkey client", "error", err.Error())
		os.Exit(1)
	}

	// Get server address
	const defaultServerAddress = "localhost:8080"
	serverAddress, ok := os.LookupEnv("SERVER_ADDRESS")
	if !ok {
		log.Warn("the SERVER_ADDRESS is not set, using default " + defaultServerAddress)
		serverAddress = defaultServerAddress
	}

	// Prepare constants for templ components.
	// This needs to be done before the server starts listening
	serverHost, ok := os.LookupEnv("SERVER_HOST")
	if !ok {
		serverHost = serverAddress
		log.Warn("the SERVER_HOST is not set, using server address " + serverHost)
	}
	if !strings.HasPrefix(serverHost, "http") {
		serverHost = "http://" + serverHost
		log.Warn("added http:// prefix to SERVER_HOST because it was missing")
	}
	const (
		staticPathSegment          = "/static/"
		seedDetailPathSegment      = "/seed/"
		groupDetailPathSegment     = "/seeds/"
		waybackRedirectPathSegment = "/wa/"
	)
	components.SetComponentConstants(components.NewComponentConstants(
		serverHost,
		staticPathSegment,
		seedDetailPathSegment,
		groupDetailPathSegment,
		waybackRedirectPathSegment,
	))

	// Catch SIGINT and SIGHUP. Prepare gentle shutdown.
	// TODO: There are more signals that need catching
	signals := []os.Signal{os.Interrupt}
	if runtime.GOOS == "linux" {
		signals = append(signals, syscall.SIGHUP, syscall.SIGTERM)
	}
	stopSignal, stop := signal.NotifyContext(context.Background(), signals...)
	defer stop()
	utils.ShutdownFunc = stop // Setup function, that can be used in cases, where shutdown of the server is necessary.

	// Prepare repository
	seedRepository := gormStorage.NewSeedRepository(log, db)
	idListRepository := gormStorage.NewIdListRepository(db)
	repository := storage.NewRepository(seedRepository, idListRepository)

	// Prepare services
	queue := valkeyq.NewQueue(log, client)
	serviceSettings := &services.ServiceSettings{
		ServerHost:          serverHost,
		SeedDetailPath:      seedDetailPathSegment,
		WaybackRedirectPath: waybackRedirectPathSegment,
	}
	initiatedServices := services.NewServices(stopSignal, log, repository, queue, serviceSettings)

	// Prepare server
	server := server.NewServer(
		stopSignal,
		log,
		serverAddress,
		initiatedServices,
		e,
	)

	// Start the server in new goroutine
	// TODO: See if it makes sense to cath this error.
	go server.ListenAndServe()
	log.Info("Server is listening at http://" + serverAddress)

	// Start listening for results from queue
	initiatedServices.CaptureService.ListenForResults(stopSignal)
	log.Info("CaptureService is listening for CaptureResults")

	// Wait for interrupt
	<-stopSignal.Done()
	// Wait for shutdown (or timeout and go eat dirt)
	shutdownTimeout, stop := context.WithTimeout(context.Background(), 120*time.Second)
	defer stop()
	err = server.Shutdown(shutdownTimeout)
	if err != nil {
		log.Error("shutdown timeout run out", slog.String("error", err.Error()))
	}
	log.Info("Server shutdown")
}