remove gob cache

Author: julienrbrt

apps/evm/cmd/rollback.go

@@ -80,9 +80,6 @@ func NewRollbackCmd() *cobra.Command {
 			}
 
 			cmd.Printf("Rolled back ev-node state to height %d\n", height)
-			if syncNode {
-				fmt.Println("Restart the node with the `--evnode.clear_cache` flag")
-			}
 
 			return nil
 		},

apps/testapp/cmd/rollback.go

@@ -75,9 +75,6 @@ func NewRollbackCmd() *cobra.Command {
 			}
 
 			fmt.Printf("Rolled back ev-node state to height %d\n", height)
-			if syncNode {
-				fmt.Println("Restart the node with the `--evnode.clear_cache` flag")
-			}
 
 			return nil
 		},

block/components.go

@@ -112,7 +112,7 @@ func (bc *Components) Stop() error {
 		}
 	}
 	if bc.Cache != nil {
-		if err := bc.Cache.SaveToDisk(); err != nil {
+		if err := bc.Cache.SaveToStore(); err != nil {
 			errs = errors.Join(errs, fmt.Errorf("failed to save caches: %w", err))
 		}
 	}

block/internal/cache/generic_cache.go

@@ -1,18 +1,16 @@
 package cache
 
 import (
-	"bufio"
-	"encoding/gob"
-	"errors"
+	"context"
+	"encoding/binary"
 	"fmt"
-	"os"
-	"path/filepath"
 	"sync"
 
 	"sync/atomic"
 
 	lru "github.com/hashicorp/golang-lru/v2"
-	"golang.org/x/sync/errgroup"
+
+	"github.com/evstack/ev-node/pkg/store"
 )
 
 const (
@@ -47,62 +45,33 @@ type Cache[T any] struct {
 
 	// maxDAHeight tracks the maximum DA height seen
 	maxDAHeight *atomic.Uint64
-}
-
-// CacheConfig holds configuration for cache sizes.
-type CacheConfig struct {
-	ItemsCacheSize      int
-	HashesCacheSize     int
-	DAIncludedCacheSize int
-}
 
-// DefaultCacheConfig returns the default cache configuration.
-func DefaultCacheConfig() CacheConfig {
-	return CacheConfig{
-		ItemsCacheSize:      DefaultItemsCacheSize,
-		HashesCacheSize:     DefaultHashesCacheSize,
-		DAIncludedCacheSize: DefaultDAIncludedCacheSize,
-	}
-}
+	// store is used for persisting DA inclusion data (optional, can be nil for ephemeral caches)
+	store store.Store
 
-// NewCache returns a new Cache struct with default sizes
-func NewCache[T any]() *Cache[T] {
-	cache, _ := NewCacheWithConfig[T](DefaultCacheConfig())
-	return cache
+	// storeKeyPrefix is the prefix used for store keys (allows different caches to use different namespaces)
+	storeKeyPrefix string
 }
 
-// NewCacheWithConfig returns a new Cache struct with custom sizes
-func NewCacheWithConfig[T any](config CacheConfig) (*Cache[T], error) {
-	itemsCache, err := lru.New[uint64, *T](config.ItemsCacheSize)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create items cache: %w", err)
-	}
-
-	hashesCache, err := lru.New[string, bool](config.HashesCacheSize)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create hashes cache: %w", err)
-	}
-
-	daIncludedCache, err := lru.New[string, uint64](config.DAIncludedCacheSize)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create daIncluded cache: %w", err)
-	}
-
+// NewCache returns a new Cache struct with default sizes.
+// If store and keyPrefix are provided, DA inclusion data will be persisted to the store for populating the cache on restarts.
+func NewCache[T any](s store.Store, keyPrefix string) *Cache[T] {
+	// LRU cache creation only fails if size <= 0, which won't happen with our defaults
+	itemsCache, _ := lru.New[uint64, *T](DefaultItemsCacheSize)
+	hashesCache, _ := lru.New[string, bool](DefaultHashesCacheSize)
+	daIncludedCache, _ := lru.New[string, uint64](DefaultDAIncludedCacheSize)
 	// hashByHeight must be at least as large as hashes cache to ensure proper pruning.
-	// If an entry is evicted from hashByHeight before hashes, the corresponding hash
-	// entry can no longer be pruned by height, causing a slow memory leak.
-	hashByHeightCache, err := lru.New[uint64, string](config.HashesCacheSize)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create hashByHeight cache: %w", err)
-	}
+	hashByHeightCache, _ := lru.New[uint64, string](DefaultHashesCacheSize)
 
 	return &Cache[T]{
-		itemsByHeight: itemsCache,
-		hashes:        hashesCache,
-		daIncluded:    daIncludedCache,
-		hashByHeight:  hashByHeightCache,
-		maxDAHeight:   &atomic.Uint64{},
-	}, nil
+		itemsByHeight:  itemsCache,
+		hashes:         hashesCache,
+		daIncluded:     daIncludedCache,
+		hashByHeight:   hashByHeightCache,
+		maxDAHeight:    &atomic.Uint64{},
+		store:          s,
+		storeKeyPrefix: keyPrefix,
+	}
 }
 
 // getItem returns an item from the cache by height.
