feat: core erda k8s labels

apistructs/addon.go

@@ -1019,6 +1019,8 @@ type AddonHandlerCreateItem struct {
 	InsideAddon string `json:"insideAddon"`
 	// ShareScope 是否为内部依赖addon，N:否，Y:是
 	ShareScope string `json:"shareScope"`
+	// TenantId 租户Id
+	TenantId string `json:"tenantId,omitempty"`
 }
 
 // AddonExtension addon extension对象信息

internal/apps/msp/resource/deploy/handlers/handler.go

@@ -602,6 +602,8 @@
 			service.Labels = make(map[string]string)
 		}
 		utils.SetlabelsFromOptions(options, service.Labels)
+		utils.SetCoreErdaLabels(service.Labels, labels, req)
+		utils.SetAddonErdaLabels(service.Labels, req, resourceInfo.Spec)
 	}
 
 	return &req

internal/apps/msp/resource/utils/common.go

@@ -109,3 +109,49 @@
 		labels[apistructs.AlibabaECILabel] = options[apistructs.AlibabaECILabel]
 	}
 }
+
+// k8s labels for cluster addons
+const (
+	LabelCoreErdaCloudClusterName = "core.erda.cloud/cluster-name"
+	LabelCoreErdaCloudServiceType = "core.erda.cloud/service-type"
+
+	LabelDiceClusterName = "DICE_CLUSTER_NAME"
+	LabelDiceServiceType = "SERVICE_TYPE"
+)
+
+const (
+	LabelAddonErdaCloudId      = "addon.erda.cloud/id"
+	LabelAddonErdaCloudScope   = "addon.erda.cloud/scope"
+	LabelAddonErdaCloudType    = "addon.erda.cloud/type"
+	LabelAddonErdaCloudVersion = "addon.erda.cloud/version"
+)
+
+var labelMappings = map[string]string{
+	LabelCoreErdaCloudClusterName: LabelDiceClusterName,
+	LabelCoreErdaCloudServiceType: LabelDiceServiceType,
+}
+
+func SetCoreErdaLabels(target map[string]string, source map[string]string, req apistructs.ServiceGroupCreateV2Request) {
+	if target == nil || source == nil {
+		return
+	}
+	for core, dice := range labelMappings {
+		if v, exist := source[dice]; exist {
+			target[core] = v
+		}
+	}
+
+	target[LabelCoreErdaCloudClusterName] = req.ClusterName
+}
+
+func SetAddonErdaLabels(labels map[string]string, req apistructs.ServiceGroupCreateV2Request, spec *apistructs.AddonExtension) {
+	if labels == nil && spec == nil {
+		return
+	}
+	if spec.ShareScopes != nil && len(spec.ShareScopes) > 0 {
+		labels[LabelAddonErdaCloudScope] = spec.ShareScopes[0]
+	}
+	labels[LabelAddonErdaCloudId] = req.ID
+	labels[LabelAddonErdaCloudType] = spec.Name
+	labels[LabelAddonErdaCloudVersion] = spec.Version
+}

internal/tools/orchestrator/dbclient/msp_tenant.go

@@ -0,0 +1,43 @@
+// Copyright (c) 2021 Terminus, Inc.
+//
+// Licensed 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 dbclient
+
+import "time"
+
+const (
+	TableMSPTenant = "msp_tenant"
+)
+
+type MSPTenant struct {
+	Id               string    `gorm:"column:id" db:"id" json:"id" form:"id"`                                                                 // Tenant id
+	Type             string    `gorm:"column:type" db:"type" json:"type" form:"type"`                                                         // Tenant type（dop 、msp）
+	RelatedProjectId string    `gorm:"column:related_project_id" db:"related_project_id" json:"related_project_id" form:"related_project_id"` // Project id
+	RelatedWorkspace string    `gorm:"column:related_workspace" db:"related_workspace" json:"related_workspace" form:"related_workspace"`     // Workspace（ DEV、TEST、STAGING、PROD、DEFAULT）
+	CreatedAt        time.Time `gorm:"column:created_at" db:"created_at" json:"create_time" form:"create_time"`                               // Create time
+	UpdatedAt        time.Time `gorm:"column:updated_at" db:"updated_at" json:"update_time" form:"update_time"`                               // Update time
+	IsDeleted        bool      `gorm:"column:is_deleted" db:"is_deleted" json:"is_deleted" form:"is_deleted"`                                 // Delete or not
+}
+
+func (MSPTenant) TableName() string { return TableMSPTenant }
+
+func (db *DBClient) QueryTenantByProjectIDAndWorkspace(projectId, workSpace string) (*MSPTenant, error) {
+	tenant := MSPTenant{}
+	err := db.
+		Model(&tenant).
+		Where("`related_project_id` = ?", projectId).
+		Where("`related_workspace` = ?", workSpace).
+		Find(&tenant).Error
+	return &tenant, err
+}

