120 lines
2.5 KiB
Go
120 lines
2.5 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"kooltap-updateserver/internal/db"
|
|
"kooltap-updateserver/internal/routes"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strconv"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/joho/godotenv"
|
|
)
|
|
|
|
func main() {
|
|
|
|
_ = godotenv.Load()
|
|
|
|
dsn := os.Getenv("DATABASE_URL")
|
|
if dsn == "" {
|
|
log.Fatal("DATABASE_URL is required, e.g. postgres://user:pass@host:5432/kooltap?sslmode=disable")
|
|
}
|
|
|
|
database, err := db.Connect(dsn)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
// One-time migration of the old file based database, if it is still mounted
|
|
if err := db.ImportSQLite(database, env("SQLITE_IMPORT_PATH", "data/updater.db")); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
h := &routes.Handler{
|
|
DB: database,
|
|
UploadDir: env("UPLOAD_DIR", "uploads"),
|
|
TmpDir: env("TMP_DIR", "tmp"),
|
|
MaxUpload: int64(envInt("MAX_UPLOAD_MB", 300)) << 20,
|
|
}
|
|
|
|
for _, dir := range []string{h.UploadDir, h.TmpDir} {
|
|
if err := os.MkdirAll(dir, 0755); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
r := gin.Default()
|
|
|
|
// No proxy headers are used for anything, so do not trust any
|
|
_ = r.SetTrustedProxies(nil)
|
|
|
|
r.Use(func(c *gin.Context) {
|
|
c.Header("Server", "KoolTap Updater")
|
|
c.Next()
|
|
})
|
|
|
|
r.Static("/downloads", h.UploadDir)
|
|
|
|
r.GET("/", func(c *gin.Context) {
|
|
sqlDB, err := database.DB()
|
|
if err == nil {
|
|
err = sqlDB.PingContext(c.Request.Context())
|
|
}
|
|
if err != nil {
|
|
c.JSON(http.StatusServiceUnavailable, gin.H{"status": "database unavailable"})
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, gin.H{"status": "ok"})
|
|
})
|
|
|
|
h.Register(r)
|
|
|
|
srv := &http.Server{
|
|
Addr: ":" + env("PORT", "3000"),
|
|
Handler: r,
|
|
ReadHeaderTimeout: 10 * time.Second,
|
|
}
|
|
|
|
go func() {
|
|
log.Printf("listening on %s", srv.Addr)
|
|
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
log.Fatal(err)
|
|
}
|
|
}()
|
|
|
|
// Let in-flight uploads finish when the container is stopped
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
<-ctx.Done()
|
|
|
|
log.Println("shutting down")
|
|
shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
if err := srv.Shutdown(shutdownCtx); err != nil {
|
|
log.Printf("shutdown: %v", err)
|
|
}
|
|
if sqlDB, err := database.DB(); err == nil {
|
|
sqlDB.Close()
|
|
}
|
|
}
|
|
|
|
func env(key, fallback string) string {
|
|
if v := os.Getenv(key); v != "" {
|
|
return v
|
|
}
|
|
return fallback
|
|
}
|
|
|
|
func envInt(key string, fallback int) int {
|
|
if v, err := strconv.Atoi(os.Getenv(key)); err == nil && v > 0 {
|
|
return v
|
|
}
|
|
return fallback
|
|
}
|