Merge branch 'jsonrpc' of github.com-obscure:ethereum/go-ethereum into jsonrpc

5 files changed, 189 insertions, 51 deletions

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)
+}