From 8e8c71e37bb71884c3574f86af2f7a6acfd3ece6 Mon Sep 17 00:00:00 2001 From: evan-forbes Date: Mon, 10 Oct 2022 15:25:32 -0500 Subject: [PATCH 1/7] fix: protect global var with a sync.Once --- rpc/core/env.go | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/rpc/core/env.go b/rpc/core/env.go index 11a51bfe70..b9c5e47651 100644 --- a/rpc/core/env.go +++ b/rpc/core/env.go @@ -3,6 +3,7 @@ package core import ( "encoding/base64" "fmt" + "sync" "time" cfg "github.com/tendermint/tendermint/config" @@ -35,13 +36,19 @@ const ( var ( // set by Node - env *Environment + env *Environment + envOnce sync.Once ) -// SetEnvironment sets up the given Environment. -// It will race if multiple Node call SetEnvironment. +// SetEnvironment sets up the given Environment. The env global var that this +// function modifies is protected by a sync.Once, so multiple calls within the +// same process will not be effective. func SetEnvironment(e *Environment) { - env = e + envOnce.Do( + func() { + env = e + }, + ) } //---------------------------------------------- @@ -69,7 +76,7 @@ type peers interface { Peers() p2p.IPeerSet } -//---------------------------------------------- +// ---------------------------------------------- // Environment contains objects and interfaces used by the RPC. It is expected // to be setup once during startup. type Environment struct { From 2ebaff4501bde33fe8ae70bca82c28a638733320 Mon Sep 17 00:00:00 2001 From: evan-forbes Date: Mon, 10 Oct 2022 17:30:22 -0500 Subject: [PATCH 2/7] fix: use a mutex instead of sync.Once to allow for arbitrary swapping of the env --- rpc/core/env.go | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/rpc/core/env.go b/rpc/core/env.go index b9c5e47651..23615b48a3 100644 --- a/rpc/core/env.go +++ b/rpc/core/env.go @@ -36,19 +36,17 @@ const ( var ( // set by Node - env *Environment - envOnce sync.Once + mut = &sync.Mutex{} + env *Environment ) // SetEnvironment sets up the given Environment. The env global var that this // function modifies is protected by a sync.Once, so multiple calls within the // same process will not be effective. func SetEnvironment(e *Environment) { - envOnce.Do( - func() { - env = e - }, - ) + mut.Lock() + defer mut.Unlock() + env = e } //---------------------------------------------- From c569855a3e10b8f93512b6b1ef6c0c845f920bfe Mon Sep 17 00:00:00 2001 From: Rootul Patel Date: Fri, 14 Oct 2022 08:33:23 -0500 Subject: [PATCH 3/7] fix: implement and use GetEnvironment --- rpc/core/abci.go | 4 ++-- rpc/core/blocks.go | 48 ++++++++++++++++++++--------------------- rpc/core/blocks_test.go | 6 ++++-- rpc/core/consensus.go | 10 ++++----- rpc/core/dev.go | 2 +- rpc/core/env.go | 34 ++++++++++++++++++----------- rpc/core/events.go | 28 ++++++++++++------------ rpc/core/evidence.go | 2 +- rpc/core/mempool.go | 44 ++++++++++++++++++------------------- rpc/core/net.go | 36 +++++++++++++++---------------- rpc/core/net_test.go | 8 +++---- rpc/core/status.go | 18 ++++++++-------- rpc/core/tx.go | 12 +++++------ 13 files changed, 131 insertions(+), 121 deletions(-) diff --git a/rpc/core/abci.go b/rpc/core/abci.go index 2cf00f93a8..34aad0f3de 100644 --- a/rpc/core/abci.go +++ b/rpc/core/abci.go @@ -17,7 +17,7 @@ func ABCIQuery( height int64, prove bool, ) (*ctypes.ResultABCIQuery, error) { - resQuery, err := env.ProxyAppQuery.QuerySync(abci.RequestQuery{ + resQuery, err := GetEnvironment().ProxyAppQuery.QuerySync(abci.RequestQuery{ Path: path, Data: data, Height: height, @@ -33,7 +33,7 @@ func ABCIQuery( // ABCIInfo gets some info about the application. // More: https://docs.tendermint.com/master/rpc/#/ABCI/abci_info func ABCIInfo(ctx *rpctypes.Context) (*ctypes.ResultABCIInfo, error) { - resInfo, err := env.ProxyAppQuery.InfoSync(proxy.RequestInfo) + resInfo, err := GetEnvironment().ProxyAppQuery.InfoSync(proxy.RequestInfo) if err != nil { return nil, err } diff --git a/rpc/core/blocks.go b/rpc/core/blocks.go index 1ac0b9a162..4e63e3bbdd 100644 --- a/rpc/core/blocks.go +++ b/rpc/core/blocks.go @@ -24,24 +24,24 @@ func BlockchainInfo(ctx *rpctypes.Context, minHeight, maxHeight int64) (*ctypes. const limit int64 = 20 var err error minHeight, maxHeight, err = filterMinMax( - env.BlockStore.Base(), - env.BlockStore.Height(), + GetEnvironment().BlockStore.Base(), + GetEnvironment().BlockStore.Height(), minHeight, maxHeight, limit) if err != nil { return nil, err } - env.Logger.Debug("BlockchainInfoHandler", "maxHeight", maxHeight, "minHeight", minHeight) + GetEnvironment().Logger.Debug("BlockchainInfoHandler", "maxHeight", maxHeight, "minHeight", minHeight) blockMetas := []*types.BlockMeta{} for height := maxHeight; height >= minHeight; height-- { - blockMeta := env.BlockStore.LoadBlockMeta(height) + blockMeta := GetEnvironment().BlockStore.LoadBlockMeta(height) blockMetas = append(blockMetas, blockMeta) } return &ctypes.ResultBlockchainInfo{ - LastHeight: env.BlockStore.Height(), + LastHeight: GetEnvironment().BlockStore.Height(), BlockMetas: blockMetas}, nil } @@ -82,13 +82,13 @@ func filterMinMax(base, height, min, max, limit int64) (int64, int64, error) { // If no height is provided, it will fetch the latest block. // More: https://docs.tendermint.com/master/rpc/#/Info/block func Block(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultBlock, error) { - height, err := getHeight(env.BlockStore.Height(), heightPtr) + height, err := getHeight(GetEnvironment().BlockStore.Height(), heightPtr) if err != nil { return nil, err } - block := env.BlockStore.LoadBlock(height) - blockMeta := env.BlockStore.LoadBlockMeta(height) + block := GetEnvironment().BlockStore.LoadBlock(height) + blockMeta := GetEnvironment().BlockStore.LoadBlockMeta(height) if blockMeta == nil { return &ctypes.ResultBlock{BlockID: types.BlockID{}, Block: block}, nil } @@ -98,12 +98,12 @@ func Block(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultBlock, error) // BlockByHash gets block by hash. // More: https://docs.tendermint.com/master/rpc/#/Info/block_by_hash func BlockByHash(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultBlock, error) { - block := env.BlockStore.LoadBlockByHash(hash) + block := GetEnvironment().BlockStore.LoadBlockByHash(hash) if block == nil { return &ctypes.ResultBlock{BlockID: types.BlockID{}, Block: nil}, nil } // If block is not nil, then blockMeta can't be nil. - blockMeta := env.BlockStore.LoadBlockMeta(block.Height) + blockMeta := GetEnvironment().BlockStore.LoadBlockMeta(block.Height) return &ctypes.ResultBlock{BlockID: blockMeta.BlockID, Block: block}, nil } @@ -111,12 +111,12 @@ func BlockByHash(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultBlock, error // If no height is provided, it will fetch the commit for the latest block. // More: https://docs.tendermint.com/master/rpc/#/Info/commit func Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultCommit, error) { - height, err := getHeight(env.BlockStore.Height(), heightPtr) + height, err := getHeight(GetEnvironment().BlockStore.Height(), heightPtr) if err != nil { return nil, err } - blockMeta := env.BlockStore.LoadBlockMeta(height) + blockMeta := GetEnvironment().BlockStore.LoadBlockMeta(height) if blockMeta == nil { return nil, nil } @@ -124,13 +124,13 @@ func Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultCommit, erro // If the next block has not been committed yet, // use a non-canonical commit - if height == env.BlockStore.Height() { - commit := env.BlockStore.LoadSeenCommit(height) + if height == GetEnvironment().BlockStore.Height() { + commit := GetEnvironment().BlockStore.LoadSeenCommit(height) return ctypes.NewResultCommit(&header, commit, false), nil } // Return the canonical commit (comes from the block at height+1) - commit := env.BlockStore.LoadBlockCommit(height) + commit := GetEnvironment().BlockStore.LoadBlockCommit(height) return ctypes.NewResultCommit(&header, commit, true), nil } @@ -171,14 +171,14 @@ func validateDataCommitmentRange(beginBlock uint64, endBlock uint64) error { if beginBlock > endBlock { return fmt.Errorf("end block is smaller than begin block") } - if endBlock > uint64(env.BlockStore.Height()) { + if endBlock > uint64(GetEnvironment().BlockStore.Height()) { return fmt.Errorf( "end block %d is higher than current chain height %d", endBlock, - env.BlockStore.Height(), + GetEnvironment().BlockStore.Height(), ) } - has, err := env.BlockIndexer.Has(int64(endBlock)) + has, err := GetEnvironment().BlockIndexer.Has(int64(endBlock)) if err != nil { return err } @@ -209,12 +209,12 @@ func hashDataRoots(blocks []*ctypes.ResultBlock) []byte { // getBlock(h).Txs[5] // More: https://docs.tendermint.com/master/rpc/#/Info/block_results func BlockResults(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultBlockResults, error) { - height, err := getHeight(env.BlockStore.Height(), heightPtr) + height, err := getHeight(GetEnvironment().BlockStore.Height(), heightPtr) if err != nil { return nil, err } - results, err := env.StateStore.LoadABCIResponses(height) + results, err := GetEnvironment().StateStore.LoadABCIResponses(height) if err != nil { return nil, err } @@ -269,7 +269,7 @@ func BlockSearch( // heightsByQuery returns a list of heights corresponding to the provided query. func heightsByQuery(ctx *rpctypes.Context, query string) ([]int64, error) { // skip if block indexing is disabled - if _, ok := env.BlockIndexer.(*blockidxnull.BlockerIndexer); ok { + if _, ok := GetEnvironment().BlockIndexer.(*blockidxnull.BlockerIndexer); ok { return nil, errors.New("block indexing is disabled") } @@ -278,7 +278,7 @@ func heightsByQuery(ctx *rpctypes.Context, query string) ([]int64, error) { return nil, err } - results, err := env.BlockIndexer.Search(ctx.Context(), q) + results, err := GetEnvironment().BlockIndexer.Search(ctx.Context(), q) return results, err } @@ -302,9 +302,9 @@ func sortBlocks(results []int64, orderBy string) error { func fetchBlocks(results []int64, pageSize int, skipCount int) []*ctypes.ResultBlock { apiResults := make([]*ctypes.ResultBlock, 0, pageSize) for i := skipCount; i < skipCount+pageSize; i++ { - block := env.BlockStore.LoadBlock(results[i]) + block := GetEnvironment().BlockStore.LoadBlock(results[i]) if block != nil { - blockMeta := env.BlockStore.LoadBlockMeta(block.Height) + blockMeta := GetEnvironment().BlockStore.LoadBlockMeta(block.Height) if blockMeta != nil { apiResults = append(apiResults, &ctypes.ResultBlock{ Block: block, diff --git a/rpc/core/blocks_test.go b/rpc/core/blocks_test.go index a654b76300..19082f2cbc 100644 --- a/rpc/core/blocks_test.go +++ b/rpc/core/blocks_test.go @@ -85,11 +85,12 @@ func TestBlockResults(t *testing.T) { BeginBlock: &abci.ResponseBeginBlock{}, } - env = &Environment{} + env := &Environment{} env.StateStore = sm.NewStore(dbm.NewMemDB()) err := env.StateStore.SaveABCIResponses(100, results) require.NoError(t, err) env.BlockStore = mockBlockStore{height: 100} + SetEnvironment(env) testCases := []struct { height int64 @@ -121,7 +122,7 @@ func TestBlockResults(t *testing.T) { } func TestDataCommitmentResults(t *testing.T) { - env = &Environment{} + env := &Environment{} height := int64(2826) blocks := randomBlocks(height) @@ -149,6 +150,7 @@ func TestDataCommitmentResults(t *testing.T) { beginQueryBlock: tc.beginQuery, endQueryBlock: tc.endQuery, } + SetEnvironment(env) actualCommitment, err := DataCommitment(&rpctypes.Context{}, uint64(tc.beginQuery), uint64(tc.endQuery)) if tc.expectPass { diff --git a/rpc/core/consensus.go b/rpc/core/consensus.go index 89b5d6a459..29797ac9c2 100644 --- a/rpc/core/consensus.go +++ b/rpc/core/consensus.go @@ -22,7 +22,7 @@ func Validators(ctx *rpctypes.Context, heightPtr *int64, pagePtr, perPagePtr *in return nil, err } - validators, err := env.StateStore.LoadValidators(height) + validators, err := GetEnvironment().StateStore.LoadValidators(height) if err != nil { return nil, err } @@ -50,7 +50,7 @@ func Validators(ctx *rpctypes.Context, heightPtr *int64, pagePtr, perPagePtr *in // More: https://docs.tendermint.com/master/rpc/#/Info/dump_consensus_state func DumpConsensusState(ctx *rpctypes.Context) (*ctypes.ResultDumpConsensusState, error) { // Get Peer consensus states. - peers := env.P2PPeers.Peers().List() + peers := GetEnvironment().P2PPeers.Peers().List() peerStates := make([]ctypes.PeerStateInfo, len(peers)) for i, peer := range peers { peerState, ok := peer.Get(types.PeerStateKey).(*cm.PeerState) @@ -69,7 +69,7 @@ func DumpConsensusState(ctx *rpctypes.Context) (*ctypes.ResultDumpConsensusState } } // Get self round state. - roundState, err := env.ConsensusState.GetRoundStateJSON() + roundState, err := GetEnvironment().ConsensusState.GetRoundStateJSON() if err != nil { return nil, err } @@ -83,7 +83,7 @@ func DumpConsensusState(ctx *rpctypes.Context) (*ctypes.ResultDumpConsensusState // More: https://docs.tendermint.com/master/rpc/#/Info/consensus_state func ConsensusState(ctx *rpctypes.Context) (*ctypes.ResultConsensusState, error) { // Get self round state. - bz, err := env.ConsensusState.GetRoundStateSimpleJSON() + bz, err := GetEnvironment().ConsensusState.GetRoundStateSimpleJSON() return &ctypes.ResultConsensusState{RoundState: bz}, err } @@ -98,7 +98,7 @@ func ConsensusParams(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultCon return nil, err } - consensusParams, err := env.StateStore.LoadConsensusParams(height) + consensusParams, err := GetEnvironment().StateStore.LoadConsensusParams(height) if err != nil { return nil, err } diff --git a/rpc/core/dev.go b/rpc/core/dev.go index b70f5f1e12..5383653525 100644 --- a/rpc/core/dev.go +++ b/rpc/core/dev.go @@ -7,6 +7,6 @@ import ( // UnsafeFlushMempool removes all transactions from the mempool. func UnsafeFlushMempool(ctx *rpctypes.Context) (*ctypes.ResultUnsafeFlushMempool, error) { - env.Mempool.Flush() + GetEnvironment().Mempool.Flush() return &ctypes.ResultUnsafeFlushMempool{}, nil } diff --git a/rpc/core/env.go b/rpc/core/env.go index 23615b48a3..506c26b350 100644 --- a/rpc/core/env.go +++ b/rpc/core/env.go @@ -36,17 +36,23 @@ const ( var ( // set by Node - mut = &sync.Mutex{} - env *Environment + mut = &sync.Mutex{} + globalEnv *Environment ) -// SetEnvironment sets up the given Environment. The env global var that this -// function modifies is protected by a sync.Once, so multiple calls within the +// SetEnvironment sets the global environment to e. The globalEnv var that this +// function modifies is protected by a sync.Once so multiple calls within the // same process will not be effective. func SetEnvironment(e *Environment) { mut.Lock() defer mut.Unlock() - env = e + globalEnv = e +} + +func GetEnvironment() *Environment { + mut.Lock() + defer mut.Unlock() + return globalEnv } //---------------------------------------------- @@ -147,15 +153,15 @@ func validatePerPage(perPagePtr *int) int { // InitGenesisChunks configures the environment and should be called on service // startup. func InitGenesisChunks() error { - if env.genChunks != nil { + if GetEnvironment().genChunks != nil { return nil } - if env.GenDoc == nil { + if GetEnvironment().GenDoc == nil { return nil } - data, err := tmjson.Marshal(env.GenDoc) + data, err := tmjson.Marshal(GetEnvironment().GenDoc) if err != nil { return err } @@ -167,7 +173,9 @@ func InitGenesisChunks() error { end = len(data) } - env.genChunks = append(env.genChunks, base64.StdEncoding.EncodeToString(data[i:end])) + mut.Lock() + defer mut.Unlock() + globalEnv.genChunks = append(globalEnv.genChunks, base64.StdEncoding.EncodeToString(data[i:end])) } return nil @@ -193,7 +201,7 @@ func getHeight(latestHeight int64, heightPtr *int64) (int64, error) { return 0, fmt.Errorf("height %d must be less than or equal to the current blockchain height %d", height, latestHeight) } - base := env.BlockStore.Base() + base := GetEnvironment().BlockStore.Base() if height < base { return 0, fmt.Errorf("height %d is not available, lowest height is %d", height, base) @@ -204,9 +212,9 @@ func getHeight(latestHeight int64, heightPtr *int64) (int64, error) { } func latestUncommittedHeight() int64 { - nodeIsSyncing := env.ConsensusReactor.WaitSync() + nodeIsSyncing := GetEnvironment().ConsensusReactor.WaitSync() if nodeIsSyncing { - return env.BlockStore.Height() + return GetEnvironment().BlockStore.Height() } - return env.BlockStore.Height() + 1 + return GetEnvironment().BlockStore.Height() + 1 } diff --git a/rpc/core/events.go b/rpc/core/events.go index 438979004a..0a32068856 100644 --- a/rpc/core/events.go +++ b/rpc/core/events.go @@ -23,15 +23,15 @@ const ( func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, error) { addr := ctx.RemoteAddr() - if env.EventBus.NumClients() >= env.Config.MaxSubscriptionClients { - return nil, fmt.Errorf("max_subscription_clients %d reached", env.Config.MaxSubscriptionClients) - } else if env.EventBus.NumClientSubscriptions(addr) >= env.Config.MaxSubscriptionsPerClient { - return nil, fmt.Errorf("max_subscriptions_per_client %d reached", env.Config.MaxSubscriptionsPerClient) + if GetEnvironment().EventBus.NumClients() >= GetEnvironment().Config.MaxSubscriptionClients { + return nil, fmt.Errorf("max_subscription_clients %d reached", GetEnvironment().Config.MaxSubscriptionClients) + } else if GetEnvironment().EventBus.NumClientSubscriptions(addr) >= GetEnvironment().Config.MaxSubscriptionsPerClient { + return nil, fmt.Errorf("max_subscriptions_per_client %d reached", GetEnvironment().Config.MaxSubscriptionsPerClient) } else if len(query) > maxQueryLength { return nil, errors.New("maximum query length exceeded") } - env.Logger.Info("Subscribe to query", "remote", addr, "query", query) + GetEnvironment().Logger.Info("Subscribe to query", "remote", addr, "query", query) q, err := tmquery.New(query) if err != nil { @@ -41,7 +41,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er subCtx, cancel := context.WithTimeout(ctx.Context(), SubscribeTimeout) defer cancel() - sub, err := env.EventBus.Subscribe(subCtx, addr, q, env.Config.SubscriptionBufferSize) + sub, err := GetEnvironment().EventBus.Subscribe(subCtx, addr, q, GetEnvironment().Config.SubscriptionBufferSize) if err != nil { return nil, err } @@ -49,7 +49,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er return nil, fmt.Errorf("env.EventBus.Subscribe() returned nil") } - closeIfSlow := env.Config.CloseOnSlowClient + closeIfSlow := GetEnvironment().Config.CloseOnSlowClient // Capture the current ID, since it can change in the future. subscriptionID := ctx.JSONReq.ID @@ -64,7 +64,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er writeCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() if err := ctx.WSConn.WriteRPCResponse(writeCtx, resp); err != nil { - env.Logger.Info("Can't write response (slow client)", + GetEnvironment().Logger.Info("Can't write response (slow client)", "to", addr, "subscriptionID", subscriptionID, "err", err) if closeIfSlow { @@ -73,7 +73,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er resp = rpctypes.RPCServerError(subscriptionID, err) ) if !ctx.WSConn.TryWriteRPCResponse(resp) { - env.Logger.Info("Can't write response (slow client)", + GetEnvironment().Logger.Info("Can't write response (slow client)", "to", addr, "subscriptionID", subscriptionID, "err", err) } return @@ -92,7 +92,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er resp = rpctypes.RPCServerError(subscriptionID, err) ) if !ctx.WSConn.TryWriteRPCResponse(resp) { - env.Logger.Info("Can't write response (slow client)", + GetEnvironment().Logger.Info("Can't write response (slow client)", "to", addr, "subscriptionID", subscriptionID, "err", err) } } @@ -108,12 +108,12 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er // More: https://docs.tendermint.com/master/rpc/#/Websocket/unsubscribe func Unsubscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultUnsubscribe, error) { addr := ctx.RemoteAddr() - env.Logger.Info("Unsubscribe from query", "remote", addr, "query", query) + GetEnvironment().Logger.Info("Unsubscribe from query", "remote", addr, "query", query) q, err := tmquery.New(query) if err != nil { return nil, fmt.Errorf("failed to parse query: %w", err) } - err = env.EventBus.Unsubscribe(context.Background(), addr, q) + err = GetEnvironment().EventBus.Unsubscribe(context.Background(), addr, q) if err != nil { return nil, err } @@ -124,8 +124,8 @@ func Unsubscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultUnsubscribe // More: https://docs.tendermint.com/master/rpc/#/Websocket/unsubscribe_all func UnsubscribeAll(ctx *rpctypes.Context) (*ctypes.ResultUnsubscribe, error) { addr := ctx.RemoteAddr() - env.Logger.Info("Unsubscribe from all", "remote", addr) - err := env.EventBus.UnsubscribeAll(context.Background(), addr) + GetEnvironment().Logger.Info("Unsubscribe from all", "remote", addr) + err := GetEnvironment().EventBus.UnsubscribeAll(context.Background(), addr) if err != nil { return nil, err } diff --git a/rpc/core/evidence.go b/rpc/core/evidence.go index b8fd2e2e20..373e7c442d 100644 --- a/rpc/core/evidence.go +++ b/rpc/core/evidence.go @@ -20,7 +20,7 @@ func BroadcastEvidence(ctx *rpctypes.Context, ev types.Evidence) (*ctypes.Result return nil, fmt.Errorf("evidence.ValidateBasic failed: %w", err) } - if err := env.EvidencePool.AddEvidence(ev); err != nil { + if err := GetEnvironment().EvidencePool.AddEvidence(ev); err != nil { return nil, fmt.Errorf("failed to add evidence: %w", err) } return &ctypes.ResultBroadcastEvidence{Hash: ev.Hash()}, nil diff --git a/rpc/core/mempool.go b/rpc/core/mempool.go index f9fa4b37e5..45d9c0903f 100644 --- a/rpc/core/mempool.go +++ b/rpc/core/mempool.go @@ -20,7 +20,7 @@ import ( // CheckTx nor DeliverTx results. // More: https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async func BroadcastTxAsync(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { - err := env.Mempool.CheckTx(tx, nil, mempl.TxInfo{}) + err := GetEnvironment().Mempool.CheckTx(tx, nil, mempl.TxInfo{}) if err != nil { return nil, err @@ -33,7 +33,7 @@ func BroadcastTxAsync(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadca // More: https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync func BroadcastTxSync(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { resCh := make(chan *abci.Response, 1) - err := env.Mempool.CheckTx(tx, func(res *abci.Response) { + err := GetEnvironment().Mempool.CheckTx(tx, func(res *abci.Response) { select { case <-ctx.Context().Done(): case resCh <- res: @@ -64,38 +64,38 @@ func BroadcastTxSync(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcas func BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { subscriber := ctx.RemoteAddr() - if env.EventBus.NumClients() >= env.Config.MaxSubscriptionClients { - return nil, fmt.Errorf("max_subscription_clients %d reached", env.Config.MaxSubscriptionClients) - } else if env.EventBus.NumClientSubscriptions(subscriber) >= env.Config.MaxSubscriptionsPerClient { - return nil, fmt.Errorf("max_subscriptions_per_client %d reached", env.Config.MaxSubscriptionsPerClient) + if GetEnvironment().EventBus.NumClients() >= GetEnvironment().Config.MaxSubscriptionClients { + return nil, fmt.Errorf("max_subscription_clients %d reached", GetEnvironment().Config.MaxSubscriptionClients) + } else if GetEnvironment().EventBus.NumClientSubscriptions(subscriber) >= GetEnvironment().Config.MaxSubscriptionsPerClient { + return nil, fmt.Errorf("max_subscriptions_per_client %d reached", GetEnvironment().Config.MaxSubscriptionsPerClient) } // Subscribe to tx being committed in block. subCtx, cancel := context.WithTimeout(ctx.Context(), SubscribeTimeout) defer cancel() q := types.EventQueryTxFor(tx) - deliverTxSub, err := env.EventBus.Subscribe(subCtx, subscriber, q) + deliverTxSub, err := GetEnvironment().EventBus.Subscribe(subCtx, subscriber, q) if err != nil { err = fmt.Errorf("failed to subscribe to tx: %w", err) - env.Logger.Error("Error on broadcast_tx_commit", "err", err) + GetEnvironment().Logger.Error("Error on broadcast_tx_commit", "err", err) return nil, err } defer func() { - if err := env.EventBus.Unsubscribe(context.Background(), subscriber, q); err != nil { - env.Logger.Error("Error unsubscribing from eventBus", "err", err) + if err := GetEnvironment().EventBus.Unsubscribe(context.Background(), subscriber, q); err != nil { + GetEnvironment().Logger.Error("Error unsubscribing from eventBus", "err", err) } }() // Broadcast tx and wait for CheckTx result checkTxResCh := make(chan *abci.Response, 1) - err = env.Mempool.CheckTx(tx, func(res *abci.Response) { + err = GetEnvironment().Mempool.CheckTx(tx, func(res *abci.Response) { select { case <-ctx.Context().Done(): case checkTxResCh <- res: } }, mempl.TxInfo{}) if err != nil { - env.Logger.Error("Error on broadcastTxCommit", "err", err) + GetEnvironment().Logger.Error("Error on broadcastTxCommit", "err", err) return nil, fmt.Errorf("error on broadcastTxCommit: %v", err) } select { @@ -129,15 +129,15 @@ func BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadc reason = deliverTxSub.Err().Error() } err = fmt.Errorf("deliverTxSub was cancelled (reason: %s)", reason) - env.Logger.Error("Error on broadcastTxCommit", "err", err) + GetEnvironment().Logger.Error("Error on broadcastTxCommit", "err", err) return &ctypes.ResultBroadcastTxCommit{ CheckTx: *checkTxRes, DeliverTx: abci.ResponseDeliverTx{}, Hash: tx.Hash(), }, err - case <-time.After(env.Config.TimeoutBroadcastTxCommit): + case <-time.After(GetEnvironment().Config.TimeoutBroadcastTxCommit): err = errors.New("timed out waiting for tx to be included in a block") - env.Logger.Error("Error on broadcastTxCommit", "err", err) + GetEnvironment().Logger.Error("Error on broadcastTxCommit", "err", err) return &ctypes.ResultBroadcastTxCommit{ CheckTx: *checkTxRes, DeliverTx: abci.ResponseDeliverTx{}, @@ -154,11 +154,11 @@ func UnconfirmedTxs(ctx *rpctypes.Context, limitPtr *int) (*ctypes.ResultUnconfi // reuse per_page validator limit := validatePerPage(limitPtr) - txs := env.Mempool.ReapMaxTxs(limit) + txs := GetEnvironment().Mempool.ReapMaxTxs(limit) return &ctypes.ResultUnconfirmedTxs{ Count: len(txs), - Total: env.Mempool.Size(), - TotalBytes: env.Mempool.SizeBytes(), + Total: GetEnvironment().Mempool.Size(), + TotalBytes: GetEnvironment().Mempool.SizeBytes(), Txs: txs}, nil } @@ -166,16 +166,16 @@ func UnconfirmedTxs(ctx *rpctypes.Context, limitPtr *int) (*ctypes.ResultUnconfi // More: https://docs.tendermint.com/master/rpc/#/Info/num_unconfirmed_txs func NumUnconfirmedTxs(ctx *rpctypes.Context) (*ctypes.ResultUnconfirmedTxs, error) { return &ctypes.ResultUnconfirmedTxs{ - Count: env.Mempool.Size(), - Total: env.Mempool.Size(), - TotalBytes: env.Mempool.SizeBytes()}, nil + Count: GetEnvironment().Mempool.Size(), + Total: GetEnvironment().Mempool.Size(), + TotalBytes: GetEnvironment().Mempool.SizeBytes()}, nil } // CheckTx checks the transaction without executing it. The transaction won't // be added to the mempool either. // More: https://docs.tendermint.com/master/rpc/#/Tx/check_tx func CheckTx(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultCheckTx, error) { - res, err := env.ProxyAppMempool.CheckTxSync(abci.RequestCheckTx{Tx: tx}) + res, err := GetEnvironment().ProxyAppMempool.CheckTxSync(abci.RequestCheckTx{Tx: tx}) if err != nil { return nil, err } diff --git a/rpc/core/net.go b/rpc/core/net.go index 2a0e2c92d4..6556f81814 100644 --- a/rpc/core/net.go +++ b/rpc/core/net.go @@ -13,7 +13,7 @@ import ( // NetInfo returns network info. // More: https://docs.tendermint.com/master/rpc/#/Info/net_info func NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) { - peersList := env.P2PPeers.Peers().List() + peersList := GetEnvironment().P2PPeers.Peers().List() peers := make([]ctypes.Peer, 0, len(peersList)) for _, peer := range peersList { nodeInfo, ok := peer.NodeInfo().(p2p.DefaultNodeInfo) @@ -31,8 +31,8 @@ func NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) { // PRO: useful info // CON: privacy return &ctypes.ResultNetInfo{ - Listening: env.P2PTransport.IsListening(), - Listeners: env.P2PTransport.Listeners(), + Listening: GetEnvironment().P2PTransport.IsListening(), + Listeners: GetEnvironment().P2PTransport.Listeners(), NPeers: len(peers), Peers: peers, }, nil @@ -43,8 +43,8 @@ func UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (*ctypes.ResultDialS if len(seeds) == 0 { return &ctypes.ResultDialSeeds{}, errors.New("no seeds provided") } - env.Logger.Info("DialSeeds", "seeds", seeds) - if err := env.P2PPeers.DialPeersAsync(seeds); err != nil { + GetEnvironment().Logger.Info("DialSeeds", "seeds", seeds) + if err := GetEnvironment().P2PPeers.DialPeersAsync(seeds); err != nil { return &ctypes.ResultDialSeeds{}, err } return &ctypes.ResultDialSeeds{Log: "Dialing seeds in progress. See /net_info for details"}, nil @@ -63,28 +63,28 @@ func UnsafeDialPeers(ctx *rpctypes.Context, peers []string, persistent, uncondit return &ctypes.ResultDialPeers{}, err } - env.Logger.Info("DialPeers", "peers", peers, "persistent", + GetEnvironment().Logger.Info("DialPeers", "peers", peers, "persistent", persistent, "unconditional", unconditional, "private", private) if persistent { - if err := env.P2PPeers.AddPersistentPeers(peers); err != nil { + if err := GetEnvironment().P2PPeers.AddPersistentPeers(peers); err != nil { return &ctypes.ResultDialPeers{}, err } } if private { - if err := env.P2PPeers.AddPrivatePeerIDs(ids); err != nil { + if err := GetEnvironment().P2PPeers.AddPrivatePeerIDs(ids); err != nil { return &ctypes.ResultDialPeers{}, err } } if unconditional { - if err := env.P2PPeers.AddUnconditionalPeerIDs(ids); err != nil { + if err := GetEnvironment().P2PPeers.AddUnconditionalPeerIDs(ids); err != nil { return &ctypes.ResultDialPeers{}, err } } - if err := env.P2PPeers.DialPeersAsync(peers); err != nil { + if err := GetEnvironment().P2PPeers.DialPeersAsync(peers); err != nil { return &ctypes.ResultDialPeers{}, err } @@ -94,32 +94,32 @@ func UnsafeDialPeers(ctx *rpctypes.Context, peers []string, persistent, uncondit // Genesis returns genesis file. // More: https://docs.tendermint.com/master/rpc/#/Info/genesis func Genesis(ctx *rpctypes.Context) (*ctypes.ResultGenesis, error) { - if len(env.genChunks) > 1 { + if len(GetEnvironment().genChunks) > 1 { return nil, errors.New("genesis response is large, please use the genesis_chunked API instead") } - return &ctypes.ResultGenesis{Genesis: env.GenDoc}, nil + return &ctypes.ResultGenesis{Genesis: GetEnvironment().GenDoc}, nil } func GenesisChunked(ctx *rpctypes.Context, chunk uint) (*ctypes.ResultGenesisChunk, error) { - if env.genChunks == nil { + if GetEnvironment().genChunks == nil { return nil, fmt.Errorf("service configuration error, genesis chunks are not initialized") } - if len(env.genChunks) == 0 { + if len(GetEnvironment().genChunks) == 0 { return nil, fmt.Errorf("service configuration error, there are no chunks") } id := int(chunk) - if id > len(env.genChunks)-1 { - return nil, fmt.Errorf("there are %d chunks, %d is invalid", len(env.genChunks)-1, id) + if id > len(GetEnvironment().genChunks)-1 { + return nil, fmt.Errorf("there are %d chunks, %d is invalid", len(GetEnvironment().genChunks)-1, id) } return &ctypes.ResultGenesisChunk{ - TotalChunks: len(env.genChunks), + TotalChunks: len(GetEnvironment().genChunks), ChunkNumber: id, - Data: env.genChunks[id], + Data: GetEnvironment().genChunks[id], }, nil } diff --git a/rpc/core/net_test.go b/rpc/core/net_test.go index c971776f3e..30341c74f4 100644 --- a/rpc/core/net_test.go +++ b/rpc/core/net_test.go @@ -23,8 +23,8 @@ func TestUnsafeDialSeeds(t *testing.T) { } }) - env.Logger = log.TestingLogger() - env.P2PPeers = sw + GetEnvironment().Logger = log.TestingLogger() + GetEnvironment().P2PPeers = sw testCases := []struct { seeds []string @@ -62,8 +62,8 @@ func TestUnsafeDialPeers(t *testing.T) { } }) - env.Logger = log.TestingLogger() - env.P2PPeers = sw + GetEnvironment().Logger = log.TestingLogger() + GetEnvironment().P2PPeers = sw testCases := []struct { peers []string diff --git a/rpc/core/status.go b/rpc/core/status.go index 72f50f5468..89012b83e8 100644 --- a/rpc/core/status.go +++ b/rpc/core/status.go @@ -21,7 +21,7 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { earliestBlockTimeNano int64 ) - if earliestBlockMeta := env.BlockStore.LoadBaseMeta(); earliestBlockMeta != nil { + if earliestBlockMeta := GetEnvironment().BlockStore.LoadBaseMeta(); earliestBlockMeta != nil { earliestBlockHeight = earliestBlockMeta.Header.Height earliestAppHash = earliestBlockMeta.Header.AppHash earliestBlockHash = earliestBlockMeta.BlockID.Hash @@ -33,11 +33,11 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { latestAppHash tmbytes.HexBytes latestBlockTimeNano int64 - latestHeight = env.BlockStore.Height() + latestHeight = GetEnvironment().BlockStore.Height() ) if latestHeight != 0 { - if latestBlockMeta := env.BlockStore.LoadBlockMeta(latestHeight); latestBlockMeta != nil { + if latestBlockMeta := GetEnvironment().BlockStore.LoadBlockMeta(latestHeight); latestBlockMeta != nil { latestBlockHash = latestBlockMeta.BlockID.Hash latestAppHash = latestBlockMeta.Header.AppHash latestBlockTimeNano = latestBlockMeta.Header.Time.UnixNano() @@ -52,7 +52,7 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { } result := &ctypes.ResultStatus{ - NodeInfo: env.P2PTransport.NodeInfo().(p2p.DefaultNodeInfo), + NodeInfo: GetEnvironment().P2PTransport.NodeInfo().(p2p.DefaultNodeInfo), SyncInfo: ctypes.SyncInfo{ LatestBlockHash: latestBlockHash, LatestAppHash: latestAppHash, @@ -62,11 +62,11 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { EarliestAppHash: earliestAppHash, EarliestBlockHeight: earliestBlockHeight, EarliestBlockTime: time.Unix(0, earliestBlockTimeNano), - CatchingUp: env.ConsensusReactor.WaitSync(), + CatchingUp: GetEnvironment().ConsensusReactor.WaitSync(), }, ValidatorInfo: ctypes.ValidatorInfo{ - Address: env.PubKey.Address(), - PubKey: env.PubKey, + Address: GetEnvironment().PubKey.Address(), + PubKey: GetEnvironment().PubKey, VotingPower: votingPower, }, } @@ -75,11 +75,11 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { } func validatorAtHeight(h int64) *types.Validator { - vals, err := env.StateStore.LoadValidators(h) + vals, err := GetEnvironment().StateStore.LoadValidators(h) if err != nil { return nil } - privValAddress := env.PubKey.Address() + privValAddress := GetEnvironment().PubKey.Address() _, val := vals.GetByAddress(privValAddress) return val } diff --git a/rpc/core/tx.go b/rpc/core/tx.go index ad14dbb7c0..0809596ff0 100644 --- a/rpc/core/tx.go +++ b/rpc/core/tx.go @@ -25,11 +25,11 @@ import ( // More: https://docs.tendermint.com/master/rpc/#/Info/tx func Tx(ctx *rpctypes.Context, hash []byte, prove bool) (*ctypes.ResultTx, error) { // if index is disabled, return error - if _, ok := env.TxIndexer.(*null.TxIndex); ok { + if _, ok := GetEnvironment().TxIndexer.(*null.TxIndex); ok { return nil, fmt.Errorf("transaction indexing is disabled") } - r, err := env.TxIndexer.Get(hash) + r, err := GetEnvironment().TxIndexer.Get(hash) if err != nil { return nil, err } @@ -73,7 +73,7 @@ func TxSearch( ) (*ctypes.ResultTxSearch, error) { // if index is disabled, return error - if _, ok := env.TxIndexer.(*null.TxIndex); ok { + if _, ok := GetEnvironment().TxIndexer.(*null.TxIndex); ok { return nil, errors.New("transaction indexing is disabled") } else if len(query) > maxQueryLength { return nil, errors.New("maximum query length exceeded") @@ -84,7 +84,7 @@ func TxSearch( return nil, err } - results, err := env.TxIndexer.Search(ctx.Context(), q) + results, err := GetEnvironment().TxIndexer.Search(ctx.Context(), q) if err != nil { return nil, err } @@ -151,11 +151,11 @@ func proveTx(height int64, index uint32) (types.TxProof, error) { pTxProof tmproto.TxProof txProof types.TxProof ) - rawBlock, err := loadRawBlock(env.BlockStore, height) + rawBlock, err := loadRawBlock(GetEnvironment().BlockStore, height) if err != nil { return txProof, err } - res, err := env.ProxyAppQuery.QuerySync(abcitypes.RequestQuery{ + res, err := GetEnvironment().ProxyAppQuery.QuerySync(abcitypes.RequestQuery{ Data: rawBlock, Path: fmt.Sprintf(consts.TxInclusionProofQueryPath, index), }) From f5c610e36dc8501d1db64106aed54b9ee312af4c Mon Sep 17 00:00:00 2001 From: Rootul Patel Date: Fri, 14 Oct 2022 08:42:46 -0500 Subject: [PATCH 4/7] fix: lint by disabling lll --- rpc/core/mempool.go | 1 + 1 file changed, 1 insertion(+) diff --git a/rpc/core/mempool.go b/rpc/core/mempool.go index 45d9c0903f..8288c1f215 100644 --- a/rpc/core/mempool.go +++ b/rpc/core/mempool.go @@ -64,6 +64,7 @@ func BroadcastTxSync(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcas func BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { subscriber := ctx.RemoteAddr() + //nolint:lll if GetEnvironment().EventBus.NumClients() >= GetEnvironment().Config.MaxSubscriptionClients { return nil, fmt.Errorf("max_subscription_clients %d reached", GetEnvironment().Config.MaxSubscriptionClients) } else if GetEnvironment().EventBus.NumClientSubscriptions(subscriber) >= GetEnvironment().Config.MaxSubscriptionsPerClient { From fda227f312905d9c4e37b60f9608428ecdfe111a Mon Sep 17 00:00:00 2001 From: Rootul Patel Date: Mon, 14 Nov 2022 11:54:15 -0500 Subject: [PATCH 5/7] fix: invoke GetEnvironment() once per function scope --- rpc/core/blocks.go | 49 +++++++++++++++++++++++++------------------- rpc/core/env.go | 7 ++++--- rpc/core/events.go | 31 +++++++++++++++------------- rpc/core/mempool.go | 41 +++++++++++++++++++----------------- rpc/core/net.go | 41 ++++++++++++++++++++---------------- rpc/core/net_test.go | 10 +++++---- rpc/core/status.go | 20 ++++++++++-------- rpc/core/tx.go | 15 ++++++++------ 8 files changed, 120 insertions(+), 94 deletions(-) diff --git a/rpc/core/blocks.go b/rpc/core/blocks.go index 4e63e3bbdd..e389d3f082 100644 --- a/rpc/core/blocks.go +++ b/rpc/core/blocks.go @@ -23,25 +23,26 @@ func BlockchainInfo(ctx *rpctypes.Context, minHeight, maxHeight int64) (*ctypes. // maximum 20 block metas const limit int64 = 20 var err error + env := GetEnvironment() minHeight, maxHeight, err = filterMinMax( - GetEnvironment().BlockStore.Base(), - GetEnvironment().BlockStore.Height(), + env.BlockStore.Base(), + env.BlockStore.Height(), minHeight, maxHeight, limit) if err != nil { return nil, err } - GetEnvironment().Logger.Debug("BlockchainInfoHandler", "maxHeight", maxHeight, "minHeight", minHeight) + env.Logger.Debug("BlockchainInfoHandler", "maxHeight", maxHeight, "minHeight", minHeight) blockMetas := []*types.BlockMeta{} for height := maxHeight; height >= minHeight; height-- { - blockMeta := GetEnvironment().BlockStore.LoadBlockMeta(height) + blockMeta := env.BlockStore.LoadBlockMeta(height) blockMetas = append(blockMetas, blockMeta) } return &ctypes.ResultBlockchainInfo{ - LastHeight: GetEnvironment().BlockStore.Height(), + LastHeight: env.BlockStore.Height(), BlockMetas: blockMetas}, nil } @@ -98,12 +99,13 @@ func Block(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultBlock, error) // BlockByHash gets block by hash. // More: https://docs.tendermint.com/master/rpc/#/Info/block_by_hash func BlockByHash(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultBlock, error) { - block := GetEnvironment().BlockStore.LoadBlockByHash(hash) + env := GetEnvironment() + block := env.BlockStore.LoadBlockByHash(hash) if block == nil { return &ctypes.ResultBlock{BlockID: types.BlockID{}, Block: nil}, nil } // If block is not nil, then blockMeta can't be nil. - blockMeta := GetEnvironment().BlockStore.LoadBlockMeta(block.Height) + blockMeta := env.BlockStore.LoadBlockMeta(block.Height) return &ctypes.ResultBlock{BlockID: blockMeta.BlockID, Block: block}, nil } @@ -111,12 +113,13 @@ func BlockByHash(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultBlock, error // If no height is provided, it will fetch the commit for the latest block. // More: https://docs.tendermint.com/master/rpc/#/Info/commit func Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultCommit, error) { - height, err := getHeight(GetEnvironment().BlockStore.Height(), heightPtr) + env := GetEnvironment() + height, err := getHeight(env.BlockStore.Height(), heightPtr) if err != nil { return nil, err } - blockMeta := GetEnvironment().BlockStore.LoadBlockMeta(height) + blockMeta := env.BlockStore.LoadBlockMeta(height) if blockMeta == nil { return nil, nil } @@ -124,13 +127,13 @@ func Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultCommit, erro // If the next block has not been committed yet, // use a non-canonical commit - if height == GetEnvironment().BlockStore.Height() { - commit := GetEnvironment().BlockStore.LoadSeenCommit(height) + if height == env.BlockStore.Height() { + commit := env.BlockStore.LoadSeenCommit(height) return ctypes.NewResultCommit(&header, commit, false), nil } // Return the canonical commit (comes from the block at height+1) - commit := GetEnvironment().BlockStore.LoadBlockCommit(height) + commit := env.BlockStore.LoadBlockCommit(height) return ctypes.NewResultCommit(&header, commit, true), nil } @@ -161,6 +164,7 @@ func generateHeightsList(beginBlock uint64, endBlock uint64) []int64 { // validateDataCommitmentRange runs basic checks on the asc sorted list of heights // that will be used subsequently in generating data commitments over the defined set of heights. func validateDataCommitmentRange(beginBlock uint64, endBlock uint64) error { + env := GetEnvironment() heightsRange := endBlock - beginBlock + 1 if heightsRange > uint64(consts.DataCommitmentBlocksLimit) { return fmt.Errorf("the query exceeds the limit of allowed blocks %d", consts.DataCommitmentBlocksLimit) @@ -171,14 +175,14 @@ func validateDataCommitmentRange(beginBlock uint64, endBlock uint64) error { if beginBlock > endBlock { return fmt.Errorf("end block is smaller than begin block") } - if endBlock > uint64(GetEnvironment().BlockStore.Height()) { + if endBlock > uint64(env.BlockStore.Height()) { return fmt.Errorf( "end block %d is higher than current chain height %d", endBlock, - GetEnvironment().BlockStore.Height(), + env.BlockStore.Height(), ) } - has, err := GetEnvironment().BlockIndexer.Has(int64(endBlock)) + has, err := env.BlockIndexer.Has(int64(endBlock)) if err != nil { return err } @@ -209,12 +213,13 @@ func hashDataRoots(blocks []*ctypes.ResultBlock) []byte { // getBlock(h).Txs[5] // More: https://docs.tendermint.com/master/rpc/#/Info/block_results func BlockResults(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultBlockResults, error) { - height, err := getHeight(GetEnvironment().BlockStore.Height(), heightPtr) + env := GetEnvironment() + height, err := getHeight(env.BlockStore.Height(), heightPtr) if err != nil { return nil, err } - results, err := GetEnvironment().StateStore.LoadABCIResponses(height) + results, err := env.StateStore.LoadABCIResponses(height) if err != nil { return nil, err } @@ -268,8 +273,9 @@ func BlockSearch( // heightsByQuery returns a list of heights corresponding to the provided query. func heightsByQuery(ctx *rpctypes.Context, query string) ([]int64, error) { + env := GetEnvironment() // skip if block indexing is disabled - if _, ok := GetEnvironment().BlockIndexer.(*blockidxnull.BlockerIndexer); ok { + if _, ok := env.BlockIndexer.(*blockidxnull.BlockerIndexer); ok { return nil, errors.New("block indexing is disabled") } @@ -278,7 +284,7 @@ func heightsByQuery(ctx *rpctypes.Context, query string) ([]int64, error) { return nil, err } - results, err := GetEnvironment().BlockIndexer.Search(ctx.Context(), q) + results, err := env.BlockIndexer.Search(ctx.Context(), q) return results, err } @@ -300,11 +306,12 @@ func sortBlocks(results []int64, orderBy string) error { // fetchBlocks takes a list of block heights and fetches them. func fetchBlocks(results []int64, pageSize int, skipCount int) []*ctypes.ResultBlock { + env := GetEnvironment() apiResults := make([]*ctypes.ResultBlock, 0, pageSize) for i := skipCount; i < skipCount+pageSize; i++ { - block := GetEnvironment().BlockStore.LoadBlock(results[i]) + block := env.BlockStore.LoadBlock(results[i]) if block != nil { - blockMeta := GetEnvironment().BlockStore.LoadBlockMeta(block.Height) + blockMeta := env.BlockStore.LoadBlockMeta(block.Height) if blockMeta != nil { apiResults = append(apiResults, &ctypes.ResultBlock{ Block: block, diff --git a/rpc/core/env.go b/rpc/core/env.go index 506c26b350..e945f65691 100644 --- a/rpc/core/env.go +++ b/rpc/core/env.go @@ -212,9 +212,10 @@ func getHeight(latestHeight int64, heightPtr *int64) (int64, error) { } func latestUncommittedHeight() int64 { - nodeIsSyncing := GetEnvironment().ConsensusReactor.WaitSync() + env := GetEnvironment() + nodeIsSyncing := env.ConsensusReactor.WaitSync() if nodeIsSyncing { - return GetEnvironment().BlockStore.Height() + return env.BlockStore.Height() } - return GetEnvironment().BlockStore.Height() + 1 + return env.BlockStore.Height() + 1 } diff --git a/rpc/core/events.go b/rpc/core/events.go index 0a32068856..91c7e62a44 100644 --- a/rpc/core/events.go +++ b/rpc/core/events.go @@ -22,16 +22,17 @@ const ( // More: https://docs.tendermint.com/master/rpc/#/Websocket/subscribe func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, error) { addr := ctx.RemoteAddr() + env := GetEnvironment() - if GetEnvironment().EventBus.NumClients() >= GetEnvironment().Config.MaxSubscriptionClients { - return nil, fmt.Errorf("max_subscription_clients %d reached", GetEnvironment().Config.MaxSubscriptionClients) - } else if GetEnvironment().EventBus.NumClientSubscriptions(addr) >= GetEnvironment().Config.MaxSubscriptionsPerClient { - return nil, fmt.Errorf("max_subscriptions_per_client %d reached", GetEnvironment().Config.MaxSubscriptionsPerClient) + if env.EventBus.NumClients() >= env.Config.MaxSubscriptionClients { + return nil, fmt.Errorf("max_subscription_clients %d reached", env.Config.MaxSubscriptionClients) + } else if env.EventBus.NumClientSubscriptions(addr) >= env.Config.MaxSubscriptionsPerClient { + return nil, fmt.Errorf("max_subscriptions_per_client %d reached", env.Config.MaxSubscriptionsPerClient) } else if len(query) > maxQueryLength { return nil, errors.New("maximum query length exceeded") } - GetEnvironment().Logger.Info("Subscribe to query", "remote", addr, "query", query) + env.Logger.Info("Subscribe to query", "remote", addr, "query", query) q, err := tmquery.New(query) if err != nil { @@ -41,7 +42,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er subCtx, cancel := context.WithTimeout(ctx.Context(), SubscribeTimeout) defer cancel() - sub, err := GetEnvironment().EventBus.Subscribe(subCtx, addr, q, GetEnvironment().Config.SubscriptionBufferSize) + sub, err := env.EventBus.Subscribe(subCtx, addr, q, env.Config.SubscriptionBufferSize) if err != nil { return nil, err } @@ -49,7 +50,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er return nil, fmt.Errorf("env.EventBus.Subscribe() returned nil") } - closeIfSlow := GetEnvironment().Config.CloseOnSlowClient + closeIfSlow := env.Config.CloseOnSlowClient // Capture the current ID, since it can change in the future. subscriptionID := ctx.JSONReq.ID @@ -64,7 +65,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er writeCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() if err := ctx.WSConn.WriteRPCResponse(writeCtx, resp); err != nil { - GetEnvironment().Logger.Info("Can't write response (slow client)", + env.Logger.Info("Can't write response (slow client)", "to", addr, "subscriptionID", subscriptionID, "err", err) if closeIfSlow { @@ -73,7 +74,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er resp = rpctypes.RPCServerError(subscriptionID, err) ) if !ctx.WSConn.TryWriteRPCResponse(resp) { - GetEnvironment().Logger.Info("Can't write response (slow client)", + env.Logger.Info("Can't write response (slow client)", "to", addr, "subscriptionID", subscriptionID, "err", err) } return @@ -92,7 +93,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er resp = rpctypes.RPCServerError(subscriptionID, err) ) if !ctx.WSConn.TryWriteRPCResponse(resp) { - GetEnvironment().Logger.Info("Can't write response (slow client)", + env.Logger.Info("Can't write response (slow client)", "to", addr, "subscriptionID", subscriptionID, "err", err) } } @@ -108,12 +109,13 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er // More: https://docs.tendermint.com/master/rpc/#/Websocket/unsubscribe func Unsubscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultUnsubscribe, error) { addr := ctx.RemoteAddr() - GetEnvironment().Logger.Info("Unsubscribe from query", "remote", addr, "query", query) + env := GetEnvironment() + env.Logger.Info("Unsubscribe from query", "remote", addr, "query", query) q, err := tmquery.New(query) if err != nil { return nil, fmt.Errorf("failed to parse query: %w", err) } - err = GetEnvironment().EventBus.Unsubscribe(context.Background(), addr, q) + err = env.EventBus.Unsubscribe(context.Background(), addr, q) if err != nil { return nil, err } @@ -124,8 +126,9 @@ func Unsubscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultUnsubscribe // More: https://docs.tendermint.com/master/rpc/#/Websocket/unsubscribe_all func UnsubscribeAll(ctx *rpctypes.Context) (*ctypes.ResultUnsubscribe, error) { addr := ctx.RemoteAddr() - GetEnvironment().Logger.Info("Unsubscribe from all", "remote", addr) - err := GetEnvironment().EventBus.UnsubscribeAll(context.Background(), addr) + env := GetEnvironment() + env.Logger.Info("Unsubscribe from all", "remote", addr) + err := env.EventBus.UnsubscribeAll(context.Background(), addr) if err != nil { return nil, err } diff --git a/rpc/core/mempool.go b/rpc/core/mempool.go index 8288c1f215..230356c14a 100644 --- a/rpc/core/mempool.go +++ b/rpc/core/mempool.go @@ -63,40 +63,41 @@ func BroadcastTxSync(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcas // More: https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit func BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { subscriber := ctx.RemoteAddr() + env := GetEnvironment() //nolint:lll - if GetEnvironment().EventBus.NumClients() >= GetEnvironment().Config.MaxSubscriptionClients { - return nil, fmt.Errorf("max_subscription_clients %d reached", GetEnvironment().Config.MaxSubscriptionClients) - } else if GetEnvironment().EventBus.NumClientSubscriptions(subscriber) >= GetEnvironment().Config.MaxSubscriptionsPerClient { - return nil, fmt.Errorf("max_subscriptions_per_client %d reached", GetEnvironment().Config.MaxSubscriptionsPerClient) + if env.EventBus.NumClients() >= env.Config.MaxSubscriptionClients { + return nil, fmt.Errorf("max_subscription_clients %d reached", env.Config.MaxSubscriptionClients) + } else if env.EventBus.NumClientSubscriptions(subscriber) >= env.Config.MaxSubscriptionsPerClient { + return nil, fmt.Errorf("max_subscriptions_per_client %d reached", env.Config.MaxSubscriptionsPerClient) } // Subscribe to tx being committed in block. subCtx, cancel := context.WithTimeout(ctx.Context(), SubscribeTimeout) defer cancel() q := types.EventQueryTxFor(tx) - deliverTxSub, err := GetEnvironment().EventBus.Subscribe(subCtx, subscriber, q) + deliverTxSub, err := env.EventBus.Subscribe(subCtx, subscriber, q) if err != nil { err = fmt.Errorf("failed to subscribe to tx: %w", err) - GetEnvironment().Logger.Error("Error on broadcast_tx_commit", "err", err) + env.Logger.Error("Error on broadcast_tx_commit", "err", err) return nil, err } defer func() { - if err := GetEnvironment().EventBus.Unsubscribe(context.Background(), subscriber, q); err != nil { - GetEnvironment().Logger.Error("Error unsubscribing from eventBus", "err", err) + if err := env.EventBus.Unsubscribe(context.Background(), subscriber, q); err != nil { + env.Logger.Error("Error unsubscribing from eventBus", "err", err) } }() // Broadcast tx and wait for CheckTx result checkTxResCh := make(chan *abci.Response, 1) - err = GetEnvironment().Mempool.CheckTx(tx, func(res *abci.Response) { + err = env.Mempool.CheckTx(tx, func(res *abci.Response) { select { case <-ctx.Context().Done(): case checkTxResCh <- res: } }, mempl.TxInfo{}) if err != nil { - GetEnvironment().Logger.Error("Error on broadcastTxCommit", "err", err) + env.Logger.Error("Error on broadcastTxCommit", "err", err) return nil, fmt.Errorf("error on broadcastTxCommit: %v", err) } select { @@ -130,15 +131,15 @@ func BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadc reason = deliverTxSub.Err().Error() } err = fmt.Errorf("deliverTxSub was cancelled (reason: %s)", reason) - GetEnvironment().Logger.Error("Error on broadcastTxCommit", "err", err) + env.Logger.Error("Error on broadcastTxCommit", "err", err) return &ctypes.ResultBroadcastTxCommit{ CheckTx: *checkTxRes, DeliverTx: abci.ResponseDeliverTx{}, Hash: tx.Hash(), }, err - case <-time.After(GetEnvironment().Config.TimeoutBroadcastTxCommit): + case <-time.After(env.Config.TimeoutBroadcastTxCommit): err = errors.New("timed out waiting for tx to be included in a block") - GetEnvironment().Logger.Error("Error on broadcastTxCommit", "err", err) + env.Logger.Error("Error on broadcastTxCommit", "err", err) return &ctypes.ResultBroadcastTxCommit{ CheckTx: *checkTxRes, DeliverTx: abci.ResponseDeliverTx{}, @@ -154,22 +155,24 @@ func BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadc func UnconfirmedTxs(ctx *rpctypes.Context, limitPtr *int) (*ctypes.ResultUnconfirmedTxs, error) { // reuse per_page validator limit := validatePerPage(limitPtr) + env := GetEnvironment() - txs := GetEnvironment().Mempool.ReapMaxTxs(limit) + txs := env.Mempool.ReapMaxTxs(limit) return &ctypes.ResultUnconfirmedTxs{ Count: len(txs), - Total: GetEnvironment().Mempool.Size(), - TotalBytes: GetEnvironment().Mempool.SizeBytes(), + Total: env.Mempool.Size(), + TotalBytes: env.Mempool.SizeBytes(), Txs: txs}, nil } // NumUnconfirmedTxs gets number of unconfirmed transactions. // More: https://docs.tendermint.com/master/rpc/#/Info/num_unconfirmed_txs func NumUnconfirmedTxs(ctx *rpctypes.Context) (*ctypes.ResultUnconfirmedTxs, error) { + env := GetEnvironment() return &ctypes.ResultUnconfirmedTxs{ - Count: GetEnvironment().Mempool.Size(), - Total: GetEnvironment().Mempool.Size(), - TotalBytes: GetEnvironment().Mempool.SizeBytes()}, nil + Count: env.Mempool.Size(), + Total: env.Mempool.Size(), + TotalBytes: env.Mempool.SizeBytes()}, nil } // CheckTx checks the transaction without executing it. The transaction won't diff --git a/rpc/core/net.go b/rpc/core/net.go index 6556f81814..fd80d63877 100644 --- a/rpc/core/net.go +++ b/rpc/core/net.go @@ -13,7 +13,8 @@ import ( // NetInfo returns network info. // More: https://docs.tendermint.com/master/rpc/#/Info/net_info func NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) { - peersList := GetEnvironment().P2PPeers.Peers().List() + env := GetEnvironment() + peersList := env.P2PPeers.Peers().List() peers := make([]ctypes.Peer, 0, len(peersList)) for _, peer := range peersList { nodeInfo, ok := peer.NodeInfo().(p2p.DefaultNodeInfo) @@ -31,8 +32,8 @@ func NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) { // PRO: useful info // CON: privacy return &ctypes.ResultNetInfo{ - Listening: GetEnvironment().P2PTransport.IsListening(), - Listeners: GetEnvironment().P2PTransport.Listeners(), + Listening: env.P2PTransport.IsListening(), + Listeners: env.P2PTransport.Listeners(), NPeers: len(peers), Peers: peers, }, nil @@ -43,8 +44,9 @@ func UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (*ctypes.ResultDialS if len(seeds) == 0 { return &ctypes.ResultDialSeeds{}, errors.New("no seeds provided") } - GetEnvironment().Logger.Info("DialSeeds", "seeds", seeds) - if err := GetEnvironment().P2PPeers.DialPeersAsync(seeds); err != nil { + env := GetEnvironment() + env.Logger.Info("DialSeeds", "seeds", seeds) + if err := env.P2PPeers.DialPeersAsync(seeds); err != nil { return &ctypes.ResultDialSeeds{}, err } return &ctypes.ResultDialSeeds{Log: "Dialing seeds in progress. See /net_info for details"}, nil @@ -63,28 +65,29 @@ func UnsafeDialPeers(ctx *rpctypes.Context, peers []string, persistent, uncondit return &ctypes.ResultDialPeers{}, err } - GetEnvironment().Logger.Info("DialPeers", "peers", peers, "persistent", + env := GetEnvironment() + env.Logger.Info("DialPeers", "peers", peers, "persistent", persistent, "unconditional", unconditional, "private", private) if persistent { - if err := GetEnvironment().P2PPeers.AddPersistentPeers(peers); err != nil { + if err := env.P2PPeers.AddPersistentPeers(peers); err != nil { return &ctypes.ResultDialPeers{}, err } } if private { - if err := GetEnvironment().P2PPeers.AddPrivatePeerIDs(ids); err != nil { + if err := env.P2PPeers.AddPrivatePeerIDs(ids); err != nil { return &ctypes.ResultDialPeers{}, err } } if unconditional { - if err := GetEnvironment().P2PPeers.AddUnconditionalPeerIDs(ids); err != nil { + if err := env.P2PPeers.AddUnconditionalPeerIDs(ids); err != nil { return &ctypes.ResultDialPeers{}, err } } - if err := GetEnvironment().P2PPeers.DialPeersAsync(peers); err != nil { + if err := env.P2PPeers.DialPeersAsync(peers); err != nil { return &ctypes.ResultDialPeers{}, err } @@ -94,32 +97,34 @@ func UnsafeDialPeers(ctx *rpctypes.Context, peers []string, persistent, uncondit // Genesis returns genesis file. // More: https://docs.tendermint.com/master/rpc/#/Info/genesis func Genesis(ctx *rpctypes.Context) (*ctypes.ResultGenesis, error) { - if len(GetEnvironment().genChunks) > 1 { + env := GetEnvironment() + if len(env.genChunks) > 1 { return nil, errors.New("genesis response is large, please use the genesis_chunked API instead") } - return &ctypes.ResultGenesis{Genesis: GetEnvironment().GenDoc}, nil + return &ctypes.ResultGenesis{Genesis: env.GenDoc}, nil } func GenesisChunked(ctx *rpctypes.Context, chunk uint) (*ctypes.ResultGenesisChunk, error) { - if GetEnvironment().genChunks == nil { + env := GetEnvironment() + if env.genChunks == nil { return nil, fmt.Errorf("service configuration error, genesis chunks are not initialized") } - if len(GetEnvironment().genChunks) == 0 { + if len(env.genChunks) == 0 { return nil, fmt.Errorf("service configuration error, there are no chunks") } id := int(chunk) - if id > len(GetEnvironment().genChunks)-1 { - return nil, fmt.Errorf("there are %d chunks, %d is invalid", len(GetEnvironment().genChunks)-1, id) + if id > len(env.genChunks)-1 { + return nil, fmt.Errorf("there are %d chunks, %d is invalid", len(env.genChunks)-1, id) } return &ctypes.ResultGenesisChunk{ - TotalChunks: len(GetEnvironment().genChunks), + TotalChunks: len(env.genChunks), ChunkNumber: id, - Data: GetEnvironment().genChunks[id], + Data: env.genChunks[id], }, nil } diff --git a/rpc/core/net_test.go b/rpc/core/net_test.go index 30341c74f4..e44d5cf5b6 100644 --- a/rpc/core/net_test.go +++ b/rpc/core/net_test.go @@ -22,9 +22,10 @@ func TestUnsafeDialSeeds(t *testing.T) { t.Error(err) } }) + env := GetEnvironment() - GetEnvironment().Logger = log.TestingLogger() - GetEnvironment().P2PPeers = sw + env.Logger = log.TestingLogger() + env.P2PPeers = sw testCases := []struct { seeds []string @@ -62,8 +63,9 @@ func TestUnsafeDialPeers(t *testing.T) { } }) - GetEnvironment().Logger = log.TestingLogger() - GetEnvironment().P2PPeers = sw + env := GetEnvironment() + env.Logger = log.TestingLogger() + env.P2PPeers = sw testCases := []struct { peers []string diff --git a/rpc/core/status.go b/rpc/core/status.go index 89012b83e8..37a07b0238 100644 --- a/rpc/core/status.go +++ b/rpc/core/status.go @@ -21,7 +21,8 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { earliestBlockTimeNano int64 ) - if earliestBlockMeta := GetEnvironment().BlockStore.LoadBaseMeta(); earliestBlockMeta != nil { + env := GetEnvironment() + if earliestBlockMeta := env.BlockStore.LoadBaseMeta(); earliestBlockMeta != nil { earliestBlockHeight = earliestBlockMeta.Header.Height earliestAppHash = earliestBlockMeta.Header.AppHash earliestBlockHash = earliestBlockMeta.BlockID.Hash @@ -33,11 +34,11 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { latestAppHash tmbytes.HexBytes latestBlockTimeNano int64 - latestHeight = GetEnvironment().BlockStore.Height() + latestHeight = env.BlockStore.Height() ) if latestHeight != 0 { - if latestBlockMeta := GetEnvironment().BlockStore.LoadBlockMeta(latestHeight); latestBlockMeta != nil { + if latestBlockMeta := env.BlockStore.LoadBlockMeta(latestHeight); latestBlockMeta != nil { latestBlockHash = latestBlockMeta.BlockID.Hash latestAppHash = latestBlockMeta.Header.AppHash latestBlockTimeNano = latestBlockMeta.Header.Time.UnixNano() @@ -52,7 +53,7 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { } result := &ctypes.ResultStatus{ - NodeInfo: GetEnvironment().P2PTransport.NodeInfo().(p2p.DefaultNodeInfo), + NodeInfo: env.P2PTransport.NodeInfo().(p2p.DefaultNodeInfo), SyncInfo: ctypes.SyncInfo{ LatestBlockHash: latestBlockHash, LatestAppHash: latestAppHash, @@ -62,11 +63,11 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { EarliestAppHash: earliestAppHash, EarliestBlockHeight: earliestBlockHeight, EarliestBlockTime: time.Unix(0, earliestBlockTimeNano), - CatchingUp: GetEnvironment().ConsensusReactor.WaitSync(), + CatchingUp: env.ConsensusReactor.WaitSync(), }, ValidatorInfo: ctypes.ValidatorInfo{ - Address: GetEnvironment().PubKey.Address(), - PubKey: GetEnvironment().PubKey, + Address: env.PubKey.Address(), + PubKey: env.PubKey, VotingPower: votingPower, }, } @@ -75,11 +76,12 @@ func Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { } func validatorAtHeight(h int64) *types.Validator { - vals, err := GetEnvironment().StateStore.LoadValidators(h) + env := GetEnvironment() + vals, err := env.StateStore.LoadValidators(h) if err != nil { return nil } - privValAddress := GetEnvironment().PubKey.Address() + privValAddress := env.PubKey.Address() _, val := vals.GetByAddress(privValAddress) return val } diff --git a/rpc/core/tx.go b/rpc/core/tx.go index c802010e65..9016916db2 100644 --- a/rpc/core/tx.go +++ b/rpc/core/tx.go @@ -22,12 +22,13 @@ import ( // place. // More: https://docs.tendermint.com/v0.34/rpc/#/Info/tx func Tx(ctx *rpctypes.Context, hash []byte, prove bool) (*ctypes.ResultTx, error) { + env := GetEnvironment() // if index is disabled, return error - if _, ok := GetEnvironment().TxIndexer.(*null.TxIndex); ok { + if _, ok := env.TxIndexer.(*null.TxIndex); ok { return nil, fmt.Errorf("transaction indexing is disabled") } - r, err := GetEnvironment().TxIndexer.Get(hash) + r, err := env.TxIndexer.Get(hash) if err != nil { return nil, err } @@ -70,8 +71,9 @@ func TxSearch( orderBy string, ) (*ctypes.ResultTxSearch, error) { + env := GetEnvironment() // if index is disabled, return error - if _, ok := GetEnvironment().TxIndexer.(*null.TxIndex); ok { + if _, ok := env.TxIndexer.(*null.TxIndex); ok { return nil, errors.New("transaction indexing is disabled") } else if len(query) > maxQueryLength { return nil, errors.New("maximum query length exceeded") @@ -82,7 +84,7 @@ func TxSearch( return nil, err } - results, err := GetEnvironment().TxIndexer.Search(ctx.Context(), q) + results, err := env.TxIndexer.Search(ctx.Context(), q) if err != nil { return nil, err } @@ -149,11 +151,12 @@ func proveTx(height int64, index uint32) (types.TxProof, error) { pTxProof tmproto.TxProof txProof types.TxProof ) - rawBlock, err := loadRawBlock(GetEnvironment().BlockStore, height) + env := GetEnvironment() + rawBlock, err := loadRawBlock(env.BlockStore, height) if err != nil { return txProof, err } - res, err := GetEnvironment().ProxyAppQuery.QuerySync(abcitypes.RequestQuery{ + res, err := env.ProxyAppQuery.QuerySync(abcitypes.RequestQuery{ Data: rawBlock, Path: fmt.Sprintf(consts.TxInclusionProofQueryPath, index), }) From 412d50be22715cc5c4cd9873d04d1e6c222fe5a2 Mon Sep 17 00:00:00 2001 From: Rootul Patel Date: Mon, 14 Nov 2022 11:58:10 -0500 Subject: [PATCH 6/7] remove //nolint:lll --- rpc/core/mempool.go | 1 - 1 file changed, 1 deletion(-) diff --git a/rpc/core/mempool.go b/rpc/core/mempool.go index 230356c14a..276fa4f53e 100644 --- a/rpc/core/mempool.go +++ b/rpc/core/mempool.go @@ -65,7 +65,6 @@ func BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadc subscriber := ctx.RemoteAddr() env := GetEnvironment() - //nolint:lll if env.EventBus.NumClients() >= env.Config.MaxSubscriptionClients { return nil, fmt.Errorf("max_subscription_clients %d reached", env.Config.MaxSubscriptionClients) } else if env.EventBus.NumClientSubscriptions(subscriber) >= env.Config.MaxSubscriptionsPerClient { From ebe58dc2523543d5a85e0fc2e7faecf071a1c2fd Mon Sep 17 00:00:00 2001 From: Rootul Patel Date: Mon, 14 Nov 2022 13:59:32 -0500 Subject: [PATCH 7/7] make proto-gen --- proto/tendermint/types/types.pb.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/proto/tendermint/types/types.pb.go b/proto/tendermint/types/types.pb.go index 6c6b8a3b88..912b98b5c0 100644 --- a/proto/tendermint/types/types.pb.go +++ b/proto/tendermint/types/types.pb.go @@ -780,7 +780,8 @@ func (m *EvidenceList) GetEvidence() []Evidence { return nil } -// Blob defines an indivisible chunk of data that is posted on chain. +// Blob defines a chunk of data that is attributed to a namespace and under +// usual circumstances, ends up published on-chain. type Blob struct { NamespaceId []byte `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`