feat: support clusterName into service config

pkg/microservice/aslan/core/common/service/kube/parse.go

@@ -30,6 +30,7 @@ const (
 	envRegexString       = `\$EnvName\$`
 	productRegexString   = `\$Product\$`
 	serviceRegexString   = `\$Service\$`
+	clusterRegexString   = `\$ClusterName\$`
 )
 
 var (
@@ -41,13 +42,15 @@ var (
 	productRegex   = regexp.MustCompile(productRegexString)
 	envNameRegex   = regexp.MustCompile(envRegexString)
 	serviceRegex   = regexp.MustCompile(serviceRegexString)
+	clusterRegex   = regexp.MustCompile(clusterRegexString)
 )
 
 // ParseSysKeys 渲染系统变量键值
-func ParseSysKeys(namespace, envName, productName, serviceName, ori string) string {
+func ParseSysKeys(namespace, envName, productName, serviceName, clusterID, ori string) string {
 	ori = envNameRegex.ReplaceAllLiteralString(ori, strings.ToLower(envName))
 	ori = namespaceRegex.ReplaceAllLiteralString(ori, strings.ToLower(namespace))
 	ori = productRegex.ReplaceAllLiteralString(ori, strings.ToLower(productName))
 	ori = serviceRegex.ReplaceAllLiteralString(ori, strings.ToLower(serviceName))
+	ori = clusterRegex.ReplaceAllLiteralString(ori, strings.ToLower(clusterID))
 	return ori
 }

pkg/microservice/aslan/core/common/service/kube/render.go

@@ -412,7 +412,7 @@ func FetchCurrentAppliedYaml(option *GeneSvcYamlOption) (string, int, error) {
 		if err != nil {
 			return "", 0, err
 		}
-		fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, fullRenderedYaml)
+		fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, productInfo.ClusterID, fullRenderedYaml)
 		mergedContainers := mergeContainers(prodSvcTemplate.Containers, curProductSvc.Containers)
 		fullRenderedYaml, _, err = ReplaceWorkloadImages(fullRenderedYaml, mergedContainers)
 		if err != nil {
@@ -430,7 +430,7 @@ func FetchImportedAllManifests(envInfo *models.Product, serviceTmp *models.Servi
 	if err != nil {
 		return "", nil, err
 	}
-	fullRenderedYaml = ParseSysKeys(envInfo.Namespace, envInfo.EnvName, envInfo.ProductName, serviceTmp.ServiceName, fullRenderedYaml)
+	fullRenderedYaml = ParseSysKeys(envInfo.Namespace, envInfo.EnvName, envInfo.ProductName, serviceTmp.ServiceName, envInfo.ClusterID, fullRenderedYaml)
 
 	manifests := util.SplitManifestsOrdered(fullRenderedYaml)
 
@@ -686,7 +686,7 @@ func FetchImportedManifests(option *GeneSvcYamlOption, productInfo *models.Produ
 	if err != nil {
 		return "", nil, err
 	}
-	fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, fullRenderedYaml)
+	fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, productInfo.ClusterID, fullRenderedYaml)
 
 	manifests := releaseutil.SplitManifests(fullRenderedYaml)
 
@@ -831,7 +831,7 @@ func GenerateRenderedYaml(option *GeneSvcYamlOption) (string, int, []*WorkloadRe
 		if renderErr != nil {
 			return "", 0, nil, renderErr
 		}
-		currentRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, currentRenderedYaml)
+		currentRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, productInfo.ClusterID, currentRenderedYaml)
 		currentBaseReplicaMap, err = ExtractWorkloadReplicas(currentRenderedYaml)
 		if err != nil {
 			return "", 0, nil, err
@@ -860,7 +860,7 @@ func GenerateRenderedYaml(option *GeneSvcYamlOption) (string, int, []*WorkloadRe
 	if err != nil {
 		return "", 0, nil, err
 	}
-	fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, fullRenderedYaml)
+	fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, productInfo.ClusterID, fullRenderedYaml)
 
 	// service may not be deployed in environment, we need to extract containers again, since image related variables may be changed
 	latestSvcTemplate.KubeYamls = util.SplitYaml(fullRenderedYaml)
@@ -977,7 +977,7 @@ func RenderEnvServiceWithTempl(prod *commonmodels.Product, serviceRender *templa
 		log.Errorf("failed to render service yaml, err: %s", err)
 		return "", err
 	}
-	parsedYaml = ParseSysKeys(prod.Namespace, prod.EnvName, prod.ProductName, service.ServiceName, parsedYaml)
+	parsedYaml = ParseSysKeys(prod.Namespace, prod.EnvName, prod.ProductName, service.ServiceName, prod.ClusterID, parsedYaml)
 	parsedYaml, _, err = ReplaceWorkloadImages(parsedYaml, service.Containers)
 	if err != nil {
 		return "", err

pkg/microservice/aslan/core/common/service/service.go

@@ -1422,7 +1422,7 @@ func GetServiceImpl(serviceName string, serviceTmpl *commonmodels.Service, workL
 			return nil, err
 		}
 		// 渲染系统变量键值
-		parsedYaml = kube.ParseSysKeys(namespace, envName, productName, service.ServiceName, parsedYaml)
+		parsedYaml = kube.ParseSysKeys(namespace, envName, productName, service.ServiceName, env.ClusterID, parsedYaml)
 
 		manifests := releaseutil.SplitManifests(parsedYaml)
 		for _, item := range manifests {

pkg/microservice/aslan/core/environment/service/configmap.go

@@ -211,7 +211,7 @@ func UpdateConfigMap(args *models.CreateUpdateCommonEnvCfgArgs, userName string,
 		//for _, kv := range renderSet.KVs {
 		//	value = strings.Replace(value, kv.Alias, kv.Value, -1)
 		//}
-		value = kube.ParseSysKeys(product.Namespace, product.EnvName, product.ProductName, args.ServiceName, value)
+		value = kube.ParseSysKeys(product.Namespace, product.EnvName, product.ProductName, args.ServiceName, product.ClusterID, value)
 		cm.Data[key] = value
 	}
 

pkg/microservice/aslan/core/environment/service/kube.go

@@ -983,7 +983,7 @@ func GetResourceDeployStatus(productName string, request *K8sDeployStatusCheckRe
 		if err != nil {
 			return nil, e.ErrGetResourceDeployInfo.AddErr(fmt.Errorf("failed to render service yaml, serviceName：%s, err: %w", svc.ServiceName, err))
 		}
-		rederedYaml = kube.ParseSysKeys(request.Namespace, request.EnvName, productName, svc.ServiceName, rederedYaml)
+		rederedYaml = kube.ParseSysKeys(request.Namespace, request.EnvName, productName, svc.ServiceName, request.ClusterID, rederedYaml)
 
 		manifests := releaseutil.SplitManifests(rederedYaml)
 		resources := make([]*ResourceDeployStatus, 0)

pkg/microservice/aslan/core/environment/service/service.go

@@ -186,7 +186,7 @@ func GetServiceWorkloads(svcTmpl *commonmodels.Service, env *commonmodels.Produc
 		log.Errorf("failed to render service yaml, err: %s", err)
 		return nil, err
 	}
-	parsedYaml = kube.ParseSysKeys(namespace, envName, productName, svcTmpl.ServiceName, parsedYaml)
+	parsedYaml = kube.ParseSysKeys(namespace, envName, productName, svcTmpl.ServiceName, env.ClusterID, parsedYaml)
 
 	manifests := releaseutil.SplitManifests(parsedYaml)
 	for _, item := range manifests {

pkg/microservice/aslan/core/service/service/environment.go

@@ -44,6 +44,7 @@ type DeployableEnv struct {
 	Alias             string                          `json:"alias"`
 	Namespace         string                          `json:"namespace"`
 	ClusterID         string                          `json:"cluster_id"`
+	ClusterName       string                          `json:"cluster_name"`
 	Services          []*types.ServiceWithVariable    `json:"services"`
 	GlobalVariableKVs []*commontypes.GlobalVariableKV `json:"global_variable_kvs"`
 }
@@ -83,6 +84,33 @@ func GetDeployableEnvs(svcName, projectName string, production bool) (*Deployabl
 
 	return resp, nil
 }
+// getClusterNameMap Get cluster name map.
+func getClusterNameMap() (map[string]string, error) {
+	clusters, err := commonrepo.NewK8SClusterColl().List(&commonrepo.ClusterListOpts{})
+	if err != nil {
+		return nil, err
+	}
+
+	clusterNameMap := make(map[string]string, len(clusters))
+	for _, cluster := range clusters {
+		clusterNameMap[cluster.ID.Hex()] = cluster.Name
+	}
+
+	return clusterNameMap, nil
+}
+
+// newDeployableEnv New deployable environment.	
+func newDeployableEnv(templateProduct *template.Product, env *commonmodels.Product, clusterNameMap map[string]string) *DeployableEnv {
+	return &DeployableEnv{
+		EnvName:           env.EnvName,
+		Alias:             env.Alias,
+		Namespace:         env.Namespace,
+		ClusterID:         env.ClusterID,
+		ClusterName:       clusterNameMap[env.ClusterID],
+		GlobalVariableKVs: env.GlobalVariables,
+		Services:          getServiceVariables(templateProduct, env),
+	}
+}
 
 type GetKubeWorkloadsResp struct {
 	WorkloadsMap map[string][]string `json:"workloads_map"`
@@ -356,20 +384,14 @@ func getAllGeneralEnvs(templateProduct *template.Product, production bool) ([]*D
 		return nil, err
 	}
 
-	ret := make([]*DeployableEnv, len(envs))
+	clusterNameMap, err := getClusterNameMap()
+	if err != nil {
+		return nil, err
+	}
 
-	envNames := make([]string, len(envs))
+	ret := make([]*DeployableEnv, len(envs))
 	for i, env := range envs {
-
-		envNames[i] = env.EnvName
-		ret[i] = &DeployableEnv{
-			EnvName:           env.EnvName,
-			Alias:             env.Alias,
-			Namespace:         env.Namespace,
-			ClusterID:         env.ClusterID,
-			GlobalVariableKVs: env.GlobalVariables,
-			Services:          getServiceVariables(templateProduct, env),
-		}
+		ret[i] = newDeployableEnv(templateProduct, env, clusterNameMap)
 	}
 
 	return ret, nil
@@ -388,23 +410,20 @@ func getDeployableShareEnvs(svcName string, templateProduct *template.Product, p
 			return nil, err
 		}
 
+		clusterNameMap, err := getClusterNameMap()
+		if err != nil {
+			return nil, err
+		}
+
 		ret := make([]*DeployableEnv, 0)
 		for _, baseEnv := range baseEnvs {
-
-			ret = append(ret, &DeployableEnv{
-				EnvName:           baseEnv.EnvName,
-				Alias:             baseEnv.Alias,
-				Namespace:         baseEnv.Namespace,
-				ClusterID:         baseEnv.ClusterID,
-				GlobalVariableKVs: baseEnv.GlobalVariables,
-				Services:          getServiceVariables(templateProduct, baseEnv),
-			})
+			ret = append(ret, newDeployableEnv(templateProduct, baseEnv, clusterNameMap))
 
 			if !hasSvcInEnv(svcName, baseEnv) {
 				continue
 			}
 
-			subEnvs, err := getSubEnvs(baseEnv.EnvName, templateProduct)
+			subEnvs, err := getSubEnvs(baseEnv.EnvName, templateProduct, clusterNameMap)
 			if err != nil {
 				return nil, err
 			}
@@ -424,23 +443,20 @@ func getDeployableShareEnvs(svcName string, templateProduct *template.Product, p
 			return nil, err
 		}
 
+		clusterNameMap, err := getClusterNameMap()
+		if err != nil {
+			return nil, err
+		}
+
 		ret := make([]*DeployableEnv, 0)
 		for _, baseEnv := range baseEnvs {
-
-			ret = append(ret, &DeployableEnv{
-				EnvName:           baseEnv.EnvName,
-				Alias:             baseEnv.Alias,
-				Namespace:         baseEnv.Namespace,
-				ClusterID:         baseEnv.ClusterID,
-				GlobalVariableKVs: baseEnv.GlobalVariables,
-				Services:          getServiceVariables(templateProduct, baseEnv),
-			})
+			ret = append(ret, newDeployableEnv(templateProduct, baseEnv, clusterNameMap))
 
 			if !hasSvcInEnv(svcName, baseEnv) {
 				continue
 			}
 
-			grayEnvs, err := getGrayEnvs(baseEnv.EnvName, baseEnv.ClusterID, templateProduct)
+			grayEnvs, err := getGrayEnvs(baseEnv.EnvName, baseEnv.ClusterID, templateProduct, clusterNameMap)
 			if err != nil {
 				return nil, err
 			}
@@ -452,7 +468,7 @@ func getDeployableShareEnvs(svcName string, templateProduct *template.Product, p
 	}
 }
 
-func getSubEnvs(baseEnvName string, templateProduct *template.Product) ([]*DeployableEnv, error) {
+func getSubEnvs(baseEnvName string, templateProduct *template.Product, clusterNameMap map[string]string) ([]*DeployableEnv, error) {
 	projectName := templateProduct.ProjectName
 	envs, err := commonrepo.NewProductColl().List(&commonrepo.ProductListOptions{
 		Name:            projectName,
@@ -467,20 +483,13 @@ func getSubEnvs(baseEnvName string, templateProduct *template.Product) ([]*Deplo
 
 	ret := make([]*DeployableEnv, len(envs))
 	for i, env := range envs {
-		ret[i] = &DeployableEnv{
-			EnvName:           env.EnvName,
-			Alias:             env.Alias,
-			Namespace:         env.Namespace,
-			ClusterID:         env.ClusterID,
-			GlobalVariableKVs: env.GlobalVariables,
-			Services:          getServiceVariables(templateProduct, env),
-		}
+		ret[i] = newDeployableEnv(templateProduct, env, clusterNameMap)
 	}
 
 	return ret, nil
 }
 
-func getGrayEnvs(baseEnvName, clusterID string, templateProduct *template.Product) ([]*DeployableEnv, error) {
+func getGrayEnvs(baseEnvName, clusterID string, templateProduct *template.Product, clusterNameMap map[string]string) ([]*DeployableEnv, error) {
 	projectName := templateProduct.ProjectName
 	envs, err := commonutil.FetchGrayEnvs(context.TODO(), projectName, clusterID, baseEnvName)
 	if err != nil {
@@ -489,14 +498,7 @@ func getGrayEnvs(baseEnvName, clusterID string, templateProduct *template.Produc
 
 	ret := make([]*DeployableEnv, len(envs))
 	for i, env := range envs {
-		ret[i] = &DeployableEnv{
-			EnvName:           env.EnvName,
-			Alias:             env.Alias,
-			Namespace:         env.Namespace,
-			ClusterID:         env.ClusterID,
-			GlobalVariableKVs: env.GlobalVariables,
-			Services:          getServiceVariables(templateProduct, env),
-		}
+		ret[i] = newDeployableEnv(templateProduct, env, clusterNameMap)
 	}
 
 	return ret, nil

pkg/microservice/aslan/core/service/service/service.go

@@ -181,6 +181,9 @@ func GetServiceOption(args *commonmodels.Service, log *zap.SugaredLogger) (*Serv
 		{
 			Key:   "$EnvName$",
 			Value: ""},
+		{
+			Key:   "$ClusterName$",
+			Value: ""},
 	}
 
 	serviceOption.VariableYaml = args.VariableYaml