diff --git a/rpc/v0/json_rpc.go b/rpc/rpc.go
similarity index 99%
rename from rpc/v0/json_rpc.go
rename to rpc/rpc.go
index 46ca4b06788df04b7da1d1d98f002c678001a41f..a42e57c0ca349f11cc007fffaf3556e5c9128787 100644
--- a/rpc/v0/json_rpc.go
+++ b/rpc/rpc.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package v0
+package rpc
import (
"encoding/json"
@@ -21,8 +21,8 @@ import (
// JSON-RPC 2.0 error codes.
const (
- INVALID_REQUEST = -32600
PARSE_ERROR = -32700
+ INVALID_REQUEST = -32600
METHOD_NOT_FOUND = -32601
INVALID_PARAMS = -32602
INTERNAL_ERROR = -32603
diff --git a/rpc/tendermint/test/rpc_client_test.go b/rpc/tendermint/test/rpc_client_test.go
index d53ff9d713ffcee49a4646c7d303fd55a42a51ec..80f0f250868d2b77f22ad709e3e784eaf93b73da 100644
--- a/rpc/tendermint/test/rpc_client_test.go
+++ b/rpc/tendermint/test/rpc_client_test.go
@@ -20,10 +20,11 @@ package test
import (
"bytes"
"fmt"
- "golang.org/x/crypto/ripemd160"
"testing"
"time"
+ "golang.org/x/crypto/ripemd160"
+
consensus_types "github.com/eris-ltd/eris-db/consensus/types"
edbcli "github.com/eris-ltd/eris-db/rpc/tendermint/client"
"github.com/eris-ltd/eris-db/txs"
diff --git a/rpc/v0/codec.go b/rpc/v0/codec.go
index 04fab0308e15c0283826315c93d676b5f3c971c0..ecc01f823b441bd119d45560a4ffe25fe4bbe2de 100644
--- a/rpc/v0/codec.go
+++ b/rpc/v0/codec.go
@@ -18,9 +18,10 @@ import (
"io"
"io/ioutil"
+ "reflect"
+ "github.com/eris-ltd/eris-db/rpc"
wire "github.com/tendermint/go-wire"
- "reflect"
)
// Codec that uses tendermints 'binary' package for JSON.
@@ -28,7 +29,7 @@ type TCodec struct {
}
// Get a new codec.
-func NewTCodec() Codec {
+func NewTCodec() rpc.Codec {
return &TCodec{}
}
diff --git a/rpc/v0/codec_test.go b/rpc/v0/codec_test.go
index c51eed68a909006ba4865715eddfe402773b501b..c300ee649838e20ac3035b2731623b556f5556a4 100644
--- a/rpc/v0/codec_test.go
+++ b/rpc/v0/codec_test.go
@@ -20,6 +20,7 @@ import (
"github.com/eris-ltd/eris-db/txs"
+ "github.com/eris-ltd/eris-db/rpc"
"github.com/stretchr/testify/assert"
)
@@ -60,7 +61,7 @@ func TestCallTxJsonFormatCodec(t *testing.T) {
param := new(txs.Tx)
// Create new request object and unmarshal.
- request := &RPCRequest{}
+ request := &rpc.RPCRequest{}
assert.NoError(t, json.Unmarshal(testBroadcastCallTxJsonRequest, request),
"Provided JSON test data does not unmarshal to rpc.RPCRequest object.")
assert.NoError(t, codec.DecodeBytes(param, request.Params),
diff --git a/rpc/v0/json_rpc_server.go b/rpc/v0/json_rpc_server.go
index 9908bb424738485dd5f8579362e285faeee20e05..d8a8bf8f3901fe41c78fea4fb26758de77046a16 100644
--- a/rpc/v0/json_rpc_server.go
+++ b/rpc/v0/json_rpc_server.go
@@ -22,6 +22,7 @@ import (
definitions "github.com/eris-ltd/eris-db/definitions"
event "github.com/eris-ltd/eris-db/event"
+ "github.com/eris-ltd/eris-db/rpc"
server "github.com/eris-ltd/eris-db/server"
)
@@ -64,14 +65,14 @@ func (this *JsonRpcServer) handleFunc(c *gin.Context) {
// Used for ErisDb. Implements server.HttpService
type ErisDbJsonService struct {
- codec Codec
+ codec rpc.Codec
pipe definitions.Pipe
eventSubs *event.EventSubscriptions
defaultHandlers map[string]RequestHandlerFunc
}
// Create a new JSON-RPC 2.0 service for erisdb (tendermint).
-func NewErisDbJsonService(codec Codec, pipe definitions.Pipe,
+func NewErisDbJsonService(codec rpc.Codec, pipe definitions.Pipe,
eventSubs *event.EventSubscriptions) server.HttpService {
tmhttps := &ErisDbJsonService{codec: codec, pipe: pipe, eventSubs: eventSubs}
@@ -90,21 +91,21 @@ func NewErisDbJsonService(codec Codec, pipe definitions.Pipe,
func (this *ErisDbJsonService) Process(r *http.Request, w http.ResponseWriter) {
// Create new request object and unmarshal.
- req := &RPCRequest{}
+ req := &rpc.RPCRequest{}
decoder := json.NewDecoder(r.Body)
errU := decoder.Decode(req)
// Error when decoding.
if errU != nil {
this.writeError("Failed to parse request: "+errU.Error(), "",
- PARSE_ERROR, w)
+ rpc.PARSE_ERROR, w)
return
}
// Wrong protocol version.
if req.JSONRPC != "2.0" {
this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id,
- INVALID_REQUEST, w)
+ rpc.INVALID_REQUEST, w)
return
}
@@ -118,13 +119,13 @@ func (this *ErisDbJsonService) Process(r *http.Request, w http.ResponseWriter) {
this.writeResponse(req.Id, resp, w)
}
} else {
- this.writeError("Method not found: "+mName, req.Id, METHOD_NOT_FOUND, w)
+ this.writeError("Method not found: "+mName, req.Id, rpc.METHOD_NOT_FOUND, w)
}
}
// Helper for writing error responses.
func (this *ErisDbJsonService) writeError(msg, id string, code int, w http.ResponseWriter) {
- response := NewRPCErrorResponse(id, code, msg)
+ response := rpc.NewRPCErrorResponse(id, code, msg)
err := this.codec.Encode(response, w)
// If there's an error here all bets are off.
if err != nil {
@@ -136,10 +137,10 @@ func (this *ErisDbJsonService) writeError(msg, id string, code int, w http.Respo
// Helper for writing responses.
func (this *ErisDbJsonService) writeResponse(id string, result interface{}, w http.ResponseWriter) {
- response := NewRPCResponse(id, result)
+ response := rpc.NewRPCResponse(id, result)
err := this.codec.Encode(response, w)
if err != nil {
- this.writeError("Internal error: "+err.Error(), id, INTERNAL_ERROR, w)
+ this.writeError("Internal error: "+err.Error(), id, rpc.INTERNAL_ERROR, w)
return
}
w.WriteHeader(200)
@@ -148,51 +149,51 @@ func (this *ErisDbJsonService) writeResponse(id string, result interface{}, w ht
// *************************************** Events ************************************
// Subscribe to an event.
-func (this *ErisDbJsonService) EventSubscribe(request *RPCRequest,
+func (this *ErisDbJsonService) EventSubscribe(request *rpc.RPCRequest,
requester interface{}) (interface{}, int, error) {
param := &EventIdParam{}
err := json.Unmarshal(request.Params, param)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
eventId := param.EventId
subId, errC := this.eventSubs.Add(eventId)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return &event.EventSub{subId}, 0, nil
}
// Un-subscribe from an event.
-func (this *ErisDbJsonService) EventUnsubscribe(request *RPCRequest,
+func (this *ErisDbJsonService) EventUnsubscribe(request *rpc.RPCRequest,
requester interface{}) (interface{}, int, error) {
param := &SubIdParam{}
err := json.Unmarshal(request.Params, param)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
subId := param.SubId
errC := this.pipe.Events().Unsubscribe(subId)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return &event.EventUnsub{true}, 0, nil
}
// Check subscription event cache for new data.
-func (this *ErisDbJsonService) EventPoll(request *RPCRequest,
+func (this *ErisDbJsonService) EventPoll(request *rpc.RPCRequest,
requester interface{}) (interface{}, int, error) {
param := &SubIdParam{}
err := json.Unmarshal(request.Params, param)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
subId := param.SubId
result, errC := this.eventSubs.Poll(subId)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return &event.PollResponse{result}, 0, nil
}
diff --git a/rpc/v0/json_rpc_server_test.go b/rpc/v0/json_rpc_server_test.go
index c9de5cd639ee6c6078b667dd7c45c60b135f4a59..fb5a41ec03ca38448c2061c1174819f1a3536f78 100644
--- a/rpc/v0/json_rpc_server_test.go
+++ b/rpc/v0/json_rpc_server_test.go
@@ -19,6 +19,7 @@ import (
"github.com/eris-ltd/eris-db/account"
"github.com/eris-ltd/eris-db/manager/eris-mint/evm/opcodes"
+ "github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/txs"
"github.com/stretchr/testify/assert"
"github.com/tendermint/go-wire"
@@ -34,7 +35,7 @@ func TestBroadcastTx(t *testing.T) {
var tx txs.Tx = txs.NewCallTxWithNonce(pubKey, address, code, 10, 2,
1, 0)
jsonBytes := wire.JSONBytesPretty(wrappedTx{tx})
- request := NewRPCRequest("TestBroadcastTx", "BroacastTx", jsonBytes)
+ request := rpc.NewRPCRequest("TestBroadcastTx", "BroacastTx", jsonBytes)
result, _, err := methods.BroadcastTx(request, "TestBroadcastTx")
assert.NoError(t, err)
receipt, ok := result.(*txs.Receipt)
diff --git a/rpc/v0/json_rpc_test.go b/rpc/v0/json_rpc_test.go
index 54b45134353aa0168222a62d178f226c7e0ec9dc..27ef8f455a8e541b2136248ccd965d05f42524e1 100644
--- a/rpc/v0/json_rpc_test.go
+++ b/rpc/v0/json_rpc_test.go
@@ -17,6 +17,7 @@ package v0
import (
"testing"
+ "github.com/eris-ltd/eris-db/rpc"
"github.com/stretchr/testify/assert"
)
@@ -24,12 +25,12 @@ import (
func TestNewJsonRpcResponse(t *testing.T) {
id := "testId"
data := "a string"
- resp := RPCResponse(&RPCResultResponse{
+ resp := rpc.RPCResponse(&rpc.RPCResultResponse{
Result: data,
Id: id,
JSONRPC: "2.0",
})
- respGen := NewRPCResponse(id, data)
+ respGen := rpc.NewRPCResponse(id, data)
assert.Equal(t, respGen, resp)
}
@@ -38,11 +39,11 @@ func TestNewJsonRpcErrorResponse(t *testing.T) {
id := "testId"
code := 100
message := "the error"
- resp := RPCResponse(&RPCErrorResponse{
- Error: &RPCError{code, message},
+ resp := rpc.RPCResponse(&rpc.RPCErrorResponse{
+ Error: &rpc.RPCError{code, message},
Id: id,
JSONRPC: "2.0",
})
- respGen := NewRPCErrorResponse(id, code, message)
+ respGen := rpc.NewRPCErrorResponse(id, code, message)
assert.Equal(t, respGen, resp)
}
diff --git a/rpc/v0/methods.go b/rpc/v0/methods.go
index 14d88ac132ea7ca9e9c0affeb5e6bd65fc9cfffc..93db17522a556477b09d538de4a1a52ec16ee8ec 100644
--- a/rpc/v0/methods.go
+++ b/rpc/v0/methods.go
@@ -19,6 +19,7 @@ import (
core_types "github.com/eris-ltd/eris-db/core/types"
definitions "github.com/eris-ltd/eris-db/definitions"
"github.com/eris-ltd/eris-db/event"
+ "github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/rpc/v0/shared"
"github.com/eris-ltd/eris-db/txs"
)
@@ -68,12 +69,12 @@ const (
// The rpc method handlers.
type ErisDbMethods struct {
- codec Codec
+ codec rpc.Codec
pipe definitions.Pipe
filterFactory *event.FilterFactory
}
-func NewErisDbMethods(codec Codec,
+func NewErisDbMethods(codec rpc.Codec,
pipe definitions.Pipe) *ErisDbMethods {
return &ErisDbMethods{
@@ -84,7 +85,7 @@ func NewErisDbMethods(codec Codec,
}
// Used to handle requests. interface{} param is a wildcard used for example with socket events.
-type RequestHandlerFunc func(*RPCRequest, interface{}) (interface{}, int, error)
+type RequestHandlerFunc func(*rpc.RPCRequest, interface{}) (interface{}, int, error)
// Private. Create a method name -> method handler map.
func (erisDbMethods *ErisDbMethods) getMethods() map[string]RequestHandlerFunc {
@@ -138,132 +139,132 @@ func (erisDbMethods *ErisDbMethods) getMethods() map[string]RequestHandlerFunc {
// *************************************** Accounts ***************************************
-func (erisDbMethods *ErisDbMethods) GenPrivAccount(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) GenPrivAccount(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
pac, errC := erisDbMethods.pipe.Accounts().GenPrivAccount()
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return pac, 0, nil
}
-func (erisDbMethods *ErisDbMethods) GenPrivAccountFromKey(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) GenPrivAccountFromKey(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &PrivKeyParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
privKey := param.PrivKey
pac, errC := erisDbMethods.pipe.Accounts().GenPrivAccountFromKey(privKey)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return pac, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Account(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Account(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &AddressParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
address := param.Address
// TODO is address check?
account, errC := erisDbMethods.pipe.Accounts().Account(address)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return account, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Accounts(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Accounts(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &AccountsParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
list, errC := erisDbMethods.pipe.Accounts().Accounts(param.Filters)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return list, 0, nil
}
-func (erisDbMethods *ErisDbMethods) AccountStorage(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) AccountStorage(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &AddressParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
address := param.Address
storage, errC := erisDbMethods.pipe.Accounts().Storage(address)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return storage, 0, nil
}
-func (erisDbMethods *ErisDbMethods) AccountStorageAt(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) AccountStorageAt(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &StorageAtParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
address := param.Address
key := param.Key
storageItem, errC := erisDbMethods.pipe.Accounts().StorageAt(address, key)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return storageItem, 0, nil
}
// *************************************** Blockchain ************************************
-func (erisDbMethods *ErisDbMethods) BlockchainInfo(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) BlockchainInfo(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
return shared.BlockchainInfo(erisDbMethods.pipe), 0, nil
}
-func (erisDbMethods *ErisDbMethods) ChainId(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) ChainId(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
chainId := erisDbMethods.pipe.Blockchain().ChainId()
return &core_types.ChainId{chainId}, 0, nil
}
-func (erisDbMethods *ErisDbMethods) GenesisHash(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) GenesisHash(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
hash := erisDbMethods.pipe.GenesisHash()
return &core_types.GenesisHash{hash}, 0, nil
}
-func (erisDbMethods *ErisDbMethods) LatestBlockHeight(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) LatestBlockHeight(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
height := erisDbMethods.pipe.Blockchain().Height()
return &core_types.LatestBlockHeight{height}, 0, nil
}
-func (erisDbMethods *ErisDbMethods) LatestBlock(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) LatestBlock(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
latestHeight := erisDbMethods.pipe.Blockchain().Height()
block := erisDbMethods.pipe.Blockchain().Block(latestHeight)
return block, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Blocks(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Blocks(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &BlocksParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
blocks, errC := blockchain.FilterBlocks(erisDbMethods.pipe.Blockchain(), erisDbMethods.filterFactory, param.Filters)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return blocks, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Block(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Block(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &HeightParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
height := param.Height
block := erisDbMethods.pipe.Blockchain().Block(height)
@@ -272,51 +273,51 @@ func (erisDbMethods *ErisDbMethods) Block(request *RPCRequest, requester interfa
// *************************************** Consensus ************************************
-func (erisDbMethods *ErisDbMethods) ConsensusState(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) ConsensusState(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
return erisDbMethods.pipe.GetConsensusEngine().ConsensusState(), 0, nil
}
-func (erisDbMethods *ErisDbMethods) Validators(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Validators(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
return erisDbMethods.pipe.GetConsensusEngine().ListValidators(), 0, nil
}
// *************************************** Net ************************************
-func (erisDbMethods *ErisDbMethods) NetworkInfo(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) NetworkInfo(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
info := shared.NetInfo(erisDbMethods.pipe)
return info, 0, nil
}
-func (erisDbMethods *ErisDbMethods) ClientVersion(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) ClientVersion(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
version := shared.ClientVersion(erisDbMethods.pipe)
return &core_types.ClientVersion{version}, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Moniker(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Moniker(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
moniker := shared.Moniker(erisDbMethods.pipe)
return &core_types.Moniker{moniker}, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Listening(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Listening(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
listening := shared.Listening(erisDbMethods.pipe)
return &core_types.Listening{listening}, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Listeners(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Listeners(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
listeners := shared.Listeners(erisDbMethods.pipe)
return &core_types.Listeners{listeners}, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Peers(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Peers(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
peers := erisDbMethods.pipe.GetConsensusEngine().Peers()
return peers, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Peer(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Peer(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &PeerParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
address := param.Address
peer := shared.Peer(erisDbMethods.pipe, address)
@@ -325,165 +326,165 @@ func (erisDbMethods *ErisDbMethods) Peer(request *RPCRequest, requester interfac
// *************************************** Txs ************************************
-func (erisDbMethods *ErisDbMethods) Call(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Call(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &CallParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
from := param.From
to := param.Address
data := param.Data
call, errC := erisDbMethods.pipe.Transactor().Call(from, to, data)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return call, 0, nil
}
-func (erisDbMethods *ErisDbMethods) CallCode(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) CallCode(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &CallCodeParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
from := param.From
code := param.Code
data := param.Data
call, errC := erisDbMethods.pipe.Transactor().CallCode(from, code, data)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return call, 0, nil
}
-func (erisDbMethods *ErisDbMethods) BroadcastTx(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) BroadcastTx(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
tx := new(txs.Tx)
err := erisDbMethods.codec.DecodeBytes(tx, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
receipt, errC := erisDbMethods.pipe.Transactor().BroadcastTx(*tx)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return receipt, 0, nil
}
-func (erisDbMethods *ErisDbMethods) Transact(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) Transact(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &TransactParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
receipt, errC := erisDbMethods.pipe.Transactor().Transact(param.PrivKey, param.Address, param.Data, param.GasLimit, param.Fee)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return receipt, 0, nil
}
-func (erisDbMethods *ErisDbMethods) TransactAndHold(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) TransactAndHold(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &TransactParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
ce, errC := erisDbMethods.pipe.Transactor().TransactAndHold(param.PrivKey, param.Address, param.Data, param.GasLimit, param.Fee)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return ce, 0, nil
}
-func (this *ErisDbMethods) Send(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Send(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &SendParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
receipt, errC := this.pipe.Transactor().Send(param.PrivKey, param.ToAddress, param.Amount)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return receipt, 0, nil
}
-func (this *ErisDbMethods) SendAndHold(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) SendAndHold(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &SendParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
rec, errC := this.pipe.Transactor().SendAndHold(param.PrivKey, param.ToAddress, param.Amount)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return rec, 0, nil
}
-func (erisDbMethods *ErisDbMethods) TransactNameReg(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) TransactNameReg(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &TransactNameRegParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
receipt, errC := erisDbMethods.pipe.Transactor().TransactNameReg(param.PrivKey, param.Name, param.Data, param.Amount, param.Fee)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return receipt, 0, nil
}
-func (erisDbMethods *ErisDbMethods) UnconfirmedTxs(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) UnconfirmedTxs(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
trans, errC := erisDbMethods.pipe.GetConsensusEngine().ListUnconfirmedTxs(-1)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return txs.UnconfirmedTxs{trans}, 0, nil
}
-func (erisDbMethods *ErisDbMethods) SignTx(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) SignTx(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &SignTxParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
tx := param.Tx
pAccs := param.PrivAccounts
txRet, errC := erisDbMethods.pipe.Transactor().SignTx(tx, pAccs)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return txRet, 0, nil
}
// *************************************** Name Registry ***************************************
-func (erisDbMethods *ErisDbMethods) NameRegEntry(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) NameRegEntry(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &NameRegEntryParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
name := param.Name
// TODO is address check?
entry, errC := erisDbMethods.pipe.NameReg().Entry(name)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return entry, 0, nil
}
-func (erisDbMethods *ErisDbMethods) NameRegEntries(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (erisDbMethods *ErisDbMethods) NameRegEntries(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &FilterListParam{}
err := erisDbMethods.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
list, errC := erisDbMethods.pipe.NameReg().Entries(param.Filters)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return list, 0, nil
}
diff --git a/rpc/v0/mock_test_data_test.go b/rpc/v0/mock_test_data_test.go
index 3722047b68a7e2280460bd79ff7464996ba17f0a..c62c6f6224563df088874f6863a2c47817e6cc41 100644
--- a/rpc/v0/mock_test_data_test.go
+++ b/rpc/v0/mock_test_data_test.go
@@ -557,22 +557,22 @@ type (
}
GetAccountData struct {
- Input *AddressParam `json:"input"`
- Output *account.Account `json:"output"`
+ Input *AddressParam `json:"input"`
+ Output *account.Account `json:"output"`
}
GetAccountsData struct {
- Input *AccountsParam `json:"input"`
+ Input *AccountsParam `json:"input"`
Output *core_types.AccountList `json:"output"`
}
GetStorageData struct {
- Input *AddressParam `json:"input"`
- Output *core_types.Storage `json:"output"`
+ Input *AddressParam `json:"input"`
+ Output *core_types.Storage `json:"output"`
}
GetStorageAtData struct {
- Input *StorageAtParam `json:"input"`
+ Input *StorageAtParam `json:"input"`
Output *core_types.StorageItem `json:"output"`
}
@@ -601,13 +601,13 @@ type (
}
GetBlockData struct {
- Input *HeightParam `json:"input"`
- Output *mintTypes.Block `json:"output"`
+ Input *HeightParam `json:"input"`
+ Output *mintTypes.Block `json:"output"`
}
GetBlocksData struct {
- Input *BlocksParam `json:"input"`
- Output *core_types.Blocks `json:"output"`
+ Input *BlocksParam `json:"input"`
+ Output *core_types.Blocks `json:"output"`
}
GetConsensusStateData struct {
@@ -643,18 +643,18 @@ type (
}
GetPeerData struct {
- Input *PeerParam `json:"input"`
+ Input *PeerParam `json:"input"`
Output *consensus_types.Peer `json:"output"`
}
TransactData struct {
- Input *TransactParam `json:"input"`
- Output *transaction.Receipt `json:"output"`
+ Input *TransactParam `json:"input"`
+ Output *transaction.Receipt `json:"output"`
}
TransactCreateData struct {
- Input *TransactParam `json:"input"`
- Output *transaction.Receipt `json:"output"`
+ Input *TransactParam `json:"input"`
+ Output *transaction.Receipt `json:"output"`
}
GetUnconfirmedTxsData struct {
@@ -662,37 +662,37 @@ type (
}
CallCodeData struct {
- Input *CallCodeParam `json:"input"`
- Output *core_types.Call `json:"output"`
+ Input *CallCodeParam `json:"input"`
+ Output *core_types.Call `json:"output"`
}
CallData struct {
- Input *CallParam `json:"input"`
- Output *core_types.Call `json:"output"`
+ Input *CallParam `json:"input"`
+ Output *core_types.Call `json:"output"`
}
EventSubscribeData struct {
- Input *EventIdParam `json:"input"`
- Output *event.EventSub `json:"output"`
+ Input *EventIdParam `json:"input"`
+ Output *event.EventSub `json:"output"`
}
EventUnsubscribeData struct {
- Input *SubIdParam `json:"input"`
- Output *event.EventUnsub `json:"output"`
+ Input *SubIdParam `json:"input"`
+ Output *event.EventUnsub `json:"output"`
}
TransactNameRegData struct {
Input *TransactNameRegParam `json:"input"`
- Output *transaction.Receipt `json:"output"`
+ Output *transaction.Receipt `json:"output"`
}
GetNameRegEntryData struct {
- Input *NameRegEntryParam `json:"input"`
- Output *core_types.NameRegEntry `json:"output"`
+ Input *NameRegEntryParam `json:"input"`
+ Output *core_types.NameRegEntry `json:"output"`
}
GetNameRegEntriesData struct {
- Input *FilterListParam `json:"input"`
+ Input *FilterListParam `json:"input"`
Output *core_types.ResultListNames `json:"output"`
}
diff --git a/rpc/v0/rest_server.go b/rpc/v0/rest_server.go
index a02c680406bd0e2ef6363f07b12c28370eb6d2b4..bc89b4225f25e1efb3ed038691dd7f1f8fe62ddc 100644
--- a/rpc/v0/rest_server.go
+++ b/rpc/v0/rest_server.go
@@ -26,6 +26,7 @@ import (
core_types "github.com/eris-ltd/eris-db/core/types"
definitions "github.com/eris-ltd/eris-db/definitions"
event "github.com/eris-ltd/eris-db/event"
+ "github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/rpc/v0/shared"
server "github.com/eris-ltd/eris-db/server"
"github.com/eris-ltd/eris-db/txs"
@@ -36,7 +37,7 @@ import (
// TODO more routers. Also, start looking into how better status codes
// can be gotten.
type RestServer struct {
- codec Codec
+ codec rpc.Codec
pipe definitions.Pipe
eventSubs *event.EventSubscriptions
filterFactory *event.FilterFactory
@@ -44,7 +45,7 @@ type RestServer struct {
}
// Create a new rest server.
-func NewRestServer(codec Codec, pipe definitions.Pipe,
+func NewRestServer(codec rpc.Codec, pipe definitions.Pipe,
eventSubs *event.EventSubscriptions) *RestServer {
return &RestServer{
codec: codec,
diff --git a/rpc/v0/rest_server_test.go b/rpc/v0/rest_server_test.go
index 30906a9bf1d5f0a6e69a6d8138af63aa14011568..b0f070349a89819ade18837c9683804c3975a57e 100644
--- a/rpc/v0/rest_server_test.go
+++ b/rpc/v0/rest_server_test.go
@@ -31,6 +31,7 @@ import (
server "github.com/eris-ltd/eris-db/server"
"github.com/eris-ltd/eris-db/txs"
+ "github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/rpc/v0/shared"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/suite"
@@ -50,7 +51,7 @@ type MockSuite struct {
suite.Suite
baseDir string
serveProcess *server.ServeProcess
- codec Codec
+ codec rpc.Codec
sUrl string
testData *TestData
}
diff --git a/rpc/v0/websocket_service.go b/rpc/v0/websocket_service.go
index c1ffae951c0359c470b2db5267d519a8b4b8bb7e..d5985941725da123991302d52ca51ec6e75f2db1 100644
--- a/rpc/v0/websocket_service.go
+++ b/rpc/v0/websocket_service.go
@@ -20,20 +20,21 @@ import (
definitions "github.com/eris-ltd/eris-db/definitions"
"github.com/eris-ltd/eris-db/event"
+ "github.com/eris-ltd/eris-db/rpc"
server "github.com/eris-ltd/eris-db/server"
"github.com/eris-ltd/eris-db/txs"
)
// Used for ErisDb. Implements WebSocketService.
type ErisDbWsService struct {
- codec Codec
+ codec rpc.Codec
pipe definitions.Pipe
defaultHandlers map[string]RequestHandlerFunc
}
// Create a new websocket service.
-func NewErisDbWsService(codec Codec,
- pipe definitions.Pipe) server.WebSocketService {
+func NewErisDbWsService(codec rpc.Codec,
+ pipe definitions.Pipe) server.WebSocketService {
tmwss := &ErisDbWsService{codec: codec, pipe: pipe}
mtds := NewErisDbMethods(codec, pipe)
@@ -48,18 +49,20 @@ func NewErisDbWsService(codec Codec,
// Process a request.
func (this *ErisDbWsService) Process(msg []byte, session *server.WSSession) {
// Create new request object and unmarshal.
- req := &RPCRequest{}
+ req := &rpc.RPCRequest{}
errU := json.Unmarshal(msg, req)
// Error when unmarshaling.
if errU != nil {
- this.writeError("Failed to parse request: "+errU.Error()+" . Raw: "+string(msg), "", PARSE_ERROR, session)
+ this.writeError("Failed to parse request: "+errU.Error()+" . Raw: "+string(msg),
+ "", rpc.PARSE_ERROR, session)
return
}
// Wrong protocol version.
if req.JSONRPC != "2.0" {
- this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id, INVALID_REQUEST, session)
+ this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id,
+ rpc.INVALID_REQUEST, session)
return
}
@@ -73,14 +76,15 @@ func (this *ErisDbWsService) Process(msg []byte, session *server.WSSession) {
this.writeResponse(req.Id, resp, session)
}
} else {
- this.writeError("Method not found: "+mName, req.Id, METHOD_NOT_FOUND, session)
+ this.writeError("Method not found: "+mName, req.Id,
+ rpc.METHOD_NOT_FOUND, session)
}
}
// Convenience method for writing error responses.
func (this *ErisDbWsService) writeError(msg, id string, code int,
session *server.WSSession) {
- response := NewRPCErrorResponse(id, code, msg)
+ response := rpc.NewRPCErrorResponse(id, code, msg)
bts, err := this.codec.EncodeBytes(response)
// If there's an error here all bets are off.
if err != nil {
@@ -92,10 +96,10 @@ func (this *ErisDbWsService) writeError(msg, id string, code int,
// Convenience method for writing responses.
func (this *ErisDbWsService) writeResponse(id string, result interface{},
session *server.WSSession) error {
- response := NewRPCResponse(id, result)
+ response := rpc.NewRPCResponse(id, result)
bts, err := this.codec.EncodeBytes(response)
if err != nil {
- this.writeError("Internal error: "+err.Error(), id, INTERNAL_ERROR, session)
+ this.writeError("Internal error: "+err.Error(), id, rpc.INTERNAL_ERROR, session)
return err
}
return session.Write(bts)
@@ -103,22 +107,22 @@ func (this *ErisDbWsService) writeResponse(id string, result interface{},
// *************************************** Events ************************************
-func (this *ErisDbWsService) EventSubscribe(request *RPCRequest,
+func (this *ErisDbWsService) EventSubscribe(request *rpc.RPCRequest,
requester interface{}) (interface{}, int, error) {
session, ok := requester.(*server.WSSession)
if !ok {
- return 0, INTERNAL_ERROR,
+ return 0, rpc.INTERNAL_ERROR,
fmt.Errorf("Passing wrong object to websocket events")
}
param := &EventIdParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
eventId := param.EventId
subId, errSID := event.GenerateSubId()
if errSID != nil {
- return nil, INTERNAL_ERROR, errSID
+ return nil, rpc.INTERNAL_ERROR, errSID
}
callback := func(ret txs.EventData) {
@@ -126,26 +130,28 @@ func (this *ErisDbWsService) EventSubscribe(request *RPCRequest,
}
errC := this.pipe.Events().Subscribe(subId, eventId, callback)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return &event.EventSub{subId}, 0, nil
}
-func (this *ErisDbWsService) EventUnsubscribe(request *RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbWsService) EventUnsubscribe(request *rpc.RPCRequest,
+ requester interface{}) (interface{}, int, error) {
param := &EventIdParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, INVALID_PARAMS, err
+ return nil, rpc.INVALID_PARAMS, err
}
eventId := param.EventId
errC := this.pipe.Events().Unsubscribe(eventId)
if errC != nil {
- return nil, INTERNAL_ERROR, errC
+ return nil, rpc.INTERNAL_ERROR, errC
}
return &event.EventUnsub{true}, 0, nil
}
-func (this *ErisDbWsService) EventPoll(request *RPCRequest, requester interface{}) (interface{}, int, error) {
- return nil, INTERNAL_ERROR, fmt.Errorf("Cannot poll with websockets")
+func (this *ErisDbWsService) EventPoll(request *rpc.RPCRequest,
+ requester interface{}) (interface{}, int, error) {
+ return nil, rpc.INTERNAL_ERROR, fmt.Errorf("Cannot poll with websockets")
}
diff --git a/test/server/scumbag.go b/test/server/scumbag.go
index 4a0b4f115d2cd79014205cd68550a0129a762299..3d153b322bdbdf3f67d3b0d6c5f63ac685c9dafc 100644
--- a/test/server/scumbag.go
+++ b/test/server/scumbag.go
@@ -22,7 +22,7 @@ import (
"github.com/eris-ltd/eris-db/server"
"github.com/gin-gonic/gin"
"github.com/tendermint/log15"
- "github.com/eris-ltd/eris-db/rpc/v0"
+ "github.com/eris-ltd/eris-db/rpc"
)
func init() {
@@ -60,7 +60,7 @@ func (this *ScumbagServer) ShutDown() {
type ScumSocketService struct{}
func (this *ScumSocketService) Process(data []byte, session *server.WSSession) {
- resp := v0.NewRPCResponse("1", "Scumbag")
+ resp := rpc.NewRPCResponse("1", "Scumbag")
bts, _ := json.Marshal(resp)
session.Write(bts)
}