internal/tools/orchestrator/labels/labels.go

@@ -0,0 +1,186 @@
+// Copyright (c) 2021 Terminus, Inc.
+//
+// Licensed 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 labels
+
+import (
+	"encoding/json"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/erda-project/erda/apistructs"
+	"github.com/erda-project/erda/internal/tools/orchestrator/dbclient"
+)
+
+// k8s labels
+const (
+	LabelCoreErdaCloudClusterName    = "core.erda.cloud/cluster-name"
+	LabelCoreErdaCloudOrgId          = "core.erda.cloud/org-id"
+	LabelCoreErdaCloudOrgName        = "core.erda.cloud/org-name"
+	LabelCoreErdaCloudAppId          = "core.erda.cloud/app-id"
+	LabelCoreErdaCloudAppName        = "core.erda.cloud/app-name"
+	LabelCoreErdaCloudProjectId      = "core.erda.cloud/project-id"
+	LabelCoreErdaCloudProjectName    = "core.erda.cloud/project-name"
+	LabelCoreErdaCloudRuntimeId      = "core.erda.cloud/runtime-id"
+	LabelCoreErdaCloudServiceName    = "core.erda.cloud/service-name"
+	LabelCoreErdaCloudWorkSpace      = "core.erda.cloud/workspace"
+	LabelCoreErdaCloudServiceType    = "core.erda.cloud/service-type"
+	LabelCoreErdaCloudServiceGroupId = "core.erda.cloud/servicegroup-id"
+
+	LabelMonitorErdaCloudTenantId = "monitor.erda.cloud/tenant-id"
+	LabelMonitorErdaCloudEnabled  = "monitor.erda.cloud/enabled"
+	LabelMonitorErdaCloudExporter = "monitor.erda.cloud/exporter"
+
+	LabelDiceClusterName = "DICE_CLUSTER_NAME"
+	LabelDiceOrgId       = "DICE_ORG_ID"
+	LabelDiceOrgName     = "DICE_ORG_NAME"
+	LabelDiceAppId       = "DICE_APPLICATION_ID"
+	LabelDiceAppName     = "DICE_APPLICATION_NAME"
+	LabelDiceProjectId   = "DICE_PROJECT_ID"
+	LabelDiceProjectName = "DICE_PROJECT_NAME"
+	LabelDiceRuntimeId   = "DICE_RUNTIME_ID"
+	LabelDiceServiceName = "DICE_SERVICE_NAME"
+	LabelDiceWorkSpace   = "DICE_WORKSPACE"
+	LabelDiceServiceType = "SERVICE_TYPE"
+	LabelServiceGroupId  = "servicegroup-id"
+
+	ServiceEnvPublicHost = "PUBLIC_HOST"
+
+	PublicHostTerminusKey = "terminusKey"
+)
+
+const (
+	LabelAddonErdaCloudId      = "addon.erda.cloud/id"
+	LabelAddonErdaCloudScope   = "addon.erda.cloud/scope"
+	LabelAddonErdaCloudType    = "addon.erda.cloud/type"
+	LabelAddonErdaCloudVersion = "addon.erda.cloud/version"
+)
+
+var labelMappings = map[string]string{
+	LabelCoreErdaCloudClusterName: LabelDiceClusterName,
+	LabelCoreErdaCloudOrgId:       LabelDiceOrgId,
+	LabelCoreErdaCloudOrgName:     LabelDiceOrgName,
+	LabelCoreErdaCloudAppId:       LabelDiceAppId,
+	LabelCoreErdaCloudAppName:     LabelDiceAppName,
+	LabelCoreErdaCloudProjectId:   LabelDiceProjectId,
+	LabelCoreErdaCloudProjectName: LabelDiceProjectName,
+	LabelCoreErdaCloudRuntimeId:   LabelDiceRuntimeId,
+	LabelCoreErdaCloudServiceName: LabelDiceServiceName,
+	LabelCoreErdaCloudWorkSpace:   LabelDiceWorkSpace,
+	LabelCoreErdaCloudServiceType: LabelDiceServiceType,
+}
+
+// AddonLabelSetter Set labels for addon
+type AddonLabelSetter struct {
+	target   map[string]string
+	source   map[string]string
+	instance *dbclient.AddonInstance
+	params   *apistructs.AddonHandlerCreateItem
+}
+
+func NewAddonLabelSetter(target map[string]string, source map[string]string, ins *dbclient.AddonInstance, params *apistructs.AddonHandlerCreateItem) *AddonLabelSetter {
+	return &AddonLabelSetter{target: target, source: source, instance: ins, params: params}
+}
+
+func (a *AddonLabelSetter) SetCoreErdaLabels() *AddonLabelSetter {
+	if a.source == nil || a.target == nil {
+		return a
+	}
+	for core, dice := range labelMappings {
+		if v, exist := a.source[dice]; exist {
+			a.target[core] = v
+		}
+	}
+	return a
+}
+
+func (a *AddonLabelSetter) SetAddonErdaLabels() *AddonLabelSetter {
+	if a.instance == nil || a.target == nil {
+		return a
+	}
+	a.target[LabelAddonErdaCloudId] = a.instance.ID
+	a.target[LabelAddonErdaCloudScope] = a.instance.ShareScope
+	a.target[LabelAddonErdaCloudType] = a.instance.AddonName
+	a.target[LabelAddonErdaCloudVersion] = a.instance.Version
+	return a
+}
+
+func (a *AddonLabelSetter) SetMonitorErdaCloudLabels() *AddonLabelSetter {
+	if a.target == nil {
+		return a
+	}
+	if a.params != nil && a.params.TenantId != "" {
+		a.target[LabelMonitorErdaCloudTenantId] = a.params.TenantId
+	}
+	a.target[LabelMonitorErdaCloudEnabled] = "true"
+	a.target[LabelMonitorErdaCloudExporter] = "true"
+	return nil
+}
+
+// RuntimeLabelSetter  Set labels for runtime
+type RuntimeLabelSetter struct {
+	service *apistructs.Service
+	sg      *apistructs.ServiceGroup
+	labels  map[string]string
+}
+
+func NewRuntimeLabelSetter(service *apistructs.Service, sg *apistructs.ServiceGroup, labels map[string]string) *RuntimeLabelSetter {
+	return &RuntimeLabelSetter{service: service, sg: sg, labels: labels}
+}
+
+func (r *RuntimeLabelSetter) SetMonitorErdaCloudLabels() *RuntimeLabelSetter {
+	if r.labels == nil {
+		r.labels = make(map[string]string)
+	}
+	r.labels[LabelMonitorErdaCloudEnabled] = "true"
+	r.labels[LabelMonitorErdaCloudExporter] = "true"
+
+	if r.service == nil {
+		return r
+	}
+
+	if publicHost, exists := r.service.Env[ServiceEnvPublicHost]; exists {
+		var publicHostMap map[string]string
+		if err := json.Unmarshal([]byte(publicHost), &publicHostMap); err != nil {
+			logrus.Errorf("failed to unmarshal public host map for service: %v, err: %v", r.service.Name, err)
+		}
+		if terminusKey, exists := publicHostMap[PublicHostTerminusKey]; exists {
+			r.labels[LabelMonitorErdaCloudTenantId] = terminusKey
+		}
+	}
+	return r
+}
+
+func (r *RuntimeLabelSetter) SetCoreErdaLabels() *RuntimeLabelSetter {
+	if r.labels == nil {
+		r.labels = make(map[string]string)
+	}
+	if r.service != nil {
+		for coreLabel, diceLabel := range labelMappings {
+			if value, exists := r.service.Labels[diceLabel]; exists {
+				r.labels[coreLabel] = value
+			}
+		}
+	}
+
+	if sgId, exists := r.labels[LabelServiceGroupId]; exists {
+		r.labels[LabelCoreErdaCloudServiceGroupId] = sgId
+	}
+
+	if r.sg != nil && r.sg.ID != "" {
+		r.labels[LabelCoreErdaCloudServiceGroupId] = r.sg.ID
+	}
+
+	return r
+}

