- package core
-
- import (
- "context"
- "encoding/base64"
- "encoding/json"
- "fmt"
- "net"
- "net/http"
- "time"
-
- "github.com/rs/cors"
-
- abciclient "github.com/tendermint/tendermint/abci/client"
- "github.com/tendermint/tendermint/config"
- "github.com/tendermint/tendermint/crypto"
- "github.com/tendermint/tendermint/internal/blocksync"
- "github.com/tendermint/tendermint/internal/consensus"
- "github.com/tendermint/tendermint/internal/eventbus"
- "github.com/tendermint/tendermint/internal/eventlog"
- "github.com/tendermint/tendermint/internal/mempool"
- "github.com/tendermint/tendermint/internal/p2p"
- tmpubsub "github.com/tendermint/tendermint/internal/pubsub"
- "github.com/tendermint/tendermint/internal/pubsub/query"
- sm "github.com/tendermint/tendermint/internal/state"
- "github.com/tendermint/tendermint/internal/state/indexer"
- "github.com/tendermint/tendermint/internal/statesync"
- "github.com/tendermint/tendermint/libs/log"
- "github.com/tendermint/tendermint/libs/strings"
- "github.com/tendermint/tendermint/rpc/coretypes"
- rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server"
- "github.com/tendermint/tendermint/types"
- )
-
- const (
- // see README
- defaultPerPage = 30
- maxPerPage = 100
-
- // SubscribeTimeout is the maximum time we wait to subscribe for an event.
- // must be less than the server's write timeout (see rpcserver.DefaultConfig)
- SubscribeTimeout = 5 * time.Second
-
- // genesisChunkSize is the maximum size, in bytes, of each
- // chunk in the genesis structure for the chunked API
- genesisChunkSize = 16 * 1024 * 1024 // 16
- )
-
- //----------------------------------------------
- // These interfaces are used by RPC and must be thread safe
-
- type consensusState interface {
- GetState() sm.State
- GetValidators() (int64, []*types.Validator)
- GetLastHeight() int64
- GetRoundStateJSON() ([]byte, error)
- GetRoundStateSimpleJSON() ([]byte, error)
- }
-
- type peerManager interface {
- Peers() []types.NodeID
- Addresses(types.NodeID) []p2p.NodeAddress
- }
-
- //----------------------------------------------
- // Environment contains objects and interfaces used by the RPC. It is expected
- // to be setup once during startup.
- type Environment struct {
- // external, thread safe interfaces
- ProxyApp abciclient.Client
-
- // interfaces defined in types and above
- StateStore sm.Store
- BlockStore sm.BlockStore
- EvidencePool sm.EvidencePool
- ConsensusState consensusState
- ConsensusReactor *consensus.Reactor
- BlockSyncReactor *blocksync.Reactor
-
- IsListening bool
- Listeners []string
- NodeInfo types.NodeInfo
-
- // interfaces for new p2p interfaces
- PeerManager peerManager
-
- // objects
- PubKey crypto.PubKey
- GenDoc *types.GenesisDoc // cache the genesis structure
- EventSinks []indexer.EventSink
- EventBus *eventbus.EventBus // thread safe
- EventLog *eventlog.Log
- Mempool mempool.Mempool
- StateSyncMetricer statesync.Metricer
-
- Logger log.Logger
-
- Config config.RPCConfig
-
- // cache of chunked genesis data.
- genChunks []string
- }
-
- //----------------------------------------------
-
- func validatePage(pagePtr *int, perPage, totalCount int) (int, error) {
- // this can only happen if we haven't first run validatePerPage
- if perPage < 1 {
- panic(fmt.Errorf("%w (%d)", coretypes.ErrZeroOrNegativePerPage, perPage))
- }
-
- if pagePtr == nil { // no page parameter
- return 1, nil
- }
-
- pages := ((totalCount - 1) / perPage) + 1
- if pages == 0 {
- pages = 1 // one page (even if it's empty)
- }
- page := *pagePtr
- if page <= 0 || page > pages {
- return 1, fmt.Errorf("%w expected range: [1, %d], given %d", coretypes.ErrPageOutOfRange, pages, page)
- }
-
- return page, nil
- }
-
- func (env *Environment) validatePerPage(perPagePtr *int) int {
- if perPagePtr == nil { // no per_page parameter
- return defaultPerPage
- }
-
- perPage := *perPagePtr
- if perPage < 1 {
- return defaultPerPage
- // in unsafe mode there is no max on the page size but in safe mode
- // we cap it to maxPerPage
- } else if perPage > maxPerPage && !env.Config.Unsafe {
- return maxPerPage
- }
- return perPage
- }
-
- // InitGenesisChunks configures the environment and should be called on service
- // startup.
- func (env *Environment) InitGenesisChunks() error {
- if env.genChunks != nil {
- return nil
- }
-
- if env.GenDoc == nil {
- return nil
- }
-
- data, err := json.Marshal(env.GenDoc)
- if err != nil {
- return err
- }
-
- for i := 0; i < len(data); i += genesisChunkSize {
- end := i + genesisChunkSize
-
- if end > len(data) {
- end = len(data)
- }
-
- env.genChunks = append(env.genChunks, base64.StdEncoding.EncodeToString(data[i:end]))
- }
-
- return nil
- }
-
- func validateSkipCount(page, perPage int) int {
- skipCount := (page - 1) * perPage
- if skipCount < 0 {
- return 0
- }
-
- return skipCount
- }
-
- // latestHeight can be either latest committed or uncommitted (+1) height.
- func (env *Environment) getHeight(latestHeight int64, heightPtr *int64) (int64, error) {
- if heightPtr != nil {
- height := *heightPtr
- if height <= 0 {
- return 0, fmt.Errorf("%w (requested height: %d)", coretypes.ErrZeroOrNegativeHeight, height)
- }
- if height > latestHeight {
- return 0, fmt.Errorf("%w (requested height: %d, blockchain height: %d)",
- coretypes.ErrHeightExceedsChainHead, height, latestHeight)
- }
- base := env.BlockStore.Base()
- if height < base {
- return 0, fmt.Errorf("%w (requested height: %d, base height: %d)", coretypes.ErrHeightNotAvailable, height, base)
- }
- return height, nil
- }
- return latestHeight, nil
- }
-
- func (env *Environment) latestUncommittedHeight() int64 {
- if env.ConsensusReactor != nil {
- // consensus reactor can be nil in inspect mode.
-
- nodeIsSyncing := env.ConsensusReactor.WaitSync()
- if nodeIsSyncing {
- return env.BlockStore.Height()
- }
- }
- return env.BlockStore.Height() + 1
- }
-
- // StartService constructs and starts listeners for the RPC service
- // according to the config object, returning an error if the service
- // cannot be constructed or started. The listeners, which provide
- // access to the service, run until the context is canceled.
- func (env *Environment) StartService(ctx context.Context, conf *config.Config) ([]net.Listener, error) {
- if err := env.InitGenesisChunks(); err != nil {
- return nil, err
- }
-
- env.Listeners = []string{
- fmt.Sprintf("Listener(@%v)", conf.P2P.ExternalAddress),
- }
-
- listenAddrs := strings.SplitAndTrimEmpty(conf.RPC.ListenAddress, ",", " ")
- routes := NewRoutesMap(env, &RouteOptions{
- Unsafe: conf.RPC.Unsafe,
- })
-
- cfg := rpcserver.DefaultConfig()
- cfg.MaxBodyBytes = conf.RPC.MaxBodyBytes
- cfg.MaxHeaderBytes = conf.RPC.MaxHeaderBytes
- cfg.MaxOpenConnections = conf.RPC.MaxOpenConnections
- // If necessary adjust global WriteTimeout to ensure it's greater than
- // TimeoutBroadcastTxCommit.
- // See https://github.com/tendermint/tendermint/issues/3435
- if cfg.WriteTimeout <= conf.RPC.TimeoutBroadcastTxCommit {
- cfg.WriteTimeout = conf.RPC.TimeoutBroadcastTxCommit + 1*time.Second
- }
-
- // If the event log is enabled, subscribe to all events published to the
- // event bus, and forward them to the event log.
- if lg := env.EventLog; lg != nil {
- // TODO(creachadair): This is kind of a hack, ideally we'd share the
- // observer with the indexer, but it's tricky to plumb them together.
- // For now, use a "normal" subscription with a big buffer allowance.
- // The event log should always be able to keep up.
- const subscriberID = "event-log-subscriber"
- sub, err := env.EventBus.SubscribeWithArgs(ctx, tmpubsub.SubscribeArgs{
- ClientID: subscriberID,
- Query: query.All,
- Limit: 1 << 16, // essentially "no limit"
- })
- if err != nil {
- return nil, fmt.Errorf("event log subscribe: %w", err)
- }
- go func() {
- // N.B. Use background for unsubscribe, ctx is already terminated.
- defer env.EventBus.UnsubscribeAll(context.Background(), subscriberID) // nolint:errcheck
- for {
- msg, err := sub.Next(ctx)
- if err != nil {
- env.Logger.Error("Subscription terminated", "err", err)
- return
- }
- etype, ok := eventlog.FindType(msg.Events())
- if ok {
- _ = lg.Add(etype, msg.Data())
- }
- }
- }()
-
- env.Logger.Info("Event log subscription enabled")
- }
-
- // We may expose the RPC over both TCP and a Unix-domain socket.
- listeners := make([]net.Listener, len(listenAddrs))
- for i, listenAddr := range listenAddrs {
- mux := http.NewServeMux()
- rpcLogger := env.Logger.With("module", "rpc-server")
- rpcserver.RegisterRPCFuncs(mux, routes, rpcLogger)
-
- if conf.RPC.ExperimentalDisableWebsocket {
- rpcLogger.Info("Disabling websocket endpoints (experimental-disable-websocket=true)")
- } else {
- rpcLogger.Info("WARNING: Websocket RPC access is deprecated and will be removed " +
- "in Tendermint v0.37. See https://tinyurl.com/adr075 for more information.")
- wmLogger := rpcLogger.With("protocol", "websocket")
- wm := rpcserver.NewWebsocketManager(wmLogger, routes,
- rpcserver.OnDisconnect(func(remoteAddr string) {
- err := env.EventBus.UnsubscribeAll(context.Background(), remoteAddr)
- if err != nil && err != tmpubsub.ErrSubscriptionNotFound {
- wmLogger.Error("Failed to unsubscribe addr from events", "addr", remoteAddr, "err", err)
- }
- }),
- rpcserver.ReadLimit(cfg.MaxBodyBytes),
- )
- mux.HandleFunc("/websocket", wm.WebsocketHandler)
- }
-
- listener, err := rpcserver.Listen(
- listenAddr,
- cfg.MaxOpenConnections,
- )
- if err != nil {
- return nil, err
- }
-
- var rootHandler http.Handler = mux
- if conf.RPC.IsCorsEnabled() {
- corsMiddleware := cors.New(cors.Options{
- AllowedOrigins: conf.RPC.CORSAllowedOrigins,
- AllowedMethods: conf.RPC.CORSAllowedMethods,
- AllowedHeaders: conf.RPC.CORSAllowedHeaders,
- })
- rootHandler = corsMiddleware.Handler(mux)
- }
- if conf.RPC.IsTLSEnabled() {
- go func() {
- if err := rpcserver.ServeTLS(
- ctx,
- listener,
- rootHandler,
- conf.RPC.CertFile(),
- conf.RPC.KeyFile(),
- rpcLogger,
- cfg,
- ); err != nil {
- env.Logger.Error("error serving server with TLS", "err", err)
- }
- }()
- } else {
- go func() {
- if err := rpcserver.Serve(
- ctx,
- listener,
- rootHandler,
- rpcLogger,
- cfg,
- ); err != nil {
- env.Logger.Error("error serving server", "err", err)
- }
- }()
- }
-
- listeners[i] = listener
- }
-
- return listeners, nil
-
- }
|