From 75242eb2cfada46413d6a6392577bbf610aa1b1e Mon Sep 17 00:00:00 2001 From: Nene7ko_ <1604009816@qq.com> Date: Thu, 30 Jul 2026 11:29:27 +0800 Subject: [PATCH 1/5] fix: handle ignored errors across rpc paths --- graceful_shutdown/shutdown.go | 3 +- protocol/dubbo/hessian2/hessian_request.go | 66 +++++--- .../dubbo/hessian2/hessian_request_test.go | 33 ++++ protocol/dubbo/impl/hessian.go | 151 +++++++++++------- protocol/dubbo/impl/hessian_test.go | 32 ++++ protocol/grpc/grpc_invoker.go | 6 +- protocol/grpc/grpc_invoker_test.go | 28 ++++ protocol/triple/server.go | 28 +++- registry/nacos/listener.go | 4 +- remoting/getty/config.go | 9 +- remoting/polaris/parser/parser.go | 5 +- 11 files changed, 268 insertions(+), 97 deletions(-) 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..ce64a911b6 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,55 @@ func packRequest(service Service, header DubboHeader, req any) ([]byte, error) { // body ////////////////////////////////////////// if hb { - _ = encoder.Encode(nil) + if err := encoder.Encode(nil); err != nil { + return nil, perrors.Wrap(err, "failed to encode heartbeat request") + } goto END } + if err := encodeRequestBody(encoder, service, request, args); err != nil { + return nil, err + } + +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) + } + // 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 +187,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..7834d566b1 100644 --- a/protocol/dubbo/hessian2/hessian_request_test.go +++ b/protocol/dubbo/hessian2/hessian_request_test.go @@ -90,6 +90,39 @@ func TestPackRequest(t *testing.T) { } } +func TestPackRequestReturnsEncodeErrors(t *testing.T) { + tests := []struct { + name string + request *DubboRequest + }{ + { + name: "unsupported argument", + request: NewRequest([]any{ + map[complex64]string{1 + 2i: "value"}, + }, nil), + }, + { + name: "unsupported attachment", + request: NewRequest([]any{}, map[string]any{ + "unsupported": func() {}, + }), + }, + } + + 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) + 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 1e3817d8b2..e9673efc32 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 *hessian2.GenericException: - _ = encoder.Encode(java_exception.NewDubboGenericException(ex.ExceptionClass, ex.ExceptionMessage)) - case hessian2.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 *hessian2.GenericException: + value = java_exception.NewDubboGenericException(ex.ExceptionClass, ex.ExceptionMessage) + case hessian2.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,9 @@ func marshalRequest(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) { if err != nil { return nil, perrors.Wrapf(err, " PackRequest(args:%+v)", args) } - _ = encoder.Encode(types) + if err := encodeHessianValue(encoder, types, "argument types"); 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 1ce98c6e06..52afce84f9 100644 --- a/protocol/dubbo/impl/hessian_test.go +++ b/protocol/dubbo/impl/hessian_test.go @@ -450,6 +450,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 1144e4918b..0175c65b1b 100644 --- a/protocol/grpc/grpc_invoker.go +++ b/protocol/grpc/grpc_invoker.go @@ -124,8 +124,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..6d095523c3 100644 --- a/remoting/getty/config.go +++ b/remoting/getty/config.go @@ -23,6 +23,7 @@ import ( import ( getty "github.com/apache/dubbo-getty" + "github.com/dubbogo/gost/log/logger" perrors "github.com/pkg/errors" ) @@ -140,7 +141,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 +169,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..dcd9459b49 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 fail, 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) From 1e38c10e1c9de9937240bba31355681a02db381e Mon Sep 17 00:00:00 2001 From: Nene7ko_ <1604009816@qq.com> Date: Thu, 30 Jul 2026 11:55:01 +0800 Subject: [PATCH 2/5] style: fix getty import formatting --- remoting/getty/config.go | 1 + 1 file changed, 1 insertion(+) diff --git a/remoting/getty/config.go b/remoting/getty/config.go index 6d095523c3..ec23225846 100644 --- a/remoting/getty/config.go +++ b/remoting/getty/config.go @@ -23,6 +23,7 @@ import ( import ( getty "github.com/apache/dubbo-getty" + "github.com/dubbogo/gost/log/logger" perrors "github.com/pkg/errors" From 81446ebcbe8c1b7fedea52c8debaafa396ca0dc0 Mon Sep 17 00:00:00 2001 From: Nene7ko_ <1604009816@qq.com> Date: Thu, 30 Jul 2026 12:05:56 +0800 Subject: [PATCH 3/5] fix: avoid shadowing hessian encode error --- protocol/dubbo/impl/hessian.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/protocol/dubbo/impl/hessian.go b/protocol/dubbo/impl/hessian.go index e9673efc32..dfce47fe97 100644 --- a/protocol/dubbo/impl/hessian.go +++ b/protocol/dubbo/impl/hessian.go @@ -173,7 +173,8 @@ func marshalRequest(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) { if err != nil { return nil, perrors.Wrapf(err, " PackRequest(args:%+v)", args) } - if err := encodeHessianValue(encoder, types, "argument types"); err != nil { + err = encodeHessianValue(encoder, types, "argument types") + if err != nil { return nil, err } for _, v := range args { From 5c83cc4f9382ea8c3af0c449db1844395b10b980 Mon Sep 17 00:00:00 2001 From: Nene7ko_ <1604009816@qq.com> Date: Thu, 6 Aug 2026 17:27:14 +0800 Subject: [PATCH 4/5] fix: address PR 3574 review feedback --- protocol/dubbo/hessian2/hessian_request.go | 10 ++++----- .../dubbo/hessian2/hessian_request_test.go | 21 ++++++++++++++++--- remoting/polaris/parser/parser.go | 2 +- 3 files changed, 23 insertions(+), 10 deletions(-) diff --git a/protocol/dubbo/hessian2/hessian_request.go b/protocol/dubbo/hessian2/hessian_request.go index ce64a911b6..295ff10c22 100644 --- a/protocol/dubbo/hessian2/hessian_request.go +++ b/protocol/dubbo/hessian2/hessian_request.go @@ -127,14 +127,12 @@ func packRequest(service Service, header DubboHeader, req any) ([]byte, error) { if err := encoder.Encode(nil); err != nil { return nil, perrors.Wrap(err, "failed to encode heartbeat request") } - goto END - } - - if err := encodeRequestBody(encoder, service, request, args); err != nil { - return nil, err + } else { + if err := encodeRequestBody(encoder, service, request, args); err != nil { + return nil, err + } } -END: byteArray = encoder.Buffer() pkgLen = len(byteArray) if pkgLen > int(DEFAULT_LEN) { // recommand 8M diff --git a/protocol/dubbo/hessian2/hessian_request_test.go b/protocol/dubbo/hessian2/hessian_request_test.go index 7834d566b1..2b20002a89 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,22 +91,35 @@ 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 + name string + request *DubboRequest + errString string }{ { - name: "unsupported argument", + 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", }, } @@ -118,6 +132,7 @@ func TestPackRequestReturnsEncodeErrors(t *testing.T) { }, DubboHeader{Type: PackageRequest}, tt.request) require.Error(t, err) + assert.ErrorContains(t, err, tt.errString) assert.Nil(t, data) }) } diff --git a/remoting/polaris/parser/parser.go b/remoting/polaris/parser/parser.go index dcd9459b49..835f377bc5 100644 --- a/remoting/polaris/parser/parser.go +++ b/remoting/polaris/parser/parser.go @@ -89,7 +89,7 @@ func ParseArgumentsByExpression(key string, parameters []any) any { } var searchVal any if err = json.Unmarshal(data, &searchVal); err != nil { - logger.Errorf("[Remoting][Polaris] unmarshal parameter %+v fail, err=%v", parameters[index], err) + logger.Errorf("[Remoting][Polaris] unmarshal parameter %+v failed, err=%v", parameters[index], err) return nil } res, err := jsonpath.JsonPathLookup(searchVal, key) From e73d449fc23bf3ffbdc8f80cfbce5a73253353ae Mon Sep 17 00:00:00 2001 From: Nene7ko_ <1604009816@qq.com> Date: Thu, 6 Aug 2026 18:01:42 +0800 Subject: [PATCH 5/5] fix: satisfy testifylint error assertion --- protocol/dubbo/hessian2/hessian_request_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/protocol/dubbo/hessian2/hessian_request_test.go b/protocol/dubbo/hessian2/hessian_request_test.go index 2b20002a89..5d55eeb912 100644 --- a/protocol/dubbo/hessian2/hessian_request_test.go +++ b/protocol/dubbo/hessian2/hessian_request_test.go @@ -132,7 +132,7 @@ func TestPackRequestReturnsEncodeErrors(t *testing.T) { }, DubboHeader{Type: PackageRequest}, tt.request) require.Error(t, err) - assert.ErrorContains(t, err, tt.errString) + require.ErrorContains(t, err, tt.errString) assert.Nil(t, data) }) }