fix return type to use blocker (#742)

* fix return type to use blocker

* add more blocker type

Author: capt4ce

common/blocker/blocker.go

@@ -16,6 +16,8 @@ type (
 )
 
 var (
+	ServiceErr                TypeBlocker = "ServiceErr"
+	InternalErr               TypeBlocker = "InternalErr"
 	DBErr                     TypeBlocker = "DBErr"
 	DBRowNotFound             TypeBlocker = "DBRowNotFound"
 	BlockErr                  TypeBlocker = "BlockErr"

p2p/service/p2pServerService.go

@@ -3,6 +3,7 @@ package service
 import (
 	"context"
 
+	"github.com/zoobc/zoobc-core/common/blocker"
 	"github.com/zoobc/zoobc-core/common/chaintype"
 	"github.com/zoobc/zoobc-core/common/constant"
 	"github.com/zoobc/zoobc-core/common/model"
@@ -11,9 +12,7 @@ import (
 	"github.com/zoobc/zoobc-core/observer"
 	"github.com/zoobc/zoobc-core/p2p/strategy"
 	p2pUtil "github.com/zoobc/zoobc-core/p2p/util"
-	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
-	"google.golang.org/grpc/status"
 )
 
 type (
@@ -110,7 +109,7 @@ func (ps *P2PServerService) GetPeerInfo(ctx context.Context, req *model.GetPeerI
 			HostInfo: ps.PeerExplorer.GetHostInfo(),
 		}, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 // GetMorePeers contains info other peers
@@ -123,7 +122,7 @@ func (ps *P2PServerService) GetMorePeers(ctx context.Context, req *model.Empty)
 		}
 		return nodes, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 // SendPeers receives set of peers info from other node and put them into the unresolved peers
@@ -135,11 +134,11 @@ func (ps *P2PServerService) SendPeers(
 		// TODO: only accept nodes that are already registered in the node registration
 		err := ps.PeerExplorer.AddToUnresolvedPeers(peers, true)
 		if err != nil {
-			return nil, status.Error(codes.Internal, err.Error())
+			return nil, blocker.NewBlocker(blocker.InternalErr, err.Error())
 		}
 		return &model.Empty{}, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 // GetCumulativeDifficulty responds to the request of the cumulative difficulty status of a node
@@ -150,21 +149,21 @@ func (ps *P2PServerService) GetCumulativeDifficulty(
 	if ps.PeerExplorer.ValidateRequest(ctx) {
 		blockService := ps.BlockServices[chainType.GetTypeInt()]
 		if blockService == nil {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"blockServiceNotFoundByThisChainType",
 			)
 		}
 		lastBlock, err := blockService.GetLastBlock()
 		if err != nil {
-			return nil, status.Error(codes.Internal, err.Error())
+			return nil, blocker.NewBlocker(blocker.InternalErr, err.Error())
 		}
 		return &model.GetCumulativeDifficultyResponse{
 			CumulativeDifficulty: lastBlock.CumulativeDifficulty,
 			Height:               lastBlock.Height,
 		}, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 func (ps P2PServerService) GetCommonMilestoneBlockIDs(
@@ -182,17 +181,17 @@ func (ps P2PServerService) GetCommonMilestoneBlockIDs(
 			blockService = ps.BlockServices[chainType.GetTypeInt()]
 		)
 		if blockService == nil {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"blockServiceNotFoundByThisChainType",
 			)
 		}
 		if lastBlockID == 0 && lastMilestoneBlockID == 0 {
-			return nil, status.Error(codes.InvalidArgument, "either LastBlockID or LastMilestoneBlockID has to be supplied")
+			return nil, blocker.NewBlocker(blocker.ValidationErr, "either LastBlockID or LastMilestoneBlockID has to be supplied")
 		}
 		myLastBlock, err := blockService.GetLastBlock()
 		if err != nil || myLastBlock == nil {
-			return nil, status.Error(codes.Internal, "failedGetLastBlock")
+			return nil, blocker.NewBlocker(blocker.InternalErr, "failedGetLastBlock")
 		}
 		myLastBlockID := myLastBlock.ID
 		myBlockchainHeight := myLastBlock.Height
@@ -213,7 +212,7 @@ func (ps P2PServerService) GetCommonMilestoneBlockIDs(
 			lastMilestoneBlock, err := blockService.GetBlockByID(lastMilestoneBlockID, false)
 			// this error is handled because when lastMilestoneBlockID is provided, it was expected to be the one returned from this node
 			if err != nil {
-				return nil, status.Error(codes.Internal, err.Error())
+				return nil, blocker.NewBlocker(blocker.InternalErr, err.Error())
 			}
 			height = lastMilestoneBlock.GetHeight()
 			jump = util.MinUint32(constant.SafeBlockGap, util.MaxUint32(myBlockchainHeight, 1))
@@ -227,7 +226,7 @@ func (ps P2PServerService) GetCommonMilestoneBlockIDs(
 		for ; limit > 0; limit-- {
 			block, err := blockService.GetBlockByHeight(height)
 			if err != nil {
-				return nil, status.Error(codes.Internal, err.Error())
+				return nil, blocker.NewBlocker(blocker.InternalErr, err.Error())
 			}
 			blockIds = append(blockIds, block.ID)
 			switch {
@@ -242,7 +241,7 @@ func (ps P2PServerService) GetCommonMilestoneBlockIDs(
 
 		return &model.GetCommonMilestoneBlockIdsResponse{BlockIds: blockIds}, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 func (ps *P2PServerService) GetNextBlockIDs(
@@ -257,8 +256,8 @@ func (ps *P2PServerService) GetNextBlockIDs(
 			blockService = ps.BlockServices[chainType.GetTypeInt()]
 		)
 		if blockService == nil {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"blockServiceNotFoundByThisChainType",
 			)
 		}
@@ -269,19 +268,19 @@ func (ps *P2PServerService) GetNextBlockIDs(
 
 		foundBlock, err := blockService.GetBlockByID(reqBlockID, false)
 		if err != nil {
-			return nil, status.Error(codes.Internal, err.Error())
+			return nil, blocker.NewBlocker(blocker.InternalErr, err.Error())
 		}
 		blocks, err := blockService.GetBlocksFromHeight(foundBlock.Height, limit, false)
 		if err != nil {
-			return nil, status.Error(codes.Internal, "failedGetBlocks")
+			return nil, blocker.NewBlocker(blocker.InternalErr, "failedGetBlocks")
 		}
 		for _, block := range blocks {
 			blockIds = append(blockIds, block.ID)
 		}
 
 		return blockIds, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 func (ps *P2PServerService) GetNextBlocks(
@@ -297,20 +296,20 @@ func (ps *P2PServerService) GetNextBlocks(
 			blockService  = ps.BlockServices[chainType.GetTypeInt()]
 		)
 		if blockService == nil {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"blockServiceNotFoundByThisChainType",
 			)
 		}
 		blockService.ChainWriteLock(constant.BlockchainSendingBlocks)
 		defer blockService.ChainWriteUnlock(constant.BlockchainSendingBlocks)
 		block, err := blockService.GetBlockByID(blockID, false)
 		if err != nil {
-			return nil, status.Error(codes.InvalidArgument, err.Error())
+			return nil, blocker.NewBlocker(blocker.ValidationErr, err.Error())
 		}
 		blocks, err := blockService.GetBlocksFromHeight(block.Height, uint32(len(blockIDList)), true)
 		if err != nil {
-			return nil, status.Error(codes.InvalidArgument, err.Error())
+			return nil, blocker.NewBlocker(blocker.ValidationErr, err.Error())
 		}
 
 		for idx, block := range blocks {
@@ -319,13 +318,13 @@ func (ps *P2PServerService) GetNextBlocks(
 			}
 			err = blockService.PopulateBlockData(block)
 			if err != nil {
-				return nil, status.Error(codes.Internal, err.Error())
+				return nil, blocker.NewBlocker(blocker.InternalErr, err.Error())
 			}
 			blocksMessage = append(blocksMessage, block)
 		}
 		return &model.BlocksData{NextBlocks: blocksMessage}, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 // SendBlock receive block from other node
@@ -338,8 +337,8 @@ func (ps *P2PServerService) SendBlock(
 	if ps.PeerExplorer.ValidateRequest(ctx) {
 		var md, _ = metadata.FromIncomingContext(ctx)
 		if len(md) == 0 {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"InvalidContext",
 			)
 		}
@@ -348,19 +347,19 @@ func (ps *P2PServerService) SendBlock(
 			peer, err   = p2pUtil.ParsePeer(fullAddress)
 		)
 		if err != nil {
-			return nil, status.Error(codes.InvalidArgument, "invalidPeer")
+			return nil, blocker.NewBlocker(blocker.ValidationErr, "invalidPeer")
 		}
 		blockService := ps.BlockServices[chainType.GetTypeInt()]
 		if blockService == nil {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"blockServiceNotFoundByThisChainType",
 			)
 		}
 		lastBlock, err := blockService.GetLastBlock()
 		if err != nil {
-			return nil, status.Error(
-				codes.Internal,
+			return nil, blocker.NewBlocker(
+				blocker.InternalErr,
 				"failGetLastBlock",
 			)
 		}
@@ -378,7 +377,7 @@ func (ps *P2PServerService) SendBlock(
 			BatchReceipt: batchReceipt,
 		}, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 // SendTransaction receive transaction from other node and calling TransactionReceived Event
@@ -391,22 +390,22 @@ func (ps *P2PServerService) SendTransaction(
 	if ps.PeerExplorer.ValidateRequest(ctx) {
 		var blockService = ps.BlockServices[chainType.GetTypeInt()]
 		if blockService == nil {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"blockServiceNotFoundByThisChainType",
 			)
 		}
 		lastBlock, err := blockService.GetLastBlock()
 		if err != nil {
-			return nil, status.Error(
-				codes.Internal,
+			return nil, blocker.NewBlocker(
+				blocker.InternalErr,
 				"failGetLastBlock",
 			)
 		}
 		var mempoolService = ps.MempoolServices[chainType.GetTypeInt()]
 		if mempoolService == nil {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"mempoolServiceNotFoundByThisChainType",
 			)
 		}
@@ -423,7 +422,7 @@ func (ps *P2PServerService) SendTransaction(
 			BatchReceipt: batchReceipt,
 		}, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 // SendBlockTransactions receive a list of transaction from other node and calling TransactionReceived Event
@@ -436,22 +435,22 @@ func (ps *P2PServerService) SendBlockTransactions(
 	if ps.PeerExplorer.ValidateRequest(ctx) {
 		var blockService = ps.BlockServices[chainType.GetTypeInt()]
 		if blockService == nil {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"blockServiceNotFoundByThisChainType",
 			)
 		}
 		lastBlock, err := blockService.GetLastBlock()
 		if err != nil {
-			return nil, status.Error(
-				codes.Internal,
+			return nil, blocker.NewBlocker(
+				blocker.InternalErr,
 				"failGetLastBlock",
 			)
 		}
 		var mempoolService = ps.MempoolServices[chainType.GetTypeInt()]
 		if mempoolService == nil {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"mempoolServiceNotFoundByThisChainType",
 			)
 		}
@@ -468,7 +467,7 @@ func (ps *P2PServerService) SendBlockTransactions(
 			BatchReceipts: batchReceipts,
 		}, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 func (ps *P2PServerService) RequestBlockTransactions(
@@ -480,8 +479,8 @@ func (ps *P2PServerService) RequestBlockTransactions(
 	if ps.PeerExplorer.ValidateRequest(ctx) {
 		var md, _ = metadata.FromIncomingContext(ctx)
 		if len(md) == 0 {
-			return nil, status.Error(
-				codes.InvalidArgument,
+			return nil, blocker.NewBlocker(
+				blocker.ValidationErr,
 				"invalidContext",
 			)
 		}
@@ -490,12 +489,12 @@ func (ps *P2PServerService) RequestBlockTransactions(
 			peer, err   = p2pUtil.ParsePeer(fullAddress)
 		)
 		if err != nil {
-			return nil, status.Error(codes.InvalidArgument, "invalidPeer")
+			return nil, blocker.NewBlocker(blocker.ValidationErr, "invalidPeer")
 		}
 		ps.Observer.Notify(observer.BlockTransactionsRequested, transactionsIDs, chainType, blockID, peer)
 		return &model.Empty{}, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }
 
 func (ps *P2PServerService) RequestDownloadFile(
@@ -521,5 +520,5 @@ func (ps *P2PServerService) RequestDownloadFile(
 		}
 		return res, nil
 	}
-	return nil, status.Error(codes.Unauthenticated, "Rejected request")
+	return nil, blocker.NewBlocker(blocker.P2PNetworkConnectionErr, "Rejected request")
 }