roysc/plugeth
1
0
Fork 0
forked from cerc-io/plugeth
Code Pull Requests Activity

Move HTTP transport to sub package of RPC

Browse Source
This commit is contained in:
Taylor Gerring 2015-01-25 14:50:43 -06:00
parent 7a894e3738
commit d790229a33
6 changed files with 66 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/utils/cmd.go
View File

@ -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 {

2
eth/backend.go
View File

@ -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

65
rpc/server.go → rpc/http/server.go
View File

@ -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() {
jsonlogger.Infoln("Starting JSON-RPC server")
func (s *RpcHttpServer) Start() {
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) {
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 {
func (s *RpcHttpServer) apiHandler(xeth *rpc.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)
JSON.Send(w, &RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: reserr.Error()})
rpchttplogger.Errorln(reserr)
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)
JSON.Send(w, &RpcSuccessResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: false, Result: response})
rpchttplogger.Debugf("Generated response: %T %s", response, response)
JSON.Send(w, &rpc.RpcSuccessResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: false, Result: response})
}
return http.HandlerFunc(fn)

19
rpc/json.go
View File

@ -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

14
rpc/message.go
View File

@ -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
}

15
rpc/packages.go
View File

@ -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
}