zolfa
/
tendermint
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 221 Wiki Activity
Browse Source

remove "rpc" prefix from package imports

pull/456/head
Anton Kaliaev 7 years ago
parent
e1d5873bdf
commit
66867bf949
No known key found for this signature in database GPG Key ID: 7B6881D965918214
4 changed files with 39 additions and 41 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +4
    -5
      client/http_client.go
  2. +4
    -4
      client/ws_client.go
  3. +25
    -24
      rpc_test.go
  4. +6
    -8
      server/http_server.go

+ 4
- 5
client/http_client.go View File

@ -11,8 +11,7 @@ import (
"reflect"
"strings"
// cmn "github.com/tendermint/go-common"
rpctypes "github.com/tendermint/go-rpc/types"
types "github.com/tendermint/go-rpc/types"
wire "github.com/tendermint/go-wire"
)
@ -28,7 +27,7 @@ func makeHTTPDialer(remoteAddr string) (string, func(string, string) (net.Conn,
var protocol, address string
if len(parts) != 2 {
log.Warn("WARNING (go-rpc): Please use fully formed listening addresses, including the tcp:// or unix:// prefix")
protocol = rpctypes.SocketType(remoteAddr)
protocol = types.SocketType(remoteAddr)
address = remoteAddr
} else {
protocol, address = parts[0], parts[1]
@ -73,7 +72,7 @@ func (c *ClientJSONRPC) Call(method string, params map[string]interface{}, resul
func (c *ClientJSONRPC) call(method string, params map[string]interface{}, result interface{}) (interface{}, error) {
// Make request and get responseBytes
request := rpctypes.RPCRequest{
request := types.RPCRequest{
JSONRPC: "2.0",
Method: method,
Params: params,
@ -144,7 +143,7 @@ func unmarshalResponseBytes(responseBytes []byte, result interface{}) (interface
// into the correct type
// log.Notice("response", "response", string(responseBytes))
var err error
response := &rpctypes.RPCResponse{}
response := &types.RPCResponse{}
err = json.Unmarshal(responseBytes, response)
if err != nil {
return nil, fmt.Errorf("Error unmarshalling rpc response: %v", err)


+ 4
- 4
client/ws_client.go View File

@ -9,7 +9,7 @@ import (
"github.com/gorilla/websocket"
cmn "github.com/tendermint/go-common"
rpctypes "github.com/tendermint/go-rpc/types"
types "github.com/tendermint/go-rpc/types"
)
const (
@ -96,7 +96,7 @@ func (wsc *WSClient) receiveEventsRoutine() {
wsc.Stop()
break
} else {
var response rpctypes.RPCResponse
var response types.RPCResponse
err := json.Unmarshal(data, &response)
if err != nil {
log.Info("WSClient failed to parse message", "error", err, "data", string(data))
@ -118,7 +118,7 @@ func (wsc *WSClient) receiveEventsRoutine() {
// subscribe to an event
func (wsc *WSClient) Subscribe(eventid string) error {
err := wsc.WriteJSON(rpctypes.RPCRequest{
err := wsc.WriteJSON(types.RPCRequest{
JSONRPC: "2.0",
ID: "",
Method: "subscribe",
@ -129,7 +129,7 @@ func (wsc *WSClient) Subscribe(eventid string) error {
// unsubscribe from an event
func (wsc *WSClient) Unsubscribe(eventid string) error {
err := wsc.WriteJSON(rpctypes.RPCRequest{
err := wsc.WriteJSON(types.RPCRequest{
JSONRPC: "2.0",
ID: "",
Method: "unsubscribe",


+ 25
- 24
rpc_test.go View File

@ -5,14 +5,14 @@ import (
"testing"
"time"
rpcclient "github.com/tendermint/go-rpc/client"
rpcserver "github.com/tendermint/go-rpc/server"
rpctypes "github.com/tendermint/go-rpc/types"
client "github.com/tendermint/go-rpc/client"
server "github.com/tendermint/go-rpc/server"
types "github.com/tendermint/go-rpc/types"
wire "github.com/tendermint/go-wire"
)
// Client and Server should work over tcp or unix sockets
var (
const (
tcpAddr = "tcp://0.0.0.0:46657"
unixAddr = "unix:///tmp/go-rpc.sock" // NOTE: must remove file for test to run again
@ -32,8 +32,8 @@ var _ = wire.RegisterInterface(
)
// Define some routes
var Routes = map[string]*rpcserver.RPCFunc{
"status": rpcserver.NewRPCFunc(StatusResult, "arg"),
var Routes = map[string]*server.RPCFunc{
"status": server.NewRPCFunc(StatusResult, "arg"),
}
// an rpc function
@ -43,23 +43,24 @@ func StatusResult(v string) (Result, error) {
// launch unix and tcp servers
func init() {
mux := http.NewServeMux()
rpcserver.RegisterRPCFuncs(mux, Routes)
wm := rpcserver.NewWebsocketManager(Routes, nil)
server.RegisterRPCFuncs(mux, Routes)
wm := server.NewWebsocketManager(Routes, nil)
mux.HandleFunc(websocketEndpoint, wm.WebsocketHandler)
go func() {
_, err := rpcserver.StartHTTPServer(tcpAddr, mux)
_, err := server.StartHTTPServer(tcpAddr, mux)
if err != nil {
panic(err)
}
}()
mux2 := http.NewServeMux()
rpcserver.RegisterRPCFuncs(mux2, Routes)
wm = rpcserver.NewWebsocketManager(Routes, nil)
server.RegisterRPCFuncs(mux2, Routes)
wm = server.NewWebsocketManager(Routes, nil)
mux2.HandleFunc(websocketEndpoint, wm.WebsocketHandler)
go func() {
_, err := rpcserver.StartHTTPServer(unixAddr, mux2)
_, err := server.StartHTTPServer(unixAddr, mux2)
if err != nil {
panic(err)
}
@ -70,7 +71,7 @@ func init() {
}
func testURI(t *testing.T, cl *rpcclient.ClientURI) {
func testURI(t *testing.T, cl *client.ClientURI) {
val := "acbd"
params := map[string]interface{}{
"arg": val,
@ -86,7 +87,7 @@ func testURI(t *testing.T, cl *rpcclient.ClientURI) {
}
}
func testJSONRPC(t *testing.T, cl *rpcclient.ClientJSONRPC) {
func testJSONRPC(t *testing.T, cl *client.ClientJSONRPC) {
val := "acbd"
params := map[string]interface{}{
"arg": val,
@ -102,12 +103,12 @@ func testJSONRPC(t *testing.T, cl *rpcclient.ClientJSONRPC) {
}
}
func testWS(t *testing.T, cl *rpcclient.WSClient) {
func testWS(t *testing.T, cl *client.WSClient) {
val := "acbd"
params := map[string]interface{}{
"arg": val,
}
err := cl.WriteJSON(rpctypes.RPCRequest{
err := cl.WriteJSON(types.RPCRequest{
JSONRPC: "2.0",
ID: "",
Method: "status",
@ -132,27 +133,27 @@ func testWS(t *testing.T, cl *rpcclient.WSClient) {
//-------------
func TestURI_TCP(t *testing.T) {
cl := rpcclient.NewClientURI(tcpAddr)
cl := client.NewClientURI(tcpAddr)
testURI(t, cl)
}
func TestURI_UNIX(t *testing.T) {
cl := rpcclient.NewClientURI(unixAddr)
cl := client.NewClientURI(unixAddr)
testURI(t, cl)
}
func TestJSONRPC_TCP(t *testing.T) {
cl := rpcclient.NewClientJSONRPC(tcpAddr)
cl := client.NewClientJSONRPC(tcpAddr)
testJSONRPC(t, cl)
}
func TestJSONRPC_UNIX(t *testing.T) {
cl := rpcclient.NewClientJSONRPC(unixAddr)
cl := client.NewClientJSONRPC(unixAddr)
testJSONRPC(t, cl)
}
func TestWS_TCP(t *testing.T) {
cl := rpcclient.NewWSClient(tcpAddr, websocketEndpoint)
cl := client.NewWSClient(tcpAddr, websocketEndpoint)
_, err := cl.Start()
if err != nil {
t.Fatal(err)
@ -161,7 +162,7 @@ func TestWS_TCP(t *testing.T) {
}
func TestWS_UNIX(t *testing.T) {
cl := rpcclient.NewWSClient(unixAddr, websocketEndpoint)
cl := client.NewWSClient(unixAddr, websocketEndpoint)
_, err := cl.Start()
if err != nil {
t.Fatal(err)
@ -170,7 +171,7 @@ func TestWS_UNIX(t *testing.T) {
}
func TestHexStringArg(t *testing.T) {
cl := rpcclient.NewClientURI(tcpAddr)
cl := client.NewClientURI(tcpAddr)
// should NOT be handled as hex
val := "0xabc"
params := map[string]interface{}{
@ -188,7 +189,7 @@ func TestHexStringArg(t *testing.T) {
}
func TestQuotedStringArg(t *testing.T) {
cl := rpcclient.NewClientURI(tcpAddr)
cl := client.NewClientURI(tcpAddr)
// should NOT be unquoted
val := "\"abc\""
params := map[string]interface{}{


+ 6
- 8
server/http_server.go View File

@ -11,9 +11,7 @@ import (
"strings"
"time"
. "github.com/tendermint/go-common"
. "github.com/tendermint/go-rpc/types"
//"github.com/tendermint/go-wire"
types "github.com/tendermint/go-rpc/types"
)
func StartHTTPServer(listenAddr string, handler http.Handler) (listener net.Listener, err error) {
@ -24,14 +22,14 @@ func StartHTTPServer(listenAddr string, handler http.Handler) (listener net.List
log.Warn("WARNING (go-rpc): Please use fully formed listening addresses, including the tcp:// or unix:// prefix")
// we used to allow addrs without tcp/unix prefix by checking for a colon
// TODO: Deprecate
proto = SocketType(listenAddr)
proto = types.SocketType(listenAddr)
addr = listenAddr
// return nil, fmt.Errorf("Invalid listener address %s", lisenAddr)
} else {
proto, addr = parts[0], parts[1]
}
log.Notice(Fmt("Starting RPC HTTP server on %s socket %v", proto, addr))
log.Notice(fmt.Sprintf("Starting RPC HTTP server on %s socket %v", proto, addr))
listener, err = net.Listen(proto, addr)
if err != nil {
return nil, fmt.Errorf("Failed to listen to %v: %v", listenAddr, err)
@ -47,7 +45,7 @@ func StartHTTPServer(listenAddr string, handler http.Handler) (listener net.List
return listener, nil
}
func WriteRPCResponseHTTP(w http.ResponseWriter, res RPCResponse) {
func WriteRPCResponseHTTP(w http.ResponseWriter, res types.RPCResponse) {
// jsonBytes := wire.JSONBytesPretty(res)
jsonBytes, err := json.Marshal(res)
if err != nil {
@ -83,13 +81,13 @@ func RecoverAndLogHandler(handler http.Handler) http.Handler {
if e := recover(); e != nil {
// If RPCResponse
if res, ok := e.(RPCResponse); ok {
if res, ok := e.(types.RPCResponse); ok {
WriteRPCResponseHTTP(rww, res)
} else {
// For the rest,
log.Error("Panic in RPC HTTP handler", "error", e, "stack", string(debug.Stack()))
rww.WriteHeader(http.StatusInternalServerError)
WriteRPCResponseHTTP(rww, NewRPCResponse("", nil, Fmt("Internal Server Error: %v", e)))
WriteRPCResponseHTTP(rww, types.NewRPCResponse("", nil, fmt.Sprintf("Internal Server Error: %v", e)))
}
}


Write Preview
Loading…
Cancel
Save