internal/tools/orchestrator/scheduler/executor/plugins/k8s/daemonset.go

@@ -26,6 +26,7 @@
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/erda-project/erda/apistructs"
+	"github.com/erda-project/erda/internal/tools/orchestrator/labels"
 	"github.com/erda-project/erda/internal/tools/orchestrator/scheduler/executor/plugins/k8s/k8sapi"
 	"github.com/erda-project/erda/internal/tools/orchestrator/scheduler/executor/plugins/k8s/toleration"
 	"github.com/erda-project/erda/internal/tools/orchestrator/scheduler/executor/plugins/k8s/types"
@@ -93,9 +94,27 @@
 			return errors.New(reason)
 		}
 	}
+	oldDaemon, err := k.getDaemonSet(ds.Namespace, ds.Name)
+	if err != nil {
+		return errors.Errorf("failed to merge daemonset labels, name: %s, (%v)", service.Name, err)
+	}
+	// merge DaemonSet labels
+	k.mergeLabels(ds.Labels, oldDaemon.Labels)
+	// merge Pod labels
+	k.mergeLabels(ds.Spec.Template.Labels, oldDaemon.Spec.Template.Labels)
+
 	return k.ds.Update(ds)
 }
 
+func (k *Kubernetes) mergeLabels(newLabels map[string]string, oldLabels map[string]string) {
+	for key, value := range oldLabels {
+		if _, ok := newLabels[key]; ok {
+			continue
+		}
+		newLabels[key] = value
+	}
+}
+
 func (k *Kubernetes) getDaemonSetDeltaResource(ctx context.Context, ds *appsv1.DaemonSet) (deltaCPU, deltaMemory int64, err error) {
 	oldDs, err := k.k8sClient.ClientSet.AppsV1().DaemonSets(ds.Namespace).Get(ctx, ds.Name, metav1.GetOptions{})
 	if err != nil {
@@ -244,13 +263,6 @@
 	}
 	podAnnotations(service, daemonset.Spec.Template.Annotations)
 
-	// inherit Labels from service.Labels and service.DeploymentLabels
-	err = inheritDaemonsetLabels(service, daemonset)
-	if err != nil {
-		logrus.Errorf("failed to set labels for service %s for Pod with error: %v\n", service.Name, err)
-		return nil, err
-	}
-
 	// set pod Annotations from service.Labels and service.DeploymentLabels
 	setPodAnnotationsFromLabels(service, daemonset.Spec.Template.Annotations)
 
@@ -289,6 +301,14 @@
 
 	SetPodAnnotationsBaseContainerEnvs(daemonset.Spec.Template.Spec.Containers[0], daemonset.Spec.Template.Annotations)
 
+	labels.NewRuntimeLabelSetter(service, sg, daemonset.Labels).
+		SetCoreErdaLabels().
+		SetMonitorErdaCloudLabels()
+
+	labels.NewRuntimeLabelSetter(service, sg, daemonset.Spec.Template.Labels).
+		SetCoreErdaLabels().
+		SetMonitorErdaCloudLabels()
+
 	secrets, err := k.CopyErdaSecrets("secret", service.Namespace)
 	if err != nil {
 		logrus.Errorf("failed to copy secret: %v", err)