aboutsummaryrefslogtreecommitdiffstats
path: root/rpc
diff options
context:
space:
mode:
Diffstat (limited to 'rpc')
-rw-r--r--rpc/args.go218
-rw-r--r--rpc/json.go37
-rw-r--r--rpc/message.go169
-rw-r--r--rpc/packages.go319
-rw-r--r--rpc/server.go61
-rw-r--r--rpc/writer.go75
6 files changed, 573 insertions, 306 deletions
diff --git a/rpc/args.go b/rpc/args.go
new file mode 100644
index 000000000..8b01cc191
--- /dev/null
+++ b/rpc/args.go
@@ -0,0 +1,218 @@
+package rpc
+
+import (
+ "encoding/json"
+)
+
+type GetBlockArgs struct {
+ BlockNumber int32
+ Hash string
+}
+
+func (obj *GetBlockArgs) UnmarshalJSON(b []byte) (err error) {
+ argint, argstr := int32(0), ""
+ if err = json.Unmarshal(b, &argint); err == nil {
+ obj.BlockNumber = argint
+ return
+ }
+ if err = json.Unmarshal(b, &argstr); err == nil {
+ obj.Hash = argstr
+ return
+ }
+ return NewErrorResponse(ErrorDecodeArgs)
+}
+
+func (obj *GetBlockArgs) requirements() error {
+ if obj.BlockNumber == 0 && obj.Hash == "" {
+ return NewErrorResponse("GetBlock requires either a block 'number' or a block 'hash' as argument")
+ }
+ return nil
+}
+
+type NewTxArgs struct {
+ Sec string `json:"sec"`
+ Recipient string `json:"recipient"`
+ Value string `json:"value"`
+ Gas string `json:"gas"`
+ GasPrice string `json:"gasprice"`
+ Init string `json:"init"`
+ Body string `json:"body"`
+}
+
+// type TxResponse struct {
+// Hash string
+// }
+
+func (obj *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
+ if err = json.Unmarshal(b, obj); err == nil {
+ return
+ }
+ return NewErrorResponse(ErrorDecodeArgs)
+}
+
+func (a *NewTxArgs) requirements() error {
+ if a.Recipient == "" {
+ return NewErrorResponse("Transact requires a 'recipient' address as argument")
+ }
+ if a.Value == "" {
+ return NewErrorResponse("Transact requires a 'value' as argument")
+ }
+ if a.Gas == "" {
+ return NewErrorResponse("Transact requires a 'gas' value as argument")
+ }
+ if a.GasPrice == "" {
+ return NewErrorResponse("Transact requires a 'gasprice' value as argument")
+ }
+ return nil
+}
+
+func (a *NewTxArgs) requirementsContract() error {
+ if a.Value == "" {
+ return NewErrorResponse("Create requires a 'value' as argument")
+ }
+ if a.Gas == "" {
+ return NewErrorResponse("Create requires a 'gas' value as argument")
+ }
+ if a.GasPrice == "" {
+ return NewErrorResponse("Create requires a 'gasprice' value as argument")
+ }
+ if a.Body == "" {
+ return NewErrorResponse("Create requires a 'body' value as argument")
+ }
+ return nil
+}
+
+type PushTxArgs struct {
+ Tx string `json:"tx"`
+}
+
+func (obj *PushTxArgs) UnmarshalJSON(b []byte) (err error) {
+ arg0 := ""
+ if err = json.Unmarshal(b, arg0); err == nil {
+ obj.Tx = arg0
+ return
+ }
+ return NewErrorResponse(ErrorDecodeArgs)
+}
+
+func (a *PushTxArgs) requirementsPushTx() error {
+ if a.Tx == "" {
+ return NewErrorResponse("PushTx requires a 'tx' as argument")
+ }
+ return nil
+}
+
+type GetStorageArgs struct {
+ Address string
+ Key string
+}
+
+func (obj *GetStorageArgs) UnmarshalJSON(b []byte) (err error) {
+ arg0 := ""
+ if err = json.Unmarshal(b, arg0); err == nil {
+ obj.Address = arg0
+ return
+ }
+ return NewErrorResponse(ErrorDecodeArgs)
+}
+
+func (a *GetStorageArgs) requirements() error {
+ if a.Address == "" {
+ return NewErrorResponse("GetStorageAt requires an 'address' value as argument")
+ }
+ if a.Key == "" {
+ return NewErrorResponse("GetStorageAt requires an 'key' value as argument")
+ }
+ return nil
+}
+
+type GetStorageAtRes struct {
+ Key string `json:"key"`
+ Value string `json:"value"`
+ Address string `json:"address"`
+}
+
+type GetTxCountArgs struct {
+ Address string `json:"address"`
+}
+
+// type GetTxCountRes struct {
+// Nonce int `json:"nonce"`
+// }
+
+func (obj *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
+ arg0 := ""
+ if err = json.Unmarshal(b, arg0); err == nil {
+ obj.Address = arg0
+ return
+ }
+ return NewErrorResponse("Could not determine JSON parameters")
+}
+
+func (a *GetTxCountArgs) requirements() error {
+ if a.Address == "" {
+ return NewErrorResponse("GetTxCountAt requires an 'address' value as argument")
+ }
+ return nil
+}
+
+// type GetPeerCountRes struct {
+// PeerCount int `json:"peerCount"`
+// }
+
+// type GetListeningRes struct {
+// IsListening bool `json:"isListening"`
+// }
+
+// type GetCoinbaseRes struct {
+// Coinbase string `json:"coinbase"`
+// }
+
+// type GetMiningRes struct {
+// IsMining bool `json:"isMining"`
+// }
+
+type GetBalanceArgs struct {
+ Address string
+}
+
+func (obj *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
+ arg0 := ""
+ if err = json.Unmarshal(b, &arg0); err == nil {
+ obj.Address = arg0
+ return
+ }
+ return NewErrorResponse("Could not determine JSON parameters")
+}
+
+func (a *GetBalanceArgs) requirements() error {
+ if a.Address == "" {
+ return NewErrorResponse("GetBalanceAt requires an 'address' value as argument")
+ }
+ return nil
+}
+
+type BalanceRes struct {
+ Balance string `json:"balance"`
+ Address string `json:"address"`
+}
+
+type GetCodeAtArgs struct {
+ Address string
+}
+
+func (obj *GetCodeAtArgs) UnmarshalJSON(b []byte) (err error) {
+ arg0 := ""
+ if err = json.Unmarshal(b, &arg0); err == nil {
+ obj.Address = arg0
+ return
+ }
+ return NewErrorResponse(ErrorDecodeArgs)
+}
+
+func (a *GetCodeAtArgs) requirements() error {
+ if a.Address == "" {
+ return NewErrorResponse("GetCodeAt requires an 'address' value as argument")
+ }
+ return nil
+}
diff --git a/rpc/json.go b/rpc/json.go
index e467f9a34..5446cb3c1 100644
--- a/rpc/json.go
+++ b/rpc/json.go
@@ -1,8 +1,25 @@
+/*
+ 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 rpc
import (
"encoding/json"
"io"
+ "net/http"
)
type jsonWrapper struct{}
@@ -11,10 +28,30 @@ 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)
return 0, err
}
+ jsonlogger.Infof("Sending payload: %s", payload)
return writer.Write(payload)
}
+func (self jsonWrapper) ParseRequestBody(req *http.Request) (RpcRequest, error) {
+ var reqParsed RpcRequest
+
+ // Convert JSON to native types
+ d := json.NewDecoder(req.Body)
+ // d.UseNumber()
+ defer req.Body.Close()
+ err := d.Decode(&reqParsed)
+
+ if err != nil {
+ jsonlogger.Errorln("Error decoding JSON: ", err)
+ return reqParsed, err
+ }
+ jsonlogger.DebugDetailf("Parsed request: %s", reqParsed)
+
+ return reqParsed, nil
+}
+
var JSON jsonWrapper
diff --git a/rpc/message.go b/rpc/message.go
index c8103eded..63de734b8 100644
--- a/rpc/message.go
+++ b/rpc/message.go
@@ -1,14 +1,167 @@
+/*
+ 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 rpc
-import "github.com/ethereum/go-ethereum/ethutil"
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+)
+
+const (
+ ErrorArguments = "Error: Insufficient arguments"
+ ErrorNotImplemented = "Error: Method not implemented"
+ ErrorUnknown = "Error: Unknown error"
+ ErrorParseRequest = "Error: Could not parse request"
+ ErrorDecodeArgs = "Error: Could not decode arguments"
+)
+
+type ErrorResponse struct {
+ Error bool `json:"error"`
+ ErrorText string `json:"errorText"`
+}
+
+type RpcSuccessResponse struct {
+ ID int `json:"id"`
+ JsonRpc string `json:"jsonrpc"`
+ Error bool `json:"error"`
+ Result interface{} `json:"result"`
+}
+
+type RpcErrorResponse struct {
+ ID int `json:"id"`
+ JsonRpc string `json:"jsonrpc"`
+ Error bool `json:"error"`
+ ErrorText string `json:"errortext"`
+}
+
+type RpcRequest struct {
+ JsonRpc string `json:"jsonrpc"`
+ ID int `json:"id"`
+ Method string `json:"method"`
+ Params []json.RawMessage `json:"params"`
+}
+
+func (req *RpcRequest) ToGetBlockArgs() (*GetBlockArgs, error) {
+ if len(req.Params) < 1 {
+ return nil, NewErrorResponse(ErrorArguments)
+ }
+
+ args := new(GetBlockArgs)
+ r := bytes.NewReader(req.Params[0])
+ err := json.NewDecoder(r).Decode(args)
+ if err != nil {
+ return nil, NewErrorResponse(ErrorDecodeArgs)
+ }
+ jsonlogger.DebugDetailf("%T %v", args, args)
+ return args, nil
+}
+
+func (req *RpcRequest) ToNewTxArgs() (*NewTxArgs, error) {
+ if len(req.Params) < 7 {
+ return nil, NewErrorResponse(ErrorArguments)
+ }
+
+ args := new(NewTxArgs)
+ r := bytes.NewReader(req.Params[0])
+ err := json.NewDecoder(r).Decode(args)
+ if err != nil {
+ return nil, NewErrorResponse(ErrorDecodeArgs)
+ }
+ jsonlogger.DebugDetailf("%T %v", args, args)
+ return args, nil
+}
+
+func (req *RpcRequest) ToPushTxArgs() (*PushTxArgs, error) {
+ if len(req.Params) < 1 {
+ return nil, NewErrorResponse(ErrorArguments)
+ }
+
+ args := new(PushTxArgs)
+ r := bytes.NewReader(req.Params[0])
+ err := json.NewDecoder(r).Decode(args)
+ if err != nil {
+ return nil, NewErrorResponse(ErrorDecodeArgs)
+ }
+ jsonlogger.DebugDetailf("%T %v", args, args)
+ return args, nil
+}
+
+func (req *RpcRequest) ToGetStorageArgs() (*GetStorageArgs, error) {
+ if len(req.Params) < 2 {
+ return nil, NewErrorResponse(ErrorArguments)
+ }
+
+ args := new(GetStorageArgs)
+ // TODO need to pass both arguments
+ r := bytes.NewReader(req.Params[0])
+ err := json.NewDecoder(r).Decode(args)
+ if err != nil {
+ return nil, NewErrorResponse(ErrorDecodeArgs)
+ }
+ jsonlogger.DebugDetailf("%T %v", args, args)
+ return args, nil
+}
+
+func (req *RpcRequest) ToGetTxCountArgs() (*GetTxCountArgs, error) {
+ if len(req.Params) < 1 {
+ return nil, NewErrorResponse(ErrorArguments)
+ }
+
+ args := new(GetTxCountArgs)
+ r := bytes.NewReader(req.Params[0])
+ err := json.NewDecoder(r).Decode(args)
+ if err != nil {
+ return nil, NewErrorResponse(ErrorDecodeArgs)
+ }
+ jsonlogger.DebugDetailf("%T %v", args, args)
+ return args, nil
+}
+
+func (req *RpcRequest) ToGetBalanceArgs() (*GetBalanceArgs, error) {
+ if len(req.Params) < 1 {
+ return nil, NewErrorResponse(ErrorArguments)
+ }
+
+ args := new(GetBalanceArgs)
+ r := bytes.NewReader(req.Params[0])
+ err := json.NewDecoder(r).Decode(args)
+ if err != nil {
+ return nil, NewErrorResponse(ErrorDecodeArgs)
+ }
+ jsonlogger.DebugDetailf("%T %v", args, args)
+ return args, nil
+}
+
+func (req *RpcRequest) ToGetCodeAtArgs() (*GetCodeAtArgs, error) {
+ if len(req.Params) < 1 {
+ return nil, NewErrorResponse(ErrorArguments)
+ }
-type Message struct {
- Call string `json:"call"`
- Args []interface{} `json:"args"`
- Id int `json:"_id"`
- Data interface{} `json:"data"`
+ args := new(GetCodeAtArgs)
+ r := bytes.NewReader(req.Params[0])
+ err := json.NewDecoder(r).Decode(args)
+ if err != nil {
+ return nil, NewErrorResponse(ErrorDecodeArgs)
+ }
+ jsonlogger.DebugDetailf("%T %v", args, args)
+ return args, nil
}
-func (self *Message) Arguments() *ethutil.Value {
- return ethutil.NewValue(self.Args)
+func NewErrorResponse(msg string) error {
+ return errors.New(msg)
}
diff --git a/rpc/packages.go b/rpc/packages.go
index 5535e6e79..e87e0db7c 100644
--- a/rpc/packages.go
+++ b/rpc/packages.go
@@ -1,8 +1,31 @@
+/*
+ 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/>.
+*/
+/*
+
+For each request type, define the following:
+
+1. RpcRequest "To" method [message.go], which does basic validation and conversion to "Args" type via json.Decoder()
+2. json.Decoder() calls "UnmarshalJSON" defined on each "Args" struct
+3. EthereumApi method, taking the "Args" type and replying with an interface to be marshalled to JSON
+
+*/
package rpc
import (
- "encoding/json"
- "errors"
"math/big"
"strings"
@@ -14,185 +37,57 @@ type EthereumApi struct {
pipe *xeth.JSXEth
}
-type JsonArgs interface {
- requirements() error
-}
-
-type BlockResponse struct {
- JsonResponse
-}
-type GetBlockArgs struct {
- BlockNumber int
- Hash string
-}
-
-type ErrorResponse struct {
- Error bool `json:"error"`
- ErrorText string `json:"errorText"`
-}
-
-type JsonResponse interface {
-}
-
-type SuccessRes struct {
- Error bool `json:"error"`
- Result JsonResponse `json:"result"`
-}
-
-func NewSuccessRes(object JsonResponse) string {
- e := SuccessRes{Error: false, Result: object}
- res, err := json.Marshal(e)
- if err != nil {
- // This should never happen
- panic("Creating json error response failed, help")
- }
- success := string(res)
- return success
-}
-
-func NewErrorResponse(msg string) error {
- e := ErrorResponse{Error: true, ErrorText: msg}
- res, err := json.Marshal(e)
- if err != nil {
- // This should never happen
- panic("Creating json error response failed, help")
- }
- newErr := errors.New(string(res))
- return newErr
-}
-
-func (b *GetBlockArgs) requirements() error {
- if b.BlockNumber == 0 && b.Hash == "" {
- return NewErrorResponse("GetBlock requires either a block 'number' or a block 'hash' as argument")
- }
- return nil
-}
-
-func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *string) error {
+func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
- block := p.pipe.BlockByHash(args.Hash)
- *reply = NewSuccessRes(block)
- return nil
-}
-
-type NewTxArgs struct {
- Sec string
- Recipient string
- Value string
- Gas string
- GasPrice string
- Init string
- Body string
-}
-type TxResponse struct {
- Hash string
-}
-
-func (a *NewTxArgs) requirements() error {
- if a.Recipient == "" {
- return NewErrorResponse("Transact requires a 'recipient' address as argument")
- }
- if a.Value == "" {
- return NewErrorResponse("Transact requires a 'value' as argument")
- }
- if a.Gas == "" {
- return NewErrorResponse("Transact requires a 'gas' value as argument")
- }
- if a.GasPrice == "" {
- return NewErrorResponse("Transact requires a 'gasprice' value as argument")
- }
- return nil
-}
-
-func (a *NewTxArgs) requirementsContract() error {
- if a.Value == "" {
- return NewErrorResponse("Create requires a 'value' as argument")
- }
- if a.Gas == "" {
- return NewErrorResponse("Create requires a 'gas' value as argument")
- }
- if a.GasPrice == "" {
- return NewErrorResponse("Create requires a 'gasprice' value as argument")
- }
- if a.Body == "" {
- return NewErrorResponse("Create requires a 'body' value as argument")
+ if args.BlockNumber > 0 {
+ *reply = p.pipe.BlockByNumber(args.BlockNumber)
+ } else {
+ *reply = p.pipe.BlockByHash(args.Hash)
}
return nil
}
-func (p *EthereumApi) Transact(args *NewTxArgs, reply *string) error {
+func (p *EthereumApi) Transact(args *NewTxArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
- *reply = NewSuccessRes(result)
+ *reply = result
return nil
}
-func (p *EthereumApi) Create(args *NewTxArgs, reply *string) error {
+func (p *EthereumApi) Create(args *NewTxArgs, reply *interface{}) error {
err := args.requirementsContract()
if err != nil {
return err
}
result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, "", args.Value, args.Gas, args.GasPrice, args.Body)
- *reply = NewSuccessRes(result)
- return nil
-}
-
-type PushTxArgs struct {
- Tx string
-}
-
-func (a *PushTxArgs) requirementsPushTx() error {
- if a.Tx == "" {
- return NewErrorResponse("PushTx requires a 'tx' as argument")
- }
+ *reply = result
return nil
}
-func (p *EthereumApi) PushTx(args *PushTxArgs, reply *string) error {
+func (p *EthereumApi) PushTx(args *PushTxArgs, reply *interface{}) error {
err := args.requirementsPushTx()
if err != nil {
return err
}
result, _ := p.pipe.PushTx(args.Tx)
- *reply = NewSuccessRes(result)
+ *reply = result
return nil
}
-func (p *EthereumApi) GetKey(args interface{}, reply *string) error {
- *reply = NewSuccessRes(p.pipe.Key())
+func (p *EthereumApi) GetKey(args interface{}, reply *interface{}) error {
+ *reply = p.pipe.Key()
return nil
}
-type GetStorageArgs struct {
- Address string
- Key string
-}
-
-func (a *GetStorageArgs) requirements() error {
- if a.Address == "" {
- return NewErrorResponse("GetStorageAt requires an 'address' value as argument")
- }
- if a.Key == "" {
- return NewErrorResponse("GetStorageAt requires an 'key' value as argument")
- }
- return nil
-}
-
-type GetStorageAtRes struct {
- Key string `json:"key"`
- Value string `json:"value"`
- Address string `json:"address"`
-}
-
-func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *string) error {
+func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
@@ -210,102 +105,104 @@ func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *string) error {
}
jsonlogger.Debugf("GetStorageAt(%s, %s)\n", args.Address, hx)
value := state.Storage(ethutil.Hex2Bytes(hx))
- *reply = NewSuccessRes(GetStorageAtRes{Address: args.Address, Key: args.Key, Value: value.Str()})
+ *reply = GetStorageAtRes{Address: args.Address, Key: args.Key, Value: value.Str()}
return nil
}
-type GetTxCountArgs struct {
- Address string `json:"address"`
-}
-type GetTxCountRes struct {
- Nonce int `json:"nonce"`
-}
-
-func (a *GetTxCountArgs) requirements() error {
- if a.Address == "" {
- return NewErrorResponse("GetTxCountAt requires an 'address' value as argument")
- }
+func (p *EthereumApi) GetPeerCount(reply *interface{}) error {
+ *reply = p.pipe.PeerCount()
return nil
}
-type GetPeerCountRes struct {
- PeerCount int `json:"peerCount"`
-}
-
-func (p *EthereumApi) GetPeerCount(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetPeerCountRes{PeerCount: p.pipe.PeerCount()})
+func (p *EthereumApi) GetIsListening(reply *interface{}) error {
+ *reply = p.pipe.IsListening()
return nil
}
-type GetListeningRes struct {
- IsListening bool `json:"isListening"`
-}
-
-func (p *EthereumApi) GetIsListening(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetListeningRes{IsListening: p.pipe.IsListening()})
+func (p *EthereumApi) GetCoinbase(reply *interface{}) error {
+ *reply = p.pipe.CoinBase()
return nil
}
-type GetCoinbaseRes struct {
- Coinbase string `json:"coinbase"`
-}
-
-func (p *EthereumApi) GetCoinbase(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetCoinbaseRes{Coinbase: p.pipe.CoinBase()})
+func (p *EthereumApi) GetIsMining(reply *interface{}) error {
+ *reply = p.pipe.IsMining()
return nil
}
-type GetMiningRes struct {
- IsMining bool `json:"isMining"`
-}
-
-func (p *EthereumApi) GetIsMining(args *interface{}, reply *string) error {
- *reply = NewSuccessRes(GetMiningRes{IsMining: p.pipe.IsMining()})
- return nil
-}
-
-func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *string) error {
+func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
- state := p.pipe.TxCountAt(args.Address)
- *reply = NewSuccessRes(GetTxCountRes{Nonce: state})
- return nil
-}
-
-type GetBalanceArgs struct {
- Address string
-}
-
-func (a *GetBalanceArgs) requirements() error {
- if a.Address == "" {
- return NewErrorResponse("GetBalanceAt requires an 'address' value as argument")
- }
+ *reply = p.pipe.TxCountAt(args.Address)
return nil
}
-type BalanceRes struct {
- Balance string `json:"balance"`
- Address string `json:"address"`
-}
-
-func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *string) error {
+func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *interface{}) error {
err := args.requirements()
if err != nil {
return err
}
state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
- *reply = NewSuccessRes(BalanceRes{Balance: state.Balance().String(), Address: args.Address})
+ *reply = BalanceRes{Balance: state.Balance().String(), Address: args.Address}
return nil
}
-type TestRes struct {
- JsonResponse `json:"-"`
- Answer int `json:"answer"`
-}
-
-func (p *EthereumApi) Test(args *GetBlockArgs, reply *string) error {
- *reply = NewSuccessRes(TestRes{Answer: 15})
+func (p *EthereumApi) GetCodeAt(args *GetCodeAtArgs, reply *interface{}) error {
+ err := args.requirements()
+ if err != nil {
+ return err
+ }
+ *reply = p.pipe.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)
+ switch req.Method {
+ case "eth_coinbase":
+ return p.GetCoinbase(reply)
+ case "eth_listening":
+ return p.GetIsListening(reply)
+ case "eth_mining":
+ return p.GetIsMining(reply)
+ case "eth_peerCount":
+ return p.GetPeerCount(reply)
+ case "eth_countAt":
+ args, err := req.ToGetTxCountArgs()
+ if err != nil {
+ return err
+ }
+ return p.GetTxCountAt(args, reply)
+ case "eth_codeAt":
+ args, err := req.ToGetCodeAtArgs()
+ if err != nil {
+ return err
+ }
+ return p.GetCodeAt(args, reply)
+ case "eth_balanceAt":
+ args, err := req.ToGetBalanceArgs()
+ if err != nil {
+ return err
+ }
+ return p.GetBalanceAt(args, reply)
+ case "eth_stateAt":
+ args, err := req.ToGetStorageArgs()
+ if err != nil {
+ return err
+ }
+ return p.GetStorageAt(args, reply)
+ case "eth_blockByNumber", "eth_blockByHash":
+ args, err := req.ToGetBlockArgs()
+ if err != nil {
+ return err
+ }
+ return p.GetBlock(args, reply)
+ default:
+ return NewErrorResponse(ErrorNotImplemented)
+ }
+
+ jsonlogger.DebugDetailf("Reply: %T %s", reply, reply)
return nil
}
diff --git a/rpc/server.go b/rpc/server.go
index 983dc6c33..a4cf1aa7c 100644
--- a/rpc/server.go
+++ b/rpc/server.go
@@ -1,10 +1,25 @@
+/*
+ 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 rpc
import (
"fmt"
"net"
- "net/rpc"
- "net/rpc/jsonrpc"
+ "net/http"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/xeth"
@@ -38,17 +53,14 @@ func (s *JsonRpcServer) Stop() {
func (s *JsonRpcServer) Start() {
jsonlogger.Infoln("Starting JSON-RPC server")
go s.exitHandler()
- rpc.Register(&EthereumApi{pipe: s.pipe})
- rpc.HandleHTTP()
- for {
- conn, err := s.listener.Accept()
- if err != nil {
- jsonlogger.Infoln("Error starting JSON-RPC:", err)
- break
- }
- jsonlogger.Debugln("Incoming request.")
- go jsonrpc.ServeConn(conn)
+ h := apiHandler(&EthereumApi{pipe: s.pipe})
+ 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)
}
}
@@ -65,3 +77,28 @@ func NewJsonRpcServer(pipe *xeth.JSXEth, port int) (*JsonRpcServer, error) {
pipe: pipe,
}, nil
}
+
+func apiHandler(xeth *EthereumApi) http.Handler {
+ fn := func(w http.ResponseWriter, req *http.Request) {
+ jsonlogger.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})
+ return
+ }
+
+ var response interface{}
+ reserr := xeth.GetRequestReply(&reqParsed, &response)
+ if reserr != nil {
+ jsonlogger.Errorln(reserr)
+ JSON.Send(w, &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})
+ }
+
+ return http.HandlerFunc(fn)
+}
diff --git a/rpc/writer.go b/rpc/writer.go
deleted file mode 100644
index 4cc39f577..000000000
--- a/rpc/writer.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package rpc
-
-/*
-func pack(id int, v ...interface{}) Message {
- return Message{Data: v, Id: id}
-}
-
-func WriteOn(msg *Message, writer io.Writer) {
- //msg := &Message{Seed: seed, Data: data}
-
- switch msg.Call {
- case "compile":
- data := ethutil.NewValue(msg.Args)
- bcode, err := ethutil.Compile(data.Get(0).Str(), false)
- if err != nil {
- JSON.Send(writer, pack(msg.Id, err.Error()))
- }
-
- code := ethutil.Bytes2Hex(bcode)
-
- JSON.Send(writer, pack(msg.Id, code, nil))
- case "block":
- args := msg.Arguments()
-
- block := pipe.BlockByNumber(int32(args.Get(0).Uint()))
-
- JSON.Send(writer, pack(msg.Id, block))
- case "transact":
- if mp, ok := msg.Args[0].(map[string]interface{}); ok {
- object := mapToTxParams(mp)
- JSON.Send(
- writer,
- pack(msg.Id, args(pipe.Transact(object["from"], object["to"], object["value"], object["gas"], object["gasPrice"], object["data"]))),
- )
-
- }
- case "coinbase":
- JSON.Send(writer, pack(msg.Id, pipe.CoinBase(), msg.Seed))
-
- case "listening":
- JSON.Send(writer, pack(msg.Id, pipe.IsListening()))
-
- case "mining":
- JSON.Send(writer, pack(msg.Id, pipe.IsMining()))
-
- case "peerCoint":
- JSON.Send(writer, pack(msg.Id, pipe.PeerCount()))
-
- case "countAt":
- args := msg.Arguments()
-
- JSON.Send(writer, pack(msg.Id, pipe.TxCountAt(args.Get(0).Str())))
-
- case "codeAt":
- args := msg.Arguments()
-
- JSON.Send(writer, pack(msg.Id, len(pipe.CodeAt(args.Get(0).Str()))))
-
- case "stateAt":
- args := msg.Arguments()
-
- JSON.Send(writer, pack(msg.Id, pipe.StorageAt(args.Get(0).Str(), args.Get(1).Str())))
-
- case "balanceAt":
- args := msg.Arguments()
-
- JSON.Send(writer, pack(msg.Id, pipe.BalanceAt(args.Get(0).Str())))
-
- case "newFilter":
- case "newFilterString":
- case "messages":
- // TODO
- }
-}
-*/
generated by cgit (git 2.34.1) at 2024-10-13 04:21:06 +0800