FEAT: Use templates to store cachable blocks

Author: mariusmihaic

data/interface.go

@@ -0,0 +1,25 @@
+package data
+
+func (h *HyperblockApiResponse) ID() string {
+	return h.Data.Hyperblock.Hash
+}
+
+func (h *HyperblockApiResponse) Hash() string {
+	return h.Data.Hyperblock.Hash
+}
+
+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
+}
+
+func (h *BlockApiResponse) Nonce() uint64 {
+	return h.Data.Block.Nonce
+}

process/blockProcessor.go

@@ -55,6 +55,11 @@ func NewBlockProcessor(proc Processor) (*BlockProcessor, error) {
 
 // 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("block:shardID=%d", shardID)
+	if cached := getObjectFromCache[*data.BlockApiResponse](bp.cache, scope, hash, nil, options); cached != nil {
+		return *cached, nil
+	}
+
 	observers, err := bp.getObserversOrFullHistoryNodes(shardID)
 	if err != nil {
 		return nil, err
@@ -64,23 +69,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("block:shardID=%d", shardID)
+	if cached := getObjectFromCache[*data.BlockApiResponse](bp.cache, scope, "", &nonce, options); cached != nil {
+		return *cached, nil
+	}
+
 	observers, err := bp.getObserversOrFullHistoryNodes(shardID)
 	if err != nil {
 		return nil, err
@@ -90,16 +100,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)
@@ -116,8 +125,8 @@ 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 hyperBlock := bp.getHyperblockFromCache(hash, nil, options); hyperBlock != nil {
-		return hyperBlock, nil
+	if cached := getObjectFromCache[*data.HyperblockApiResponse](bp.cache, "hyperblock", hash, nil, options); cached != nil {
+		return *cached, nil
 	}
 
 	builder := &hyperblockBuilder{}
@@ -143,8 +152,7 @@ func (bp *BlockProcessor) GetHyperBlockByHash(hash string, options common.Hyperb
 
 	hyperblock := builder.build(options.NotarizedAtSource)
 	hyperBlockRsp := data.NewHyperblockApiResponse(hyperblock)
-
-	bp.cacheHyperblock(hyperBlockRsp, options)
+	bp.cacheObject(hyperBlockRsp, "hyperblock", options)
 
 	return hyperBlockRsp, nil
 }
@@ -191,6 +199,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 := getObjectFromCache[*data.HyperblockApiResponse](bp.cache, "hyperblock", "", &nonce, options); cached != nil {
+		return *cached, nil
+	}
+
 	builder := &hyperblockBuilder{}
 
 	blockQueryOptions := common.BlockQueryOptions{
@@ -213,7 +225,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, "hyperblock", options)
+
+	return hyperBlockRsp, nil
 }
 
 // GetInternalBlockByHash will return the internal block based on its hash

process/blockProcessorCache.go

@@ -3,53 +3,53 @@ package process
 import (
 	"encoding/json"
 	"fmt"
-
-	"github.com/multiversx/mx-chain-proxy-go/common"
-	"github.com/multiversx/mx-chain-proxy-go/data"
 )
 
-type hyperBlockCacheHandler interface {
-	cacheHyperblock(resp *data.HyperblockApiResponse, opts common.HyperblockQueryOptions)
-	getHyperblockFromCache(hash string, nonce *uint64, opts common.HyperblockQueryOptions) *data.HyperblockApiResponse
+type cacheableBlock interface {
+	ID() string
+	Hash() string
+	Nonce() uint64
 }
 
-func (bp *BlockProcessor) cacheHyperblock(resp *data.HyperblockApiResponse, opts common.HyperblockQueryOptions) {
-	hashKey := resp.Data.Hyperblock.Hash
-	optsStr, _ := json.Marshal(opts)
-	objKey := []byte(hashKey + string(optsStr))
+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(id string, opts interface{}) []byte {
+	optBytes, _ := json.Marshal(opts)
+	return []byte(id + string(optBytes))
+}
+
+func (bp *BlockProcessor) cacheObject(obj cacheableBlock, scope string, opts interface{}) {
+	objKey := makeObjKey(obj.ID(), opts)
 
 	// Store object
-	bp.cache.Put(objKey, resp, 0)
+	bp.cache.Put(objKey, obj, 0)
 
 	// Store nonce + hash lookup keys
-	bp.cache.Put(getHashCacheKey(resp.Data.Hyperblock.Hash, opts), objKey, 0)
-	bp.cache.Put(getNonceCacheKey(resp.Data.Hyperblock.Nonce, opts), objKey, 0)
+	bp.cache.Put(makeHashCacheKey(scope, obj.Hash(), opts), objKey, 0)
+	bp.cache.Put(makeNonceCacheKey(scope, obj.Nonce(), opts), objKey, 0)
 }
 
-func (bp *BlockProcessor) getHyperblockFromCache(hash string, nonce *uint64, opts common.HyperblockQueryOptions) *data.HyperblockApiResponse {
+func getObjectFromCache[T cacheableBlock](c TimedCache, scope string, hash string, nonce *uint64, opts interface{}) *T {
 	var key interface{}
 	if hash != "" {
-		key, _ = bp.cache.Get(getHashCacheKey(hash, opts))
+		key, _ = c.Get(makeHashCacheKey(scope, hash, opts))
 	} else if nonce != nil {
-		key, _ = bp.cache.Get(getNonceCacheKey(*nonce, opts))
+		key, _ = c.Get(makeNonceCacheKey(scope, *nonce, opts))
 	}
 
 	if key != nil {
-		val, ok := bp.cache.Get(key.([]byte))
+		val, ok := c.Get(key.([]byte))
 		if ok {
-			return val.(*data.HyperblockApiResponse)
+			return val.(*T)
 		}
 	}
-
 	return nil
 }
-
-func getHashCacheKey(hash string, opts common.HyperblockQueryOptions) []byte {
-	optBytes, _ := json.Marshal(opts)
-	return []byte(fmt.Sprintf("hash:%s|opts:%s", hash, string(optBytes)))
-}
-
-func getNonceCacheKey(nonce uint64, opts common.HyperblockQueryOptions) []byte {
-	optBytes, _ := json.Marshal(opts)
-	return []byte(fmt.Sprintf("nonce:%d|opts:%s", nonce, string(optBytes)))
-}