add latest lcd

2024-12-25 07:45:18 +00:00 · 2018-09-19 20:23:37 -04:00 · 2018-09-19 20:23:37 -04:00 · a7659e2519
commit a7659e2519
parent eb927b1fb7
8 changed files with 1516 additions and 43 deletions
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -48,7 +48,7 @@
  revision = "d4cc87b860166d00d6b5b9e0d3b3d71d6088d4d4"

 [[projects]]
-  digest = "1:7f6e80c9a48014e57211353a9a82d12088f9dc85f564b6a70674bbc1d5abc34e"
+  digest = "1:f3b0e995c000b2caa93309b8202a599326b708583d60aec2eef668bea2827c9d"
  name = "github.com/cosmos/cosmos-sdk"
  packages = [
    "baseapp",
@ -58,6 +58,7 @@
    "client/rpc",
    "client/tx",
    "client/utils",
+    "cmd/gaia/app",
    "crypto",
    "crypto/keys",
    "crypto/keys/bcrypt",
@ -66,21 +67,29 @@
    "server",
    "server/config",
    "store",
+    "tests",
    "types",
    "version",
    "wire",
    "x/auth",
    "x/auth/client/cli",
    "x/auth/client/context",
+    "x/auth/client/rest",
    "x/bank",
    "x/bank/client",
    "x/bank/client/cli",
+    "x/bank/client/rest",
+    "x/gov",
+    "x/gov/tags",
+    "x/ibc",
    "x/mock",
    "x/params",
    "x/slashing",
    "x/slashing/client/cli",
+    "x/slashing/client/rest",
    "x/stake",
    "x/stake/client/cli",
+    "x/stake/client/rest",
    "x/stake/keeper",
    "x/stake/tags",
    "x/stake/types",
@ -715,35 +724,53 @@
    "github.com/cosmos/cosmos-sdk/client/rpc",
    "github.com/cosmos/cosmos-sdk/client/tx",
    "github.com/cosmos/cosmos-sdk/client/utils",
+    "github.com/cosmos/cosmos-sdk/cmd/gaia/app",
+    "github.com/cosmos/cosmos-sdk/crypto/keys",
    "github.com/cosmos/cosmos-sdk/server",
    "github.com/cosmos/cosmos-sdk/server/config",
+    "github.com/cosmos/cosmos-sdk/tests",
    "github.com/cosmos/cosmos-sdk/types",
    "github.com/cosmos/cosmos-sdk/version",
    "github.com/cosmos/cosmos-sdk/wire",
    "github.com/cosmos/cosmos-sdk/x/auth",
    "github.com/cosmos/cosmos-sdk/x/auth/client/cli",
    "github.com/cosmos/cosmos-sdk/x/auth/client/context",
+    "github.com/cosmos/cosmos-sdk/x/auth/client/rest",
    "github.com/cosmos/cosmos-sdk/x/bank",
    "github.com/cosmos/cosmos-sdk/x/bank/client/cli",
+    "github.com/cosmos/cosmos-sdk/x/bank/client/rest",
+    "github.com/cosmos/cosmos-sdk/x/gov",
    "github.com/cosmos/cosmos-sdk/x/mock",
    "github.com/cosmos/cosmos-sdk/x/params",
    "github.com/cosmos/cosmos-sdk/x/slashing",
    "github.com/cosmos/cosmos-sdk/x/slashing/client/cli",
+    "github.com/cosmos/cosmos-sdk/x/slashing/client/rest",
    "github.com/cosmos/cosmos-sdk/x/stake",
    "github.com/cosmos/cosmos-sdk/x/stake/client/cli",
+    "github.com/cosmos/cosmos-sdk/x/stake/client/rest",
+    "github.com/gorilla/mux",
    "github.com/kava-labs/cosmos-sdk/client",
    "github.com/pkg/errors",
    "github.com/spf13/cobra",
    "github.com/spf13/pflag",
    "github.com/spf13/viper",
    "github.com/stretchr/testify/assert",
+    "github.com/stretchr/testify/require",
+    "github.com/tendermint/go-amino",
    "github.com/tendermint/tendermint/abci/types",
+    "github.com/tendermint/tendermint/config",
    "github.com/tendermint/tendermint/crypto",
    "github.com/tendermint/tendermint/crypto/ed25519",
    "github.com/tendermint/tendermint/libs/cli",
    "github.com/tendermint/tendermint/libs/common",
    "github.com/tendermint/tendermint/libs/db",
    "github.com/tendermint/tendermint/libs/log",
+    "github.com/tendermint/tendermint/node",
+    "github.com/tendermint/tendermint/p2p",
+    "github.com/tendermint/tendermint/privval",
+    "github.com/tendermint/tendermint/proxy",
+    "github.com/tendermint/tendermint/rpc/core/types",
+    "github.com/tendermint/tendermint/rpc/lib/server",
    "github.com/tendermint/tendermint/types",
  ]
  solver-name = "gps-cdcl"