@@ -158,11 +127,20 @@ func (c *Cache[T]) getDAIncluded(hash string) (uint64, bool) {
 	return daHeight, true
 }
 
-// setDAIncluded sets the hash as DA-included with the given DA height and tracks block height for pruning
+// setDAIncluded sets the hash as DA-included with the given DA height and tracks block height for pruning.
 func (c *Cache[T]) setDAIncluded(hash string, daHeight uint64, blockHeight uint64) {
 	c.daIncluded.Add(hash, daHeight)
 	c.hashByHeight.Add(blockHeight, hash)
 
+	// Persist to store if configured
+	if c.store != nil {
+		key := c.storeKeyPrefix + hash
+		value := make([]byte, 16) // 8 bytes for daHeight + 8 bytes for blockHeight
+		binary.LittleEndian.PutUint64(value[0:8], daHeight)
+		binary.LittleEndian.PutUint64(value[8:16], blockHeight)
+		_ = c.store.SetMetadata(context.Background(), key, value)
+	}
+
 	// Update max DA height if necessary
 	for range 1_000 {
 		current := c.maxDAHeight.Load()
@@ -208,156 +186,91 @@ func (c *Cache[T]) deleteAllForHeight(height uint64) {
 	}
 }
 
-const (
-	itemsByHeightFilename = "items_by_height.gob"
-	hashesFilename        = "hashes.gob"
-	daIncludedFilename    = "da_included.gob"
-)
-
-// saveMapGob saves a map to a file using gob encoding.
-func saveMapGob[K comparable, V any](filePath string, data map[K]V) (err error) {
-	file, err := os.Create(filePath)
-	if err != nil {
-		return fmt.Errorf("failed to create file %s: %w", filePath, err)
+// RestoreFromStore loads DA inclusion data from the store into the in-memory cache.
+// This should be called during initialization to restore persisted state.
+// It iterates through store metadata keys with the cache's prefix and populates the LRU cache.
+func (c *Cache[T]) RestoreFromStore(ctx context.Context, hashes []string) error {
+	if c.store == nil {
+		return nil // No store configured, nothing to restore
 	}
-	writer := bufio.NewWriter(file)
 
-	defer func() {
-		err = errors.Join(err, writer.Flush(), file.Sync(), file.Close())
-	}()
-	if err := gob.NewEncoder(writer).Encode(data); err != nil {
-		return fmt.Errorf("failed to encode to file %s: %w", filePath, err)
-	}
-	return nil
-}
+	for _, hash := range hashes {
+		key := c.storeKeyPrefix + hash
+		value, err := c.store.GetMetadata(ctx, key)
+		if err != nil {
+			// Key not found is not an error - the hash may not have been DA included yet
+			continue
+		}
+		if len(value) != 16 {
+			continue // Invalid data, skip
+		}
+
+		daHeight := binary.LittleEndian.Uint64(value[0:8])
+		blockHeight := binary.LittleEndian.Uint64(value[8:16])
 
-// loadMapGob loads a map from a file using gob encoding.
-// if the file does not exist, it returns an empty map and no error.
-func loadMapGob[K comparable, V any](filePath string) (map[K]V, error) {
-	m := make(map[K]V)
-	file, err := os.Open(filePath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return m, nil // return empty map if file not found
+		c.daIncluded.Add(hash, daHeight)
+		c.hashByHeight.Add(blockHeight, hash)
+
+		// Update max DA height
+		current := c.maxDAHeight.Load()
+		if daHeight > current {
+			c.maxDAHeight.Store(daHeight)
 		}
-		return nil, fmt.Errorf("failed to open file %s: %w", filePath, err)
 	}
-	defer file.Close()
 
-	decoder := gob.NewDecoder(file)
-	if err := decoder.Decode(&m); err != nil {
-		return nil, fmt.Errorf("failed to decode file %s: %w", filePath, err)
-	}
-	return m, nil
+	return nil
 }
 
-// SaveToDisk saves the cache contents to disk in the specified folder.
-// It's the caller's responsibility to ensure that type T (and any types it contains)
-// are registered with the gob package if necessary (e.g., using gob.Register).
-func (c *Cache[T]) SaveToDisk(folderPath string) error {
-	if err := os.MkdirAll(folderPath, 0o755); err != nil {
-		return fmt.Errorf("failed to create directory %s: %w", folderPath, err)
+// SaveToStore persists all current DA inclusion entries to the store.
+// This can be called before shutdown to ensure all data is persisted.
+func (c *Cache[T]) SaveToStore(ctx context.Context) error {
+	if c.store == nil {
+		return nil // No store configured
 	}
-	var wg errgroup.Group
-
-	// save items by height
-	wg.Go(func() error {
-		itemsByHeightMap := make(map[uint64]*T)
-		keys := c.itemsByHeight.Keys()
-		for _, k := range keys {
-			if v, ok := c.itemsByHeight.Peek(k); ok {
-				itemsByHeightMap[k] = v
-			}
-		}
 
-		if err := saveMapGob(filepath.Join(folderPath, itemsByHeightFilename), itemsByHeightMap); err != nil {
-			return fmt.Errorf("save %s: %w", itemsByHeightFilename, err)
-		}
-		return nil
-	})
-
-	// save hashes
-	wg.Go(func() error {
-		hashesToSave := make(map[string]bool)
-		keys := c.hashes.Keys()
-		for _, k := range keys {
-			if v, ok := c.hashes.Peek(k); ok {
-				hashesToSave[k] = v
-			}
+	keys := c.daIncluded.Keys()
+	for _, hash := range keys {
+		daHeight, ok := c.daIncluded.Peek(hash)
+		if !ok {
+			continue
 		}
 
-		if err := saveMapGob(filepath.Join(folderPath, hashesFilename), hashesToSave); err != nil {
-			return fmt.Errorf("save %s: %w", hashesFilename, err)
-		}
-		return nil
-	})
-
-	// save daIncluded
-	wg.Go(func() error {
-		daIncludedToSave := make(map[string]uint64)
-		keys := c.daIncluded.Keys()
-		for _, k := range keys {
-			if v, ok := c.daIncluded.Peek(k); ok {
-				daIncludedToSave[k] = v
+		// We need to find the block height for this hash
+		// Since we track hash by height, we need to iterate
+		var blockHeight uint64
+		heightKeys := c.hashByHeight.Keys()
+		for _, h := range heightKeys {
+			if storedHash, ok := c.hashByHeight.Peek(h); ok && storedHash == hash {
+				blockHeight = h
+				break
 			}
 		}
 
-		if err := saveMapGob(filepath.Join(folderPath, daIncludedFilename), daIncludedToSave); err != nil {
-			return fmt.Errorf("save %s: %w", daIncludedFilename, err)
+		key := c.storeKeyPrefix + hash
+		value := make([]byte, 16)
+		binary.LittleEndian.PutUint64(value[0:8], daHeight)
+		binary.LittleEndian.PutUint64(value[8:16], blockHeight)
+
+		if err := c.store.SetMetadata(ctx, key, value); err != nil {
+			return fmt.Errorf("failed to save DA inclusion for hash %s: %w", hash, err)
 		}
-		return nil
-	})
+	}
 
-	return wg.Wait()
+	return nil
 }
 
-// LoadFromDisk loads the cache contents from disk from the specified folder.
-// It populates the current cache instance. If files are missing, corresponding parts of the cache will be empty.
-// It's the caller's responsibility to ensure that type T (and any types it contains)
-// are registered with the gob package if necessary (e.g., using gob.Register).
-func (c *Cache[T]) LoadFromDisk(folderPath string) error {
-	var wg errgroup.Group
-
-	// load items by height
-	wg.Go(func() error {
-		itemsByHeightMap, err := loadMapGob[uint64, *T](filepath.Join(folderPath, itemsByHeightFilename))
-		if err != nil {
-			return fmt.Errorf("failed to load %s : %w", itemsByHeightFilename, err)
-		}
-		for k, v := range itemsByHeightMap {
-			c.itemsByHeight.Add(k, v)
-		}
-		return nil
-	})
-
-	// load hashes
-	wg.Go(func() error {
-		hashesMap, err := loadMapGob[string, bool](filepath.Join(folderPath, hashesFilename))
-		if err != nil {
-			return fmt.Errorf("failed to load %s : %w", hashesFilename, err)
-		}
-		for k, v := range hashesMap {
-			c.hashes.Add(k, v)
-		}
+// ClearFromStore removes all DA inclusion entries from the store for this cache.
+func (c *Cache[T]) ClearFromStore(ctx context.Context, hashes []string) error {
+	if c.store == nil {
 		return nil
-	})
+	}
 
-	// load daIncluded
-	wg.Go(func() error {
-		daIncludedMap, err := loadMapGob[string, uint64](filepath.Join(folderPath, daIncludedFilename))
-		if err != nil {
-			return fmt.Errorf("failed to load %s : %w", daIncludedFilename, err)
-		}
-		for k, v := range daIncludedMap {
-			c.daIncluded.Add(k, v)
-			// Update max DA height during load
-			current := c.maxDAHeight.Load()
-			if v > current {
-				c.maxDAHeight.Store(v)
-			}
+	for _, hash := range hashes {
+		key := c.storeKeyPrefix + hash
+		if err := c.store.DeleteMetadata(ctx, key); err != nil {
+			return fmt.Errorf("failed to delete DA inclusion for hash %s: %w", hash, err)
 		}
-		return nil
-	})
+	}
 
-	return wg.Wait()
+	return nil
 }