diff --git a/core/core.go b/core/core.go
index cb4d29c9dcbb002f52d6901046332d5db1294721..43d0bb3a68542aedf3a8938b0828df3cb942a178 100644
--- a/core/core.go
+++ b/core/core.go
@@ -24,12 +24,16 @@ import (
log "github.com/eris-ltd/eris-logger"
- config "github.com/eris-ltd/eris-db/config"
- consensus "github.com/eris-ltd/eris-db/consensus"
- core_types "github.com/eris-ltd/eris-db/core/types"
- definitions "github.com/eris-ltd/eris-db/definitions"
- manager "github.com/eris-ltd/eris-db/manager"
- server "github.com/eris-ltd/eris-db/server"
+ config "github.com/eris-ltd/eris-db/config"
+ consensus "github.com/eris-ltd/eris-db/consensus"
+ definitions "github.com/eris-ltd/eris-db/definitions"
+ event "github.com/eris-ltd/eris-db/event"
+ manager "github.com/eris-ltd/eris-db/manager"
+ // rpc_v0 is carried over from Eris-DBv0.11 and before on port 1337
+ rpc_v0 "github.com/eris-ltd/eris-db/rpc/v0"
+ // rpc_tendermint is carried over from Eris-DBv0.11 and before on port 46657
+ // rpc_tendermint "github.com/eris-ltd/eris-db/rpc/tendermint"
+ server "github.com/eris-ltd/eris-db/server"
)
// Core is the high-level structure
@@ -76,14 +80,14 @@ func NewCore(chainId string, consensusConfig *config.ModuleConfig,
func (core *Core) NewGateway(config *server.ServerConfig) (*server.ServeProcess,
error) {
- codec := &core_types.TCodec{}
- eventSubscriptions := NewEventSubscriptions(core.pipe.Events())
+ codec := &rpc_v0.TCodec{}
+ eventSubscriptions := event.NewEventSubscriptions(core.pipe.Events())
// The services.
- tmwss := NewErisDbWsService(codec, core.pipe)
- tmjs := NewErisDbJsonService(codec, core.pipe, eventSubscriptions)
+ tmwss := rpc_v0.NewErisDbWsService(codec, core.pipe)
+ tmjs := rpc_v0.NewErisDbJsonService(codec, core.pipe, eventSubscriptions)
// The servers.
- jsonServer := NewJsonRpcServer(tmjs)
- restServer := NewRestServer(codec, core.pipe, eventSubscriptions)
+ jsonServer := rpc_v0.NewJsonRpcServer(tmjs)
+ restServer := rpc_v0.NewRestServer(codec, core.pipe, eventSubscriptions)
wsServer := server.NewWebSocketServer(config.WebSocket.MaxWebSocketSessions,
tmwss)
// Create a server process.
diff --git a/definitions/pipe.go b/definitions/pipe.go
index 1db83165085c1b32fad713fd6ede3956944fb477..070c3d22bdc1b4ca3b226f4e5aa7937fbac38c56 100644
--- a/definitions/pipe.go
+++ b/definitions/pipe.go
@@ -25,10 +25,10 @@ package definitions
// these interfaces into an Engine, Communicator, NameReg, Permissions (suggestion)
import (
- events "github.com/tendermint/go-events"
tendermint_types "github.com/tendermint/tendermint/types"
account "github.com/eris-ltd/eris-db/account"
+ event "github.com/eris-ltd/eris-db/event"
manager_types "github.com/eris-ltd/eris-db/manager/types"
transaction "github.com/eris-ltd/eris-db/txs"
types "github.com/eris-ltd/eris-db/core/types"
@@ -38,7 +38,7 @@ type Pipe interface {
Accounts() Accounts
Blockchain() Blockchain
Consensus() Consensus
- Events() EventEmitter
+ Events() event.EventEmitter
NameReg() NameReg
Net() Net
Transactor() Transactor
@@ -50,7 +50,7 @@ type Pipe interface {
type Accounts interface {
GenPrivAccount() (*account.PrivAccount, error)
GenPrivAccountFromKey(privKey []byte) (*account.PrivAccount, error)
- Accounts([]*types.FilterData) (*types.AccountList, error)
+ Accounts([]*event.FilterData) (*types.AccountList, error)
Account(address []byte) (*account.Account, error)
Storage(address []byte) (*types.Storage, error)
StorageAt(address, key []byte) (*types.StorageItem, error)
@@ -62,7 +62,7 @@ type Blockchain interface {
ChainId() (string, error)
LatestBlockHeight() (int, error)
LatestBlock() (*tendermint_types.Block, error)
- Blocks([]*types.FilterData) (*types.Blocks, error)
+ Blocks([]*event.FilterData) (*types.Blocks, error)
Block(height int) (*tendermint_types.Block, error)
}
@@ -71,14 +71,9 @@ type Consensus interface {
Validators() (*types.ValidatorList, error)
}
-type EventEmitter interface {
- Subscribe(subId, event string, callback func(events.EventData)) (bool, error)
- Unsubscribe(subId string) (bool, error)
-}
-
type NameReg interface {
Entry(key string) (*transaction.NameRegEntry, error)
- Entries([]*types.FilterData) (*types.ResultListNames, error)
+ Entries([]*event.FilterData) (*types.ResultListNames, error)
}
type Net interface {
diff --git a/definitions/tendermint_pipe.go b/definitions/tendermint_pipe.go
new file mode 100644
index 0000000000000000000000000000000000000000..d82f8727f7e2fb7bbb839c1ba1fa4927b2c3bea8
--- /dev/null
+++ b/definitions/tendermint_pipe.go
@@ -0,0 +1,26 @@
+// Copyright 2015, 2016 Eris Industries (UK) Ltd.
+// This file is part of Eris-RT
+
+// Eris-RT 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.
+
+// Eris-RT 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 Eris-RT. If not, see <http://www.gnu.org/licenses/>.
+
+package definitions
+
+// NOTE: [ben] TendermintPipe is the additional pipe to carry over
+// the RPC exposed by old Tendermint on port `46657` (eris-db-0.11.4 and before)
+// This TendermintPipe interface should be depracted and work towards a generic
+// collection of RPC routes for Eris-DB-1.0.0
+
+type TendermintPipe interface {
+
+}
diff --git a/core/event_cache.go b/event/event_cache.go
similarity index 82%
rename from core/event_cache.go
rename to event/event_cache.go
index f2e2e58a81d4b626ef708df6b67922c957ddba3a..5b196e16eb3d12eeb9c672a6e3965c79a138a72f 100644
--- a/core/event_cache.go
+++ b/event/event_cache.go
@@ -1,13 +1,11 @@
-package core
+package event
import (
"fmt"
"sync"
"time"
- "github.com/tendermint/go-events"
-
- definitions "github.com/eris-ltd/eris-db/definitions"
+ evts "github.com/tendermint/go-events"
)
var (
@@ -48,12 +46,12 @@ func (this *EventCache) poll() []interface{} {
// Catches events that callers subscribe to and adds them to an array ready to be polled.
type EventSubscriptions struct {
mtx *sync.Mutex
- eventEmitter definitions.EventEmitter
+ eventEmitter EventEmitter
subs map[string]*EventCache
reap bool
}
-func NewEventSubscriptions(eventEmitter definitions.EventEmitter) *EventSubscriptions {
+func NewEventSubscriptions(eventEmitter EventEmitter) *EventSubscriptions {
es := &EventSubscriptions{
mtx: &sync.Mutex{},
eventEmitter: eventEmitter,
@@ -86,14 +84,14 @@ func reap(es *EventSubscriptions) {
// a delay - though a conflict is practically impossible, and if it does
// happen it's for an insignificant amount of time (the time it takes to
// carry out EventCache.poll() ).
-func (this *EventSubscriptions) add(eventId string) (string, error) {
- subId, errSID := generateSubId()
+func (this *EventSubscriptions) Add(eventId string) (string, error) {
+ subId, errSID := GenerateSubId()
if errSID != nil {
return "", errSID
}
cache := newEventCache()
_, errC := this.eventEmitter.Subscribe(subId, eventId,
- func(evt events.EventData) {
+ func(evt evts.EventData) {
cache.mtx.Lock()
defer cache.mtx.Unlock()
cache.events = append(cache.events, evt)
@@ -106,7 +104,7 @@ func (this *EventSubscriptions) add(eventId string) (string, error) {
return subId, nil
}
-func (this *EventSubscriptions) poll(subId string) ([]interface{}, error) {
+func (this *EventSubscriptions) Poll(subId string) ([]interface{}, error) {
sub, ok := this.subs[subId]
if !ok {
return nil, fmt.Errorf("Subscription not active. ID: " + subId)
@@ -114,7 +112,7 @@ func (this *EventSubscriptions) poll(subId string) ([]interface{}, error) {
return sub.poll(), nil
}
-func (this *EventSubscriptions) remove(subId string) error {
+func (this *EventSubscriptions) Remove(subId string) error {
this.mtx.Lock()
defer this.mtx.Unlock()
// TODO Check this.
diff --git a/core/event_cache_test.go b/event/event_cache_test.go
similarity index 99%
rename from core/event_cache_test.go
rename to event/event_cache_test.go
index da0a483993b0ac7b73856a6fdf750a19cf3a003e..065611312182bd527b53d52e433ccdacb276469b 100644
--- a/core/event_cache_test.go
+++ b/event/event_cache_test.go
@@ -1,4 +1,4 @@
-package core
+package event
import (
"encoding/hex"
diff --git a/core/types/events.go b/event/events.go
similarity index 64%
rename from core/types/events.go
rename to event/events.go
index c96f7dfa43aa8d83c7078e6f20e84b2fb1fd810a..9df7739d88101be843ebc5a6aa99a13819d5982b 100644
--- a/core/types/events.go
+++ b/event/events.go
@@ -14,9 +14,13 @@
// You should have received a copy of the GNU General Public License
// along with Eris-RT. If not, see <http://www.gnu.org/licenses/>.
-package types
+package event
import (
+ "crypto/rand"
+ "encoding/hex"
+ "strings"
+
evts "github.com/tendermint/go-events"
)
@@ -25,6 +29,11 @@ import (
// [ben] To improve this we will switch out go-events with eris-db/event so
// that there is no need anymore for this poor wrapper.
+type EventEmitter interface {
+ Subscribe(subId, event string, callback func(evts.EventData)) (bool, error)
+ Unsubscribe(subId string) (bool, error)
+}
+
// The events struct has methods for working with events.
type events struct {
eventSwitch *evts.EventSwitch
@@ -45,3 +54,34 @@ func (this *events) Unsubscribe(subId string) (bool, error) {
this.eventSwitch.RemoveListener(subId)
return true, nil
}
+
+// *********************************** Events ***********************************
+
+// EventSubscribe
+type EventSub struct {
+ SubId string `json:"sub_id"`
+}
+
+// EventUnsubscribe
+type EventUnsub struct {
+ Result bool `json:"result"`
+}
+
+// EventPoll
+type PollResponse struct {
+ Events []interface{} `json:"events"`
+}
+
+// **************************************************************************************
+// Helper function
+
+func GenerateSubId() (string, error) {
+ b := make([]byte, 32)
+ _, err := rand.Read(b)
+ if err != nil {
+ return "", err
+ }
+ rStr := hex.EncodeToString(b)
+ return strings.ToUpper(rStr), nil
+
+}
diff --git a/core/types/filters.go b/event/filters.go
similarity index 99%
rename from core/types/filters.go
rename to event/filters.go
index 9cb86241fd8b682d4f65a1f1311dc015e2f820e5..948a2f012af4275782adcd480248cc424b459ca6 100644
--- a/core/types/filters.go
+++ b/event/filters.go
@@ -1,4 +1,4 @@
-package types
+package event
import (
"fmt"
diff --git a/event/event.go b/event_new/event.go
similarity index 100%
rename from event/event.go
rename to event_new/event.go
diff --git a/event/event_test.go b/event_new/event_test.go
similarity index 100%
rename from event/event_test.go
rename to event_new/event_test.go
diff --git a/event/example_test.go b/event_new/example_test.go
similarity index 100%
rename from event/example_test.go
rename to event_new/example_test.go
diff --git a/event/filter/filter.go b/event_new/filter/filter.go
similarity index 100%
rename from event/filter/filter.go
rename to event_new/filter/filter.go
diff --git a/event/filter/filter_test.go b/event_new/filter/filter_test.go
similarity index 100%
rename from event/filter/filter_test.go
rename to event_new/filter/filter_test.go
diff --git a/event/filter/generic_filter.go b/event_new/filter/generic_filter.go
similarity index 100%
rename from event/filter/generic_filter.go
rename to event_new/filter/generic_filter.go
diff --git a/manager/eris-mint/accounts.go b/manager/eris-mint/accounts.go
index 28bb3de1475e0e144e2cd1573a658817f5f5f766..9acbe4a541e40e6c842ff859ee944e7400dc1c85 100644
--- a/manager/eris-mint/accounts.go
+++ b/manager/eris-mint/accounts.go
@@ -26,18 +26,19 @@ import (
tendermint_common "github.com/tendermint/go-common"
- account "github.com/eris-ltd/eris-db/account"
- core_types "github.com/eris-ltd/eris-db/core/types"
+ account "github.com/eris-ltd/eris-db/account"
+ core_types "github.com/eris-ltd/eris-db/core/types"
+ event "github.com/eris-ltd/eris-db/event"
)
// The accounts struct has methods for working with accounts.
type accounts struct {
erisMint *ErisMint
- filterFactory *core_types.FilterFactory
+ filterFactory *event.FilterFactory
}
func newAccounts(erisMint *ErisMint) *accounts {
- ff := core_types.NewFilterFactory()
+ ff := event.NewFilterFactory()
ff.RegisterFilterPool("code", &sync.Pool{
New: func() interface{} {
@@ -73,7 +74,7 @@ func (this *accounts) GenPrivAccountFromKey(privKey []byte) (
}
// Get all accounts.
-func (this *accounts) Accounts(fda []*core_types.FilterData) (
+func (this *accounts) Accounts(fda []*event.FilterData) (
*core_types.AccountList, error) {
accounts := make([]*account.Account, 0)
state := this.erisMint.GetState()
@@ -161,7 +162,7 @@ type AccountCodeFilter struct {
match func([]byte, []byte) bool
}
-func (this *AccountCodeFilter) Configure(fd *core_types.FilterData) error {
+func (this *AccountCodeFilter) Configure(fd *event.FilterData) error {
op := fd.Op
val, err := hex.DecodeString(fd.Value)
@@ -200,12 +201,12 @@ type AccountBalanceFilter struct {
match func(int64, int64) bool
}
-func (this *AccountBalanceFilter) Configure(fd *core_types.FilterData) error {
- val, err := core_types.ParseNumberValue(fd.Value)
+func (this *AccountBalanceFilter) Configure(fd *event.FilterData) error {
+ val, err := event.ParseNumberValue(fd.Value)
if err != nil {
return err
}
- match, err2 := core_types.GetRangeFilter(fd.Op, "balance")
+ match, err2 := event.GetRangeFilter(fd.Op, "balance")
if err2 != nil {
return err2
}
diff --git a/manager/eris-mint/blockchain.go b/manager/eris-mint/blockchain.go
index 461d4291eb8016eb244b93b252a473b93f9e8e6f..86a7b6481b29af321188df043a441306d40094a5 100644
--- a/manager/eris-mint/blockchain.go
+++ b/manager/eris-mint/blockchain.go
@@ -29,6 +29,7 @@ import (
"github.com/tendermint/tendermint/types"
core_types "github.com/eris-ltd/eris-db/core/types"
+ event "github.com/eris-ltd/eris-db/event"
"github.com/eris-ltd/eris-db/manager/eris-mint/state"
)
@@ -45,11 +46,11 @@ type blockchain struct {
chainID string
genDocFile string // XXX
blockStore BlockStore
- filterFactory *core_types.FilterFactory
+ filterFactory *event.FilterFactory
}
func newBlockchain(chainID, genDocFile string, blockStore BlockStore) *blockchain {
- ff := core_types.NewFilterFactory()
+ ff := event.NewFilterFactory()
ff.RegisterFilterPool("height", &sync.Pool{
New: func() interface{} {
@@ -106,7 +107,7 @@ func (this *blockchain) LatestBlock() (*types.Block, error) {
// Get the blocks from 'minHeight' to 'maxHeight'.
// TODO Caps on total number of blocks should be set.
-func (this *blockchain) Blocks(fda []*core_types.FilterData) (*core_types.Blocks, error) {
+func (this *blockchain) Blocks(fda []*event.FilterData) (*core_types.Blocks, error) {
newFda := fda
var minHeight int
var maxHeight int
@@ -156,7 +157,7 @@ func (this *blockchain) Block(height int) (*types.Block, error) {
}
// Function for matching accounts against filter data.
-func (this *accounts) matchBlock(block, fda []*core_types.FilterData) bool {
+func (this *accounts) matchBlock(block, fda []*event.FilterData) bool {
return false
}
@@ -168,7 +169,7 @@ type BlockHeightFilter struct {
match func(int, int) bool
}
-func (this *BlockHeightFilter) Configure(fd *core_types.FilterData) error {
+func (this *BlockHeightFilter) Configure(fd *event.FilterData) error {
op := fd.Op
var val int
if fd.Value == "min" {
@@ -224,7 +225,7 @@ func (this *BlockHeightFilter) Match(v interface{}) bool {
}
// TODO i should start using named return params...
-func getHeightMinMax(fda []*core_types.FilterData, height int) (int, int, []*core_types.FilterData, error) {
+func getHeightMinMax(fda []*event.FilterData, height int) (int, int, []*event.FilterData, error) {
min := 0
max := height
diff --git a/manager/eris-mint/namereg.go b/manager/eris-mint/namereg.go
index 4871a533132a9c96b71b0104f13adb88f2299c5c..cc161feb19dc2bd00dd5940e48b6483bb0de327b 100644
--- a/manager/eris-mint/namereg.go
+++ b/manager/eris-mint/namereg.go
@@ -28,17 +28,18 @@ import (
"github.com/eris-ltd/eris-db/txs"
core_types "github.com/eris-ltd/eris-db/core/types"
+ event "github.com/eris-ltd/eris-db/event"
)
// The net struct.
type namereg struct {
erisMint *ErisMint
- filterFactory *core_types.FilterFactory
+ filterFactory *event.FilterFactory
}
func newNameReg(erisMint *ErisMint) *namereg {
- ff := core_types.NewFilterFactory()
+ ff := event.NewFilterFactory()
ff.RegisterFilterPool("name", &sync.Pool{
New: func() interface{} {
@@ -76,7 +77,7 @@ func (this *namereg) Entry(key string) (*txs.NameRegEntry, error) {
return entry, nil
}
-func (this *namereg) Entries(filters []*core_types.FilterData) (*core_types.ResultListNames, error) {
+func (this *namereg) Entries(filters []*event.FilterData) (*core_types.ResultListNames, error) {
var blockHeight int
var names []*txs.NameRegEntry
state := this.erisMint.GetState()
@@ -108,7 +109,7 @@ type NameRegNameFilter struct {
match func(string, string) bool
}
-func (this *NameRegNameFilter) Configure(fd *core_types.FilterData) error {
+func (this *NameRegNameFilter) Configure(fd *event.FilterData) error {
op := fd.Op
val := fd.Value
@@ -144,7 +145,7 @@ type NameRegOwnerFilter struct {
match func([]byte, []byte) bool
}
-func (this *NameRegOwnerFilter) Configure(fd *core_types.FilterData) error {
+func (this *NameRegOwnerFilter) Configure(fd *event.FilterData) error {
op := fd.Op
val, err := hex.DecodeString(fd.Value)
@@ -183,7 +184,7 @@ type NameRegDataFilter struct {
match func(string, string) bool
}
-func (this *NameRegDataFilter) Configure(fd *core_types.FilterData) error {
+func (this *NameRegDataFilter) Configure(fd *event.FilterData) error {
op := fd.Op
val := fd.Value
@@ -219,12 +220,12 @@ type NameRegExpiresFilter struct {
match func(int64, int64) bool
}
-func (this *NameRegExpiresFilter) Configure(fd *core_types.FilterData) error {
- val, err := core_types.ParseNumberValue(fd.Value)
+func (this *NameRegExpiresFilter) Configure(fd *event.FilterData) error {
+ val, err := event.ParseNumberValue(fd.Value)
if err != nil {
return err
}
- match, err2 := core_types.GetRangeFilter(fd.Op, "expires")
+ match, err2 := event.GetRangeFilter(fd.Op, "expires")
if err2 != nil {
return err2
}
diff --git a/manager/eris-mint/pipe.go b/manager/eris-mint/pipe.go
index 74bc637313cb56a6b97b4e2f84cf0411778a8bfd..c5dcf62099138cbc22278511fae11dab730fc0a9 100644
--- a/manager/eris-mint/pipe.go
+++ b/manager/eris-mint/pipe.go
@@ -28,6 +28,7 @@ import (
config "github.com/eris-ltd/eris-db/config"
definitions "github.com/eris-ltd/eris-db/definitions"
+ event "github.com/eris-ltd/eris-db/event"
manager_types "github.com/eris-ltd/eris-db/manager/types"
state "github.com/eris-ltd/eris-db/manager/eris-mint/state"
state_types "github.com/eris-ltd/eris-db/manager/eris-mint/state/types"
@@ -41,7 +42,7 @@ type ErisMintPipe struct {
accounts definitions.Accounts
blockchain definitions.Blockchain
consensus definitions.Consensus
- events definitions.EventEmitter
+ events event.EventEmitter
namereg definitions.NameReg
net definitions.Net
transactor definitions.Transactor
@@ -53,6 +54,10 @@ type ErisMintPipe struct {
// eris-db/definitions.Pipe
var _ definitions.Pipe = (*ErisMintPipe)(nil)
+// NOTE [ben] Compiler check to ensure ErisMintPipe successfully implements
+// eris-db/definitions.TendermintPipe
+var _ definitions.TendermintPipe = (*ErisMintPipe)(nil)
+
func NewErisMintPipe(moduleConfig *config.ModuleConfig,
eventSwitch *tendermint_events.EventSwitch) (*ErisMintPipe, error) {
@@ -163,7 +168,7 @@ func (pipe *ErisMintPipe) Consensus() definitions.Consensus {
return pipe.consensus
}
-func (pipe *ErisMintPipe) Events() definitions.EventEmitter {
+func (pipe *ErisMintPipe) Events() event.EventEmitter {
return pipe.events
}
diff --git a/manager/eris-mint/transactor.go b/manager/eris-mint/transactor.go
index 548375140df03aeaa1f47f7e58b5289b33d05162..0f5f21b4e7809f508eae4c797471c3a6ea10f1a7 100644
--- a/manager/eris-mint/transactor.go
+++ b/manager/eris-mint/transactor.go
@@ -31,7 +31,7 @@ import (
"github.com/eris-ltd/eris-db/account"
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/manager/eris-mint/evm"
"github.com/eris-ltd/eris-db/manager/eris-mint/state"
"github.com/eris-ltd/eris-db/txs"
@@ -41,12 +41,12 @@ type transactor struct {
chainID string
eventSwitch tEvents.Fireable
erisMint *ErisMint
- eventEmitter definitions.EventEmitter
+ eventEmitter event.EventEmitter
txMtx *sync.Mutex
}
func newTransactor(chainID string, eventSwitch tEvents.Fireable,
- erisMint *ErisMint, eventEmitter definitions.EventEmitter) *transactor {
+ erisMint *ErisMint, eventEmitter event.EventEmitter) *transactor {
txs := &transactor{
chainID,
eventSwitch,
diff --git a/rpc/client/client.go b/rpc/tendermint/client/client.go
similarity index 100%
rename from rpc/client/client.go
rename to rpc/tendermint/client/client.go
diff --git a/rpc/core/accounts.go b/rpc/tendermint/core/accounts.go
similarity index 100%
rename from rpc/core/accounts.go
rename to rpc/tendermint/core/accounts.go
diff --git a/rpc/core/log.go b/rpc/tendermint/core/log.go
similarity index 100%
rename from rpc/core/log.go
rename to rpc/tendermint/core/log.go
diff --git a/rpc/core/mempool.go b/rpc/tendermint/core/mempool.go
similarity index 100%
rename from rpc/core/mempool.go
rename to rpc/tendermint/core/mempool.go
diff --git a/rpc/core/names.go b/rpc/tendermint/core/names.go
similarity index 100%
rename from rpc/core/names.go
rename to rpc/tendermint/core/names.go
diff --git a/rpc/core/net.go b/rpc/tendermint/core/net.go
similarity index 100%
rename from rpc/core/net.go
rename to rpc/tendermint/core/net.go
diff --git a/rpc/core/pipe.go b/rpc/tendermint/core/pipe.go
similarity index 100%
rename from rpc/core/pipe.go
rename to rpc/tendermint/core/pipe.go
diff --git a/rpc/core/routes.go b/rpc/tendermint/core/routes.go
similarity index 100%
rename from rpc/core/routes.go
rename to rpc/tendermint/core/routes.go
diff --git a/rpc/core/txs.go b/rpc/tendermint/core/txs.go
similarity index 100%
rename from rpc/core/txs.go
rename to rpc/tendermint/core/txs.go
diff --git a/rpc/core/types/responses.go b/rpc/tendermint/core/types/responses.go
similarity index 100%
rename from rpc/core/types/responses.go
rename to rpc/tendermint/core/types/responses.go
diff --git a/rpc/jsonrpc.go b/rpc/tendermint/jsonrpc.go
similarity index 98%
rename from rpc/jsonrpc.go
rename to rpc/tendermint/jsonrpc.go
index 72115138ad53350c8619c1fdce1ba67720e78a17..f0be57ee3633a085373aa117d7eb56d3aec3e37a 100644
--- a/rpc/jsonrpc.go
+++ b/rpc/tendermint/jsonrpc.go
@@ -1,4 +1,4 @@
-package rpc
+package rpc_tendermint
import (
"encoding/json"
diff --git a/rpc/rpc_test.go b/rpc/tendermint/rpc_test.go
similarity index 96%
rename from rpc/rpc_test.go
rename to rpc/tendermint/rpc_test.go
index bfafa4c2f9861f01192de0ad9b9aba05897d304d..5764ef6407f0b16c1af89bc955d31f8b1701001e 100644
--- a/rpc/rpc_test.go
+++ b/rpc/tendermint/rpc_test.go
@@ -1,4 +1,4 @@
-package rpc
+package rpc_tendermint
import (
"github.com/stretchr/testify/assert"
diff --git a/rpc/test/client_rpc_test.go b/rpc/tendermint/test/client_rpc_test.go
similarity index 100%
rename from rpc/test/client_rpc_test.go
rename to rpc/tendermint/test/client_rpc_test.go
diff --git a/rpc/test/client_ws_test.go b/rpc/tendermint/test/client_ws_test.go
similarity index 100%
rename from rpc/test/client_ws_test.go
rename to rpc/tendermint/test/client_ws_test.go
diff --git a/rpc/test/genesis.go b/rpc/tendermint/test/genesis.go
similarity index 95%
rename from rpc/test/genesis.go
rename to rpc/tendermint/test/genesis.go
index d1ee56212430394bf7f9e7a08bdff5b34b1eaf46..3cd80e11130fb6d27449d4d7b3c68e84582143ab 100644
--- a/rpc/test/genesis.go
+++ b/rpc/tendermint/test/genesis.go
@@ -40,7 +40,7 @@ var defaultGenesis = `{
}`
var defaultPrivValidator = `{
- "address": "1D7A91CB32F758A02EBB9BE1FB6F8DEE56F90D42",
+ "address": "1D7A91CB32F758A02EBB9BE1FB6F8DEE56F90D42",
"pub_key": [1,"06FBAC4E285285D1D91FCBC7E91C780ADA11516F67462340B3980CE2B94940E8"],
"priv_key": [1,"C453604BD6480D5538B4C6FD2E3E314B5BCE518D75ADE4DA3DA85AB8ADFD819606FBAC4E285285D1D91FCBC7E91C780ADA11516F67462340B3980CE2B94940E8"],
"last_height":0,
diff --git a/rpc/test/helpers.go b/rpc/tendermint/test/helpers.go
similarity index 100%
rename from rpc/test/helpers.go
rename to rpc/tendermint/test/helpers.go
diff --git a/rpc/test/tests.go b/rpc/tendermint/test/tests.go
similarity index 100%
rename from rpc/test/tests.go
rename to rpc/tendermint/test/tests.go
diff --git a/rpc/test/ws_helpers.go b/rpc/tendermint/test/ws_helpers.go
similarity index 100%
rename from rpc/test/ws_helpers.go
rename to rpc/tendermint/test/ws_helpers.go
diff --git a/core/types/codec.go b/rpc/v0/codec.go
similarity index 99%
rename from core/types/codec.go
rename to rpc/v0/codec.go
index eff1ac4b61220934e374743ec0258156a442b2f7..1fd379bea6e5e330827421c9a56813ea165d0d76 100644
--- a/core/types/codec.go
+++ b/rpc/v0/codec.go
@@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with Eris-RT. If not, see <http://www.gnu.org/licenses/>.
-package types
+package rpc_v0
import (
"io"
diff --git a/core/json_service.go b/rpc/v0/json_service.go
similarity index 68%
rename from core/json_service.go
rename to rpc/v0/json_service.go
index 9d10ff952925362d4b1818e4fae1b40db24b418d..d880790ac2e3cca83831f3565c25d9f4e8248849 100644
--- a/core/json_service.go
+++ b/rpc/v0/json_service.go
@@ -1,4 +1,4 @@
-package core
+package rpc_v0
import (
"encoding/json"
@@ -8,10 +8,11 @@ import (
log "github.com/eris-ltd/eris-logger"
- core_types "github.com/eris-ltd/eris-db/core/types"
- definitions "github.com/eris-ltd/eris-db/definitions"
- rpc "github.com/eris-ltd/eris-db/rpc"
- server "github.com/eris-ltd/eris-db/server"
+ definitions "github.com/eris-ltd/eris-db/definitions"
+ event "github.com/eris-ltd/eris-db/event"
+ rpc "github.com/eris-ltd/eris-db/rpc"
+ rpc_tendermint "github.com/eris-ltd/eris-db/rpc/tendermint"
+ server "github.com/eris-ltd/eris-db/server"
)
// Server used to handle JSON-RPC 2.0 requests. Implements server.Server
@@ -54,13 +55,13 @@ func (this *JsonRpcServer) handleFunc(c *gin.Context) {
type ErisDbJsonService struct {
codec rpc.Codec
pipe definitions.Pipe
- eventSubs *EventSubscriptions
+ eventSubs *event.EventSubscriptions
defaultHandlers map[string]RequestHandlerFunc
}
// Create a new JSON-RPC 2.0 service for erisdb (tendermint).
func NewErisDbJsonService(codec rpc.Codec, pipe definitions.Pipe,
- eventSubs *EventSubscriptions) server.HttpService {
+ eventSubs *event.EventSubscriptions) server.HttpService {
tmhttps := &ErisDbJsonService{codec: codec, pipe: pipe, eventSubs: eventSubs}
mtds := &ErisDbMethods{codec, pipe}
@@ -78,19 +79,19 @@ func NewErisDbJsonService(codec rpc.Codec, pipe definitions.Pipe,
func (this *ErisDbJsonService) Process(r *http.Request, w http.ResponseWriter) {
// Create new request object and unmarshal.
- req := &rpc.RPCRequest{}
+ req := &rpc_tendermint.RPCRequest{}
decoder := json.NewDecoder(r.Body)
errU := decoder.Decode(req)
// Error when decoding.
if errU != nil {
- this.writeError("Failed to parse request: "+errU.Error(), "", rpc.PARSE_ERROR, w)
+ this.writeError("Failed to parse request: "+errU.Error(), "", rpc_tendermint.PARSE_ERROR, w)
return
}
// Wrong protocol version.
if req.JSONRPC != "2.0" {
- this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id, rpc.INVALID_REQUEST, w)
+ this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id, rpc_tendermint.INVALID_REQUEST, w)
return
}
@@ -104,13 +105,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, rpc.METHOD_NOT_FOUND, w)
+ this.writeError("Method not found: "+mName, req.Id, rpc_tendermint.METHOD_NOT_FOUND, w)
}
}
// Helper for writing error responses.
func (this *ErisDbJsonService) writeError(msg, id string, code int, w http.ResponseWriter) {
- response := rpc.NewRPCErrorResponse(id, code, msg)
+ response := rpc_tendermint.NewRPCErrorResponse(id, code, msg)
err := this.codec.Encode(response, w)
// If there's an error here all bets are off.
if err != nil {
@@ -123,11 +124,11 @@ 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) {
log.Debug("Result: %v\n", result)
- response := rpc.NewRPCResponse(id, result)
+ response := rpc_tendermint.NewRPCResponse(id, result)
err := this.codec.Encode(response, w)
log.Debug("Response: %v\n", response)
if err != nil {
- this.writeError("Internal error: "+err.Error(), id, rpc.INTERNAL_ERROR, w)
+ this.writeError("Internal error: "+err.Error(), id, rpc_tendermint.INTERNAL_ERROR, w)
return
}
w.WriteHeader(200)
@@ -136,48 +137,48 @@ func (this *ErisDbJsonService) writeResponse(id string, result interface{}, w ht
// *************************************** Events ************************************
// Subscribe to an event.
-func (this *ErisDbJsonService) EventSubscribe(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbJsonService) EventSubscribe(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &EventIdParam{}
err := json.Unmarshal(request.Params, param)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
eventId := param.EventId
- subId, errC := this.eventSubs.add(eventId)
+ subId, errC := this.eventSubs.Add(eventId)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
- return &core_types.EventSub{subId}, 0, nil
+ return &event.EventSub{subId}, 0, nil
}
// Un-subscribe from an event.
-func (this *ErisDbJsonService) EventUnsubscribe(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbJsonService) EventUnsubscribe(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &SubIdParam{}
err := json.Unmarshal(request.Params, param)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
subId := param.SubId
result, errC := this.pipe.Events().Unsubscribe(subId)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
- return &core_types.EventUnsub{result}, 0, nil
+ return &event.EventUnsub{result}, 0, nil
}
// Check subscription event cache for new data.
-func (this *ErisDbJsonService) EventPoll(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbJsonService) EventPoll(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &SubIdParam{}
err := json.Unmarshal(request.Params, param)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
subId := param.SubId
- result, errC := this.eventSubs.poll(subId)
+ result, errC := this.eventSubs.Poll(subId)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
- return &core_types.PollResponse{result}, 0, nil
+ return &event.PollResponse{result}, 0, nil
}
diff --git a/core/methods.go b/rpc/v0/methods.go
similarity index 62%
rename from core/methods.go
rename to rpc/v0/methods.go
index 3dcecec07bc63e3f21b1392843ac3555a9763ebb..1c4feeec6c6b3b5f946f567526e4c74dab8ce1b5 100644
--- a/core/methods.go
+++ b/rpc/v0/methods.go
@@ -1,14 +1,10 @@
-package core
+package rpc_v0
import (
- "crypto/rand"
- "encoding/hex"
- "strings"
-
- rpc "github.com/eris-ltd/eris-db/rpc"
-
- core_types "github.com/eris-ltd/eris-db/core/types"
- definitions "github.com/eris-ltd/eris-db/definitions"
+ core_types "github.com/eris-ltd/eris-db/core/types"
+ definitions "github.com/eris-ltd/eris-db/definitions"
+ rpc "github.com/eris-ltd/eris-db/rpc"
+ rpc_tendermint "github.com/eris-ltd/eris-db/rpc/tendermint"
"github.com/eris-ltd/eris-db/txs"
)
@@ -60,7 +56,7 @@ type ErisDbMethods struct {
}
// Used to handle requests. interface{} param is a wildcard used for example with socket events.
-type RequestHandlerFunc func(*rpc.RPCRequest, interface{}) (interface{}, int, error)
+type RequestHandlerFunc func(*rpc_tendermint.RPCRequest, interface{}) (interface{}, int, error)
// Private. Create a method name -> method handler map.
func (this *ErisDbMethods) getMethods() map[string]RequestHandlerFunc {
@@ -112,387 +108,374 @@ func (this *ErisDbMethods) getMethods() map[string]RequestHandlerFunc {
// *************************************** Accounts ***************************************
-func (this *ErisDbMethods) GenPrivAccount(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) GenPrivAccount(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
pac, errC := this.pipe.Accounts().GenPrivAccount()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return pac, 0, nil
}
-func (this *ErisDbMethods) GenPrivAccountFromKey(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) GenPrivAccountFromKey(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &PrivKeyParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
privKey := param.PrivKey
pac, errC := this.pipe.Accounts().GenPrivAccountFromKey(privKey)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return pac, 0, nil
}
-func (this *ErisDbMethods) Account(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Account(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &AddressParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
address := param.Address
// TODO is address check?
account, errC := this.pipe.Accounts().Account(address)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return account, 0, nil
}
-func (this *ErisDbMethods) Accounts(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Accounts(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &AccountsParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
list, errC := this.pipe.Accounts().Accounts(param.Filters)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return list, 0, nil
}
-func (this *ErisDbMethods) AccountStorage(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) AccountStorage(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &AddressParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
address := param.Address
storage, errC := this.pipe.Accounts().Storage(address)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return storage, 0, nil
}
-func (this *ErisDbMethods) AccountStorageAt(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) AccountStorageAt(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &StorageAtParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
address := param.Address
key := param.Key
storageItem, errC := this.pipe.Accounts().StorageAt(address, key)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return storageItem, 0, nil
}
// *************************************** Blockchain ************************************
-func (this *ErisDbMethods) BlockchainInfo(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) BlockchainInfo(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
status, errC := this.pipe.Blockchain().Info()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return status, 0, nil
}
-func (this *ErisDbMethods) ChainId(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) ChainId(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
chainId, errC := this.pipe.Blockchain().ChainId()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return &core_types.ChainId{chainId}, 0, nil
}
-func (this *ErisDbMethods) GenesisHash(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) GenesisHash(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
hash, errC := this.pipe.Blockchain().GenesisHash()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return &core_types.GenesisHash{hash}, 0, nil
}
-func (this *ErisDbMethods) LatestBlockHeight(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) LatestBlockHeight(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
height, errC := this.pipe.Blockchain().LatestBlockHeight()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return &core_types.LatestBlockHeight{height}, 0, nil
}
-func (this *ErisDbMethods) LatestBlock(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) LatestBlock(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
block, errC := this.pipe.Blockchain().LatestBlock()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return block, 0, nil
}
-func (this *ErisDbMethods) Blocks(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Blocks(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &BlocksParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
blocks, errC := this.pipe.Blockchain().Blocks(param.Filters)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return blocks, 0, nil
}
-func (this *ErisDbMethods) Block(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Block(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &HeightParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
height := param.Height
block, errC := this.pipe.Blockchain().Block(height)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return block, 0, nil
}
// *************************************** Consensus ************************************
-func (this *ErisDbMethods) ConsensusState(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) ConsensusState(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
state, errC := this.pipe.Consensus().State()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return state, 0, nil
}
-func (this *ErisDbMethods) Validators(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Validators(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
validators, errC := this.pipe.Consensus().Validators()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return validators, 0, nil
}
// *************************************** Net ************************************
-func (this *ErisDbMethods) NetworkInfo(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) NetworkInfo(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
info, errC := this.pipe.Net().Info()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return info, 0, nil
}
-func (this *ErisDbMethods) ClientVersion(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) ClientVersion(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
version, errC := this.pipe.Net().ClientVersion()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return &core_types.ClientVersion{version}, 0, nil
}
-func (this *ErisDbMethods) Moniker(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Moniker(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
moniker, errC := this.pipe.Net().Moniker()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return &core_types.Moniker{moniker}, 0, nil
}
-func (this *ErisDbMethods) Listening(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Listening(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
listening, errC := this.pipe.Net().Listening()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return &core_types.Listening{listening}, 0, nil
}
-func (this *ErisDbMethods) Listeners(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Listeners(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
listeners, errC := this.pipe.Net().Listeners()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return &core_types.Listeners{listeners}, 0, nil
}
-func (this *ErisDbMethods) Peers(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Peers(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
peers, errC := this.pipe.Net().Peers()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return peers, 0, nil
}
-func (this *ErisDbMethods) Peer(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Peer(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &PeerParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
address := param.Address
peer, errC := this.pipe.Net().Peer(address)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return peer, 0, nil
}
// *************************************** Txs ************************************
-func (this *ErisDbMethods) Call(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Call(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &CallParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
from := param.From
to := param.Address
data := param.Data
call, errC := this.pipe.Transactor().Call(from, to, data)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return call, 0, nil
}
-func (this *ErisDbMethods) CallCode(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) CallCode(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &CallCodeParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
from := param.From
code := param.Code
data := param.Data
call, errC := this.pipe.Transactor().CallCode(from, code, data)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return call, 0, nil
}
-func (this *ErisDbMethods) BroadcastTx(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) BroadcastTx(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &txs.CallTx{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
receipt, errC := this.pipe.Transactor().BroadcastTx(param)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return receipt, 0, nil
}
-func (this *ErisDbMethods) Transact(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) Transact(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &TransactParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
receipt, errC := this.pipe.Transactor().Transact(param.PrivKey, param.Address, param.Data, param.GasLimit, param.Fee)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return receipt, 0, nil
}
-func (this *ErisDbMethods) TransactAndHold(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) TransactAndHold(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &TransactParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
ce, errC := this.pipe.Transactor().TransactAndHold(param.PrivKey, param.Address, param.Data, param.GasLimit, param.Fee)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return ce, 0, nil
}
-func (this *ErisDbMethods) TransactNameReg(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) TransactNameReg(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &TransactNameRegParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
receipt, errC := this.pipe.Transactor().TransactNameReg(param.PrivKey, param.Name, param.Data, param.Amount, param.Fee)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return receipt, 0, nil
}
-func (this *ErisDbMethods) UnconfirmedTxs(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) UnconfirmedTxs(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
txs, errC := this.pipe.Transactor().UnconfirmedTxs()
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return txs, 0, nil
}
-func (this *ErisDbMethods) SignTx(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) SignTx(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &SignTxParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
tx := param.Tx
pAccs := param.PrivAccounts
txRet, errC := this.pipe.Transactor().SignTx(tx, pAccs)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return txRet, 0, nil
}
// *************************************** Name Registry ***************************************
-func (this *ErisDbMethods) NameRegEntry(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) NameRegEntry(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &NameRegEntryParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
name := param.Name
// TODO is address check?
entry, errC := this.pipe.NameReg().Entry(name)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return entry, 0, nil
}
-func (this *ErisDbMethods) NameRegEntries(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbMethods) NameRegEntries(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &FilterListParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
list, errC := this.pipe.NameReg().Entries(param.Filters)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
return list, 0, nil
}
-
-// **************************************************************************************
-
-func generateSubId() (string, error) {
- b := make([]byte, 32)
- _, err := rand.Read(b)
- if err != nil {
- return "", err
- }
- rStr := hex.EncodeToString(b)
- return strings.ToUpper(rStr), nil
-
-}
diff --git a/core/params.go b/rpc/v0/params.go
similarity index 90%
rename from core/params.go
rename to rpc/v0/params.go
index 1549eaf94e6c01f203222b21f430b63325ded463..08b93079bcad641660c889afc6543ad7d890e9f1 100644
--- a/core/params.go
+++ b/rpc/v0/params.go
@@ -1,8 +1,8 @@
-package core
+package rpc_v0
import (
"github.com/eris-ltd/eris-db/account"
- core_types "github.com/eris-ltd/eris-db/core/types"
+ event "github.com/eris-ltd/eris-db/event"
"github.com/eris-ltd/eris-db/txs"
)
@@ -17,12 +17,12 @@ type (
// Used to send an address
// TODO deprecate in favor of 'FilterListParam'
AccountsParam struct {
- Filters []*core_types.FilterData `json:"filters"`
+ Filters []*event.FilterData `json:"filters"`
}
// Used to send an address
FilterListParam struct {
- Filters []*core_types.FilterData `json:"filters"`
+ Filters []*event.FilterData `json:"filters"`
}
PrivKeyParam struct {
@@ -43,7 +43,7 @@ type (
// Get a series of blocks
// TODO deprecate in favor of 'FilterListParam'
BlocksParam struct {
- Filters []*core_types.FilterData `json:"filters"`
+ Filters []*event.FilterData `json:"filters"`
}
// Event Id
diff --git a/core/restServer.go b/rpc/v0/restServer.go
similarity index 92%
rename from core/restServer.go
rename to rpc/v0/restServer.go
index 2875317c056978687cf95eefbd11c5ecb53663e0..41655fd4d865f2a1652ba21daf2a2cc27dd61155 100644
--- a/core/restServer.go
+++ b/rpc/v0/restServer.go
@@ -1,4 +1,4 @@
-package core
+package rpc_v0
import (
"encoding/hex"
@@ -10,6 +10,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"
rpc "github.com/eris-ltd/eris-db/rpc"
server "github.com/eris-ltd/eris-db/server"
"github.com/eris-ltd/eris-db/txs"
@@ -22,12 +23,13 @@ import (
type RestServer struct {
codec rpc.Codec
pipe definitions.Pipe
- eventSubs *EventSubscriptions
+ eventSubs *event.EventSubscriptions
running bool
}
// Create a new rest server.
-func NewRestServer(codec rpc.Codec, pipe definitions.Pipe, eventSubs *EventSubscriptions) *RestServer {
+func NewRestServer(codec rpc.Codec, pipe definitions.Pipe,
+ eventSubs *event.EventSubscriptions) *RestServer {
return &RestServer{codec: codec, pipe: pipe, eventSubs: eventSubs}
}
@@ -108,10 +110,10 @@ func (this *RestServer) handleGenPrivAcc(c *gin.Context) {
}
func (this *RestServer) handleAccounts(c *gin.Context) {
- var filters []*core_types.FilterData
+ var filters []*event.FilterData
fs, exists := c.Get("filters")
if exists {
- filters = fs.([]*core_types.FilterData)
+ filters = fs.([]*event.FilterData)
}
accs, err := this.pipe.Accounts().Accounts(filters)
if err != nil {
@@ -200,10 +202,10 @@ func (this *RestServer) handleLatestBlock(c *gin.Context) {
}
func (this *RestServer) handleBlocks(c *gin.Context) {
- var filters []*core_types.FilterData
+ var filters []*event.FilterData
fs, exists := c.Get("filters")
if exists {
- filters = fs.([]*core_types.FilterData)
+ filters = fs.([]*event.FilterData)
}
blocks, err := this.pipe.Blockchain().Blocks(filters)
@@ -252,41 +254,41 @@ func (this *RestServer) handleEventSubscribe(c *gin.Context) {
if errD != nil {
c.AbortWithError(500, errD)
}
- subId, err := this.eventSubs.add(param.EventId)
+ subId, err := this.eventSubs.Add(param.EventId)
if err != nil {
c.AbortWithError(500, err)
}
c.Writer.WriteHeader(200)
- this.codec.Encode(&core_types.EventSub{subId}, c.Writer)
+ this.codec.Encode(&event.EventSub{subId}, c.Writer)
}
func (this *RestServer) handleEventPoll(c *gin.Context) {
subId := c.MustGet("id").(string)
- data, err := this.eventSubs.poll(subId)
+ data, err := this.eventSubs.Poll(subId)
if err != nil {
c.AbortWithError(500, err)
}
c.Writer.WriteHeader(200)
- this.codec.Encode(&core_types.PollResponse{data}, c.Writer)
+ this.codec.Encode(&event.PollResponse{data}, c.Writer)
}
func (this *RestServer) handleEventUnsubscribe(c *gin.Context) {
subId := c.MustGet("id").(string)
- err := this.eventSubs.remove(subId)
+ err := this.eventSubs.Remove(subId)
if err != nil {
c.AbortWithError(500, err)
}
c.Writer.WriteHeader(200)
- this.codec.Encode(&core_types.EventUnsub{true}, c.Writer)
+ this.codec.Encode(&event.EventUnsub{true}, c.Writer)
}
// ********************************* NameReg *********************************
func (this *RestServer) handleNameRegEntries(c *gin.Context) {
- var filters []*core_types.FilterData
+ var filters []*event.FilterData
fs, exists := c.Get("filters")
if exists {
- filters = fs.([]*core_types.FilterData)
+ filters = fs.([]*event.FilterData)
}
entries, err := this.pipe.NameReg().Entries(filters)
if err != nil {
@@ -564,12 +566,12 @@ func parseSearchQuery(c *gin.Context) {
}
}
-func _parseSearchQuery(queryString string) ([]*core_types.FilterData, error) {
+func _parseSearchQuery(queryString string) ([]*event.FilterData, error) {
if len(queryString) == 0 {
return nil, nil
}
filters := strings.Split(queryString, " ")
- fdArr := []*core_types.FilterData{}
+ fdArr := []*event.FilterData{}
for _, f := range filters {
kv := strings.Split(f, ":")
if len(kv) != 2 {
@@ -592,10 +594,10 @@ func _parseSearchQuery(queryString string) ([]*core_types.FilterData, error) {
}
// Parse the query statement and create . Two filter data in case of a range param.
-func toFilterData(field, stmt string) (*core_types.FilterData, *core_types.FilterData, error) {
+func toFilterData(field, stmt string) (*event.FilterData, *event.FilterData, error) {
// In case statement is empty
if stmt == "" {
- return &core_types.FilterData{field, "==", ""}, nil, nil
+ return &event.FilterData{field, "==", ""}, nil, nil
}
// Simple routine based on string splitting. TODO add quoted range query.
if stmt[0] == '>' || stmt[0] == '<' || stmt[0] == '=' || stmt[0] == '!' {
@@ -603,18 +605,18 @@ func toFilterData(field, stmt string) (*core_types.FilterData, *core_types.Filte
// peek at next and check if it's a "=".
if len(stmt) == 1 {
- return &core_types.FilterData{field, stmt[0:1], ""}, nil, nil
+ return &event.FilterData{field, stmt[0:1], ""}, nil, nil
} else if stmt[1] == '=' {
- return &core_types.FilterData{field, stmt[:2], stmt[2:]}, nil, nil
+ return &event.FilterData{field, stmt[:2], stmt[2:]}, nil, nil
} else {
- return &core_types.FilterData{field, stmt[0:1], stmt[1:]}, nil, nil
+ return &event.FilterData{field, stmt[0:1], stmt[1:]}, nil, nil
}
} else {
// Either we have a range query here or a malformed query.
rng := strings.Split(stmt, "..")
// This is for when there is no op, but the value is not empty.
if len(rng) == 1 {
- return &core_types.FilterData{field, "==", stmt}, nil, nil
+ return &event.FilterData{field, "==", stmt}, nil, nil
}
// The rest.
if len(rng) != 2 || rng[0] == "" || rng[1] == "" {
@@ -632,7 +634,7 @@ func toFilterData(field, stmt string) (*core_types.FilterData, *core_types.Filte
} else {
max = rng[1]
}
- return &core_types.FilterData{field, ">=", min}, &core_types.FilterData{field, "<=", max}, nil
+ return &event.FilterData{field, ">=", min}, &event.FilterData{field, "<=", max}, nil
}
return nil, nil, nil
}
diff --git a/core/wsService.go b/rpc/v0/wsService.go
similarity index 62%
rename from core/wsService.go
rename to rpc/v0/wsService.go
index 0937a04cc5e06bc38b38b6333be9c2e374845c82..98438280f605efe03099c4990a9bd52e13931ca2 100644
--- a/core/wsService.go
+++ b/rpc/v0/wsService.go
@@ -1,4 +1,4 @@
-package core
+package rpc_v0
import (
"encoding/json"
@@ -8,10 +8,11 @@ import (
log "github.com/eris-ltd/eris-logger"
- core_types "github.com/eris-ltd/eris-db/core/types"
- definitions "github.com/eris-ltd/eris-db/definitions"
- rpc "github.com/eris-ltd/eris-db/rpc"
- server "github.com/eris-ltd/eris-db/server"
+ definitions "github.com/eris-ltd/eris-db/definitions"
+ event "github.com/eris-ltd/eris-db/event"
+ rpc "github.com/eris-ltd/eris-db/rpc"
+ rpc_tendermint "github.com/eris-ltd/eris-db/rpc/tendermint"
+ server "github.com/eris-ltd/eris-db/server"
)
// Used for ErisDb. Implements WebSocketService.
@@ -39,18 +40,18 @@ func NewErisDbWsService(codec rpc.Codec,
func (this *ErisDbWsService) Process(msg []byte, session *server.WSSession) {
log.Debug("REQUEST: %s\n", string(msg))
// Create new request object and unmarshal.
- req := &rpc.RPCRequest{}
+ req := &rpc_tendermint.RPCRequest{}
errU := json.Unmarshal(msg, req)
// Error when unmarshaling.
if errU != nil {
- this.writeError("Failed to parse request: "+errU.Error()+" . Raw: "+string(msg), "", rpc.PARSE_ERROR, session)
+ this.writeError("Failed to parse request: "+errU.Error()+" . Raw: "+string(msg), "", rpc_tendermint.PARSE_ERROR, session)
return
}
// Wrong protocol version.
if req.JSONRPC != "2.0" {
- this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id, rpc.INVALID_REQUEST, session)
+ this.writeError("Wrong protocol version: "+req.JSONRPC, req.Id, rpc_tendermint.INVALID_REQUEST, session)
return
}
@@ -64,13 +65,13 @@ func (this *ErisDbWsService) Process(msg []byte, session *server.WSSession) {
this.writeResponse(req.Id, resp, session)
}
} else {
- this.writeError("Method not found: "+mName, req.Id, rpc.METHOD_NOT_FOUND, session)
+ this.writeError("Method not found: "+mName, req.Id, rpc_tendermint.METHOD_NOT_FOUND, session)
}
}
// Convenience method for writing error responses.
func (this *ErisDbWsService) writeError(msg, id string, code int, session *server.WSSession) {
- response := rpc.NewRPCErrorResponse(id, code, msg)
+ response := rpc_tendermint.NewRPCErrorResponse(id, code, msg)
bts, err := this.codec.EncodeBytes(response)
// If there's an error here all bets are off.
if err != nil {
@@ -81,11 +82,11 @@ func (this *ErisDbWsService) writeError(msg, id string, code int, session *serve
// Convenience method for writing responses.
func (this *ErisDbWsService) writeResponse(id string, result interface{}, session *server.WSSession) error {
- response := rpc.NewRPCResponse(id, result)
+ response := rpc_tendermint.NewRPCResponse(id, result)
bts, err := this.codec.EncodeBytes(response)
log.Debug("RESPONSE: %v\n", response)
if err != nil {
- this.writeError("Internal error: "+err.Error(), id, rpc.INTERNAL_ERROR, session)
+ this.writeError("Internal error: "+err.Error(), id, rpc_tendermint.INTERNAL_ERROR, session)
return err
}
return session.Write(bts)
@@ -93,20 +94,20 @@ func (this *ErisDbWsService) writeResponse(id string, result interface{}, sessio
// *************************************** Events ************************************
-func (this *ErisDbWsService) EventSubscribe(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbWsService) EventSubscribe(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
session, ok := requester.(*server.WSSession)
if !ok {
- return 0, rpc.INTERNAL_ERROR, fmt.Errorf("Passing wrong object to websocket events")
+ return 0, rpc_tendermint.INTERNAL_ERROR, fmt.Errorf("Passing wrong object to websocket events")
}
param := &EventIdParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
eventId := param.EventId
- subId, errSID := generateSubId()
+ subId, errSID := event.GenerateSubId()
if errSID != nil {
- return nil, rpc.INTERNAL_ERROR, errSID
+ return nil, rpc_tendermint.INTERNAL_ERROR, errSID
}
callback := func(ret events.EventData) {
@@ -114,26 +115,26 @@ func (this *ErisDbWsService) EventSubscribe(request *rpc.RPCRequest, requester i
}
_, errC := this.pipe.Events().Subscribe(subId, eventId, callback)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
- return &core_types.EventSub{subId}, 0, nil
+ return &event.EventSub{subId}, 0, nil
}
-func (this *ErisDbWsService) EventUnsubscribe(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
+func (this *ErisDbWsService) EventUnsubscribe(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
param := &EventIdParam{}
err := this.codec.DecodeBytes(param, request.Params)
if err != nil {
- return nil, rpc.INVALID_PARAMS, err
+ return nil, rpc_tendermint.INVALID_PARAMS, err
}
eventId := param.EventId
result, errC := this.pipe.Events().Unsubscribe(eventId)
if errC != nil {
- return nil, rpc.INTERNAL_ERROR, errC
+ return nil, rpc_tendermint.INTERNAL_ERROR, errC
}
- return &core_types.EventUnsub{result}, 0, nil
+ return &event.EventUnsub{result}, 0, nil
}
-func (this *ErisDbWsService) EventPoll(request *rpc.RPCRequest, requester interface{}) (interface{}, int, error) {
- return nil, rpc.INTERNAL_ERROR, fmt.Errorf("Cannot poll with websockets")
+func (this *ErisDbWsService) EventPoll(request *rpc_tendermint.RPCRequest, requester interface{}) (interface{}, int, error) {
+ return nil, rpc_tendermint.INTERNAL_ERROR, fmt.Errorf("Cannot poll with websockets")
}
diff --git a/test/filters/filter_test.go b/test/filters/filter_test.go
index e1b0edbbed47866c4f87aaff238ec7a9407dd787..98404ca9ad4f6e233090bfdb60d2a5d2e68666ee 100644
--- a/test/filters/filter_test.go
+++ b/test/filters/filter_test.go
@@ -6,6 +6,7 @@ import (
"testing"
. "github.com/eris-ltd/eris-db/manager/eris-mint"
+ event "github.com/eris-ltd/eris-db/event"
"github.com/stretchr/testify/suite"
)
@@ -77,8 +78,8 @@ func (this *StringFilter) Match(v interface{}) bool {
// Test suite
type FilterSuite struct {
suite.Suite
- objects []FilterableObject
- filterFactory *FilterFactory
+ objects []event.FilterableObject
+ filterFactory *event.FilterFactory
}
func (this *FilterSuite) SetupSuite() {
diff --git a/test/mock/pipe.go b/test/mock/pipe.go
index b8e7e580aa65a30da299fd856adfa8cf33389f74..21e946fc7e835a2bfb0519c02e829d3db1d33c85 100644
--- a/test/mock/pipe.go
+++ b/test/mock/pipe.go
@@ -2,7 +2,9 @@ package mock
import (
"github.com/eris-ltd/eris-db/account"
- core_types "github.com/eris-ltd/eris-db/core/types"
+ 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"
td "github.com/eris-ltd/eris-db/test/testdata/testdata"
types "github.com/eris-ltd/eris-db/txs"
@@ -12,17 +14,17 @@ import (
// Base struct.
type MockPipe struct {
testData *td.TestData
- accounts core_types.Accounts
- blockchain core_types.Blockchain
- consensus core_types.Consensus
- events core_types.EventEmitter
- namereg core_types.NameReg
- net core_types.Net
- transactor core_types.Transactor
+ accounts definitions.Accounts
+ blockchain definitions.Blockchain
+ consensus definitions.Consensus
+ events event.EventEmitter
+ namereg definitions.NameReg
+ net definitions.Net
+ transactor definitions.Transactor
}
// Create a new mock tendermint pipe.
-func NewMockPipe(td *td.TestData) core_types.Pipe {
+func NewMockPipe(td *td.TestData) definitions.Pipe {
accounts := &accounts{td}
blockchain := &blockchain{td}
consensus := &consensus{td}
@@ -43,23 +45,23 @@ func NewMockPipe(td *td.TestData) core_types.Pipe {
}
// Create a mock pipe with default mock data.
-func NewDefaultMockPipe() core_types.Pipe {
+func NewDefaultMockPipe() definitions.Pipe {
return NewMockPipe(td.LoadTestData())
}
-func (this *MockPipe) Accounts() core_types.Accounts {
+func (this *MockPipe) Accounts() definitions.Accounts {
return this.accounts
}
-func (this *MockPipe) Blockchain() core_types.Blockchain {
+func (this *MockPipe) Blockchain() definitions.Blockchain {
return this.blockchain
}
-func (this *MockPipe) Consensus() core_types.Consensus {
+func (this *MockPipe) Consensus() definitions.Consensus {
return this.consensus
}
-func (this *MockPipe) Events() core_types.EventEmitter {
+func (this *MockPipe) Events() event.EventEmitter {
return this.events
}
@@ -90,7 +92,7 @@ func (this *accounts) GenPrivAccountFromKey(key []byte) (*account.PrivAccount, e
return this.testData.GenPrivAccount.Output, nil
}
-func (this *accounts) Accounts([]*core_types.FilterData) (*core_types.AccountList, error) {
+func (this *accounts) Accounts([]*event.FilterData) (*core_types.AccountList, error) {
return this.testData.GetAccounts.Output, nil
}
@@ -131,7 +133,7 @@ func (this *blockchain) LatestBlock() (*mintTypes.Block, error) {
return this.testData.GetLatestBlock.Output, nil
}
-func (this *blockchain) Blocks([]*core_types.FilterData) (*core_types.Blocks, error) {
+func (this *blockchain) Blocks([]*event.FilterData) (*core_types.Blocks, error) {
return this.testData.GetBlocks.Output, nil
}
@@ -174,7 +176,7 @@ func (this *namereg) Entry(key string) (*types.NameRegEntry, error) {
return this.testData.GetNameRegEntry.Output, nil
}
-func (this *namereg) Entries(filters []*core_types.FilterData) (*core_types.ResultListNames, error) {
+func (this *namereg) Entries(filters []*event.FilterData) (*core_types.ResultListNames, error) {
return this.testData.GetNameRegEntries.Output, nil
}
diff --git a/test/testdata/filters/testdata_filters.go b/test/testdata/filters/testdata_filters.go
index d65859861643d4992f7658d2d4ea64465e5873e1..fefc112eb2dc53dd94108d9e8db4cedeaca996e3 100644
--- a/test/testdata/filters/testdata_filters.go
+++ b/test/testdata/filters/testdata_filters.go
@@ -276,7 +276,7 @@ type (
}
GetAccountData struct {
- Input []*core_types.FilterData `json:"input"`
+ Input []*event.FilterData `json:"input"`
Output *core_types.AccountList `json:"output"`
}
diff --git a/test/testdata/testdata/testdata.go b/test/testdata/testdata/testdata.go
index 6abff9f784c63d82c632e6d6b814d0c9f5edd05e..29e906130850c2096e3cdc06341d7dab99661b30 100644
--- a/test/testdata/testdata/testdata.go
+++ b/test/testdata/testdata/testdata.go
@@ -626,12 +626,12 @@ type (
EventSubscribeData struct {
Input *core.EventIdParam `json:"input"`
- Output *core_types.EventSub `json:"output"`
+ Output *event.EventSub `json:"output"`
}
EventUnsubscribeData struct {
Input *core.SubIdParam `json:"input"`
- Output *core_types.EventUnsub `json:"output"`
+ Output *event.EventUnsub `json:"output"`
}
TransactNameRegData struct {
@@ -652,7 +652,7 @@ type (
/*
EventPollData struct {
Input *core.SubIdParam `json:"input"`
- Output *core_types.PollResponse `json:"output"`
+ Output *event.PollResponse `json:"output"`
}
*/