rpc: TMResult and TMEventData

rpc/core/events.go

@@ -4,6 +4,7 @@ import (
 	"github.com/tendermint/go-events"
 	"github.com/tendermint/go-rpc/types"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
+	"github.com/tendermint/tendermint/types"
 )
 
 func Subscribe(wsCtx rpctypes.WSRPCContext, event string) (*ctypes.ResultSubscribe, error) {
@@ -11,17 +12,14 @@ func Subscribe(wsCtx rpctypes.WSRPCContext, event string) (*ctypes.ResultSubscri
 	wsCtx.GetEventSwitch().AddListenerForEvent(wsCtx.GetRemoteAddr(), event, func(msg events.EventData) {
 		// NOTE: EventSwitch callbacks must be nonblocking
 		// NOTE: RPCResponses of subscribed events have id suffix "#event"
-		wsCtx.TryWriteRPCResponse(rpctypes.NewRPCResponse(wsCtx.Request.ID+"#event", &events.EventResult{event, msg}, ""))
+		tmResult := ctypes.TMResult(&ctypes.ResultEvent{event, types.TMEventData(msg)})
+		wsCtx.TryWriteRPCResponse(rpctypes.NewRPCResponse(wsCtx.Request.ID+"#event", &tmResult, ""))
 	})
 	return &ctypes.ResultSubscribe{}, nil
 }
 
 func Unsubscribe(wsCtx rpctypes.WSRPCContext, event string) (*ctypes.ResultUnsubscribe, error) {
 	log.Notice("Unsubscribe to event", "remote", wsCtx.GetRemoteAddr(), "event", event)
-	wsCtx.GetEventSwitch().AddListenerForEvent(wsCtx.GetRemoteAddr(), event, func(msg events.EventData) {
-		// NOTE: EventSwitch callbacks must be nonblocking
-		// NOTE: RPCResponses of subscribed events have id suffix "#event"
-		wsCtx.TryWriteRPCResponse(rpctypes.NewRPCResponse(wsCtx.Request.ID+"#event", &events.EventResult{event, msg}, ""))
-	})
+	wsCtx.GetEventSwitch().RemoveListener(event)
 	return &ctypes.ResultUnsubscribe{}, nil
 }

rpc/core/routes.go

@@ -22,90 +22,90 @@ var Routes = map[string]*rpc.RPCFunc{
 	// subscribe/unsubscribe are reserved for websocket events.
 }
 
-func SubscribeResult(wsCtx rpctypes.WSRPCContext, event string) (*ctypes.TendermintResult, error) {
+func SubscribeResult(wsCtx rpctypes.WSRPCContext, event string) (ctypes.TMResult, error) {
 	if r, err := Subscribe(wsCtx, event); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func UnsubscribeResult(wsCtx rpctypes.WSRPCContext, event string) (*ctypes.TendermintResult, error) {
+func UnsubscribeResult(wsCtx rpctypes.WSRPCContext, event string) (ctypes.TMResult, error) {
 	if r, err := Unsubscribe(wsCtx, event); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func StatusResult() (*ctypes.TendermintResult, error) {
+func StatusResult() (ctypes.TMResult, error) {
 	if r, err := Status(); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func NetInfoResult() (*ctypes.TendermintResult, error) {
+func NetInfoResult() (ctypes.TMResult, error) {
 	if r, err := NetInfo(); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func BlockchainInfoResult(min, max int) (*ctypes.TendermintResult, error) {
+func BlockchainInfoResult(min, max int) (ctypes.TMResult, error) {
 	if r, err := BlockchainInfo(min, max); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func GenesisResult() (*ctypes.TendermintResult, error) {
+func GenesisResult() (ctypes.TMResult, error) {
 	if r, err := Genesis(); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func GetBlockResult(height int) (*ctypes.TendermintResult, error) {
+func GetBlockResult(height int) (ctypes.TMResult, error) {
 	if r, err := GetBlock(height); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func ListValidatorsResult() (*ctypes.TendermintResult, error) {
+func ListValidatorsResult() (ctypes.TMResult, error) {
 	if r, err := ListValidators(); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func DumpConsensusStateResult() (*ctypes.TendermintResult, error) {
+func DumpConsensusStateResult() (ctypes.TMResult, error) {
 	if r, err := DumpConsensusState(); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func ListUnconfirmedTxsResult() (*ctypes.TendermintResult, error) {
+func ListUnconfirmedTxsResult() (ctypes.TMResult, error) {
 	if r, err := ListUnconfirmedTxs(); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }
 
-func BroadcastTxResult(tx []byte) (*ctypes.TendermintResult, error) {
+func BroadcastTxResult(tx []byte) (ctypes.TMResult, error) {
 	if r, err := BroadcastTx(tx); err != nil {
 		return nil, err
 	} else {
-		return &ctypes.TendermintResult{r}, nil
+		return r, nil
 	}
 }

rpc/core/types/responses.go

@@ -3,6 +3,7 @@ package core_types
 import (
 	"github.com/tendermint/go-crypto"
 	"github.com/tendermint/go-p2p"
+	"github.com/tendermint/go-rpc/types"
 	"github.com/tendermint/go-wire"
 	"github.com/tendermint/tendermint/types"
 )
@@ -66,6 +67,11 @@ type ResultSubscribe struct {
 type ResultUnsubscribe struct {
 }
 
+type ResultEvent struct {
+	Name string            `json:"name"`
+	Data types.TMEventData `json:"data"`
+}
+
 //----------------------------------------
 // response & result types
 
@@ -81,18 +87,16 @@ const (
 	ResultTypeListUnconfirmedTxs = byte(0x09)
 	ResultTypeSubscribe          = byte(0x0A)
 	ResultTypeUnsubscribe        = byte(0x0B)
+	ResultTypeEvent              = byte(0x0C)
 )
 
-type TendermintResultInterface interface{}
-
-// NOTE: up to the application to register this as rpctypes.Result
-type TendermintResult struct {
-	Result TendermintResultInterface
+type TMResult interface {
+	rpctypes.Result
 }
 
 // for wire.readReflect
 var _ = wire.RegisterInterface(
-	struct{ TendermintResultInterface }{},
+	struct{ TMResult }{},
 	wire.ConcreteType{&ResultGenesis{}, ResultTypeGenesis},
 	wire.ConcreteType{&ResultBlockchainInfo{}, ResultTypeBlockchainInfo},
 	wire.ConcreteType{&ResultGetBlock{}, ResultTypeGetBlock},
@@ -104,4 +108,5 @@ var _ = wire.RegisterInterface(
 	wire.ConcreteType{&ResultListUnconfirmedTxs{}, ResultTypeListUnconfirmedTxs},
 	wire.ConcreteType{&ResultSubscribe{}, ResultTypeSubscribe},
 	wire.ConcreteType{&ResultUnsubscribe{}, ResultTypeUnsubscribe},
+	wire.ConcreteType{&ResultEvent{}, ResultTypeEvent},
 )