Play well with go-{rpc,crypto,data}:develop

2025-04-25 06:42:16 +00:00 · 2017-04-10 21:16:41 +02:00 · 2017-04-10 21:16:41 +02:00 · e4e17a2c95
commit e4e17a2c95
parent fc95c9872f
6 changed files with 77 additions and 82 deletions
--- a/benchmarks/simu/counter.go
+++ b/benchmarks/simu/counter.go
@ -37,7 +37,9 @@ func main() {
 	for i := 0; ; i++ {
 		binary.BigEndian.PutUint64(buf, uint64(i))
 		//txBytes := hex.EncodeToString(buf[:n])
-		request := rpctypes.NewRPCRequest("fakeid", "broadcast_tx", Arr(buf[:8]))
+		request := rpctypes.NewRPCRequest("fakeid",
+			"broadcast_tx",
+			map[string]interface{}{"tx": buf[:8]})
 		reqBytes := wire.JSONBytes(request)
 		//fmt.Println("!!", string(reqBytes))
 		fmt.Print(".")
--- a/glide.lock
+++ b/glide.lock
@ -1,5 +1,5 @@
-hash: 81cd41d28f9a747a71e6a47e8bc7d855846df29f359ffdcc8d1645c451112b31
-updated: 2017-03-06T17:34:23.99160606-05:00
+hash: 3fd28c04658701e65d8f27e245d15c61056199201fd5af6d18385491fc579a70
+updated: 2017-04-10T20:38:02.65047007+02:00
 imports:
 - name: github.com/btcsuite/btcd
  version: 583684b21bfbde9b5fc4403916fd7c807feb0289
@ -16,7 +16,7 @@ imports:
 - name: github.com/go-stack/stack
  version: 100eb0c0a9c5b306ca2fb4f165df21d80ada4b82
 - name: github.com/gogo/protobuf
-  version: 909568be09de550ed094403c2bf8a261b5bb730a
+  version: 100ba4e885062801d56799d78530b73b178a78f3
  subpackages:
  - proto
 - name: github.com/golang/protobuf
@ -66,7 +66,7 @@ imports:
  - leveldb/table
  - leveldb/util
 - name: github.com/tendermint/abci
-  version: 1236e8fb6eee3a63909f4014a8e84385ead7933d
+  version: af792eac777de757cd496349a5f6b5313738fcbc
  subpackages:
  - client
  - example/counter
@ -83,15 +83,15 @@ imports:
 - name: github.com/tendermint/go-clist
  version: 3baa390bbaf7634251c42ad69a8682e7e3990552
 - name: github.com/tendermint/go-common
-  version: dcb015dff6c7af21e65c8e2f3b450df19d38c777
+  version: 6af2364fa91ef2f3afc8ba0db33b66d9d3ae006c
  subpackages:
  - test
 - name: github.com/tendermint/go-config
  version: 620dcbbd7d587cf3599dedbf329b64311b0c307a
 - name: github.com/tendermint/go-crypto
-  version: 3f47cfac5fcd9e0f1727c7db980b3559913b3e3a
+  version: 750b25c47a5782f5f2b773ed9e706cb82b3ccef4
 - name: github.com/tendermint/go-data
-  version: 32271140e8fd5abdbb22e268d7a02421fa382f0b
+  version: e7fcc6d081ec8518912fcdc103188275f83a3ee5
 - name: github.com/tendermint/go-db
  version: eac3f2bc147023957c8bf69432a4e6c4dc5c3f72
 - name: github.com/tendermint/go-events
@ -109,7 +109,7 @@ imports:
  subpackages:
  - upnp
 - name: github.com/tendermint/go-rpc
-  version: fcea0cda21f64889be00a0f4b6d13266b1a76ee7
+  version: a416c37ebd389dcc320d8f41bdcdc575bdc0a826
  subpackages:
  - client
  - server
--- a/glide.yaml
+++ b/glide.yaml
@ -10,6 +10,8 @@ import:
  version: develop
 - package: github.com/tendermint/go-crypto
  version: develop
+- package: github.com/tendermint/go-data
+  version: develop
 - package: github.com/tendermint/go-db
  version: develop
 - package: github.com/tendermint/go-events
--- a/rpc/client/httpclient.go
+++ b/rpc/client/httpclient.go
@ -22,7 +22,7 @@ out the server for test code (mock).
 */
 type HTTP struct {
 	remote string
-	rpc    *rpcclient.ClientJSONRPC
+	rpc    *rpcclient.JSONRPCClient
 	*WSEvents
 }

@ -30,7 +30,7 @@ type HTTP struct {
 // and the websocket path (which always seems to be "/websocket")
 func NewHTTP(remote, wsEndpoint string) *HTTP {
 	return &HTTP{
-		rpc:      rpcclient.NewClientJSONRPC(remote),
+		rpc:      rpcclient.NewJSONRPCClient(remote),
 		remote:   remote,
 		WSEvents: newWSEvents(remote, wsEndpoint),
 	}
@ -50,7 +50,7 @@ func (c *HTTP) _assertIsEventSwitch() types.EventSwitch {

 func (c *HTTP) Status() (*ctypes.ResultStatus, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("status", []interface{}{}, tmResult)
+	_, err := c.rpc.Call("status", map[string]interface{}{}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "Status")
 	}
@ -60,7 +60,7 @@ func (c *HTTP) Status() (*ctypes.ResultStatus, error) {

 func (c *HTTP) ABCIInfo() (*ctypes.ResultABCIInfo, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("abci_info", []interface{}{}, tmResult)
+	_, err := c.rpc.Call("abci_info", map[string]interface{}{}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "ABCIInfo")
 	}
@ -69,7 +69,9 @@ func (c *HTTP) ABCIInfo() (*ctypes.ResultABCIInfo, error) {

 func (c *HTTP) ABCIQuery(path string, data []byte, prove bool) (*ctypes.ResultABCIQuery, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("abci_query", []interface{}{path, data, prove}, tmResult)
+	_, err := c.rpc.Call("abci_query",
+		map[string]interface{}{"path": path, "data": data, "prove": prove},
+		tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "ABCIQuery")
 	}
@ -78,7 +80,7 @@ func (c *HTTP) ABCIQuery(path string, data []byte, prove bool) (*ctypes.ResultAB

 func (c *HTTP) BroadcastTxCommit(tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("broadcast_tx_commit", []interface{}{tx}, tmResult)
+	_, err := c.rpc.Call("broadcast_tx_commit", map[string]interface{}{"tx": tx}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "broadcast_tx_commit")
 	}
@ -95,7 +97,7 @@ func (c *HTTP) BroadcastTxSync(tx types.Tx) (*ctypes.ResultBroadcastTx, error) {

 func (c *HTTP) broadcastTX(route string, tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call(route, []interface{}{tx}, tmResult)
+	_, err := c.rpc.Call(route, map[string]interface{}{"tx": tx}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, route)
 	}
@ -104,7 +106,7 @@ func (c *HTTP) broadcastTX(route string, tx types.Tx) (*ctypes.ResultBroadcastTx

 func (c *HTTP) NetInfo() (*ctypes.ResultNetInfo, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("net_info", nil, tmResult)
+	_, err := c.rpc.Call("net_info", map[string]interface{}{}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "NetInfo")
 	}
@ -113,7 +115,7 @@ func (c *HTTP) NetInfo() (*ctypes.ResultNetInfo, error) {

 func (c *HTTP) DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("dump_consensus_state", nil, tmResult)
+	_, err := c.rpc.Call("dump_consensus_state", map[string]interface{}{}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "DumpConsensusState")
 	}
@ -122,7 +124,9 @@ func (c *HTTP) DumpConsensusState() (*ctypes.ResultDumpConsensusState, error) {

 func (c *HTTP) BlockchainInfo(minHeight, maxHeight int) (*ctypes.ResultBlockchainInfo, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("blockchain", []interface{}{minHeight, maxHeight}, tmResult)
+	_, err := c.rpc.Call("blockchain",
+		map[string]interface{}{"minHeight": minHeight, "maxHeight": maxHeight},
+		tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "BlockchainInfo")
 	}
@ -131,7 +135,7 @@ func (c *HTTP) BlockchainInfo(minHeight, maxHeight int) (*ctypes.ResultBlockchai

 func (c *HTTP) Genesis() (*ctypes.ResultGenesis, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("genesis", nil, tmResult)
+	_, err := c.rpc.Call("genesis", map[string]interface{}{}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "Genesis")
 	}
@ -140,7 +144,7 @@ func (c *HTTP) Genesis() (*ctypes.ResultGenesis, error) {

 func (c *HTTP) Block(height int) (*ctypes.ResultBlock, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("block", []interface{}{height}, tmResult)
+	_, err := c.rpc.Call("block", map[string]interface{}{"height": height}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "Block")
 	}
@ -149,7 +153,7 @@ func (c *HTTP) Block(height int) (*ctypes.ResultBlock, error) {

 func (c *HTTP) Commit(height int) (*ctypes.ResultCommit, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("commit", []interface{}{height}, tmResult)
+	_, err := c.rpc.Call("commit", map[string]interface{}{"height": height}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "Commit")
 	}
@ -158,7 +162,7 @@ func (c *HTTP) Commit(height int) (*ctypes.ResultCommit, error) {

 func (c *HTTP) Validators() (*ctypes.ResultValidators, error) {
 	tmResult := new(ctypes.TMResult)
-	_, err := c.rpc.Call("validators", nil, tmResult)
+	_, err := c.rpc.Call("validators", map[string]interface{}{}, tmResult)
 	if err != nil {
 		return nil, errors.Wrap(err, "Validators")
 	}
--- a/rpc/test/client_test.go
+++ b/rpc/test/client_test.go
@ -12,6 +12,7 @@ import (
 	"github.com/stretchr/testify/require"
 	abci "github.com/tendermint/abci/types"
 	. "github.com/tendermint/go-common"
+	rpc "github.com/tendermint/go-rpc/client"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	"github.com/tendermint/tendermint/types"
 )
@ -25,24 +26,20 @@ import (
 // status

 func TestURIStatus(t *testing.T) {
-	tmResult := new(ctypes.TMResult)
-	_, err := GetURIClient().Call("status", map[string]interface{}{}, tmResult)
-	require.Nil(t, err)
-	testStatus(t, tmResult)
+	testStatus(t, GetURIClient())
 }

 func TestJSONStatus(t *testing.T) {
-	tmResult := new(ctypes.TMResult)
-	_, err := GetJSONClient().Call("status", []interface{}{}, tmResult)
-	require.Nil(t, err)
-	testStatus(t, tmResult)
+	testStatus(t, GetJSONClient())
 }

-func testStatus(t *testing.T, statusI interface{}) {
+func testStatus(t *testing.T, client rpc.HTTPClient) {
 	chainID := GetConfig().GetString("chain_id")
+	tmResult := new(ctypes.TMResult)
+	_, err := client.Call("status", map[string]interface{}{}, tmResult)
+	require.Nil(t, err)

-	tmRes := statusI.(*ctypes.TMResult)
-	status := (*tmRes).(*ctypes.ResultStatus)
+	status := (*tmResult).(*ctypes.ResultStatus)
 	assert.Equal(t, chainID, status.NodeInfo.Network)
 }

@ -59,28 +56,22 @@ func randBytes(t *testing.T) []byte {
 }

 func TestURIBroadcastTxSync(t *testing.T) {
-	config.Set("block_size", 0)
-	defer config.Set("block_size", -1)
-	tmResult := new(ctypes.TMResult)
-	tx := randBytes(t)
-	_, err := GetURIClient().Call("broadcast_tx_sync", map[string]interface{}{"tx": tx}, tmResult)
-	require.Nil(t, err)
-	testBroadcastTxSync(t, tmResult, tx)
+	testBroadcastTxSync(t, GetURIClient())
 }

 func TestJSONBroadcastTxSync(t *testing.T) {
+	testBroadcastTxSync(t, GetJSONClient())
+}
+
+func testBroadcastTxSync(t *testing.T, client rpc.HTTPClient) {
 	config.Set("block_size", 0)
 	defer config.Set("block_size", -1)
 	tmResult := new(ctypes.TMResult)
 	tx := randBytes(t)
-	_, err := GetJSONClient().Call("broadcast_tx_sync", []interface{}{tx}, tmResult)
+	_, err := client.Call("broadcast_tx_sync", map[string]interface{}{"tx": tx}, tmResult)
 	require.Nil(t, err)
-	testBroadcastTxSync(t, tmResult, tx)
-}

-func testBroadcastTxSync(t *testing.T, resI interface{}, tx []byte) {
-	tmRes := resI.(*ctypes.TMResult)
-	res := (*tmRes).(*ctypes.ResultBroadcastTx)
+	res := (*tmResult).(*ctypes.ResultBroadcastTx)
 	require.Equal(t, abci.CodeType_OK, res.Code)
 	mem := node.MempoolReactor().Mempool
 	require.Equal(t, 1, mem.Size())
@ -98,34 +89,31 @@ func testTxKV(t *testing.T) ([]byte, []byte, []byte) {
 	return k, v, []byte(Fmt("%s=%s", k, v))
 }

-func sendTx(t *testing.T) ([]byte, []byte) {
+func sendTx(t *testing.T, client rpc.HTTPClient) ([]byte, []byte) {
 	tmResult := new(ctypes.TMResult)
 	k, v, tx := testTxKV(t)
-	_, err := GetJSONClient().Call("broadcast_tx_commit", []interface{}{tx}, tmResult)
+	_, err := client.Call("broadcast_tx_commit", map[string]interface{}{"tx": tx}, tmResult)
 	require.Nil(t, err)
 	return k, v
 }

 func TestURIABCIQuery(t *testing.T) {
-	k, v := sendTx(t)
-	time.Sleep(time.Second)
-	tmResult := new(ctypes.TMResult)
-	_, err := GetURIClient().Call("abci_query", map[string]interface{}{"path": "", "data": k, "prove": false}, tmResult)
-	require.Nil(t, err)
-	testABCIQuery(t, tmResult, v)
+	testABCIQuery(t, GetURIClient())
 }

 func TestJSONABCIQuery(t *testing.T) {
-	k, v := sendTx(t)
-	tmResult := new(ctypes.TMResult)
-	_, err := GetJSONClient().Call("abci_query", []interface{}{"", k, false}, tmResult)
-	require.Nil(t, err)
-	testABCIQuery(t, tmResult, v)
+	testABCIQuery(t, GetURIClient())
 }

-func testABCIQuery(t *testing.T, statusI interface{}, value []byte) {
-	tmRes := statusI.(*ctypes.TMResult)
-	resQuery := (*tmRes).(*ctypes.ResultABCIQuery)
+func testABCIQuery(t *testing.T, client rpc.HTTPClient) {
+	k, _ := sendTx(t, client)
+	time.Sleep(time.Millisecond * 100)
+	tmResult := new(ctypes.TMResult)
+	_, err := client.Call("abci_query",
+		map[string]interface{}{"path": "", "data": k, "prove": false}, tmResult)
+	require.Nil(t, err)
+
+	resQuery := (*tmResult).(*ctypes.ResultABCIQuery)
 	require.EqualValues(t, 0, resQuery.Response.Code)

 	// XXX: specific to value returned by the dummy
@ -136,25 +124,22 @@ func testABCIQuery(t *testing.T, statusI interface{}, value []byte) {
 // broadcast tx commit

 func TestURIBroadcastTxCommit(t *testing.T) {
-	tmResult := new(ctypes.TMResult)
-	tx := randBytes(t)
-	_, err := GetURIClient().Call("broadcast_tx_commit", map[string]interface{}{"tx": tx}, tmResult)
-	require.Nil(t, err)
-	testBroadcastTxCommit(t, tmResult, tx)
+	testBroadcastTxCommit(t, GetURIClient())
 }

 func TestJSONBroadcastTxCommit(t *testing.T) {
-	tmResult := new(ctypes.TMResult)
-	tx := randBytes(t)
-	_, err := GetJSONClient().Call("broadcast_tx_commit", []interface{}{tx}, tmResult)
-	require.Nil(t, err)
-	testBroadcastTxCommit(t, tmResult, tx)
+	testBroadcastTxCommit(t, GetJSONClient())
 }

-func testBroadcastTxCommit(t *testing.T, resI interface{}, tx []byte) {
+func testBroadcastTxCommit(t *testing.T, client rpc.HTTPClient) {
 	require := require.New(t)
-	tmRes := resI.(*ctypes.TMResult)
-	res := (*tmRes).(*ctypes.ResultBroadcastTxCommit)
+
+	tmResult := new(ctypes.TMResult)
+	tx := randBytes(t)
+	_, err := client.Call("broadcast_tx_commit", map[string]interface{}{"tx": tx}, tmResult)
+	require.Nil(err)
+
+	res := (*tmResult).(*ctypes.ResultBroadcastTxCommit)
 	checkTx := res.CheckTx
 	require.Equal(abci.CodeType_OK, checkTx.Code)
 	deliverTx := res.DeliverTx
@ -240,7 +225,7 @@ func TestWSTxEvent(t *testing.T) {

 	// send an tx
 	tmResult := new(ctypes.TMResult)
-	_, err := GetJSONClient().Call("broadcast_tx_sync", []interface{}{tx}, tmResult)
+	_, err := GetJSONClient().Call("broadcast_tx_sync", map[string]interface{}{"tx": tx}, tmResult)
 	require.Nil(err)

 	waitForEvent(t, wsc, eid, true, func() {}, func(eid string, b interface{}) error {
@ -310,7 +295,9 @@ func TestURIUnsafeSetConfig(t *testing.T) {
 func TestJSONUnsafeSetConfig(t *testing.T) {
 	for _, testCase := range testCasesUnsafeSetConfig {
 		tmResult := new(ctypes.TMResult)
-		_, err := GetJSONClient().Call("unsafe_set_config", []interface{}{testCase[0], testCase[1], testCase[2]}, tmResult)
+		_, err := GetJSONClient().Call("unsafe_set_config",
+			map[string]interface{}{"type": testCase[0], "key": testCase[1], "value": testCase[2]},
+			tmResult)
 		require.Nil(t, err)
 	}
 	testUnsafeSetConfig(t)
--- a/rpc/test/helpers.go
+++ b/rpc/test/helpers.go
@ -72,15 +72,15 @@ func GetConfig() cfg.Config {
 }

 // GetURIClient gets a uri client pointing to the test tendermint rpc
-func GetURIClient() *client.ClientURI {
+func GetURIClient() *client.URIClient {
 	rpcAddr := GetConfig().GetString("rpc_laddr")
-	return client.NewClientURI(rpcAddr)
+	return client.NewURIClient(rpcAddr)
 }

 // GetJSONClient gets a http/json client pointing to the test tendermint rpc
-func GetJSONClient() *client.ClientJSONRPC {
+func GetJSONClient() *client.JSONRPCClient {
 	rpcAddr := GetConfig().GetString("rpc_laddr")
-	return client.NewClientJSONRPC(rpcAddr)
+	return client.NewJSONRPCClient(rpcAddr)
 }

 func GetGRPCClient() core_grpc.BroadcastAPIClient {