aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cmd/ethereum/flags.go2
-rw-r--r--cmd/ethereum/main.go2
-rw-r--r--cmd/mist/flags.go2
-rw-r--r--cmd/mist/main.go2
-rw-r--r--cmd/utils/cmd.go20
-rw-r--r--eth/backend.go6
-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.go15
-rw-r--r--rpc/ws/server.go123
11 files changed, 214 insertions, 60 deletions
diff --git a/cmd/ethereum/flags.go b/cmd/ethereum/flags.go
index f829744dc..e0fbbb008 100644
--- a/cmd/ethereum/flags.go
+++ b/cmd/ethereum/flags.go
@@ -41,6 +41,7 @@ var (
StartRpc bool
StartWebSockets bool
RpcPort int
+ WsPort int
NatType string
PMPGateway string
OutboundPort string
@@ -96,6 +97,7 @@ func Init() {
flag.StringVar(&PMPGateway, "pmp", "", "Gateway IP for PMP")
flag.IntVar(&MaxPeer, "maxpeer", 30, "maximum desired peers")
flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
+ flag.IntVar(&WsPort, "wsport", 40404, "port to start websocket rpc server on")
flag.BoolVar(&StartRpc, "rpc", false, "start rpc server")
flag.BoolVar(&StartWebSockets, "ws", false, "start websocket server")
flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)")
diff --git a/cmd/ethereum/main.go b/cmd/ethereum/main.go
index b816c678e..92dbf5a6f 100644
--- a/cmd/ethereum/main.go
+++ b/cmd/ethereum/main.go
@@ -131,7 +131,7 @@ func main() {
}
if StartWebSockets {
- utils.StartWebSockets(ethereum)
+ utils.StartWebSockets(ethereum, WsPort)
}
utils.StartEthereum(ethereum, UseSeed)
diff --git a/cmd/mist/flags.go b/cmd/mist/flags.go
index 8a67cdd0a..f530394c2 100644
--- a/cmd/mist/flags.go
+++ b/cmd/mist/flags.go
@@ -43,6 +43,7 @@ var (
StartRpc bool
StartWebSockets bool
RpcPort int
+ WsPort int
UseUPnP bool
NatType string
OutboundPort string
@@ -111,6 +112,7 @@ func Init() {
flag.BoolVar(&UseUPnP, "upnp", true, "enable UPnP support")
flag.IntVar(&MaxPeer, "maxpeer", 30, "maximum desired peers")
flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
+ flag.IntVar(&WsPort, "wsport", 40404, "port to start websocket rpc server on")
flag.BoolVar(&StartRpc, "rpc", false, "start rpc server")
flag.BoolVar(&StartWebSockets, "ws", false, "start websocket server")
flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)")
diff --git a/cmd/mist/main.go b/cmd/mist/main.go
index eb0a80add..bcfb7f2ec 100644
--- a/cmd/mist/main.go
+++ b/cmd/mist/main.go
@@ -73,7 +73,7 @@ func run() error {
}
if StartWebSockets {
- utils.StartWebSockets(ethereum)
+ utils.StartWebSockets(ethereum, WsPort)
}
gui := NewWindow(ethereum, config, ethereum.ClientIdentity().(*p2p.SimpleClientIdentity), KeyRing, LogLevel)
diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go
index 95a7f89c8..9cdd8b5d1 100644
--- a/cmd/utils/cmd.go
+++ b/cmd/utils/cmd.go
@@ -38,9 +38,10 @@ 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"
+ rpcws "github.com/ethereum/go-ethereum/rpc/ws"
"github.com/ethereum/go-ethereum/state"
- "github.com/ethereum/go-ethereum/websocket"
+ // "github.com/ethereum/go-ethereum/websocket"
"github.com/ethereum/go-ethereum/xeth"
)
@@ -193,7 +194,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 {
@@ -201,11 +202,18 @@ func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
}
}
-func StartWebSockets(eth *eth.Ethereum) {
+func StartWebSockets(eth *eth.Ethereum, wsPort int) {
clilogger.Infoln("Starting WebSockets")
- sock := websocket.NewWebSocketServer(eth)
- go sock.Serv()
+ // sock := websocket.NewWebSocketServer(eth)
+ // go sock.Serv()
+ var err error
+ eth.WsServer, err = rpcws.NewWebSocketServer(eth, wsPort)
+ if err != nil {
+ clilogger.Errorf("Could not start RPC interface (port %v): %v", wsPort, err)
+ } else {
+ go eth.WsServer.Start()
+ }
}
var gminer *miner.Miner
diff --git a/eth/backend.go b/eth/backend.go
index c3c7d1287..ab30a1b38 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -66,7 +66,8 @@ type Ethereum struct {
txSub event.Subscription
blockSub event.Subscription
- RpcServer *rpc.JsonRpcServer
+ RpcServer rpc.RpcServer
+ WsServer rpc.RpcServer
keyManager *crypto.KeyManager
clientIdentity p2p.ClientIdentity
@@ -276,6 +277,9 @@ func (s *Ethereum) Stop() {
if s.RpcServer != nil {
s.RpcServer.Stop()
}
+ if s.WsServer != nil {
+ s.WsServer.Stop()
+ }
s.txPool.Stop()
s.eventMux.Stop()
s.blockPool.Stop()
diff --git a/rpc/server.go b/rpc/http/server.go
index a4cf1aa7c..93b52a634 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,61 +61,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.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) {
- 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..8b5965069 100644
--- a/rpc/packages.go
+++ b/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
}
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 v1.2.3 (git 2.25.1) at 2024-09-29 17:28:31 +0800