plugeth/rpc/types.go

375 lines
7.9 KiB
Go
Raw Normal View History

2015-01-13 15:13:43 +00:00
/*
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/>.
*/
2014-10-21 11:24:48 +00:00
package rpc
import (
2015-04-01 21:08:00 +00:00
"encoding/binary"
"encoding/json"
2015-01-29 11:01:51 +00:00
"fmt"
2015-03-31 15:39:58 +00:00
"math/big"
"strings"
"errors"
"net"
"net/http"
"time"
"io"
2015-03-31 15:39:58 +00:00
"github.com/ethereum/go-ethereum/common"
2015-04-02 09:32:50 +00:00
"github.com/ethereum/go-ethereum/core/types"
)
2015-03-31 15:39:58 +00:00
type hexdata struct {
2015-04-02 09:32:50 +00:00
data []byte
isNil bool
2015-03-31 15:39:58 +00:00
}
2015-03-31 17:02:46 +00:00
func (d *hexdata) String() string {
return "0x" + common.Bytes2Hex(d.data)
}
2015-03-31 15:39:58 +00:00
func (d *hexdata) MarshalJSON() ([]byte, error) {
2015-04-02 09:32:50 +00:00
if d.isNil {
return json.Marshal(nil)
}
2015-03-31 17:02:46 +00:00
return json.Marshal(d.String())
2015-03-31 15:39:58 +00:00
}
func newHexData(input interface{}) *hexdata {
d := new(hexdata)
2015-04-01 13:45:56 +00:00
if input == nil {
2015-04-04 13:09:30 +00:00
d.isNil = true
2015-04-01 15:49:22 +00:00
return d
2015-04-01 13:45:56 +00:00
}
2015-04-01 09:45:29 +00:00
switch input := input.(type) {
2015-03-31 15:39:58 +00:00
case []byte:
2015-04-01 09:45:29 +00:00
d.data = input
2015-03-31 15:39:58 +00:00
case common.Hash:
2015-04-01 09:45:29 +00:00
d.data = input.Bytes()
case *common.Hash:
2015-04-02 09:32:50 +00:00
if input == nil {
d.isNil = true
} else {
d.data = input.Bytes()
}
2015-03-31 15:39:58 +00:00
case common.Address:
2015-04-01 09:45:29 +00:00
d.data = input.Bytes()
2015-04-02 09:32:50 +00:00
case *common.Address:
if input == nil {
d.isNil = true
} else {
d.data = input.Bytes()
}
2015-04-02 10:31:10 +00:00
case types.Bloom:
d.data = input.Bytes()
case *types.Bloom:
if input == nil {
d.isNil = true
} else {
d.data = input.Bytes()
}
2015-03-31 15:39:58 +00:00
case *big.Int:
2015-04-02 11:04:58 +00:00
if input == nil {
d.isNil = true
} else {
d.data = input.Bytes()
}
2015-03-31 15:39:58 +00:00
case int64:
2015-04-01 09:45:29 +00:00
d.data = big.NewInt(input).Bytes()
2015-03-31 15:39:58 +00:00
case uint64:
2015-04-01 21:08:00 +00:00
buff := make([]byte, 8)
binary.BigEndian.PutUint64(buff, input)
d.data = buff
2015-03-31 15:39:58 +00:00
case int:
2015-04-01 09:45:29 +00:00
d.data = big.NewInt(int64(input)).Bytes()
2015-03-31 15:39:58 +00:00
case uint:
2015-04-01 09:45:29 +00:00
d.data = big.NewInt(int64(input)).Bytes()
2015-04-02 10:31:10 +00:00
case int8:
d.data = big.NewInt(int64(input)).Bytes()
case uint8:
d.data = big.NewInt(int64(input)).Bytes()
case int16:
d.data = big.NewInt(int64(input)).Bytes()
case uint16:
2015-04-04 13:09:30 +00:00
buff := make([]byte, 2)
2015-04-02 10:52:25 +00:00
binary.BigEndian.PutUint16(buff, input)
d.data = buff
2015-04-02 10:31:10 +00:00
case int32:
d.data = big.NewInt(int64(input)).Bytes()
case uint32:
2015-04-04 13:09:30 +00:00
buff := make([]byte, 4)
2015-04-02 10:52:25 +00:00
binary.BigEndian.PutUint32(buff, input)
d.data = buff
case string: // hexstring
2015-04-01 09:45:29 +00:00
d.data = common.Big(input).Bytes()
2015-03-31 15:39:58 +00:00
default:
2015-04-04 13:09:30 +00:00
d.isNil = true
2015-03-31 15:39:58 +00:00
}
return d
}
type hexnum struct {
2015-04-02 09:32:50 +00:00
data []byte
isNil bool
2015-03-31 15:39:58 +00:00
}
2015-03-31 17:02:46 +00:00
func (d *hexnum) String() string {
2015-03-31 15:39:58 +00:00
// Get hex string from bytes
out := common.Bytes2Hex(d.data)
// Trim leading 0s
2015-04-02 10:30:42 +00:00
out = strings.TrimLeft(out, "0")
2015-03-31 15:39:58 +00:00
// Output "0x0" when value is 0
if len(out) == 0 {
out = "0"
}
2015-03-31 17:02:46 +00:00
return "0x" + out
}
func (d *hexnum) MarshalJSON() ([]byte, error) {
2015-04-02 09:32:50 +00:00
if d.isNil {
return json.Marshal(nil)
}
2015-03-31 17:02:46 +00:00
return json.Marshal(d.String())
2015-03-31 15:39:58 +00:00
}
func newHexNum(input interface{}) *hexnum {
d := new(hexnum)
d.data = newHexData(input).data
return d
}
type RpcConfig struct {
ListenAddress string
ListenPort uint
CorsDomain string
}
2015-03-26 12:33:44 +00:00
type InvalidTypeError struct {
method string
msg string
}
func (e *InvalidTypeError) Error() string {
return fmt.Sprintf("invalid type on field %s: %s", e.method, e.msg)
}
func NewInvalidTypeError(method, msg string) *InvalidTypeError {
return &InvalidTypeError{
method: method,
msg: msg,
}
}
type InsufficientParamsError struct {
have int
want int
}
func (e *InsufficientParamsError) Error() string {
return fmt.Sprintf("insufficient params, want %d have %d", e.want, e.have)
}
func NewInsufficientParamsError(have int, want int) *InsufficientParamsError {
return &InsufficientParamsError{
have: have,
want: want,
}
}
type NotImplementedError struct {
Method string
}
func (e *NotImplementedError) Error() string {
return fmt.Sprintf("%s method not implemented", e.Method)
}
func NewNotImplementedError(method string) *NotImplementedError {
return &NotImplementedError{
Method: method,
}
}
type NotAvailableError struct {
Method string
Reason string
}
func (e *NotAvailableError) Error() string {
return fmt.Sprintf("%s method not available: %s", e.Method, e.Reason)
}
func NewNotAvailableError(method string, reason string) *NotAvailableError {
return &NotAvailableError{
Method: method,
Reason: reason,
}
}
type DecodeParamError struct {
err string
}
func (e *DecodeParamError) Error() string {
return fmt.Sprintf("could not decode, %s", e.err)
}
func NewDecodeParamError(errstr string) error {
return &DecodeParamError{
err: errstr,
}
}
type ValidationError struct {
ParamName string
msg string
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("%s not valid, %s", e.ParamName, e.msg)
}
func NewValidationError(param string, msg string) error {
return &ValidationError{
ParamName: param,
msg: msg,
}
}
2015-02-03 23:29:29 +00:00
type RpcRequest struct {
Id interface{} `json:"id"`
Jsonrpc string `json:"jsonrpc"`
2015-03-06 03:37:45 +00:00
Method string `json:"method"`
Params json.RawMessage `json:"params"`
}
type RpcSuccessResponse struct {
Id interface{} `json:"id"`
Jsonrpc string `json:"jsonrpc"`
Result interface{} `json:"result"`
2014-10-21 11:24:48 +00:00
}
type RpcErrorResponse struct {
Id interface{} `json:"id"`
Jsonrpc string `json:"jsonrpc"`
2015-02-03 23:29:29 +00:00
Error *RpcErrorObject `json:"error"`
}
2015-02-03 23:29:29 +00:00
type RpcErrorObject struct {
Code int `json:"code"`
Message string `json:"message"`
// Data interface{} `json:"data"`
}
2015-04-19 08:01:50 +00:00
type listenerHasStoppedError struct {
msg string
}
2015-04-19 08:01:50 +00:00
func (self listenerHasStoppedError) Error() string {
return self.msg
}
2015-04-19 08:01:50 +00:00
var listenerStoppedError = listenerHasStoppedError{"Listener stopped"}
// When https://github.com/golang/go/issues/4674 is fixed this could be replaced
2015-04-19 08:01:50 +00:00
type stoppableTCPListener struct {
*net.TCPListener
stop chan struct{} // closed when the listener must stop
}
// Wraps the default handler and checks if the RPC service was stopped. In that case it returns an
// error indicating that the service was stopped. This will only happen for connections which are
// kept open (HTTP keep-alive) when the RPC service was shutdown.
2015-04-19 08:01:50 +00:00
func newStoppableHandler(h http.Handler, stop chan struct{}) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
select {
case <-stop:
w.Header().Set("Content-Type", "application/json")
jsonerr := &RpcErrorObject{-32603, "RPC service stopped"}
send(w, &RpcErrorResponse{Jsonrpc: jsonrpcver, Id: nil, Error: jsonerr})
default:
h.ServeHTTP(w, r)
}
})
}
// Stop the listener and all accepted and still active connections.
2015-04-19 08:01:50 +00:00
func (self *stoppableTCPListener) Stop() {
close(self.stop)
}
2015-04-19 08:01:50 +00:00
func newStoppableTCPListener(addr string) (*stoppableTCPListener, error) {
wl, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
if tcpl, ok := wl.(*net.TCPListener); ok {
stop := make(chan struct{})
2015-04-19 08:01:50 +00:00
l := &stoppableTCPListener{tcpl, stop}
return l, nil
}
return nil, errors.New("Unable to create TCP listener for RPC service")
}
2015-04-19 08:01:50 +00:00
func (self *stoppableTCPListener) Accept() (net.Conn, error) {
for {
self.SetDeadline(time.Now().Add(time.Duration(1 * time.Second)))
c, err := self.TCPListener.AcceptTCP()
select {
case <-self.stop:
if c != nil { // accept timeout
c.Close()
}
self.TCPListener.Close()
return nil, listenerStoppedError
default:
}
if err != nil {
if netErr, ok := err.(net.Error); ok && netErr.Timeout() && netErr.Temporary() {
continue // regular timeout
}
}
2015-04-19 08:01:50 +00:00
return &closableConnection{c, self.stop}, err
}
}
2015-04-19 08:01:50 +00:00
type closableConnection struct {
*net.TCPConn
closed chan struct{}
}
2015-04-19 08:01:50 +00:00
func (self *closableConnection) Read(b []byte) (n int, err error) {
select {
case <-self.closed:
self.TCPConn.Close()
return 0, io.EOF
default:
return self.TCPConn.Read(b)
}
}