aboutsummaryrefslogtreecommitdiffstats
path: root/rpc
diff options
context:
space:
mode:
Diffstat (limited to 'rpc')
-rw-r--r--rpc/http/server.go (renamed from rpc/server.go)69
-rw-r--r--rpc/json.go19
-rw-r--r--rpc/message.go14
-rw-r--r--rpc/packages.go48
-rw-r--r--rpc/ws/server.go123
5 files changed, 203 insertions, 70 deletions
diff --git a/rpc/server.go b/rpc/http/server.go
index 9061c33ef..2a492f465 100644
--- a/rpc/server.go
+++ b/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,36 @@ 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,
+ port: port,
+ }, nil
+}
+
+type RpcHttpServer struct {
quit chan bool
listener net.Listener
pipe *xeth.JSXEth
+ port int
}
-func (s *JsonRpcServer) exitHandler() {
+func (s *RpcHttpServer) exitHandler() {
out:
for {
select {
@@ -43,63 +61,50 @@ 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.Infof("Starting RPC-HTTP server on port %d", s.port)
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(api *rpc.EthereumApi) http.Handler {
fn := func(w http.ResponseWriter, req *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
- 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)
+ reserr := api.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)
diff --git a/rpc/json.go b/rpc/json.go
index 5446cb3c1..9bd204818 100644
--- a/rpc/json.go
+++ b/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
diff --git a/rpc/message.go b/rpc/message.go
index 63de734b8..caf50a6c0 100644
--- a/rpc/message.go
+++ b/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
}
diff --git a/rpc/packages.go b/rpc/packages.go
index e87e0db7c..e6d4859d2 100644
--- a/rpc/packages.go
+++ b/rpc/packages.go
@@ -33,8 +33,17 @@ import (
"github.com/ethereum/go-ethereum/xeth"
)
+type RpcServer interface {
+ Start()
+ Stop()
+}
+
+func NewEthereumApi(xeth *xeth.JSXEth) *EthereumApi {
+ return &EthereumApi{xeth: xeth}
+}
+
type EthereumApi struct {
- pipe *xeth.JSXEth
+ xeth *xeth.JSXEth
}
func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
@@ -44,9 +53,9 @@ func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
}
if args.BlockNumber > 0 {
- *reply = p.pipe.BlockByNumber(args.BlockNumber)
+ *reply = p.xeth.BlockByNumber(args.BlockNumber)
} else {
- *reply = p.pipe.BlockByHash(args.Hash)
+ *reply = p.xeth.BlockByHash(args.Hash)
}
return nil
}
@@ -56,7 +65,7 @@ func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) error {
if err != nil {
return err
}
- result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
+ result, _ := p.xeth.Transact( /* TODO specify account */ "", args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
*reply = result
return nil
}
@@ -67,7 +76,7 @@ func (p *EthereumApi) Create(args *NewTxArgs, reply *interface{}) error {
return err
}
- result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, "", args.Value, args.Gas, args.GasPrice, args.Body)
+ result, _ := p.xeth.Transact( /* TODO specify account */ "", "", args.Value, args.Gas, args.GasPrice, args.Body)
*reply = result
return nil
}
@@ -77,23 +86,18 @@ func (p *EthereumApi) PushTx(args *PushTxArgs, reply *interface{}) error {
if err != nil {
return err
}
- result, _ := p.pipe.PushTx(args.Tx)
+ result, _ := p.xeth.PushTx(args.Tx)
*reply = result
return nil
}
-func (p *EthereumApi) GetKey(args interface{}, reply *interface{}) error {
- *reply = p.pipe.Key()
- return nil
-}
-
func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
- state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
+ state := p.xeth.State().SafeGet(args.Address)
var hx string
if strings.Index(args.Key, "0x") == 0 {
@@ -103,29 +107,29 @@ 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
}
func (p *EthereumApi) GetPeerCount(reply *interface{}) error {
- *reply = p.pipe.PeerCount()
+ *reply = p.xeth.PeerCount()
return nil
}
func (p *EthereumApi) GetIsListening(reply *interface{}) error {
- *reply = p.pipe.IsListening()
+ *reply = p.xeth.IsListening()
return nil
}
func (p *EthereumApi) GetCoinbase(reply *interface{}) error {
- *reply = p.pipe.CoinBase()
+ *reply = p.xeth.Coinbase()
return nil
}
func (p *EthereumApi) GetIsMining(reply *interface{}) error {
- *reply = p.pipe.IsMining()
+ *reply = p.xeth.IsMining()
return nil
}
@@ -134,7 +138,7 @@ func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *interface{}) err
if err != nil {
return err
}
- *reply = p.pipe.TxCountAt(args.Address)
+ *reply = p.xeth.TxCountAt(args.Address)
return nil
}
@@ -143,7 +147,7 @@ func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *interface{}) err
if err != nil {
return err
}
- state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
+ state := p.xeth.State().SafeGet(args.Address)
*reply = BalanceRes{Balance: state.Balance().String(), Address: args.Address}
return nil
}
@@ -153,13 +157,13 @@ func (p *EthereumApi) GetCodeAt(args *GetCodeAtArgs, reply *interface{}) error {
if err != nil {
return err
}
- *reply = p.pipe.CodeAt(args.Address)
+ *reply = p.xeth.CodeAt(args.Address)
return nil
}
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 +207,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
}
diff --git a/rpc/ws/server.go b/rpc/ws/server.go
new file mode 100644
index 000000000..248ebc585
--- /dev/null
+++ b/rpc/ws/server.go
@@ -0,0 +1,123 @@
+/*
+ This file is part of go-ethereum
+
+ go-ethereum is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ go-ethereum is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ 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 ws
+
+import (
+ "fmt"
+ "net"
+ "net/http"
+
+ "code.google.com/p/go.net/websocket"
+ "github.com/ethereum/go-ethereum/eth"
+ "github.com/ethereum/go-ethereum/event/filter"
+ "github.com/ethereum/go-ethereum/logger"
+ "github.com/ethereum/go-ethereum/rpc"
+ "github.com/ethereum/go-ethereum/xeth"
+)
+
+var wslogger = logger.NewLogger("RPC-WS")
+
+type WebSocketServer struct {
+ eth *eth.Ethereum
+ filterManager *filter.FilterManager
+ port int
+ doneCh chan bool
+ listener net.Listener
+}
+
+func NewWebSocketServer(eth *eth.Ethereum, port int) (*WebSocketServer, error) {
+ sport := fmt.Sprintf(":%d", port)
+ l, err := net.Listen("tcp", sport)
+ if err != nil {
+ return nil, err
+ }
+
+ filterManager := filter.NewFilterManager(eth.EventMux())
+ go filterManager.Start()
+
+ return &WebSocketServer{eth,
+ filterManager,
+ port,
+ make(chan bool),
+ l,
+ }, nil
+}
+
+func (self *WebSocketServer) handlerLoop() {
+ for {
+ select {
+ case <-self.doneCh:
+ wslogger.Infoln("Shutdown RPC-WS server")
+ return
+ }
+ }
+}
+
+func (self *WebSocketServer) Stop() {
+ close(self.doneCh)
+}
+
+func (self *WebSocketServer) Start() {
+ wslogger.Infof("Starting RPC-WS server on port %d", self.port)
+ go self.handlerLoop()
+
+ api := rpc.NewEthereumApi(xeth.NewJSXEth(self.eth))
+ h := self.apiHandler(api)
+ http.Handle("/ws", h)
+
+ err := http.Serve(self.listener, nil)
+ if err != nil {
+ wslogger.Errorln("Error on RPC-WS interface:", err)
+ }
+}
+
+func (s *WebSocketServer) apiHandler(api *rpc.EthereumApi) http.Handler {
+ fn := func(w http.ResponseWriter, req *http.Request) {
+ h := sockHandler(api)
+ s := websocket.Server{Handler: h}
+ s.ServeHTTP(w, req)
+ }
+
+ return http.HandlerFunc(fn)
+}
+
+func sockHandler(api *rpc.EthereumApi) websocket.Handler {
+ fn := func(conn *websocket.Conn) {
+ for {
+ wslogger.Debugln("Handling request")
+ var reqParsed rpc.RpcRequest
+
+ if err := websocket.JSON.Receive(conn, &reqParsed); err != nil {
+ wslogger.Debugln(rpc.ErrorParseRequest)
+ websocket.JSON.Send(conn, rpc.RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: rpc.ErrorParseRequest})
+ continue
+ }
+
+ var response interface{}
+ reserr := api.GetRequestReply(&reqParsed, &response)
+ if reserr != nil {
+ wslogger.Errorln(reserr)
+ websocket.JSON.Send(conn, rpc.RpcErrorResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: true, ErrorText: reserr.Error()})
+ continue
+ }
+
+ wslogger.Debugf("Generated response: %T %s", response, response)
+ websocket.JSON.Send(conn, rpc.RpcSuccessResponse{JsonRpc: reqParsed.JsonRpc, ID: reqParsed.ID, Error: false, Result: response})
+ }
+ }
+ return websocket.Handler(fn)
+}
generated by cgit (git 2.34.1) at 2024-11-14 22:44:09 +0800