add CanInvoke

Author: julienrbrt

core/appmodule/v2/environment.go

@@ -18,7 +18,7 @@ type Environment struct {
 	EventService  event.Service
 	GasService    gas.Service
 	HeaderService header.Service
-	RouterService router.Router
+	RouterService router.Service
 
 	KVStoreService  store.KVStoreService
 	MemStoreService store.MemoryStoreService

core/router/service.go

@@ -6,15 +6,17 @@ import (
 	"google.golang.org/protobuf/runtime/protoiface"
 )
 
-// Router embeds a QueryRouterService and MessageRouterService.
-// Each service allows to invoke messages and queries via the corresponding router.
-type Router interface {
-	QueryRouterService() Service
-	MessageRouterService() Service
+// Service embeds a QueryRouterService and MessageRouterService.
+// Each router allows to invoke messages and queries via the corresponding router.
+type Service interface {
+	QueryRouterService() Router
+	MessageRouterService() Router
 }
 
-// Service is the interface that wraps the basic methods for a router service.
-type Service interface {
+// Router is the interface that wraps the basic methods for a router.
+type Router interface {
+	// CanInvoke returns an error if the given request cannot be invoked.
+	CanInvoke(ctx context.Context, req protoiface.MessageV1) error
 	// InvokeTyped execute a message or query. It should be used when the called knows the type of the response.
 	InvokeTyped(ctx context.Context, req, res protoiface.MessageV1) error
 	// InvokeUntyped execute a message or query. It should be used when the called doesn't know the type of the response.

runtime/router.go

@@ -16,7 +16,7 @@ import (
 )
 
 // NewRouterService creates a router.Service which allows to invoke messages and queries using the msg router.
-func NewRouterService(storeService store.KVStoreService, queryRouter *baseapp.GRPCQueryRouter, msgRouter baseapp.MessageRouter) router.Router {
+func NewRouterService(storeService store.KVStoreService, queryRouter *baseapp.GRPCQueryRouter, msgRouter baseapp.MessageRouter) router.Service {
 	return &routerService{
 		queryRouterService: &queryRouterService{
 			storeService: storeService, // TODO: this will be used later on as authenticating modules before routing
@@ -29,36 +29,46 @@ func NewRouterService(storeService store.KVStoreService, queryRouter *baseapp.GR
 	}
 }
 
-var _ router.Router = (*routerService)(nil)
+var _ router.Service = (*routerService)(nil)
 
 type routerService struct {
-	queryRouterService router.Service
-	msgRouterService   router.Service
+	queryRouterService router.Router
+	msgRouterService   router.Router
 }
 
-// MessageRouterService implements router.Router.
-func (r *routerService) MessageRouterService() router.Service {
+// MessageRouterService implements router.Service.
+func (r *routerService) MessageRouterService() router.Router {
 	return r.msgRouterService
 }
 
-// QueryRouterService implements router.Router.
-func (r *routerService) QueryRouterService() router.Service {
+// QueryRouterService implements router.Service.
+func (r *routerService) QueryRouterService() router.Router {
 	return r.queryRouterService
 }
 
-var _ router.Service = (*msgRouterService)(nil)
+var _ router.Router = (*msgRouterService)(nil)
 
 type msgRouterService struct {
 	storeService store.KVStoreService
 	router       baseapp.MessageRouter
 }
 
+// CanInvoke returns an error if the given message cannot be invoked.
+func (m *msgRouterService) CanInvoke(ctx context.Context, msg protoiface.MessageV1) error {
+	messageName := msgTypeURL(msg)
+	handler := m.router.HybridHandlerByMsgName(messageName)
+	if handler == nil {
+		return fmt.Errorf("unknown message: %s", messageName)
+	}
+
+	return nil
+}
+
 // InvokeTyped execute a message and fill-in a response.
 // The response must be known and passed as a parameter.
 // Use InvokeUntyped if the response type is not known.
 func (m *msgRouterService) InvokeTyped(ctx context.Context, msg, resp protoiface.MessageV1) error {
 	messageName := msgTypeURL(msg)
-
 	handler := m.router.HybridHandlerByMsgName(messageName)
 	if handler == nil {
 		return fmt.Errorf("unknown message: %s", messageName)
@@ -88,32 +98,47 @@ func (m *msgRouterService) InvokeUntyped(ctx context.Context, msg protoiface.Mes
 	return msgResp, m.InvokeTyped(ctx, msg, msgResp)
 }
 
-var _ router.Service = (*queryRouterService)(nil)
+var _ router.Router = (*queryRouterService)(nil)
 
 type queryRouterService struct {
 	storeService store.KVStoreService
 	router       *baseapp.GRPCQueryRouter
 }
 
+// CanInvoke returns an error if the given request cannot be invoked.
+func (m *queryRouterService) CanInvoke(ctx context.Context, req protoiface.MessageV1) error {
+	reqName := msgTypeURL(req)
+	handlers := m.router.HybridHandlerByRequestName(reqName)
+	if len(handlers) == 0 {
+		return fmt.Errorf("unknown request: %s", reqName)
+	} else if len(handlers) > 1 {
+		return fmt.Errorf("ambiguous request, query have multiple handlers: %s", reqName)
+	}
+
+	return nil
+}
+
 // InvokeTyped execute a message and fill-in a response.
 // The response must be known and passed as a parameter.
 // Use InvokeUntyped if the response type is not known.
 func (m *queryRouterService) InvokeTyped(ctx context.Context, req, resp protoiface.MessageV1) error {
-	messageName := msgTypeURL(req)
-	handlers := m.router.HybridHandlerByRequestName(messageName)
+	reqName := msgTypeURL(req)
+	handlers := m.router.HybridHandlerByRequestName(reqName)
 	if len(handlers) == 0 {
-		return fmt.Errorf("unknown request: %s", messageName)
+		return fmt.Errorf("unknown request: %s", reqName)
+	} else if len(handlers) > 1 {
+		return fmt.Errorf("ambiguous request, query have multiple handlers: %s", reqName)
 	}
 
 	return handlers[0](ctx, req, resp)
 }
 
 // InvokeUntyped execute a message and returns a response.
 func (m *queryRouterService) InvokeUntyped(ctx context.Context, req protoiface.MessageV1) (protoiface.MessageV1, error) {
-	messageName := msgTypeURL(req)
-	respName := m.router.ResponseNameByRequestName(messageName)
+	reqName := msgTypeURL(req)
+	respName := m.router.ResponseNameByRequestName(reqName)
 	if respName == "" {
-		return nil, fmt.Errorf("could not find response type for request %s (%T)", messageName, req)
+		return nil, fmt.Errorf("could not find response type for request %s (%T)", reqName, req)
 	}
 
 	// get response type