Cache block results

cmd/proxy/config/config.toml

@@ -18,6 +18,9 @@
    # before it should be updated
    EconomicsMetricsCacheValidityDurationSec = 600 # 10 minutes
 
+   # BlockCacheDurationSec defines how long block/hyperblock results (queried by hash or nonce) are kept in cache, in seconds.
+   BlockCacheDurationSec = 30
+
    # BalancedObservers - if this flag is set to true, then the requests will be distributed equally between observers.
    # Otherwise, there are chances that only one observer from a shard will process the requests
    BalancedObservers = true

cmd/proxy/main.go

@@ -30,6 +30,7 @@ import (
 	processFactory "github.com/multiversx/mx-chain-proxy-go/process/factory"
 	"github.com/multiversx/mx-chain-proxy-go/testing"
 	versionsFactory "github.com/multiversx/mx-chain-proxy-go/versions/factory"
+	"github.com/multiversx/mx-chain-storage-go/timecache"
 	"github.com/urfave/cli"
 )
 
@@ -336,6 +337,7 @@ func createVersionsRegistryTestOrProduction(
 				HeartbeatCacheValidityDurationSec:        60,
 				ValStatsCacheValidityDurationSec:         60,
 				EconomicsMetricsCacheValidityDurationSec: 6,
+				BlockCacheDurationSec:                    30,
 				FaucetValue:                              "10000000000",
 			},
 			ApiLogging: config.ApiLoggingConfig{
@@ -512,13 +514,22 @@ func createVersionsRegistry(
 		return nil, err
 	}
 
-	closableComponents.Add(nodeGroupProc, valStatsProc, nodeStatusProc, bp)
+	cacheDuration := time.Duration(cfg.GeneralSettings.BlockCacheDurationSec) * time.Second
+	timedCache, err := timecache.NewTimeCacher(timecache.ArgTimeCacher{
+		DefaultSpan: cacheDuration,
+		CacheExpiry: cacheDuration,
+	})
+	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
 	}

config/config.go

