diff --git a/graceful_shutdown/shutdown.go b/graceful_shutdown/shutdown.go index f01d16db36..b024a1f29f 100644 --- a/graceful_shutdown/shutdown.go +++ b/graceful_shutdown/shutdown.go @@ -422,7 +422,8 @@ func invokeCustomShutdownCallback(timeout time.Duration, callback func()) { func getProtocolSafely(name string) (protocol protocolbase.Protocol, ok bool) { defer func() { - if recover() != nil { + if recovered := recover(); recovered != nil { + logger.Warnf("[GracefulShutdown] get protocol %s panicked, err=%v", name, recovered) protocol = nil ok = false } diff --git a/protocol/dubbo/hessian2/hessian_request.go b/protocol/dubbo/hessian2/hessian_request.go index b503295fa2..295ff10c22 100644 --- a/protocol/dubbo/hessian2/hessian_request.go +++ b/protocol/dubbo/hessian2/hessian_request.go @@ -85,8 +85,6 @@ func EnsureRequest(body any) *DubboRequest { func packRequest(service Service, header DubboHeader, req any) ([]byte, error) { var ( - err error - types string byteArray []byte pkgLen int ) @@ -126,31 +124,53 @@ func packRequest(service Service, header DubboHeader, req any) ([]byte, error) { // body ////////////////////////////////////////// if hb { - _ = encoder.Encode(nil) - goto END + if err := encoder.Encode(nil); err != nil { + return nil, perrors.Wrap(err, "failed to encode heartbeat request") + } + } else { + if err := encodeRequestBody(encoder, service, request, args); err != nil { + return nil, err + } } + byteArray = encoder.Buffer() + pkgLen = len(byteArray) + if pkgLen > int(DEFAULT_LEN) { // recommand 8M + logger.Warnf("[Dubbo][Hessian2] data length %d too large, recommand max payload %d. "+ + "Dubbo java can't handle the package whose size is greater than %d!!!", pkgLen, DEFAULT_LEN, DEFAULT_LEN) + } + // byteArray{body length} + binary.BigEndian.PutUint32(byteArray[12:], uint32(pkgLen-HEADER_LENGTH)) + return byteArray, nil +} + +func encodeRequestBody(encoder *hessian.Encoder, service Service, request *DubboRequest, args []any) error { // dubbo version + path + version + method - if err = encoder.Encode(DEFAULT_DUBBO_PROTOCOL_VERSION); err != nil { - logger.Warnf("[Dubbo][Hessian2] encode default dubbo protocol version failed, err=%v", err) + if err := encoder.Encode(DEFAULT_DUBBO_PROTOCOL_VERSION); err != nil { + return perrors.Wrap(err, "failed to encode default dubbo protocol version") } - if err = encoder.Encode(service.Path); err != nil { - logger.Warnf("[Dubbo][Hessian2] encode service path failed, err=%v", err) + if err := encoder.Encode(service.Path); err != nil { + return perrors.Wrap(err, "failed to encode service path") } - if err = encoder.Encode(service.Version); err != nil { - logger.Warnf("[Dubbo][Hessian2] encode service version failed, err=%v", err) + if err := encoder.Encode(service.Version); err != nil { + return perrors.Wrap(err, "failed to encode service version") } - if err = encoder.Encode(service.Method); err != nil { - logger.Warnf("[Dubbo][Hessian2] encode service method failed, err=%v", err) + if err := encoder.Encode(service.Method); err != nil { + return perrors.Wrap(err, "failed to encode service method") } // args = args type list + args value list - if types, err = getArgsTypeList(args); err != nil { - return nil, perrors.Wrapf(err, " PackRequest(args:%+v)", args) + types, err := getArgsTypeList(args) + if err != nil { + return perrors.Wrapf(err, " PackRequest(args:%+v)", args) + } + if err := encoder.Encode(types); err != nil { + return perrors.Wrap(err, "failed to encode argument types") } - _ = encoder.Encode(types) for _, v := range args { - _ = encoder.Encode(v) + if err := encoder.Encode(v); err != nil { + return perrors.Wrapf(err, "failed to encode argument of type %T", v) + } } request.Attachments[PATH_KEY] = service.Path @@ -165,18 +185,10 @@ func packRequest(service Service, header DubboHeader, req any) ([]byte, error) { request.Attachments[TIMEOUT_KEY] = strconv.Itoa(int(service.Timeout / time.Millisecond)) } - _ = encoder.Encode(request.Attachments) - -END: - byteArray = encoder.Buffer() - pkgLen = len(byteArray) - if pkgLen > int(DEFAULT_LEN) { // recommand 8M - logger.Warnf("[Dubbo][Hessian2] data length %d too large, recommand max payload %d. "+ - "Dubbo java can't handle the package whose size is greater than %d!!!", pkgLen, DEFAULT_LEN, DEFAULT_LEN) + if err := encoder.Encode(request.Attachments); err != nil { + return perrors.Wrap(err, "failed to encode request attachments") } - // byteArray{body length} - binary.BigEndian.PutUint32(byteArray[12:], uint32(pkgLen-HEADER_LENGTH)) - return byteArray, nil + return nil } // hessian decode request body diff --git a/protocol/dubbo/hessian2/hessian_request_test.go b/protocol/dubbo/hessian2/hessian_request_test.go index 7a9d70ead7..5d55eeb912 100644 --- a/protocol/dubbo/hessian2/hessian_request_test.go +++ b/protocol/dubbo/hessian2/hessian_request_test.go @@ -18,6 +18,7 @@ package hessian2 import ( + "encoding/binary" "reflect" "strconv" "testing" @@ -90,6 +91,53 @@ func TestPackRequest(t *testing.T) { } } +func TestPackRequestHeartbeat(t *testing.T) { + data, err := packRequest(Service{}, DubboHeader{Type: PackageHeartbeat}, NewRequest([]any{}, nil)) + + require.NoError(t, err) + require.Len(t, data, HEADER_LENGTH+1) + assert.Equal(t, DubboRequestHeartbeatHeader[:HEADER_LENGTH-4], data[:HEADER_LENGTH-4]) + assert.Equal(t, uint32(1), binary.BigEndian.Uint32(data[HEADER_LENGTH-4:HEADER_LENGTH])) + assert.Equal(t, byte('N'), data[HEADER_LENGTH]) +} + +func TestPackRequestReturnsEncodeErrors(t *testing.T) { + tests := []struct { + name string + request *DubboRequest + errString string + }{ + { + name: "unsupported map key argument", + request: NewRequest([]any{ + map[complex64]string{1 + 2i: "value"}, + }, nil), + errString: "failed to encode argument of type map[complex64]string", + }, + { + name: "unsupported attachment", + request: NewRequest([]any{}, map[string]any{ + "unsupported": func() {}, + }), + errString: "failed to encode request attachments", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + data, err := packRequest(Service{ + Path: "test", + Version: "v1.0", + Method: "test", + }, DubboHeader{Type: PackageRequest}, tt.request) + + require.Error(t, err) + require.ErrorContains(t, err, tt.errString) + assert.Nil(t, data) + }) + } +} + func TestGetArgsTypeList(t *testing.T) { type Test struct{} str, err := getArgsTypeList([]any{nil, 1, []int{2}, true, []bool{false}, "a", []string{"b"}, Test{}, &Test{}, []Test{}, map[string]Test{}, TestEnumGender(MAN)}) diff --git a/protocol/dubbo/impl/hessian.go b/protocol/dubbo/impl/hessian.go index becdfcdeef..4a0e4d6e2b 100644 --- a/protocol/dubbo/impl/hessian.go +++ b/protocol/dubbo/impl/hessian.go @@ -61,60 +61,9 @@ func (h HessianSerializer) Unmarshal(input []byte, p *DubboPackage) error { } func marshalResponse(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) { - header := p.Header response := EnsureResponsePayload(p.Body) - if header.ResponseStatus == Response_OK { - if p.IsHeartBeat() { - _ = encoder.Encode(nil) - } else { - var version string - if attachmentVersion, ok := response.Attachments[DUBBO_VERSION_KEY]; ok { - version = attachmentVersion.(string) - } - atta := isSupportResponseAttachment(version) - - var resWithException, resValue, resNullValue int32 - if atta { - resWithException = RESPONSE_WITH_EXCEPTION_WITH_ATTACHMENTS - resValue = RESPONSE_VALUE_WITH_ATTACHMENTS - resNullValue = RESPONSE_NULL_VALUE_WITH_ATTACHMENTS - } else { - resWithException = RESPONSE_WITH_EXCEPTION - resValue = RESPONSE_VALUE - resNullValue = RESPONSE_NULL_VALUE - } - - if response.Exception != nil { // throw error - _ = encoder.Encode(resWithException) - switch ex := response.Exception.(type) { - case *hessian.GenericException: - _ = encoder.Encode(java_exception.NewDubboGenericException(ex.ExceptionClass, ex.ExceptionMessage)) - case hessian.GenericException: - _ = encoder.Encode(java_exception.NewDubboGenericException(ex.ExceptionClass, ex.ExceptionMessage)) - case java_exception.Throwabler: - _ = encoder.Encode(ex) - default: - _ = encoder.Encode(java_exception.NewThrowable(response.Exception.Error())) - } - } else { - if response.RspObj == nil { - _ = encoder.Encode(resNullValue) - } else { - _ = encoder.Encode(resValue) - _ = encoder.Encode(response.RspObj) // result - } - } - - if atta { - _ = encoder.Encode(response.Attachments) // attachments - } - } - } else { - if response.Exception != nil { // throw error - _ = encoder.Encode(response.Exception.Error()) - } else { - _ = encoder.Encode(response.RspObj) - } + if err := encodeResponse(encoder, p, response); err != nil { + return nil, err } bs := encoder.Buffer() // encNull @@ -122,13 +71,97 @@ func marshalResponse(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) { return bs, nil } +func encodeResponse(encoder *hessian.Encoder, p DubboPackage, response *ResponsePayload) error { + if p.Header.ResponseStatus != Response_OK { + if response.Exception != nil { + return encodeHessianValue(encoder, response.Exception.Error(), "response exception message") + } + return encodeHessianValue(encoder, response.RspObj, "response value") + } + if p.IsHeartBeat() { + return encodeHessianValue(encoder, nil, "heartbeat response") + } + + var version string + if attachmentVersion, ok := response.Attachments[DUBBO_VERSION_KEY]; ok { + version = attachmentVersion.(string) + } + withAttachments := isSupportResponseAttachment(version) + resWithException, resValue, resNullValue := responseTypes(withAttachments) + + if err := encodeResponsePayload(encoder, response, resWithException, resValue, resNullValue); err != nil { + return err + } + if withAttachments { + return encodeHessianValue(encoder, response.Attachments, "response attachments") + } + return nil +} + +func encodeResponsePayload(encoder *hessian.Encoder, response *ResponsePayload, resWithException, resValue, resNullValue int32) error { + if response.Exception != nil { + return encodeExceptionResponse(encoder, response.Exception, resWithException) + } + if response.RspObj == nil { + return encodeHessianValue(encoder, resNullValue, "null response type") + } + if err := encodeHessianValue(encoder, resValue, "response value type"); err != nil { + return err + } + return encodeHessianValue(encoder, response.RspObj, "response value") +} + +func responseTypes(withAttachments bool) (int32, int32, int32) { + if withAttachments { + return RESPONSE_WITH_EXCEPTION_WITH_ATTACHMENTS, RESPONSE_VALUE_WITH_ATTACHMENTS, RESPONSE_NULL_VALUE_WITH_ATTACHMENTS + } + return RESPONSE_WITH_EXCEPTION, RESPONSE_VALUE, RESPONSE_NULL_VALUE +} + +func encodeResponseException(encoder *hessian.Encoder, exception error) error { + var value any + switch ex := exception.(type) { + case *hessian.GenericException: + value = java_exception.NewDubboGenericException(ex.ExceptionClass, ex.ExceptionMessage) + case hessian.GenericException: + value = java_exception.NewDubboGenericException(ex.ExceptionClass, ex.ExceptionMessage) + case java_exception.Throwabler: + value = ex + default: + value = java_exception.NewThrowable(exception.Error()) + } + return encodeHessianValue(encoder, value, "response exception") +} + +func encodeExceptionResponse(encoder *hessian.Encoder, exception error, responseType int32) error { + if err := encodeHessianValue(encoder, responseType, "response exception type"); err != nil { + return err + } + return encodeResponseException(encoder, exception) +} + +func encodeHessianValue(encoder *hessian.Encoder, value any, description string) error { + if err := encoder.Encode(value); err != nil { + return perrors.Wrapf(err, "failed to encode %s", description) + } + return nil +} + func marshalRequest(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) { service := p.Service request := EnsureRequestPayload(p.Body) - _ = encoder.Encode(DEFAULT_DUBBO_PROTOCOL_VERSION) - _ = encoder.Encode(service.Path) - _ = encoder.Encode(service.Version) - _ = encoder.Encode(service.Method) + if err := encodeHessianValue(encoder, DEFAULT_DUBBO_PROTOCOL_VERSION, "dubbo protocol version"); err != nil { + return nil, err + } + if err := encodeHessianValue(encoder, service.Path, "service path"); err != nil { + return nil, err + } + if err := encodeHessianValue(encoder, service.Version, "service version"); err != nil { + return nil, err + } + if err := encodeHessianValue(encoder, service.Method, "service method"); err != nil { + return nil, err + } args, ok := request.Params.([]any) @@ -140,7 +173,10 @@ func marshalRequest(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) { if err != nil { return nil, perrors.Wrapf(err, " PackRequest(args:%+v)", args) } - _ = encoder.Encode(types) + err = encodeHessianValue(encoder, types, "argument types") + if err != nil { + return nil, err + } for _, v := range args { if e := encoder.Encode(v); e != nil { return nil, perrors.Wrapf(e, "failed to encode argument: %v", v) diff --git a/protocol/dubbo/impl/hessian_test.go b/protocol/dubbo/impl/hessian_test.go index 16e29b4243..51bb412c2a 100644 --- a/protocol/dubbo/impl/hessian_test.go +++ b/protocol/dubbo/impl/hessian_test.go @@ -449,6 +449,38 @@ func TestMarshalResponse(t *testing.T) { assert.NotNil(t, data) }) + t.Run("response with unsupported value", func(t *testing.T) { + encoder := hessian.NewEncoder() + pkg := DubboPackage{ + Header: DubboHeader{ResponseStatus: Response_OK}, + Body: &ResponsePayload{ + RspObj: func() {}, + Attachments: map[string]any{}, + }, + } + + data, err := marshalResponse(encoder, pkg) + require.Error(t, err) + assert.Nil(t, data) + }) + + t.Run("response with unsupported attachment", func(t *testing.T) { + encoder := hessian.NewEncoder() + pkg := DubboPackage{ + Header: DubboHeader{ResponseStatus: Response_OK}, + Body: &ResponsePayload{ + Attachments: map[string]any{ + DUBBO_VERSION_KEY: "2.7.0", + "unsupported": func() {}, + }, + }, + } + + data, err := marshalResponse(encoder, pkg) + require.Error(t, err) + assert.Nil(t, data) + }) + t.Run("response with value", func(t *testing.T) { encoder := hessian.NewEncoder() pkg := DubboPackage{ diff --git a/protocol/grpc/grpc_invoker.go b/protocol/grpc/grpc_invoker.go index 9ab74ce68c..1df29000e5 100644 --- a/protocol/grpc/grpc_invoker.go +++ b/protocol/grpc/grpc_invoker.go @@ -123,8 +123,10 @@ func (gi *GrpcInvoker) Invoke(ctx context.Context, invocation base.Invocation) r // check err if !res[1].IsNil() { result.SetError(res[1].Interface().(error)) - } else { - _ = hessian2.ReflectResponse(res[0], invocation.Reply()) + } else if invocation.Reply() != nil { + if err := hessian2.ReflectResponse(res[0], invocation.Reply()); err != nil { + result.SetError(errors.WithStack(err)) + } } return &result diff --git a/protocol/grpc/grpc_invoker_test.go b/protocol/grpc/grpc_invoker_test.go index b1cb637faa..f59903ee34 100644 --- a/protocol/grpc/grpc_invoker_test.go +++ b/protocol/grpc/grpc_invoker_test.go @@ -20,6 +20,7 @@ package grpc import ( "context" "reflect" + "sync" "testing" ) @@ -31,11 +32,38 @@ import ( import ( "dubbo.apache.org/dubbo-go/v3/common" "dubbo.apache.org/dubbo-go/v3/common/constant" + "dubbo.apache.org/dubbo-go/v3/protocol/base" "dubbo.apache.org/dubbo-go/v3/protocol/grpc/internal/helloworld" "dubbo.apache.org/dubbo-go/v3/protocol/grpc/internal/routeguide" "dubbo.apache.org/dubbo-go/v3/protocol/invocation" ) +type grpcInvokerTestClient struct{} + +func (*grpcInvokerTestClient) Call(context.Context) (string, error) { + return "response", nil +} + +func TestUnaryInvokeReturnsReflectResponseError(t *testing.T) { + url := common.NewURLWithOptions(common.WithProtocol("grpc")) + invoker := &GrpcInvoker{ + BaseInvoker: *base.NewBaseInvoker(url), + clientGuard: &sync.RWMutex{}, + client: &Client{ + invoker: reflect.ValueOf(&grpcInvokerTestClient{}), + }, + } + invo := invocation.NewRPCInvocationWithOptions( + invocation.WithMethodName("Call"), + invocation.WithReply("reply must be a pointer"), + ) + + res := invoker.Invoke(context.Background(), invo) + + require.Error(t, res.Error()) + assert.ErrorContains(t, res.Error(), "@out should be a pointer") +} + const ( helloworldURL = "grpc://127.0.0.1:30000/GrpcGreeterImpl?accesslog=&anyhost=true&app.version=0.0.1&application=BDTService&async=false&bean.name=GrpcGreeterImpl" + "&category=providers&cluster=failover&dubbo=dubbo-provider-golang-2.6.0&environment=dev&execute.limit=&execute.limit.rejected.handler=&generic=false&group=&interface=io.grpc.examples.helloworld.GreeterGrpc%24IGreeter" + diff --git a/protocol/triple/server.go b/protocol/triple/server.go index fc7225b6be..939d6467e7 100644 --- a/protocol/triple/server.go +++ b/protocol/triple/server.go @@ -496,7 +496,9 @@ func (s *Server) compatRegisterHandler(interfaceName string, svc dubbo3.Dubbo3Gr // please refer to protocol/triple/internal/proto/triple_gen/greettriple for procedure examples // error could be ignored because base is empty string procedure := joinProcedure(interfaceName, method.MethodName) - _ = s.triServer.RegisterCompatUnaryHandler(procedure, method.MethodName, svc, tri.MethodHandler(method.Handler), opts...) + if err := s.triServer.RegisterCompatUnaryHandler(procedure, method.MethodName, svc, tri.MethodHandler(method.Handler), opts...); err != nil { + logger.Errorf("[Triple][Server] register compat unary handler failed, procedure=%s, err=%v", procedure, err) + } } // init stream handlers @@ -513,7 +515,9 @@ func (s *Server) compatRegisterHandler(interfaceName string, svc dubbo3.Dubbo3Gr case stream.ServerStreams: typ = tri.StreamTypeServer } - _ = s.triServer.RegisterCompatStreamHandler(procedure, svc, typ, stream.Handler, opts...) + if err := s.triServer.RegisterCompatStreamHandler(procedure, svc, typ, stream.Handler, opts...); err != nil { + logger.Errorf("[Triple][Server] register compat stream handler failed, procedure=%s, err=%v", procedure, err) + } } } @@ -543,7 +547,7 @@ func (s *Server) registerMethodHandler(procedure string, m common.MethodInfo, in } func (s *Server) registerUnaryMethodHandler(procedure string, m common.MethodInfo, invoker base.Invoker, opts ...tri.HandlerOption) { - _ = s.triServer.RegisterUnaryHandler( + err := s.triServer.RegisterUnaryHandler( procedure, m.ReqInitFunc, func(ctx context.Context, req *tri.Request) (*tri.Response, error) { @@ -561,10 +565,13 @@ func (s *Server) registerUnaryMethodHandler(procedure string, m common.MethodInf }, opts..., ) + if err != nil { + logger.Errorf("[Triple][Server] register unary handler failed, procedure=%s, err=%v", procedure, err) + } } func (s *Server) registerClientStreamMethodHandler(procedure string, m common.MethodInfo, invoker base.Invoker, opts ...tri.HandlerOption) { - _ = s.triServer.RegisterClientStreamHandler( + err := s.triServer.RegisterClientStreamHandler( procedure, func(ctx context.Context, stream *tri.ClientStream) (*tri.Response, error) { args := []any{m.StreamInitFunc(stream)} @@ -577,10 +584,13 @@ func (s *Server) registerClientStreamMethodHandler(procedure string, m common.Me }, opts..., ) + if err != nil { + logger.Errorf("[Triple][Server] register client stream handler failed, procedure=%s, err=%v", procedure, err) + } } func (s *Server) registerServerStreamMethodHandler(procedure string, m common.MethodInfo, invoker base.Invoker, opts ...tri.HandlerOption) { - _ = s.triServer.RegisterServerStreamHandler( + err := s.triServer.RegisterServerStreamHandler( procedure, m.ReqInitFunc, func(ctx context.Context, req *tri.Request, stream *tri.ServerStream) error { @@ -594,10 +604,13 @@ func (s *Server) registerServerStreamMethodHandler(procedure string, m common.Me }, opts..., ) + if err != nil { + logger.Errorf("[Triple][Server] register server stream handler failed, procedure=%s, err=%v", procedure, err) + } } func (s *Server) registerBidiStreamMethodHandler(procedure string, m common.MethodInfo, invoker base.Invoker, opts ...tri.HandlerOption) { - _ = s.triServer.RegisterBidiStreamHandler( + err := s.triServer.RegisterBidiStreamHandler( procedure, func(ctx context.Context, stream *tri.BidiStream) error { args := []any{m.StreamInitFunc(stream)} @@ -610,6 +623,9 @@ func (s *Server) registerBidiStreamMethodHandler(procedure string, m common.Meth }, opts..., ) + if err != nil { + logger.Errorf("[Triple][Server] register bidi stream handler failed, procedure=%s, err=%v", procedure, err) + } } func extractUnaryInvocationArgs(msg any) []any { diff --git a/registry/nacos/listener.go b/registry/nacos/listener.go index 8a59716427..99687b0e6e 100644 --- a/registry/nacos/listener.go +++ b/registry/nacos/listener.go @@ -239,7 +239,9 @@ func (nl *nacosListener) Next() (*registry.ServiceEvent, error) { // Close stops the subscription and releases resources. func (nl *nacosListener) Close() { nl.once.Do(func() { - _ = nl.stopListen() + if err := nl.stopListen(); err != nil { + logger.Warnf("[Registry][Nacos] unsubscribe listener failed, serviceName=%s, err=%v", nl.serviceName, err) + } close(nl.done) }) } diff --git a/remoting/getty/config.go b/remoting/getty/config.go index 5143e075f8..ec23225846 100644 --- a/remoting/getty/config.go +++ b/remoting/getty/config.go @@ -24,6 +24,8 @@ import ( import ( getty "github.com/apache/dubbo-getty" + "github.com/dubbogo/gost/log/logger" + perrors "github.com/pkg/errors" ) @@ -140,7 +142,9 @@ func GetDefaultClientConfig() *ClientConfig { SessionName: "client", }, } - _ = defaultClientConfig.CheckValidity() + if err := defaultClientConfig.CheckValidity(); err != nil { + logger.Errorf("[Remoting][Getty] invalid default client config, err=%v", err) + } return defaultClientConfig } @@ -166,7 +170,9 @@ func GetDefaultServerConfig() *ServerConfig { SessionName: "server", }, } - _ = defaultServerConfig.CheckValidity() + if err := defaultServerConfig.CheckValidity(); err != nil { + logger.Errorf("[Remoting][Getty] invalid default server config, err=%v", err) + } return defaultServerConfig } diff --git a/remoting/polaris/parser/parser.go b/remoting/polaris/parser/parser.go index 7271f74784..835f377bc5 100644 --- a/remoting/polaris/parser/parser.go +++ b/remoting/polaris/parser/parser.go @@ -88,7 +88,10 @@ func ParseArgumentsByExpression(key string, parameters []any) any { return nil } var searchVal any - _ = json.Unmarshal(data, &searchVal) + if err = json.Unmarshal(data, &searchVal); err != nil { + logger.Errorf("[Remoting][Polaris] unmarshal parameter %+v failed, err=%v", parameters[index], err) + return nil + } res, err := jsonpath.JsonPathLookup(searchVal, key) if err != nil { logger.Errorf("[Remoting][Polaris] invalid do json path lookup, key=%s err=%v", key, err)