Jae Kwon
9 years ago
27 changed files with 982 additions and 214 deletions
Split View
Diff Options
-
+6 -0account/account.go
-
+2 -2blockchain/reactor.go
-
+5 -4common/word.go
-
+3 -2consensus/reactor.go
-
+37 -16consensus/state.go
-
+41 -0events/event_cache.go
-
+6 -1events/events.go
-
+2 -2mempool/mempool.go
-
+2 -2mempool/reactor.go
-
+7 -3node/node.go
-
+2 -2p2p/pex_reactor.go
-
+0 -4rpc/core/routes.go
-
+2 -2rpc/core/txs.go
-
+124 -87rpc/handlers.go
-
+17 -0rpc/http_server.go
-
+302 -0rpc/test/client_ws_test.go
-
+66 -5rpc/test/helpers_test.go
-
+36 -54rpc/test/tests_test.go
-
+136 -0rpc/test/ws_helpers_test.go
-
+6 -6state/block_cache.go
-
+39 -4state/execution.go
-
+10 -0state/state.go
-
+1 -1state/state_test.go
-
+10 -6state/tx_cache.go
-
+84 -0types/events.go
-
+2 -2vm/test/vm_test.go
-
+34 -9vm/vm.go
+ 6
- 0
account/account.go
View File
+ 2
- 2
blockchain/reactor.go
View File
+ 5
- 4
common/word.go
View File
+ 3
- 2
consensus/reactor.go
View File
+ 37
- 16
consensus/state.go
View File
+ 41
- 0
events/event_cache.go
View File
| @ -0,0 +1,41 @@ | |||
| package events | |||
| const ( | |||
| eventsBufferSize = 1000 | |||
| ) | |||
| // An EventCache buffers events for a Fireable | |||
| // All events are cached. Filtering happens on Flush | |||
| type EventCache struct { | |||
| evsw Fireable | |||
| events []eventInfo | |||
| } | |||
| // Create a new EventCache with an EventSwitch as backend | |||
| func NewEventCache(evsw Fireable) *EventCache { | |||
| return &EventCache{ | |||
| evsw: evsw, | |||
| events: make([]eventInfo, eventsBufferSize), | |||
| } | |||
| } | |||
| // a cached event | |||
| type eventInfo struct { | |||
| event string | |||
| msg interface{} | |||
| } | |||
| // Cache an event to be fired upon finality. | |||
| func (evc *EventCache) FireEvent(event string, msg interface{}) { | |||
| // append to list | |||
| evc.events = append(evc.events, eventInfo{event, msg}) | |||
| } | |||
| // Fire events by running evsw.FireEvent on all cached events. Blocks. | |||
| // Clears cached events | |||
| func (evc *EventCache) Flush() { | |||
| for _, ei := range evc.events { | |||
| evc.evsw.FireEvent(ei.event, ei.msg) | |||
| } | |||
| evc.events = make([]eventInfo, eventsBufferSize) | |||
| } | |||
+ 6
- 1
events/events.go
View File
+ 2
- 2
mempool/mempool.go
View File
+ 2
- 2
mempool/reactor.go
View File
+ 7
- 3
node/node.go
View File
+ 2
- 2
p2p/pex_reactor.go
View File
+ 0
- 4
rpc/core/routes.go
View File
+ 2
- 2
rpc/core/txs.go
View File
+ 124
- 87
rpc/handlers.go
View File
+ 17
- 0
rpc/http_server.go
View File
+ 302
- 0
rpc/test/client_ws_test.go
View File
| @ -0,0 +1,302 @@ | |||
| package rpc | |||
| import ( | |||
| "encoding/json" | |||
| "fmt" | |||
| "github.com/gorilla/websocket" | |||
| "github.com/tendermint/tendermint/account" | |||
| "github.com/tendermint/tendermint/binary" | |||
| "github.com/tendermint/tendermint/rpc" | |||
| "github.com/tendermint/tendermint/types" | |||
| "net/http" | |||
| "testing" | |||
| "time" | |||
| ) | |||
| //-------------------------------------------------------------------------------- | |||
| // Utilities for testing the websocket service | |||
| // create a new connection | |||
| func newWSCon(t *testing.T) *websocket.Conn { | |||
| dialer := websocket.DefaultDialer | |||
| rHeader := http.Header{} | |||
| con, r, err := dialer.Dial(websocketAddr, rHeader) | |||
| fmt.Println("response", r) | |||
| if err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| return con | |||
| } | |||
| // subscribe to an event | |||
| func subscribe(t *testing.T, con *websocket.Conn, eventid string) { | |||
| err := con.WriteJSON(rpc.WSRequest{ | |||
| Type: "subscribe", | |||
| Event: eventid, | |||
| }) | |||
| if err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| } | |||
| // unsubscribe from an event | |||
| func unsubscribe(t *testing.T, con *websocket.Conn, eventid string) { | |||
| err := con.WriteJSON(rpc.WSRequest{ | |||
| Type: "unsubscribe", | |||
| Event: eventid, | |||
| }) | |||
| if err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| } | |||
| // wait for an event; do things that might trigger events, and check them when they are received | |||
| func waitForEvent(t *testing.T, con *websocket.Conn, eventid string, dieOnTimeout bool, f func(), check func(string, []byte) error) { | |||
| // go routine to wait for webscoket msg | |||
| gch := make(chan []byte) // good channel | |||
| ech := make(chan error) // error channel | |||
| go func() { | |||
| for { | |||
| _, p, err := con.ReadMessage() | |||
| if err != nil { | |||
| ech <- err | |||
| break | |||
| } else { | |||
| // if the event id isnt what we're waiting on | |||
| // ignore it | |||
| var response struct { | |||
| Event string | |||
| } | |||
| if err := json.Unmarshal(p, &response); err != nil { | |||
| ech <- err | |||
| break | |||
| } | |||
| if response.Event == eventid { | |||
| gch <- p | |||
| break | |||
| } | |||
| } | |||
| } | |||
| }() | |||
| // do stuff (transactions) | |||
| f() | |||
| // wait for an event or 10 seconds | |||
| ticker := time.Tick(10 * time.Second) | |||
| select { | |||
| case <-ticker: | |||
| if dieOnTimeout { | |||
| con.Close() | |||
| t.Fatalf("%s event was not received in time", eventid) | |||
| } | |||
| // else that's great, we didn't hear the event | |||
| // and we shouldn't have | |||
| case p := <-gch: | |||
| if dieOnTimeout { | |||
| // message was received and expected | |||
| // run the check | |||
| err := check(eventid, p) | |||
| if err != nil { | |||
| t.Fatal(err) | |||
| } | |||
| } else { | |||
| con.Close() | |||
| t.Fatalf("%s event was not expected", eventid) | |||
| } | |||
| case err := <-ech: | |||
| t.Fatal(err) | |||
| } | |||
| } | |||
| func unmarshalResponseNewBlock(b []byte) (*types.Block, error) { | |||
| // unmarshall and assert somethings | |||
| var response struct { | |||
| Event string | |||
| Data *types.Block | |||
| Error string | |||
| } | |||
| var err error | |||
| binary.ReadJSON(&response, b, &err) | |||
| if err != nil { | |||
| return nil, err | |||
| } | |||
| if response.Error != "" { | |||
| return nil, fmt.Errorf(response.Error) | |||
| } | |||
| block := response.Data | |||
| return block, nil | |||
| } | |||
| //-------------------------------------------------------------------------------- | |||
| // Test the websocket service | |||
| // make a simple connection to the server | |||
| func TestWSConnect(t *testing.T) { | |||
| con := newWSCon(t) | |||
| con.Close() | |||
| } | |||
| // receive a new block message | |||
| func _TestWSNewBlock(t *testing.T) { | |||
| con := newWSCon(t) | |||
| eid := types.EventStringNewBlock() | |||
| subscribe(t, con, eid) | |||
| defer func() { | |||
| unsubscribe(t, con, eid) | |||
| con.Close() | |||
| }() | |||
| waitForEvent(t, con, eid, true, func() {}, func(eid string, b []byte) error { | |||
| fmt.Println("Check:", string(b)) | |||
| return nil | |||
| }) | |||
| } | |||
| // receive a few new block messages in a row, with increasing height | |||
| func TestWSBlockchainGrowth(t *testing.T) { | |||
| con := newWSCon(t) | |||
| eid := types.EventStringNewBlock() | |||
| subscribe(t, con, eid) | |||
| defer func() { | |||
| unsubscribe(t, con, eid) | |||
| con.Close() | |||
| }() | |||
| // listen for NewBlock, ensure height increases by 1 | |||
| unmarshalValidateBlockchain(t, con, eid) | |||
| } | |||
| // send a transaction and validate the events from listening for both sender and receiver | |||
| func TestWSSend(t *testing.T) { | |||
| toAddr := []byte{20, 143, 25, 63, 16, 177, 83, 29, 91, 91, 54, 23, 233, 46, 190, 121, 122, 34, 86, 54} | |||
| amt := uint64(100) | |||
| con := newWSCon(t) | |||
| eidInput := types.EventStringAccInput(userByteAddr) | |||
| eidOutput := types.EventStringAccOutput(toAddr) | |||
| subscribe(t, con, eidInput) | |||
| subscribe(t, con, eidOutput) | |||
| defer func() { | |||
| unsubscribe(t, con, eidInput) | |||
| unsubscribe(t, con, eidOutput) | |||
| con.Close() | |||
| }() | |||
| waitForEvent(t, con, eidInput, true, func() { | |||
| broadcastTx(t, "JSONRPC", userByteAddr, toAddr, nil, userBytePriv, amt, 0, 0) | |||
| }, unmarshalValidateSend(amt, toAddr)) | |||
| waitForEvent(t, con, eidOutput, true, func() {}, unmarshalValidateSend(amt, toAddr)) | |||
| } | |||
| // ensure events are only fired once for a given transaction | |||
| func TestWSDoubleFire(t *testing.T) { | |||
| con := newWSCon(t) | |||
| eid := types.EventStringAccInput(userByteAddr) | |||
| subscribe(t, con, eid) | |||
| defer func() { | |||
| unsubscribe(t, con, eid) | |||
| con.Close() | |||
| }() | |||
| amt := uint64(100) | |||
| toAddr := []byte{20, 143, 25, 63, 16, 177, 83, 29, 91, 91, 54, 23, 233, 46, 190, 121, 122, 34, 86, 54} | |||
| // broadcast the transaction, wait to hear about it | |||
| waitForEvent(t, con, eid, true, func() { | |||
| broadcastTx(t, "JSONRPC", userByteAddr, toAddr, nil, userBytePriv, amt, 0, 0) | |||
| }, func(eid string, b []byte) error { | |||
| return nil | |||
| }) | |||
| // but make sure we don't hear about it twice | |||
| waitForEvent(t, con, eid, false, func() { | |||
| }, func(eid string, b []byte) error { | |||
| return nil | |||
| }) | |||
| } | |||
| // create a contract, wait for the event, and send it a msg, validate the return | |||
| func TestWSCallWait(t *testing.T) { | |||
| con := newWSCon(t) | |||
| eid1 := types.EventStringAccInput(userByteAddr) | |||
| subscribe(t, con, eid1) | |||
| defer func() { | |||
| unsubscribe(t, con, eid1) | |||
| con.Close() | |||
| }() | |||
| amt := uint64(10000) | |||
| code, returnCode, returnVal := simpleContract() | |||
| var contractAddr []byte | |||
| // wait for the contract to be created | |||
| waitForEvent(t, con, eid1, true, func() { | |||
| _, receipt := broadcastTx(t, "JSONRPC", userByteAddr, nil, code, userBytePriv, amt, 1000, 1000) | |||
| contractAddr = receipt.ContractAddr | |||
| }, unmarshalValidateCall(amt, returnCode)) | |||
| // susbscribe to the new contract | |||
| amt = uint64(10001) | |||
| eid2 := types.EventStringAccReceive(contractAddr) | |||
| subscribe(t, con, eid2) | |||
| defer func() { | |||
| unsubscribe(t, con, eid2) | |||
| }() | |||
| // get the return value from a call | |||
| data := []byte{0x1} // just needs to be non empty for this to be a CallTx | |||
| waitForEvent(t, con, eid2, true, func() { | |||
| broadcastTx(t, "JSONRPC", userByteAddr, contractAddr, data, userBytePriv, amt, 1000, 1000) | |||
| }, unmarshalValidateCall(amt, returnVal)) | |||
| } | |||
| // create a contract and send it a msg without waiting. wait for contract event | |||
| // and validate return | |||
| func TestWSCallNoWait(t *testing.T) { | |||
| con := newWSCon(t) | |||
| amt := uint64(10000) | |||
| code, _, returnVal := simpleContract() | |||
| _, receipt := broadcastTx(t, "JSONRPC", userByteAddr, nil, code, userBytePriv, amt, 1000, 1000) | |||
| contractAddr := receipt.ContractAddr | |||
| // susbscribe to the new contract | |||
| amt = uint64(10001) | |||
| eid := types.EventStringAccReceive(contractAddr) | |||
| subscribe(t, con, eid) | |||
| defer func() { | |||
| unsubscribe(t, con, eid) | |||
| con.Close() | |||
| }() | |||
| // get the return value from a call | |||
| data := []byte{0x1} // just needs to be non empty for this to be a CallTx | |||
| waitForEvent(t, con, eid, true, func() { | |||
| broadcastTx(t, "JSONRPC", userByteAddr, contractAddr, data, userBytePriv, amt, 1000, 1000) | |||
| }, unmarshalValidateCall(amt, returnVal)) | |||
| } | |||
| // create two contracts, one of which calls the other | |||
| func TestWSCallCall(t *testing.T) { | |||
| con := newWSCon(t) | |||
| amt := uint64(10000) | |||
| code, _, returnVal := simpleContract() | |||
| txid := new([]byte) | |||
| // deploy the two contracts | |||
| _, receipt := broadcastTx(t, "JSONRPC", userByteAddr, nil, code, userBytePriv, amt, 1000, 1000) | |||
| contractAddr1 := receipt.ContractAddr | |||
| code, _, _ = simpleCallContract(contractAddr1) | |||
| _, receipt = broadcastTx(t, "JSONRPC", userByteAddr, nil, code, userBytePriv, amt, 1000, 1000) | |||
| contractAddr2 := receipt.ContractAddr | |||
| // susbscribe to the new contracts | |||
| amt = uint64(10001) | |||
| eid1 := types.EventStringAccReceive(contractAddr1) | |||
| eid2 := types.EventStringAccReceive(contractAddr2) | |||
| subscribe(t, con, eid1) | |||
| subscribe(t, con, eid2) | |||
| defer func() { | |||
| unsubscribe(t, con, eid1) | |||
| unsubscribe(t, con, eid2) | |||
| con.Close() | |||
| }() | |||
| // call contract2, which should call contract1, and wait for ev1 | |||
| data := []byte{0x1} // just needs to be non empty for this to be a CallTx | |||
| waitForEvent(t, con, eid1, true, func() { | |||
| tx, _ := broadcastTx(t, "JSONRPC", userByteAddr, contractAddr2, data, userBytePriv, amt, 1000, 1000) | |||
| *txid = account.HashSignBytes(tx) | |||
| }, unmarshalValidateCallCall(userByteAddr, returnVal, txid)) | |||
| } | |||
rpc/test/helpers.go → rpc/test/helpers_test.go
View File
rpc/test/tests.go → rpc/test/tests_test.go
View File
+ 136
- 0
rpc/test/ws_helpers_test.go
View File
| @ -0,0 +1,136 @@ | |||
| package rpc | |||
| import ( | |||
| "bytes" | |||
| "fmt" | |||
| "github.com/gorilla/websocket" | |||
| "github.com/tendermint/tendermint/binary" | |||
| "github.com/tendermint/tendermint/types" | |||
| "testing" | |||
| ) | |||
| func unmarshalValidateBlockchain(t *testing.T, con *websocket.Conn, eid string) { | |||
| var initBlockN uint | |||
| for i := 0; i < 2; i++ { | |||
| waitForEvent(t, con, eid, true, func() {}, func(eid string, b []byte) error { | |||
| block, err := unmarshalResponseNewBlock(b) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| if i == 0 { | |||
| initBlockN = block.Header.Height | |||
| } else { | |||
| if block.Header.Height != initBlockN+uint(i) { | |||
| return fmt.Errorf("Expected block %d, got block %d", i, block.Header.Height) | |||
| } | |||
| } | |||
| return nil | |||
| }) | |||
| } | |||
| } | |||
| func unmarshalValidateSend(amt uint64, toAddr []byte) func(string, []byte) error { | |||
| return func(eid string, b []byte) error { | |||
| // unmarshal and assert correctness | |||
| var response struct { | |||
| Event string | |||
| Data types.SendTx | |||
| Error string | |||
| } | |||
| var err error | |||
| binary.ReadJSON(&response, b, &err) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| if response.Error != "" { | |||
| return fmt.Errorf(response.Error) | |||
| } | |||
| if eid != response.Event { | |||
| return fmt.Errorf("Eventid is not correct. Got %s, expected %s", response.Event, eid) | |||
| } | |||
| tx := response.Data | |||
| if bytes.Compare(tx.Inputs[0].Address, userByteAddr) != 0 { | |||
| return fmt.Errorf("Senders do not match up! Got %x, expected %x", tx.Inputs[0].Address, userByteAddr) | |||
| } | |||
| if tx.Inputs[0].Amount != amt { | |||
| return fmt.Errorf("Amt does not match up! Got %d, expected %d", tx.Inputs[0].Amount, amt) | |||
| } | |||
| if bytes.Compare(tx.Outputs[0].Address, toAddr) != 0 { | |||
| return fmt.Errorf("Receivers do not match up! Got %x, expected %x", tx.Outputs[0].Address, userByteAddr) | |||
| } | |||
| return nil | |||
| } | |||
| } | |||
| func unmarshalValidateCall(amt uint64, returnCode []byte) func(string, []byte) error { | |||
| return func(eid string, b []byte) error { | |||
| // unmarshall and assert somethings | |||
| var response struct { | |||
| Event string | |||
| Data struct { | |||
| Tx types.CallTx | |||
| Return []byte | |||
| Exception string | |||
| } | |||
| Error string | |||
| } | |||
| var err error | |||
| binary.ReadJSON(&response, b, &err) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| if response.Error != "" { | |||
| return fmt.Errorf(response.Error) | |||
| } | |||
| if response.Data.Exception != "" { | |||
| return fmt.Errorf(response.Data.Exception) | |||
| } | |||
| tx := response.Data.Tx | |||
| if bytes.Compare(tx.Input.Address, userByteAddr) != 0 { | |||
| return fmt.Errorf("Senders do not match up! Got %x, expected %x", tx.Input.Address, userByteAddr) | |||
| } | |||
| if tx.Input.Amount != amt { | |||
| return fmt.Errorf("Amt does not match up! Got %d, expected %d", tx.Input.Amount, amt) | |||
| } | |||
| ret := response.Data.Return | |||
| if bytes.Compare(ret, returnCode) != 0 { | |||
| return fmt.Errorf("Call did not return correctly. Got %x, expected %x", ret, returnCode) | |||
| } | |||
| return nil | |||
| } | |||
| } | |||
| func unmarshalValidateCallCall(origin, returnCode []byte, txid *[]byte) func(string, []byte) error { | |||
| return func(eid string, b []byte) error { | |||
| // unmarshall and assert somethings | |||
| var response struct { | |||
| Event string | |||
| Data types.EventMsgCall | |||
| Error string | |||
| } | |||
| var err error | |||
| binary.ReadJSON(&response, b, &err) | |||
| if err != nil { | |||
| return err | |||
| } | |||
| if response.Error != "" { | |||
| return fmt.Errorf(response.Error) | |||
| } | |||
| if response.Data.Exception != "" { | |||
| return fmt.Errorf(response.Data.Exception) | |||
| } | |||
| if bytes.Compare(response.Data.Origin, origin) != 0 { | |||
| return fmt.Errorf("Origin does not match up! Got %x, expected %x", response.Data.Origin, origin) | |||
| } | |||
| ret := response.Data.Return | |||
| if bytes.Compare(ret, returnCode) != 0 { | |||
| return fmt.Errorf("Call did not return correctly. Got %x, expected %x", ret, returnCode) | |||
| } | |||
| if bytes.Compare(response.Data.TxId, *txid) != 0 { | |||
| return fmt.Errorf("TxIds do not match up! Got %x, expected %x", response.Data.TxId, *txid) | |||
| } | |||
| // calldata := response.Data.CallData | |||
| return nil | |||
| } | |||
| } | |||
+ 6
- 6
state/block_cache.go
View File
+ 39
- 4
state/execution.go
View File
+ 10
- 0
state/state.go
View File
+ 1
- 1
state/state_test.go
View File
+ 10
- 6
state/tx_cache.go
View File
+ 84
- 0
types/events.go
View File
| @ -0,0 +1,84 @@ | |||
| package types | |||
| import ( | |||
| "fmt" | |||
| ) | |||
| // Functions to generate eventId strings | |||
| func EventStringAccInput(addr []byte) string { | |||
| return fmt.Sprintf("Acc/%x/Input", addr) | |||
| } | |||
| func EventStringAccOutput(addr []byte) string { | |||
| return fmt.Sprintf("Acc/%x/Output", addr) | |||
| } | |||
| func EventStringAccReceive(addr []byte) string { | |||
| return fmt.Sprintf("Acc/%x/Receive", addr) | |||
| } | |||
| func EventStringBond() string { | |||
| return "Bond" | |||
| } | |||
| func EventStringUnbond() string { | |||
| return "Unbond" | |||
| } | |||
| func EventStringRebond() string { | |||
| return "Rebond" | |||
| } | |||
| func EventStringDupeout() string { | |||
| return "Dupeout" | |||
| } | |||
| func EventStringNewBlock() string { | |||
| return "NewBlock" | |||
| } | |||
| func EventStringFork() string { | |||
| return "Fork" | |||
| } | |||
| // Most event messages are basic types (a block, a transaction) | |||
| // but some (an input to a call tx or a receive) are more exotic: | |||
| type EventMsgCallTx struct { | |||
| Tx Tx | |||
| Return []byte | |||
| Exception string | |||
| } | |||
| type CallData struct { | |||
| Caller []byte | |||
| Callee []byte | |||
| Data []byte | |||
| Value uint64 | |||
| Gas uint64 | |||
| } | |||
| type EventMsgCall struct { | |||
| CallData *CallData | |||
| Origin []byte | |||
| TxId []byte | |||
| Return []byte | |||
| Exception string | |||
| } | |||
| /* | |||
| Acc/XYZ/Input -> full tx or {full tx, return value, exception} | |||
| Acc/XYZ/Output -> full tx | |||
| Acc/XYZ/Receive -> full tx, return value, exception, (optionally?) calldata | |||
| Bond -> full tx | |||
| Unbond -> full tx | |||
| Rebond -> full tx | |||
| Dupeout -> full tx | |||
| NewBlock -> full block | |||
| Fork -> block A, block B | |||
| Log -> Fuck this | |||
| NewPeer -> peer | |||
| Alert -> alert msg | |||
| */ | |||