Fix: change triple api and add test file

config/config_loader.go

@@ -201,6 +201,9 @@ func loadProviderConfig() {
 	checkRegistries(providerConfig.Registries, providerConfig.Registry)
 
 	for key, svs := range providerConfig.Services {
+		if key == "GrpcGreeterImpl2" {
+			fmt.Println("here")
+		}
 		rpcService := GetProviderService(key)
 		if rpcService == nil {
 			logger.Warnf("%s does not exist!", key)
@@ -208,6 +211,7 @@ func loadProviderConfig() {
 		}
 		svs.id = key
 		svs.Implement(rpcService)
+
 		svs.Protocols = providerConfig.Protocols
 		if err := svs.Export(); err != nil {
 			panic(fmt.Sprintf("service %s export failed! err: %#v", key, err))

go.mod

@@ -13,7 +13,7 @@ require (
 	github.com/creasty/defaults v1.5.1
 	github.com/dubbogo/go-zookeeper v1.0.2
 	github.com/dubbogo/gost v1.11.0
-	github.com/dubbogo/triple v0.0.0-20210314060249-a8daea612f94
+	github.com/dubbogo/triple v0.0.0-20210318020559-4db55a5388a2
 	github.com/emicklei/go-restful/v3 v3.4.0
 	github.com/fsnotify/fsnotify v1.4.9
 	github.com/go-co-op/gocron v0.1.1

go.sum

@@ -255,6 +255,8 @@ github.com/dubbogo/triple v0.0.0-20210301083516-185f5a3b1234 h1:2u3jO/06/Itk5pI1
 github.com/dubbogo/triple v0.0.0-20210301083516-185f5a3b1234/go.mod h1:v1szRcUO/P3lbe2NveWHBLsI4d3fF9tVCg5f8CB3WE8=
 github.com/dubbogo/triple v0.0.0-20210314060249-a8daea612f94 h1:njPcvq1+x/RMMKjE62R+G3cJQ7hlka64A5aOioGIBMA=
 github.com/dubbogo/triple v0.0.0-20210314060249-a8daea612f94/go.mod h1:/jrqKfnQRjI91dFT3cgUuDkG3AuFPTTMOya6RdCiVcE=
+github.com/dubbogo/triple v0.0.0-20210318020559-4db55a5388a2 h1:1kHGnzCr5E97Y9fW0G2jg4yXktAe1l0zo2aUthR5gvI=
+github.com/dubbogo/triple v0.0.0-20210318020559-4db55a5388a2/go.mod h1:xNXaE2KrRrZfHSaS6ipvMyREzV/LyGeHdjXa9wbTS7Y=
 github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=

protocol/dubbo3/common_test.go

+/*
+ * 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 dubbo3
+
+import (
+	"context"
+	"fmt"
+)
+
+import (
+	triCommon "github.com/dubbogo/triple/pkg/common"
+	native_grpc "google.golang.org/grpc"
+)
+
+import (
+	"github.com/apache/dubbo-go/config"
+	"github.com/apache/dubbo-go/protocol"
+	"github.com/apache/dubbo-go/protocol/dubbo3/internal"
+	"github.com/apache/dubbo-go/protocol/invocation"
+)
+
+// userd dubbo3 biz service
+func addService() {
+	config.SetProviderService(newGreeterProvider())
+}
+
+type greeterProvider struct {
+	*greeterProviderBase
+}
+
+func newGreeterProvider() *greeterProvider {
+	return &greeterProvider{
+		greeterProviderBase: &greeterProviderBase{},
+	}
+}
+
+func (g *greeterProvider) SayHello(ctx context.Context, req *internal.HelloRequest) (reply *internal.HelloReply, err error) {
+	fmt.Printf("req: %v", req)
+	return &internal.HelloReply{Message: "this is message from reply"}, nil
+}
+
+func (g *greeterProvider) Reference() string {
+	return "DubboGreeterImpl"
+}
+
+// code generated by greeter.go
+type greeterProviderBase struct {
+	proxyImpl protocol.Invoker
+}
+
+func (g *greeterProviderBase) SetProxyImpl(impl protocol.Invoker) {
+	g.proxyImpl = impl
+}
+
+func (g *greeterProviderBase) GetProxyImpl() protocol.Invoker {
+	return g.proxyImpl
+}
+
+func (g *greeterProviderBase) ServiceDesc() *native_grpc.ServiceDesc {
+	return &native_grpc.ServiceDesc{
+		ServiceName: "helloworld.Greeter",
+		HandlerType: (*internal.GreeterServer)(nil),
+		Methods: []native_grpc.MethodDesc{
+			{
+				MethodName: "SayHello",
+				Handler:    dubboGreeterSayHelloHandler,
+			},
+		},
+		Streams:  []native_grpc.StreamDesc{},
+		Metadata: "helloworld.proto",
+	}
+}
+
+func dubboGreeterSayHelloHandler(srv interface{}, ctx context.Context,
+	dec func(interface{}) error, interceptor native_grpc.UnaryServerInterceptor) (interface{}, error) {
+
+	in := new(internal.HelloRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	base := srv.(triCommon.Dubbo3GrpcService)
+
+	args := []interface{}{}
+	args = append(args, in)
+	invo := invocation.NewRPCInvocation("SayHello", args, nil)
+
+	if interceptor == nil {
+		result := base.GetProxyImpl().Invoke(context.Background(), invo)
+		return result.Result(), result.Error()
+	}
+	info := &native_grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/helloworld.Greeter/SayHello",
+	}
+	handler := func(context.Context, interface{}) (interface{}, error) {
+		result := base.GetProxyImpl().Invoke(context.Background(), invo)
+		return result.Result(), result.Error()
+	}
+	return interceptor(ctx, in, info, handler)
+}

protocol/dubbo3/dubbo3_exporter.go

@@ -21,6 +21,10 @@ import (
 	"sync"
 )
 
+import (
+	tripleCommon "github.com/dubbogo/triple/pkg/common"
+)
+
 import (
 	"github.com/apache/dubbo-go/common"
 	"github.com/apache/dubbo-go/common/constant"
@@ -31,12 +35,15 @@ import (
 // DubboExporter is dubbo3 service exporter.
 type DubboExporter struct {
 	protocol.BaseExporter
+	// serviceMap
+	serviceMap *sync.Map
 }
 
 // NewDubboExporter get a Dubbo3Exporter.
-func NewDubboExporter(key string, invoker protocol.Invoker, exporterMap *sync.Map) *DubboExporter {
+func NewDubboExporter(key string, invoker protocol.Invoker, exporterMap *sync.Map, serviceMap *sync.Map) *DubboExporter {
 	return &DubboExporter{
 		BaseExporter: *protocol.NewBaseExporter(key, invoker, exporterMap),
+		serviceMap:   serviceMap,
 	}
 }
 
@@ -46,8 +53,9 @@ func (de *DubboExporter) Unexport() {
 	serviceId := url.GetParam(constant.BEAN_NAME_KEY, "")
 	interfaceName := url.GetParam(constant.INTERFACE_KEY, "")
 	de.BaseExporter.Unexport()
-	err := common.ServiceMap.UnRegister(interfaceName, DUBBO3, serviceId)
+	err := common.ServiceMap.UnRegister(interfaceName, tripleCommon.TRIPLE, serviceId)
 	if err != nil {
 		logger.Errorf("[DubboExporter.Unexport] error: %v", err)
 	}
+	de.serviceMap.Delete(interfaceName)
 }

protocol/dubbo3/dubbo3_invoker.go

@@ -19,7 +19,6 @@ package dubbo3
 
 import (
 	"context"
-	"github.com/apache/dubbo-go/common/logger"
 	"reflect"
 	"strconv"
 	"strings"
@@ -29,12 +28,14 @@ import (
 
 import (
 	hessian2 "github.com/apache/dubbo-go-hessian2"
-	dubbo3 "github.com/dubbogo/triple/pkg/triple"
+	triConfig "github.com/dubbogo/triple/pkg/config"
+	"github.com/dubbogo/triple/pkg/triple"
 )
 
 import (
 	"github.com/apache/dubbo-go/common"
 	"github.com/apache/dubbo-go/common/constant"
+	"github.com/apache/dubbo-go/common/logger"
 	"github.com/apache/dubbo-go/config"
 	"github.com/apache/dubbo-go/protocol"
 	invocation_impl "github.com/apache/dubbo-go/protocol/invocation"
@@ -44,7 +45,7 @@ import (
 type DubboInvoker struct {
 	protocol.BaseInvoker
 	// the net layer client, it is focus on network communication.
-	client *dubbo3.TripleClient
+	client *triple.TripleClient
 	// quitOnce is used to make sure DubboInvoker is only destroyed once
 	quitOnce sync.Once
 	// timeout for service(interface) level.
@@ -63,7 +64,13 @@ func NewDubboInvoker(url *common.URL) (*DubboInvoker, error) {
 
 	key := url.GetParam(constant.BEAN_NAME_KEY, "")
 	consumerService := config.GetConsumerService(key)
-	client, err := dubbo3.NewTripleClient(url, consumerService)
+
+	// new triple client
+	triOption := triConfig.NewTripleOption(
+		triConfig.WithClientTimeout(uint32(requestTimeout.Seconds())),
+	)
+	client, err := triple.NewTripleClient(url, consumerService, triOption)
+
 	if err != nil {
 		return nil, err
 	}
@@ -76,14 +83,14 @@ func NewDubboInvoker(url *common.URL) (*DubboInvoker, error) {
 	}, nil
 }
 
-func (di *DubboInvoker) setClient(client *dubbo3.TripleClient) {
+func (di *DubboInvoker) setClient(client *triple.TripleClient) {
 	di.clientGuard.Lock()
 	defer di.clientGuard.Unlock()
 
 	di.client = client
 }
 
-func (di *DubboInvoker) getClient() *dubbo3.TripleClient {
+func (di *DubboInvoker) getClient() *triple.TripleClient {
 	di.clientGuard.RLock()
 	defer di.clientGuard.RUnlock()
 
@@ -120,14 +127,20 @@ func (di *DubboInvoker) Invoke(ctx context.Context, invocation protocol.Invocati
 		return &result
 	}
 
+	// append interface id to ctx
+	interfaceKey := constant.INTERFACE_KEY
+	ctx = context.WithValue(ctx, interfaceKey, di.BaseInvoker.GetUrl().GetParam(constant.INTERFACE_KEY, ""))
 	in := make([]reflect.Value, 0, 16)
 	in = append(in, reflect.ValueOf(ctx))
+
 	if len(invocation.ParameterValues()) > 0 {
 		in = append(in, invocation.ParameterValues()...)
 	}
 
 	methodName := invocation.MethodName()
 	method := di.client.Invoker.MethodByName(methodName)
+
+	// call function in pb.go
 	res := method.Call(in)
 
 	result.Rest = res[0]

protocol/dubbo3/dubbo3_invoker_test.go

+/*
+ * 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 dubbo3
+
+import (
+	"context"
+	"reflect"
+	"testing"
+	"time"
+)
+
+import (
+	"github.com/stretchr/testify/assert"
+)
+
+import (
+	"github.com/apache/dubbo-go/common"
+	"github.com/apache/dubbo-go/protocol/dubbo3/internal"
+	"github.com/apache/dubbo-go/protocol/invocation"
+)
+
+func TestInvoke(t *testing.T) {
+	go internal.InitDubboServer()
+	time.Sleep(time.Second * 3)
+
+	url, err := common.NewURL(mockDubbo3CommonUrl)
+	assert.Nil(t, err)
+
+	invoker, err := NewDubboInvoker(url)
+
+	assert.Nil(t, err)
+
+	args := []reflect.Value{}
+	args = append(args, reflect.ValueOf(&internal.HelloRequest{Name: "request name"}))
+	bizReply := &internal.HelloReply{}
+	invo := invocation.NewRPCInvocationWithOptions(invocation.WithMethodName("SayHello"),
+		invocation.WithParameterValues(args), invocation.WithReply(bizReply))
+	res := invoker.Invoke(context.Background(), invo)
+	assert.Nil(t, res.Error())
+	assert.NotNil(t, res.Result())
+	assert.Equal(t, "Hello request name", bizReply.Message)
+}

protocol/dubbo3/dubbo3_protocol.go

@@ -18,13 +18,13 @@ package dubbo3
 
 import (
 	"fmt"
-	tripleCommon "github.com/dubbogo/triple/pkg/common"
 	"reflect"
 	"sync"
 )
 
 import (
-	dubbo3 "github.com/dubbogo/triple/pkg/triple"
+	tripleCommon "github.com/dubbogo/triple/pkg/common"
+	"github.com/dubbogo/triple/pkg/triple"
 	"google.golang.org/grpc"
 )
 
@@ -37,15 +37,10 @@ import (
 	"github.com/apache/dubbo-go/protocol"
 )
 
-const (
-	// DUBBO3 is dubbo3 protocol name
-	DUBBO3 = "dubbo3"
-)
-
 var protocolOnce sync.Once
 
 func init() {
-	extension.SetProtocol(DUBBO3, GetProtocol)
+	extension.SetProtocol(tripleCommon.TRIPLE, GetProtocol)
 	protocolOnce = sync.Once{}
 }
 
@@ -57,14 +52,16 @@ var (
 type DubboProtocol struct {
 	protocol.BaseProtocol
 	serverLock sync.Mutex
-	serverMap  map[string]*dubbo3.TripleServer // It is store relationship about serviceKey(group/interface:version) and ExchangeServer
+	serviceMap *sync.Map                       // is used to export multiple service by one server
+	serverMap  map[string]*triple.TripleServer // It is store relationship about serviceKey(group/interface:version) and ExchangeServer
 }
 
 // NewDubboProtocol create a dubbo protocol.
 func NewDubboProtocol() *DubboProtocol {
 	return &DubboProtocol{
 		BaseProtocol: protocol.NewBaseProtocol(),
-		serverMap:    make(map[string]*dubbo3.TripleServer),
+		serverMap:    make(map[string]*triple.TripleServer),
+		serviceMap:   &sync.Map{},
 	}
 }
 
@@ -72,11 +69,29 @@ func NewDubboProtocol() *DubboProtocol {
 func (dp *DubboProtocol) Export(invoker protocol.Invoker) protocol.Exporter {
 	url := invoker.GetUrl()
 	serviceKey := url.ServiceKey()
-	exporter := NewDubboExporter(serviceKey, invoker, dp.ExporterMap())
+	exporter := NewDubboExporter(serviceKey, invoker, dp.ExporterMap(), dp.serviceMap)
 	dp.SetExporterMap(serviceKey, exporter)
 	logger.Infof("Export service: %s", url.String())
-	// start server
 
+	key := url.GetParam(constant.BEAN_NAME_KEY, "")
+	service := config.GetProviderService(key)
+
+	m, ok := reflect.TypeOf(service).MethodByName("SetProxyImpl")
+	if !ok {
+		panic("method SetProxyImpl is necessary for triple service")
+	}
+
+	if invoker == nil {
+		panic(fmt.Sprintf("no invoker found for servicekey: %v", url.ServiceKey()))
+	}
+
+	in := []reflect.Value{reflect.ValueOf(service)}
+	in = append(in, reflect.ValueOf(invoker))
+	m.Func.Call(in)
+
+	dp.serviceMap.Store(url.GetParam(constant.INTERFACE_KEY, ""), service)
+
+	// try start server
 	dp.openServer(url)
 	return exporter
 }
@@ -114,7 +129,7 @@ type Dubbo3GrpcService interface {
 	ServiceDesc() *grpc.ServiceDesc
 }
 
-// openServer open a dubbo3 server
+// openServer open a dubbo3 server, if there is already a service using the same protocol, it returns directly.
 func (dp *DubboProtocol) openServer(url *common.URL) {
 	_, ok := dp.serverMap[url.Location]
 	if ok {
@@ -131,29 +146,8 @@ func (dp *DubboProtocol) openServer(url *common.URL) {
 	if ok {
 		return
 	}
-	key := url.GetParam(constant.BEAN_NAME_KEY, "")
-	service := config.GetProviderService(key)
-
-	m, ok := reflect.TypeOf(service).MethodByName("SetProxyImpl")
-	if !ok {
-		panic("method SetProxyImpl is necessary for grpc service")
-	}
-
-	exporter, _ := dubboProtocol.ExporterMap().Load(url.ServiceKey())
-	if exporter == nil {
-		panic(fmt.Sprintf("no exporter found for servicekey: %v", url.ServiceKey()))
-	}
-	invoker := exporter.(protocol.Exporter).GetInvoker()
-	if invoker == nil {
-		panic(fmt.Sprintf("no invoker found for servicekey: %v", url.ServiceKey()))
-	}
-
-	in := []reflect.Value{reflect.ValueOf(service)}
-	in = append(in, reflect.ValueOf(invoker))
-	m.Func.Call(in)
-
-	srv := dubbo3.NewTripleServer(url, service.(tripleCommon.Dubbo3GrpcService))
 
+	srv := triple.NewTripleServer(url, dp.serviceMap, nil)
 	dp.serverMap[url.Location] = srv
 
 	srv.Start()

protocol/dubbo3/dubbo3_protocol_test.go

+package dubbo3
+
+import (
+	"testing"
+	"time"
+)
+
+import (
+	"github.com/stretchr/testify/assert"
+)
+
+import (
+	"github.com/apache/dubbo-go/common"
+	"github.com/apache/dubbo-go/protocol"
+)
+
+const (
+	mockDubbo3CommonUrl = "tri://127.0.0.1:30000/DubboGreeterImpl?accesslog=&anyhost=true&app.version=0.0.1&application=BDTService&async=false&bean.name=DubboGreeterImpl" +
+		"&category=providers&cluster=failover&dubbo=dubbo-provider-golang-2.6.0&environment=dev&execute.limit=&execute.limit.rejected.handler=&generic=false&group=&interface=org.apache.dubbo.DubboGreeterImpl" +
+		"&ip=192.168.1.106&loadbalance=random&methods.SayHello.loadbalance=random&methods.SayHello.retries=1&methods.SayHello.tps.limit.interval=&methods.SayHello.tps.limit.rate=&methods.SayHello.tps.limit.strategy=" +
+		"&methods.SayHello.weight=0&module=dubbogo+say-hello+client&name=BDTService&organization=ikurento.com&owner=ZX&pid=49427&reference.filter=cshutdown&registry.role=3&remote.timestamp=1576923717&retries=" +
+		"&service.filter=echo%2Ctoken%2Caccesslog%2Ctps%2Cexecute%2Cpshutdown&side=provider&timestamp=1576923740&tps.limit.interval=&tps.limit.rate=&tps.limit.rejected.handler=&tps.limit.strategy=&tps.limiter=&version=&warmup=100!"
+)
+
+func TestDubboProtocolExport(t *testing.T) {
+	// Export
+	addService()
+
+	proto := GetProtocol()
+	url, err := common.NewURL(mockDubbo3CommonUrl)
+	assert.NoError(t, err)
+	exporter := proto.Export(protocol.NewBaseInvoker(url))
+	time.Sleep(time.Second)
+
+	// make sure url
+	eq := exporter.GetInvoker().GetUrl().URLEqual(url)
+	assert.True(t, eq)
+
+	// make sure exporterMap after 'Unexport'
+	_, ok := proto.(*DubboProtocol).ExporterMap().Load(url.ServiceKey())
+	assert.True(t, ok)
+	exporter.Unexport()
+	_, ok = proto.(*DubboProtocol).ExporterMap().Load(url.ServiceKey())
+	assert.False(t, ok)
+
+	// make sure serverMap after 'Destroy'
+	_, ok = proto.(*DubboProtocol).serverMap[url.Location]
+	assert.True(t, ok)
+	proto.Destroy()
+	_, ok = proto.(*DubboProtocol).serverMap[url.Location]
+	assert.False(t, ok)
+}
+
+func TestDubboProtocolRefer(t *testing.T) {
+	proto := GetProtocol()
+	url, err := common.NewURL(mockDubbo3CommonUrl)
+	assert.NoError(t, err)
+	invoker := proto.Refer(url)
+
+	// make sure url
+	eq := invoker.GetUrl().URLEqual(url)
+	assert.True(t, eq)
+
+	// make sure invokers after 'Destroy'
+	invokersLen := len(proto.(*DubboProtocol).Invokers())
+	assert.Equal(t, 1, invokersLen)
+	proto.Destroy()
+	invokersLen = len(proto.(*DubboProtocol).Invokers())
+	assert.Equal(t, 0, invokersLen)
+}

protocol/dubbo3/internal/client.go

+/*
+ * 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 internal
+
+import (
+	"context"
+	"github.com/apache/dubbo-go/config"
+	"github.com/dubbogo/triple/pkg/triple"
+)
+
+func init() {
+	config.SetConsumerService(&GrpcGreeterImpl{})
+}
+
+// GrpcGreeterImpl
+//used for dubbo3 biz client
+type GrpcGreeterImpl struct {
+	SayHello func(ctx context.Context, in *HelloRequest, out *HelloReply) error
+}
+
+// Reference ...
+func (u *GrpcGreeterImpl) Reference() string {
+	return "DubboGreeterImpl"
+}
+
+// GetDubboStub ...
+func (u *GrpcGreeterImpl) GetDubboStub(cc *triple.TripleConn) GreeterClient {
+	return NewGreeterDubbo3Client(cc)
+}

protocol/dubbo3/internal/helloworld.pb.go

+/*
+ * 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.
+ */
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: helloworld.proto
+
+package internal
+
+import (
+	context "context"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	math "math"
+)
+
+import (
+	dubboConstant "github.com/apache/dubbo-go/common/constant"
+	"github.com/apache/dubbo-go/protocol"
+	dgrpc "github.com/apache/dubbo-go/protocol/grpc"
+	"github.com/apache/dubbo-go/protocol/invocation"
+	dubbo3 "github.com/dubbogo/triple/pkg/triple"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+// The request message containing the user's name.
+type HelloRequest struct {
+	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *HelloRequest) Reset()         { *m = HelloRequest{} }
+func (m *HelloRequest) String() string { return proto.CompactTextString(m) }
+func (*HelloRequest) ProtoMessage()    {}
+func (*HelloRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_17b8c58d586b62f2, []int{0}
+}
+
+func (m *HelloRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_HelloRequest.Unmarshal(m, b)
+}
+func (m *HelloRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_HelloRequest.Marshal(b, m, deterministic)
+}
+func (m *HelloRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_HelloRequest.Merge(m, src)
+}
+func (m *HelloRequest) XXX_Size() int {
+	return xxx_messageInfo_HelloRequest.Size(m)
+}
+func (m *HelloRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_HelloRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_HelloRequest proto.InternalMessageInfo
+
+func (m *HelloRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+// The response message containing the greetings
+type HelloReply struct {
+	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *HelloReply) Reset()         { *m = HelloReply{} }
+func (m *HelloReply) String() string { return proto.CompactTextString(m) }
+func (*HelloReply) ProtoMessage()    {}
+func (*HelloReply) Descriptor() ([]byte, []int) {
+	return fileDescriptor_17b8c58d586b62f2, []int{1}
+}
+
+func (m *HelloReply) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_HelloReply.Unmarshal(m, b)
+}
+func (m *HelloReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_HelloReply.Marshal(b, m, deterministic)
+}
+func (m *HelloReply) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_HelloReply.Merge(m, src)
+}
+func (m *HelloReply) XXX_Size() int {
+	return xxx_messageInfo_HelloReply.Size(m)
+}
+func (m *HelloReply) XXX_DiscardUnknown() {
+	xxx_messageInfo_HelloReply.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_HelloReply proto.InternalMessageInfo
+
+func (m *HelloReply) GetMessage() string {
+	if m != nil {
+		return m.Message
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*HelloRequest)(nil), "internal.HelloRequest")
+	proto.RegisterType((*HelloReply)(nil), "internal.HelloReply")
+}
+
+func init() { proto.RegisterFile("helloworld.proto", fileDescriptor_17b8c58d586b62f2) }
+
+var fileDescriptor_17b8c58d586b62f2 = []byte{
+	// 189 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xc8, 0x48, 0xcd, 0xc9,
+	0xc9, 0x2f, 0xcf, 0x2f, 0xca, 0x49, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0xc8, 0xcc,
+	0x2b, 0x49, 0x2d, 0xca, 0x4b, 0xcc, 0x51, 0x52, 0xe2, 0xe2, 0xf1, 0x00, 0xc9, 0x06, 0xa5, 0x16,
+	0x96, 0xa6, 0x16, 0x97, 0x08, 0x09, 0x71, 0xb1, 0xe4, 0x25, 0xe6, 0xa6, 0x4a, 0x30, 0x2a, 0x30,
+	0x6a, 0x70, 0x06, 0x81, 0xd9, 0x4a, 0x6a, 0x5c, 0x5c, 0x50, 0x35, 0x05, 0x39, 0x95, 0x42, 0x12,
+	0x5c, 0xec, 0xb9, 0xa9, 0xc5, 0xc5, 0x89, 0xe9, 0x30, 0x45, 0x30, 0xae, 0x91, 0x2b, 0x17, 0xbb,
+	0x7b, 0x51, 0x6a, 0x6a, 0x49, 0x6a, 0x91, 0x90, 0x15, 0x17, 0x47, 0x70, 0x62, 0x25, 0x58, 0x97,
+	0x90, 0x98, 0x1e, 0xcc, 0x36, 0x3d, 0x64, 0xab, 0xa4, 0x44, 0x30, 0xc4, 0x0b, 0x72, 0x2a, 0x95,
+	0x18, 0x9c, 0xcc, 0xb8, 0xa4, 0x33, 0xf3, 0xf5, 0xd2, 0x8b, 0x0a, 0x92, 0xf5, 0x52, 0x2b, 0x12,
+	0x73, 0x0b, 0x72, 0x52, 0x8b, 0xf5, 0x10, 0x3e, 0x70, 0xe2, 0x07, 0x2b, 0x0e, 0x07, 0xb1, 0x03,
+	0x40, 0x9e, 0x09, 0x60, 0x5c, 0xc4, 0xc4, 0xec, 0xe1, 0x13, 0x9e, 0xc4, 0x06, 0xf6, 0x9b, 0x31,
+	0x20, 0x00, 0x00, 0xff, 0xff, 0xc4, 0x20, 0xe8, 0xd3, 0xef, 0x00, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+
+// GreeterClient is the client API for Greeter service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type GreeterClient interface {
+	// Sends a greeting
+	SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
+}
+
+type greeterClient struct {
+	cc grpc.ClientConn
+}
+
+func NewGreeterClient(cc grpc.ClientConn) GreeterClient {
+	return &greeterClient{cc}
+}
+
+func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
+	out := new(HelloReply)
+	err := c.cc.Invoke(ctx, "/internal.Greeter/SayHello", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// GreeterServer is the server API for Greeter service.
+type GreeterServer interface {
+	// Sends a greeting
+	SayHello(context.Context, *HelloRequest) (*HelloReply, error)
+}
+
+// UnimplementedGreeterServer can be embedded to have forward compatible implementations.
+type UnimplementedGreeterServer struct {
+}
+
+func (*UnimplementedGreeterServer) SayHello(ctx context.Context, req *HelloRequest) (*HelloReply, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
+}
+
+func RegisterGreeterServer(s *grpc.Server, srv GreeterServer) {
+	s.RegisterService(&_Greeter_serviceDesc, srv)
+}
+
+func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HelloRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GreeterServer).SayHello(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/internal.Greeter/SayHello",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Greeter_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "internal.Greeter",
+	HandlerType: (*GreeterServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "SayHello",
+			Handler:    _Greeter_SayHello_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "helloworld.proto",
+}
+
+type greeterDubbo3Client struct {
+	cc *dubbo3.TripleConn
+}
+
+func NewGreeterDubbo3Client(cc *dubbo3.TripleConn) GreeterClient {
+	return &greeterDubbo3Client{cc}
+}
+func (c *greeterDubbo3Client) SayHello(ctx context.Context, in *HelloRequest, opt ...grpc.CallOption) (*HelloReply, error) {
+	out := new(HelloReply)
+	interfaceKey := ctx.Value(dubboConstant.INTERFACE_KEY).(string)
+	err := c.cc.Invoke(ctx, "/"+interfaceKey+"/SayHello", in, out)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// GreeterClientImpl is the client API for Greeter service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type GreeterClientImpl struct {
+	// Sends a greeting
+	SayHello func(ctx context.Context, in *HelloRequest, out *HelloReply) error
+}
+
+func (c *GreeterClientImpl) Reference() string {
+	return "greeterImpl"
+}
+
+func (c *GreeterClientImpl) GetDubboStub(cc *dubbo3.TripleConn) GreeterClient {
+	return NewGreeterDubbo3Client(cc)
+}
+
+type GreeterProviderBase struct {
+	proxyImpl protocol.Invoker
+}
+
+func (s *GreeterProviderBase) SetProxyImpl(impl protocol.Invoker) {
+	s.proxyImpl = impl
+}
+
+func (s *GreeterProviderBase) GetProxyImpl() protocol.Invoker {
+	return s.proxyImpl
+}
+
+func _DUBBO_Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HelloRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	base := srv.(dgrpc.DubboGrpcService)
+	args := []interface{}{}
+	args = append(args, in)
+	invo := invocation.NewRPCInvocation("SayHello", args, nil)
+	if interceptor == nil {
+		result := base.GetProxyImpl().Invoke(ctx, invo)
+		return result.Result(), result.Error()
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/internal.Greeter/SayHello",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		result := base.GetProxyImpl().Invoke(context.Background(), invo)
+		return result.Result(), result.Error()
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func (s *GreeterProviderBase) ServiceDesc() *grpc.ServiceDesc {
+	return &grpc.ServiceDesc{
+		ServiceName: "internal.Greeter",
+		HandlerType: (*GreeterServer)(nil),
+		Methods: []grpc.MethodDesc{
+			{
+				MethodName: "SayHello",
+				Handler:    _DUBBO_Greeter_SayHello_Handler,
+			},
+		},
+		Streams:  []grpc.StreamDesc{},
+		Metadata: "helloworld.proto",
+	}
+}

protocol/dubbo3/internal/helloworld.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.
+ */
+
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package internal;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}

protocol/dubbo3/internal/server.go

+/*
+ * 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 internal
+
+import (
+	"context"
+	_ "github.com/apache/dubbo-go/common/proxy/proxy_factory"
+	"github.com/apache/dubbo-go/config"
+	_ "github.com/apache/dubbo-go/filter/filter_impl"
+	"log"
+)
+
+// server is used to implement helloworld.GreeterServer.
+type Server struct {
+	*GreeterProviderBase
+}
+
+// SayHello implements helloworld.GreeterServer
+func (s *Server) SayHello(ctx context.Context, in *HelloRequest) (*HelloReply, error) {
+	log.Printf("Received: %v", in.GetName())
+	return &HelloReply{Message: "Hello " + in.GetName()}, nil
+}
+
+func (s *Server) Reference() string {
+	return "DubboGreeterImpl"
+}
+
+// InitDubboServer creates global gRPC server.
+func InitDubboServer() {
+	providerConfig := config.NewProviderConfig(
+		config.WithProviderAppConfig(config.NewDefaultApplicationConfig()),
+		config.WithProviderProtocol("tri", "tri", "30000"), // protocol and port
+		config.WithProviderServices("DubboGreeterImpl", config.NewServiceConfigByAPI(
+			config.WithServiceProtocol("tri"),                                // export protocol
+			config.WithServiceInterface("org.apache.dubbo.DubboGreeterImpl"), // interface id
+			config.WithServiceLoadBalance("random"),                          // lb
+			config.WithServiceWarmUpTime("100"),
+			config.WithServiceCluster("failover"),
+		)),
+	)
+	config.SetProviderConfig(*providerConfig) // set to providerConfig ptr
+
+	config.SetProviderService(&Server{
+		GreeterProviderBase: &GreeterProviderBase{},
+	})
+	config.Load()
+}

protocol/dubbo3/protoc-gen-dubbo3/examples/helloworld.pb.go

@@ -31,6 +31,7 @@ import (
 )
 
 import (
+	dubboConstant "github.com/apache/dubbo-go/common/constant"
 	"github.com/apache/dubbo-go/protocol"
 	dgrpc "github.com/apache/dubbo-go/protocol/grpc"
 	"github.com/apache/dubbo-go/protocol/invocation"
@@ -242,7 +243,8 @@ func NewGreeterDubbo3Client(cc *dubbo3.TripleConn) GreeterClient {
 }
 func (c *greeterDubbo3Client) SayHello(ctx context.Context, in *HelloRequest, opt ...grpc.CallOption) (*HelloReply, error) {
 	out := new(HelloReply)
-	err := c.cc.Invoke(ctx, "/main.Greeter/SayHello", in, out)
+	interfaceKey := ctx.Value(dubboConstant.INTERFACE_KEY).(string)
+	err := c.cc.Invoke(ctx, "/"+interfaceKey+"/SayHello", in, out)
 	if err != nil {
 		return nil, err
 	}

protocol/dubbo3/protoc-gen-dubbo3/plugin/dubbo3/dubbo3.go

@@ -108,6 +108,7 @@ func (g *dubboGrpc) GenerateImports(file *generator.FileDescriptor) {
 	g.P(`"github.com/apache/dubbo-go/protocol/invocation"`)
 	g.P(`"github.com/apache/dubbo-go/protocol"`)
 	g.P(`dubbo3 "github.com/dubbogo/triple/pkg/triple"`)
+	g.P(`dubboConstant "github.com/apache/dubbo-go/common/constant"`)
 	g.P(` ) `)
 }
 
@@ -146,7 +147,8 @@ func (g *dubboGrpc) generateService(file *generator.FileDescriptor, service *pb.
 			//now we only support two way streaming
 			g.P(fmt.Sprintf("func (c *%sDubbo3Client) %s(ctx %s.Context,opt ...grpc.CallOption) (%s, error) {",
 				lowerServName, method.GetName(), contextPkg, servName+"_"+method.GetName()+"Client"))
-			g.P(fmt.Sprintf("stream, err := c.cc.NewStream(ctx,  \"/%s/%s\", opt...)", fullServName, method.GetName()))
+			g.P(fmt.Sprintf("interfaceKey := ctx.Value(dubboConstant.INTERFACE_KEY).(string)"))
+			g.P(fmt.Sprintf("stream, err := c.cc.NewStream(ctx, \"/\" + interfaceKey + \"/%s\", opt...)", method.GetName()))
 			g.P("if err != nil {")
 			g.P("return nil, err")
 			g.P("}")
@@ -159,7 +161,8 @@ func (g *dubboGrpc) generateService(file *generator.FileDescriptor, service *pb.
 		g.P(fmt.Sprintf("func (c *%sDubbo3Client) %s(ctx %s.Context, in *%s, opt ...grpc.CallOption) (*%s, error) {",
 			lowerServName, method.GetName(), contextPkg, inputTypeName, outputTypeName))
 		g.P(fmt.Sprintf("out := new(%s)", outputTypeName))
-		g.P(fmt.Sprintf("err := c.cc.Invoke(ctx, \"/%s/%s\", in, out)", fullServName, method.GetName()))
+		g.P(fmt.Sprintf("interfaceKey := ctx.Value(dubboConstant.INTERFACE_KEY).(string)"))
+		g.P(fmt.Sprintf("err := c.cc.Invoke(ctx, \"/\" + interfaceKey + \"/%s\", in, out)", method.GetName()))
 		g.P("if err != nil {")
 		g.P("return nil, err")
 		g.P("}")