feat: add cluster name 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, clusterName, 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(clusterName))
 	return ori
 }

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

@@ -385,6 +385,12 @@ func FetchCurrentAppliedYaml(option *GeneSvcYamlOption) (string, int, error) {
 		return "", 0, errors.Wrapf(err, "failed to find product %s", option.ProductName)
 	}
 
+	// get cluster name by cluster id
+	clusterName, err := GetClusterNameByID(productInfo.ClusterID)
+	if err != nil {
+		return "", 0, err
+	}
+
 	curProductSvc := productInfo.GetServiceMap()[option.ServiceName]
 
 	// service not installed, nothing to return
@@ -412,7 +418,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, clusterName, fullRenderedYaml)
 		mergedContainers := mergeContainers(prodSvcTemplate.Containers, curProductSvc.Containers)
 		fullRenderedYaml, _, err = ReplaceWorkloadImages(fullRenderedYaml, mergedContainers)
 		if err != nil {
@@ -430,7 +436,12 @@ 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)
+	// get cluster name by cluster id
+	clusterName, err := GetClusterNameByID(envInfo.ClusterID)
+	if err != nil {
+		return "", nil, err
+	}
+	fullRenderedYaml = ParseSysKeys(envInfo.Namespace, envInfo.EnvName, envInfo.ProductName, serviceTmp.ServiceName, clusterName, fullRenderedYaml)
 
 	manifests := util.SplitManifestsOrdered(fullRenderedYaml)
 
@@ -686,7 +697,12 @@ func FetchImportedManifests(option *GeneSvcYamlOption, productInfo *models.Produ
 	if err != nil {
 		return "", nil, err
 	}
-	fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, fullRenderedYaml)
+	// get cluster name by id
+	clusterName, err := GetClusterNameByID(productInfo.ClusterID)
+	if err != nil {
+		return "", nil, err
+	}
+	fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, clusterName, fullRenderedYaml)
 
 	manifests := releaseutil.SplitManifests(fullRenderedYaml)
 
@@ -770,6 +786,12 @@ func GenerateRenderedYaml(option *GeneSvcYamlOption) (string, int, []*WorkloadRe
 		return "", 0, nil, errors.Wrapf(err, "failed to find product %s", option.ProductName)
 	}
 
+	// get cluster name by id
+	clusterName, err := GetClusterNameByID(productInfo.ClusterID)
+	if err != nil {
+		return "", 0, nil, err
+	}
+
 	curProductSvc := productInfo.GetServiceMap()[option.ServiceName]
 
 	// nothing to render when trying to uninstall a service which is not deployed
@@ -831,7 +853,7 @@ func GenerateRenderedYaml(option *GeneSvcYamlOption) (string, int, []*WorkloadRe
 		if renderErr != nil {
 			return "", 0, nil, fmt.Errorf("failed to render current service yaml: %v", renderErr)
 		}
-		currentRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, currentRenderedYaml)
+		currentRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, clusterName, currentRenderedYaml)
 		currentBaseReplicaMap, err = ExtractWorkloadReplicas(currentRenderedYaml)
 		if err != nil {
 			return "", 0, nil, fmt.Errorf("failed to extract workload replicas: %v", err)
@@ -860,7 +882,7 @@ func GenerateRenderedYaml(option *GeneSvcYamlOption) (string, int, []*WorkloadRe
 	if err != nil {
 		return "", 0, nil, fmt.Errorf("failed to render service yaml: %v", err)
 	}
-	fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, fullRenderedYaml)
+	fullRenderedYaml = ParseSysKeys(productInfo.Namespace, productInfo.EnvName, option.ProductName, option.ServiceName, clusterName, 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)
@@ -971,20 +993,33 @@ func RenderEnvService(prod *commonmodels.Product, serviceRender *template.Servic
 		return "", err
 	}
 
-	return RenderEnvServiceWithTempl(prod, serviceRender, service, svcTmpl)
+	// get cluster name by cluster id
+	clusterName, err := GetClusterNameByID(prod.ClusterID)
+	if err != nil {
+		return "", err
+	}
+	return RenderEnvServiceWithTempl(prod, serviceRender, service, svcTmpl, clusterName)
 }
 
