Ftr: condition router

cluster/router/condition/factory.go

@@ -33,22 +33,27 @@ func init() {
 type ConditionRouterFactory struct{}
 
 func newConditionRouterFactory() router.RouterFactory {
-	return ConditionRouterFactory{}
+	return &ConditionRouterFactory{}
 }
 
 // NewRouter Create ConditionRouterFactory by URL
-func (c ConditionRouterFactory) NewRouter(url *common.URL) (router.Router, error) {
+func (c *ConditionRouterFactory) NewRouter(url *common.URL) (router.Router, error) {
 	return NewConditionRouter(url)
 }
 
+// NewRouter Create FileRouterFactory by Content
+func (c *ConditionRouterFactory) NewFileRouter(content []byte) (router.Router, error) {
+	return NewFileConditionRouter(content)
+}
+
 // AppRouterFactory Application router factory
 type AppRouterFactory struct{}
 
 func newAppRouterFactory() router.RouterFactory {
-	return AppRouterFactory{}
+	return &AppRouterFactory{}
 }
 
 // NewRouter Create AppRouterFactory by URL
-func (c AppRouterFactory) NewRouter(url *common.URL) (router.Router, error) {
+func (c *AppRouterFactory) NewRouter(url *common.URL) (router.Router, error) {
 	return NewAppRouter(url)
 }

cluster/router/condition/file.go

@@ -0,0 +1,101 @@
+/*
+ * 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 condition
+
+import (
+	"encoding/base64"
+	"net/url"
+	"strconv"
+	"strings"
+)
+
+import (
+	perrors "github.com/pkg/errors"
+)
+
+import (
+	"github.com/apache/dubbo-go/common"
+	"github.com/apache/dubbo-go/common/constant"
+)
+
+type FileConditionRouter struct {
+	listenableRouter
+}
+
+func NewFileConditionRouter(content []byte) (*FileConditionRouter, error) {
+	fileRouter := &FileConditionRouter{}
+	rule, err := Parse(string(content))
+	if err != nil {
+		return nil, perrors.Errorf("yaml.Unmarshal() failed , error:%v", perrors.WithStack(err))
+	}
+
+	if !rule.Valid {
+		return nil, perrors.Errorf("rule content is not verify for condition router , error:%v", perrors.WithStack(err))
+	}
+
+	fileRouter.generateConditions(rule)
+
+	return fileRouter, nil
+}
+
+func (f *FileConditionRouter) URL() common.URL {
+	routerRule := f.routerRule
+	rule := parseCondition(routerRule.Conditions)
+	return *common.NewURLWithOptions(
+		common.WithProtocol(constant.ROUTE_PROTOCOL),
+		common.WithIp(constant.ANYHOST_VALUE),
+		common.WithParams(url.Values{}),
+		common.WithParamsValue(constant.RouterForce, strconv.FormatBool(routerRule.Force)),
+		common.WithParamsValue(constant.RouterPriority, strconv.Itoa(routerRule.Priority)),
+		common.WithParamsValue(constant.RULE_KEY, base64.URLEncoding.EncodeToString([]byte(rule))),
+		common.WithParamsValue(constant.ROUTER_KEY, "condition"),
+		common.WithParamsValue(constant.CATEGORY_KEY, constant.ROUTERS_CATEGORY))
+}
+
+func parseCondition(conditions []string) string {
+	var (
+		when string
+		then string
+	)
+	for _, condition := range conditions {
+		condition = strings.Trim(condition, " ")
+		if strings.Contains(condition, "=>") {
+			array := strings.SplitN(condition, "=>", 2)
+			consumer := strings.Trim(array[0], " ")
+			provider := strings.Trim(array[1], " ")
+			if len(consumer) != 0 {
+				if len(when) != 0 {
+					when = strings.Join([]string{when, consumer}, " & ")
+				} else {
+					when = consumer
+				}
+			}
+			if len(provider) != 0 {
+				if len(then) != 0 {
+					then = strings.Join([]string{then, provider}, " & ")
+				} else {
+					then = provider
+				}
+			}
+
+		}
+
+	}
+
+	return strings.Join([]string{when, then}, " => ")
+}

cluster/router/condition/file_test.go

@@ -0,0 +1,47 @@
+/*
+ * 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 condition
+
+import (
+	"testing"
+)
+
+import (
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLoadYmlConfig(t *testing.T) {
+	router, e := NewFileConditionRouter([]byte(`priority: 1
+force: true
+conditions :
+  - "a => b"
+  - "c => d"`))
+	assert.Nil(t, e)
+	assert.NotNil(t, router)
+	assert.Equal(t, router.routerRule.Priority, 1)
+	assert.Equal(t, router.routerRule.Force, true)
+	assert.Equal(t, len(router.routerRule.Conditions), 2)
+}
+
+func TestParseCondition(t *testing.T) {
+	s := make([]string, 2)
+	s = append(s, "a => b")
+	s = append(s, "c => d")
+	condition := parseCondition(s)
+	assert.Equal(t, "a & c => b & d", condition)
+}

cluster/router/router.go

@@ -30,6 +30,11 @@ type RouterFactory interface {
 	NewRouter(*common.URL) (Router, error)
 }
 
+type FIleRouterFactory interface {
+	// NewFileRouters Create file router with config file
+	NewFileRouter([]byte) (Router, error)
+}
+
 // Router
 type Router interface {
 	// Route Determine the target invokers list.

common/extension/router_factory.go

@@ -17,12 +17,18 @@
 
 package extension
 
+import (
+	"sync"
+)
+
 import (
 	"github.com/apache/dubbo-go/cluster/router"
 )
 
 var (
-	routers = make(map[string]func() router.RouterFactory)
+	routers               = make(map[string]func() router.RouterFactory)
+	fileRouterFactoryOnce sync.Once
+	fileRouterFactories   = make(map[string]router.FIleRouterFactory)
 )
 
 // SetRouterFactory Set create router factory function by name
@@ -42,3 +48,20 @@ func GetRouterFactory(name string) router.RouterFactory {
 func GetRouterFactories() map[string]func() router.RouterFactory {
 	return routers
 }
+
+// GetFileRouterFactories Get all create file router factory instance
+func GetFileRouterFactories() map[string]router.FIleRouterFactory {
+	l := len(routers)
+	if l == 0 {
+		return nil
+	}
+	fileRouterFactoryOnce.Do(func() {
+		for k := range routers {
+			factory := GetRouterFactory(k)
+			if fr, ok := factory.(router.FIleRouterFactory); ok {
+				fileRouterFactories[k] = fr
+			}
+		}
+	})
+	return fileRouterFactories
+}

config/base_config.go

@@ -27,7 +27,6 @@ import (
 
 import (
 	perrors "github.com/pkg/errors"
-	"gopkg.in/yaml.v2"
 )
 
 import (
@@ -364,22 +363,15 @@ func initializeStruct(t reflect.Type, v reflect.Value) {
 
 }
 
-func loadYmlConfig(confRouterFile string, i interface{}) error {
+// loadYmlConfig Load yml config byte from file
+func loadYmlConfig(confRouterFile string) ([]byte, error) {
 	if len(confRouterFile) == 0 {
-		return perrors.Errorf("application configure(provider) file name is nil")
+		return nil, perrors.Errorf("application configure(provider) file name is nil")
 	}
 
 	if path.Ext(confRouterFile) != ".yml" {
-		return perrors.Errorf("application configure file name{%v} suffix must be .yml", confRouterFile)
+		return nil, perrors.Errorf("application configure file name{%v} suffix must be .yml", confRouterFile)
 	}
 
-	confFileStream, err := ioutil.ReadFile(confRouterFile)
-	if err != nil {
-		return perrors.Errorf("ioutil.ReadFile(file:%s) = error:%v", confRouterFile, perrors.WithStack(err))
-	}
-	err = yaml.Unmarshal(confFileStream, i)
-	if err != nil {
-		return perrors.Errorf("yaml.Unmarshal() = error:%v", perrors.WithStack(err))
-	}
-	return nil
+	return ioutil.ReadFile(confRouterFile)
 }

config/condition_router_config.go

@@ -18,93 +18,30 @@
 package config
 
 import (
-	"encoding/base64"
-	"net/url"
-	"strconv"
-	"strings"
-	"sync"
+	perrors "github.com/pkg/errors"
 )
 
 import (
 	"github.com/apache/dubbo-go/cluster/directory"
-	"github.com/apache/dubbo-go/common"
-	"github.com/apache/dubbo-go/common/constant"
+	"github.com/apache/dubbo-go/common/extension"
 	"github.com/apache/dubbo-go/common/logger"
 )
 
-var (
-	mutex sync.Mutex
-)
-
-// ConditionRouterConfig Condition router config map to router config file
-type ConditionRouterConfig struct {
-	Priority   int      `yaml:"priority"`
-	Force      bool     `yaml:"force" default:"false"`
-	Conditions []string `yaml:"conditions"`
-}
-
-// Prefix Return router config prefix
-func (*ConditionRouterConfig) Prefix() string {
-	return constant.RouterConfigPrefix
-}
-
 //RouterInit Load config file to init router config
 func RouterInit(confRouterFile string) error {
-	routerConfig = &ConditionRouterConfig{}
-	e := loadYmlConfig(confRouterFile, routerConfig)
-
-	if e != nil {
-		return e
+	fileRouterFactories := extension.GetFileRouterFactories()
+	bytes, err := loadYmlConfig(confRouterFile)
+	if err != nil {
+		return perrors.Errorf("ioutil.ReadFile(file:%s) = error:%v", confRouterFile, perrors.WithStack(err))
 	}
-
-	logger.Debugf("router config{%#v}\n", routerConfig)
-	directory.AddRouterURLSet(initRouterUrl(routerConfig))
-	return nil
-}
-
-func initRouterUrl(routerConfig *ConditionRouterConfig) *common.URL {
-	rule := parseCondition(routerConfig.Conditions)
-
-	return common.NewURLWithOptions(
-		common.WithProtocol(constant.ROUTE_PROTOCOL),
-		common.WithIp(constant.ANYHOST_VALUE),
-		common.WithParams(url.Values{}),
-		common.WithParamsValue("force", strconv.FormatBool(routerConfig.Force)),
-		common.WithParamsValue("priority", strconv.Itoa(routerConfig.Priority)),
-		common.WithParamsValue(constant.RULE_KEY, base64.URLEncoding.EncodeToString([]byte(rule))),
-		common.WithParamsValue("router", "condition"),
-		common.WithParamsValue(constant.CATEGORY_KEY, constant.ROUTERS_CATEGORY))
-}
-
-func parseCondition(conditions []string) string {
-	var (
-		when string
-		then string
-	)
-	for _, condition := range conditions {
-		condition = strings.Trim(condition, " ")
-		if strings.Contains(condition, "=>") {
-			array := strings.SplitN(condition, "=>", 2)
-			consumer := strings.Trim(array[0], " ")
-			provider := strings.Trim(array[1], " ")
-			if len(consumer) != 0 {
-				if len(when) != 0 {
-					when = strings.Join([]string{when, consumer}, " & ")
-				} else {
-					when = consumer
-				}
-			}
-			if len(provider) != 0 {
-				if len(then) != 0 {
-					then = strings.Join([]string{then, provider}, " & ")
-				} else {
-					then = provider
-				}
-			}
-
+	for k, factory := range fileRouterFactories {
+		r, e := factory.NewFileRouter(bytes)
+		if e == nil {
+			url := r.URL()
+			directory.AddRouterURLSet(&url)
+			break
 		}
-
+		logger.Warnf("router config type %s create fail \n", k)
 	}
-
-	return strings.Join([]string{when, then}, " => ")
+	return nil
 }