[Access] Upgrade lru cache

engine/access/rpc/backend/backend.go

@@ -2,12 +2,14 @@ package backend
 
 import (
 	"context"
+	"crypto/md5"
 	"fmt"
 	"net"
 	"strconv"
 	"time"
 
-	lru "github.com/hashicorp/golang-lru"
+	lru2 "github.com/hashicorp/golang-lru/v2"
+	accessproto "github.com/onflow/flow/protobuf/go/flow/access"
 	"github.com/rs/zerolog"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -22,8 +24,6 @@ import (
 	"github.com/onflow/flow-go/module"
 	"github.com/onflow/flow-go/state/protocol"
 	"github.com/onflow/flow-go/storage"
-
-	accessproto "github.com/onflow/flow/protobuf/go/flow/access"
 )
 
 // minExecutionNodesCnt is the minimum number of execution nodes expected to have sent the execution receipt for a block
@@ -119,7 +119,7 @@ func New(
 		retry.Activate()
 	}
 
-	loggedScripts, err := lru.New(DefaultLoggedScriptsCacheSize)
+	loggedScripts, err := lru2.New[[md5.Size]byte, time.Time](DefaultLoggedScriptsCacheSize)
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed to initialize script logging cache")
 	}
@@ -228,14 +228,13 @@ func NewCache(
 	log zerolog.Logger,
 	accessMetrics module.AccessMetrics,
 	connectionPoolSize uint,
-) (*lru.Cache, uint, error) {
+) (*lru2.Cache[string, *connection.CachedClient], uint, error) {
 
-	var cache *lru.Cache
+	var cache *lru2.Cache[string, *connection.CachedClient]
 	cacheSize := connectionPoolSize
 	if cacheSize > 0 {
 		var err error
-		cache, err = lru.NewWithEvict(int(cacheSize), func(_, evictedValue interface{}) {
-			store := evictedValue.(*connection.CachedClient)
+		cache, err = lru2.NewWithEvict[string, *connection.CachedClient](int(cacheSize), func(_ string, store *connection.CachedClient) {
 			store.Close()
 			log.Debug().Str("grpc_conn_evicted", store.Address).Msg("closing grpc connection evicted from pool")
 			if accessMetrics != nil {

engine/access/rpc/backend/backend_block_details.go

@@ -49,11 +49,11 @@ func (b *backendBlockDetails) GetLatestBlock(_ context.Context, isSealed bool) (
 		return nil, flow.BlockStatusUnknown, status.Errorf(codes.Internal, "could not get latest block: %v", err)
 	}
 
-	status, err := b.getBlockStatus(block)
+	stat, err := b.getBlockStatus(block)
 	if err != nil {
-		return nil, status, err
+		return nil, stat, err
 	}
-	return block, status, nil
+	return block, stat, nil
 }
 
 func (b *backendBlockDetails) GetBlockByID(_ context.Context, id flow.Identifier) (*flow.Block, flow.BlockStatus, error) {
@@ -62,11 +62,11 @@ func (b *backendBlockDetails) GetBlockByID(_ context.Context, id flow.Identifier
 		return nil, flow.BlockStatusUnknown, rpc.ConvertStorageError(err)
 	}
 
-	status, err := b.getBlockStatus(block)
+	stat, err := b.getBlockStatus(block)
 	if err != nil {
-		return nil, status, err
+		return nil, stat, err
 	}
-	return block, status, nil
+	return block, stat, nil
 }
 
 func (b *backendBlockDetails) GetBlockByHeight(_ context.Context, height uint64) (*flow.Block, flow.BlockStatus, error) {
@@ -75,11 +75,11 @@ func (b *backendBlockDetails) GetBlockByHeight(_ context.Context, height uint64)
 		return nil, flow.BlockStatusUnknown, rpc.ConvertStorageError(err)
 	}
 
-	status, err := b.getBlockStatus(block)
+	stat, err := b.getBlockStatus(block)
 	if err != nil {
-		return nil, status, err
+		return nil, stat, err
 	}
-	return block, status, nil
+	return block, stat, nil
 }
 
 func (b *backendBlockDetails) getBlockStatus(block *flow.Block) (flow.BlockStatus, error) {

engine/access/rpc/backend/backend_block_headers.go

@@ -42,11 +42,11 @@ func (b *backendBlockHeaders) GetLatestBlockHeader(_ context.Context, isSealed b
 		return nil, flow.BlockStatusUnknown, status.Errorf(codes.Internal, "could not get latest block header: %v", err)
 	}
 
-	status, err := b.getBlockStatus(header)
+	stat, err := b.getBlockStatus(header)
 	if err != nil {
-		return nil, status, err
+		return nil, stat, err
 	}
-	return header, status, nil
+	return header, stat, nil
 }
 
 func (b *backendBlockHeaders) GetBlockHeaderByID(_ context.Context, id flow.Identifier) (*flow.Header, flow.BlockStatus, error) {
@@ -55,11 +55,11 @@ func (b *backendBlockHeaders) GetBlockHeaderByID(_ context.Context, id flow.Iden
 		return nil, flow.BlockStatusUnknown, rpc.ConvertStorageError(err)
 	}
 
-	status, err := b.getBlockStatus(header)
+	stat, err := b.getBlockStatus(header)
 	if err != nil {
-		return nil, status, err
+		return nil, stat, err
 	}
-	return header, status, nil
+	return header, stat, nil
 }
 
 func (b *backendBlockHeaders) GetBlockHeaderByHeight(_ context.Context, height uint64) (*flow.Header, flow.BlockStatus, error) {
@@ -68,19 +68,19 @@ func (b *backendBlockHeaders) GetBlockHeaderByHeight(_ context.Context, height u
 		return nil, flow.BlockStatusUnknown, rpc.ConvertStorageError(err)
 	}
 
-	status, err := b.getBlockStatus(header)
+	stat, err := b.getBlockStatus(header)
 	if err != nil {
-		return nil, status, err
+		return nil, stat, err
 	}
-	return header, status, nil
+	return header, stat, nil
 }
 
 func (b *backendBlockHeaders) getBlockStatus(header *flow.Header) (flow.BlockStatus, error) {
 	sealed, err := b.state.Sealed().Head()
 	if err != nil {
 		// In the RPC engine, if we encounter an error from the protocol state indicating state corruption,
 		// we should halt processing requests, but do throw an exception which might cause a crash:
-		// - It is unsafe to process requests if we have an internally bad state.
+		// - It is unsafe to process requests if we have an internally bad State.
 		//   TODO: https://github.com/onflow/flow-go/issues/4028
 		// - We would like to avoid throwing an exception as a result of an Access API request by policy
 		//   because this can cause DOS potential

engine/access/rpc/backend/backend_network.go

@@ -4,12 +4,11 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/onflow/flow-go/cmd/build"
-
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 
 	"github.com/onflow/flow-go/access"
+	"github.com/onflow/flow-go/cmd/build"
 	"github.com/onflow/flow-go/engine/common/rpc/convert"
 	"github.com/onflow/flow-go/model/flow"
 	"github.com/onflow/flow-go/state/protocol"

engine/access/rpc/backend/backend_scripts.go

@@ -8,7 +8,7 @@ import (
 	"time"
 
 	"github.com/hashicorp/go-multierror"
-	lru "github.com/hashicorp/golang-lru"
+	lru "github.com/hashicorp/golang-lru/v2"
 	"github.com/onflow/flow/protobuf/go/flow/access"
 	execproto "github.com/onflow/flow/protobuf/go/flow/execution"
 	"github.com/rs/zerolog"
@@ -27,13 +27,14 @@ import (
 const uniqueScriptLoggingTimeWindow = 10 * time.Minute
 
 type backendScripts struct {
-	headers              storage.Headers
-	executionReceipts    storage.ExecutionReceipts
-	state                protocol.State
-	connFactory          connection.ConnectionFactory
-	log                  zerolog.Logger
-	metrics              module.BackendScriptsMetrics
-	loggedScripts        *lru.Cache
+	headers           storage.Headers
+	executionReceipts storage.ExecutionReceipts
+	state             protocol.State
+	connFactory       connection.ConnectionFactory
+	log               zerolog.Logger
+	metrics           module.BackendScriptsMetrics
+	loggedScripts     *lru.Cache[[md5.Size]byte, time.Time]
+
 	archiveAddressList   []string
 	archivePorts         []uint
 	scriptExecValidation bool
@@ -219,7 +220,7 @@ func (b *backendScripts) executeScriptOnAvailableArchiveNodes(
 						Msg("script failed to execute on the execution node")
 					return nil, err
 				case codes.NotFound:
-					// failures due to unavailable blocks are explicitly marked Not found
+					// failures due to unavailable blocks  are explicitly marked Not found
 					b.metrics.ScriptExecutionErrorOnArchiveNode()
 					b.log.Error().Err(err).Msg("script execution failed for archive node")
 					return nil, err
@@ -310,14 +311,11 @@ func (b *backendScripts) executeScriptOnAvailableExecutionNodes(
 
 // shouldLogScript checks if the script hash is unique in the time window
 func (b *backendScripts) shouldLogScript(execTime time.Time, scriptHash [16]byte) bool {
-	rawTimestamp, seen := b.loggedScripts.Get(scriptHash)
-	if !seen || rawTimestamp == nil {
+	timestamp, seen := b.loggedScripts.Get(scriptHash)
+	if !seen {
 		return true
-	} else {
-		// safe cast
-		timestamp := rawTimestamp.(time.Time)
-		return execTime.Sub(timestamp) >= uniqueScriptLoggingTimeWindow
 	}
+	return execTime.Sub(timestamp) >= uniqueScriptLoggingTimeWindow
 }
 
 func (b *backendScripts) tryExecuteScriptOnExecutionNode(

engine/access/rpc/connection/cache.go

@@ -4,7 +4,7 @@ import (
 	"sync"
 	"time"
 
-	lru "github.com/hashicorp/golang-lru"
+	lru "github.com/hashicorp/golang-lru/v2"
 	"go.uber.org/atomic"
 	"google.golang.org/grpc"
 )
@@ -38,12 +38,12 @@ func (s *CachedClient) Close() {
 
 // Cache represents a cache of CachedClient instances with a given maximum size.
 type Cache struct {
-	cache *lru.Cache
+	cache *lru.Cache[string, *CachedClient]
 	size  int
 }
 
 // NewCache creates a new Cache with the specified maximum size and the underlying LRU cache.
-func NewCache(cache *lru.Cache, size int) *Cache {
+func NewCache(cache *lru.Cache[string, *CachedClient], size int) *Cache {
 	return &Cache{
 		cache: cache,
 		size:  size,
@@ -57,7 +57,7 @@ func (c *Cache) Get(address string) (*CachedClient, bool) {
 	if !ok {
 		return nil, false
 	}
-	return val.(*CachedClient), true
+	return val, true
 }
 
 // GetOrAdd atomically gets the CachedClient for the given address from the cache, or adds a new one
@@ -71,7 +71,7 @@ func (c *Cache) GetOrAdd(address string, timeout time.Duration) (*CachedClient,
 
 	val, existed, _ := c.cache.PeekOrAdd(address, client)
 	if existed {
-		return val.(*CachedClient), true
+		return val, true
 	}
 
 	client.Address = address