feat: clanker fixxes + postgress

2026-10-18 01:50:08 +02:00
parent 95a25453df
commit 6c3b2bdc1f
18 changed files with 829 additions and 180 deletions
@@ -1,26 +1,77 @@
 package db

 import (
+	"context"
+	"fmt"
 	"kooltap-updateserver/internal/models"
 	"log"
+	"time"

-	"github.com/glebarez/sqlite"
+	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
 )

-var DB *gorm.DB
+// Connect opens the Postgres database and migrates the schema.
+// It retries for a while because the database container may still be starting.
+func Connect(dsn string) (*gorm.DB, error) {

-func Connect() {
+	cfg := &gorm.Config{
+		// Turns driver specific unique violations into gorm.ErrDuplicatedKey
+		TranslateError: true,
+		Logger:         logger.Default.LogMode(logger.Warn),
+	}

-	db, err := gorm.Open(sqlite.Open("/app/data/updater.db"), &gorm.Config{})
+	var (
+		db  *gorm.DB
+		err error
+	)

+	deadline := time.Now().Add(60 * time.Second)
+	for {
+		db, err = gorm.Open(postgres.Open(dsn), cfg)
+		if err == nil {
+			err = ping(db)
+		}
+		if err == nil || time.Now().After(deadline) {
+			break
+		}
+		log.Printf("database not ready, retrying: %v", err)
+		time.Sleep(2 * time.Second)
+	}
 	if err != nil {
-		log.Fatal(err)
+		return nil, fmt.Errorf("connect to postgres: %w", err)
 	}

-	DB = db
-
-	if err := DB.AutoMigrate(&models.Release{}); err != nil {
-		log.Fatal(err)
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, err
 	}
+	sqlDB.SetMaxOpenConns(10)
+	sqlDB.SetMaxIdleConns(5)
+	sqlDB.SetConnMaxLifetime(30 * time.Minute)
+
+	if err := Migrate(db); err != nil {
+		return nil, err
+	}
+
+	return db, nil
+}
+
+// Migrate creates or updates the tables for all models.
+func Migrate(db *gorm.DB) error {
+	if err := db.AutoMigrate(&models.Release{}); err != nil {
+		return fmt.Errorf("migrate: %w", err)
+	}
+	return nil
+}
+
+func ping(db *gorm.DB) error {
+	sqlDB, err := db.DB()
+	if err != nil {
+		return err
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	return sqlDB.PingContext(ctx)
 }
@@ -0,0 +1,75 @@
+package db
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"kooltap-updateserver/internal/models"
+	"log"
+	"os"
+
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+// ImportSQLite copies releases from the old SQLite database at path into db,
+// once. It does nothing when the file does not exist. After a successful
+// import the file is renamed to path+".imported" so it is not imported again.
+func ImportSQLite(db *gorm.DB, path string) error {
+
+	if path == "" {
+		return nil
+	}
+	if _, err := os.Stat(path); errors.Is(err, fs.ErrNotExist) {
+		return nil
+	} else if err != nil {
+		return err
+	}
+
+	var existing int64
+	if err := db.Model(&models.Release{}).Count(&existing).Error; err != nil {
+		return err
+	}
+	if existing > 0 {
+		log.Printf("skipping SQLite import from %s: database already has %d releases", path, existing)
+		return nil
+	}
+
+	src, err := gorm.Open(sqlite.Open(path), &gorm.Config{Logger: logger.Discard})
+	if err != nil {
+		return fmt.Errorf("open sqlite %s: %w", path, err)
+	}
+	var releases []models.Release
+	err = src.Order("id").Find(&releases).Error
+	// Close before renaming the file below
+	if sqlDB, cerr := src.DB(); cerr == nil {
+		sqlDB.Close()
+	}
+	if err != nil {
+		return fmt.Errorf("read sqlite releases: %w", err)
+	}
+
+	err = db.Transaction(func(tx *gorm.DB) error {
+		if len(releases) > 0 {
+			if err := tx.Create(&releases).Error; err != nil {
+				return err
+			}
+		}
+		// Rows were inserted with their original IDs, so move the sequence past them
+		if tx.Dialector.Name() == "postgres" {
+			return tx.Exec(`SELECT setval(pg_get_serial_sequence('releases', 'id'), COALESCE((SELECT MAX(id) FROM releases), 0) + 1, false)`).Error
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("import releases: %w", err)
+	}
+
+	if err := os.Rename(path, path+".imported"); err != nil {
+		log.Printf("imported SQLite database but could not rename it: %v", err)
+	}
+
+	log.Printf("imported %d releases from %s", len(releases), path)
+	return nil
+}
@@ -0,0 +1,88 @@
+package db
+
+import (
+	"errors"
+	"io/fs"
+	"kooltap-updateserver/internal/models"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+func openSQLite(t *testing.T, dsn string) *gorm.DB {
+	t.Helper()
+	d, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{Logger: logger.Discard})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := Migrate(d); err != nil {
+		t.Fatal(err)
+	}
+	return d
+}
+
+// target returns the database to import into: Postgres when TEST_DATABASE_URL
+// is set, otherwise an in-memory SQLite database.
+func target(t *testing.T) *gorm.DB {
+	t.Helper()
+	if dsn := os.Getenv("TEST_DATABASE_URL"); dsn != "" {
+		d, err := Connect(dsn)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := d.Exec("TRUNCATE releases RESTART IDENTITY").Error; err != nil {
+			t.Fatal(err)
+		}
+		return d
+	}
+	return openSQLite(t, "file:"+t.Name()+"?mode=memory&cache=shared")
+}
+
+func TestImportSQLite(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "updater.db")
+
+	old := openSQLite(t, path)
+	old.Create(&models.Release{Version: "1.0.0", VersionCode: 1, APKFile: "app-1.0.0.apk"})
+	old.Create(&models.Release{Version: "1.1.0", VersionCode: 2, APKFile: "app-1.1.0.apk", Notes: "fixes"})
+	old.Delete(&models.Release{}, 1) // leave a gap so IDs must be preserved, not renumbered
+	old.Create(&models.Release{Version: "1.2.0", VersionCode: 3, APKFile: "app-1.2.0.apk", Mandatory: true})
+	if sqlDB, err := old.DB(); err == nil {
+		sqlDB.Close()
+	}
+
+	dst := target(t)
+	if err := ImportSQLite(dst, path); err != nil {
+		t.Fatal(err)
+	}
+
+	var got []models.Release
+	dst.Order("id").Find(&got)
+	if len(got) != 2 || got[0].ID != 2 || got[1].ID != 3 || got[0].Notes != "fixes" || !got[1].Mandatory {
+		t.Fatalf("imported %+v", got)
+	}
+
+	if _, err := os.Stat(path); !errors.Is(err, fs.ErrNotExist) {
+		t.Fatalf("sqlite file not renamed: %v", err)
+	}
+	if _, err := os.Stat(path + ".imported"); err != nil {
+		t.Fatal(err)
+	}
+
+	// New rows must not collide with the imported IDs
+	next := models.Release{Version: "1.3.0", VersionCode: 4, APKFile: "app-1.3.0.apk"}
+	if err := dst.Create(&next).Error; err != nil {
+		t.Fatal(err)
+	}
+	if next.ID <= 3 {
+		t.Fatalf("new id %d collides with imported rows", next.ID)
+	}
+
+	// A missing file is not an error
+	if err := ImportSQLite(dst, path); err != nil {
+		t.Fatal(err)
+	}
+}