Merge pull request #2175 from karalabe/refactor-http-rpc

cmd, common, node, rpc: move HTTP RPC into node, drop singleton aspect

2 files changed, 39 insertions, 176 deletions

diff --git a/cmd/utils/client.go b/cmd/utils/client.go
index 40ebcd729..3913d007b 100644
--- a/cmd/utils/client.go
+++ b/cmd/utils/client.go
@@ -17,132 +17,14 @@
 package utils
 
 import (
-	"encoding/json"
 	"fmt"
-
 	"strings"
 
 	"github.com/codegangsta/cli"
-	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/logger"
-	"github.com/ethereum/go-ethereum/logger/glog"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
-// NewInProcRPCClient will start a new RPC server for the given node and returns a client to interact with it.
-func NewInProcRPCClient(stack *node.Node) *inProcClient {
-	server := rpc.NewServer()
-
-	offered := stack.APIs()
-	for _, api := range offered {
-		server.RegisterName(api.Namespace, api.Service)
-	}
-
-	web3 := node.NewPublicWeb3API(stack)
-	server.RegisterName("web3", web3)
-
-	var ethereum *eth.Ethereum
-	if err := stack.Service(&ethereum); err == nil {
-		net := eth.NewPublicNetAPI(stack.Server(), ethereum.NetVersion())
-		server.RegisterName("net", net)
-	} else {
-		glog.V(logger.Warn).Infof("%v\n", err)
-	}
-
-	buf := &buf{
-		requests:  make(chan []byte),
-		responses: make(chan []byte),
-	}
-	client := &inProcClient{
-		server: server,
-		buf:    buf,
-	}
-
-	go func() {
-		server.ServeCodec(rpc.NewJSONCodec(client.buf))
-	}()
-
-	return client
-}
-
-// buf represents the connection between the RPC server and console
-type buf struct {
-	readBuf   []byte      // store remaining request bytes after a partial read
-	requests  chan []byte // list with raw serialized requests
-	responses chan []byte // list with raw serialized responses
-}
-
-// will read the next request in json format
-func (b *buf) Read(p []byte) (int, error) {
-	// last read didn't read entire request, return remaining bytes
-	if len(b.readBuf) > 0 {
-		n := copy(p, b.readBuf)
-		if n < len(b.readBuf) {
-			b.readBuf = b.readBuf[:n]
-		} else {
-			b.readBuf = b.readBuf[:0]
-		}
-		return n, nil
-	}
-
-	// read next request
-	req := <-b.requests
-	n := copy(p, req)
-	if n < len(req) {
-		// buf too small, store remaining chunk for next read
-		b.readBuf = req[n:]
-	}
-
-	return n, nil
-}
-
-// Write send the given buffer to the backend
-func (b *buf) Write(p []byte) (n int, err error) {
-	b.responses <- p
-	return len(p), nil
-}
-
-// Close cleans up obtained resources.
-func (b *buf) Close() error {
-	close(b.requests)
-	close(b.responses)
-
-	return nil
-}
-
-// inProcClient starts a RPC server and uses buf to communicate with it.
-type inProcClient struct {
-	server *rpc.Server
-	buf    *buf
-}
-
-// Close will stop the RPC server
-func (c *inProcClient) Close() {
-	c.server.Stop()
-}
-
-// Send a msg to the endpoint
-func (c *inProcClient) Send(msg interface{}) error {
-	d, err := json.Marshal(msg)
-	if err != nil {
-		return err
-	}
-	c.buf.requests <- d
-	return nil
-}
-
-// Recv reads a message and tries to parse it into the given msg
-func (c *inProcClient) Recv(msg interface{}) error {
-	data := <-c.buf.responses
-	return json.Unmarshal(data, &msg)
-}
-
-// Returns the collection of modules the RPC server offers.
-func (c *inProcClient) SupportedModules() (map[string]string, error) {
-	return rpc.SupportedModules(c)
-}
-
 // NewRemoteRPCClient returns a RPC client which connects to a running geth instance.
 // Depending on the given context this can either be a IPC or a HTTP client.
 func NewRemoteRPCClient(ctx *cli.Context) (rpc.Client, error) {
@@ -151,7 +33,7 @@ func NewRemoteRPCClient(ctx *cli.Context) (rpc.Client, error) {
 		return NewRemoteRPCClientFromString(endpoint)
 	}
 	// use IPC by default
-	return rpc.NewIPCClient(node.DefaultIpcEndpoint())
+	return rpc.NewIPCClient(node.DefaultIPCEndpoint())
 }
 
 // NewRemoteRPCClientFromString returns a RPC client which connects to the given
@@ -169,6 +51,5 @@ func NewRemoteRPCClientFromString(endpoint string) (rpc.Client, error) {
 	if strings.HasPrefix(endpoint, "ws:") {
 		return rpc.NewWSClient(endpoint)
 	}
-
 	return nil, fmt.Errorf("invalid endpoint")
 }
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index ca9fd74ba..8e89b9fb1 100644
--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@@ -18,7 +18,6 @@ package utils
 
 import (
 	"crypto/ecdsa"
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"math"
@@ -233,12 +232,12 @@ var (
 	RPCListenAddrFlag = cli.StringFlag{
 		Name:  "rpcaddr",
 		Usage: "HTTP-RPC server listening interface",
-		Value: "127.0.0.1",
+		Value: common.DefaultHTTPHost,
 	}
 	RPCPortFlag = cli.IntFlag{
 		Name:  "rpcport",
 		Usage: "HTTP-RPC server listening port",
-		Value: 8545,
+		Value: common.DefaultHTTPPort,
 	}
 	RPCCORSDomainFlag = cli.StringFlag{
 		Name:  "rpccorsdomain",
@@ -248,7 +247,7 @@ var (
 	RPCApiFlag = cli.StringFlag{
 		Name:  "rpcapi",
 		Usage: "API's offered over the HTTP-RPC interface",
-		Value: rpc.DefaultHttpRpcApis,
+		Value: rpc.DefaultHTTPApis,
 	}
 	IPCDisabledFlag = cli.BoolFlag{
 		Name:  "ipcdisable",
@@ -257,12 +256,12 @@ var (
 	IPCApiFlag = cli.StringFlag{
 		Name:  "ipcapi",
 		Usage: "API's offered over the IPC-RPC interface",
-		Value: rpc.DefaultIpcApis,
+		Value: rpc.DefaultIPCApis,
 	}
 	IPCPathFlag = DirectoryFlag{
 		Name:  "ipcpath",
 		Usage: "Filename for IPC socket/pipe within the datadir (explicit paths escape it)",
-		Value: DirectoryString{common.DefaultIpcSocket()},
+		Value: DirectoryString{common.DefaultIPCSocket},
 	}
 	WSEnabledFlag = cli.BoolFlag{
 		Name:  "ws",
@@ -271,21 +270,21 @@ var (
 	WSListenAddrFlag = cli.StringFlag{
 		Name:  "wsaddr",
 		Usage: "WS-RPC server listening interface",
-		Value: "127.0.0.1",
+		Value: common.DefaultWSHost,
 	}
 	WSPortFlag = cli.IntFlag{
 		Name:  "wsport",
 		Usage: "WS-RPC server listening port",
-		Value: 8546,
+		Value: common.DefaultWSPort,
 	}
 	WSApiFlag = cli.StringFlag{
 		Name:  "wsapi",
 		Usage: "API's offered over the WS-RPC interface",
-		Value: rpc.DefaultHttpRpcApis,
+		Value: rpc.DefaultHTTPApis,
 	}
 	WSAllowedDomainsFlag = cli.StringFlag{
 		Name:  "wsdomains",
-		Usage: "Domains from which to accept websockets requests",
+		Usage: "Domains from which to accept websockets requests (can be spoofed)",
 		Value: "",
 	}
 	ExecFlag = cli.StringFlag{
@@ -394,9 +393,9 @@ func MustMakeDataDir(ctx *cli.Context) string {
 	return ""
 }
 
-// MakeIpcPath creates an IPC path configuration from the set command line flags,
+// MakeIPCPath creates an IPC path configuration from the set command line flags,
 // returning an empty string if IPC was explicitly disabled, or the set path.
-func MakeIpcPath(ctx *cli.Context) string {
+func MakeIPCPath(ctx *cli.Context) string {
 	if ctx.GlobalBool(IPCDisabledFlag.Name) {
 		return ""
 	}
@@ -482,6 +481,24 @@ func MakeNAT(ctx *cli.Context) nat.Interface {
 	return natif
 }
 
+// MakeHTTPRpcHost creates the HTTP RPC listener interface string from the set
+// command line flags, returning empty if the HTTP endpoint is disabled.
+func MakeHTTPRpcHost(ctx *cli.Context) string {
+	if !ctx.GlobalBool(RPCEnabledFlag.Name) {
+		return ""
+	}
+	return ctx.GlobalString(RPCListenAddrFlag.Name)
+}
+
+// MakeWSRpcHost creates the WebSocket RPC listener interface string from the set
+// command line flags, returning empty if the HTTP endpoint is disabled.
+func MakeWSRpcHost(ctx *cli.Context) string {
+	if !ctx.GlobalBool(WSEnabledFlag.Name) {
+		return ""
+	}
+	return ctx.GlobalString(WSListenAddrFlag.Name)
+}
+
 // MakeGenesisBlock loads up a genesis block from an input file specified in the
 // command line, or returns the empty string if none set.
 func MakeGenesisBlock(ctx *cli.Context) string {
@@ -591,7 +608,6 @@ func MakeSystemNode(name, version string, extra []byte, ctx *cli.Context) *node.
 	// Configure the node's service container
 	stackConf := &node.Config{
 		DataDir:         MustMakeDataDir(ctx),
-		IpcPath:         MakeIpcPath(ctx),
 		PrivateKey:      MakeNodeKey(ctx),
 		Name:            MakeNodeName(name, version, ctx),
 		NoDiscovery:     ctx.GlobalBool(NoDiscoverFlag.Name),
@@ -600,6 +616,15 @@ func MakeSystemNode(name, version string, extra []byte, ctx *cli.Context) *node.
 		NAT:             MakeNAT(ctx),
 		MaxPeers:        ctx.GlobalInt(MaxPeersFlag.Name),
 		MaxPendingPeers: ctx.GlobalInt(MaxPendingPeersFlag.Name),
+		IPCPath:         MakeIPCPath(ctx),
+		HTTPHost:        MakeHTTPRpcHost(ctx),
+		HTTPPort:        ctx.GlobalInt(RPCPortFlag.Name),
+		HTTPCors:        ctx.GlobalString(RPCCORSDomainFlag.Name),
+		HTTPModules:     strings.Split(ctx.GlobalString(RPCApiFlag.Name), ","),
+		WSHost:          MakeWSRpcHost(ctx),
+		WSPort:          ctx.GlobalInt(WSPortFlag.Name),
+		WSDomains:       ctx.GlobalString(WSAllowedDomainsFlag.Name),
+		WSModules:       strings.Split(ctx.GlobalString(WSApiFlag.Name), ","),
 	}
 	// Configure the Ethereum service
 	accman := MakeAccountManager(ctx)
@@ -740,48 +765,5 @@ func MakeChain(ctx *cli.Context) (chain *core.BlockChain, chainDb ethdb.Database
 	if err != nil {
 		Fatalf("Could not start chainmanager: %v", err)
 	}
-
 	return chain, chainDb
 }
-
-// StartRPC starts a HTTP JSON-RPC API server.
-func StartRPC(stack *node.Node, ctx *cli.Context) error {
-	for _, api := range stack.APIs() {
-		if adminApi, ok := api.Service.(*node.PrivateAdminAPI); ok {
-			address := ctx.GlobalString(RPCListenAddrFlag.Name)
-			port := ctx.GlobalInt(RPCPortFlag.Name)
-			cors := ctx.GlobalString(RPCCORSDomainFlag.Name)
-			apiStr := ""
-			if ctx.GlobalIsSet(RPCApiFlag.Name) {
-				apiStr = ctx.GlobalString(RPCApiFlag.Name)
-			}
-
-			_, err := adminApi.StartRPC(address, port, cors, apiStr)
-			return err
-		}
-	}
-
-	glog.V(logger.Error).Infof("Unable to start RPC-HTTP interface, could not find admin API")
-	return errors.New("Unable to start RPC-HTTP interface")
-}
-
-// StartWS starts a websocket JSON-RPC API server.
-func StartWS(stack *node.Node, ctx *cli.Context) error {
-	for _, api := range stack.APIs() {
-		if adminApi, ok := api.Service.(*node.PrivateAdminAPI); ok {
-			address := ctx.GlobalString(WSListenAddrFlag.Name)
-			port := ctx.GlobalInt(WSAllowedDomainsFlag.Name)
-			allowedDomains := ctx.GlobalString(WSAllowedDomainsFlag.Name)
-			apiStr := ""
-			if ctx.GlobalIsSet(WSApiFlag.Name) {
-				apiStr = ctx.GlobalString(WSApiFlag.Name)
-			}
-
-			_, err := adminApi.StartWS(address, port, allowedDomains, apiStr)
-			return err
-		}
-	}
-
-	glog.V(logger.Error).Infof("Unable to start RPC-WS interface, could not find admin API")
-	return errors.New("Unable to start RPC-WS interface")
-}