@@ -11,6 +11,7 @@ type GeneralSettingsConfig struct {
 	HeartbeatCacheValidityDurationSec        int
 	ValStatsCacheValidityDurationSec         int
 	EconomicsMetricsCacheValidityDurationSec int
+	BlockCacheDurationSec                    int
 	FaucetValue                              string
 	RateLimitWindowDurationSeconds           int
 	BalancedObservers                        bool

data/block.go

@@ -12,6 +12,16 @@ type BlockApiResponse struct {
 	Code  ReturnCode              `json:"code"`
 }
 
+// Hash returns internal hash
+func (h *BlockApiResponse) Hash() string {
+	return h.Data.Block.Hash
+}
+
+// Nonce returns internal nonce
+func (h *BlockApiResponse) Nonce() uint64 {
+	return h.Data.Block.Nonce
+}
+
 // BlockApiResponsePayload wraps a block
 type BlockApiResponsePayload struct {
 	Block api.Block `json:"block"`
@@ -24,6 +34,16 @@ type HyperblockApiResponse struct {
 	Code  ReturnCode                   `json:"code"`
 }
 
+// Hash returns internal hash
+func (h *HyperblockApiResponse) Hash() string {
+	return h.Data.Hyperblock.Hash
+}
+
+// Nonce returns internal nonce
+func (h *HyperblockApiResponse) Nonce() uint64 {
+	return h.Data.Hyperblock.Nonce
+}
+
 // NewHyperblockApiResponse creates a HyperblockApiResponse
 func NewHyperblockApiResponse(hyperblock api.Hyperblock) *HyperblockApiResponse {
 	return &HyperblockApiResponse{

facade/mock/timedCacheMock.go

@@ -0,0 +1,33 @@
+package mock
+
+// TimedCacheMock -
+type TimedCacheMock struct {
+	Cache map[string]interface{}
+}
+
+// NewTimedCacheMock -
+func NewTimedCacheMock() *TimedCacheMock {
+	return &TimedCacheMock{Cache: make(map[string]interface{})}
+}
+
+// Put -
+func (mock *TimedCacheMock) Put(key []byte, value interface{}, _ int) bool {
+	mock.Cache[string(key)] = value
+	return false
+}
+
+// Get -
+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{}, _ int) bool {
+	return false
+}
+
+// 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
+}

go.mod

@@ -11,6 +11,7 @@ require (
 	github.com/multiversx/mx-chain-crypto-go v1.3.0
 	github.com/multiversx/mx-chain-es-indexer-go v1.8.0
 	github.com/multiversx/mx-chain-logger-go v1.1.0
+	github.com/multiversx/mx-chain-storage-go v1.1.0
 	github.com/pkg/errors v0.9.1
 	github.com/stretchr/testify v1.10.0
 	github.com/urfave/cli v1.22.16

go.sum

@@ -140,6 +140,8 @@ github.com/multiversx/mx-chain-es-indexer-go v1.8.0 h1:VLN9V3yNxchyGub25yOIUoa3K
 github.com/multiversx/mx-chain-es-indexer-go v1.8.0/go.mod h1:OLsBLRme3wL59qPRSJ2UG3xRU8QIR/JnbXHPEncR4dg=
 github.com/multiversx/mx-chain-logger-go v1.1.0 h1:97x84A6L4RfCa6YOx1HpAFxZp1cf/WI0Qh112whgZNM=
 github.com/multiversx/mx-chain-logger-go v1.1.0/go.mod h1:K9XgiohLwOsNACETMNL0LItJMREuEvTH6NsoXWXWg7g=
+github.com/multiversx/mx-chain-storage-go v1.1.0 h1:M1Y9DqMrJ62s7Zw31+cyuqsnPIvlG4jLBJl5WzeZLe8=
+github.com/multiversx/mx-chain-storage-go v1.1.0/go.mod h1:o6Jm7cjfPmcc6XpyihYWrd6sx3sgqwurrunw3ZrfyxI=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=

process/blockProcessor.go

@@ -35,24 +35,39 @@ const (
 	rawPathStr  = "raw"
 )
 
+const (
+	blockScope      = "block"
+	hyperBlockScope = "hyperblock"
+)
+
 // BlockProcessor handles blocks retrieving
 type BlockProcessor struct {
-	proc Processor
+	proc  Processor
+	cache TimedCache
 }
 
 // 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,
+		proc:  proc,
+		cache: cache,
 	}, nil
 }
 
 // GetBlockByHash will return the block based on its hash
 func (bp *BlockProcessor) GetBlockByHash(shardID uint32, hash string, options common.BlockQueryOptions) (*data.BlockApiResponse, error) {
+	scope := fmt.Sprintf("%s:shardID=%d", blockScope, shardID)
+	if cached := getObjectFromCacheWithHash[*data.BlockApiResponse](bp.cache, scope, hash, options); cached != nil {
+		return cached, nil
+	}
+
 	observers, err := bp.getObserversOrFullHistoryNodes(shardID)
 	if err != nil {
 		return nil, err
@@ -62,23 +77,28 @@ func (bp *BlockProcessor) GetBlockByHash(shardID uint32, hash string, options co
 
 	response := data.BlockApiResponse{}
 	for _, observer := range observers {
-
 		_, err := bp.proc.CallGetRestEndPoint(observer.Address, path, &response)
 		if err != nil {
 			log.Error("block request", "observer", observer.Address, "error", err.Error())
 			continue
 		}
 
 		log.Info("block request", "shard id", observer.ShardId, "hash", hash, "observer", observer.Address)
-		return &response, nil
 
+		bp.cacheObject(&response, scope, options)
+		return &response, nil
 	}
 
 	return nil, WrapObserversError(response.Error)
 }
 
 // GetBlockByNonce will return the block based on the nonce
 func (bp *BlockProcessor) GetBlockByNonce(shardID uint32, nonce uint64, options common.BlockQueryOptions) (*data.BlockApiResponse, error) {
+	scope := fmt.Sprintf("%s:shardID=%d", blockScope, shardID)
+	if cached := getObjectFromCacheWithNonce[*data.BlockApiResponse](bp.cache, scope, nonce, options); cached != nil {
+		return cached, nil
+	}
+
 	observers, err := bp.getObserversOrFullHistoryNodes(shardID)
 	if err != nil {
 		return nil, err
@@ -88,16 +108,15 @@ func (bp *BlockProcessor) GetBlockByNonce(shardID uint32, nonce uint64, options
 
 	response := data.BlockApiResponse{}
 	for _, observer := range observers {
-
 		_, err := bp.proc.CallGetRestEndPoint(observer.Address, path, &response)
 		if err != nil {
 			log.Error("block request", "observer", observer.Address, "error", err.Error())
 			continue
 		}
 
 		log.Info("block request", "shard id", observer.ShardId, "nonce", nonce, "observer", observer.Address)
+		bp.cacheObject(&response, scope, options)
 		return &response, nil
-
 	}
 
 	return nil, WrapObserversError(response.Error)
@@ -114,6 +133,10 @@ func (bp *BlockProcessor) getObserversOrFullHistoryNodes(shardID uint32) ([]*dat
 
 // GetHyperBlockByHash returns the hyperblock by hash
 func (bp *BlockProcessor) GetHyperBlockByHash(hash string, options common.HyperblockQueryOptions) (*data.HyperblockApiResponse, error) {
+	if cached := getObjectFromCacheWithHash[*data.HyperblockApiResponse](bp.cache, hyperBlockScope, hash, options); cached != nil {
+		return cached, nil
+	}
+
 	builder := &hyperblockBuilder{}
 
 	blockQueryOptions := common.BlockQueryOptions{
@@ -136,7 +159,10 @@ func (bp *BlockProcessor) GetHyperBlockByHash(hash string, options common.Hyperb
 	}
 
 	hyperblock := builder.build(options.NotarizedAtSource)
-	return data.NewHyperblockApiResponse(hyperblock), nil
+	hyperBlockRsp := data.NewHyperblockApiResponse(hyperblock)
+	bp.cacheObject(hyperBlockRsp, hyperBlockScope, options)
+
+	return hyperBlockRsp, nil
 }
 
 func (bp *BlockProcessor) addShardBlocks(
@@ -181,6 +207,10 @@ func (bp *BlockProcessor) getAlteredAccountsIfNeeded(options common.HyperblockQu
 
 // GetHyperBlockByNonce returns the hyperblock by nonce
 func (bp *BlockProcessor) GetHyperBlockByNonce(nonce uint64, options common.HyperblockQueryOptions) (*data.HyperblockApiResponse, error) {
+	if cached := getObjectFromCacheWithNonce[*data.HyperblockApiResponse](bp.cache, hyperBlockScope, nonce, options); cached != nil {
+		return cached, nil
+	}
+
 	builder := &hyperblockBuilder{}
 
 	blockQueryOptions := common.BlockQueryOptions{
@@ -203,7 +233,10 @@ func (bp *BlockProcessor) GetHyperBlockByNonce(nonce uint64, options common.Hype
 	}
 
 	hyperblock := builder.build(options.NotarizedAtSource)
-	return data.NewHyperblockApiResponse(hyperblock), nil
+	hyperBlockRsp := data.NewHyperblockApiResponse(hyperblock)
+	bp.cacheObject(hyperBlockRsp, hyperBlockScope, options)
+
+	return hyperBlockRsp, nil
 }
 
 // GetInternalBlockByHash will return the internal block based on its hash