FEAT: Inject timed cache in block processor

Author: mariusmihaic

cmd/proxy/main.go

@@ -512,13 +512,18 @@ func createVersionsRegistry(
 		return nil, err
 	}
 
-	closableComponents.Add(nodeGroupProc, valStatsProc, nodeStatusProc, bp)
+	timedCache, err := cache.NewTimeCacher(time.Second * 5)
+	if err != nil {
+		return nil, err
+	}
+
+	closableComponents.Add(nodeGroupProc, valStatsProc, nodeStatusProc, bp, timedCache)
 
 	nodeGroupProc.StartCacheUpdate()
 	valStatsProc.StartCacheUpdate()
 	nodeStatusProc.StartCacheUpdate()
 
-	blockProc, err := process.NewBlockProcessor(bp)
+	blockProc, err := process.NewBlockProcessor(bp, timedCache)
 	if err != nil {
 		return nil, err
 	}

data/interface.go

@@ -1,9 +1,5 @@
 package data
 
-func (h *HyperblockApiResponse) ID() string {
-	return h.Data.Hyperblock.Hash
-}
-
 func (h *HyperblockApiResponse) Hash() string {
 	return h.Data.Hyperblock.Hash
 }
@@ -12,10 +8,6 @@ func (h *HyperblockApiResponse) Nonce() uint64 {
 	return h.Data.Hyperblock.Nonce
 }
 
-func (h *BlockApiResponse) ID() string {
-	return h.Data.Block.Hash
-}
-
 func (h *BlockApiResponse) Hash() string {
 	return h.Data.Block.Hash
 }

facade/mock/TimedCacheStub.go facade/mock/timedCacheMock.gofacade/mock/TimedCacheStub.go renamed to facade/mock/timedCacheMock.go

@@ -21,3 +21,13 @@ func (mock *TimedCacheMock) Get(key []byte) (value interface{}, ok bool) {
 	val, found := mock.Cache[string(key)]
 	return val, found
 }
+
+// Close -
+func (mock *TimedCacheMock) Close() error {
+	return nil
+}
+
+// IsInterfaceNil -
+func (mock *TimedCacheMock) IsInterfaceNil() bool {
+	return mock == nil
+}

facade/mock/timedCacheStub.go

@@ -0,0 +1,25 @@
+package mock
+
+// TimedCacheStub -
+type TimedCacheStub struct {
+}
+
+// Put -
+func (stub *TimedCacheStub) Put(_ []byte, _ interface{}) error {
+	return nil
+}
+
+// Get -
+func (stub *TimedCacheStub) Get(_ []byte) (value interface{}, ok bool) {
+	return nil, false
+}
+
+// Close -
+func (stub *TimedCacheStub) Close() error {
+	return nil
+}
+
+// IsInterfaceNil -
+func (stub *TimedCacheStub) IsInterfaceNil() bool {
+	return stub == nil
+}

process/blockProcessor.go

@@ -9,7 +9,6 @@ import (
 	"github.com/multiversx/mx-chain-core-go/data/api"
 	"github.com/multiversx/mx-chain-proxy-go/common"
 	"github.com/multiversx/mx-chain-proxy-go/data"
-	"github.com/multiversx/mx-chain-proxy-go/facade/mock"
 )
 
 const (
@@ -48,13 +47,17 @@ type BlockProcessor struct {
 }
 
 // NewBlockProcessor will create a new block processor
-func NewBlockProcessor(proc Processor) (*BlockProcessor, error) {
+func NewBlockProcessor(proc Processor, cache TimedCache) (*BlockProcessor, error) {
 	if check.IfNil(proc) {
 		return nil, ErrNilCoreProcessor
 	}
+	if check.IfNil(cache) {
+		return nil, ErrNilTimedCache
+	}
+
 	return &BlockProcessor{
 		proc:  proc,
-		cache: mock.NewTimedCacheMock(),
+		cache: cache,
 	}, nil
 }
 

process/blockProcessorCache.go

@@ -6,29 +6,13 @@ import (
 )
 
 type cacheableBlock interface {
-	ID() string
 	Hash() string
 	Nonce() uint64
 }
 
-// No error checks or returns in for this cache.
+// No error checks for this cache.
 // These caching errors should never happen, and if they do, they should not be blocking
 
-func makeHashCacheKey(scope string, hash string, opts interface{}) []byte {
-	optBytes, _ := json.Marshal(opts)
-	return []byte(fmt.Sprintf("%s:hash:%s|opts:%s", scope, hash, string(optBytes)))
-}
-
-func makeNonceCacheKey(scope string, nonce uint64, opts interface{}) []byte {
-	optBytes, _ := json.Marshal(opts)
-	return []byte(fmt.Sprintf("%s:nonce:%d|opts:%s", scope, nonce, string(optBytes)))
-}
-
-func makeObjKey(scope string, hash string, opts interface{}) []byte {
-	optBytes, _ := json.Marshal(opts)
-	return []byte(scope + ":" + hash + "|" + string(optBytes))
-}
-
 func (bp *BlockProcessor) cacheObject(obj cacheableBlock, scope string, opts interface{}) {
 	objKey := makeObjKey(scope, obj.Hash(), opts)
 
@@ -40,6 +24,21 @@ func (bp *BlockProcessor) cacheObject(obj cacheableBlock, scope string, opts int
 	_ = bp.cache.Put(makeNonceCacheKey(scope, obj.Nonce(), opts), objKey)
 }
 
+func makeObjKey(scope string, hash string, opts interface{}) []byte {
+	optBytes, _ := json.Marshal(opts)
+	return []byte(scope + ":" + hash + "|" + string(optBytes))
+}
+
+func makeHashCacheKey(scope string, hash string, opts interface{}) []byte {
+	optBytes, _ := json.Marshal(opts)
+	return []byte(fmt.Sprintf("%s:hash:%s|opts:%s", scope, hash, string(optBytes)))
+}
+
+func makeNonceCacheKey(scope string, nonce uint64, opts interface{}) []byte {
+	optBytes, _ := json.Marshal(opts)
+	return []byte(fmt.Sprintf("%s:nonce:%d|opts:%s", scope, nonce, string(optBytes)))
+}
+
 func getObjectFromCacheWithHash[T cacheableBlock](c TimedCache, scope string, hash string, opts interface{}) T {
 	return getObjFromCache[T](c, makeHashCacheKey(scope, hash, opts))
 }

process/blockProcessorCache_test.go

@@ -24,7 +24,8 @@ func getObjectFromCache[T cacheableBlock](c TimedCache, scope string, hash strin
 func TestBlockProcessorCache(t *testing.T) {
 	t.Parallel()
 
-	bp, _ := NewBlockProcessor(&mock.ProcessorStub{})
+	mockCache := facadeMock.NewTimedCacheMock()
+	bp, _ := NewBlockProcessor(&mock.ProcessorStub{}, mockCache)
 
 	nonceBlock1 := uint64(1)
 	nonceBlock2 := uint64(2)
@@ -177,8 +178,6 @@ func TestBlockProcessorCache(t *testing.T) {
 
 	opts1Str, _ := json.Marshal(&opts1)
 	opts2Str, _ := json.Marshal(&opts2)
-
-	mockCache := bp.cache.(*facadeMock.TimedCacheMock)
 	require.Len(t, mockCache.Cache, 12)
 
 	expectedObjKeys := []string{