R4R: Bianjie/lcd implementation

Gopkg.toml

@@ -47,6 +47,14 @@
  name = "github.com/stretchr/testify"
  version = "=1.2.1"
 
+[[constraint]]
+ name = "github.com/swaggo/gin-swagger"
+ version = "=v1.0.0"
+
+[[constraint]]
+ name = "github.com/swaggo/swag"
+ version = "=v1.3.2"
+
 [[override]]
  name = "github.com/tendermint/go-amino"
  version = "=v0.12.0-rc0"

client/context/context.go

@@ -10,6 +10,7 @@ import (
  "github.com/spf13/viper"
 
  rpcclient "github.com/tendermint/tendermint/rpc/client"
+ tendermintLite"github.com/tendermint/tendermint/lite"
 )
 
 const ctxAccStoreName = "acc"
@@ -30,6 +31,8 @@ type CLIContext struct {
  Async bool
  JSON bool
  PrintResponse bool
+ Certifier tendermintLite.Certifier
+ ClientManager *ClientManager
 }
 
 // NewCLIContext returns a new initialized CLIContext with parameters from the
@@ -113,3 +116,15 @@ func (ctx CLIContext) WithUseLedger(useLedger bool) CLIContext {
  ctx.UseLedger = useLedger
  return ctx
 }
+
+// WithCertifier - return a copy of the context with an updated Certifier
+func (ctx CLIContext) WithCertifier(certifier tendermintLite.Certifier) CLIContext {
+ ctx.Certifier = certifier
+ return ctx
+}
+
+// WithClientManager - return a copy of the context with an updated ClientManager
+func (ctx CLIContext) WithClientManager(clientManager *ClientManager) CLIContext {
+ ctx.ClientManager = clientManager
+ return ctx
+}

client/context/loadbalancing.go

@@ -0,0 +1,46 @@
+package context
+
+import (
+ rpcclient "github.com/tendermint/tendermint/rpc/client"
+ "strings"
+ "sync"
+ "github.com/pkg/errors"
+)
+
+// ClientManager is a manager of a set of rpc clients to full nodes.
+// This manager can do load balancing upon these rpc clients.
+type ClientManager struct {
+ clients []rpcclient.Client
+ currentIndex int
+ mutex sync.RWMutex
+}
+
+// NewClientManager create a new ClientManager
+func NewClientManager(nodeURIs string) (*ClientManager,error) {
+ if nodeURIs != "" {
+ nodeURLArray := strings.Split(nodeURIs, ",")
+ var clients []rpcclient.Client
+ for _, url := range nodeURLArray {
+ client := rpcclient.NewHTTP(url, "/websocket")
+ clients = append(clients, client)
+ }
+ mgr := &ClientManager{
+ currentIndex: 0,
+ clients: clients,
+ }
+ return mgr, nil
+ }
+ return nil, errors.New("missing node URIs")
+}
+
+func (mgr *ClientManager) getClient() rpcclient.Client {
+ mgr.mutex.Lock()
+ defer mgr.mutex.Unlock()
+
+ client := mgr.clients[mgr.currentIndex]
+ mgr.currentIndex++
+ if mgr.currentIndex >= len(mgr.clients){
+ mgr.currentIndex = 0
+ }
+ return client
+}

client/context/loadbalancing_test.go

