package validation import ( "context" "google.golang.org/genproto/googleapis/rpc/errdetails" "google.golang.org/grpc" "google.golang.org/protobuf/proto" "go.linka.cloud/grpc/errors" "go.linka.cloud/grpc/interceptors" ) type validatorAll interface { Validate() error ValidateAll() error } // The validate interface starting with protoc-gen-validate v0.6.0. // See https://github.com/envoyproxy/protoc-gen-validate/pull/455. type validator interface { Validate(all bool) error } // The validate interface prior to protoc-gen-validate v0.6.0. type validatorLegacy interface { Validate() error } type validatorMultiError interface { AllErrors() []error } type validatorError interface { Field() string Reason() string Key() bool Cause() error ErrorName() string } func validatorErrorToGrpc(e validatorError) *errdetails.BadRequest_FieldViolation { return &errdetails.BadRequest_FieldViolation{ Field: e.Field(), Description: e.Reason(), } } func errToStatus(err error) error { if err == nil { return nil } switch v := err.(type) { case validatorError: return errors.InvalidArgumentd(err, validatorErrorToGrpc(v)) case validatorMultiError: var details []proto.Message for _, v := range v.AllErrors() { if d, ok := v.(validatorError); ok { details = append(details, validatorErrorToGrpc(d)) } } return errors.InvalidArgumentd(err, details...) default: return errors.InvalidArgument(err) } } func (i interceptor) validate(req interface{}) error { switch v := req.(type) { case validatorAll: if i.all { return errToStatus(v.ValidateAll()) } return errToStatus(v.Validate()) case validatorLegacy: return errToStatus(v.Validate()) case validator: return errToStatus(v.Validate(i.all)) } return nil } type interceptor struct { all bool } func NewInterceptors(validateAll bool) interceptors.Interceptors { return &interceptor{all: validateAll} } // UnaryServerInterceptor returns a new unary server interceptor that validates incoming messages. // // Invalid messages will be rejected with `InvalidArgument` before reaching any userspace handlers. func (i interceptor) UnaryServerInterceptor() grpc.UnaryServerInterceptor { return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) { if err := i.validate(req); err != nil { return nil, err } return handler(ctx, req) } } // UnaryClientInterceptor returns a new unary client interceptor that validates outgoing messages. // // Invalid messages will be rejected with `InvalidArgument` before sending the request to server. func (i interceptor) UnaryClientInterceptor() grpc.UnaryClientInterceptor { return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error { if err := i.validate(req); err != nil { return err } return invoker(ctx, method, req, reply, cc, opts...) } } // StreamServerInterceptor returns a new streaming server interceptor that validates incoming messages. // // The stage at which invalid messages will be rejected with `InvalidArgument` varies based on the // type of the RPC. For `ServerStream` (1:m) requests, it will happen before reaching any userspace // handlers. For `ClientStream` (n:1) or `BidiStream` (n:m) RPCs, the messages will be rejected on // calls to `stream.Recv()`. func (i interceptor) StreamServerInterceptor() grpc.StreamServerInterceptor { return func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error { wrapper := &recvWrapper{ServerStream: stream, i: i} return handler(srv, wrapper) } } func (i interceptor) StreamClientInterceptor() grpc.StreamClientInterceptor { return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) { desc.Handler = (&sendWrapper{handler: desc.Handler, i: i}).Handler() return streamer(ctx, desc, cc, method) } } type recvWrapper struct { i interceptor grpc.ServerStream } func (s *recvWrapper) RecvMsg(m interface{}) error { if err := s.ServerStream.RecvMsg(m); err != nil { return err } if err := s.i.validate(m); err != nil { return err } return nil } type sendWrapper struct { i interceptor grpc.ServerStream handler grpc.StreamHandler } func (s *sendWrapper) Handler() grpc.StreamHandler { return func(srv interface{}, stream grpc.ServerStream) error { return s.handler(srv, s) } } func (s *sendWrapper) SendMsg(m interface{}) error { if err := s.i.validate(m); err != nil { return err } return s.ServerStream.SendMsg(m) }