diff --git a/apistructs/addon.go b/apistructs/addon.go index 14ce444d803..ac7c2e44783 100644 --- a/apistructs/addon.go +++ b/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对象信息 diff --git a/internal/apps/msp/resource/deploy/handlers/handler.go b/internal/apps/msp/resource/deploy/handlers/handler.go index b940c0e8624..262f7fc8e8e 100644 --- a/internal/apps/msp/resource/deploy/handlers/handler.go +++ b/internal/apps/msp/resource/deploy/handlers/handler.go @@ -602,6 +602,8 @@ func (h *DefaultDeployHandler) BuildServiceGroupRequest(resourceInfo *ResourceIn 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 diff --git a/internal/apps/msp/resource/utils/common.go b/internal/apps/msp/resource/utils/common.go index 056e1e57621..a8d14f88b7a 100644 --- a/internal/apps/msp/resource/utils/common.go +++ b/internal/apps/msp/resource/utils/common.go @@ -109,3 +109,49 @@ func SetlabelsFromOptions(options, labels map[string]string) { 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 +} diff --git a/internal/tools/orchestrator/dbclient/msp_tenant.go b/internal/tools/orchestrator/dbclient/msp_tenant.go new file mode 100644 index 00000000000..05322f9f48b --- /dev/null +++ b/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 +} diff --git a/internal/tools/orchestrator/labels/labels.go b/internal/tools/orchestrator/labels/labels.go new file mode 100644 index 00000000000..4919a1f62fb --- /dev/null +++ b/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 +} diff --git a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/daemonset.go b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/daemonset.go index 3336db75b6a..2cdf53fa51e 100644 --- a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/daemonset.go +++ b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/daemonset.go @@ -26,6 +26,7 @@ import ( 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 @@ func (k *Kubernetes) updateDaemonSet(ctx context.Context, ds *appsv1.DaemonSet, 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 @@ func (k *Kubernetes) newDaemonSet(service *apistructs.Service, sg *apistructs.Se } 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 @@ func (k *Kubernetes) newDaemonSet(service *apistructs.Service, sg *apistructs.Se 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) diff --git a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/deployment.go b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/deployment.go index b5ddb58aa6d..c1342e5984a 100644 --- a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/deployment.go +++ b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/deployment.go @@ -33,6 +33,7 @@ import ( "github.com/erda-project/erda/apistructs" "github.com/erda-project/erda/internal/tools/orchestrator/conf" + "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" @@ -164,6 +165,15 @@ func (k *Kubernetes) putDeployment(ctx context.Context, deployment *appsv1.Deplo } } + oldDeploy, err := k.deploy.Get(deployment.Namespace, deployment.Name) + if err != nil { + return errors.Errorf("failed to merge deployment labels, name: %s, (%v)", service.Name, err) + } + // merge Deployment labels + k.mergeLabels(deployment.Labels, oldDeploy.Labels) + // merge Pod labels + k.mergeLabels(deployment.Spec.Template.Labels, oldDeploy.Spec.Template.Labels) + err = k.deploy.Put(deployment) if err != nil { return errors.Errorf("failed to update deployment, name: %s, (%v)", service.Name, err) @@ -616,13 +626,6 @@ func (k *Kubernetes) newDeployment(service *apistructs.Service, serviceGroup *ap } podAnnotations(service, deployment.Spec.Template.Annotations) - // inherit Labels from service.Labels and service.DeploymentLabels - err = inheritDeploymentLabels(service, deployment) - 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, deployment.Spec.Template.Annotations) @@ -660,6 +663,14 @@ func (k *Kubernetes) newDeployment(service *apistructs.Service, serviceGroup *ap SetPodAnnotationsBaseContainerEnvs(deployment.Spec.Template.Spec.Containers[0], deployment.Spec.Template.Annotations) + labels.NewRuntimeLabelSetter(service, serviceGroup, deployment.Labels). + SetCoreErdaLabels(). + SetMonitorErdaCloudLabels() + + labels.NewRuntimeLabelSetter(service, serviceGroup, deployment.Spec.Template.Labels). + SetCoreErdaLabels(). + SetMonitorErdaCloudLabels() + // TODO: Delete this logic //Mobil temporary demand: // Inject the secret under the "secret" namespace into the business container diff --git a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/service.go b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/service.go index 951297d3ecb..d179be9553d 100644 --- a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/service.go +++ b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/service.go @@ -29,6 +29,7 @@ import ( "k8s.io/apimachinery/pkg/util/validation" "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/k8serror" "github.com/erda-project/erda/pkg/istioctl" "github.com/erda-project/erda/pkg/strutil" @@ -112,7 +113,6 @@ func newService(service *apistructs.Service, selectors map[string]string) *apiv1 if len(service.Ports) == 0 { return nil } - k8sService := &apiv1.Service{ TypeMeta: metav1.TypeMeta{ APIVersion: "v1", @@ -153,6 +153,10 @@ func newService(service *apistructs.Service, selectors map[string]string) *apiv1 } } + labels.NewRuntimeLabelSetter(service, nil, k8sService.Labels). + SetCoreErdaLabels(). + SetMonitorErdaCloudLabels() + for i, port := range service.Ports { k8sService.Spec.Ports = append(k8sService.Spec.Ports, apiv1.ServicePort{ // TODO: name? @@ -341,7 +345,9 @@ func (k *Kubernetes) UpdateK8sService(k8sService *apiv1.Service, service *apistr setServiceLabelSelector(k8sService, selectors) k8sService.Spec.Ports = newPorts - + labels.NewRuntimeLabelSetter(service, nil, k8sService.Labels). + SetCoreErdaLabels(). + SetMonitorErdaCloudLabels() if err := k.PutService(k8sService); err != nil { errMsg := fmt.Sprintf("update service err %v", err) logrus.Error(errMsg) diff --git a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/service_test.go b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/service_test.go index 7825b4090d0..c0a4c70a9e1 100644 --- a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/service_test.go +++ b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/service_test.go @@ -27,6 +27,7 @@ import ( "k8s.io/apimachinery/pkg/util/intstr" "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/k8sservice" "github.com/erda-project/erda/pkg/parser/diceyml" ) @@ -75,10 +76,19 @@ func Test_newService(t *testing.T) { }, }, labels: map[string]string{ - "app": "fake-service", - "svc": "fake-service.default.svc.cluster.local", - // invalid label, value must be 63 characters or less and must be empty or begin and end with an alphanumeric character ([a-z0-9A-Z]) - "invalid": "manager.addon-idxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.erda.cloud", + "app": "fake-service", + "svc": "fake-service.default.svc.cluster.local", + labels.LabelCoreErdaCloudAppId: "11972", + labels.LabelCoreErdaCloudAppName: "fake-service", + labels.LabelCoreErdaCloudClusterName: "erda-jicheng", + labels.LabelCoreErdaCloudOrgId: "100060", + labels.LabelCoreErdaCloudOrgName: "erda", + labels.LabelCoreErdaCloudProjectId: "387", + labels.LabelCoreErdaCloudProjectName: "erda-project", + labels.LabelCoreErdaCloudRuntimeId: "25160", + labels.LabelCoreErdaCloudServiceName: "fake-server", + labels.LabelCoreErdaCloudServiceType: "STATELESS", + labels.LabelCoreErdaCloudWorkSpace: "test", }, }, want: &v1.Service{ @@ -90,21 +100,39 @@ func Test_newService(t *testing.T) { Name: "fake-service", Namespace: apiv1.NamespaceDefault, Labels: map[string]string{ - "app": "fake-service", - "svc": "fake-service.default.svc.cluster.local", + "app": "fake-service", + "svc": "fake-service.default.svc.cluster.local", + labels.LabelCoreErdaCloudAppId: "11972", + labels.LabelCoreErdaCloudAppName: "fake-service", + labels.LabelCoreErdaCloudClusterName: "erda-jicheng", + labels.LabelCoreErdaCloudOrgId: "100060", + labels.LabelCoreErdaCloudOrgName: "erda", + labels.LabelCoreErdaCloudProjectId: "387", + labels.LabelCoreErdaCloudProjectName: "erda-project", + labels.LabelCoreErdaCloudRuntimeId: "25160", + labels.LabelCoreErdaCloudServiceName: "fake-server", + labels.LabelCoreErdaCloudServiceType: "STATELESS", + labels.LabelCoreErdaCloudWorkSpace: "test", + labels.LabelMonitorErdaCloudExporter: "true", + labels.LabelMonitorErdaCloudEnabled: "true", }, }, Spec: v1.ServiceSpec{ - Ports: []v1.ServicePort{ - { - Name: "tcp-0", - Port: 80, - TargetPort: intstr.FromInt(80), - }, - }, + Ports: []v1.ServicePort{{Name: "tcp-0", Port: 80, TargetPort: intstr.IntOrString{IntVal: 80}}}, Selector: map[string]string{ - "app": "fake-service", - "svc": "fake-service.default.svc.cluster.local", + "app": "fake-service", + "svc": "fake-service.default.svc.cluster.local", + labels.LabelCoreErdaCloudAppId: "11972", + labels.LabelCoreErdaCloudAppName: "fake-service", + labels.LabelCoreErdaCloudClusterName: "erda-jicheng", + labels.LabelCoreErdaCloudOrgId: "100060", + labels.LabelCoreErdaCloudOrgName: "erda", + labels.LabelCoreErdaCloudProjectId: "387", + labels.LabelCoreErdaCloudProjectName: "erda-project", + labels.LabelCoreErdaCloudRuntimeId: "25160", + labels.LabelCoreErdaCloudServiceName: "fake-server", + labels.LabelCoreErdaCloudServiceType: "STATELESS", + labels.LabelCoreErdaCloudWorkSpace: "test", }, }, }, diff --git a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/statefulset.go b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/statefulset.go index 2d0542c86c8..56433f50b41 100644 --- a/internal/tools/orchestrator/scheduler/executor/plugins/k8s/statefulset.go +++ b/internal/tools/orchestrator/scheduler/executor/plugins/k8s/statefulset.go @@ -32,6 +32,7 @@ import ( 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" @@ -112,6 +113,14 @@ func (k *Kubernetes) createStatefulSet(ctx context.Context, info types.Statefuls }, } + labels.NewRuntimeLabelSetter(service, info.Sg, set.Labels). + SetCoreErdaLabels(). + SetMonitorErdaCloudLabels() + + labels.NewRuntimeLabelSetter(service, info.Sg, set.Spec.Template.Labels). + SetCoreErdaLabels(). + SetMonitorErdaCloudLabels() + hasHostPath := serviceHasHostpath(service) err := setPodLabelsFromService(hasHostPath, service.Labels, set.Labels) if err != nil { diff --git a/internal/tools/orchestrator/services/addon/addon.go b/internal/tools/orchestrator/services/addon/addon.go index fe37913fbf9..8e901b7a7cb 100644 --- a/internal/tools/orchestrator/services/addon/addon.go +++ b/internal/tools/orchestrator/services/addon/addon.go @@ -3054,7 +3054,24 @@ func (a *Addon) checkCreateParams(req *apistructs.AddonCreateRequest) error { // deployAddons addons 部署 func (a *Addon) deployAddons(req *apistructs.AddonCreateRequest, deploys []dbclient.AddonPrebuild) error { needDeployAddons := []apistructs.AddonHandlerCreateItem{} + //terminusKey + tenantResp, err := a.tenantSvc.GetTenant(context.Background(), &tenantpb.GetTenantRequest{ + ProjectID: fmt.Sprintf("%v", req.ProjectID), + TenantType: tenantpb.Type_DOP.String(), + Workspace: req.Workspace, + }) + + var tenantId string + if tenantResp != nil && tenantResp.Data != nil { + tenantId = tenantResp.Data.Id + } + + if err != nil { + return errors.Errorf("can't get tenant id from tenant service , %v", err.Error()) + } + var regVersion, confVersion string + for _, v := range deploys { if _, ok := AddonInfos.Load(v.AddonName); !ok { errStr := i18n2.OrgSprintf(strconv.FormatUint(req.OrgID, 10), "AddonTypeDoseNoExist", v.AddonName) @@ -3077,6 +3094,7 @@ func (a *Addon) deployAddons(req *apistructs.AddonCreateRequest, deploys []dbcli RuntimeID: strconv.FormatUint(req.RuntimeID, 10), RuntimeName: req.RuntimeName, OperatorID: req.Operator, + TenantId: tenantId, } if len(createItem.Options) == 0 { createItem.Options = map[string]string{} diff --git a/internal/tools/orchestrator/services/addon/addon_deploy.go b/internal/tools/orchestrator/services/addon/addon_deploy.go index 038eaebd888..1d23c525fa9 100644 --- a/internal/tools/orchestrator/services/addon/addon_deploy.go +++ b/internal/tools/orchestrator/services/addon/addon_deploy.go @@ -30,6 +30,7 @@ import ( "github.com/erda-project/erda/internal/tools/orchestrator/conf" "github.com/erda-project/erda/internal/tools/orchestrator/dbclient" "github.com/erda-project/erda/internal/tools/orchestrator/i18n" + "github.com/erda-project/erda/internal/tools/orchestrator/labels" "github.com/erda-project/erda/pkg/discover" "github.com/erda-project/erda/pkg/mysqlhelper" "github.com/erda-project/erda/pkg/parser/diceyml" @@ -673,6 +674,14 @@ func (a *Addon) BuildAddonRequestGroup(params *apistructs.AddonHandlerCreateItem ser.Envs[k] = v } } + + for _, svc := range addonDice.Services { + labels.NewAddonLabelSetter(svc.Labels, addonDeployGroup.GroupLabels, addonIns, params). + SetCoreErdaLabels(). + SetAddonErdaLabels(). + SetMonitorErdaCloudLabels() + } + addonDeployGroup.DiceYml = *addonDice return &addonDeployGroup, nil diff --git a/internal/tools/orchestrator/services/addon/addon_handler.go b/internal/tools/orchestrator/services/addon/addon_handler.go index cc85617e7b7..31751251efb 100644 --- a/internal/tools/orchestrator/services/addon/addon_handler.go +++ b/internal/tools/orchestrator/services/addon/addon_handler.go @@ -281,6 +281,14 @@ func (a *Addon) AddonDelete(req apistructs.AddonDirectDeleteRequest) error { return nil } +func (a *Addon) getTenantId(projectID string, tenantType, workspace string) string { + tenant, err := a.db.QueryTenantByProjectIDAndWorkspace(projectID, workspace) + if err != nil { + return utils.GenerateTenantID(projectID, tenantType, workspace) + } + return tenant.Id +} + func (a *Addon) AddonCreate(req apistructs.AddonDirectCreateRequest) (string, error) { if len(req.Addons) != 1 { return "", fmt.Errorf("len(req.Addons) != 1") @@ -311,6 +319,7 @@ func (a *Addon) AddonCreate(req apistructs.AddonDirectCreateRequest) (string, er InsideAddon: "N", ShareScope: req.ShareScope, Options: baseAddons[0].Options, + TenantId: a.getTenantId(strconv.FormatUint(req.ProjectID, 10), pb.Type_DOP.String(), req.Workspace), } addonSpec, addonDice, err := a.GetAddonExtention(&addonItem) if err != nil { diff --git a/internal/tools/orchestrator/services/addon/addon_test.go b/internal/tools/orchestrator/services/addon/addon_test.go index 78fc81421f3..bf1f659ac6a 100644 --- a/internal/tools/orchestrator/services/addon/addon_test.go +++ b/internal/tools/orchestrator/services/addon/addon_test.go @@ -982,6 +982,9 @@ func TestAddon2(t *testing.T) { return nil, nil, errors.New("error") }, ) + monkey.PatchInstanceMethod(reflect.TypeOf(a.db), "QueryTenantByProjectIDAndWorkspace", func(db *dbclient.DBClient, projectId, workSpace string) (*dbclient.MSPTenant, error) { + return nil, errors.New("error") + }) a.AddonCreate(apistructs.AddonDirectCreateRequest{ Addons: diceyml.AddOns{ "mysql": &diceyml.AddOn{ diff --git a/internal/tools/orchestrator/utils/addon_utils.go b/internal/tools/orchestrator/utils/addon_utils.go new file mode 100644 index 00000000000..1c697b155a7 --- /dev/null +++ b/internal/tools/orchestrator/utils/addon_utils.go @@ -0,0 +1,28 @@ +// 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 utils + +import ( + "crypto/md5" + "encoding/hex" + "fmt" +) + +func GenerateTenantID(projectID string, tenantType, workspace string) string { + md5H := md5.New() + hStr := fmt.Sprintf("%v-%s-%s", projectID, tenantType, workspace) + md5H.Write([]byte(hStr)) + return hex.EncodeToString(md5H.Sum(nil)) +}