115 lines
4.2 KiB
Go
115 lines
4.2 KiB
Go
package baseapp
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
gogogrpc "github.com/gogo/protobuf/grpc"
|
|
"github.com/gogo/protobuf/proto"
|
|
"google.golang.org/grpc"
|
|
|
|
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
|
|
)
|
|
|
|
// MsgServiceRouter routes fully-qualified Msg service methods to their handler.
|
|
type MsgServiceRouter struct {
|
|
interfaceRegistry codectypes.InterfaceRegistry
|
|
routes map[string]MsgServiceHandler
|
|
}
|
|
|
|
var _ gogogrpc.Server = &MsgServiceRouter{}
|
|
|
|
// NewMsgServiceRouter creates a new MsgServiceRouter.
|
|
func NewMsgServiceRouter() *MsgServiceRouter {
|
|
return &MsgServiceRouter{
|
|
routes: map[string]MsgServiceHandler{},
|
|
}
|
|
}
|
|
|
|
// MsgServiceHandler defines a function type which handles Msg service message.
|
|
type MsgServiceHandler = func(ctx sdk.Context, req sdk.MsgRequest) (*sdk.Result, error)
|
|
|
|
// Handler returns the MsgServiceHandler for a given query route path or nil
|
|
// if not found.
|
|
func (msr *MsgServiceRouter) Handler(methodName string) MsgServiceHandler {
|
|
return msr.routes[methodName]
|
|
}
|
|
|
|
// RegisterService implements the gRPC Server.RegisterService method. sd is a gRPC
|
|
// service description, handler is an object which implements that gRPC service.
|
|
//
|
|
// This function PANICs:
|
|
// - if it is called before the service `Msg`s have been registered using
|
|
// RegisterInterfaces,
|
|
// - or if a service is being registered twice.
|
|
func (msr *MsgServiceRouter) RegisterService(sd *grpc.ServiceDesc, handler interface{}) {
|
|
// Adds a top-level query handler based on the gRPC service name.
|
|
for _, method := range sd.Methods {
|
|
fqMethod := fmt.Sprintf("/%s/%s", sd.ServiceName, method.MethodName)
|
|
methodHandler := method.Handler
|
|
|
|
// Check that the service Msg fully-qualified method name has already
|
|
// been registered (via RegisterInterfaces). If the user registers a
|
|
// service without registering according service Msg type, there might be
|
|
// some unexpected behavior down the road. Since we can't return an error
|
|
// (`Server.RegisterService` interface restriction) we panic (at startup).
|
|
serviceMsg, err := msr.interfaceRegistry.Resolve(fqMethod)
|
|
if err != nil || serviceMsg == nil {
|
|
panic(
|
|
fmt.Errorf(
|
|
"type_url %s has not been registered yet. "+
|
|
"Before calling RegisterService, you must register all interfaces by calling the `RegisterInterfaces` "+
|
|
"method on module.BasicManager. Each module should call `msgservice.RegisterMsgServiceDesc` inside its "+
|
|
"`RegisterInterfaces` method with the `_Msg_serviceDesc` generated by proto-gen",
|
|
fqMethod,
|
|
),
|
|
)
|
|
}
|
|
|
|
// Check that each service is only registered once. If a service is
|
|
// registered more than once, then we should error. Since we can't
|
|
// return an error (`Server.RegisterService` interface restriction) we
|
|
// panic (at startup).
|
|
_, found := msr.routes[fqMethod]
|
|
if found {
|
|
panic(
|
|
fmt.Errorf(
|
|
"msg service %s has already been registered. Please make sure to only register each service once. "+
|
|
"This usually means that there are conflicting modules registering the same msg service",
|
|
fqMethod,
|
|
),
|
|
)
|
|
}
|
|
|
|
msr.routes[fqMethod] = func(ctx sdk.Context, req sdk.MsgRequest) (*sdk.Result, error) {
|
|
ctx = ctx.WithEventManager(sdk.NewEventManager())
|
|
interceptor := func(goCtx context.Context, _ interface{}, _ *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
|
|
goCtx = context.WithValue(goCtx, sdk.SdkContextKey, ctx)
|
|
return handler(goCtx, req)
|
|
}
|
|
// Call the method handler from the service description with the handler object.
|
|
// We don't do any decoding here because the decoding was already done.
|
|
res, err := methodHandler(handler, sdk.WrapSDKContext(ctx), noopDecoder, interceptor)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
resMsg, ok := res.(proto.Message)
|
|
if !ok {
|
|
return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "Expecting proto.Message, got %T", resMsg)
|
|
}
|
|
|
|
return sdk.WrapServiceResult(ctx, resMsg, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// SetInterfaceRegistry sets the interface registry for the router.
|
|
func (msr *MsgServiceRouter) SetInterfaceRegistry(interfaceRegistry codectypes.InterfaceRegistry) {
|
|
msr.interfaceRegistry = interfaceRegistry
|
|
}
|
|
|
|
func noopDecoder(_ interface{}) error { return nil }
|