Fix deadlock with AutoShrink and Close, pass tests. Bump v1.8.1

Author: Jipok

Diff for: README.md

@@ -125,18 +125,52 @@ func main() {
 <details><summary>Using Multiple Typed Maps Together</summary>
 
 ```go
-store := persist.New()
-defer store.Close()
+package main
+
+import (
+    "log"
+    "time"
+    "github.com/Jipok/go-persist"
+)
+
+type User struct {
+    Name  string
+    Age   int
+}
+
+type Product struct {
+    Name  string
+    Price float64
+}
 
-users, _ := persist.Map[User](store, "users")
-products, _ := persist.Map[Product](store, "products")
-sessions, _ := persist.Map[Session](store, "sessions")
+type Session struct {
+    UserID     string
+    Expiration int64
+}
+
+func main() {
+    store := persist.New()
+    defer store.Close()
+
+    // Create typed maps for different entity types
+    users, _ := persist.Map[User](store, "users")
+    products, _ := persist.Map[Product](store, "products")
+    sessions, _ := persist.Map[Session](store, "sessions")
 
-store.Open("app.db")
+    // Create or load store file
+    err := store.Open("app.db")
+    if err != nil {
+        log.Fatal(err)
+    }
+
+    // Set up automatic compaction
+    store.StartAutoShrink(time.Minute, 1.8)
 
-users.Set("user1", User{Name: "Alice", Age: 30})
-products.Set("product42", Product{Name: "Gadget", Price: 49.99})
-sessions.SetAsync("sess12345", Session{UserID: "user1", Expire: 1718557123})
+    // Use each map independently
+    users.Set("u1", User{Name: "Admin", Age: 35})
+    products.Set("p1", Product{Name: "Widget", Price: 19.99})
+    sessions.SetAsync("sess123", Session{UserID: "u1", Expiration: 1718557123})
+}
 ```
 </details>
 

Diff for: benchmark-load/go.mod

@@ -5,7 +5,7 @@ go 1.24.1
 replace github.com/Jipok/go-persist => ../
 
 require (
-	github.com/Jipok/go-persist v1.7.0
+	github.com/Jipok/go-persist v1.8.0
 	github.com/goccy/go-json v0.10.5
 	github.com/tidwall/buntdb v1.3.2
 	go.etcd.io/bbolt v1.4.0

Diff for: benchmark/go.mod

@@ -3,7 +3,7 @@ module bench
 go 1.23.6
 
 require (
-	github.com/Jipok/go-persist v1.7.0
+	github.com/Jipok/go-persist v1.8.0
 	github.com/goccy/go-json v0.10.5
 	github.com/tidwall/buntdb v1.3.2
 	go.etcd.io/bbolt v1.4.0

Diff for: wal.go

@@ -25,7 +25,6 @@ const WalHeader = "go-persist 1"
 const DefaultSyncInterval = time.Second
 
 var (
-	// ErrKeyNotFound is returned when the key is not found in the storage
 	ErrKeyNotFound      = errors.New("key not found")
 	ErrNotLoaded        = errors.New("store is not loaded")
 	ErrShrinkInProgress = errors.New("shrink operation is already in progress")
@@ -198,6 +197,7 @@ func (s *Store) processRecords() error {
 	recordsChan := make(chan recordData, 100)
 
 	// Start a goroutine for reading the records concurrently
+	var outErr error
 	go func() {
 		defer close(recordsChan)
 		for {
@@ -206,7 +206,7 @@ func (s *Store) processRecords() error {
 				if err == io.EOF {
 					break
 				}
-				log.Println("go-persist: error reading record:", err)
+				outErr = errors.New("error reading record: " + err.Error())
 				break
 			}
 			s.totalWALRecords.Add(1)
@@ -226,7 +226,7 @@ func (s *Store) processRecords() error {
 			// Registered map found - process the record via its interface
 			pm, _ := mapVal.(persistMapI)
 			if err := pm.processRecord(rec.op, rec.fullKey[idx+1:], rec.valueStr); err != nil {
-				log.Println("go-persist: failed processing record for key", rec.fullKey, "error:", err)
+				return errors.New("go-persist: failed processing record for key `" + rec.fullKey + "`:" + err.Error())
 			}
 		} else {
 			// No matching map – save the raw record as a string in orphanRecords
@@ -239,6 +239,10 @@ func (s *Store) processRecords() error {
 		}
 	}
 
+	if outErr != nil {
+		return outErr
+	}
+
 	return nil
 }
 
@@ -254,7 +258,6 @@ func (s *Store) Close() error {
 	// Stop auto-shrink if enabled
 	if s.stopAutoShrink != nil {
 		close(s.stopAutoShrink)
-		s.stopAutoShrink = nil
 	}
 
 	// Signal background FSyncAll to stop and wait for it to finish
@@ -481,17 +484,22 @@ func (s *Store) Shrink() error {
 	defer s.wg.Done()
 	s.mu.Unlock()
 
+	stopShrinking := func() {
+		s.mu.Lock()
+		s.shrinking = false
+		s.mu.Unlock()
+	}
+
 	// Create temporary file for the compacted WAL
 	tmpPath := s.path + ".tmp"
 	tmpFile, err := os.Create(tmpPath)
 	if err != nil {
-		s.shrinking = false
 		return err
 	}
 
 	// Write the WAL header
 	if _, err := tmpFile.WriteString(WalHeader + "\n"); err != nil {
-		s.shrinking = false
+		stopShrinking()
 		return err
 	}
 
@@ -527,7 +535,7 @@ func (s *Store) Shrink() error {
 		return true
 	})
 	if outErr != nil {
-		s.shrinking = false
+		stopShrinking()
 		return outErr
 	}
 
@@ -544,13 +552,13 @@ func (s *Store) Shrink() error {
 		return true
 	})
 	if outErr != nil {
-		s.shrinking = false
+		stopShrinking()
 		return outErr
 	}
 
 	// Sync file to disk before obtaining lock to minimize lock duration
 	if err := tmpFile.Sync(); err != nil {
-		s.shrinking = false
+		stopShrinking()
 		return err
 	}
 
@@ -571,13 +579,13 @@ func (s *Store) Shrink() error {
 		// Write the locally copied pending records outside the lock
 		for _, rec := range localPending {
 			if _, err := tmpFile.WriteString(rec); err != nil {
-				s.shrinking = false
+				stopShrinking()
 				return err
 			}
 			recordCounter++
 		}
 		if err := tmpFile.Sync(); err != nil {
-			s.shrinking = false
+			stopShrinking()
 			return err
 		}
 	}

Diff for: wal_test.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"os"
 	"strconv"
+	"strings"
 	"sync"
 	"testing"
 )
@@ -365,27 +366,32 @@ func TestStore_InvalidRecordMidFile(t *testing.T) {
 	// Open the store
 	store := New()
 	err = store.Open(path)
-	if err != nil {
-		t.Fatalf("failed to open store: %v", err)
+	if !strings.Contains(err.Error(), "invalid record header format") {
+		t.Fatalf("expected: invalid record header format. Got:  %v", err)
 	}
 	defer store.Close()
 
-	// Attempt to retrieve key "first" which was written before the invalid record.
-	// Expect to get the value 100.
-	firstVal, err := Get[int](store, "first")
-	if err != nil {
-		t.Errorf("failed to get key 'first': %v", err)
-	}
-	if firstVal != 100 {
-		t.Errorf("expected key 'first' to have value 100, got %d", firstVal)
-	}
-
-	// Attempt to retrieve key "second" which was written after the invalid record.
-	// Since the invalid record stops further processing, key "second" should not be found.
-	secondVal, err := Get[int](store, "second")
-	if err == nil {
-		t.Errorf("expected error for key 'second' due to invalid record mid file, got value %d", secondVal)
-	} else if !errors.Is(err, ErrKeyNotFound) {
-		t.Errorf("expected ErrKeyNotFound for key 'second', got: %v", err)
-	}
+	_, err = Get[int](store, "first")
+	if !strings.Contains(err.Error(), "store is not loaded") {
+		t.Fatalf("expected: store is not loaded. Got:  %v", err)
+	}
+
+	// // Attempt to retrieve key "first" which was written before the invalid record.
+	// // Expect to get the value 100.
+	// firstVal, err := Get[int](store, "first")
+	// if err != nil {
+	// 	t.Errorf("failed to get key 'first': %v", err)
+	// }
+	// if firstVal != 100 {
+	// 	t.Errorf("expected key 'first' to have value 100, got %d", firstVal)
+	// }
+
+	// // Attempt to retrieve key "second" which was written after the invalid record.
+	// // Since the invalid record stops further processing, key "second" should not be found.
+	// secondVal, err := Get[int](store, "second")
+	// if err == nil {
+	// 	t.Errorf("expected error for key 'second' due to invalid record mid file, got value %d", secondVal)
+	// } else if !errors.Is(err, ErrKeyNotFound) {
+	// 	t.Errorf("expected ErrKeyNotFound for key 'second', got: %v", err)
+	// }
 }