@@ -0,0 +1,16 @@
+package context
+
+import (
+ "testing"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestLoadBalancing(t *testing.T) {
+ nodeURIs := "10.10.10.10:26657,20.20.20.20:26657,30.30.30.30:26657"
+ clientMgr,err := NewClientManager(nodeURIs)
+ assert.Empty(t,err)
+ endpoint := clientMgr.getClient()
+ assert.NotEqual(t,endpoint,clientMgr.getClient())
+ clientMgr.getClient()
+ assert.Equal(t,endpoint,clientMgr.getClient())
+}

client/context/query.go

@@ -14,11 +14,19 @@ import (
  cmn "github.com/tendermint/tendermint/libs/common"
  rpcclient "github.com/tendermint/tendermint/rpc/client"
  ctypes "github.com/tendermint/tendermint/rpc/core/types"
+ "github.com/cosmos/cosmos-sdk/store"
+ "github.com/cosmos/cosmos-sdk/wire"
+ "strings"
+ tendermintLiteProxy "github.com/tendermint/tendermint/lite/proxy"
+ abci "github.com/tendermint/tendermint/abci/types"
 )
 
 // GetNode returns an RPC client. If the context's client is not defined, an
 // error is returned.
 func (ctx CLIContext) GetNode() (rpcclient.Client, error) {
+ if ctx.ClientManager != nil {
+ return ctx.ClientManager.getClient(), nil
+ }
  if ctx.Client == nil {
  return nil, errors.New("no RPC client defined")
  }
@@ -282,6 +290,50 @@ func (ctx CLIContext) ensureBroadcastTx(txBytes []byte) error {
  return nil
 }
 
+// proofVerify perform response proof verification
+func (ctx CLIContext) proofVerify(path string, resp abci.ResponseQuery) error {
+ // Data from trusted node or subspace query doesn't need verification
+ if ctx.TrustNode || !isQueryStoreWithProof(path) {
+ return nil
+ }
+
+ // TODO: Later we consider to return error for missing valid certifier to verify data from untrusted node
+ if ctx.Certifier == nil {
+ if ctx.Logger != nil {
+ io.WriteString(ctx.Logger, fmt.Sprintf("Missing valid certifier to verify data from untrusted node\n"))
+ }
+ return nil
+ }
+
+ node, err := ctx.GetNode()
+ if err != nil {
+ return err
+ }
+ // AppHash for height H is in header H+1
+ commit, err := tendermintLiteProxy.GetCertifiedCommit(resp.Height+1, node, ctx.Certifier)
+ if err != nil {
+ return err
+ }
+
+ var multiStoreProof store.MultiStoreProof
+ cdc := wire.NewCodec()
+ err = cdc.UnmarshalBinary(resp.Proof, &multiStoreProof)
+ if err != nil {
+ return errors.Wrap(err, "failed to unmarshalBinary rangeProof")
+ }
+
+ // Validate the substore commit hash against trusted appHash
+ substoreCommitHash, err := store.VerifyMultiStoreCommitInfo(multiStoreProof.StoreName, multiStoreProof.CommitIDList, commit.Header.AppHash)
+ if err != nil {
+ return errors.Wrap(err, "failed in verifying the proof against appHash")
+ }
+ err = store.VerifyRangeProof(resp.Key, resp.Value, substoreCommitHash, &multiStoreProof.RangeProof)
+ if err != nil {
+ return errors.Wrap(err, "failed in the range proof verification")
+ }
+ return nil
+}
+
 // query performs a query from a Tendermint node with the provided store name
 // and path.
 func (ctx CLIContext) query(path string, key common.HexBytes) (res []byte, err error) {
@@ -301,10 +353,15 @@ func (ctx CLIContext) query(path string, key common.HexBytes) (res []byte, err e
  }
 
  resp := result.Response
- if !resp.IsOK() {
+ if resp.Code != uint32(0) {
  return res, errors.Errorf("query failed: (%d) %s", resp.Code, resp.Log)
  }
 
+ err = ctx.proofVerify(path, resp)
+ if err != nil {
+ return nil, err
+ }
+
  return resp.Value, nil
 }
 
@@ -314,3 +371,21 @@ func (ctx CLIContext) queryStore(key cmn.HexBytes, storeName, endPath string) ([
  path := fmt.Sprintf("/store/%s/%s", storeName, endPath)
  return ctx.query(path, key)
 }
+
+// isQueryStoreWithProof expects a format like /<queryType>/<storeName>/<subpath>
+// queryType can be app or store
+// if subpath equals to store or key, then return true
+func isQueryStoreWithProof(path string) (bool) {
+ if !strings.HasPrefix(path, "/") {
+ return false
+ }
+ paths := strings.SplitN(path[1:], "/", 3)
+ if len(paths) != 3 {
+ return false
+ }
+ // WARNING This should be consistent with query method in iavlstore.go
+ if paths[2] == "store" || paths[2] == "key" {
+ return true
+ }
+ return false
+}

client/flags.go

@@ -19,6 +19,11 @@ const (
  FlagAsync = "async"
  FlagJson = "json"
  FlagPrintResponse = "print-response"
+ FlagListenAddr = "laddr"
+ FlagSwaggerHostIP = "swagger-host-ip"
+ FlagModules = "modules"
+ FlagNodeList = "node-list"
+ FlagTrustStore = "trust-store"
 )
 
 // LineBreak can be included in a command list to provide a blank line

client/httputils/httputils.go

@@ -0,0 +1,32 @@
+package httputils
+
+import (
+ "github.com/gin-gonic/gin"
+ "net/http"
+)
+
+// NewError create error http response
+func NewError(ctx *gin.Context, errCode int, err error) {
+ errorResponse := HTTPError{
+ API: "2.0",
+ Code: errCode,
+ }
+ if err != nil {
+ errorResponse.ErrMsg = err.Error()
+ }
+
+ ctx.JSON(errCode, errorResponse)
+}
+
+// NormalResponse create normal http response
+func NormalResponse(ctx *gin.Context, data []byte) {
+ ctx.Status(http.StatusOK)
+ ctx.Writer.Write(data)
+}
+
+// HTTPError is http response with error
+type HTTPError struct {
+ API string `json:"rest api" example:"2.0"`
+ Code int `json:"code" example:"500"`
+ ErrMsg string `json:"error message"`
+}