Skip to content
Merged
Show file tree
Hide file tree
Changes from 4 commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 2 additions & 1 deletion graceful_shutdown/shutdown.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
}
Expand Down
66 changes: 40 additions & 26 deletions protocol/dubbo/hessian2/hessian_request.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
)
Expand Down Expand Up @@ -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:
Comment thread
XnLemon marked this conversation as resolved.
Resolved
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
Expand All @@ -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
Expand Down
33 changes: 33 additions & 0 deletions protocol/dubbo/hessian2/hessian_request_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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),
},
Comment thread
XnLemon marked this conversation as resolved.
Resolved
{
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)})
Expand Down
152 changes: 94 additions & 58 deletions protocol/dubbo/impl/hessian.go
Original file line number Diff line number Diff line change
Expand Up @@ -61,74 +61,107 @@ 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
bs = append(bs, byte('N'))
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)

Expand All @@ -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)
Expand Down
32 changes: 32 additions & 0 deletions protocol/dubbo/impl/hessian_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -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{
Expand Down
6 changes: 4 additions & 2 deletions protocol/grpc/grpc_invoker.go
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
Loading
Loading