diff --git a/.scannerwork/.sonar_lock b/.scannerwork/.sonar_lock
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.scannerwork/report-task.txt b/.scannerwork/report-task.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e08d951c551ccf968eed258b6c82b85caa329801
--- /dev/null
+++ b/.scannerwork/report-task.txt
@@ -0,0 +1,6 @@
+projectKey=dubbo-go-local
+serverUrl=http://localhost:9000
+serverVersion=8.3.1.34397
+dashboardUrl=http://localhost:9000/dashboard?id=dubbo-go-local
+ceTaskId=AXL0nCPXfOzcRn_yfiMD
+ceTaskUrl=http://localhost:9000/api/ce/task?id=AXL0nCPXfOzcRn_yfiMD
diff --git a/.scannerwork/sonar-go-to-slang-darwin-amd64 b/.scannerwork/sonar-go-to-slang-darwin-amd64
new file mode 100755
index 0000000000000000000000000000000000000000..e4d5adde2e697bdf563641c4c7da993ff6f45b3a
Binary files /dev/null and b/.scannerwork/sonar-go-to-slang-darwin-amd64 differ
diff --git a/config/base_config.go b/config/base_config.go
index cf490019b2a48b98ffb6fab1036bfd6218fe7343..fd749a934b8344a5ed00343f1b18f10bc41fd820 100644
--- a/config/base_config.go
+++ b/config/base_config.go
@@ -124,20 +124,20 @@ func getKeyPrefix(val reflect.Value) []string {
var (
prefix string
)
-
+ configPrefixMethod := "Prefix"
if val.CanAddr() {
- prefix = val.Addr().MethodByName("Prefix").Call(nil)[0].String()
+ prefix = val.Addr().MethodByName(configPrefixMethod).Call(nil)[0].String()
} else {
- prefix = val.MethodByName("Prefix").Call(nil)[0].String()
+ prefix = val.MethodByName(configPrefixMethod).Call(nil)[0].String()
}
- var retPrefixs []string
+ var retPrefixes []string
for _, pfx := range strings.Split(prefix, "|") {
- retPrefixs = append(retPrefixs, pfx)
+ retPrefixes = append(retPrefixes, pfx)
}
- return retPrefixs
+ return retPrefixes
}
@@ -164,13 +164,13 @@ func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryC
idStr string
)
- prefixs := getKeyPrefix(val)
+ prefixes := getKeyPrefix(val)
if id.Kind() == reflect.String {
idStr = id.Interface().(string)
}
- for _, pfx := range prefixs {
+ for _, pfx := range prefixes {
if len(pfx) > 0 {
if len(idStr) > 0 {
@@ -190,18 +190,20 @@ func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryC
}
if ok {
+ errMsg := func(structName string, fieldName string, errorDetails error) {
+ logger.Errorf("Dynamic change the configuration in struct {%v} field {%v} error ,error message is {%v}",
+ structName, fieldName, errorDetails)
+ }
switch f.Kind() {
case reflect.Int64:
x, err := strconv.Atoi(value)
if err != nil {
- logger.Errorf("Dynamic change the configuration in struct {%v} field {%v} error ,error message is {%v}",
- val.Type().Name(), val.Type().Field(i).Name, err)
+ errMsg(val.Type().Name(), val.Type().Field(i).Name, err)
} else {
if !f.OverflowInt(int64(x)) {
f.SetInt(int64(x))
} else {
- logger.Errorf("Dynamic change the configuration in struct {%v} field {%v} error ,error message is {%v}",
- val.Type().Name(), val.Type().Field(i).Name, perrors.Errorf("the int64 value {%v} from config center is overflow", int64(x)))
+ errMsg(val.Type().Name(), val.Type().Field(i).Name, perrors.Errorf("the int64 value {%v} from config center is overflow", int64(x)))
}
}
case reflect.String:
@@ -209,21 +211,18 @@ func setFieldValue(val reflect.Value, id reflect.Value, config *config.InmemoryC
case reflect.Bool:
x, err := strconv.ParseBool(value)
if err != nil {
- logger.Errorf("Dynamic change the configuration in struct {%v} field {%v} error ,error message is {%v}",
- val.Type().Name(), val.Type().Field(i).Name, err)
+ errMsg(val.Type().Name(), val.Type().Field(i).Name, err)
}
f.SetBool(x)
case reflect.Float64:
x, err := strconv.ParseFloat(value, 64)
if err != nil {
- logger.Errorf("Dynamic change the configuration in struct {%v} field {%v} error ,error message is {%v}",
- val.Type().Name(), val.Type().Field(i).Name, err)
+ errMsg(val.Type().Name(), val.Type().Field(i).Name, err)
} else {
if !f.OverflowFloat(x) {
f.SetFloat(x)
} else {
- logger.Errorf("Dynamic change the configuration in struct {%v} field {%v} error ,error message is {%v}",
- val.Type().Name(), val.Type().Field(i).Name, perrors.Errorf("the float64 value {%v} from config center is overflow", x))
+ errMsg(val.Type().Name(), val.Type().Field(i).Name, perrors.Errorf("the float64 value {%v} from config center is overflow", x))
}
}
default:
@@ -328,39 +327,40 @@ func (c *BaseConfig) SetFatherConfig(fatherConfig interface{}) {
}
func initializeStruct(t reflect.Type, v reflect.Value) {
- if v.Kind() == reflect.Struct {
- for i := 0; i < v.NumField(); i++ {
- f := v.Field(i)
- ft := t.Field(i)
-
- if ft.Tag.Get("property") != "" {
- switch ft.Type.Kind() {
- case reflect.Map:
- if f.IsNil() {
- f.Set(reflect.MakeMap(ft.Type))
- }
- case reflect.Slice:
- if f.IsNil() {
- f.Set(reflect.MakeSlice(ft.Type, 0, 0))
- }
- case reflect.Chan:
- if f.IsNil() {
- f.Set(reflect.MakeChan(ft.Type, 0))
- }
- case reflect.Struct:
- if f.IsNil() {
- initializeStruct(ft.Type, f)
- }
- case reflect.Ptr:
- if f.IsNil() {
- fv := reflect.New(ft.Type.Elem())
- initializeStruct(ft.Type.Elem(), fv.Elem())
- f.Set(fv)
- }
- default:
- }
- }
+ if v.Kind() != reflect.Struct {
+ return
+ }
+ for i := 0; i < v.NumField(); i++ {
+ f := v.Field(i)
+ ft := t.Field(i)
+ if ft.Tag.Get("property") == "" {
+ continue
+ }
+ switch ft.Type.Kind() {
+ case reflect.Map:
+ if f.IsNil() {
+ f.Set(reflect.MakeMap(ft.Type))
+ }
+ case reflect.Slice:
+ if f.IsNil() {
+ f.Set(reflect.MakeSlice(ft.Type, 0, 0))
+ }
+ case reflect.Chan:
+ if f.IsNil() {
+ f.Set(reflect.MakeChan(ft.Type, 0))
+ }
+ case reflect.Struct:
+ if f.IsNil() {
+ initializeStruct(ft.Type, f)
+ }
+ case reflect.Ptr:
+ if f.IsNil() {
+ fv := reflect.New(ft.Type.Elem())
+ initializeStruct(ft.Type.Elem(), fv.Elem())
+ f.Set(fv)
+ }
+ default:
}
}
}
diff --git a/config/base_config_test.go b/config/base_config_test.go
index bc422d018946017a2c50dccefe54357d786a7589..0e954a76a43cabcffb3d8185bb8e1dc7ffd9ed02 100644
--- a/config/base_config_test.go
+++ b/config/base_config_test.go
@@ -33,89 +33,93 @@ import (
_ "github.com/apache/dubbo-go/config_center/apollo"
)
-func Test_refresh(t *testing.T) {
- c := &BaseConfig{}
- mockMap := map[string]string{}
- mockMap["dubbo.registries.shanghai_reg1.protocol"] = "mock100"
- mockMap["dubbo.reference.com.MockService.MockService.retries"] = "10"
- mockMap["dubbo.com.MockService.MockService.GetUser.retries"] = "10"
- mockMap["dubbo.consumer.check"] = "false"
- mockMap["dubbo.application.name"] = "dubbo"
- mockMap["dubbo.shutdown.timeout"] = "12s"
+func getMockMap() map[string]string{
+ baseMockMap := map[string]string{
+ "dubbo.registries.shanghai_reg1.protocol": "mock100",
+ "dubbo.reference.com.MockService.MockService.retries": "10",
+ "dubbo.com.MockService.MockService.GetUser.retries": "10",
+ "dubbo.consumer.check": "false",
+ "dubbo.application.name": "dubbo",
+ }
+ return baseMockMap
+}
- config.GetEnvInstance().UpdateExternalConfigMap(mockMap)
+var baseAppConfig = &ApplicationConfig{
+ Organization: "dubbo_org",
+ Name: "dubbo",
+ Module: "module",
+ Version: "2.6.0",
+ Owner: "dubbo",
+ Environment: "test",
+}
- father := &ConsumerConfig{
- Check: &[]bool{true}[0],
- ApplicationConfig: &ApplicationConfig{
- Organization: "dubbo_org",
- Name: "dubbo",
- Module: "module",
- Version: "2.6.0",
- Owner: "dubbo",
- Environment: "test"},
- Registries: map[string]*RegistryConfig{
- //"shanghai_reg1": {
- // id: "shanghai_reg1",
- // Protocol: "mock",
- // TimeoutStr: "2s",
- // Group: "shanghai_idc",
- // Address: "127.0.0.1:2181",
- // Username: "user1",
- // Password: "pwd1",
- //},
- "shanghai_reg2": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "shanghai_idc",
- Address: "127.0.0.2:2181",
- Username: "user1",
- Password: "pwd1",
- },
- "hangzhou_reg1": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "hangzhou_idc",
- Address: "127.0.0.3:2181",
- Username: "user1",
- Password: "pwd1",
- },
- "hangzhou_reg2": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "hangzhou_idc",
- Address: "127.0.0.4:2181",
- Username: "user1",
- Password: "pwd1",
+var baseRegistries = map[string]*RegistryConfig{
+ "shanghai_reg2": {
+ Protocol: "mock",
+ TimeoutStr: "2s",
+ Group: "shanghai_idc",
+ Address: "127.0.0.2:2181",
+ Username: "user1",
+ Password: "pwd1",
+ },
+ "hangzhou_reg1": {
+ Protocol: "mock",
+ TimeoutStr: "2s",
+ Group: "hangzhou_idc",
+ Address: "127.0.0.3:2181",
+ Username: "user1",
+ Password: "pwd1",
+ },
+ "hangzhou_reg2": {
+ Protocol: "mock",
+ TimeoutStr: "2s",
+ Group: "hangzhou_idc",
+ Address: "127.0.0.4:2181",
+ Username: "user1",
+ Password: "pwd1",
+ },
+}
+
+var baseMockRef = map[string]*ReferenceConfig{
+ "MockService": {
+ InterfaceName: "com.MockService",
+ Protocol: "mock",
+ Cluster: "failover",
+ Loadbalance: "random",
+ Retries: "3",
+ Group: "huadong_idc",
+ Version: "1.0.0",
+ Methods: []*MethodConfig{
+ {
+ InterfaceId: "MockService",
+ InterfaceName: "com.MockService",
+ Name: "GetUser",
+ Retries: "2",
+ Loadbalance: "random",
},
- },
- References: map[string]*ReferenceConfig{
- "MockService": {
+ {
+ InterfaceId: "MockService",
InterfaceName: "com.MockService",
- Protocol: "mock",
- Cluster: "failover",
+ Name: "GetUser1",
+ Retries: "2",
Loadbalance: "random",
- Retries: "3",
- Group: "huadong_idc",
- Version: "1.0.0",
- Methods: []*MethodConfig{
- {
- InterfaceId: "MockService",
- InterfaceName: "com.MockService",
- Name: "GetUser",
- Retries: "2",
- Loadbalance: "random",
- },
- {
- InterfaceId: "MockService",
- InterfaceName: "com.MockService",
- Name: "GetUser1",
- Retries: "2",
- Loadbalance: "random",
- },
- },
},
},
+ },
+}
+
+func TestRefresh(t *testing.T) {
+ c := &BaseConfig{}
+ mockMap := getMockMap()
+ mockMap["dubbo.shutdown.timeout"] = "12s"
+
+ config.GetEnvInstance().UpdateExternalConfigMap(mockMap)
+
+ father := &ConsumerConfig{
+ Check: &[]bool{true}[0],
+ ApplicationConfig: baseAppConfig,
+ Registries: baseRegistries,
+ References: baseMockRef,
ShutdownConfig: &ShutdownConfig{
Timeout: "12s",
StepTimeout: "2s",
@@ -135,90 +139,19 @@ func Test_refresh(t *testing.T) {
assert.Equal(t, "dubbo", father.ApplicationConfig.Name)
}
-func Test_appExternal_refresh(t *testing.T) {
+func TestAppExternalRefresh(t *testing.T) {
c := &BaseConfig{}
- mockMap := map[string]string{}
- mockMap["dubbo.registries.shanghai_reg1.protocol"] = "mock100"
- mockMap["dubbo.reference.com.MockService.MockService.retries"] = "10"
+ mockMap := getMockMap()
mockMap["dubbo.reference.com.MockService.retries"] = "5"
- mockMap["dubbo.com.MockService.MockService.GetUser.retries"] = "10"
- mockMap["dubbo.consumer.check"] = "false"
- mockMap["dubbo.application.name"] = "dubbo"
config.GetEnvInstance().UpdateAppExternalConfigMap(mockMap)
mockMap["dubbo.consumer.check"] = "true"
config.GetEnvInstance().UpdateExternalConfigMap(mockMap)
father := &ConsumerConfig{
Check: &[]bool{true}[0],
- ApplicationConfig: &ApplicationConfig{
- Organization: "dubbo_org",
- Name: "dubbo",
- Module: "module",
- Version: "2.6.0",
- Owner: "dubbo",
- Environment: "test"},
- Registries: map[string]*RegistryConfig{
- //"shanghai_reg1": {
- // id: "shanghai_reg1",
- // Protocol: "mock",
- // TimeoutStr: "2s",
- // Group: "shanghai_idc",
- // Address: "127.0.0.1:2181",
- // Username: "user1",
- // Password: "pwd1",
- //},
- "shanghai_reg2": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "shanghai_idc",
- Address: "127.0.0.2:2181",
- Username: "user1",
- Password: "pwd1",
- },
- "hangzhou_reg1": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "hangzhou_idc",
- Address: "127.0.0.3:2181",
- Username: "user1",
- Password: "pwd1",
- },
- "hangzhou_reg2": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "hangzhou_idc",
- Address: "127.0.0.4:2181",
- Username: "user1",
- Password: "pwd1",
- },
- },
- References: map[string]*ReferenceConfig{
- "MockService": {
- InterfaceName: "com.MockService",
- Protocol: "mock",
- Cluster: "failover",
- Loadbalance: "random",
- Retries: "3",
- Group: "huadong_idc",
- Version: "1.0.0",
- Methods: []*MethodConfig{
- {
- InterfaceId: "MockService",
- InterfaceName: "com.MockService",
- Name: "GetUser",
- Retries: "2",
- Loadbalance: "random",
- },
- {
- InterfaceId: "MockService",
- InterfaceName: "com.MockService",
- Name: "GetUser1",
- Retries: "2",
- Loadbalance: "random",
- },
- },
- },
- },
+ ApplicationConfig: baseAppConfig,
+ Registries: baseRegistries,
+ References: baseMockRef,
}
c.SetFatherConfig(father)
@@ -231,89 +164,20 @@ func Test_appExternal_refresh(t *testing.T) {
assert.Equal(t, "dubbo", father.ApplicationConfig.Name)
}
-func Test_appExternalWithoutId_refresh(t *testing.T) {
+func TestAppExternalWithoutIDRefresh(t *testing.T) {
c := &BaseConfig{}
- mockMap := map[string]string{}
- mockMap["dubbo.registries.shanghai_reg1.protocol"] = "mock100"
+ mockMap := getMockMap()
+ delete(mockMap, "dubbo.reference.com.MockService.MockService.retries")
mockMap["dubbo.reference.com.MockService.retries"] = "10"
- mockMap["dubbo.com.MockService.MockService.GetUser.retries"] = "10"
- mockMap["dubbo.consumer.check"] = "false"
- mockMap["dubbo.application.name"] = "dubbo"
config.GetEnvInstance().UpdateAppExternalConfigMap(mockMap)
mockMap["dubbo.consumer.check"] = "true"
config.GetEnvInstance().UpdateExternalConfigMap(mockMap)
father := &ConsumerConfig{
Check: &[]bool{true}[0],
- ApplicationConfig: &ApplicationConfig{
- Organization: "dubbo_org",
- Name: "dubbo",
- Module: "module",
- Version: "2.6.0",
- Owner: "dubbo",
- Environment: "test"},
- Registries: map[string]*RegistryConfig{
- //"shanghai_reg1": {
- // id: "shanghai_reg1",
- // Protocol: "mock",
- // TimeoutStr: "2s",
- // Group: "shanghai_idc",
- // Address: "127.0.0.1:2181",
- // Username: "user1",
- // Password: "pwd1",
- //},
- "shanghai_reg2": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "shanghai_idc",
- Address: "127.0.0.2:2181",
- Username: "user1",
- Password: "pwd1",
- },
- "hangzhou_reg1": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "hangzhou_idc",
- Address: "127.0.0.3:2181",
- Username: "user1",
- Password: "pwd1",
- },
- "hangzhou_reg2": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "hangzhou_idc",
- Address: "127.0.0.4:2181",
- Username: "user1",
- Password: "pwd1",
- },
- },
- References: map[string]*ReferenceConfig{
- "MockService": {
- InterfaceName: "com.MockService",
- Protocol: "mock",
- Cluster: "failover",
- Loadbalance: "random",
- Retries: "3",
- Group: "huadong_idc",
- Version: "1.0.0",
- Methods: []*MethodConfig{
- {
- InterfaceId: "MockService",
- InterfaceName: "com.MockService",
- Name: "GetUser",
- Retries: "3",
- Loadbalance: "random",
- },
- {
- InterfaceId: "MockService",
- InterfaceName: "com.MockService",
- Name: "GetUser1",
- Retries: "2",
- Loadbalance: "random",
- },
- },
- },
- },
+ ApplicationConfig: baseAppConfig,
+ Registries: baseRegistries,
+ References: baseMockRef,
}
c.SetFatherConfig(father)
@@ -326,7 +190,7 @@ func Test_appExternalWithoutId_refresh(t *testing.T) {
assert.Equal(t, "dubbo", father.ApplicationConfig.Name)
}
-func Test_refresh_singleRegistry(t *testing.T) {
+func TestRefreshSingleRegistry(t *testing.T) {
c := &BaseConfig{}
mockMap := map[string]string{}
mockMap["dubbo.registry.address"] = "mock100://127.0.0.1:2181"
@@ -339,42 +203,10 @@ func Test_refresh_singleRegistry(t *testing.T) {
father := &ConsumerConfig{
Check: &[]bool{true}[0],
- ApplicationConfig: &ApplicationConfig{
- Organization: "dubbo_org",
- Name: "dubbo",
- Module: "module",
- Version: "2.6.0",
- Owner: "dubbo",
- Environment: "test"},
+ ApplicationConfig: baseAppConfig,
Registries: map[string]*RegistryConfig{},
Registry: &RegistryConfig{},
- References: map[string]*ReferenceConfig{
- "MockService": {
- InterfaceName: "com.MockService",
- Protocol: "mock",
- Cluster: "failover",
- Loadbalance: "random",
- Retries: "3",
- Group: "huadong_idc",
- Version: "1.0.0",
- Methods: []*MethodConfig{
- {
- InterfaceId: "MockService",
- InterfaceName: "com.MockService",
- Name: "GetUser",
- Retries: "2",
- Loadbalance: "random",
- },
- {
- InterfaceId: "MockService",
- InterfaceName: "com.MockService",
- Name: "GetUser1",
- Retries: "2",
- Loadbalance: "random",
- },
- },
- },
- },
+ References: baseMockRef,
}
c.SetFatherConfig(father)
@@ -387,14 +219,11 @@ func Test_refresh_singleRegistry(t *testing.T) {
assert.Equal(t, "dubbo", father.ApplicationConfig.Name)
}
-func Test_refreshProvider(t *testing.T) {
+func TestRefreshProvider(t *testing.T) {
c := &BaseConfig{}
- mockMap := map[string]string{}
- mockMap["dubbo.registries.shanghai_reg1.protocol"] = "mock100"
+ mockMap := getMockMap()
+ delete(mockMap, "dubbo.reference.com.MockService.MockService.retries")
mockMap["dubbo.service.com.MockService.MockService.retries"] = "10"
- mockMap["dubbo.com.MockService.MockService.GetUser.retries"] = "10"
- mockMap["dubbo.consumer.check"] = "false"
- mockMap["dubbo.application.name"] = "dubbo"
mockMap["dubbo.protocols.jsonrpc1.name"] = "jsonrpc"
mockMap["dubbo.protocols.jsonrpc1.ip"] = "127.0.0.1"
mockMap["dubbo.protocols.jsonrpc1.port"] = "20001"
@@ -402,48 +231,8 @@ func Test_refreshProvider(t *testing.T) {
config.GetEnvInstance().UpdateExternalConfigMap(mockMap)
father := &ProviderConfig{
- ApplicationConfig: &ApplicationConfig{
- Organization: "dubbo_org",
- Name: "dubbo",
- Module: "module",
- Version: "2.6.0",
- Owner: "dubbo",
- Environment: "test"},
- Registries: map[string]*RegistryConfig{
- //"shanghai_reg1": {
- // id: "shanghai_reg1",
- // Protocol: "mock",
- // TimeoutStr: "2s",
- // Group: "shanghai_idc",
- // Address: "127.0.0.1:2181",
- // Username: "user1",
- // Password: "pwd1",
- //},
- "shanghai_reg2": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "shanghai_idc",
- Address: "127.0.0.2:2181",
- Username: "user1",
- Password: "pwd1",
- },
- "hangzhou_reg1": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "hangzhou_idc",
- Address: "127.0.0.3:2181",
- Username: "user1",
- Password: "pwd1",
- },
- "hangzhou_reg2": {
- Protocol: "mock",
- TimeoutStr: "2s",
- Group: "hangzhou_idc",
- Address: "127.0.0.4:2181",
- Username: "user1",
- Password: "pwd1",
- },
- },
+ ApplicationConfig: baseAppConfig,
+ Registries: baseRegistries,
Services: map[string]*ServiceConfig{
"MockService": {
InterfaceName: "com.MockService",
@@ -461,7 +250,8 @@ func Test_refreshProvider(t *testing.T) {
Retries: "2",
Loadbalance: "random",
},
- {InterfaceId: "MockService",
+ {
+ InterfaceId: "MockService",
InterfaceName: "com.MockService",
Name: "GetUser1",
Retries: "2",
@@ -482,7 +272,7 @@ func Test_refreshProvider(t *testing.T) {
assert.Equal(t, "20001", father.Protocols["jsonrpc1"].Port)
}
-func Test_startConfigCenter(t *testing.T) {
+func TestStartConfigCenter(t *testing.T) {
extension.SetConfigCenterFactory("mock", func() config_center.DynamicConfigurationFactory {
return &config_center.MockDynamicConfigurationFactory{}
})
@@ -499,7 +289,7 @@ func Test_startConfigCenter(t *testing.T) {
assert.Equal(t, "ikurento.com", v)
}
-func Test_initializeStruct(t *testing.T) {
+func TestInitializeStruct(t *testing.T) {
testConsumerConfig := &ConsumerConfig{}
tp := reflect.TypeOf(ConsumerConfig{})
v := reflect.New(tp)
diff --git a/config/config_loader.go b/config/config_loader.go
index c84817eaea9d2ba825c96bdb7b2945018b523114..f8f83533d4796cc6df3e2d4c2d77f42be56e5933 100644
--- a/config/config_loader.go
+++ b/config/config_loader.go
@@ -89,7 +89,7 @@ func loadConsumerConfig() {
// init other consumer config
conConfigType := consumerConfig.ConfigType
for key, value := range extension.GetDefaultConfigReader() {
- if conConfigType == nil {
+ if conConfigType != nil {
if v, ok := conConfigType[key]; ok {
value = v
}
diff --git a/config/config_loader_test.go b/config/config_loader_test.go
index 6368fcbd2c7bc675231e7b7835750f26743708af..a21a4998aae9eb6e0bd0632c7248cc39e7bbd9fa 100644
--- a/config/config_loader_test.go
+++ b/config/config_loader_test.go
@@ -36,10 +36,13 @@ import (
"github.com/apache/dubbo-go/config_center"
)
+const mockConsumerConfigPath = "./testdata/consumer_config.yml"
+const mockProviderConfigPath = "./testdata/provider_config.yml"
+
func TestConfigLoader(t *testing.T) {
- conPath, err := filepath.Abs("./testdata/consumer_config.yml")
+ conPath, err := filepath.Abs(mockConsumerConfigPath)
assert.NoError(t, err)
- proPath, err := filepath.Abs("./testdata/provider_config.yml")
+ proPath, err := filepath.Abs(mockProviderConfigPath)
assert.NoError(t, err)
assert.Nil(t, consumerConfig)
@@ -152,7 +155,7 @@ func TestConfigLoaderWithConfigCenter(t *testing.T) {
conPath, err := filepath.Abs("./testdata/consumer_config_with_configcenter.yml")
assert.NoError(t, err)
- proPath, err := filepath.Abs("./testdata/provider_config.yml")
+ proPath, err := filepath.Abs(mockProviderConfigPath)
assert.NoError(t, err)
assert.Nil(t, consumerConfig)
@@ -205,7 +208,7 @@ func TestConfigLoaderWithConfigCenterSingleRegistry(t *testing.T) {
conPath, err := filepath.Abs("./testdata/consumer_config_with_configcenter.yml")
assert.NoError(t, err)
- proPath, err := filepath.Abs("./testdata/provider_config.yml")
+ proPath, err := filepath.Abs(mockProviderConfigPath)
assert.NoError(t, err)
assert.Nil(t, consumerConfig)
diff --git a/config/config_utils.go b/config/config_utils.go
index 6bc574a546ebad548aaa15ce7dc9bcf68b95c3a1..0dfb8b076a4fbaebc9e195a0ea13f050b57111e7 100644
--- a/config/config_utils.go
+++ b/config/config_utils.go
@@ -18,6 +18,7 @@
package config
import (
+ "fmt"
"regexp"
"strings"
)
@@ -30,50 +31,35 @@ func mergeValue(str1, str2, def string) string {
if str1 == "" && str2 == "" {
return def
}
- str := "," + strings.Trim(str1, ",")
- if str1 == "" {
- str = "," + strings.Trim(str2, ",")
- } else if str2 != "" {
- str = str + "," + strings.Trim(str2, ",")
- }
+ s1 := strings.Split(str1, ",")
+ s2 := strings.Split(str2, ",")
+ str := "," + strings.Join(append(s1, s2...), ",")
defKey := strings.Contains(str, ","+constant.DEFAULT_KEY)
if !defKey {
str = "," + constant.DEFAULT_KEY + str
}
str = strings.TrimPrefix(strings.Replace(str, ","+constant.DEFAULT_KEY, ","+def, -1), ",")
+ return removeMinus(strings.Split(str, ","))
+}
- strArr := strings.Split(str, ",")
- strMap := make(map[string][]int)
- for k, v := range strArr {
- add := true
+func removeMinus(strArr []string) string {
+ if len(strArr) == 0 {
+ return ""
+ }
+ var normalStr string
+ var minusStrArr []string
+ for _, v := range strArr {
if strings.HasPrefix(v, "-") {
- v = v[1:]
- add = false
- }
- if _, ok := strMap[v]; !ok {
- if add {
- strMap[v] = []int{1, k}
- }
+ minusStrArr = append(minusStrArr,v[1:])
} else {
- if add {
- strMap[v][0] += 1
- strMap[v] = append(strMap[v], k)
- } else {
- strMap[v][0] -= 1
- strMap[v] = strMap[v][:len(strMap[v])-1]
- }
+ normalStr += fmt.Sprintf(",%s", v)
}
}
- strArr = make([]string, len(strArr))
- for key, value := range strMap {
- if value[0] == 0 {
- continue
- }
- for i := 1; i < len(value); i++ {
- strArr[value[i]] = key
- }
+ normalStr = strings.Trim(normalStr, ",")
+ for _, v := range minusStrArr {
+ normalStr = strings.Replace(normalStr, v, "",1)
}
reg := regexp.MustCompile("[,]+")
- str = reg.ReplaceAllString(strings.Join(strArr, ","), ",")
- return strings.Trim(str, ",")
+ normalStr = reg.ReplaceAllString(strings.Trim(normalStr, ","), ",")
+ return normalStr
}
diff --git a/config/config_utils_test.go b/config/config_utils_test.go
index 5170b90c83a0f31bbbe1b5de5bca9b8dc5869ac6..d706b81507370b5c995b756ffb41f87a2f4386a0 100644
--- a/config/config_utils_test.go
+++ b/config/config_utils_test.go
@@ -41,3 +41,23 @@ func TestMergeValue(t *testing.T) {
str = mergeValue("", "default,-b,e,f", "a,b")
assert.Equal(t, "a,e,f", str)
}
+
+func TestRemoveMinus(t *testing.T) {
+ strList := removeMinus([]string{})
+ assert.Equal(t, strList, "")
+
+ strList = removeMinus([]string{"a", "b", "c", "d", "-a"})
+ assert.Equal(t, strList, "b,c,d")
+
+ strList = removeMinus([]string{"a", "b", "c", "d", "-a", "-b"})
+ assert.Equal(t, strList, "c,d")
+
+ strList = removeMinus([]string{"a", "b", "c", "-c", "-a", "-b"})
+ assert.Equal(t, strList, "")
+
+ strList = removeMinus([]string{"b", "a", "-c", "c"})
+ assert.Equal(t, strList, "b,a")
+
+ strList = removeMinus([]string{"c", "b", "a", "d","c", "-c", "-a", "e", "f"})
+ assert.Equal(t, strList, "b,d,c,e,f")
+}
\ No newline at end of file
diff --git a/config/graceful_shutdown_config_test.go b/config/graceful_shutdown_config_test.go
index 583ed70b838a8271a47e180ee3c6eb32cbb46984..80eb5317386f4e9d966f7a9f07635a810727d77c 100644
--- a/config/graceful_shutdown_config_test.go
+++ b/config/graceful_shutdown_config_test.go
@@ -26,7 +26,7 @@ import (
"github.com/stretchr/testify/assert"
)
-func TestShutdownConfig_GetTimeout(t *testing.T) {
+func TestShutdownConfigGetTimeout(t *testing.T) {
config := ShutdownConfig{}
assert.False(t, config.RejectRequest)
assert.False(t, config.RequestsFinished)
diff --git a/config/metadata_report_config_test.go b/config/metadata_report_config_test.go
index 635feecc2d433366534566d184e058eb54a881ed..b80a77657568d0821fddca2fc16a0ccc90d7f96e 100644
--- a/config/metadata_report_config_test.go
+++ b/config/metadata_report_config_test.go
@@ -23,7 +23,7 @@ import (
"github.com/stretchr/testify/assert"
)
-func TestMetadataReportConfig_ToUrl(t *testing.T) {
+func TestMetadataReportConfigToUrl(t *testing.T) {
metadataReportConfig := MetadataReportConfig{
Protocol: "mock",
Address: "127.0.0.1:2181",
diff --git a/config/reference_config_test.go b/config/reference_config_test.go
index 7a65e55f09c997cb49b83f1f185faf9338cf0f5a..e43f5aa40af84b9f15a5595ce23696b6a1bae9a4 100644
--- a/config/reference_config_test.go
+++ b/config/reference_config_test.go
@@ -123,6 +123,7 @@ func (m *MockProvider) Reference() string {
}
func (m *MockProvider) CallBack(res common.CallbackResponse) {
+ // CallBack is a mock function. to implement the interface
}
func doInitConsumerAsync() {
@@ -178,7 +179,7 @@ func doInitConsumerWithSingleRegistry() {
}
}
-func Test_ReferMultireg(t *testing.T) {
+func TestReferMultireg(t *testing.T) {
doInitConsumer()
extension.SetProtocol("registry", GetProtocol)
extension.SetCluster("registryAware", cluster_impl.NewRegistryAwareCluster)
@@ -191,7 +192,7 @@ func Test_ReferMultireg(t *testing.T) {
consumerConfig = nil
}
-func Test_Refer(t *testing.T) {
+func TestRefer(t *testing.T) {
doInitConsumer()
extension.SetProtocol("registry", GetProtocol)
extension.SetCluster("registryAware", cluster_impl.NewRegistryAwareCluster)
@@ -205,7 +206,7 @@ func Test_Refer(t *testing.T) {
consumerConfig = nil
}
-func Test_ReferAsync(t *testing.T) {
+func TestReferAsync(t *testing.T) {
doInitConsumerAsync()
extension.SetProtocol("registry", GetProtocol)
extension.SetCluster("registryAware", cluster_impl.NewRegistryAwareCluster)
@@ -220,7 +221,7 @@ func Test_ReferAsync(t *testing.T) {
consumerConfig = nil
}
-func Test_ReferP2P(t *testing.T) {
+func TestReferP2P(t *testing.T) {
doInitConsumer()
extension.SetProtocol("dubbo", GetProtocol)
m := consumerConfig.References["MockService"]
@@ -234,7 +235,7 @@ func Test_ReferP2P(t *testing.T) {
consumerConfig = nil
}
-func Test_ReferMultiP2P(t *testing.T) {
+func TestReferMultiP2P(t *testing.T) {
doInitConsumer()
extension.SetProtocol("dubbo", GetProtocol)
m := consumerConfig.References["MockService"]
@@ -248,7 +249,7 @@ func Test_ReferMultiP2P(t *testing.T) {
consumerConfig = nil
}
-func Test_ReferMultiP2PWithReg(t *testing.T) {
+func TestReferMultiP2PWithReg(t *testing.T) {
doInitConsumer()
extension.SetProtocol("dubbo", GetProtocol)
extension.SetProtocol("registry", GetProtocol)
@@ -263,7 +264,7 @@ func Test_ReferMultiP2PWithReg(t *testing.T) {
consumerConfig = nil
}
-func Test_Implement(t *testing.T) {
+func TestImplement(t *testing.T) {
doInitConsumer()
extension.SetProtocol("registry", GetProtocol)
extension.SetCluster("registryAware", cluster_impl.NewRegistryAwareCluster)
@@ -276,7 +277,7 @@ func Test_Implement(t *testing.T) {
consumerConfig = nil
}
-func Test_Forking(t *testing.T) {
+func TestForking(t *testing.T) {
doInitConsumer()
extension.SetProtocol("dubbo", GetProtocol)
extension.SetProtocol("registry", GetProtocol)
@@ -293,7 +294,7 @@ func Test_Forking(t *testing.T) {
consumerConfig = nil
}
-func Test_Sticky(t *testing.T) {
+func TestSticky(t *testing.T) {
doInitConsumer()
extension.SetProtocol("dubbo", GetProtocol)
extension.SetProtocol("registry", GetProtocol)
@@ -332,4 +333,6 @@ func (*mockRegistryProtocol) Export(invoker protocol.Invoker) protocol.Exporter
return protocol.NewBaseExporter("test", invoker, &sync.Map{})
}
-func (*mockRegistryProtocol) Destroy() {}
+func (*mockRegistryProtocol) Destroy() {
+ // Destroy is a mock function
+}
diff --git a/config/registry_config_test.go b/config/registry_config_test.go
index 6c2fed605d6c50b483f7ad2900e5a483b3986e1b..6e5dedc34ff5489fc190841bce73cd015eb78132 100644
--- a/config/registry_config_test.go
+++ b/config/registry_config_test.go
@@ -29,7 +29,7 @@ import (
"github.com/apache/dubbo-go/common"
)
-func Test_loadRegistries(t *testing.T) {
+func TestLoadRegistries(t *testing.T) {
target := "shanghai1"
regs := map[string]*RegistryConfig{
@@ -47,7 +47,7 @@ func Test_loadRegistries(t *testing.T) {
assert.Equal(t, "127.0.0.2:2181,128.0.0.1:2181", urls[0].Location)
}
-func Test_loadRegistries1(t *testing.T) {
+func TestLoadRegistries1(t *testing.T) {
target := "shanghai1"
regs := map[string]*RegistryConfig{
diff --git a/config/service_config_test.go b/config/service_config_test.go
index e39d32b7f7976cbdc668153bcd901e40dd635556..798984874a7983f4236a3e60d369b0dc9b255357 100644
--- a/config/service_config_test.go
+++ b/config/service_config_test.go
@@ -183,7 +183,7 @@ func doInitProviderWithSingleRegistry() {
}
}
-func Test_Export(t *testing.T) {
+func TestExport(t *testing.T) {
doInitProvider()
extension.SetProtocol("registry", GetProtocol)
@@ -195,7 +195,7 @@ func Test_Export(t *testing.T) {
providerConfig = nil
}
-func Test_getRandomPort(t *testing.T) {
+func TestgetRandomPort(t *testing.T) {
protocolConfigs := make([]*ProtocolConfig, 0, 3)
ip, err := gxnet.GetLocalIP()