-func RenderEnvServiceWithTempl(prod *commonmodels.Product, serviceRender *template.ServiceRender, service *commonmodels.ProductService, svcTmpl *commonmodels.Service) (yaml string, err error) {
+func RenderEnvServiceWithTempl(prod *commonmodels.Product, serviceRender *template.ServiceRender, service *commonmodels.ProductService, svcTmpl *commonmodels.Service, clusterName string) (yaml string, err error) {
 	// Note only the keys in TemplateService.ServiceVar can work
 	parsedYaml, err := RenderServiceYaml(svcTmpl.Yaml, prod.ProductName, svcTmpl.ServiceName, serviceRender)
 	if err != nil {
 		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, clusterName, parsedYaml)
 	parsedYaml, _, err = ReplaceWorkloadImages(parsedYaml, service.Containers)
 	if err != nil {
 		return "", err
 	}
 	return ApplyReplicaOverrides(parsedYaml, service.WorkLoads)
 }
+
+func GetClusterNameByID(clusterID string) (string, error) {
+	cluster, err := commonrepo.NewK8SClusterColl().FindByID(clusterID)
+	if err != nil {
+		return "", errors.Wrapf(err, "failed to find cluster by id %s", clusterID)
+	}
+	return cluster.Name, nil
+}

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

@@ -1361,6 +1361,12 @@ func GetServiceImpl(serviceName string, serviceTmpl *commonmodels.Service, workL
 	err = nil
 
 	namespace := env.Namespace
+	// get cluster name by id
+	clusterName, err := kube.GetClusterNameByID(env.ClusterID)
+	if err != nil {
+		log.Errorf("", err)
+		return nil, err
+	}
 	switch env.Source {
 	case setting.SourceFromHelm:
 		k8sServices, _ := getter.ListServicesWithCache(nil, inf)
@@ -1421,8 +1427,9 @@ func GetServiceImpl(serviceName string, serviceTmpl *commonmodels.Service, workL
 			log.Errorf("failed to render service yaml, err: %s", err)
 			return nil, err
 		}
-		// 渲染系统变量键值
-		parsedYaml = kube.ParseSysKeys(namespace, envName, productName, service.ServiceName, parsedYaml)
+
+		// render system kv value
+		parsedYaml = kube.ParseSysKeys(namespace, envName, productName, service.ServiceName, clusterName, parsedYaml)
 
 		manifests := releaseutil.SplitManifests(parsedYaml)
 		for _, item := range manifests {

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

@@ -204,14 +204,20 @@ func UpdateConfigMap(args *models.CreateUpdateCommonEnvCfgArgs, userName string,
 		return e.ErrUpdateConfigMap.AddErr(err)
 	}
 
+	// get clusterName by id
+	clusterName, err := kube.GetClusterNameByID(product.ClusterID)
+	if err != nil {
+		return e.ErrUpdateConfigMap.AddErr(err)
+	}
+
 	namespace := product.Namespace
 
 	for key, value := range cm.Data {
 		// TODO  need fill variable yaml?
 		//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, clusterName, value)
 		cm.Data[key] = value
 	}
 

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

@@ -4310,6 +4310,13 @@ func EnvSleep(productName, envName string, isEnable, isProduction bool, log *zap
 		log.Error(err)
 		return e.ErrEnvSleep.AddErr(err)
 	}
+	clusterName, err := kube.GetClusterNameByID(prod.ClusterID)
+	if err != nil {
+		wrapErr := fmt.Errorf("failed to get cluster name for cluster %s, err: %v", prod.ClusterID, err)
+		log.Error(wrapErr)
+		return e.ErrEnvSleep.AddErr(wrapErr)
+	}
+
 	if prod.Production != isProduction {
 		err = fmt.Errorf("Insufficient permissions: %s/%s, is production %v", productName, envName, prod.Production)
 		log.Error(err)
@@ -4404,7 +4411,7 @@ func EnvSleep(productName, envName string, isEnable, isProduction bool, log *zap
 				return e.ErrEnvSleep.AddErr(wrapErr)
 			}
 
-			parsedYaml, err := kube.RenderEnvServiceWithTempl(prod, prodSvc.GetServiceRender(), prodSvc, svc)
+			parsedYaml, err := kube.RenderEnvServiceWithTempl(prod, prodSvc.GetServiceRender(), prodSvc, svc, clusterName)
 			if err != nil {
 				return e.ErrEnvSleep.AddErr(fmt.Errorf("failed to render service %s, err: %s", svc.ServiceName, err))
 			}

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

@@ -934,6 +934,10 @@ func getWorkloadDetail(ns, resType, name string, kc client.Client, cs *kubernete
 
 func GetResourceDeployStatus(productName string, request *K8sDeployStatusCheckRequest, production bool, log *zap.SugaredLogger) ([]*ServiceDeployStatus, error) {
 	clusterID, namespace := request.ClusterID, request.Namespace
+	clusterName, err := kube.GetClusterNameByID(clusterID)
+	if err != nil {
+		return nil, e.ErrGetResourceDeployInfo.AddErr(fmt.Errorf("failed to get cluster name by id: %s, err: %s", clusterID, err))
+	}
 
 	svcSet := sets.NewString()
 	for _, svc := range request.Services {
@@ -983,7 +987,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, clusterName, rederedYaml)
 
 		manifests := releaseutil.SplitManifests(rederedYaml)
 		resources := make([]*ResourceDeployStatus, 0)

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

@@ -96,7 +96,14 @@ func renderServiceWithOverrides(prod *commonmodels.Product, service *commonmodel
 		return "", fmt.Errorf("service is nil")
 	}
 	serviceCopy.WorkLoads = cloneWorkLoads(overrides)
-	return kube.RenderEnvServiceWithTempl(prod, serviceCopy.GetServiceRender(), serviceCopy, tmpl)
+
+	// get clusterName
+	clusterName, err := kube.GetClusterNameByID(prod.ClusterID)
+	if err != nil {
+		return "", fmt.Errorf("failed to get cluster name for cluster %s: %w", prod.ClusterID, err)
+	}
+
+	return kube.RenderEnvServiceWithTempl(prod, serviceCopy.GetServiceRender(), serviceCopy, tmpl, clusterName)
 }
 
 func serviceReplicaStateChanged(currentSvc, candidateSvc *commonmodels.ProductService) bool {

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

@@ -179,14 +179,15 @@ func GetService(envName, productName, serviceName string, production bool, workL
 func GetServiceWorkloads(svcTmpl *commonmodels.Service, env *commonmodels.Product, inf informers.SharedInformerFactory, log *zap.SugaredLogger) ([]*commonservice.Workload, error) {
 	ret := make([]*commonservice.Workload, 0)
 	envName, productName, namespace := env.EnvName, env.ProductName, env.Namespace
+	clusterName, err := kube.GetClusterNameByID(env.ClusterID)
 
 	svcRender := env.GetSvcRender(svcTmpl.ServiceName)
 	parsedYaml, err := kube.RenderServiceYaml(svcTmpl.Yaml, productName, svcTmpl.ServiceName, svcRender)
 	if err != nil {
 		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, clusterName, parsedYaml)
 
 	manifests := releaseutil.SplitManifests(parsedYaml)
 	for _, item := range manifests {