Merge branch 'develop' of https://github.com/apache/dubbo-go into apache-develop

cluster/router/condition_router.go

@@ -156,10 +156,13 @@ func parseRule(rule string) (map[string]MatchPair, error) {
 	if len(rule) == 0 {
 		return condition, nil
 	}
-	var pair MatchPair
+
+	var (
+		pair       MatchPair
+		startIndex int
+	)
 	values := gxset.NewSet()
 	reg := regexp.MustCompile(`([&!=,]*)\s*([^&!=,\s]+)`)
-	var startIndex = 0
 	if indexTuple := reg.FindIndex([]byte(rule)); len(indexTuple) > 0 {
 		startIndex = indexTuple[0]
 	}
@@ -227,7 +230,7 @@ func MatchCondition(pairs map[string]MatchPair, url *common.URL, param *common.U
 	if sample == nil {
 		return true, perrors.Errorf("url is not allowed be nil")
 	}
-	result := false
+	var result bool
 	for key, matchPair := range pairs {
 		var sampleValue string
 

common/constant/key.go

@@ -103,6 +103,7 @@ const (
 const (
 	CONFIG_NAMESPACE_KEY  = "config.namespace"
 	CONFIG_GROUP_KEY      = "config.group"
+	CONFIG_APP_ID_KEY     = "config.appId"
 	CONFIG_CLUSTER_KEY    = "config.cluster"
 	CONFIG_CHECK_KEY      = "config.check"
 	CONFIG_TIMEOUT_KET    = "config.timeout"

common/extension/filter.go

@@ -33,7 +33,7 @@ func SetFilter(name string, v func() filter.Filter) {
 
 func GetFilter(name string) filter.Filter {
 	if filters[name] == nil {
-		panic("filter for " + name + " is not existing, make sure you have import the package.")
+		panic("filter for " + name + " is not existing, make sure you have imported the package.")
 	}
 	return filters[name]()
 }

common/logger/logger.go

@@ -40,6 +40,11 @@ var (
 	logger Logger
 )
 
+type DubboLogger struct {
+	Logger
+	dynamicLevel zap.AtomicLevel
+}
+
 type Logger interface {
 	Info(args ...interface{})
 	Warn(args ...interface{})
@@ -109,7 +114,8 @@ func InitLogger(conf *zap.Config) {
 		zapLoggerConfig = *conf
 	}
 	zapLogger, _ := zapLoggerConfig.Build(zap.AddCallerSkip(1))
-	logger = zapLogger.Sugar()
+	//logger = zapLogger.Sugar()
+	logger = &DubboLogger{Logger: zapLogger.Sugar(), dynamicLevel: zapLoggerConfig.Level}
 
 	// set getty log
 	getty.SetLogger(logger)
@@ -123,3 +129,22 @@ func SetLogger(log Logger) {
 func GetLogger() Logger {
 	return logger
 }
+
+func SetLoggerLevel(level string) bool {
+	if l, ok := logger.(OpsLogger); ok {
+		l.SetLoggerLevel(level)
+		return true
+	}
+	return false
+}
+
+type OpsLogger interface {
+	Logger
+	SetLoggerLevel(level string)
+}
+
+func (dl *DubboLogger) SetLoggerLevel(level string) {
+	l := new(zapcore.Level)
+	l.Set(level)
+	dl.dynamicLevel.SetLevel(*l)
+}

common/logger/logger_test.go

@@ -65,3 +65,19 @@ func TestInitLog(t *testing.T) {
 	Warnf("%s", "warn")
 	Errorf("%s", "error")
 }
+
+func TestSetLevel(t *testing.T) {
+	err := InitLog("./log.yml")
+	assert.NoError(t, err)
+	Debug("debug")
+	Info("info")
+
+	assert.True(t, SetLoggerLevel("info"))
+	Debug("debug")
+	Info("info")
+
+	SetLogger(GetLogger().(*DubboLogger).Logger)
+	assert.False(t, SetLoggerLevel("debug"))
+	Debug("debug")
+	Info("info")
+}

common/url.go

@@ -156,7 +156,9 @@ func WithToken(token string) option {
 		if len(token) > 0 {
 			value := token
 			if strings.ToLower(token) == "true" || strings.ToLower(token) == "default" {
-				value = uuid.NewV4().String()
+				if id, err := uuid.NewV4(); err == nil {
+					value = id.String()
+				}
 			}
 			url.SetParam(constant.TOKEN_KEY, value)
 		}

config/base_config.go

@@ -68,7 +68,7 @@ func (c *BaseConfig) prepareEnvironment() error {
 		logger.Errorf("Get dynamic configuration error , error message is %v", err)
 		return perrors.WithStack(err)
 	}
-	content, err := dynamicConfig.GetConfig(c.ConfigCenterConfig.ConfigFile, config_center.WithGroup(c.ConfigCenterConfig.Group))
+	content, err := dynamicConfig.GetProperties(c.ConfigCenterConfig.ConfigFile, config_center.WithGroup(c.ConfigCenterConfig.Group))
 	if err != nil {
 		logger.Errorf("Get config content in dynamic configuration error , error message is %v", err)
 		return perrors.WithStack(err)
@@ -88,7 +88,7 @@ func (c *BaseConfig) prepareEnvironment() error {
 		if len(configFile) == 0 {
 			configFile = c.ConfigCenterConfig.ConfigFile
 		}
-		appContent, err = dynamicConfig.GetConfig(configFile, config_center.WithGroup(appGroup))
+		appContent, err = dynamicConfig.GetProperties(configFile, config_center.WithGroup(appGroup))
 	}
 	//global config file
 	mapContent, err := dynamicConfig.Parser().Parse(content)

config/config_center_config.go

@@ -42,6 +42,7 @@ type ConfigCenterConfig struct {
 	ConfigFile    string `default:"dubbo.properties" yaml:"config_file"  json:"config_file,omitempty"`
 	Namespace     string `default:"dubbo.properties" yaml:"namespace"  json:"namespace,omitempty"`
 	AppConfigFile string `default:"dubbo.properties" yaml:"app_config_file"  json:"app_config_file,omitempty"`
+	AppId         string `default:"dubbo" yaml:"app_id"  json:"app_id,omitempty"`
 	TimeoutStr    string `yaml:"timeout"  json:"timeout,omitempty"`
 	timeout       time.Duration
 }
@@ -62,5 +63,6 @@ func (c *ConfigCenterConfig) GetUrlMap() url.Values {
 	urlMap.Set(constant.CONFIG_NAMESPACE_KEY, c.Namespace)
 	urlMap.Set(constant.CONFIG_GROUP_KEY, c.Group)
 	urlMap.Set(constant.CONFIG_CLUSTER_KEY, c.Cluster)
+	urlMap.Set(constant.CONFIG_APP_ID_KEY, c.AppId)
 	return urlMap
 }

config_center/apollo/impl.go

@@ -57,7 +57,7 @@ func newApolloConfiguration(url *common.URL) (*apolloConfiguration, error) {
 	configAddr := c.getAddressWithProtocolPrefix(url)
 	configCluster := url.GetParam(constant.CONFIG_CLUSTER_KEY, "")
 
-	appId := url.GetParam(constant.CONFIG_GROUP_KEY, DEFAULT_GROUP)
+	appId := url.GetParam(constant.CONFIG_APP_ID_KEY, "")
 	namespaces := url.GetParam(constant.CONFIG_NAMESPACE_KEY, getProperties(DEFAULT_GROUP))
 	c.appConf = &agollo.AppConfig{
 		AppId:         appId,
@@ -116,32 +116,28 @@ func getNamespaceName(namespace string, configFileFormat agollo.ConfigFileFormat
 	return fmt.Sprintf(apolloConfigFormat, namespace, configFileFormat)
 }
 
-func (c *apolloConfiguration) GetConfig(key string, opts ...Option) (string, error) {
-	k := &Options{}
-	for _, opt := range opts {
-		opt(k)
+func (c *apolloConfiguration) GetInternalProperty(key string, opts ...Option) (string, error) {
+	config := agollo.GetConfig(c.appConf.NamespaceName)
+	if config == nil {
+		return "", errors.New(fmt.Sprintf("nothing in namespace:%s ", key))
 	}
+	return config.GetStringValue(key, ""), nil
+}
+
+func (c *apolloConfiguration) GetRule(key string, opts ...Option) (string, error) {
+	return c.GetInternalProperty(key, opts...)
+}
+
+func (c *apolloConfiguration) GetProperties(key string, opts ...Option) (string, error) {
 	/**
 	 * when group is not null, we are getting startup configs(config file) from Config Center, for example:
 	 * key=dubbo.propertie
 	 */
-	if len(k.Group) != 0 {
-		config := agollo.GetConfig(key)
-		if config == nil {
-			return "", errors.New(fmt.Sprintf("nothiing in namespace:%s ", key))
-		}
-		return config.GetContent(agollo.Properties), nil
-	}
-
-	/**
-	 * when group is null, we are fetching governance rules(config item) from Config Center, for example:
-	 * namespace=use default, key =application.organization
-	 */
-	config := agollo.GetConfig(c.appConf.NamespaceName)
+	config := agollo.GetConfig(key)
 	if config == nil {
-		return "", errors.New(fmt.Sprintf("nothiing in namespace:%s ", key))
+		return "", errors.New(fmt.Sprintf("nothing in namespace:%s ", key))
 	}
-	return config.GetStringValue(key, ""), nil
+	return config.GetContent(agollo.Properties), nil
 }
 
 func (c *apolloConfiguration) getAddressWithProtocolPrefix(url *common.URL) string {
@@ -170,7 +166,3 @@ func (c *apolloConfiguration) Parser() parser.ConfigurationParser {
 func (c *apolloConfiguration) SetParser(p parser.ConfigurationParser) {
 	c.parser = p
 }
-
-func (c *apolloConfiguration) GetConfigs(key string, opts ...Option) (string, error) {
-	return c.GetConfig(key, opts...)
-}

config_center/apollo/impl_test.go

@@ -165,7 +165,7 @@ func runMockConfigServer(handlerMap map[string]func(http.ResponseWriter, *http.R
 
 func Test_GetConfig(t *testing.T) {
 	configuration := initMockApollo(t)
-	configs, err := configuration.GetConfig(mockNamespace, config_center.WithGroup("dubbo"))
+	configs, err := configuration.GetProperties(mockNamespace, config_center.WithGroup("dubbo"))
 	assert.NoError(t, err)
 	configuration.SetParser(&parser.DefaultConfigurationParser{})
 	mapContent, err := configuration.Parser().Parse(configs)
@@ -175,7 +175,7 @@ func Test_GetConfig(t *testing.T) {
 
 func Test_GetConfigItem(t *testing.T) {
 	configuration := initMockApollo(t)
-	configs, err := configuration.GetConfig("application.organization")
+	configs, err := configuration.GetInternalProperty("application.organization")
 	assert.NoError(t, err)
 	configuration.SetParser(&parser.DefaultConfigurationParser{})
 	assert.NoError(t, err)
@@ -186,7 +186,7 @@ func initMockApollo(t *testing.T) *apolloConfiguration {
 	c := &config.BaseConfig{ConfigCenterConfig: &config.ConfigCenterConfig{
 		Protocol:  "apollo",
 		Address:   "106.12.25.204:8080",
-		Group:     "testApplication_yang",
+		AppId:     "testApplication_yang",
 		Cluster:   "dev",
 		Namespace: "mockDubbog.properties",
 	}}

config_center/dynamic_configuration.go

@@ -36,8 +36,14 @@ type DynamicConfiguration interface {
 	SetParser(parser.ConfigurationParser)
 	AddListener(string, ConfigurationListener, ...Option)
 	RemoveListener(string, ConfigurationListener, ...Option)
-	GetConfig(string, ...Option) (string, error)
-	GetConfigs(string, ...Option) (string, error)
+	//GetProperties get properties file
+	GetProperties(string, ...Option) (string, error)
+
+	//GetRule get Router rule properties file
+	GetRule(string, ...Option) (string, error)
+
+	//GetInternalProperty get value by key in Default properties file(dubbo.properties)
+	GetInternalProperty(string, ...Option) (string, error)
 }
 
 type Options struct {

config_center/mock_dynamic_config.go

@@ -108,6 +108,18 @@ func (c *MockDynamicConfiguration) Parser() parser.ConfigurationParser {
 func (c *MockDynamicConfiguration) SetParser(p parser.ConfigurationParser) {
 	c.parser = p
 }
+func (c *MockDynamicConfiguration) GetProperties(key string, opts ...Option) (string, error) {
+	return c.content, nil
+}
+
+//For zookeeper, getConfig and getConfigs have the same meaning.
+func (c *MockDynamicConfiguration) GetInternalProperty(key string, opts ...Option) (string, error) {
+	return c.GetProperties(key, opts...)
+}
+
+func (c *MockDynamicConfiguration) GetRule(key string, opts ...Option) (string, error) {
+	return c.GetProperties(key, opts...)
+}
 
 func (c *MockDynamicConfiguration) MockServiceConfigEvent() {
 	config := &parser.ConfiguratorConfig{

config_center/parser/configuration_parser.go

@@ -134,14 +134,14 @@ func serviceItemToUrls(item ConfigItem, config ConfiguratorConfig) ([]*common.UR
 				newUrlStr = newUrlStr + v
 				url, err := common.NewURL(context.Background(), newUrlStr)
 				if err != nil {
-					perrors.WithStack(err)
+					return nil, perrors.WithStack(err)
 				}
 				urls = append(urls, &url)
 			}
 		} else {
 			url, err := common.NewURL(context.Background(), urlStr)
 			if err != nil {
-				perrors.WithStack(err)
+				return nil, perrors.WithStack(err)
 			}
 			urls = append(urls, &url)
 		}

config_center/zookeeper/impl.go

@@ -109,7 +109,7 @@ func (c *zookeeperDynamicConfiguration) RemoveListener(key string, listener conf
 	c.cacheListener.RemoveListener(key, listener)
 }
 
-func (c *zookeeperDynamicConfiguration) GetConfig(key string, opts ...config_center.Option) (string, error) {
+func (c *zookeeperDynamicConfiguration) GetProperties(key string, opts ...config_center.Option) (string, error) {
 
 	tmpOpts := &config_center.Options{}
 	for _, opt := range opts {
@@ -141,8 +141,12 @@ func (c *zookeeperDynamicConfiguration) GetConfig(key string, opts ...config_cen
 }
 
 //For zookeeper, getConfig and getConfigs have the same meaning.
-func (c *zookeeperDynamicConfiguration) GetConfigs(key string, opts ...config_center.Option) (string, error) {
-	return c.GetConfig(key, opts...)
+func (c *zookeeperDynamicConfiguration) GetInternalProperty(key string, opts ...config_center.Option) (string, error) {
+	return c.GetProperties(key, opts...)
+}
+
+func (c *zookeeperDynamicConfiguration) GetRule(key string, opts ...config_center.Option) (string, error) {
+	return c.GetProperties(key, opts...)
 }
 
 func (c *zookeeperDynamicConfiguration) Parser() parser.ConfigurationParser {

config_center/zookeeper/impl_test.go

@@ -81,7 +81,7 @@ func initZkData(group string, t *testing.T) (*zk.TestCluster, *zookeeperDynamicC
 func Test_GetConfig(t *testing.T) {
 	ts, reg := initZkData("dubbo", t)
 	defer ts.Stop()
-	configs, err := reg.GetConfig("dubbo.properties", config_center.WithGroup("dubbo"))
+	configs, err := reg.GetProperties("dubbo.properties", config_center.WithGroup("dubbo"))
 	assert.NoError(t, err)
 	m, err := reg.Parser().Parse(configs)
 	assert.NoError(t, err)

filter/impl/tps/impl/tps_limit_fix_window_strategy.go

@@ -21,6 +21,7 @@ import (
 	"sync/atomic"
 	"time"
 )
+
 import (
 	"github.com/apache/dubbo-go/common/constant"
 	"github.com/apache/dubbo-go/common/extension"
@@ -78,7 +79,7 @@ func (impl *FixedWindowTpsLimitStrategyImpl) IsAllowable() bool {
 func NewFixedWindowTpsLimitStrategyImpl(rate int, interval int) tps.TpsLimitStrategy {
 	return &FixedWindowTpsLimitStrategyImpl{
 		rate:      int32(rate),
-		interval:  int64(interval * 1000), // convert to ns
+		interval:  int64(interval) * int64(time.Millisecond), // convert to ns
 		count:     0,
 		timestamp: time.Now().UnixNano(),
 	}

filter/impl/tps/impl/tps_limit_fix_window_strategy_test.go

@@ -36,7 +36,7 @@ func TestFixedWindowTpsLimitStrategyImpl_IsAllowable(t *testing.T) {
 	assert.True(t, strategy.IsAllowable())
 	assert.True(t, strategy.IsAllowable())
 	assert.False(t, strategy.IsAllowable())
-	time.Sleep(time.Duration(2100 * 1000))
+	time.Sleep(2100 * time.Millisecond)
 	assert.True(t, strategy.IsAllowable())
 	assert.True(t, strategy.IsAllowable())
 	assert.False(t, strategy.IsAllowable())

filter/impl/tps/impl/tps_limit_sliding_window_strategy.go

@@ -83,7 +83,7 @@ func (impl *SlidingWindowTpsLimitStrategyImpl) IsAllowable() bool {
 func NewSlidingWindowTpsLimitStrategyImpl(rate int, interval int) tps.TpsLimitStrategy {
 	return &SlidingWindowTpsLimitStrategyImpl{
 		rate:     rate,
-		interval: int64(interval * 1000),
+		interval: int64(interval) * int64(time.Millisecond),
 		mutex:    &sync.Mutex{},
 		queue:    list.New(),
 	}

filter/impl/tps/impl/tps_limit_sliding_window_strategy_test.go

@@ -31,14 +31,14 @@ func TestSlidingWindowTpsLimitStrategyImpl_IsAllowable(t *testing.T) {
 	assert.True(t, strategy.IsAllowable())
 	assert.True(t, strategy.IsAllowable())
 	assert.False(t, strategy.IsAllowable())
-	time.Sleep(time.Duration(2100 * 1000))
+	time.Sleep(2100 * time.Millisecond)
 	assert.False(t, strategy.IsAllowable())
 
 	strategy = NewSlidingWindowTpsLimitStrategyImpl(2, 2000)
 	assert.True(t, strategy.IsAllowable())
 	assert.True(t, strategy.IsAllowable())
 	assert.False(t, strategy.IsAllowable())
-	time.Sleep(time.Duration(2100 * 1000))
+	time.Sleep(2100 * time.Millisecond)
 	assert.True(t, strategy.IsAllowable())
 	assert.True(t, strategy.IsAllowable())
 	assert.False(t, strategy.IsAllowable())

filter/impl/tps/impl/tps_limit_thread_safe_fix_window_strategy_test.go

@@ -36,7 +36,7 @@ func TestThreadSafeFixedWindowTpsLimitStrategyImpl_IsAllowable(t *testing.T) {
 	assert.True(t, strategy.IsAllowable())
 	assert.True(t, strategy.IsAllowable())
 	assert.False(t, strategy.IsAllowable())
-	time.Sleep(time.Duration(2100 * 1000))
+	time.Sleep(2100 * time.Millisecond)
 	assert.True(t, strategy.IsAllowable())
 	assert.True(t, strategy.IsAllowable())
 	assert.False(t, strategy.IsAllowable())