Move HTTP transport to sub package of RPC

cmd/utils/cmd.go

@@ -38,7 +38,7 @@ import (
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/miner"
 	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/ethereum/go-ethereum/rpc"
+	rpchttp "github.com/ethereum/go-ethereum/rpc/http"
 	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/websocket"
 	"github.com/ethereum/go-ethereum/xeth"
@@ -193,7 +193,7 @@ func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, Secre
 
 func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
 	var err error
-	ethereum.RpcServer, err = rpc.NewJsonRpcServer(xeth.NewJSXEth(ethereum), RpcPort)
+	ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.NewJSXEth(ethereum), RpcPort)
 	if err != nil {
 		clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
 	} else {

eth/backend.go

@@ -66,7 +66,7 @@ type Ethereum struct {
 	txSub    event.Subscription
 	blockSub event.Subscription
 
-	RpcServer  *rpc.JsonRpcServer
+	RpcServer  rpc.RpcServer
 	keyManager *crypto.KeyManager
 
 	clientIdentity p2p.ClientIdentity

rpc/http/server.go

@@ -14,7 +14,7 @@
 	You should have received a copy of the GNU General Public License
 	along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
 */
-package rpc
+package rpchttp
 
 import (
 	"fmt"
@@ -22,18 +22,34 @@ import (
 	"net/http"
 
 	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/xeth"
 )
 
-var jsonlogger = logger.NewLogger("JSON")
+var rpchttplogger = logger.NewLogger("RPC-HTTP")
+var JSON rpc.JsonWrapper
 
-type JsonRpcServer struct {
+func NewRpcHttpServer(pipe *xeth.JSXEth, port int) (*RpcHttpServer, error) {
+	sport := fmt.Sprintf(":%d", port)
+	l, err := net.Listen("tcp", sport)
+	if err != nil {
+		return nil, err
+	}
+
+	return &RpcHttpServer{
+		listener: l,
+		quit:     make(chan bool),
+		pipe:     pipe,
+	}, nil
+}
+
+type RpcHttpServer struct {
 	quit     chan bool
 	listener net.Listener
 	pipe     *xeth.JSXEth
 }
 
-func (s *JsonRpcServer) exitHandler() {
+func (s *RpcHttpServer) exitHandler() {
 out:
 	for {
 		select {
@@ -43,61 +59,48 @@ out:
 		}
 	}
 
-	jsonlogger.Infoln("Shutdown JSON-RPC server")
+	rpchttplogger.Infoln("Shutdown RPC-HTTP server")
 }
 
-func (s *JsonRpcServer) Stop() {
+func (s *RpcHttpServer) Stop() {
 	close(s.quit)
 }
 
-func (s *JsonRpcServer) Start() {
+func (s *RpcHttpServer) Start() {
-	jsonlogger.Infoln("Starting JSON-RPC server")
+	rpchttplogger.Infoln("Starting RPC-HTTP server")
 	go s.exitHandler()
 
-	h := apiHandler(&EthereumApi{pipe: s.pipe})
+	api := rpc.NewEthereumApi(s.pipe)
+	h := s.apiHandler(api)
 	http.Handle("/", h)
 
 	err := http.Serve(s.listener, nil)
 	// FIX Complains on shutdown due to listner already being closed
 	if err != nil {
-		jsonlogger.Errorln("Error on JSON-RPC interface:", err)
+		rpchttplogger.Errorln("Error on RPC-HTTP interface:", err)
 	}
 }
 
-func NewJsonRpcServer(pipe *xeth.JSXEth, port int) (*JsonRpcServer, error) {
+func (s *RpcHttpServer) apiHandler(xeth *rpc.EthereumApi) http.Handler {
-	sport := fmt.Sprintf(":%d", port)
-	l, err := net.Listen("tcp", sport)
-	if err != nil {
-		return nil, err
-	}
-
-	return &JsonRpcServer{
-		listener: l,
-		quit:     make(chan bool),
-		pipe:     pipe,
-	}, nil
-}
-
-func apiHandler(xeth *EthereumApi) http.Handler {
 	fn := func(w http.ResponseWriter, req *http.Request) {
-		jsonlogger.Debugln("Handling request")
+		rpchttplogger.Debugln("Handling request")
 
 		reqParsed, reqerr := JSON.ParseRequestBody(req)
 		if reqerr != nil {
-			JSON.Send(w, &RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: ErrorParseRequest})
+			JSON.Send(w, &rpc.RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: rpc.ErrorParseRequest})
 			return
 		}
 
 		var response interface{}
 		reserr := xeth.GetRequestReply(&reqParsed, &response)
 		if reserr != nil {
-			jsonlogger.Errorln(reserr)
+			rpchttplogger.Errorln(reserr)
-			JSON.Send(w, &RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: reserr.Error()})
+			JSON.Send(w, &rpc.RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: reserr.Error()})
 			return
 		}
 
-		jsonlogger.Debugf("Generated response: %T %s", response, response)
+		rpchttplogger.Debugf("Generated response: %T %s", response, response)
-		JSON.Send(w, &RpcSuccessResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: false, Result: response})
+		JSON.Send(w, &rpc.RpcSuccessResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: false, Result: response})
 	}
 
 	return http.HandlerFunc(fn)

rpc/json.go

@@ -18,25 +18,28 @@ package rpc
 
 import (
 	"encoding/json"
+	"github.com/ethereum/go-ethereum/logger"
 	"io"
 	"net/http"
 )
 
-type jsonWrapper struct{}
+var rpclogger = logger.NewLogger("RPC")
 
-func (self jsonWrapper) Send(writer io.Writer, v interface{}) (n int, err error) {
+type JsonWrapper struct{}
+
+func (self JsonWrapper) Send(writer io.Writer, v interface{}) (n int, err error) {
 	var payload []byte
 	payload, err = json.Marshal(v)
 	if err != nil {
-		jsonlogger.Fatalln("Error marshalling JSON", err)
+		rpclogger.Fatalln("Error marshalling JSON", err)
 		return 0, err
 	}
-	jsonlogger.Infof("Sending payload: %s", payload)
+	rpclogger.Infof("Sending payload: %s", payload)
 
 	return writer.Write(payload)
 }
 
-func (self jsonWrapper) ParseRequestBody(req *http.Request) (RpcRequest, error) {
+func (self JsonWrapper) ParseRequestBody(req *http.Request) (RpcRequest, error) {
 	var reqParsed RpcRequest
 
 	// Convert JSON to native types
@@ -46,12 +49,10 @@ func (self jsonWrapper) ParseRequestBody(req *http.Request) (RpcRequest, error)
 	err := d.Decode(&reqParsed)
 
 	if err != nil {
-		jsonlogger.Errorln("Error decoding JSON: ", err)
+		rpclogger.Errorln("Error decoding JSON: ", err)
 		return reqParsed, err
 	}
-	jsonlogger.DebugDetailf("Parsed request: %s", reqParsed)
+	rpclogger.DebugDetailf("Parsed request: %s", reqParsed)
 
 	return reqParsed, nil
 }
-
-var JSON jsonWrapper

rpc/message.go

@@ -67,7 +67,7 @@ func (req *RpcRequest) ToGetBlockArgs() (*GetBlockArgs, error) {
 	if err != nil {
 		return nil, NewErrorResponse(ErrorDecodeArgs)
 	}
-	jsonlogger.DebugDetailf("%T %v", args, args)
+	rpclogger.DebugDetailf("%T %v", args, args)
 	return args, nil
 }
 
@@ -82,7 +82,7 @@ func (req *RpcRequest) ToNewTxArgs() (*NewTxArgs, error) {
 	if err != nil {
 		return nil, NewErrorResponse(ErrorDecodeArgs)
 	}
-	jsonlogger.DebugDetailf("%T %v", args, args)
+	rpclogger.DebugDetailf("%T %v", args, args)
 	return args, nil
 }
 
@@ -97,7 +97,7 @@ func (req *RpcRequest) ToPushTxArgs() (*PushTxArgs, error) {
 	if err != nil {
 		return nil, NewErrorResponse(ErrorDecodeArgs)
 	}
-	jsonlogger.DebugDetailf("%T %v", args, args)
+	rpclogger.DebugDetailf("%T %v", args, args)
 	return args, nil
 }
 
@@ -113,7 +113,7 @@ func (req *RpcRequest) ToGetStorageArgs() (*GetStorageArgs, error) {
 	if err != nil {
 		return nil, NewErrorResponse(ErrorDecodeArgs)
 	}
-	jsonlogger.DebugDetailf("%T %v", args, args)
+	rpclogger.DebugDetailf("%T %v", args, args)
 	return args, nil
 }
 
@@ -128,7 +128,7 @@ func (req *RpcRequest) ToGetTxCountArgs() (*GetTxCountArgs, error) {
 	if err != nil {
 		return nil, NewErrorResponse(ErrorDecodeArgs)
 	}
-	jsonlogger.DebugDetailf("%T %v", args, args)
+	rpclogger.DebugDetailf("%T %v", args, args)
 	return args, nil
 }
 
@@ -143,7 +143,7 @@ func (req *RpcRequest) ToGetBalanceArgs() (*GetBalanceArgs, error) {
 	if err != nil {
 		return nil, NewErrorResponse(ErrorDecodeArgs)
 	}
-	jsonlogger.DebugDetailf("%T %v", args, args)
+	rpclogger.DebugDetailf("%T %v", args, args)
 	return args, nil
 }
 
@@ -158,7 +158,7 @@ func (req *RpcRequest) ToGetCodeAtArgs() (*GetCodeAtArgs, error) {
 	if err != nil {
 		return nil, NewErrorResponse(ErrorDecodeArgs)
 	}
-	jsonlogger.DebugDetailf("%T %v", args, args)
+	rpclogger.DebugDetailf("%T %v", args, args)
 	return args, nil
 }
 

rpc/packages.go

@@ -33,6 +33,15 @@ import (
 	"github.com/ethereum/go-ethereum/xeth"
 )
 
+type RpcServer interface {
+	Start()
+	Stop()
+}
+
+func NewEthereumApi(xeth *xeth.JSXEth) *EthereumApi {
+	return &EthereumApi{pipe: xeth}
+}
+
 type EthereumApi struct {
 	pipe *xeth.JSXEth
 }
@@ -103,7 +112,7 @@ func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *interface{}) err
 		i, _ := new(big.Int).SetString(args.Key, 10)
 		hx = ethutil.Bytes2Hex(i.Bytes())
 	}
-	jsonlogger.Debugf("GetStorageAt(%s, %s)\n", args.Address, hx)
+	rpclogger.Debugf("GetStorageAt(%s, %s)\n", args.Address, hx)
 	value := state.Storage(ethutil.Hex2Bytes(hx))
 	*reply = GetStorageAtRes{Address: args.Address, Key: args.Key, Value: value.Str()}
 	return nil
@@ -159,7 +168,7 @@ func (p *EthereumApi) GetCodeAt(args *GetCodeAtArgs, reply *interface{}) error {
 
 func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error {
 	// Spec at https://github.com/ethereum/wiki/wiki/Generic-JSON-RPC
-	jsonlogger.DebugDetailf("%T %s", req.Params, req.Params)
+	rpclogger.DebugDetailf("%T %s", req.Params, req.Params)
 	switch req.Method {
 	case "eth_coinbase":
 		return p.GetCoinbase(reply)
@@ -203,6 +212,6 @@ func (p *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) error
 		return NewErrorResponse(ErrorNotImplemented)
 	}
 
-	jsonlogger.DebugDetailf("Reply: %T %s", reply, reply)
+	rpclogger.DebugDetailf("Reply: %T %s", reply, reply)
 	return nil
 }