chore: refactor to use CacheOptions struct

Author: minhd-vu

cmd/p2p/sensor/sensor.go

@@ -69,12 +69,9 @@ type (
 		DiscoveryDNS                 string
 		Database                     string
 		NoDiscovery                  bool
-		MaxRequests                  int
-		RequestsCacheTTL             time.Duration
-		MaxParents                   int
-		ParentsCacheTTL              time.Duration
-		MaxBlocks                    int
-		BlocksCacheTTL               time.Duration
+		RequestsCache                p2p.CacheOptions
+		ParentsCache                 p2p.CacheOptions
+		BlocksCache                  p2p.CacheOptions
 
 		bootnodes    []*enode.Node
 		staticNodes  []*enode.Node
@@ -198,26 +195,23 @@ var SensorCmd = &cobra.Command{
 		// Create peer connection manager for broadcasting transactions
 		// and managing the global blocks cache
 		conns := p2p.NewConns(p2p.ConnsOptions{
-			MaxBlocks:      inputSensorParams.MaxBlocks,
-			BlocksCacheTTL: inputSensorParams.BlocksCacheTTL,
+			BlocksCache: inputSensorParams.BlocksCache,
 		})
 
 		opts := p2p.EthProtocolOptions{
-			Context:          cmd.Context(),
-			Database:         db,
-			GenesisHash:      common.HexToHash(inputSensorParams.GenesisHash),
-			RPC:              inputSensorParams.RPC,
-			SensorID:         inputSensorParams.SensorID,
-			NetworkID:        inputSensorParams.NetworkID,
-			Conns:            conns,
-			Head:             &head,
-			HeadMutex:        &sync.RWMutex{},
-			ForkID:           forkid.ID{Hash: [4]byte(inputSensorParams.ForkID)},
-			MsgCounter:       msgCounter,
-			MaxRequests:      inputSensorParams.MaxRequests,
-			RequestsCacheTTL: inputSensorParams.RequestsCacheTTL,
-			MaxParents:       inputSensorParams.MaxParents,
-			ParentsCacheTTL:  inputSensorParams.ParentsCacheTTL,
+			Context:       cmd.Context(),
+			Database:      db,
+			GenesisHash:   common.HexToHash(inputSensorParams.GenesisHash),
+			RPC:           inputSensorParams.RPC,
+			SensorID:      inputSensorParams.SensorID,
+			NetworkID:     inputSensorParams.NetworkID,
+			Conns:         conns,
+			Head:          &head,
+			HeadMutex:     &sync.RWMutex{},
+			ForkID:        forkid.ID{Hash: [4]byte(inputSensorParams.ForkID)},
+			MsgCounter:    msgCounter,
+			RequestsCache: inputSensorParams.RequestsCache,
+			ParentsCache:  inputSensorParams.ParentsCache,
 		}
 
 		config := ethp2p.Config{
@@ -490,10 +484,10 @@ will result in less chance of missing data but can significantly increase memory
   - json (output to stdout)
   - none (no persistence)`)
 	f.BoolVar(&inputSensorParams.NoDiscovery, "no-discovery", false, "disable P2P peer discovery")
-	f.IntVar(&inputSensorParams.MaxRequests, "max-requests", 2048, "maximum request IDs to track per peer (0 for no limit)")
-	f.DurationVar(&inputSensorParams.RequestsCacheTTL, "requests-cache-ttl", 5*time.Minute, "time to live for requests cache entries (0 for no expiration)")
-	f.IntVar(&inputSensorParams.MaxParents, "max-parents", 1024, "maximum parent block hashes to track per peer (0 for no limit)")
-	f.DurationVar(&inputSensorParams.ParentsCacheTTL, "parents-cache-ttl", 5*time.Minute, "time to live for parent hash cache entries (0 for no expiration)")
-	f.IntVar(&inputSensorParams.MaxBlocks, "max-blocks", 1024, "maximum blocks to track across all peers (0 for no limit)")
-	f.DurationVar(&inputSensorParams.BlocksCacheTTL, "blocks-cache-ttl", 10*time.Minute, "time to live for block cache entries (0 for no expiration)")
+	f.IntVar(&inputSensorParams.RequestsCache.MaxSize, "max-requests", 2048, "maximum request IDs to track per peer (0 for no limit)")
+	f.DurationVar(&inputSensorParams.RequestsCache.TTL, "requests-cache-ttl", 5*time.Minute, "time to live for requests cache entries (0 for no expiration)")
+	f.IntVar(&inputSensorParams.ParentsCache.MaxSize, "max-parents", 1024, "maximum parent block hashes to track per peer (0 for no limit)")
+	f.DurationVar(&inputSensorParams.ParentsCache.TTL, "parents-cache-ttl", 5*time.Minute, "time to live for parent hash cache entries (0 for no expiration)")
+	f.IntVar(&inputSensorParams.BlocksCache.MaxSize, "max-blocks", 1024, "maximum blocks to track across all peers (0 for no limit)")
+	f.DurationVar(&inputSensorParams.BlocksCache.TTL, "blocks-cache-ttl", 10*time.Minute, "time to live for block cache entries (0 for no expiration)")
 }

p2p/cache.go

@@ -6,6 +6,12 @@ import (
 	"time"
 )
 
+// CacheOptions contains configuration for LRU caches with TTL.
+type CacheOptions struct {
+	MaxSize int
+	TTL     time.Duration
+}
+
 // Cache is a thread-safe LRU cache with optional TTL-based expiration.
 type Cache[K comparable, V any] struct {
 	mu      sync.RWMutex
@@ -21,13 +27,13 @@ type entry[K comparable, V any] struct {
 	expiresAt time.Time
 }
 
-// NewCache creates a new cache with the given max size and optional TTL.
-// If maxSize <= 0, the cache has no size limit.
-// If ttl is 0, entries never expire based on time.
-func NewCache[K comparable, V any](maxSize int, ttl time.Duration) *Cache[K, V] {
+// NewCache creates a new cache with the given options.
+// If opts.MaxSize <= 0, the cache has no size limit.
+// If opts.TTL is 0, entries never expire based on time.
+func NewCache[K comparable, V any](opts CacheOptions) *Cache[K, V] {
 	return &Cache[K, V]{
-		maxSize: maxSize,
-		ttl:     ttl,
+		maxSize: opts.MaxSize,
+		ttl:     opts.TTL,
 		items:   make(map[K]*list.Element),
 		list:    list.New(),
 	}

p2p/conns.go

@@ -24,17 +24,14 @@ type Conns struct {
 
 // ConnsOptions contains configuration options for creating a new Conns manager.
 type ConnsOptions struct {
-	// MaxBlocks is the maximum number of blocks to track in the cache.
-	MaxBlocks int
-	// BlocksCacheTTL is the time to live for block cache entries.
-	BlocksCacheTTL time.Duration
+	BlocksCache CacheOptions
 }
 
 // NewConns creates a new connection manager with a blocks cache.
 func NewConns(opts ConnsOptions) *Conns {
 	return &Conns{
 		conns:  make(map[string]*conn),
-		blocks: NewCache[common.Hash, BlockCache](opts.MaxBlocks, opts.BlocksCacheTTL),
+		blocks: NewCache[common.Hash, BlockCache](opts.BlocksCache),
 	}
 }
 

p2p/protocol.go

@@ -84,13 +84,9 @@ type EthProtocolOptions struct {
 	Head      *HeadBlock
 	HeadMutex *sync.RWMutex
 
-	// Requests cache configuration
-	MaxRequests      int
-	RequestsCacheTTL time.Duration
-
-	// Parent hash tracking cache configuration
-	MaxParents      int
-	ParentsCacheTTL time.Duration
+	// Cache configurations
+	RequestsCache CacheOptions
+	ParentsCache  CacheOptions
 }
 
 // HeadBlock contains the necessary head block data for the status message.
@@ -116,9 +112,9 @@ func NewEthProtocol(version uint, opts EthProtocolOptions) ethp2p.Protocol {
 				logger:       log.With().Str("peer", peerURL).Logger(),
 				rw:           rw,
 				db:           opts.Database,
-				requests:     NewCache[uint64, common.Hash](opts.MaxRequests, opts.RequestsCacheTTL),
+				requests:     NewCache[uint64, common.Hash](opts.RequestsCache),
 				requestNum:   0,
-				parents:      NewCache[common.Hash, struct{}](opts.MaxParents, opts.ParentsCacheTTL),
+				parents:      NewCache[common.Hash, struct{}](opts.ParentsCache),
 				head:         opts.Head,
 				headMutex:    opts.HeadMutex,
 				counter:      opts.MsgCounter,