You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@dubbo.apache.org by dm...@apache.org on 2024/01/11 06:18:30 UTC
(dubbo-go) branch main updated: Refactor: Remove unnecessary dependency on dubbogo/grpc-go (#2573)
This is an automated email from the ASF dual-hosted git repository.
dmwangnima pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/dubbo-go.git
The following commit(s) were added to refs/heads/main by this push:
new eeab1e947 Refactor: Remove unnecessary dependency on dubbogo/grpc-go (#2573)
eeab1e947 is described below
commit eeab1e947236cddf955fe6e0fe1aa5e686af7f05
Author: Shikhar Soni <13...@users.noreply.github.com>
AuthorDate: Thu Jan 11 11:48:26 2024 +0530
Refactor: Remove unnecessary dependency on dubbogo/grpc-go (#2573)
* [triple_protocol]feat: add interoperability package
Signed-off-by: Shikhar Soni <sh...@gmail.com>
* [triple_protocol]feat: remove dependency from dubbogo/grpc-go in codec.go
Signed-off-by: Shikhar Soni <sh...@gmail.com>
* [triple_protocol]fix protoc error
Signed-off-by: Shikhar Soni <sh...@gmail.com>
* [triple_protocol]make functions private
Signed-off-by: Shikhar Soni <sh...@gmail.com>
* [triple_protocol] better protoc configuration
Signed-off-by: Shikhar Soni <sh...@gmail.com>
* refactor:format code
Signed-off-by: Shikhar Soni <sh...@gmail.com>
---------
Signed-off-by: Shikhar Soni <sh...@gmail.com>
---
protocol/triple/triple_protocol/codec.go | 205 +++++++++++++++-
.../interoperability/interop.triple_wrapper.pb.go | 269 +++++++++++++++++++++
.../interoperability/interop.triple_wrapper.proto | 35 +++
3 files changed, 502 insertions(+), 7 deletions(-)
diff --git a/protocol/triple/triple_protocol/codec.go b/protocol/triple/triple_protocol/codec.go
index ff131f6c3..84ab75c65 100644
--- a/protocol/triple/triple_protocol/codec.go
+++ b/protocol/triple/triple_protocol/codec.go
@@ -16,13 +16,14 @@ package triple_protocol
import (
"bytes"
+ "dubbo.apache.org/dubbo-go/v3/protocol/triple/triple_protocol/internal/interoperability"
"encoding/json"
"errors"
"fmt"
hessian "github.com/apache/dubbo-go-hessian2"
- "github.com/dubbogo/grpc-go/encoding"
- "github.com/dubbogo/grpc-go/encoding/proto_wrapper_api"
- "github.com/dubbogo/grpc-go/encoding/tools"
+ perrors "github.com/pkg/errors"
+ "reflect"
+ "time"
)
import (
@@ -204,10 +205,10 @@ func (c *protoWrapperCodec) Marshal(message interface{}) ([]byte, error) {
return nil, err
}
reqsBytes[i] = reqBytes
- reqsTypes[i] = encoding.GetArgType(req)
+ reqsTypes[i] = getArgType(req)
}
- wrapperReq := &proto_wrapper_api.TripleRequestWrapper{
+ wrapperReq := &interoperability.TripleRequestWrapper{
SerializeType: c.innerCodec.Name(),
Args: reqsBytes,
ArgTypes: reqsTypes,
@@ -222,7 +223,7 @@ func (c *protoWrapperCodec) Unmarshal(binary []byte, message interface{}) error
return c.innerCodec.Unmarshal(binary, message)
}
- var wrapperReq proto_wrapper_api.TripleRequestWrapper
+ var wrapperReq interoperability.TripleRequestWrapper
if err := proto.Unmarshal(binary, &wrapperReq); err != nil {
return err
}
@@ -265,7 +266,7 @@ func (c *hessian2Codec) Unmarshal(binary []byte, message interface{}) error {
if err != nil {
return err
}
- return tools.ReflectResponse(val, message)
+ return reflectResponse(val, message)
}
// todo(DMwangnima): add unit tests
@@ -337,3 +338,193 @@ func errNotProto(message interface{}) error {
}
return fmt.Errorf("%T doesn't implement proto.Message", message)
}
+
+// Definitions from dubbogo/grpc-go
+func getArgType(v interface{}) string {
+ if v == nil {
+ return "V"
+ }
+
+ switch v.(type) {
+ // Serialized tags for base types
+ case nil:
+ return "V"
+ case bool:
+ return "boolean"
+ case []bool:
+ return "[Z"
+ case byte:
+ return "byte"
+ case []byte:
+ return "[B"
+ case int8:
+ return "byte"
+ case []int8:
+ return "[B"
+ case int16:
+ return "short"
+ case []int16:
+ return "[S"
+ case uint16: // Equivalent to Char of Java
+ return "char"
+ case []uint16:
+ return "[C"
+ case int: // Equivalent to Long of Java
+ return "long"
+ case []int:
+ return "[J"
+ case int32:
+ return "int"
+ case []int32:
+ return "[I"
+ case int64:
+ return "long"
+ case []int64:
+ return "[J"
+ case time.Time:
+ return "java.util.Date"
+ case []time.Time:
+ return "[Ljava.util.Date"
+ case float32:
+ return "float"
+ case []float32:
+ return "[F"
+ case float64:
+ return "double"
+ case []float64:
+ return "[D"
+ case string:
+ return "java.lang.String"
+ case []string:
+ return "[Ljava.lang.String;"
+ case []hessian.Object:
+ return "[Ljava.lang.Object;"
+ case map[interface{}]interface{}:
+ // return "java.util.HashMap"
+ return "java.util.Map"
+ case hessian.POJOEnum:
+ return v.(hessian.POJOEnum).JavaClassName()
+ // Serialized tags for complex types
+ default:
+ t := reflect.TypeOf(v)
+ if reflect.Ptr == t.Kind() {
+ t = t.Elem()
+ }
+ switch t.Kind() {
+ case reflect.Struct:
+ v, ok := v.(hessian.POJO)
+ if ok {
+ return v.JavaClassName()
+ }
+ return "java.lang.Object"
+ case reflect.Slice, reflect.Array:
+ if t.Elem().Kind() == reflect.Struct {
+ return "[Ljava.lang.Object;"
+ }
+ // return "java.util.ArrayList"
+ return "java.util.List"
+ case reflect.Map: // Enter here, map may be map[string]int
+ return "java.util.Map"
+ default:
+ return ""
+ }
+ }
+}
+
+func reflectResponse(in interface{}, out interface{}) error {
+ if in == nil {
+ return perrors.Errorf("@in is nil")
+ }
+
+ if out == nil {
+ return perrors.Errorf("@out is nil")
+ }
+ if reflect.TypeOf(out).Kind() != reflect.Ptr {
+ return perrors.Errorf("@out should be a pointer")
+ }
+
+ inValue := hessian.EnsurePackValue(in)
+ outValue := hessian.EnsurePackValue(out)
+
+ outType := outValue.Type().String()
+ if outType == "interface {}" || outType == "*interface {}" {
+ hessian.SetValue(outValue, inValue)
+ return nil
+ }
+
+ switch inValue.Type().Kind() {
+ case reflect.Slice, reflect.Array:
+ return copySlice(inValue, outValue)
+ case reflect.Map:
+ return copyMap(inValue, outValue)
+ default:
+ hessian.SetValue(outValue, inValue)
+ }
+
+ return nil
+}
+
+// copySlice copy from inSlice to outSlice
+func copySlice(inSlice, outSlice reflect.Value) error {
+ if inSlice.IsNil() {
+ return perrors.New("@in is nil")
+ }
+ if inSlice.Kind() != reflect.Slice {
+ return perrors.Errorf("@in is not slice, but %v", inSlice.Kind())
+ }
+
+ for outSlice.Kind() == reflect.Ptr {
+ outSlice = outSlice.Elem()
+ }
+
+ size := inSlice.Len()
+ outSlice.Set(reflect.MakeSlice(outSlice.Type(), size, size))
+
+ for i := 0; i < size; i++ {
+ inSliceValue := inSlice.Index(i)
+ if !inSliceValue.Type().AssignableTo(outSlice.Index(i).Type()) {
+ return perrors.Errorf("in element type [%s] can not assign to out element type [%s]",
+ inSliceValue.Type().String(), outSlice.Type().String())
+ }
+ outSlice.Index(i).Set(inSliceValue)
+ }
+
+ return nil
+}
+
+// copyMap copy from in map to out map
+func copyMap(inMapValue, outMapValue reflect.Value) error {
+ if inMapValue.IsNil() {
+ return perrors.New("@in is nil")
+ }
+ if !inMapValue.CanInterface() {
+ return perrors.New("@in's Interface can not be used.")
+ }
+ if inMapValue.Kind() != reflect.Map {
+ return perrors.Errorf("@in is not map, but %v", inMapValue.Kind())
+ }
+
+ outMapType := hessian.UnpackPtrType(outMapValue.Type())
+ hessian.SetValue(outMapValue, reflect.MakeMap(outMapType))
+
+ outKeyType := outMapType.Key()
+
+ outMapValue = hessian.UnpackPtrValue(outMapValue)
+ outValueType := outMapValue.Type().Elem()
+
+ for _, inKey := range inMapValue.MapKeys() {
+ inValue := inMapValue.MapIndex(inKey)
+
+ if !inKey.Type().AssignableTo(outKeyType) {
+ return perrors.Errorf("in Key:{type:%s, value:%#v} can not assign to out Key:{type:%s} ",
+ inKey.Type().String(), inKey, outKeyType.String())
+ }
+ if !inValue.Type().AssignableTo(outValueType) {
+ return perrors.Errorf("in Value:{type:%s, value:%#v} can not assign to out value:{type:%s}",
+ inValue.Type().String(), inValue, outValueType.String())
+ }
+ outMapValue.SetMapIndex(inKey, inValue)
+ }
+
+ return nil
+}
diff --git a/protocol/triple/triple_protocol/internal/interoperability/interop.triple_wrapper.pb.go b/protocol/triple/triple_protocol/internal/interoperability/interop.triple_wrapper.pb.go
new file mode 100644
index 000000000..20f441d07
--- /dev/null
+++ b/protocol/triple/triple_protocol/internal/interoperability/interop.triple_wrapper.pb.go
@@ -0,0 +1,269 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.32.0
+// protoc v3.20.3
+// source: interop.triple_wrapper.proto
+
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package interoperability
+
+import (
+ protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+ protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+ reflect "reflect"
+ sync "sync"
+)
+
+const (
+ // Verify that this generated code is sufficiently up-to-date.
+ _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+ // Verify that runtime/protoimpl is sufficiently up-to-date.
+ _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type TripleRequestWrapper struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ // hessian4
+ // json
+ SerializeType string `protobuf:"bytes,1,opt,name=serializeType,proto3" json:"serializeType,omitempty"`
+ Args [][]byte `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
+ ArgTypes []string `protobuf:"bytes,3,rep,name=argTypes,proto3" json:"argTypes,omitempty"`
+}
+
+func (x *TripleRequestWrapper) Reset() {
+ *x = TripleRequestWrapper{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_interop_triple_wrapper_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *TripleRequestWrapper) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TripleRequestWrapper) ProtoMessage() {}
+
+func (x *TripleRequestWrapper) ProtoReflect() protoreflect.Message {
+ mi := &file_interop_triple_wrapper_proto_msgTypes[0]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use TripleRequestWrapper.ProtoReflect.Descriptor instead.
+func (*TripleRequestWrapper) Descriptor() ([]byte, []int) {
+ return file_interop_triple_wrapper_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *TripleRequestWrapper) GetSerializeType() string {
+ if x != nil {
+ return x.SerializeType
+ }
+ return ""
+}
+
+func (x *TripleRequestWrapper) GetArgs() [][]byte {
+ if x != nil {
+ return x.Args
+ }
+ return nil
+}
+
+func (x *TripleRequestWrapper) GetArgTypes() []string {
+ if x != nil {
+ return x.ArgTypes
+ }
+ return nil
+}
+
+type TripleResponseWrapper struct {
+ state protoimpl.MessageState
+ sizeCache protoimpl.SizeCache
+ unknownFields protoimpl.UnknownFields
+
+ SerializeType string `protobuf:"bytes,1,opt,name=serializeType,proto3" json:"serializeType,omitempty"`
+ Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+ Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
+}
+
+func (x *TripleResponseWrapper) Reset() {
+ *x = TripleResponseWrapper{}
+ if protoimpl.UnsafeEnabled {
+ mi := &file_interop_triple_wrapper_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+ }
+}
+
+func (x *TripleResponseWrapper) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TripleResponseWrapper) ProtoMessage() {}
+
+func (x *TripleResponseWrapper) ProtoReflect() protoreflect.Message {
+ mi := &file_interop_triple_wrapper_proto_msgTypes[1]
+ if protoimpl.UnsafeEnabled && x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use TripleResponseWrapper.ProtoReflect.Descriptor instead.
+func (*TripleResponseWrapper) Descriptor() ([]byte, []int) {
+ return file_interop_triple_wrapper_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *TripleResponseWrapper) GetSerializeType() string {
+ if x != nil {
+ return x.SerializeType
+ }
+ return ""
+}
+
+func (x *TripleResponseWrapper) GetData() []byte {
+ if x != nil {
+ return x.Data
+ }
+ return nil
+}
+
+func (x *TripleResponseWrapper) GetType() string {
+ if x != nil {
+ return x.Type
+ }
+ return ""
+}
+
+var File_interop_triple_wrapper_proto protoreflect.FileDescriptor
+
+var file_interop_triple_wrapper_proto_rawDesc = []byte{
+ 0x0a, 0x1c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6f, 0x70, 0x2e, 0x74, 0x72, 0x69, 0x70, 0x6c, 0x65,
+ 0x5f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10,
+ 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
+ 0x22, 0x6c, 0x0a, 0x14, 0x54, 0x72, 0x69, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+ 0x74, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x24, 0x0a, 0x0d, 0x73, 0x65, 0x72, 0x69,
+ 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x0d, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12,
+ 0x0a, 0x04, 0x61, 0x72, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x04, 0x61, 0x72,
+ 0x67, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x61, 0x72, 0x67, 0x54, 0x79, 0x70, 0x65, 0x73, 0x18, 0x03,
+ 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x61, 0x72, 0x67, 0x54, 0x79, 0x70, 0x65, 0x73, 0x22, 0x65,
+ 0x0a, 0x15, 0x54, 0x72, 0x69, 0x70, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+ 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x12, 0x24, 0x0a, 0x0d, 0x73, 0x65, 0x72, 0x69, 0x61,
+ 0x6c, 0x69, 0x7a, 0x65, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d,
+ 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a,
+ 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74,
+ 0x61, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
+ 0x04, 0x74, 0x79, 0x70, 0x65, 0x42, 0x69, 0x5a, 0x67, 0x64, 0x75, 0x62, 0x62, 0x6f, 0x2e, 0x61,
+ 0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x64, 0x75, 0x62, 0x62, 0x6f, 0x2d,
+ 0x67, 0x6f, 0x2f, 0x76, 0x33, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x74,
+ 0x72, 0x69, 0x70, 0x6c, 0x65, 0x2f, 0x74, 0x72, 0x69, 0x70, 0x6c, 0x65, 0x5f, 0x70, 0x72, 0x6f,
+ 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x69,
+ 0x6e, 0x74, 0x65, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x3b,
+ 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
+ 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+ file_interop_triple_wrapper_proto_rawDescOnce sync.Once
+ file_interop_triple_wrapper_proto_rawDescData = file_interop_triple_wrapper_proto_rawDesc
+)
+
+func file_interop_triple_wrapper_proto_rawDescGZIP() []byte {
+ file_interop_triple_wrapper_proto_rawDescOnce.Do(func() {
+ file_interop_triple_wrapper_proto_rawDescData = protoimpl.X.CompressGZIP(file_interop_triple_wrapper_proto_rawDescData)
+ })
+ return file_interop_triple_wrapper_proto_rawDescData
+}
+
+var file_interop_triple_wrapper_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_interop_triple_wrapper_proto_goTypes = []interface{}{
+ (*TripleRequestWrapper)(nil), // 0: interoperability.TripleRequestWrapper
+ (*TripleResponseWrapper)(nil), // 1: interoperability.TripleResponseWrapper
+}
+var file_interop_triple_wrapper_proto_depIdxs = []int32{
+ 0, // [0:0] is the sub-list for method output_type
+ 0, // [0:0] is the sub-list for method input_type
+ 0, // [0:0] is the sub-list for extension type_name
+ 0, // [0:0] is the sub-list for extension extendee
+ 0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_interop_triple_wrapper_proto_init() }
+func file_interop_triple_wrapper_proto_init() {
+ if File_interop_triple_wrapper_proto != nil {
+ return
+ }
+ if !protoimpl.UnsafeEnabled {
+ file_interop_triple_wrapper_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*TripleRequestWrapper); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ file_interop_triple_wrapper_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+ switch v := v.(*TripleResponseWrapper); i {
+ case 0:
+ return &v.state
+ case 1:
+ return &v.sizeCache
+ case 2:
+ return &v.unknownFields
+ default:
+ return nil
+ }
+ }
+ }
+ type x struct{}
+ out := protoimpl.TypeBuilder{
+ File: protoimpl.DescBuilder{
+ GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+ RawDescriptor: file_interop_triple_wrapper_proto_rawDesc,
+ NumEnums: 0,
+ NumMessages: 2,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_interop_triple_wrapper_proto_goTypes,
+ DependencyIndexes: file_interop_triple_wrapper_proto_depIdxs,
+ MessageInfos: file_interop_triple_wrapper_proto_msgTypes,
+ }.Build()
+ File_interop_triple_wrapper_proto = out.File
+ file_interop_triple_wrapper_proto_rawDesc = nil
+ file_interop_triple_wrapper_proto_goTypes = nil
+ file_interop_triple_wrapper_proto_depIdxs = nil
+}
diff --git a/protocol/triple/triple_protocol/internal/interoperability/interop.triple_wrapper.proto b/protocol/triple/triple_protocol/internal/interoperability/interop.triple_wrapper.proto
new file mode 100644
index 000000000..87a58dbb8
--- /dev/null
+++ b/protocol/triple/triple_protocol/internal/interoperability/interop.triple_wrapper.proto
@@ -0,0 +1,35 @@
+syntax = "proto3";
+
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package interoperability;
+
+option go_package = "dubbo.apache.org/dubbo-go/v3/protocol/triple/triple_protocol/internal/interoperability;interoperability";
+
+
+message TripleRequestWrapper {
+ // hessian4
+ // json
+ string serializeType = 1;
+ repeated bytes args = 2;
+ repeated string argTypes = 3;
+}
+
+message TripleResponseWrapper {
+ string serializeType = 1;
+ bytes data = 2;
+ string type = 3;
+}
\ No newline at end of file