plugeth/rpc/comms/comms.go

132 lines
3.0 KiB
Go
Raw Normal View History

2015-06-08 08:41:04 +00:00
package comms
2015-06-16 09:16:50 +00:00
import (
"io"
"net"
2015-06-18 16:23:13 +00:00
"fmt"
"strings"
2015-06-19 10:32:40 +00:00
"strconv"
2015-06-16 09:16:50 +00:00
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/logger/glog"
"github.com/ethereum/go-ethereum/rpc/codec"
"github.com/ethereum/go-ethereum/rpc/shared"
)
2015-06-16 11:07:13 +00:00
const (
maxHttpSizeReqLength = 1024 * 1024 // 1MB
)
var (
// List with all API's which are offered over the in proc interface by default
2015-06-22 10:47:32 +00:00
DefaultInProcApis = shared.AllApis
// List with all API's which are offered over the IPC interface by default
2015-06-22 10:47:32 +00:00
DefaultIpcApis = shared.AllApis
// List with API's which are offered over thr HTTP/RPC interface by default
DefaultHttpRpcApis = strings.Join([]string{
2015-06-22 10:47:32 +00:00
shared.DbApiName, shared.EthApiName, shared.NetApiName, shared.Web3ApiName,
2015-06-18 16:23:13 +00:00
}, ",")
)
2015-06-08 08:41:04 +00:00
type EthereumClient interface {
// Close underlaying connection
2015-06-08 08:41:04 +00:00
Close()
// Send request
2015-06-08 08:41:04 +00:00
Send(interface{}) error
// Receive response
2015-06-08 08:41:04 +00:00
Recv() (interface{}, error)
2015-06-18 16:23:13 +00:00
// List with modules this client supports
SupportedModules() (map[string]string, error)
2015-06-08 08:41:04 +00:00
}
2015-06-16 09:16:50 +00:00
func handle(id int, conn net.Conn, api shared.EthereumApi, c codec.Codec) {
2015-06-16 09:16:50 +00:00
codec := c.New(conn)
for {
2015-06-25 10:01:28 +00:00
requests, isBatch, err := codec.ReadRequest()
2015-06-16 09:16:50 +00:00
if err == io.EOF {
codec.Close()
return
} else if err != nil {
codec.Close()
glog.V(logger.Debug).Infof("Closed IPC Conn %06d recv err - %v\n", id, err)
2015-06-16 09:16:50 +00:00
return
}
2015-06-25 10:01:28 +00:00
if isBatch {
responses := make([]*interface{}, len(requests))
responseCount := 0
for _, req := range requests {
res, err := api.Execute(req)
if req.Id != nil {
rpcResponse := shared.NewRpcResponse(req.Id, req.Jsonrpc, res, err)
responses[responseCount] = rpcResponse
responseCount += 1
}
}
2015-06-16 09:16:50 +00:00
2015-06-25 10:01:28 +00:00
err = codec.WriteResponse(responses[:responseCount])
if err != nil {
codec.Close()
glog.V(logger.Debug).Infof("Closed IPC Conn %06d send err - %v\n", id, err)
2015-06-25 10:01:28 +00:00
return
}
} else {
var rpcResponse interface{}
res, err := api.Execute(requests[0])
rpcResponse = shared.NewRpcResponse(requests[0].Id, requests[0].Jsonrpc, res, err)
err = codec.WriteResponse(rpcResponse)
if err != nil {
codec.Close()
glog.V(logger.Debug).Infof("Closed IPC Conn %06d send err - %v\n", id, err)
2015-06-25 10:01:28 +00:00
return
}
2015-06-16 09:16:50 +00:00
}
}
}
2015-06-18 16:23:13 +00:00
// Endpoint must be in the form of:
// ${protocol}:${path}
// e.g. ipc:/tmp/geth.ipc
// rpc:localhost:8545
func ClientFromEndpoint(endpoint string, c codec.Codec) (EthereumClient, error) {
if strings.HasPrefix(endpoint, "ipc:") {
cfg := IpcConfig{
Endpoint: endpoint[4:],
}
return NewIpcClient(cfg, codec.JSON)
}
if strings.HasPrefix(endpoint, "rpc:") {
2015-06-19 10:32:40 +00:00
parts := strings.Split(endpoint, ":")
addr := "http://localhost"
port := uint(8545)
if len(parts) >= 3 {
addr = parts[1] + ":" + parts[2]
}
if len(parts) >= 4 {
p, err := strconv.Atoi(parts[3])
if err != nil {
return nil, err
}
port = uint(p)
}
cfg := HttpConfig{
ListenAddress: addr,
ListenPort: port,
}
2015-06-18 16:23:13 +00:00
2015-06-19 10:32:40 +00:00
return NewHttpClient(cfg, codec.JSON), nil
2015-06-18 16:23:13 +00:00
}
return nil, fmt.Errorf("Invalid endpoint")
}