From ffa9d5efff4e1d24722a316c19110b8344e02389 Mon Sep 17 00:00:00 2001 From: Rafael Vasquez Date: Tue, 26 Sep 2023 17:46:01 -0400 Subject: [PATCH] feat: Support ModelMetadata endpoint (#26) Resolves #14 Resolves kserve/modelmesh-serving#418 --------- Signed-off-by: Rafael Vasquez --- gen/grpc_predict_v2.pb.gw.go | 294 ++++++++++++++++++++++++++++++++--- grpc_predict_v2.proto | 9 +- 2 files changed, 281 insertions(+), 22 deletions(-) diff --git a/gen/grpc_predict_v2.pb.gw.go b/gen/grpc_predict_v2.pb.gw.go index 518d1cc..db04147 100644 --- a/gen/grpc_predict_v2.pb.gw.go +++ b/gen/grpc_predict_v2.pb.gw.go @@ -31,6 +31,148 @@ var _ = runtime.String var _ = utilities.NewDoubleArray var _ = metadata.Join +var ( + filter_GRPCInferenceService_ModelMetadata_0 = &utilities.DoubleArray{Encoding: map[string]int{"name": 0}, Base: []int{1, 2, 0, 0}, Check: []int{0, 1, 2, 2}} +) + +func request_GRPCInferenceService_ModelMetadata_0(ctx context.Context, marshaler runtime.Marshaler, client GRPCInferenceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ModelMetadataRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GRPCInferenceService_ModelMetadata_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.ModelMetadata(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_GRPCInferenceService_ModelMetadata_0(ctx context.Context, marshaler runtime.Marshaler, server GRPCInferenceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ModelMetadataRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_GRPCInferenceService_ModelMetadata_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.ModelMetadata(ctx, &protoReq) + return msg, metadata, err + +} + +func request_GRPCInferenceService_ModelMetadata_1(ctx context.Context, marshaler runtime.Marshaler, client GRPCInferenceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ModelMetadataRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + + val, ok = pathParams["version"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "version") + } + + protoReq.Version, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "version", err) + } + + msg, err := client.ModelMetadata(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_GRPCInferenceService_ModelMetadata_1(ctx context.Context, marshaler runtime.Marshaler, server GRPCInferenceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ModelMetadataRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + + val, ok = pathParams["version"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "version") + } + + protoReq.Version, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "version", err) + } + + msg, err := server.ModelMetadata(ctx, &protoReq) + return msg, metadata, err + +} + func request_GRPCInferenceService_ModelInfer_0(ctx context.Context, marshaler runtime.Marshaler, client GRPCInferenceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq ModelInferRequest var metadata runtime.ServerMetadata @@ -100,7 +242,7 @@ func local_request_GRPCInferenceService_ModelInfer_0(ctx context.Context, marsha } var ( - filter_GRPCInferenceService_ModelInfer_1 = &utilities.DoubleArray{Encoding: map[string]int{"model_name": 0, "model_version": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}} + filter_GRPCInferenceService_ModelInfer_1 = &utilities.DoubleArray{Encoding: map[string]int{"model_name": 0, "modelName": 1, "model_version": 2, "modelVersion": 3}, Base: []int{1, 1, 2, 3, 4, 0, 0, 0, 0}, Check: []int{0, 1, 1, 1, 1, 2, 3, 4, 5}} ) func request_GRPCInferenceService_ModelInfer_1(ctx context.Context, marshaler runtime.Marshaler, client GRPCInferenceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { @@ -195,49 +337,103 @@ func local_request_GRPCInferenceService_ModelInfer_1(ctx context.Context, marsha // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterGRPCInferenceServiceHandlerFromEndpoint instead. func RegisterGRPCInferenceServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server GRPCInferenceServiceServer) error { - mux.Handle("POST", pattern_GRPCInferenceService_ModelInfer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_GRPCInferenceService_ModelMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelInfer", runtime.WithHTTPPathPattern("/v2/models/{model_name}/infer")) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelMetadata", runtime.WithHTTPPathPattern("/v2/models/{name}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_GRPCInferenceService_ModelInfer_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_GRPCInferenceService_ModelMetadata_0(annotatedContext, inboundMarshaler, server, req, pathParams) md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GRPCInferenceService_ModelMetadata_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_GRPCInferenceService_ModelMetadata_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelMetadata", runtime.WithHTTPPathPattern("/v2/models/{name}/versions/{version}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } + resp, md, err := local_request_GRPCInferenceService_ModelMetadata_1(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } - forward_GRPCInferenceService_ModelInfer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_GRPCInferenceService_ModelMetadata_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("POST", pattern_GRPCInferenceService_ModelInfer_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("POST", pattern_GRPCInferenceService_ModelInfer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelInfer", runtime.WithHTTPPathPattern("/v2/models/{model_name}/versions/{model_version}/infer")) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelInfer", runtime.WithHTTPPathPattern("/v2/models/{model_name}/infer")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_GRPCInferenceService_ModelInfer_1(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_GRPCInferenceService_ModelInfer_0(annotatedContext, inboundMarshaler, server, req, pathParams) md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GRPCInferenceService_ModelInfer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GRPCInferenceService_ModelInfer_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelInfer", runtime.WithHTTPPathPattern("/v2/models/{model_name}/versions/{model_version}/infer")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } + resp, md, err := local_request_GRPCInferenceService_ModelInfer_1(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } - forward_GRPCInferenceService_ModelInfer_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_GRPCInferenceService_ModelInfer_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -282,43 +478,91 @@ func RegisterGRPCInferenceServiceHandler(ctx context.Context, mux *runtime.Serve // "GRPCInferenceServiceClient" to call the correct interceptors. func RegisterGRPCInferenceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client GRPCInferenceServiceClient) error { - mux.Handle("POST", pattern_GRPCInferenceService_ModelInfer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_GRPCInferenceService_ModelMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - rctx, err := runtime.AnnotateContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelInfer", runtime.WithHTTPPathPattern("/v2/models/{model_name}/infer")) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelMetadata", runtime.WithHTTPPathPattern("/v2/models/{name}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_GRPCInferenceService_ModelInfer_0(rctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) + resp, md, err := request_GRPCInferenceService_ModelMetadata_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GRPCInferenceService_ModelMetadata_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_GRPCInferenceService_ModelMetadata_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelMetadata", runtime.WithHTTPPathPattern("/v2/models/{name}/versions/{version}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } + resp, md, err := request_GRPCInferenceService_ModelMetadata_1(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } - forward_GRPCInferenceService_ModelInfer_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_GRPCInferenceService_ModelMetadata_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) - mux.Handle("POST", pattern_GRPCInferenceService_ModelInfer_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("POST", pattern_GRPCInferenceService_ModelInfer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - rctx, err := runtime.AnnotateContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelInfer", runtime.WithHTTPPathPattern("/v2/models/{model_name}/versions/{model_version}/infer")) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelInfer", runtime.WithHTTPPathPattern("/v2/models/{model_name}/infer")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_GRPCInferenceService_ModelInfer_1(rctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) + resp, md, err := request_GRPCInferenceService_ModelInfer_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + + forward_GRPCInferenceService_ModelInfer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_GRPCInferenceService_ModelInfer_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + var err error + var annotatedContext context.Context + annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/inference.GRPCInferenceService/ModelInfer", runtime.WithHTTPPathPattern("/v2/models/{model_name}/versions/{model_version}/infer")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } + resp, md, err := request_GRPCInferenceService_ModelInfer_1(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } - forward_GRPCInferenceService_ModelInfer_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_GRPCInferenceService_ModelInfer_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -326,12 +570,20 @@ func RegisterGRPCInferenceServiceHandlerClient(ctx context.Context, mux *runtime } var ( + pattern_GRPCInferenceService_ModelMetadata_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v2", "models", "name"}, "")) + + pattern_GRPCInferenceService_ModelMetadata_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v2", "models", "name", "versions", "version"}, "")) + pattern_GRPCInferenceService_ModelInfer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"v2", "models", "model_name", "infer"}, "")) pattern_GRPCInferenceService_ModelInfer_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"v2", "models", "model_name", "versions", "model_version", "infer"}, "")) ) var ( + forward_GRPCInferenceService_ModelMetadata_0 = runtime.ForwardResponseMessage + + forward_GRPCInferenceService_ModelMetadata_1 = runtime.ForwardResponseMessage + forward_GRPCInferenceService_ModelInfer_0 = runtime.ForwardResponseMessage forward_GRPCInferenceService_ModelInfer_1 = runtime.ForwardResponseMessage diff --git a/grpc_predict_v2.proto b/grpc_predict_v2.proto index 8ade2bc..089e07c 100644 --- a/grpc_predict_v2.proto +++ b/grpc_predict_v2.proto @@ -41,7 +41,14 @@ service GRPCInferenceService // The per-model metadata API provides information about a model. Errors are // indicated by the google.rpc.Status returned for the request. The OK code // indicates success and other codes indicate failure. - rpc ModelMetadata(ModelMetadataRequest) returns (ModelMetadataResponse) {} + rpc ModelMetadata(ModelMetadataRequest) returns (ModelMetadataResponse) { + option (google.api.http) = { + get: "/v2/models/{name}" + additional_bindings { + get: "/v2/models/{name}/versions/{version}" + } + }; + } // The ModelInfer API performs inference using the specified model. Errors are // indicated by the google.rpc.Status returned for the request. The OK code