[apiserver] fix lost_and_found cleanup skipped when auto_vacuum already enabled

The lost_and_found drop code was inside the mode != 2 branch, so when
auto_vacuum was already set to incremental the function returned early
and never dropped the tables. Move cleanup before the mode check so it
always runs, and VACUUM to reclaim space when tables were dropped.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dilyevsky

pkg/apiserver/storage.go

@@ -26,6 +26,9 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/metrics"
 )
 
+// SQLite auto_vacuum modes: https://www.sqlite.org/pragma.html#pragma_auto_vacuum
+const sqliteAutoVacuumIncremental = 2
+
 // encodeSQLiteConnArgs encodes connection arguments as a query string.
 func encodeSQLiteConnArgs(args map[string]string) string {
 	var buf strings.Builder
@@ -51,21 +54,8 @@ func enableAutoVacuum(path string) error {
 	}
 	defer db.Close()
 
-	var mode int
-	if err := db.QueryRow("PRAGMA auto_vacuum").Scan(&mode); err != nil {
-		return fmt.Errorf("querying auto_vacuum mode: %w", err)
-	}
-	if mode == 2 {
-		slog.Info("SQLite auto_vacuum already set to incremental")
-		return nil
-	}
-
-	slog.Info("Setting SQLite auto_vacuum to incremental", "current_mode", mode)
-	if _, err := db.Exec("PRAGMA auto_vacuum = INCREMENTAL"); err != nil {
-		return fmt.Errorf("setting auto_vacuum: %w", err)
-	}
-
 	// Drop litestream recovery artifacts (lost_and_found tables from sqlite3 .recover).
+	// This runs unconditionally so cleanup happens even when auto_vacuum is already set.
 	rows, err := db.Query("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'lost_and_found%'")
 	if err != nil {
 		return fmt.Errorf("querying lost_and_found tables: %w", err)
@@ -87,6 +77,29 @@ func enableAutoVacuum(path string) error {
 		}
 	}
 
+	var mode int
+	if err := db.QueryRow("PRAGMA auto_vacuum").Scan(&mode); err != nil {
+		return fmt.Errorf("querying auto_vacuum mode: %w", err)
+	}
+
+	if mode == sqliteAutoVacuumIncremental {
+		if len(toDrop) == 0 {
+			slog.Info("SQLite auto_vacuum already set to incremental")
+			return nil
+		}
+		// Tables were dropped; VACUUM to reclaim space.
+		slog.Info("SQLite auto_vacuum already set, vacuuming to reclaim dropped tables", "dropped", len(toDrop))
+		if _, err := db.Exec("VACUUM"); err != nil {
+			return fmt.Errorf("vacuuming database: %w", err)
+		}
+		return nil
+	}
+
+	slog.Info("Setting SQLite auto_vacuum to incremental", "current_mode", mode)
+	if _, err := db.Exec("PRAGMA auto_vacuum = INCREMENTAL"); err != nil {
+		return fmt.Errorf("setting auto_vacuum: %w", err)
+	}
+
 	// VACUUM is required to convert the database to the new auto_vacuum mode.
 	if _, err := db.Exec("VACUUM"); err != nil {
 		return fmt.Errorf("vacuuming database: %w", err)

pkg/apiserver/storage_test.go

@@ -52,6 +52,93 @@ func createBloatedDB(t *testing.T, path string) int64 {
 	return fi.Size()
 }
 
+func TestEnableAutoVacuum_AlreadyEnabled(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "test.db")
+
+	// Create a DB with auto_vacuum already set to incremental, then add lost_and_found tables.
+	db, err := sql.Open("sqlite3", dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Exec("PRAGMA auto_vacuum = INCREMENTAL"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Exec("VACUUM"); err != nil {
+		t.Fatal(err)
+	}
+	// Verify auto_vacuum is set.
+	var mode int
+	if err := db.QueryRow("PRAGMA auto_vacuum").Scan(&mode); err != nil {
+		t.Fatal(err)
+	}
+	if mode != sqliteAutoVacuumIncremental {
+		t.Fatalf("setup: auto_vacuum = %d, want %d", mode, sqliteAutoVacuumIncremental)
+	}
+
+	// Add data and lost_and_found artifacts.
+	if _, err := db.Exec("CREATE TABLE t(k TEXT, v BLOB)"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Exec("CREATE TABLE lost_and_found(rootpgno INT, pgno INT, nfield INT, id INT, c0, c1)"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Exec("CREATE TABLE lost_and_found_0(rootpgno INT, pgno INT, nfield INT, id INT, c0)"); err != nil {
+		t.Fatal(err)
+	}
+	for i := 0; i < 500; i++ {
+		if _, err := db.Exec("INSERT INTO lost_and_found VALUES (?, ?, 2, ?, randomblob(1024), randomblob(1024))", i, i, i); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := db.Exec("INSERT INTO lost_and_found_0 VALUES (?, ?, 1, ?, randomblob(2048))", i, i, i); err != nil {
+			t.Fatal(err)
+		}
+	}
+	db.Close()
+
+	before, err := os.Stat(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("before: %d bytes", before.Size())
+
+	if err := enableAutoVacuum(dbPath); err != nil {
+		t.Fatalf("enableAutoVacuum: %v", err)
+	}
+
+	db, err = sql.Open("sqlite3", dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	// Verify auto_vacuum is still set.
+	if err := db.QueryRow("PRAGMA auto_vacuum").Scan(&mode); err != nil {
+		t.Fatal(err)
+	}
+	if mode != sqliteAutoVacuumIncremental {
+		t.Errorf("auto_vacuum = %d, want %d", mode, sqliteAutoVacuumIncremental)
+	}
+
+	// Verify lost_and_found tables were dropped.
+	var lostCount int
+	if err := db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name LIKE 'lost_and_found%'").Scan(&lostCount); err != nil {
+		t.Fatal(err)
+	}
+	if lostCount != 0 {
+		t.Errorf("lost_and_found tables remain: %d", lostCount)
+	}
+
+	after, err := os.Stat(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("after: %d bytes", after.Size())
+
+	if after.Size() >= before.Size() {
+		t.Errorf("DB did not shrink: before=%d after=%d", before.Size(), after.Size())
+	}
+}
+
 func TestEnableAutoVacuum(t *testing.T) {
 	dbPath := filepath.Join(t.TempDir(), "test.db")
 	before := createBloatedDB(t, dbPath)
@@ -71,8 +158,8 @@ func TestEnableAutoVacuum(t *testing.T) {
 	if err := db.QueryRow("PRAGMA auto_vacuum").Scan(&mode); err != nil {
 		t.Fatal(err)
 	}
-	if mode != 2 {
-		t.Errorf("auto_vacuum = %d, want 2", mode)
+	if mode != sqliteAutoVacuumIncremental {
+		t.Errorf("auto_vacuum = %d, want %d", mode, sqliteAutoVacuumIncremental)
 	}
 
 	// Verify lost_and_found tables were dropped.