support grey cluster

code review

code review

code review

unit test

codereview

code review

Author: wuhua3

cluster/clusterGroup.go

@@ -3,6 +3,7 @@ package cluster
 import (
 	motan "github.com/weibocom/motan-go/core"
 	vlog "github.com/weibocom/motan-go/log"
+	"strconv"
 	"strings"
 	"sync/atomic"
 )
@@ -14,6 +15,7 @@ const (
 type ClusterGroup struct {
 	sandboxClusters []motan.Cluster
 	backupClusters  []motan.Cluster
+	greyClusters    []motan.Cluster
 	backupIndex     uint32
 
 	clusterSelector motan.ClusterSelector
@@ -44,6 +46,13 @@ func NewClusterGroup(context *motan.Context, extFactory motan.ExtensionFactory,
 		vlog.Infof("init backup clusters success. master cluster url: %s, backup groups: %s", url.ToExtInfo(), backupGroup)
 	}
 
+	// gray clusters
+	greyGroups := url.GetParam(motan.GreyGroupsKey, motan.GetDefaultGreyGroups())
+	if greyGroups != "" {
+		clusterGroup.greyClusters = createMultiClusters(context, extFactory, url, proxy, greyGroups, false, true)
+		vlog.Infof("init grey clusters success. master cluster url: %s, grey groups: %s", url.ToExtInfo(), greyGroups)
+	}
+
 	// cluster selector
 	clusterSelectorKey := url.GetParam(motan.ClusterSelectorKey, DefaultClusterSelectorName)
 	clusterSelector := extFactory.GetClusterSelector(clusterSelectorKey)
@@ -72,6 +81,9 @@ func (c *ClusterGroup) GetRuntimeInfo() map[string]interface{} {
 	for _, cluster := range c.backupClusters {
 		info["backup-"+cluster.GetIdentity()] = cluster.GetRuntimeInfo()
 	}
+	for _, cluster := range c.greyClusters {
+		info["grey-"+cluster.GetIdentity()] = cluster.GetRuntimeInfo()
+	}
 	return info
 }
 
@@ -114,6 +126,9 @@ func (c *ClusterGroup) Destroy() {
 	for _, cluster := range c.backupClusters {
 		cluster.Destroy()
 	}
+	for _, cluster := range c.greyClusters {
+		cluster.Destroy()
+	}
 	c.clusterSelector.Destroy()
 }
 
@@ -129,6 +144,10 @@ func (c *ClusterGroup) GetBackupClusters() []motan.Cluster {
 	return c.backupClusters
 }
 
+func (c *ClusterGroup) GetGreyClusters() []motan.Cluster {
+	return c.greyClusters
+}
+
 func (c *ClusterGroup) SetRefersFilter(rf motan.RefersFilter) {
 	c.masterCluster.SetRefersFilter(rf)
 	for _, cluster := range c.sandboxClusters {
@@ -144,23 +163,20 @@ func createMultiClusters(context *motan.Context, extFactory motan.ExtensionFacto
 	groups := motan.TrimSplitSet(groupsStr, motan.GroupNameSeparator)
 	for group := range groups {
 		if strings.HasPrefix(group, motan.GroupSuffixString) {
-			group = url.Group + group[len(motan.GroupSuffixString):]
+			group = group[len(motan.GroupSuffixString):]
+			// if the url.Group end with the group, skip it
+			if strings.HasSuffix(url.Group, group) {
+				continue
+			}
+			group = url.Group + group
 		}
 		// if the group same as url.Group, skip it
 		if group == url.Group {
 			continue
 		}
 		newUrl := url.Copy()
-		if lazyInit {
-			newUrl.PutParam(motan.LazyInit, "true")
-		} else {
-			newUrl.PutParam(motan.LazyInit, "false")
-		}
-		if emptyNodeNotify {
-			newUrl.PutParam(motan.ClusterEmptyNodeNotifyKey, "true")
-		} else {
-			newUrl.PutParam(motan.ClusterEmptyNodeNotifyKey, "false")
-		}
+		newUrl.PutParam(motan.LazyInit, strconv.FormatBool(proxy))
+		newUrl.PutParam(motan.ClusterEmptyNodeNotifyKey, strconv.FormatBool(emptyNodeNotify))
 		newUrl.Group = group
 		cluster := NewCluster(context, extFactory, newUrl, proxy)
 		clusters = append(clusters, cluster)

cluster/clusterGroup_test.go

@@ -45,7 +45,7 @@ func Test_NewClusterGroup(t *testing.T) {
 			},
 		},
 		{
-			"backup and sandbox cluster",
+			"backup、 sandbox and grey cluster",
 			&motan.URL{
 				Protocol: "",
 				Host:     "",
@@ -55,13 +55,15 @@ func Test_NewClusterGroup(t *testing.T) {
 				Parameters: map[string]string{
 					motan.BackupGroupsKey:    "backup1,backup2",
 					motan.SandboxGroupsKey:   "sandbox1",
+					motan.GreyGroupsKey:      "grey1",
 					motan.ClusterSelectorKey: DefaultClusterSelectorName,
 				},
 			},
 			func(t *testing.T, clusterGroup *ClusterGroup) {
 				assert.NotNil(t, clusterGroup.masterCluster)
 				assert.Equal(t, 1, len(clusterGroup.GetSandboxClusters()))
 				assert.Equal(t, 2, len(clusterGroup.GetBackupClusters()))
+				assert.Equal(t, 1, len(clusterGroup.GetGreyClusters()))
 				cs, ok := clusterGroup.clusterSelector.(*DefaultClusterSelector)
 				assert.True(t, ok)
 				assert.Equal(t, clusterGroup, cs.clusterGroup)
@@ -81,6 +83,11 @@ func Test_NewClusterGroup(t *testing.T) {
 					assert.True(t, ok)
 					assert.NotNil(t, v)
 				}
+				for _, cluster := range clusterGroup.GetGreyClusters() {
+					v, ok = runtimeInfo["grey-"+cluster.GetIdentity()]
+					assert.True(t, ok)
+					assert.NotNil(t, v)
+				}
 			},
 		},
 	}

cluster/clusterSelector.go

@@ -8,26 +8,41 @@ import (
 type DefaultClusterSelector struct {
 	clusterGroup          motan.ClusterGroup
 	defaultSandboxCluster motan.Cluster
+	defaultGreyCluster    motan.Cluster
 }
 
 func (d *DefaultClusterSelector) Init(clusterGroup motan.ClusterGroup) {
 	d.clusterGroup = clusterGroup
 	if len(clusterGroup.GetSandboxClusters()) > 0 {
 		d.defaultSandboxCluster = clusterGroup.GetSandboxClusters()[0]
 	}
+	if len(clusterGroup.GetGreyClusters()) > 0 {
+		d.defaultGreyCluster = clusterGroup.GetGreyClusters()[0]
+	}
 }
 
 func (d *DefaultClusterSelector) Select(request motan.Request) motan.Cluster {
-	if d.defaultSandboxCluster != nil && len(d.defaultSandboxCluster.GetRefers()) > 0 {
-		routeGroup := strings.TrimSpace(request.GetAttachment(MRouteGroup))
-		if routeGroup == DefaultSandboxRouteGroup {
+	routeGroup := request.GetAttachment(MRouteGroup)
+	if routeGroup != "" {
+		var sandboxGroup string
+		var greyGroup string
+		if d.defaultSandboxCluster != nil && len(d.defaultSandboxCluster.GetRefers()) > 0 {
+			sandboxGroup = d.defaultSandboxCluster.GetURL().Group
+		}
+		if d.defaultGreyCluster != nil && len(d.defaultGreyCluster.GetRefers()) > 0 {
+			greyGroup = d.defaultGreyCluster.GetURL().Group
+		}
+		if sandboxGroup != "" && strings.TrimSpace(routeGroup) == DefaultSandboxRouteGroup {
 			return d.defaultSandboxCluster
 		}
 		routeGroupList := motan.TrimSplit(routeGroup, ",")
 		for _, group := range routeGroupList {
-			if group == d.clusterGroup.GetURL().Group {
+			if sandboxGroup == group {
 				return d.defaultSandboxCluster
 			}
+			if greyGroup == group {
+				return d.defaultGreyCluster
+			}
 		}
 	}
 	return d.clusterGroup.GetMasterCluster()

cluster/clusterSelector_test.go

@@ -42,9 +42,12 @@ func TestDefaultClusterSelector_Select(t *testing.T) {
 
 	sandboxGroups := []string{"sandbox1", "sandbox2"}
 	sandboxClusters := createMultiClusters(ctx, ext, url, true, strings.Join(sandboxGroups, ","), true, true)
+	greyGroups := []string{"grey1", "grey2", "grey3"}
+	greyClusters := createMultiClusters(ctx, ext, url, true, strings.Join(greyGroups, ","), false, true)
 
 	clusterGroup := &ClusterGroup{
 		sandboxClusters: sandboxClusters,
+		greyClusters:    greyClusters,
 		backupIndex:     0,
 		context:         nil,
 		url:             url,
@@ -90,6 +93,9 @@ func TestDefaultClusterSelector_Select(t *testing.T) {
 	for _, c := range sandboxClusters {
 		c.Notify(RegistryURL, urlList)
 	}
+	for _, c := range greyClusters {
+		c.Notify(RegistryURL, urlList)
+	}
 	attachment.Store(MRouteGroup, DefaultSandboxRouteGroup)
 	for _ = range sandboxGroups {
 		cluster = clusterSelector.Select(request)
@@ -105,11 +111,15 @@ func TestDefaultClusterSelector_Select(t *testing.T) {
 		assert.Equal(t, masterGroup, cluster.GetURL().Group)
 	}
 
-	// sandbox group when motan-route-group equal to the master cluster group
-	attachment.Store(MRouteGroup, url.Group)
-	for _ = range sandboxGroups {
-		cluster = clusterSelector.Select(request)
-		assert.NotNil(t, cluster)
-		assert.Equal(t, clusterSelector.defaultSandboxCluster.GetURL().Group, cluster.GetURL().Group)
-	}
+	// sandbox group when the motan-route-group equal to the sandbox cluster group
+	attachment.Store(MRouteGroup, clusterSelector.defaultSandboxCluster.GetURL().Group)
+	cluster = clusterSelector.Select(request)
+	assert.NotNil(t, cluster)
+	assert.Equal(t, clusterSelector.defaultSandboxCluster.GetURL().Group, cluster.GetURL().Group)
+
+	// grey group when the motan-route-group equal to the grey cluster group
+	attachment.Store(MRouteGroup, clusterSelector.defaultGreyCluster.GetURL().Group)
+	cluster = clusterSelector.Select(request)
+	assert.NotNil(t, cluster)
+	assert.Equal(t, clusterSelector.defaultGreyCluster.GetURL().Group, cluster.GetURL().Group)
 }

core/constants.go

@@ -70,6 +70,7 @@ const (
 	UnixSockProtocolFlag      = "unix://"
 	BackupGroupsKey           = "backupGroups"
 	SandboxGroupsKey          = "sandboxGroups"
+	GreyGroupsKey             = "greyGroups"
 	ClusterSelectorKey        = "clusterSelector"
 	ClusterEmptyNodeNotifyKey = "clusterEmptyNodeNotify"
 )

core/globalContext.go

@@ -81,6 +81,7 @@ var (
 	extFilters = make(map[string]bool)
 
 	defaultSandboxGroups = ""
+	defaultGreyGroups    = ""
 )
 
 // SetDefaultSandboxGroups Called once before Context initialization
@@ -93,6 +94,16 @@ func GetDefaultSandboxGroups() string {
 	return defaultSandboxGroups
 }
 
+// SetDefaultGreyGroups Called once before Context initialization
+func SetDefaultGreyGroups(groups string) {
+	defaultGreyGroups = groups
+}
+
+// GetDefaultGreyGroups returns default grey groups
+func GetDefaultGreyGroups() string {
+	return defaultGreyGroups
+}
+
 // all env flag in motan-go
 var (
 	Port        = flag.Int("port", 0, "agent listen port")

core/motan.go

@@ -344,6 +344,7 @@ type ClusterGroup interface {
 	GetMasterCluster() Cluster
 	GetSandboxClusters() []Cluster
 	GetBackupClusters() []Cluster
+	GetGreyClusters() []Cluster
 	SetRefersFilter(rf RefersFilter)
 }