You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@dubbo.apache.org by al...@apache.org on 2022/12/11 14:53:13 UTC

[dubbo-go] branch 3.0 updated: registry type support all (#2140)

This is an automated email from the ASF dual-hosted git repository.

alexstocks pushed a commit to branch 3.0
in repository https://gitbox.apache.org/repos/asf/dubbo-go.git


The following commit(s) were added to refs/heads/3.0 by this push:
     new d50f955eb  registry type support all (#2140)
d50f955eb is described below

commit d50f955ebc4371ca4d9d7eb1ae856a48f8fc9d47
Author: bobtthp <gz...@gmail.com>
AuthorDate: Sun Dec 11 22:53:05 2022 +0800

     registry type support all (#2140)
    
    * registry type support all
    
    * fix test
    
    * set default to interface
    
    * use default protocol registry
    
    * fix unit test
    
    * use swith to judge
    
    * add registry support all test
    
    * Resolve registry name conflicts
    
    * fix ut err
    
    Co-authored-by: bobtthp <bo...@bob-Mac-mini.local>
    Co-authored-by: bob <bo...@bobdeMacBook-Pro.local>
    Co-authored-by: bobtthp <bo...@bob1.local>
---
 common/constant/default.go         |  1 +
 common/constant/key.go             |  3 +++
 config/config_utils.go             |  4 +++
 config/registry_config.go          | 53 ++++++++++++++++++++++++++++++++++----
 config/registry_config_test.go     | 13 ++++++++++
 config/service_config.go           |  4 +--
 config/service_config_test.go      |  2 +-
 registry/protocol/protocol.go      |  4 +--
 registry/protocol/protocol_test.go |  6 ++---
 9 files changed, 77 insertions(+), 13 deletions(-)

diff --git a/common/constant/default.go b/common/constant/default.go
index 747f409e0..93ab319d0 100644
--- a/common/constant/default.go
+++ b/common/constant/default.go
@@ -89,4 +89,5 @@ const (
 
 const (
 	ServiceDiscoveryDefaultGroup = "DEFAULT_GROUP"
+	NotAvailable                 = "N/A"
 )
diff --git a/common/constant/key.go b/common/constant/key.go
index 7adafa75b..68c7d4526 100644
--- a/common/constant/key.go
+++ b/common/constant/key.go
@@ -169,6 +169,9 @@ const (
 	RegistrySimplifiedKey   = "simplified"
 	RegistryNamespaceKey    = "registry.namespace"
 	RegistryGroupKey        = "registry.group"
+	RegistryTypeInterface   = "interface"
+	RegistryTypeService     = "service"
+	RegistryTypeAll         = "all"
 )
 
 const (
diff --git a/config/config_utils.go b/config/config_utils.go
index f08d1b901..fa6b51b2d 100644
--- a/config/config_utils.go
+++ b/config/config_utils.go
@@ -116,3 +116,7 @@ func verify(s interface{}) error {
 func clientNameID(config extension.Config, protocol, address string) string {
 	return strings.Join([]string{config.Prefix(), protocol, address}, "-")
 }
+
+func isValid(addr string) bool {
+	return addr != "" && addr != constant.NotAvailable
+}
diff --git a/config/registry_config.go b/config/registry_config.go
index c8cf359ea..facd26729 100644
--- a/config/registry_config.go
+++ b/config/registry_config.go
@@ -91,7 +91,7 @@ func (c *RegistryConfig) getUrlMap(roleType common.RoleType) url.Values {
 
 func (c *RegistryConfig) startRegistryConfig() error {
 	c.translateRegistryAddress()
-	if GetApplicationConfig().MetadataType == constant.DefaultMetadataStorageType && c.RegistryType == constant.ServiceKey {
+	if GetApplicationConfig().MetadataType == constant.DefaultMetadataStorageType && c.RegistryType == constant.ServiceKey || c.RegistryType == constant.RegistryTypeAll {
 		if tmpUrl, err := c.toMetadataReportUrl(); err == nil {
 			instance.SetMetadataReportInstanceByReg(tmpUrl)
 		} else {
@@ -149,13 +149,56 @@ func (c *RegistryConfig) GetInstance(roleType common.RoleType) (registry.Registr
 func (c *RegistryConfig) toURL(roleType common.RoleType) (*common.URL, error) {
 	address := c.translateRegistryAddress()
 	var registryURLProtocol string
-	if c.RegistryType == "service" {
-		// service discovery protocol
+	switch c.RegistryType {
+	case constant.RegistryTypeService:
 		registryURLProtocol = constant.ServiceRegistryProtocol
-	} else {
+	case constant.RegistryTypeInterface:
 		registryURLProtocol = constant.RegistryProtocol
+	default:
+		// default use interface
+		registryURLProtocol = constant.RegistryProtocol
+	}
+	return c.createNewURL(registryURLProtocol, address, roleType)
+}
+
+func (c *RegistryConfig) toURLs(roleType common.RoleType) ([]*common.URL, error) {
+	address := c.translateRegistryAddress()
+	var urls []*common.URL
+	var err error
+	var registryURL *common.URL
+
+	if !isValid(c.Address) {
+		logger.Infof("Empty or N/A registry address found, the process will work with no registry enabled " +
+			"which means that the address of this instance will not be registered and not able to be found by other consumer instances.")
+		return urls, nil
 	}
-	return common.NewURL(registryURLProtocol+"://"+address,
+	switch c.RegistryType {
+	case constant.RegistryTypeService:
+		if registryURL, err = c.createNewURL(constant.ServiceRegistryProtocol, address, roleType); err == nil {
+			urls = append(urls, registryURL)
+		}
+	case constant.RegistryTypeInterface:
+		if registryURL, err = c.createNewURL(constant.RegistryProtocol, address, roleType); err == nil {
+			urls = append(urls, registryURL)
+		}
+	case constant.RegistryTypeAll:
+		if registryURL, err = c.createNewURL(constant.ServiceRegistryProtocol, address, roleType); err == nil {
+			urls = append(urls, registryURL)
+		}
+		if registryURL, err = c.createNewURL(constant.RegistryProtocol, address, roleType); err == nil {
+			urls = append(urls, registryURL)
+		}
+	default:
+		// default use interface
+		if registryURL, err = c.createNewURL(constant.RegistryProtocol, address, roleType); err == nil {
+			urls = append(urls, registryURL)
+		}
+	}
+	return urls, err
+}
+
+func (c *RegistryConfig) createNewURL(protocol string, address string, roleType common.RoleType) (*common.URL, error) {
+	return common.NewURL(protocol+"://"+address,
 		common.WithParams(c.getUrlMap(roleType)),
 		common.WithParamsValue(constant.RegistrySimplifiedKey, strconv.FormatBool(c.Simplified)),
 		common.WithParamsValue(constant.RegistryKey, c.Protocol),
diff --git a/config/registry_config_test.go b/config/registry_config_test.go
index 9c0be8c8f..cf9ff61d0 100644
--- a/config/registry_config_test.go
+++ b/config/registry_config_test.go
@@ -66,6 +66,19 @@ func TestLoadRegistries1(t *testing.T) {
 	assert.Equal(t, "127.0.0.2:2181", urls[0].Location)
 }
 
+func TestRegistryTypeAll(t *testing.T) {
+	target := []string{"test"}
+	regs := map[string]*RegistryConfig{
+		"test": {
+			Protocol:     "mock",
+			Address:      "127.0.0.2:2181",
+			RegistryType: constant.RegistryTypeAll,
+		},
+	}
+	urls := loadRegistries(target, regs, common.PROVIDER)
+	assert.Equal(t, 2, len(urls))
+}
+
 func TestTranslateRegistryAddress(t *testing.T) {
 	reg := new(RegistryConfig)
 	reg.Address = "nacos://127.0.0.1:8848"
diff --git a/config/service_config.go b/config/service_config.go
index d669c8c5c..92a4e269c 100644
--- a/config/service_config.go
+++ b/config/service_config.go
@@ -375,11 +375,11 @@ func loadRegistries(registryIds []string, registries map[string]*RegistryConfig,
 		}
 
 		if target {
-			if registryURL, err := registryConf.toURL(roleType); err != nil {
+			if urls, err := registryConf.toURLs(roleType); err != nil {
 				logger.Errorf("The registry id: %s url is invalid, error: %#v", k, err)
 				panic(err)
 			} else {
-				registryURLs = append(registryURLs, registryURL)
+				registryURLs = append(registryURLs, urls...)
 			}
 		}
 	}
diff --git a/config/service_config_test.go b/config/service_config_test.go
index 5a0639f42..e2a9bebdc 100644
--- a/config/service_config_test.go
+++ b/config/service_config_test.go
@@ -96,7 +96,7 @@ func TestNewServiceConfigBuilder(t *testing.T) {
 	t.Run("loadRegistries&loadProtocol&getRandomPort", func(t *testing.T) {
 		registries := loadRegistries(serviceConfig.RegistryIDs, serviceConfig.RCRegistriesMap, common.PROVIDER)
 		assert.Equal(t, len(registries), 1)
-		assert.Equal(t, registries[0].Protocol, "registry")
+		assert.Equal(t, registries[0].Protocol, constant.RegistryProtocol)
 		assert.Equal(t, registries[0].Port, "8848")
 		assert.Equal(t, registries[0].GetParam("registry.role", "1"), "3")
 		assert.Equal(t, registries[0].GetParam("registry", "zk"), "nacos")
diff --git a/registry/protocol/protocol.go b/registry/protocol/protocol.go
index a869ab716..bc3340dea 100644
--- a/registry/protocol/protocol.go
+++ b/registry/protocol/protocol.go
@@ -82,14 +82,14 @@ func newRegistryProtocol() *registryProtocol {
 
 func (proto *registryProtocol) getRegistry(registryUrl *common.URL) registry.Registry {
 	var err error
-	reg, loaded := proto.registries.Load(registryUrl.Location)
+	reg, loaded := proto.registries.Load(registryUrl.PrimitiveURL)
 	if !loaded {
 		reg, err = extension.GetRegistry(registryUrl.Protocol, registryUrl)
 		if err != nil {
 			logger.Errorf("Registry can not connect success, program is going to panic.Error message is %s", err.Error())
 			panic(err)
 		}
-		proto.registries.Store(registryUrl.Location, reg)
+		proto.registries.Store(registryUrl.PrimitiveURL, reg)
 	}
 	return reg.(registry.Registry)
 }
diff --git a/registry/protocol/protocol_test.go b/registry/protocol/protocol_test.go
index 7ed3711f9..2c9ff6133 100644
--- a/registry/protocol/protocol_test.go
+++ b/registry/protocol/protocol_test.go
@@ -225,7 +225,7 @@ func TestExportWithOverrideListener(t *testing.T) {
 	regProtocol := newRegistryProtocol()
 	url := exporterNormal(t, regProtocol)
 	var reg *registry.MockRegistry
-	if regI, loaded := regProtocol.registries.Load(url.Location); loaded {
+	if regI, loaded := regProtocol.registries.Load(url.PrimitiveURL); loaded {
 		reg = regI.(*registry.MockRegistry)
 	} else {
 		assert.Fail(t, "regProtocol.registries.Load can not be loaded")
@@ -252,7 +252,7 @@ func TestExportWithServiceConfig(t *testing.T) {
 	common_cfg.GetEnvInstance().SetDynamicConfiguration(dc)
 	regProtocol := newRegistryProtocol()
 	url := exporterNormal(t, regProtocol)
-	if _, loaded := regProtocol.registries.Load(url.Location); !loaded {
+	if _, loaded := regProtocol.registries.Load(url.PrimitiveURL); !loaded {
 		assert.Fail(t, "regProtocol.registries.Load can not be loaded")
 		return
 	}
@@ -275,7 +275,7 @@ func TestExportWithApplicationConfig(t *testing.T) {
 	common_cfg.GetEnvInstance().SetDynamicConfiguration(dc)
 	regProtocol := newRegistryProtocol()
 	url := exporterNormal(t, regProtocol)
-	if _, loaded := regProtocol.registries.Load(url.Location); !loaded {
+	if _, loaded := regProtocol.registries.Load(url.PrimitiveURL); !loaded {
 		assert.Fail(t, "regProtocol.registries.Load can not be loaded")
 		return
 	}