light: rename lite2 to light & remove lite (#4946)

This PR removes lite & renames lite2 to light throughout the repo Signed-off-by: Marko Baricevic <marbar3778@yahoo.com> Closes: #4944
2026-01-07 13:55:17 +00:00 · 2020-06-03 12:13:42 +02:00
parent 395d58c27c
commit c2578e2262
63 changed files with 204 additions and 3275 deletions
--- a/light/proxy/proxy.go
+++ b/light/proxy/proxy.go
@@ -0,0 +1,104 @@
+package proxy
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+
+	amino "github.com/tendermint/go-amino"
+
+	"github.com/tendermint/tendermint/libs/log"
+	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
+	lrpc "github.com/tendermint/tendermint/light/rpc"
+	ctypes "github.com/tendermint/tendermint/rpc/core/types"
+	rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server"
+)
+
+// A Proxy defines parameters for running an HTTP server proxy.
+type Proxy struct {
+	Addr     string // TCP address to listen on, ":http" if empty
+	Config   *rpcserver.Config
+	Codec    *amino.Codec
+	Client   *lrpc.Client
+	Logger   log.Logger
+	Listener net.Listener
+}
+
+// ListenAndServe configures the rpcserver.WebsocketManager, sets up the RPC
+// routes to proxy via Client, and starts up an HTTP server on the TCP network
+// address p.Addr.
+// See http#Server#ListenAndServe.
+func (p *Proxy) ListenAndServe() error {
+	listener, mux, err := p.listen()
+	if err != nil {
+		return err
+	}
+	p.Listener = listener
+
+	return rpcserver.Serve(
+		listener,
+		mux,
+		p.Logger,
+		p.Config,
+	)
+}
+
+// ListenAndServeTLS acts identically to ListenAndServe, except that it expects
+// HTTPS connections.
+// See http#Server#ListenAndServeTLS.
+func (p *Proxy) ListenAndServeTLS(certFile, keyFile string) error {
+	listener, mux, err := p.listen()
+	if err != nil {
+		return err
+	}
+	p.Listener = listener
+
+	return rpcserver.ServeTLS(
+		listener,
+		mux,
+		certFile,
+		keyFile,
+		p.Logger,
+		p.Config,
+	)
+}
+
+func (p *Proxy) listen() (net.Listener, *http.ServeMux, error) {
+	ctypes.RegisterAmino(p.Codec)
+
+	mux := http.NewServeMux()
+
+	// 1) Register regular routes.
+	r := RPCRoutes(p.Client)
+	rpcserver.RegisterRPCFuncs(mux, r, p.Codec, p.Logger)
+
+	// 2) Allow websocket connections.
+	wmLogger := p.Logger.With("protocol", "websocket")
+	wm := rpcserver.NewWebsocketManager(r, p.Codec,
+		rpcserver.OnDisconnect(func(remoteAddr string) {
+			err := p.Client.UnsubscribeAll(context.Background(), remoteAddr)
+			if err != nil && err != tmpubsub.ErrSubscriptionNotFound {
+				wmLogger.Error("Failed to unsubscribe addr from events", "addr", remoteAddr, "err", err)
+			}
+		}),
+		rpcserver.ReadLimit(p.Config.MaxBodyBytes),
+	)
+	wm.SetLogger(wmLogger)
+	mux.HandleFunc("/websocket", wm.WebsocketHandler)
+
+	// 3) Start a client.
+	if !p.Client.IsRunning() {
+		if err := p.Client.Start(); err != nil {
+			return nil, mux, fmt.Errorf("can't start client: %w", err)
+		}
+	}
+
+	// 4) Start listening for new connections.
+	listener, err := rpcserver.Listen(p.Addr, p.Config)
+	if err != nil {
+		return nil, mux, err
+	}
+
+	return listener, mux, nil
+}
--- a/light/proxy/routes.go
+++ b/light/proxy/routes.go
@@ -0,0 +1,239 @@
+package proxy
+
+import (
+	"github.com/tendermint/tendermint/libs/bytes"
+	lrpc "github.com/tendermint/tendermint/light/rpc"
+	ctypes "github.com/tendermint/tendermint/rpc/core/types"
+	rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server"
+	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
+	"github.com/tendermint/tendermint/types"
+)
+
+func RPCRoutes(c *lrpc.Client) map[string]*rpcserver.RPCFunc {
+	return map[string]*rpcserver.RPCFunc{
+		// Subscribe/unsubscribe are reserved for websocket events.
+		"subscribe":       rpcserver.NewWSRPCFunc(c.SubscribeWS, "query"),
+		"unsubscribe":     rpcserver.NewWSRPCFunc(c.UnsubscribeWS, "query"),
+		"unsubscribe_all": rpcserver.NewWSRPCFunc(c.UnsubscribeAllWS, ""),
+
+		// info API
+		"health":               rpcserver.NewRPCFunc(makeHealthFunc(c), ""),
+		"status":               rpcserver.NewRPCFunc(makeStatusFunc(c), ""),
+		"net_info":             rpcserver.NewRPCFunc(makeNetInfoFunc(c), ""),
+		"blockchain":           rpcserver.NewRPCFunc(makeBlockchainInfoFunc(c), "minHeight,maxHeight"),
+		"genesis":              rpcserver.NewRPCFunc(makeGenesisFunc(c), ""),
+		"block":                rpcserver.NewRPCFunc(makeBlockFunc(c), "height"),
+		"block_by_hash":        rpcserver.NewRPCFunc(makeBlockByHashFunc(c), "hash"),
+		"block_results":        rpcserver.NewRPCFunc(makeBlockResultsFunc(c), "height"),
+		"commit":               rpcserver.NewRPCFunc(makeCommitFunc(c), "height"),
+		"tx":                   rpcserver.NewRPCFunc(makeTxFunc(c), "hash,prove"),
+		"tx_search":            rpcserver.NewRPCFunc(makeTxSearchFunc(c), "query,prove,page,per_page,order_by"),
+		"validators":           rpcserver.NewRPCFunc(makeValidatorsFunc(c), "height,page,per_page"),
+		"dump_consensus_state": rpcserver.NewRPCFunc(makeDumpConsensusStateFunc(c), ""),
+		"consensus_state":      rpcserver.NewRPCFunc(makeConsensusStateFunc(c), ""),
+		"consensus_params":     rpcserver.NewRPCFunc(makeConsensusParamsFunc(c), "height"),
+		"unconfirmed_txs":      rpcserver.NewRPCFunc(makeUnconfirmedTxsFunc(c), "limit"),
+		"num_unconfirmed_txs":  rpcserver.NewRPCFunc(makeNumUnconfirmedTxsFunc(c), ""),
+
+		// tx broadcast API
+		"broadcast_tx_commit": rpcserver.NewRPCFunc(makeBroadcastTxCommitFunc(c), "tx"),
+		"broadcast_tx_sync":   rpcserver.NewRPCFunc(makeBroadcastTxSyncFunc(c), "tx"),
+		"broadcast_tx_async":  rpcserver.NewRPCFunc(makeBroadcastTxAsyncFunc(c), "tx"),
+
+		// abci API
+		"abci_query": rpcserver.NewRPCFunc(makeABCIQueryFunc(c), "path,data,height,prove"),
+		"abci_info":  rpcserver.NewRPCFunc(makeABCIInfoFunc(c), ""),
+
+		// evidence API
+		"broadcast_evidence": rpcserver.NewRPCFunc(makeBroadcastEvidenceFunc(c), "evidence"),
+	}
+}
+
+type rpcHealthFunc func(ctx *rpctypes.Context) (*ctypes.ResultHealth, error)
+
+func makeHealthFunc(c *lrpc.Client) rpcHealthFunc {
+	return func(ctx *rpctypes.Context) (*ctypes.ResultHealth, error) {
+		return c.Health()
+	}
+}
+
+type rpcStatusFunc func(ctx *rpctypes.Context) (*ctypes.ResultStatus, error)
+
+// nolint: interfacer
+func makeStatusFunc(c *lrpc.Client) rpcStatusFunc {
+	return func(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) {
+		return c.Status()
+	}
+}
+
+type rpcNetInfoFunc func(ctx *rpctypes.Context, minHeight, maxHeight int64) (*ctypes.ResultNetInfo, error)
+
+func makeNetInfoFunc(c *lrpc.Client) rpcNetInfoFunc {
+	return func(ctx *rpctypes.Context, minHeight, maxHeight int64) (*ctypes.ResultNetInfo, error) {
+		return c.NetInfo()
+	}
+}
+
+type rpcBlockchainInfoFunc func(ctx *rpctypes.Context, minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error)
+
+func makeBlockchainInfoFunc(c *lrpc.Client) rpcBlockchainInfoFunc {
+	return func(ctx *rpctypes.Context, minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) {
+		return c.BlockchainInfo(minHeight, maxHeight)
+	}
+}
+
+type rpcGenesisFunc func(ctx *rpctypes.Context) (*ctypes.ResultGenesis, error)
+
+func makeGenesisFunc(c *lrpc.Client) rpcGenesisFunc {
+	return func(ctx *rpctypes.Context) (*ctypes.ResultGenesis, error) {
+		return c.Genesis()
+	}
+}
+
+type rpcBlockFunc func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultBlock, error)
+
+func makeBlockFunc(c *lrpc.Client) rpcBlockFunc {
+	return func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultBlock, error) {
+		return c.Block(height)
+	}
+}
+
+type rpcBlockByHashFunc func(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultBlock, error)
+
+func makeBlockByHashFunc(c *lrpc.Client) rpcBlockByHashFunc {
+	return func(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultBlock, error) {
+		return c.BlockByHash(hash)
+	}
+}
+
+type rpcBlockResultsFunc func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultBlockResults, error)
+
+func makeBlockResultsFunc(c *lrpc.Client) rpcBlockResultsFunc {
+	return func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultBlockResults, error) {
+		return c.BlockResults(height)
+	}
+}
+
+type rpcCommitFunc func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultCommit, error)
+
+func makeCommitFunc(c *lrpc.Client) rpcCommitFunc {
+	return func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultCommit, error) {
+		return c.Commit(height)
+	}
+}
+
+type rpcTxFunc func(ctx *rpctypes.Context, hash []byte, prove bool) (*ctypes.ResultTx, error)
+
+func makeTxFunc(c *lrpc.Client) rpcTxFunc {
+	return func(ctx *rpctypes.Context, hash []byte, prove bool) (*ctypes.ResultTx, error) {
+		return c.Tx(hash, prove)
+	}
+}
+
+type rpcTxSearchFunc func(ctx *rpctypes.Context, query string, prove bool,
+	page, perPage int, orderBy string) (*ctypes.ResultTxSearch, error)
+
+func makeTxSearchFunc(c *lrpc.Client) rpcTxSearchFunc {
+	return func(ctx *rpctypes.Context, query string, prove bool, page, perPage int, orderBy string) (
+		*ctypes.ResultTxSearch, error) {
+		return c.TxSearch(query, prove, page, perPage, orderBy)
+	}
+}
+
+type rpcValidatorsFunc func(ctx *rpctypes.Context, height *int64,
+	page, perPage int) (*ctypes.ResultValidators, error)
+
+func makeValidatorsFunc(c *lrpc.Client) rpcValidatorsFunc {
+	return func(ctx *rpctypes.Context, height *int64, page, perPage int) (*ctypes.ResultValidators, error) {
+		return c.Validators(height, page, perPage)
+	}
+}
+
+type rpcDumpConsensusStateFunc func(ctx *rpctypes.Context) (*ctypes.ResultDumpConsensusState, error)
+
+func makeDumpConsensusStateFunc(c *lrpc.Client) rpcDumpConsensusStateFunc {
+	return func(ctx *rpctypes.Context) (*ctypes.ResultDumpConsensusState, error) {
+		return c.DumpConsensusState()
+	}
+}
+
+type rpcConsensusStateFunc func(ctx *rpctypes.Context) (*ctypes.ResultConsensusState, error)
+
+func makeConsensusStateFunc(c *lrpc.Client) rpcConsensusStateFunc {
+	return func(ctx *rpctypes.Context) (*ctypes.ResultConsensusState, error) {
+		return c.ConsensusState()
+	}
+}
+
+type rpcConsensusParamsFunc func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultConsensusParams, error)
+
+func makeConsensusParamsFunc(c *lrpc.Client) rpcConsensusParamsFunc {
+	return func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultConsensusParams, error) {
+		return c.ConsensusParams(height)
+	}
+}
+
+type rpcUnconfirmedTxsFunc func(ctx *rpctypes.Context, limit int) (*ctypes.ResultUnconfirmedTxs, error)
+
+func makeUnconfirmedTxsFunc(c *lrpc.Client) rpcUnconfirmedTxsFunc {
+	return func(ctx *rpctypes.Context, limit int) (*ctypes.ResultUnconfirmedTxs, error) {
+		return c.UnconfirmedTxs(limit)
+	}
+}
+
+type rpcNumUnconfirmedTxsFunc func(ctx *rpctypes.Context) (*ctypes.ResultUnconfirmedTxs, error)
+
+func makeNumUnconfirmedTxsFunc(c *lrpc.Client) rpcNumUnconfirmedTxsFunc {
+	return func(ctx *rpctypes.Context) (*ctypes.ResultUnconfirmedTxs, error) {
+		return c.NumUnconfirmedTxs()
+	}
+}
+
+type rpcBroadcastTxCommitFunc func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error)
+
+func makeBroadcastTxCommitFunc(c *lrpc.Client) rpcBroadcastTxCommitFunc {
+	return func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
+		return c.BroadcastTxCommit(tx)
+	}
+}
+
+type rpcBroadcastTxSyncFunc func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error)
+
+func makeBroadcastTxSyncFunc(c *lrpc.Client) rpcBroadcastTxSyncFunc {
+	return func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
+		return c.BroadcastTxSync(tx)
+	}
+}
+
+type rpcBroadcastTxAsyncFunc func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error)
+
+func makeBroadcastTxAsyncFunc(c *lrpc.Client) rpcBroadcastTxAsyncFunc {
+	return func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
+		return c.BroadcastTxAsync(tx)
+	}
+}
+
+type rpcABCIQueryFunc func(ctx *rpctypes.Context, path string, data bytes.HexBytes) (*ctypes.ResultABCIQuery, error)
+
+func makeABCIQueryFunc(c *lrpc.Client) rpcABCIQueryFunc {
+	return func(ctx *rpctypes.Context, path string, data bytes.HexBytes) (*ctypes.ResultABCIQuery, error) {
+		return c.ABCIQuery(path, data)
+	}
+}
+
+type rpcABCIInfoFunc func(ctx *rpctypes.Context) (*ctypes.ResultABCIInfo, error)
+
+func makeABCIInfoFunc(c *lrpc.Client) rpcABCIInfoFunc {
+	return func(ctx *rpctypes.Context) (*ctypes.ResultABCIInfo, error) {
+		return c.ABCIInfo()
+	}
+}
+
+type rpcBroadcastEvidenceFunc func(ctx *rpctypes.Context, ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error)
+
+// nolint: interfacer
+func makeBroadcastEvidenceFunc(c *lrpc.Client) rpcBroadcastEvidenceFunc {
+	return func(ctx *rpctypes.Context, ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error) {
+		return c.BroadcastEvidence(ev)
+	}
+}