Test Restart Checkpoint timeouts

db/db.go

@@ -163,6 +163,11 @@ func Open(dbPath string, fkEnabled, wal bool) (retDB *DB, retErr error) {
 		return nil, fmt.Errorf("disable autocheckpointing: %s", err.Error())
 	}
 
+	// Unset any busy_timeout
+	if _, err := rwDB.Exec("PRAGMA busy_timeout=0"); err != nil {
+		return nil, fmt.Errorf("disable busy_timeout: %s", err.Error())
+	}
+
 	roDSN := MakeDSN(dbPath, ModeReadOnly, fkEnabled, wal)
 	roDB, err := sql.Open("sqlite3", roDSN)
 	if err != nil {
@@ -369,15 +374,17 @@ func (db *DB) CheckpointWithTimeout(mode CheckpointMode, dur time.Duration) (err
 		return err
 	}
 
-	t := time.NewTicker(checkpointRetryDelay)
-	defer t.Stop()
+	ticker := time.NewTicker(checkpointRetryDelay)
+	timer := time.NewTimer(dur)
+	defer ticker.Stop()
+	defer timer.Stop()
 	for {
 		select {
-		case <-t.C:
+		case <-ticker.C:
 			if err := f(); err == nil {
 				return nil
 			}
-		case <-time.After(dur):
+		case <-timer.C:
 			return ErrCheckpointTimeout
 		}
 	}

db/db_checkpoint_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"os"
 	"testing"
+	"time"
 )
 
 // Test_WALDatabaseCheckpointOKNoWAL tests that a checkpoint succeeds
@@ -56,14 +57,15 @@ func Test_WALDatabaseCheckpoint_RestartTruncate(t *testing.T) {
 	defer os.Remove(path)
 	db, err := Open(path, false, true)
 	if err != nil {
-		t.Fatalf("failed to open database in DELETE mode: %s", err.Error())
+		t.Fatalf("failed to open database in WAL mode: %s", err.Error())
 	}
+	defer db.Close()
 
 	_, err = db.ExecuteStringStmt(`CREATE TABLE foo (id INTEGER NOT NULL PRIMARY KEY, name TEXT)`)
 	if err != nil {
 		t.Fatalf("failed to execute on single node: %s", err.Error())
 	}
-	for i := 0; i < 100; i++ {
+	for i := 0; i < 50; i++ {
 		_, err := db.ExecuteStringStmt(`INSERT INTO foo(name) VALUES("fiona")`)
 		if err != nil {
 			t.Fatalf("failed to execute INSERT on single node: %s", err.Error())
@@ -75,7 +77,7 @@ func Test_WALDatabaseCheckpoint_RestartTruncate(t *testing.T) {
 		t.Fatalf("failed to read wal file: %s", err.Error())
 	}
 	if err := db.Checkpoint(CheckpointRestart); err != nil {
-		t.Fatalf("failed to checkpoint database in DELETE mode: %s", err.Error())
+		t.Fatalf("failed to checkpoint database: %s", err.Error())
 	}
 	walPostBytes, err := os.ReadFile(db.WALPath())
 	if err != nil {
@@ -90,12 +92,12 @@ func Test_WALDatabaseCheckpoint_RestartTruncate(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to execute query on single node: %s", err.Error())
 	}
-	if exp, got := `[{"columns":["COUNT(*)"],"types":["integer"],"values":[[100]]}]`, asJSON(rows); exp != got {
+	if exp, got := `[{"columns":["COUNT(*)"],"types":["integer"],"values":[[50]]}]`, asJSON(rows); exp != got {
 		t.Fatalf("expected %s, got %s", exp, got)
 	}
 
 	if err := db.Checkpoint(CheckpointTruncate); err != nil {
-		t.Fatalf("failed to checkpoint database in DELETE mode: %s", err.Error())
+		t.Fatalf("failed to checkpoint database: %s", err.Error())
 	}
 	sz, err := fileSize(db.WALPath())
 	if err != nil {
@@ -110,8 +112,54 @@ func Test_WALDatabaseCheckpoint_RestartTruncate(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to execute query on single node: %s", err.Error())
 	}
-	if exp, got := `[{"columns":["COUNT(*)"],"types":["integer"],"values":[[100]]}]`, asJSON(rows); exp != got {
+	if exp, got := `[{"columns":["COUNT(*)"],"types":["integer"],"values":[[50]]}]`, asJSON(rows); exp != got {
+		t.Fatalf("expected %s, got %s", exp, got)
+	}
+}
+
+func Test_WALDatabaseCheckpoint_RestartTimeout(t *testing.T) {
+	path := mustTempFile()
+	defer os.Remove(path)
+	db, err := Open(path, false, true)
+	if err != nil {
+		t.Fatalf("failed to open database in WAL mode: %s", err.Error())
+	}
+	defer db.Close()
+
+	_, err = db.ExecuteStringStmt(`CREATE TABLE foo (id INTEGER NOT NULL PRIMARY KEY, name TEXT)`)
+	if err != nil {
+		t.Fatalf("failed to execute on single node: %s", err.Error())
+	}
+	for i := 0; i < 50; i++ {
+		_, err := db.ExecuteStringStmt(`INSERT INTO foo(name) VALUES("fiona")`)
+		if err != nil {
+			t.Fatalf("failed to execute INSERT on single node: %s", err.Error())
+		}
+	}
+
+	blockingDB, err := Open(path, false, true)
+	if err != nil {
+		t.Fatalf("failed to open blocking database in WAL mode: %s", err.Error())
+	}
+	defer blockingDB.Close()
+	_, err = blockingDB.QueryStringStmt(`BEGIN TRANSACTION`)
+	if err != nil {
+		t.Fatalf("failed to execute query on single node: %s", err.Error())
+	}
+	rows, err := blockingDB.QueryStringStmt(`SELECT COUNT(*) FROM foo`)
+	if err != nil {
+		t.Fatalf("failed to execute query on single node: %s", err.Error())
+	}
+	if exp, got := `[{"columns":["COUNT(*)"],"types":["integer"],"values":[[50]]}]`, asJSON(rows); exp != got {
 		t.Fatalf("expected %s, got %s", exp, got)
 	}
 
+	if err := db.CheckpointWithTimeout(CheckpointTruncate, 250*time.Millisecond); err != ErrCheckpointTimeout {
+		t.Fatal("expected timeout error")
+	}
+
+	blockingDB.Close()
+	if err := db.CheckpointWithTimeout(CheckpointTruncate, 250*time.Millisecond); err != nil {
+		t.Fatalf("failed to checkpoint database: %s", err.Error())
+	}
 }