--- a/cmd/kvcli/main.go
+++ b/cmd/kvcli/main.go
@ -22,7 +22,7 @@ import (
 	paychancmd "github.com/kava-labs/kava/internal/x/paychan/client/cli"

 	"github.com/kava-labs/kava/internal/app"
-	//"github.com/kava-labs/kava/internal/lcd"
+	"github.com/kava-labs/kava/internal/lcd"
 )

 var (
@ -59,8 +59,7 @@ func main() {

 	advancedCmd.AddCommand(
 		tendermintCmd,
-		//ibcCmd,
-		//lcd.ServeCommand(cdc),
+		lcd.ServeCommand(cdc),
 	)
 	rootCmd.AddCommand(
 		advancedCmd,
--- a/internal/lcd/decode.go
+++ b/internal/lcd/decode.go
@ -1,24 +1,21 @@
 package lcd

-/*
 import (
-	"net/http"
-	//"encoding/hex"
 	"encoding/base64"
 	"encoding/json"
+	"net/http"

 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/wire"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 )
-*/

 type TxBody struct {
 	TxBase64 string `json:"txbase64"`
 }

 // Decode a tx from base64 into json
-func DecodeTxRequestHandlerFn(ctx context.CoreContext, cdc *wire.Codec) http.HandlerFunc {
+func DecodeTxRequestHandlerFn(cliCtx context.CLIContext, cdc *wire.Codec) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		// get the input base64 string
 		var m TxBody
--- a/internal/lcd/lcd_test.go
+++ b/internal/lcd/lcd_test.go
--- a/internal/lcd/root.go
+++ b/internal/lcd/root.go
@ -3,32 +3,27 @@

 package lcd

-/*
 import (
 	"net/http"
 	"os"

-	"github.com/gorilla/mux"
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-	"github.com/tendermint/tmlibs/log"
-
-	tmserver "github.com/tendermint/tendermint/rpc/lib/server"
-	cmn "github.com/tendermint/tmlibs/common"
-
 	client "github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
 	keys "github.com/cosmos/cosmos-sdk/client/keys"
 	rpc "github.com/cosmos/cosmos-sdk/client/rpc"
 	tx "github.com/cosmos/cosmos-sdk/client/tx"
-	version "github.com/cosmos/cosmos-sdk/version"
 	"github.com/cosmos/cosmos-sdk/wire"
 	auth "github.com/cosmos/cosmos-sdk/x/auth/client/rest"
 	bank "github.com/cosmos/cosmos-sdk/x/bank/client/rest"
-	//ibc "github.com/cosmos/cosmos-sdk/x/ibc/client/rest"
-	//stake "github.com/cosmos/cosmos-sdk/x/stake/client/rest"
+	slashing "github.com/cosmos/cosmos-sdk/x/slashing/client/rest"
+	stake "github.com/cosmos/cosmos-sdk/x/stake/client/rest"
+	"github.com/gorilla/mux"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	cmn "github.com/tendermint/tendermint/libs/common"
+	"github.com/tendermint/tendermint/libs/log"
+	tmserver "github.com/tendermint/tendermint/rpc/lib/server"
 )
-*/

 // ServeCommand will generate a long-running rest server
 // (aka Light Client Daemon) that exposes functionality similar
@ -36,6 +31,7 @@ import (
 func ServeCommand(cdc *wire.Codec) *cobra.Command {
 	flagListenAddr := "laddr"
 	flagCORS := "cors"
+	flagMaxOpenConnections := "max-open"

 	cmd := &cobra.Command{
 		Use:   "rest-server",
@ -43,48 +39,61 @@ func ServeCommand(cdc *wire.Codec) *cobra.Command {
 		RunE: func(cmd *cobra.Command, args []string) error {
 			listenAddr := viper.GetString(flagListenAddr)
 			handler := createHandler(cdc)
-			logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).
-				With("module", "rest-server")
-			listener, err := tmserver.StartHTTPServer(listenAddr, handler, logger)
+			logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "rest-server")
+			maxOpen := viper.GetInt(flagMaxOpenConnections)
+
+			listener, err := tmserver.StartHTTPServer(
+				listenAddr, handler, logger,
+				tmserver.Config{MaxOpenConnections: maxOpen},
+			)
 			if err != nil {
 				return err
 			}
+
 			logger.Info("REST server started")

-			// Wait forever and cleanup
+			// wait forever and cleanup
 			cmn.TrapSignal(func() {
 				err := listener.Close()
-				logger.Error("Error closing listener", "err", err)
+				logger.Error("error closing listener", "err", err)
 			})
+
 			return nil
 		},
 	}
-	cmd.Flags().StringP(flagListenAddr, "a", "tcp://localhost:1317", "Address for server to listen on")
-	cmd.Flags().String(flagCORS, "", "Set to domains that can make CORS requests (* for all)")
-	cmd.Flags().StringP(client.FlagChainID, "c", "", "ID of chain we connect to")
-	cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:46657", "Node to connect to")
+
+	cmd.Flags().String(flagListenAddr, "tcp://localhost:1317", "The address for the server to listen on")
+	cmd.Flags().String(flagCORS, "", "Set the domains that can make CORS requests (* for all)")
+	cmd.Flags().String(client.FlagChainID, "", "The chain ID to connect to")
+	cmd.Flags().String(client.FlagNode, "tcp://localhost:26657", "Address of the node to connect to")
+	cmd.Flags().Int(flagMaxOpenConnections, 1000, "The number of maximum open connections")
+
 	return cmd
 }

 func createHandler(cdc *wire.Codec) http.Handler {
 	r := mux.NewRouter()
-	r.HandleFunc("/version", version.RequestHandler).Methods("GET")

 	kb, err := keys.GetKeyBase() //XXX
 	if err != nil {
 		panic(err)
 	}

-	ctx := context.NewCoreContextFromViper()
+	cliCtx := context.NewCLIContext().WithCodec(cdc).WithLogger(os.Stdout)
+
+	r.HandleFunc("/version", CLIVersionRequestHandler).Methods("GET")
+	r.HandleFunc("/node_version", NodeVersionRequestHandler(cliCtx)).Methods("GET")
+	r.HandleFunc("/decode_tx", DecodeTxRequestHandlerFn(cliCtx, cdc)).Methods("POST")

-	// TODO make more functional? aka r = keys.RegisterRoutes(r)
 	keys.RegisterRoutes(r)
-	rpc.RegisterRoutes(ctx, r)
-	tx.RegisterRoutes(ctx, r, cdc)
-	auth.RegisterRoutes(ctx, r, cdc, "acc")
-	bank.RegisterRoutes(ctx, r, cdc, kb)
-	//ibc.RegisterRoutes(ctx, r, cdc, kb)
-	//stake.RegisterRoutes(ctx, r, cdc, kb)
-	r.HandleFunc("/decode_tx", DecodeTxRequestHandlerFn(ctx, cdc)).Methods("POST")
+	rpc.RegisterRoutes(cliCtx, r)
+	tx.RegisterRoutes(cliCtx, r, cdc)
+	auth.RegisterRoutes(cliCtx, r, cdc, "acc")
+	bank.RegisterRoutes(cliCtx, r, cdc, kb)
+	//ibc.RegisterRoutes(cliCtx, r, cdc, kb)
+	stake.RegisterRoutes(cliCtx, r, cdc, kb)
+	slashing.RegisterRoutes(cliCtx, r, cdc, kb)
+	//gov.RegisterRoutes(cliCtx, r, cdc)
+
 	return r
 }
--- a/internal/lcd/test_helpers.go
+++ b/internal/lcd/test_helpers.go
@ -0,0 +1,275 @@
+// Copyright 2016 All in Bits, inc
+// Modifications copyright 2018 Kava Labs
+
+package lcd
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	keys "github.com/cosmos/cosmos-sdk/client/keys"
+	gapp "github.com/cosmos/cosmos-sdk/cmd/gaia/app"
+	crkeys "github.com/cosmos/cosmos-sdk/crypto/keys"
+	"github.com/cosmos/cosmos-sdk/server"
+	"github.com/cosmos/cosmos-sdk/tests"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/x/auth"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+	tmcfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/ed25519"
+	"github.com/tendermint/tendermint/libs/cli"
+	dbm "github.com/tendermint/tendermint/libs/db"
+	"github.com/tendermint/tendermint/libs/log"
+	nm "github.com/tendermint/tendermint/node"
+	pvm "github.com/tendermint/tendermint/privval"
+	"github.com/tendermint/tendermint/proxy"
+	tmrpc "github.com/tendermint/tendermint/rpc/lib/server"
+	tmtypes "github.com/tendermint/tendermint/types"
+)
+
+// makePathname creates a unique pathname for each test. It will panic if it
+// cannot get the current working directory.
+func makePathname() string {
+	p, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+
+	sep := string(filepath.Separator)
+	return strings.Replace(p, sep, "_", -1)
+}
+
+// GetConfig returns a Tendermint config for the test cases.
+func GetConfig() *tmcfg.Config {
+	pathname := makePathname()
+	config := tmcfg.ResetTestRoot(pathname)
+
+	tmAddr, _, err := server.FreeTCPAddr()
+	if err != nil {
+		panic(err)
+	}
+
+	rcpAddr, _, err := server.FreeTCPAddr()
+	if err != nil {
+		panic(err)
+	}
+
+	grpcAddr, _, err := server.FreeTCPAddr()
+	if err != nil {
+		panic(err)
+	}
+
+	config.P2P.ListenAddress = tmAddr
+	config.RPC.ListenAddress = rcpAddr
+	config.RPC.GRPCListenAddress = grpcAddr
+
+	return config
+}
+
+// GetKeyBase returns the LCD test keybase. It also requires that a directory
+// could be made and a keybase could be fetched.
+//
+// NOTE: memDB cannot be used because the request is expecting to interact with
+// the default location.
+func GetKeyBase(t *testing.T) crkeys.Keybase {
+	dir, err := ioutil.TempDir("", "lcd_test")
+	require.NoError(t, err)
+
+	viper.Set(cli.HomeFlag, dir)
+
+	keybase, err := keys.GetKeyBase()
+	require.NoError(t, err)
+
+	return keybase
+}
+
+// CreateAddr adds an address to the key store and returns an address and seed.
+// It also requires that the key could be created.
+func CreateAddr(t *testing.T, name, password string, kb crkeys.Keybase) (sdk.AccAddress, string) {
+	var (
+		err  error
+		info crkeys.Info
+		seed string
+	)
+
+	info, seed, err = kb.CreateMnemonic(name, crkeys.English, password, crkeys.Secp256k1)
+	require.NoError(t, err)
+
+	return sdk.AccAddress(info.GetPubKey().Address()), seed
+}
+
+// InitializeTestLCD starts Tendermint and the LCD in process, listening on
+// their respective sockets where nValidators is the total number of validators
+// and initAddrs are the accounts to initialize with some steak tokens. It
+// returns a cleanup function, a set of validator public keys, and a port.
+func InitializeTestLCD(t *testing.T, nValidators int, initAddrs []sdk.AccAddress) (func(), []crypto.PubKey, string) {
+	config := GetConfig()
+	config.Consensus.TimeoutCommit = 100
+	config.Consensus.SkipTimeoutCommit = false
+	config.TxIndex.IndexAllTags = true
+
+	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
+	logger = log.NewFilter(logger, log.AllowError())
+
+	privValidatorFile := config.PrivValidatorFile()
+	privVal := pvm.LoadOrGenFilePV(privValidatorFile)
+	privVal.Reset()
+
+	db := dbm.NewMemDB()
+	app := gapp.NewGaiaApp(logger, db, nil)
+	cdc = gapp.MakeCodec()
+
+	genesisFile := config.GenesisFile()
+	genDoc, err := tmtypes.GenesisDocFromFile(genesisFile)
+	require.NoError(t, err)
+
+	if nValidators < 1 {
+		panic("InitializeTestLCD must use at least one validator")
+	}
+
+	for i := 1; i < nValidators; i++ {
+		genDoc.Validators = append(genDoc.Validators,
+			tmtypes.GenesisValidator{
+				PubKey: ed25519.GenPrivKey().PubKey(),
+				Power:  1,
+				Name:   "val",
+			},
+		)
+	}
+
+	var validatorsPKs []crypto.PubKey
+
+	// NOTE: It's bad practice to reuse public key address for the owner
+	// address but doing in the test for simplicity.
+	var appGenTxs []json.RawMessage
+	for _, gdValidator := range genDoc.Validators {
+		pk := gdValidator.PubKey
+		validatorsPKs = append(validatorsPKs, pk)
+
+		appGenTx, _, _, err := gapp.GaiaAppGenTxNF(cdc, pk, sdk.AccAddress(pk.Address()), "test_val1")
+		require.NoError(t, err)
+
+		appGenTxs = append(appGenTxs, appGenTx)
+	}
+
+	genesisState, err := gapp.GaiaAppGenState(cdc, appGenTxs[:])
+	require.NoError(t, err)
+
+	// add some tokens to init accounts
+	for _, addr := range initAddrs {
+		accAuth := auth.NewBaseAccountWithAddress(addr)
+		accAuth.Coins = sdk.Coins{sdk.NewInt64Coin("steak", 100)}
+		acc := gapp.NewGenesisAccount(&accAuth)
+		genesisState.Accounts = append(genesisState.Accounts, acc)
+		genesisState.StakeData.Pool.LooseTokens = genesisState.StakeData.Pool.LooseTokens.Add(sdk.NewRat(100))
+	}
+
+	appState, err := wire.MarshalJSONIndent(cdc, genesisState)
+	require.NoError(t, err)
+	genDoc.AppState = appState
+
+	listenAddr, port, err := server.FreeTCPAddr()
+	require.NoError(t, err)
+
+	// XXX: Need to set this so LCD knows the tendermint node address!
+	viper.Set(client.FlagNode, config.RPC.ListenAddress)
+	viper.Set(client.FlagChainID, genDoc.ChainID)
+
+	node, err := startTM(config, logger, genDoc, privVal, app)
+	require.NoError(t, err)
+
+	lcd, err := startLCD(logger, listenAddr, cdc)
+	require.NoError(t, err)
+
+	tests.WaitForLCDStart(port)
+	tests.WaitForHeight(1, port)
+
+	cleanup := func() {
+		logger.Debug("cleaning up LCD initialization")
+		node.Stop()
+		node.Wait()
+		lcd.Close()
+	}
+
+	return cleanup, validatorsPKs, port
+}
+
+// startTM creates and starts an in-process Tendermint node with memDB and
+// in-process ABCI application. It returns the new node or any error that
+// occurred.
+//
+// TODO: Clean up the WAL dir or enable it to be not persistent!
+func startTM(
+	tmcfg *tmcfg.Config, logger log.Logger, genDoc *tmtypes.GenesisDoc,
+	privVal tmtypes.PrivValidator, app abci.Application,
+) (*nm.Node, error) {
+	genDocProvider := func() (*tmtypes.GenesisDoc, error) { return genDoc, nil }
+	dbProvider := func(*nm.DBContext) (dbm.DB, error) { return dbm.NewMemDB(), nil }
+	node, err := nm.NewNode(
+		tmcfg,
+		privVal,
+		proxy.NewLocalClientCreator(app),
+		genDocProvider,
+		dbProvider,
+		nm.DefaultMetricsProvider(tmcfg.Instrumentation),
+		logger.With("module", "node"),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	err = node.Start()
+	if err != nil {
+		return nil, err
+	}
+
+	tests.WaitForRPC(tmcfg.RPC.ListenAddress)
+	logger.Info("Tendermint running!")
+
+	return node, err
+}
+
+// startLCD starts the LCD.
+//
+// NOTE: This causes the thread to block.
+func startLCD(logger log.Logger, listenAddr string, cdc *wire.Codec) (net.Listener, error) {
+	return tmrpc.StartHTTPServer(listenAddr, createHandler(cdc), logger, tmrpc.Config{})
+}
+
+// Request makes a test LCD test request. It returns a response object and a
+// stringified response body.
+func Request(t *testing.T, port, method, path string, payload []byte) (*http.Response, string) {
+	var (
+		err error
+		res *http.Response
+	)
+	url := fmt.Sprintf("http://localhost:%v%v", port, path)
+	fmt.Println("REQUEST " + method + " " + url)
+
+	req, err := http.NewRequest(method, url, bytes.NewBuffer(payload))
+	require.Nil(t, err)
+
+	res, err = http.DefaultClient.Do(req)
+	require.Nil(t, err)
+
+	output, err := ioutil.ReadAll(res.Body)
+	res.Body.Close()
+	require.Nil(t, err)
+
+	return res, string(output)
+}
--- a/internal/lcd/version.go
+++ b/internal/lcd/version.go
@ -0,0 +1,32 @@
+// Copyright 2016 All in Bits, inc
+// Modifications copyright 2018 Kava Labs
+
+package lcd
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/version"
+)
+
+// cli version REST handler endpoint
+func CLIVersionRequestHandler(w http.ResponseWriter, r *http.Request) {
+	v := version.GetVersion()
+	w.Write([]byte(v))
+}
+
+// connected node version REST handler endpoint
+func NodeVersionRequestHandler(cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		version, err := cliCtx.Query("/app/version")
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(fmt.Sprintf("Could't query version. Error: %s", err.Error())))
+			return
+		}
+
+		w.Write(version)
+	}
+}
--- a/internal/lcd/wire.go
+++ b/internal/lcd/wire.go
@ -1,11 +1,12 @@
+// Copyright 2016 All in Bits, inc
+// Modifications copyright 2018 Kava Labs
+
 package lcd

-/*
 import (
 	amino "github.com/tendermint/go-amino"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 )
-*/

 var cdc = amino.NewCodec()