[agent-operator]-无聊的更新内容

agent-operator/CmiiDeployOperator.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+	"wdd.io/agent-common/logger"
 
 	image2 "wdd.io/agent-common/image"
 	"wdd.io/agent-common/utils"
@@ -16,6 +17,8 @@ import (
 
 var DeployFilePrefix = "/root/wddproject/ProjectOctopus/agent-common/real_project/"
 
+var log = logger.Log
+
 func init() {
 	switch runtime.GOOS {
 	case "linux":

agent-operator/CmiiDeployOperator_test.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"testing"
+	"wdd.io/agent-operator/config"
 
 	image2 "wdd.io/agent-common/image"
 	"wdd.io/agent-common/real_project"
@@ -15,7 +16,7 @@ func TestCmiiEnvDeploy(t *testing.T) {
 	// devflight
 	// devoperation
 
-	deployNamespace := devFlight
+	deployNamespace := config.DevOperation
 
 	//  deploy to cmii environment
 	cmiiDeployCommonEnv := &z_dep.CommonEnvironmentConfig{
@@ -25,10 +26,10 @@ func TestCmiiEnvDeploy(t *testing.T) {
 		HarborPort:                  "",
 		Namespace:                   deployNamespace,
 		TagVersion:                  "6.0.0",
-		TenantEnv:                   "devflight",
+		TenantEnv:                   "devoperation",
 		MinioPublicIP:               "",
 		MinioInnerIP:                "127.0.0.1",
-		NFSServerIP:                 "",
+		NFSServerIP:                 "123.0.0.1",
 		ApplyFilePrefix:             "",
 	}
 
@@ -48,7 +49,7 @@ func TestCmiiEnvDeploy_ChongQingSanHua(t *testing.T) {
 		TagVersion:                  "5.6.0",
 	}
 
-	CmiiEnvDeploy(commonEnv, true, demo)
+	CmiiEnvDeploy(commonEnv, true, config.Demo)
 
 }
 
@@ -70,7 +71,7 @@ func TestCmiiEnvDeploy_LiuXiTongGan(t *testing.T) {
 		ApplyFilePrefix:             "",
 	}
 
-	CmiiEnvDeploy(commonEnv, true, demo)
+	CmiiEnvDeploy(commonEnv, true, config.Demo)
 
 }
 
@@ -155,6 +156,27 @@ func TestCmiiEnvDeploy_JiangXiTongGanErJiPingTai(t *testing.T) {
 
 }
 
+func TestCmiiEnvDeploy_ShangDongErJiPingTai(t *testing.T) {
+
+	// 山东二级平台
+	commonEnv := &z_dep.CommonEnvironmentConfig{
+		WebIP:                       "134.80.124.6",
+		WebPort:                     "8088",
+		HarborIPOrCustomImagePrefix: "134.80.124.7",
+		HarborPort:                  "8033",
+		Namespace:                   "sdejpt",
+		TagVersion:                  "6.0.0",
+		TenantEnv:                   "",
+		MinioPublicIP:               "",
+		MinioInnerIP:                "134.80.124.15",
+		NFSServerIP:                 "134.80.124.21",
+		ApplyFilePrefix:             "",
+	}
+
+	CmiiEnvDeployOffline(commonEnv, true, real_project.Cmii600ImageList)
+
+}
+
 func TestCmiiEnvDeploy_JiangSuNanTong(t *testing.T) {
 
 	// 江苏南通
@@ -259,7 +281,7 @@ func TestCmiiEnvDeploy_JiLinYiDong(t *testing.T) {
 
 func TestCmiiNewAppDeploy(t *testing.T) {
 
-	deployNamespace := devOperation
+	deployNamespace := config.DevOperation
 
 	//  deploy to cmii environment
 	cmiiDeployCommonEnv := &z_dep.CommonEnvironmentConfig{

agent-operator/CmiiImageSyncOperator.go

@@ -9,7 +9,9 @@ import (
 	image2 "wdd.io/agent-common/image"
 	"wdd.io/agent-common/utils"
 	"wdd.io/agent-deploy/d_app"
+	"wdd.io/agent-operator/config"
 	"wdd.io/agent-operator/image"
+	"wdd.io/agent-operator/minio"
 )
 
 const (
@@ -330,15 +332,15 @@ func A_DownloadCompressUpload(syncEntity *ImageSyncEntity, syncResult *ImageSync
 		projectUniqueName = strings.TrimSuffix(projectUniqueName, "/")
 
 		bucketNameWithPrefix := "cmlc-installation/" + projectUniqueName
-		log.InfoF("gzip file location in demo oss is %s", DefaultDemoEndpoint+"/"+bucketNameWithPrefix)
+		log.InfoF("gzip file location in demo oss is %s", minio.DefaultDemoEndpoint+"/"+bucketNameWithPrefix)
 
 		// 上传所有的压缩文件名称
-		if !DefaultCmiiMinioOperator.UploadToDemo(bucketNameWithPrefix, gzipLocalFolderPath, AllGzipImageLocalFileName) {
+		if !minio.DefaultCmiiMinioOperator.UploadToDemo(bucketNameWithPrefix, gzipLocalFolderPath, AllGzipImageLocalFileName) {
 			log.ErrorF("upload of %s to demo oss error !", AllGzipImageLocalFileName)
 		}
 
 		// 上传所有的镜像名称
-		if !DefaultCmiiMinioOperator.UploadToDemo(bucketNameWithPrefix, gzipLocalFolderPath, AllCmiiImageListLocalFileName) {
+		if !minio.DefaultCmiiMinioOperator.UploadToDemo(bucketNameWithPrefix, gzipLocalFolderPath, AllCmiiImageListLocalFileName) {
 			log.ErrorF("upload of %s to demo oss error !", AllCmiiImageListLocalFileName)
 		}
 
@@ -348,11 +350,11 @@ func A_DownloadCompressUpload(syncEntity *ImageSyncEntity, syncResult *ImageSync
 			gzipFileName := strings.TrimPrefix(gzipFileFullName, gzipLocalFolderPath)
 			gzipFileName = strings.TrimPrefix(gzipFileName, "/")
 
-			if !DefaultCmiiMinioOperator.UploadToDemo(bucketNameWithPrefix, gzipLocalFolderPath, gzipFileName) {
+			if !minio.DefaultCmiiMinioOperator.UploadToDemo(bucketNameWithPrefix, gzipLocalFolderPath, gzipFileName) {
 				log.ErrorF("upload of %s to demo oss error !", gzipFileName)
 				errorUploadOssGzipNameList = append(errorUploadOssGzipNameList, gzipFileName)
 			} else {
-				allDownloadUrl = append(allDownloadUrl, DefaultDemoEndpoint+"/"+bucketNameWithPrefix+"/"+gzipFileName)
+				allDownloadUrl = append(allDownloadUrl, minio.DefaultDemoEndpoint+"/"+bucketNameWithPrefix+"/"+gzipFileName)
 			}
 		}
 
@@ -448,7 +450,7 @@ func loadAllGzipImageFromLocalFolder(localGzipFolder string) {
 func parseAndDownloadFromOss(ossUrlPrefix, ossFileName, localGzipFolder string) bool {
 
 	if ossUrlPrefix == "" {
-		ossUrlPrefix = DefaultOssUrlPrefix
+		ossUrlPrefix = minio.DefaultOssUrlPrefix
 	}
 	if !strings.HasSuffix(ossUrlPrefix, "/") {
 		ossUrlPrefix += "/"
@@ -456,7 +458,7 @@ func parseAndDownloadFromOss(ossUrlPrefix, ossFileName, localGzipFolder string)
 
 	log.InfoF("prepare to download from %s%s", ossUrlPrefix, ossFileName)
 
-	if !DefaultCmiiMinioOperator.DemoMinioOperator.DownloadFileFromOssFullUrl(ossUrlPrefix+ossFileName, localGzipFolder) {
+	if !minio.DefaultCmiiMinioOperator.DemoMinioOperator.DownloadFileFromOssFullUrl(ossUrlPrefix+ossFileName, localGzipFolder) {
 		log.ErrorF("download %s from oss error !", ossUrlPrefix+ossFileName)
 		return false
 	}
@@ -466,7 +468,7 @@ func parseAndDownloadFromOss(ossUrlPrefix, ossFileName, localGzipFolder string)
 		// download all files in the txt file
 		result := utils.ReadAllContentFromFile(localGzipFolder + ossFileName)
 		for _, gzipFileName := range result {
-			DefaultCmiiMinioOperator.DemoMinioOperator.DownloadFileFromOssFullUrl(ossUrlPrefix+gzipFileName, localGzipFolder)
+			minio.DefaultCmiiMinioOperator.DemoMinioOperator.DownloadFileFromOssFullUrl(ossUrlPrefix+gzipFileName, localGzipFolder)
 		}
 	}
 
@@ -511,7 +513,7 @@ func buildAllCmiiImageNameListFromDemo(projectName string) []string {
 
 	var realCmiiImageName []string
 
-	backendMap, frontendMap, srsMap := BackupAllCmiiDeploymentToMap(demo)
+	backendMap, frontendMap, srsMap := BackupAllCmiiDeploymentToMap(config.Demo)
 
 	// save map to file
 	backendMapFile := image.OfflineImageGzipFolderPrefix + projectName + "-backend-app.json"
@@ -595,14 +597,14 @@ func buildAllCmiiImageNameListFromVersion(cmiiVersion string) []string {
 	realCmiiImageName = append(realCmiiImageName, image.CmiiImageMapToFullNameList(frontendMap)...)
 
 	for key, value := range d_app.CmiiSrsAppMap {
-		var app *CmiiDeploymentInterface
+		var app *config.CmiiDeploymentInterface
 		if strings.Contains(value, "deployment") {
-			app = DefaultCmiiOperator.DeploymentOneInterface(demo, key)
+			app = DefaultCmiiOperator.DeploymentOneInterface(config.Demo, key)
 			if app != nil {
 				realCmiiImageName = append(realCmiiImageName, app.Image)
 			}
 		} else if strings.Contains(value, "state") {
-			app = DefaultCmiiOperator.StatefulSetOneInterface(demo, key)
+			app = DefaultCmiiOperator.StatefulSetOneInterface(config.Demo, key)
 			if app != nil {
 				for _, imageName := range app.ContainerImageMap {
 					realCmiiImageName = append(realCmiiImageName, imageName)

agent-operator/CmiiK8sHigherOperator.go

@@ -0,0 +1,756 @@
+package main
+
+import (
+	"bufio"
+	"runtime"
+	"strings"
+	"time"
+	image2 "wdd.io/agent-common/image"
+	"wdd.io/agent-common/utils"
+	"wdd.io/agent-deploy/d_app"
+	"wdd.io/agent-operator/config"
+)
+
+var DefaultCmiiOperator = CmiiK8sOperator{}
+var UpdateLogPath = "/home/wdd/IdeaProjects/ProjectOctopus/agent-operator/log/cmii-update-log.txt"
+
+func init() {
+	switch runtime.GOOS {
+	case "linux":
+		UpdateLogPath = "/home/wdd/IdeaProjects/ProjectOctopus/agent-operator/log/cmii-update-log.txt"
+	case "windows":
+		UpdateLogPath = "C:\\Users\\wdd\\IdeaProjects\\ProjectOctopus\\agent-operator\\log\\cmii-update-log.txt"
+	}
+}
+
+// FindAppNotHealthyOrRestartCountGreaterThanN 重启次数大于N的所有Deployment
+func FindAppNotHealthyOrRestartCountGreaterThanN(cmiiEnv string, restartCount int32) []config.CmiiDeploymentInterface {
+
+	//podInterface := CmiiPodInterface{}
+
+	// get all pods
+	podAll := DefaultCmiiOperator.PodAllInterface(cmiiEnv)
+
+	// restart map
+	restartMap := make(map[string]int32, len(podAll))
+
+	// restart count
+	for _, pod := range podAll {
+		if pod.RestartCount > restartCount {
+			restart, exists := restartMap[pod.ContainerName]
+			if exists {
+				restartMap[pod.ContainerName] = utils.MaxInt32(pod.RestartCount, restart)
+			} else {
+				restartMap[pod.ContainerName] = pod.RestartCount
+			}
+		}
+
+		// unhealthy
+		if !pod.PodStatus {
+			restartMap[pod.ContainerName] = pod.RestartCount
+		}
+	}
+
+	result := make([]config.CmiiDeploymentInterface, len(restartMap))
+	index := 0
+	log.DebugF("[FindAppNotHealthyOrRestartCountGreaterThanN] - restart map is => %v", restartMap)
+	// find deployment convert to interface
+	for key, value := range restartMap {
+		// container Name must equals deployment name
+		deployment := DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, key)
+		if deployment != nil {
+			// deployment exists
+			log.DebugF("[FindAppNotHealthyOrRestartCountGreaterThanN] - restart [%s] [%s] is [%d]", cmiiEnv, key, value)
+
+			result[index] = *deployment
+			index++
+		}
+	}
+
+	return result[:index]
+}
+
+func FindDeploymentReplicasSmallerThanN(cmiiEnv string, replicasMin int32) (deploymentList []config.CmiiDeploymentInterface) {
+
+	// get all deployments
+	cmiiDeploymentInterfaces := DefaultCmiiOperator.DeploymentAllInterface(cmiiEnv)
+	cmiiDeploymentInterfaces = FilterAllCmiiAppSoft(cmiiDeploymentInterfaces)
+
+	// filter
+	for _, deploymentInterface := range cmiiDeploymentInterfaces {
+		if deploymentInterface.Replicas <= replicasMin {
+			deploymentList = append(deploymentList, deploymentInterface)
+		}
+	}
+
+	// convert
+	return deploymentList
+}
+
+func FindDeploymentNotHealthy(cmiiEnv string) (deploymentList []config.CmiiDeploymentInterface) {
+
+	// all unhealthy pods
+	allInterface := DefaultCmiiOperator.PodAllInterface(cmiiEnv)
+
+	// find the deployments
+	for _, podInterface := range allInterface {
+		if !podInterface.PodStatus {
+			// unhealthy pod
+			deploymentInterface := DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, podInterface.ContainerName)
+			if deploymentInterface != nil {
+				deploymentList = append(deploymentList, *deploymentInterface)
+			}
+		}
+	}
+
+	return deploymentList
+}
+func FindAllNodeNotHealthy() (nodeList []config.CmiiNodeInterface) {
+
+	// dev-cluster
+	devNodeList := DefaultCmiiOperator.NodeAllInterface("dev")
+
+	// core-cluster
+	coreNodeList := DefaultCmiiOperator.NodeAllInterface("uat")
+
+	// append
+	coreNodeList = append(coreNodeList, devNodeList...)
+
+	// filter
+	for _, node := range coreNodeList {
+		if node.Unschedulable {
+			nodeList = append(nodeList, node)
+			continue
+		}
+
+		if !node.NodeStatus {
+			nodeList = append(nodeList, node)
+			continue
+		}
+
+		if node.MemoryPressure || node.PIDPressure || node.NetworkUnavailable || node.DiskPressure {
+			nodeList = append(nodeList, node)
+			continue
+		}
+	}
+
+	return nodeList
+}
+
+func FindPodNotHealthy(cmiiEnv string) (podList []config.CmiiPodInterface) {
+	// all unhealthy pods
+	allInterface := DefaultCmiiOperator.PodAllInterface(cmiiEnv)
+
+	// find the deployments
+	for _, podInterface := range allInterface {
+		if !podInterface.PodStatus {
+			// unhealthy pod
+			podList = append(podList, podInterface)
+		}
+	}
+
+	return podList
+}
+
+func GetDeploymentGitInfoFromInnerEnv(cmiiEnv, appName string) (gitBranch, gitCommit string) {
+
+	// get app
+	podList := DefaultCmiiOperator.PodByAppName(cmiiEnv, appName)
+
+	// get pod
+	if podList == nil || len(podList) == 0 {
+		log.ErrorF("[GetDeploymentGitInfoFromInnerEnv] - get app pod error [%s] [%s]", cmiiEnv, appName)
+		return "", ""
+	}
+
+	// exec env
+	stdout, stderr := DefaultCmiiOperator.PodExec(cmiiEnv, podList[0], []string{"env"})
+
+	errLog := stderr.String()
+	if errLog != "" {
+		log.ErrorF("[GetDeploymentGitInfoFromInnerEnv] - pod Exec error %s", errLog)
+		return "", ""
+	}
+
+	scanner := bufio.NewScanner(stdout)
+	for scanner.Scan() {
+		// Get the current line
+		line := scanner.Text()
+
+		// Check if the current line contains the search term
+		if strings.HasPrefix(line, "GIT_BRANCH") {
+			gitBranch = strings.Split(line, "=")[1]
+		}
+		if strings.HasPrefix(line, "GIT_COMMIT") {
+			gitCommit = strings.Split(line, "=")[1]
+		}
+	}
+
+	// get out git info
+	return gitBranch, gitCommit
+}
+
+func FindCmiiMiddlewarePodInterface(cmiiEnv string) (podList []config.CmiiPodInterface) {
+
+	cmiiPodInterfaces := DefaultCmiiOperator.PodAllInterface(cmiiEnv)
+
+	for _, podInterface := range cmiiPodInterfaces {
+		for key := range d_app.CmiiMiddlewareNameMap {
+			if strings.Contains(podInterface.Name, key) {
+				podList = append(podList, podInterface)
+			}
+		}
+	}
+
+	return podList
+}
+
+func ScaleCmiiFrontendDeploymentToDesiredReplicas(cmiiEnv string, desiredReplicas int32) (errorUpdateMap map[string]int32) {
+	frontMap := make(map[string]int32, len(d_app.CmiiFrontendAppMap))
+	for aooName := range d_app.CmiiFrontendAppMap {
+		frontMap[aooName] = desiredReplicas
+	}
+
+	return ScaleDeploymentToDesiredReplicasFromMap(cmiiEnv, frontMap)
+}
+
+func ScaleCmiiBackendDeploymentToDesiredReplicas(cmiiEnv string, desiredReplicas int32) (errorUpdateMap map[string]int32) {
+	backMap := make(map[string]int32, len(d_app.CmiiBackendAppMap))
+	for aooName := range d_app.CmiiBackendAppMap {
+		backMap[aooName] = desiredReplicas
+	}
+
+	return ScaleDeploymentToDesiredReplicasFromMap(cmiiEnv, backMap)
+}
+
+func ScaleDeploymentToDesiredReplicasFromMap(cmiiEnv string, nameReplicasMap map[string]int32) map[string]int32 {
+
+	errorUpdateMap := make(map[string]int32, len(nameReplicasMap))
+
+	// 遍历
+	for appName, replica := range nameReplicasMap {
+		exists := DefaultCmiiOperator.DeploymentExist(cmiiEnv, appName)
+		if exists != nil {
+			scale := DefaultCmiiOperator.DeploymentScale(cmiiEnv, appName, replica)
+			if !scale {
+				errorUpdateMap[appName] = replica
+			}
+		} else {
+			errorUpdateMap[appName] = replica
+		}
+	}
+
+	return errorUpdateMap
+}
+
+func RestartDeploymentFromList(deploymentList []config.CmiiDeploymentInterface) bool {
+
+	result := true
+
+	for _, deployment := range deploymentList {
+		result = DefaultCmiiOperator.DeploymentScale(deployment.Namespace, deployment.Name, 0)
+		if !result {
+			return result
+		}
+		time.Sleep(time.Second)
+		result = DefaultCmiiOperator.DeploymentScale(deployment.Namespace, deployment.Name, deployment.Replicas)
+		if !result {
+			return result
+		}
+	}
+
+	return result
+}
+
+func RestartCmiiBackendDeployment(cmiiEnv string) {
+
+	cmiiDeploymentInterfaces := DefaultCmiiOperator.DeploymentAllInterface(cmiiEnv)
+
+	for _, deploymentInterface := range cmiiDeploymentInterfaces {
+		if AppNameBelongsToCmiiImage(deploymentInterface.Name) {
+			if !DefaultCmiiOperator.DeploymentRestart(deploymentInterface.Namespace, deploymentInterface.Name) {
+				log.ErrorF("[RestartCmiiBackendDeployment] - restart of [%s] [%s] failed !", deploymentInterface.Namespace, deploymentInterface.Name)
+			} else {
+				log.DebugF("[RestartCmiiBackendDeployment] - restart of [%s] [%s] success !", deploymentInterface.Namespace, deploymentInterface.Name)
+			}
+
+		}
+	}
+
+	log.InfoF("[RestartCmiiBackendDeployment] - restart of all backend app in [%s] success !", DefaultCmiiOperator.CurrentNamespace)
+}
+
+func RestartCmiiFrontendDeployment(cmiiEnv string) {
+
+	cmiiDeploymentInterfaces := DefaultCmiiOperator.DeploymentAllInterface(cmiiEnv)
+
+	for _, deploymentInterface := range cmiiDeploymentInterfaces {
+		_, ok := d_app.CmiiFrontendAppMap[deploymentInterface.Name]
+		if ok {
+			if !DefaultCmiiOperator.DeploymentRestart(deploymentInterface.Namespace, deploymentInterface.Name) {
+				log.ErrorF("[RestartCmiiFrontendDeployment] - restart of [%s] [%s] failed !", deploymentInterface.Namespace, deploymentInterface.Name)
+			} else {
+				log.DebugF("[RestartCmiiFrontendDeployment] - restart of [%s] [%s] success !", deploymentInterface.Namespace, deploymentInterface.Name)
+			}
+		}
+	}
+
+	log.InfoF("[RestartCmiiFrontendDeployment] - restart of all backend app in [%s] success !", DefaultCmiiOperator.CurrentNamespace)
+}
+
+// UpdateCmiiDeploymentImageTag 更新CMII的Deployment的Tag号
+func UpdateCmiiDeploymentImageTag(cmiiEnv, appName, newTag string) (updateOK bool, oldImageTag, newImageTag string) {
+
+	cmiiDeploymentInterface := DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, appName)
+	if cmiiDeploymentInterface == nil {
+		return updateOK, oldImageTag, newImageTag
+	}
+
+	// check if need to update
+	oldImageTag = cmiiDeploymentInterface.ImageTag
+	if oldImageTag == newTag {
+		log.DebugF("[UpdateCmiiDeploymentImageTag] - [%s] [%s] image tag are the same ! no need to update !", cmiiEnv, appName)
+		// restart deployment
+		if DefaultCmiiOperator.DeploymentRestart(cmiiEnv, appName) {
+			return true, oldImageTag, oldImageTag
+		} else {
+			return false, oldImageTag, oldImageTag
+		}
+	}
+
+	content := utils.WordSpaceCompletion(utils.TimeSplitFormatString()+" "+cmiiDeploymentInterface.Namespace, 35)
+	content = utils.WordSpaceCompletion(content+cmiiDeploymentInterface.Name, 75)
+	content = utils.WordSpaceCompletion(content+oldImageTag, 105)
+	content = content + newTag + "\n"
+
+	log.DebugF("[UpdateCmiiDeploymentImageTag] - prepare to update [%s]!", content)
+
+	// update
+	tag := DefaultCmiiOperator.DeploymentUpdateTag(cmiiDeploymentInterface.Namespace, cmiiDeploymentInterface.Name, newTag)
+	if !tag {
+		log.ErrorF("[UpdateCmiiDeploymentImageTag] - [%s] update failed !", content)
+		return false, oldImageTag, newImageTag
+	}
+
+	// append update log
+	utils.AppendContentToFile(content, UpdateLogPath)
+
+	// re-get from env
+	time.Sleep(time.Second)
+	deploy := DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, appName)
+	if deploy == nil {
+		log.ErrorF("[UpdateCmiiDeploymentImageTag] - unknown error happened ! [%s] [%s] not exists !", cmiiEnv, appName)
+		return false, oldImageTag, newImageTag
+	}
+
+	// result
+	return true, oldImageTag, deploy.ImageTag
+}
+
+func UpdateCmiiImageTagFromNameTagMap(cmiiEnv string, nameTagMap map[string]string) (result map[string]string) {
+
+	result = make(map[string]string, len(nameTagMap))
+	for appName, newTag := range nameTagMap {
+		if AppNameBelongsToCmiiImage(appName) {
+			ok, oldImageTag, newImageTag := UpdateCmiiDeploymentImageTag(cmiiEnv, appName, newTag)
+			if ok {
+				log.InfoF("[UpdateCmiiImageTagFromNameTagMap] - %s %s to %s", cmiiEnv, appName, newTag)
+				result[appName] = newImageTag
+			} else {
+				result[appName] = oldImageTag
+			}
+		}
+	}
+
+	return result
+}
+
+func UpdateCmiiImageTagFromNameTagList(cmiiEnv string, nameTagList []string) (result map[string]string) {
+
+	nameTagMap := make(map[string]string, len(nameTagList))
+	for _, nameTag := range nameTagList {
+		if strings.HasPrefix(nameTag, image2.CmiiHarborPrefix) {
+			nameTag = strings.TrimPrefix(nameTag, image2.CmiiHarborPrefix)
+		}
+		split := strings.Split(nameTag, ":")
+		nameTagMap[split[0]] = split[1]
+	}
+
+	return UpdateCmiiImageTagFromNameTagMap(cmiiEnv, nameTagMap)
+}
+
+func RollBackCmiiDeploymentFromUpdateLog(updateLog string) bool {
+
+	//if !executor.BasicFindContentInFile(updateLog, UpdateLogPath) {
+	//    log.ErrorF("[RollBackCmiiDeploymentFromUpdateLog] - [%s] no this update log ! use update instead ! => ", updateLog)
+	//    return false
+	//}
+
+	split := strings.Split(updateLog, " ")
+	index := 0
+	cmiiEnv := ""
+	appName := ""
+	fromTag := ""
+	newTag := ""
+	for _, s := range split {
+		if s != "" {
+			if index == 1 {
+				cmiiEnv = s
+			} else if index == 2 {
+				appName = s
+			} else if index == 3 {
+				fromTag = s
+			} else if index == 4 {
+				newTag = s
+			}
+			index++
+		}
+	}
+
+	log.InfoF("[RollBackCmiiDeploymentFromUpdateLog] - rollback [%s] [%s] from [%s] to [%s]", cmiiEnv, appName, newTag, fromTag)
+	ok, _, _ := UpdateCmiiDeploymentImageTag(cmiiEnv, appName, fromTag)
+
+	return ok
+}
+
+// BackupAllDeploymentFromEnvToFile 从DEMO提取全部的CMII的应用
+func BackupAllDeploymentFromEnvToFile(cmiiEnv string) bool {
+
+	allInterface := DefaultCmiiOperator.DeploymentAllInterface(cmiiEnv)
+
+	// must filter
+	allInterface = FilterAllCmiiAppSoft(allInterface)
+
+	//filePath := "C:\\Users\\wddsh\\Documents\\IdeaProjects\\ProjectOctopus\\cmii_operator\\log\\all-" + DefaultCmiiOperator.CurrentNamespace + "-" + utils.TimeSplitFormatString() + ".txt"
+	filePath := "/home/wdd/IdeaProjects/ProjectOctopus/agent-operator/log/all-" + DefaultCmiiOperator.CurrentNamespace + "-" + utils.TimeSplitFormatString() + ".txt"
+
+	log.InfoF("[BackupAllDeploymentFromEnvToFile] - backup all image from %s => %s", DefaultCmiiOperator.CurrentNamespace, filePath)
+
+	firstCol := 0
+	secondCol := 0
+	thirdCol := 0
+	fourthCol := 0
+
+	for _, deploymentInterface := range allInterface {
+
+		firstCol = utils.MaxInt(len(deploymentInterface.Name), firstCol)
+		secondCol = utils.MaxInt(len(deploymentInterface.ImageTag), secondCol)
+		thirdCol = utils.MaxInt(len(deploymentInterface.GitBranch), thirdCol)
+		fourthCol = utils.MaxInt(len(deploymentInterface.GitCommit), fourthCol)
+	}
+
+	firstCol += 2
+	secondCol += 2
+	secondCol += firstCol
+	thirdCol += 2
+	thirdCol += secondCol
+	fourthCol += 2
+	fourthCol += thirdCol
+
+	for _, deploymentInterface := range allInterface {
+
+		if deploymentInterface.GitBranch == "" {
+			branch, commit := GetDeploymentGitInfoFromInnerEnv(deploymentInterface.Namespace, deploymentInterface.Name)
+			deploymentInterface.GitBranch = branch
+			deploymentInterface.GitCommit = commit
+		}
+
+		content := utils.WordSpaceCompletion(deploymentInterface.Name, firstCol)
+		content = utils.WordSpaceCompletion(content+deploymentInterface.ImageTag, secondCol)
+		content = utils.WordSpaceCompletion(content+deploymentInterface.GitBranch, thirdCol)
+		content = utils.WordSpaceCompletion(content+deploymentInterface.GitCommit, fourthCol)
+		content += "\n"
+
+		if !utils.AppendContentToFile(content, filePath) {
+			log.ErrorF("[BackupAllDeploymentFromEnvToFile] - write to file %s error with contend %s", filePath, content)
+			return false
+		}
+
+	}
+
+	return true
+}
+
+// BackupAllCmiiDeploymentToMap 备份DEMO环境全部的镜像名称为Map 包括SRS 前端 后端
+func BackupAllCmiiDeploymentToMap(cmiiEnv string) (backendMap, frontendMap, srsMap map[string]string) {
+
+	allInterface := DefaultCmiiOperator.DeploymentAllInterface(cmiiEnv)
+	allInterface = FilterAllCmiiAppSoft(allInterface)
+
+	backendMap = make(map[string]string, len(allInterface))
+	frontendMap = make(map[string]string, len(allInterface))
+	srsMap = make(map[string]string, len(allInterface))
+
+	for _, deploymentInterface := range allInterface {
+		if strings.Contains(deploymentInterface.Name, "platform") {
+			frontendMap[deploymentInterface.Name] = deploymentInterface.ImageTag
+		} else {
+			backendMap[deploymentInterface.Name] = deploymentInterface.ImageTag
+		}
+	}
+
+	// add srs part
+	for key, value := range d_app.CmiiSrsAppMap {
+		var app *config.CmiiDeploymentInterface
+		if strings.Contains(value, "deployment") {
+			app = DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, key)
+			if app != nil {
+				for _, imageName := range app.ContainerImageMap {
+					split := strings.Split(imageName, ":")
+					if strings.Contains(split[0], image2.CmiiHarborPrefix) {
+						split[0] = strings.Split(split[0], image2.CmiiHarborPrefix)[1]
+					}
+					srsMap[split[0]] = split[1]
+				}
+			}
+		} else if strings.Contains(value, "state") {
+			app = DefaultCmiiOperator.StatefulSetOneInterface(cmiiEnv, key)
+			if app != nil {
+				for _, imageName := range app.ContainerImageMap {
+					split := strings.Split(imageName, ":")
+					split[0], _ = strings.CutPrefix(split[0], image2.CmiiHarborPrefix)
+					srsMap[split[0]] = split[1]
+				}
+			}
+		}
+	}
+
+	return backendMap, frontendMap, srsMap
+}
+
+func BackupAllCmiiDeploymentToList(cmiiEnv string, completePrefix bool) (allCmiiImageList []string) {
+	backendMap, frontendMap, srsMap := BackupAllCmiiDeploymentToMap(cmiiEnv)
+	allImageMap := make(map[string]string, len(backendMap)+len(frontendMap)+len(srsMap))
+	for name, tag := range backendMap {
+		allImageMap[name] = tag
+	}
+	for name, tag := range frontendMap {
+		allImageMap[name] = tag
+	}
+	for name, tag := range srsMap {
+		allImageMap[name] = tag
+	}
+
+	for name, tag := range allImageMap {
+		if completePrefix {
+			allCmiiImageList = append(allCmiiImageList, image2.CmiiHarborPrefix+name+":"+tag)
+		} else {
+			allCmiiImageList = append(allCmiiImageList, name+":"+tag)
+		}
+	}
+	return allCmiiImageList
+}
+
+func BackUpAllCmiiAppImageNameFromEnv(cmiiEnv string) {
+
+	DefaultCmiiOperator.changeOperatorEnv(cmiiEnv)
+	//filePath := "C:\\Users\\wddsh\\Documents\\IdeaProjects\\ProjectOctopus\\cmii_operator\\log\\images-" + DefaultCmiiOperator.CurrentNamespace + "-" + utils.TimeSplitFormatString() + ".txt"
+	filePath := "/home/wdd/IdeaProjects/ProjectOctopus/agent-operator/log/images-" + DefaultCmiiOperator.CurrentNamespace + "-" + utils.TimeSplitFormatString() + ".txt"
+
+	only := make(map[string]string, 150)
+	// front
+	utils.AppendContentToFile("---\n", filePath)
+	for key, value := range d_app.CmiiFrontendAppMap {
+		_, ok := only[key]
+		if !ok {
+			deploy := DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, key)
+			if deploy != nil {
+				only[key] = value
+				utils.AppendContentToFile(deploy.Image+"\n", filePath)
+			}
+		}
+	}
+	utils.AppendContentToFile("---\n", filePath)
+	for key, value := range d_app.CmiiBackendAppMap {
+		_, ok := only[key]
+		if !ok {
+			deploy := DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, key)
+			if deploy != nil {
+				only[key] = value
+				utils.AppendContentToFile(deploy.Image+"\n", filePath)
+			}
+		}
+	}
+	// backend
+	utils.AppendContentToFile("---\n", filePath)
+	// gis server
+	for key, value := range d_app.CmiiGISAppMap {
+		_, ok := only[key]
+		if !ok {
+			deploy := DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, key)
+			if deploy != nil {
+				only[key] = value
+				utils.AppendContentToFile(deploy.Image+"\n", filePath)
+			}
+		}
+	}
+	// srs
+	utils.AppendContentToFile("---\n", filePath)
+	for key, value := range d_app.CmiiSrsAppMap {
+		_, ok := only[key]
+		if !ok {
+			var app *config.CmiiDeploymentInterface
+			if strings.Contains(value, "deployment") {
+				app = DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, key)
+				if app != nil {
+					only[key] = value
+					utils.AppendContentToFile(app.Image+"\n", filePath)
+				}
+			} else if strings.Contains(value, "state") {
+				app = DefaultCmiiOperator.StatefulSetOneInterface(cmiiEnv, key)
+				if app != nil {
+					only[key] = value
+					for _, imageName := range app.ContainerImageMap {
+						utils.AppendContentToFile(imageName+"\n", filePath)
+					}
+				}
+			}
+		}
+	}
+	utils.AppendContentToFile("---\n", filePath)
+}
+
+func FilterAllCmiiAppStrict(source []config.CmiiDeploymentInterface) (result []config.CmiiDeploymentInterface) {
+
+	for _, c := range source {
+		_, ok := d_app.CmiiBackendAppMap[c.ContainerName]
+		if !ok {
+			_, ok = d_app.CmiiFrontendAppMap[c.ContainerName]
+			if !ok {
+				log.WarnF("[FilterAllCmiiAppStrict] - [%s] not cmii pod ！", c.ContainerName)
+				continue
+			}
+		}
+
+		result = append(result, c)
+	}
+
+	return result
+}
+
+func FilterAllCmiiAppSoft(source []config.CmiiDeploymentInterface) (result []config.CmiiDeploymentInterface) {
+
+	for _, c := range source {
+		if strings.Contains(c.ContainerName, "redis") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "emqxs") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "rabbitmq") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "nacos") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "oss") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "minio") {
+			continue
+		}
+		if strings.HasPrefix(c.ContainerName, "nfs") {
+			continue
+		}
+		if strings.HasPrefix(c.ContainerName, "operator") {
+			continue
+		}
+		if strings.HasPrefix(c.ContainerName, "proxy") {
+			continue
+		}
+
+		result = append(result, c)
+	}
+
+	return result
+}
+
+func FilterAllCmiiPodStrict(podList []config.CmiiPodInterface) (result []config.CmiiPodInterface) {
+	for _, c := range podList {
+		_, ok := d_app.CmiiBackendAppMap[c.ContainerName]
+		if !ok {
+			_, ok = d_app.CmiiFrontendAppMap[c.ContainerName]
+			if !ok {
+				log.WarnF("[FilterAllCmiiPodStrict] - [%s] not cmii pod ！", c.ContainerName)
+				continue
+			}
+		}
+		result = append(result, c)
+	}
+
+	return result
+}
+
+func FilterAllCmiiPodSoft(podList []config.CmiiPodInterface) (result []config.CmiiPodInterface) {
+	for _, c := range podList {
+		if strings.Contains(c.ContainerName, "redis") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "emqxs") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "rabbitmq") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "nacos") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "oss") {
+			continue
+		}
+		if strings.Contains(c.ContainerName, "minio") {
+			continue
+		}
+		if strings.HasPrefix(c.ContainerName, "nfs") {
+			continue
+		}
+		if strings.HasPrefix(c.ContainerName, "operator") {
+			continue
+		}
+		if strings.HasPrefix(c.ContainerName, "proxy") {
+			continue
+		}
+		if strings.HasPrefix(c.ContainerName, "cleanlog") {
+			continue
+		}
+
+		result = append(result, c)
+	}
+
+	return result
+}
+
+func FilterAllCmiiNodeSoft(nodeList []config.CmiiNodeInterface) (result []config.CmiiNodeInterface) {
+
+	for _, nodeInterface := range nodeList {
+
+		if strings.HasPrefix(nodeInterface.Name, "ai") {
+			continue
+		}
+
+		if strings.HasPrefix(nodeInterface.Name, "35") {
+			continue
+		}
+
+		result = append(result, nodeInterface)
+	}
+
+	return result
+}
+
+// AppNameBelongsToCmiiImage 根据CmiiBackendAppMap CmiiFrontendAppMap判断一个appName是否属于CMII
+func AppNameBelongsToCmiiImage(appName string) bool {
+	_, ok := d_app.CmiiBackendAppMap[appName]
+	if !ok {
+		_, ok = d_app.CmiiFrontendAppMap[appName]
+		if !ok {
+			log.WarnF("[AppNameBelongsToCmiiImage] - [%s] not cmii app ！", appName)
+			return false
+		} else {
+			return true
+		}
+	} else {
+		return true
+	}
+
+}

agent-operator/CmiiK8sHigherOperator_test.go

@@ -0,0 +1,315 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+	"time"
+	"wdd.io/agent-common/assert"
+	"wdd.io/agent-common/pusher"
+	"wdd.io/agent-common/utils"
+	"wdd.io/agent-operator/config"
+)
+
+var CmiiDevNamespaceList = []string{
+	"uavcloud-dev",
+	"uavcloud-devflight",
+	"uavcloud-devoperation",
+}
+
+func TestFindAppNotHealthyOrRestartCountGreaterThanN(t *testing.T) {
+
+	deploymentRestartCountGreaterThanN := FindAppNotHealthyOrRestartCountGreaterThanN("devflight", 10)
+	deploymentRestartCountGreaterThanN = FilterAllCmiiAppSoft(deploymentRestartCountGreaterThanN)
+
+	for _, deploymentInterface := range deploymentRestartCountGreaterThanN {
+		println()
+		utils.BeautifulPrint(deploymentInterface)
+		println()
+	}
+
+}
+
+func TestFindDeploymentReplicasSmallerThanN(t *testing.T) {
+
+	deploymentReplicasSmallerThanN := FindDeploymentReplicasSmallerThanN("devflight", 0)
+
+	for _, deploymentInterface := range deploymentReplicasSmallerThanN {
+		println()
+		utils.BeautifulPrint(deploymentInterface)
+		println()
+	}
+
+}
+
+func TestFindCmiiMiddlewarePodInterface(t *testing.T) {
+	middlewarePodInterface := FindCmiiMiddlewarePodInterface(config.Integration)
+
+	for _, middlePod := range middlewarePodInterface {
+		println()
+		utils.BeautifulPrint(middlePod)
+		println()
+	}
+}
+
+func TestRollBackCmiiDeploymentFromUpdateLog(t *testing.T) {
+	updateLog := RollBackCmiiDeploymentFromUpdateLog("2024-01-10-14-37-07 uavcloud-devflight       cmii-uav-depotautoreturn                12345678            123sdsa45678")
+
+	assert.Equal(t, updateLog, true, "roll back from update log failed !")
+}
+
+func TestRestartCmiiBackendDeployment(t *testing.T) {
+
+	RestartCmiiBackendDeployment("dev")
+}
+
+func TestRestartCmiiFrontendDeployment(t *testing.T) {
+	RestartCmiiFrontendDeployment("dev")
+}
+
+func TestFindDeploymentNotHealthy(t *testing.T) {
+
+	for _, devNamespace := range CmiiDevNamespaceList {
+		notHealthy := FindDeploymentNotHealthy(devNamespace)
+		notHealthy = FilterAllCmiiAppSoft(notHealthy)
+		for _, deploymentInterface := range notHealthy {
+			utils.BeautifulPrint(deploymentInterface)
+		}
+	}
+}
+
+func TestFindAllNodeNotHealthy(t *testing.T) {
+	start := time.Now()
+	allNodeNotHealthy := FindAllNodeNotHealthy()
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
+
+	allNodeNotHealthy = FilterAllCmiiNodeSoft(allNodeNotHealthy)
+
+	assert.Equal(t, len(allNodeNotHealthy), 0, "have unhealthy pod !")
+
+	for _, nodeInterface := range allNodeNotHealthy {
+		println()
+		utils.BeautifulPrint(nodeInterface)
+		println()
+	}
+
+}
+
+func TestFindPodNotHealthy(t *testing.T) {
+
+	podNotHealthy := FindPodNotHealthy("devfl")
+	podNotHealthy = FilterAllCmiiPodSoft(podNotHealthy)
+
+	for _, podInterface := range podNotHealthy {
+		t.Logf("[%s] [%s]", podInterface.Name, podInterface.PodPhase)
+	}
+}
+
+func TestFindPodNotHealthy_And_Delete(t *testing.T) {
+	podNotHealthy := FindPodNotHealthy("devf")
+	podNotHealthy = FilterAllCmiiPodSoft(podNotHealthy)
+
+	for _, podInterface := range podNotHealthy {
+		t.Logf("[%s] [%s]", podInterface.Name, podInterface.PodPhase)
+		podDelete := DefaultCmiiOperator.PodDelete(podInterface.Namespace, podInterface.Name)
+
+		assert.Equal(t, podDelete, true, "delete of ", podInterface.Namespace, podInterface.Name, " failed !")
+	}
+
+}
+
+func TestFilterAllCmiiAppStrict(t *testing.T) {
+	allInterface := DefaultCmiiOperator.DeploymentAllInterface("devflight")
+	FilterAllCmiiAppStrict(allInterface)
+}
+
+func TestRestartDeploymentFromList(t *testing.T) {
+	allInterface := DefaultCmiiOperator.DeploymentAllInterface("devflight")
+	allInterface = FilterAllCmiiAppSoft(allInterface)
+
+	RestartDeploymentFromList(allInterface)
+
+}
+
+func TestBackupAllCmiiDeploymentToMap(t *testing.T) {
+
+	backendMap, frontendMap, srsMap := BackupAllCmiiDeploymentToMap(config.Demo)
+
+	utils.BeautifulPrint(backendMap)
+	utils.BeautifulPrint(frontendMap)
+	utils.BeautifulPrint(srsMap)
+}
+
+func TestBackupAllCmiiDeploymentToList(t *testing.T) {
+	allCmiiImageList := BackupAllCmiiDeploymentToList(config.Demo, true)
+
+	utils.BeautifulPrint(allCmiiImageList)
+}
+
+// 直接更新DEMO的Tag，实现DEMO更新
+func TestUpdateCmiiImageTagFromNameTagMap(t *testing.T) {
+
+	backendMap := map[string]string{
+		"cmii-admin-data":               "6.0.0",
+		"cmii-admin-gateway":            "6.0.0",
+		"cmii-admin-user":               "6.0.0",
+		"cmii-open-gateway":             "6.0.0",
+		"cmii-suav-supervision":         "6.0.0",
+		"cmii-uav-airspace":             "6.0.0",
+		"cmii-uav-alarm":                "6.0.0",
+		"cmii-uav-brain":                "6.0.0",
+		"cmii-uav-cloud-live":           "6.0.0",
+		"cmii-uav-cms":                  "6.0.0",
+		"cmii-uav-data-post-process":    "6.0.0",
+		"cmii-uav-developer":            "6.0.0",
+		"cmii-uav-device":               "6.0.0",
+		"cmii-uav-emergency":            "6.0.0",
+		"cmii-uav-gateway":              "6.0.0",
+		"cmii-uav-gis-server":           "6.0.0",
+		"cmii-uav-industrial-portfolio": "6.0.0",
+		"cmii-uav-integration":          "6.0.0",
+		"cmii-uav-logger":               "6.0.0",
+		"cmii-uav-material-warehouse":   "6.0.0",
+		"cmii-uav-mission":              "6.0.0",
+		"cmii-uav-mqtthandler":          "6.0.0",
+		"cmii-uav-notice":               "6.0.0",
+		"cmii-uav-oauth":                "6.0.0",
+		"cmii-uav-process":              "6.0.0",
+		"cmii-uav-surveillance":         "6.0.0",
+		"cmii-uav-threedsimulation":     "6.0.0",
+		"cmii-uav-tower":                "6.0.0",
+		"cmii-uav-user":                 "6.0.0",
+		"cmii-uav-waypoint":             "6.0.0",
+		"cmii-uav-sense-adapter":        "6.0.0",
+		"cmii-uas-lifecycle":            "6.0.0",
+		"cmii-uas-gateway":              "6.0.0",
+	}
+
+	frontendMap := map[string]string{
+		"cmii-suav-platform-supervision":   "6.0.0",
+		"cmii-suav-platform-supervisionh5": "6.0.0",
+		"cmii-uav-platform":                "6.0.0",
+		"cmii-uav-platform-media":          "6.0.0",
+		"cmii-uav-platform-ai-brain":       "6.0.0",
+		"cmii-uav-platform-cms-portal":     "6.0.0",
+		"cmii-uav-platform-armypeople":     "6.0.0",
+		"cmii-uav-platform-mws":            "6.0.0",
+		"cmii-uav-platform-oms":            "6.0.0",
+		"cmii-uav-platform-open":           "6.0.0",
+		"cmii-uav-platform-securityh5":     "6.0.0",
+		"cmii-uav-platform-share":          "6.0.0",
+		"cmii-uav-platform-uasms":          "6.0.0",
+		"cmii-uav-platform-uas":            "6.0.0",
+		//"cmii-uav-platform-base":             "5.7.0",
+		//"cmii-uav-platform-detection":        "5.7.0",
+		//"cmii-uav-platform-emergency-rescue": "5.7.0",
+		//"cmii-uav-platform-logistics":        "5.7.0",
+		//"cmii-uav-platform-multiterminal":    "5.7.0",
+		//"cmii-uav-platform-seniclive":        "5.7.0",
+		//"cmii-uav-platform-splice":           "5.7.0",
+		//"cmii-uav-platform-threedsimulation": "5.7.0",
+		//"cmii-uav-platform-visualization":    "5.7.0",
+		//"cmii-uav-platform-security":         "4.1.6",
+	}
+
+	result := UpdateCmiiImageTagFromNameTagMap(config.Demo, backendMap)
+	utils.BeautifulPrint(result)
+
+	result = UpdateCmiiImageTagFromNameTagMap(config.Demo, frontendMap)
+	utils.BeautifulPrint(result)
+
+}
+
+func TestScaleCmiiFrontendDeploymentToDesiredReplicas(t *testing.T) {
+	ScaleCmiiFrontendDeploymentToDesiredReplicas(config.Dev, 0)
+}
+
+func TestScaleCmiiBackendDeploymentToDesiredReplicas(t *testing.T) {
+	ScaleCmiiBackendDeploymentToDesiredReplicas(config.Dev, 0)
+}
+
+func TestBackupAllDeploymentFromEnv(t *testing.T) {
+
+	BackupAllDeploymentFromEnvToFile(config.Demo)
+
+}
+
+func TestBackUpAllCmiiAppImageNameFromEnv(t *testing.T) {
+
+	BackUpAllCmiiAppImageNameFromEnv(config.Demo)
+
+}
+
+func TestRestartCmiiDeployment(t *testing.T) {
+	cmiiEnv := config.DevOperation
+	appName := "cmii-uav-mqtthandler"
+
+	kill := DefaultCmiiOperator.DeploymentRestartByKill(cmiiEnv, appName)
+	assert.Equal(t, kill, true, "have unhealthy pod !")
+
+	check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
+	assert.Equal(t, check, true, "DeploymentStatusCheck failed !")
+}
+
+func TestUpdateCmiiDeploymentImageTag(t *testing.T) {
+
+	//计算20:00的时间
+
+	now := time.Now()
+
+	targetTime := time.Date(now.Year(), now.Month(), now.Day(), 14, 43, 00, 0, now.Location())
+
+	duration := time.Duration(0)
+
+	if !now.After(targetTime) {
+		// 计算到20:00的剩余时间
+		duration = targetTime.Sub(now)
+	} else {
+		// 如果当前时间已经过了20:00，那么就跳到下一天
+		//targetTime = targetTime.Add(24 * time.Hour)
+	}
+
+	fmt.Println(duration)
+
+	// 等待到20:00
+	//time.Sleep(duration)
+
+	cmiiEnv := config.Demo
+
+	appNameTagMap := map[string]string{
+		//"cmii-uas-lifecycle": "6.1.0-20241125-112901",
+		"cmii-uav-platform": "6.1.0-20241125-120201",
+	}
+
+	for appName, newTag := range appNameTagMap {
+		ok, oldImageTag, newImageTag := UpdateCmiiDeploymentImageTag(cmiiEnv, appName, newTag)
+
+		if !ok {
+			log.ErrorF("update image tag failed !")
+			UpdateCmiiDeploymentImageTag(cmiiEnv, appName, oldImageTag)
+		}
+		utils.SplitLinePrint()
+
+		check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 300)
+		assert.Equal(t, check, true, "deployment run failed!")
+		if !check {
+			UpdateCmiiDeploymentImageTag(cmiiEnv, appName, oldImageTag)
+		}
+
+		deploy := DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, appName)
+
+		// push message
+		message := pusher.CmiiUpdateMessage{
+			Namespace:    cmiiEnv,
+			AppName:      appName,
+			FromTag:      oldImageTag,
+			ToTag:        newImageTag,
+			Replicas:     strconv.FormatInt(int64(deploy.Replicas), 10),
+			DeployStatus: check,
+		}
+		message.SendMessage()
+
+	}
+
+}

agent-operator/CmiiK8sOperator_test.go

@@ -1,313 +1,321 @@
 package main
 
 import (
+	"bufio"
 	"fmt"
-	"strconv"
 	"testing"
 	"time"
 	"wdd.io/agent-common/assert"
-	"wdd.io/agent-common/pusher"
 	"wdd.io/agent-common/utils"
+	"wdd.io/agent-operator/config"
 )
 
-var CmiiDevNamespaceList = []string{
-	"uavcloud-dev",
-	"uavcloud-devflight",
-	"uavcloud-devoperation",
+func TestCmiiK8sOperator_DeploymentAll(t *testing.T) {
+
+	start := time.Now()
+	deploymentList := DefaultCmiiOperator.DeploymentAll("devflight")
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
+
+	var nameList []string
+
+	count := 1
+	for _, deployment := range deploymentList {
+		if deployment.Spec.Replicas != nil {
+			count++
+		}
+		nameList = append(nameList, deployment.Name)
+	}
+
+	t.Logf("deployment list lenght is => %d", count)
+	t.Logf("deployment name list are => %d", count)
+
+	utils.BeautifulPrint(nameList)
+	//for _, deployment := range deploymentList {
+	//	utils.BeautifulPrint(deployment)
+	//	println()
+	//}
+
+}
+func TestCmiiK8sOperator_DeploymentAllInterface(t *testing.T) {
+
+	start := time.Now()
+	deploymentList := DefaultCmiiOperator.DeploymentAllInterface("devflight")
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
+
+	t.Logf("deployment list lenght is => %d", len(deploymentList))
+
+	for _, deployment := range deploymentList {
+		utils.BeautifulPrint(deployment)
+		println()
+	}
 }
 
-func TestFindAppNotHealthyOrRestartCountGreaterThanN(t *testing.T) {
+func TestCmiiK8sOperator_DeploymentFizz(t *testing.T) {
 
-	deploymentRestartCountGreaterThanN := FindAppNotHealthyOrRestartCountGreaterThanN("devflight", 10)
-	deploymentRestartCountGreaterThanN = FilterAllCmiiAppSoft(deploymentRestartCountGreaterThanN)
+	start := time.Now()
+	deploymentFizz := DefaultCmiiOperator.DeploymentFizz("int", "cmii-suav-supervision")
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
 
-	for _, deploymentInterface := range deploymentRestartCountGreaterThanN {
+	t.Logf("deployment list lenght is => %d", len(deploymentFizz))
+
+	cmiiDeploymentInterface := config.CmiiDeploymentInterface{}
+	for _, pod := range deploymentFizz {
+		convert := cmiiDeploymentInterface.Convert(pod)
+		utils.BeautifulPrint(convert)
+
+		utils.BeautifulPrint(pod)
+	}
+
+	// elastic search
+
+}
+
+func TestCmiiK8sOperator_DeploymentScale(t *testing.T) {
+	start := time.Now()
+
+	DefaultCmiiOperator.DeploymentScale(config.Demo, "cmii-uav-industrial-portfolio", 1)
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
+
+}
+
+func TestCmiiK8sOperator_DeploymentUpdateTag(t *testing.T) {
+
+	start := time.Now()
+	DefaultCmiiOperator.DeploymentUpdateTag("Demo", "cmii-uav-gateway", "5.7.0")
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
+}
+
+func TestCmiiK8sOperator_DeploymentRestart(t *testing.T) {
+
+	cmiiEnv := config.Integration
+	appName := "cmii-uav-data-post-process"
+
+	DefaultCmiiOperator.DeploymentRestart(cmiiEnv, appName)
+
+	utils.SplitLinePrint()
+
+	check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
+	assert.Equal(t, check, true, "deployment run failed!")
+}
+
+func TestCmiiK8sOperator_DeploymentRestartByKill(t *testing.T) {
+	cmiiEnv := "Demo"
+	appName := "cmii-uav-platform"
+
+	kill := DefaultCmiiOperator.DeploymentRestartByKill(cmiiEnv, appName)
+	assert.Equal(t, kill, true, "deployment restart by kill failed !")
+
+	utils.SplitLinePrint()
+
+	check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
+	assert.Equal(t, check, true, "deployment run failed!")
+
+}
+
+func TestCmiiK8sOperator_DeploymentOneInterface(t *testing.T) {
+	start := time.Now()
+	deploy := DefaultCmiiOperator.DeploymentOneInterface("devflight", "cmii-uav-depotautoreturn")
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
+
+	utils.BeautifulPrint(*deploy)
+}
+
+func TestCmiiK8sOperator_ReplicaSetExists(t *testing.T) {
+
+	cmiiEnv := "uavcloud-devflight"
+	appName := "cmii-admin-data-bf8f87cb7"
+
+	exists := DefaultCmiiOperator.ReplicaSetExists(cmiiEnv, appName)
+
+	utils.BeautifulPrint(*exists)
+}
+
+func TestCmiiK8sOperator_ReplicaSetByAppName(t *testing.T) {
+
+	cmiiEnv := "uavcloud-devflight"
+	appName := "cmii-admin-data"
+
+	exists := DefaultCmiiOperator.ReplicaSetByAppName(cmiiEnv, appName)
+
+	for _, replicaSet := range exists {
+		utils.BeautifulPrint(replicaSet)
+	}
+}
+
+func TestCmiiK8sOperator_PodAll(t *testing.T) {
+	start := time.Now()
+	podList := DefaultCmiiOperator.PodAll("devflight")
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
+
+	for _, pod := range podList {
 		println()
-		utils.BeautifulPrint(deploymentInterface)
+		utils.BeautifulPrint(pod)
+		println()
+		break
+	}
+}
+
+func TestCmiiK8sOperator_PodFizz(t *testing.T) {
+	start := time.Now()
+	podList := DefaultCmiiOperator.PodFizz("devflight", "cmii-uav-data-post-process")
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
+	t.Logf("pod list lenght is => %d", len(podList))
+
+	cmiiPodInterface := config.CmiiPodInterface{}
+	for _, pod := range podList {
+		println()
+		utils.BeautifulPrint(pod)
+		println()
+		convert := cmiiPodInterface.Convert(pod)
+		utils.BeautifulPrint(convert)
+	}
+
+}
+
+func TestCmiiK8sOperator_PodByAppName(t *testing.T) {
+	cmiiEnv := "Uat"
+	appName := "cmii-admin-data"
+
+	exists := DefaultCmiiOperator.PodByNodeName(cmiiEnv, appName)
+
+	for _, podInterface := range exists {
+		utils.BeautifulPrint(podInterface)
+	}
+}
+
+func TestCmiiK8sOperator_PodFizz2(t *testing.T) {
+
+	start := time.Now()
+	podList := DefaultCmiiOperator.PodFizz("devflight", "notice")
+	elapsed := time.Since(start).Milliseconds()
+	fmt.Printf("执行耗时： %d ms\n", elapsed)
+	t.Logf("pod list lenght is => %d", len(podList))
+
+	podInterface := config.CmiiPodInterface{}
+
+	for _, pod := range podList {
+		convert := podInterface.Convert(pod)
+
+		println()
+		utils.BeautifulPrint(&convert)
 		println()
 	}
 
 }
 
-func TestFindDeploymentReplicasSmallerThanN(t *testing.T) {
+func TestCmiiK8sOperator_PodByNodeName(t *testing.T) {
 
-	deploymentReplicasSmallerThanN := FindDeploymentReplicasSmallerThanN("devflight", 0)
+	cmiiEnv := config.DevOperation
+	nodeName := "Dev-master-01"
 
-	for _, deploymentInterface := range deploymentReplicasSmallerThanN {
-		println()
-		utils.BeautifulPrint(deploymentInterface)
-		println()
-	}
+	exists := DefaultCmiiOperator.PodByNodeName(cmiiEnv, nodeName)
+	exists = FilterAllCmiiPodSoft(exists)
+	for _, podInterface := range exists {
+		utils.BeautifulPrint(podInterface)
 
-}
-
-func TestFindCmiiMiddlewarePodInterface(t *testing.T) {
-	middlewarePodInterface := FindCmiiMiddlewarePodInterface(integration)
-
-	for _, middlePod := range middlewarePodInterface {
-		println()
-		utils.BeautifulPrint(middlePod)
-		println()
-	}
-}
-
-func TestRollBackCmiiDeploymentFromUpdateLog(t *testing.T) {
-	updateLog := RollBackCmiiDeploymentFromUpdateLog("2024-01-10-14-37-07 uavcloud-devflight       cmii-uav-depotautoreturn                12345678            123sdsa45678")
-
-	assert.Equal(t, updateLog, true, "roll back from update log failed !")
-}
-
-func TestRestartCmiiBackendDeployment(t *testing.T) {
-
-	RestartCmiiBackendDeployment("dev")
-}
-
-func TestRestartCmiiFrontendDeployment(t *testing.T) {
-	RestartCmiiFrontendDeployment("dev")
-}
-
-func TestFindDeploymentNotHealthy(t *testing.T) {
-
-	for _, devNamespace := range CmiiDevNamespaceList {
-		notHealthy := FindDeploymentNotHealthy(devNamespace)
-		notHealthy = FilterAllCmiiAppSoft(notHealthy)
-		for _, deploymentInterface := range notHealthy {
-			utils.BeautifulPrint(deploymentInterface)
+		if !podInterface.PodStatus {
+			podDelete := DefaultCmiiOperator.PodDelete(podInterface.Namespace, podInterface.Name)
+			assert.Equal(t, podDelete, true, "delete pod failed !")
 		}
 	}
 }
 
-func TestFindAllNodeNotHealthy(t *testing.T) {
+func TestCmiiK8sOperator_NodeCordon(t *testing.T) {
+	cmiiEnv := config.DevOperation
+	nodeName := "Dev-master-01"
+
+	cordon := DefaultCmiiOperator.NodeCordon(cmiiEnv, nodeName)
+	assert.Equal(t, cordon, true, "cordon node failed !")
+}
+
+func TestCmiiK8sOperator_NodeUnCordon(t *testing.T) {
+	cmiiEnv := config.DevOperation
+	nodeName := "Dev-06.ecs.io"
+
+	uncordon := DefaultCmiiOperator.NodeUnCordon(cmiiEnv, nodeName)
+	assert.Equal(t, uncordon, true, "uncordon node failed !")
+}
+
+func TestCmiiK8sOperator_PodEvictFromNode(t *testing.T) {
+	cmiiEnv := config.DevOperation
+	nodeName := "Dev-04.ecs.io"
+
+	podList := DefaultCmiiOperator.PodEvictFromNode(cmiiEnv, nodeName)
+
+	for _, podInterface := range podList {
+		utils.BeautifulPrint(podInterface)
+	}
+
+}
+
+func TestCmiiK8sOperator_PodExec(t *testing.T) {
+
+	podList := DefaultCmiiOperator.PodByAppName(config.DevFlight, "cmii-uav-gateway")
+
+	stdout, stderr := DefaultCmiiOperator.PodExec(config.DevFlight, podList[0], []string{
+		"env",
+	})
+
+	scanner := bufio.NewScanner(stdout)
+
+	for scanner.Scan() {
+		// Get the current line
+		line := scanner.Text()
+
+		// Check if the current line contains the search term
+		fmt.Println(line)
+	}
+	utils.SplitLinePrint()
+
+	scanner = bufio.NewScanner(stderr)
+	for scanner.Scan() {
+		// Get the current line
+		line := scanner.Text()
+
+		// Check if the current line contains the search term
+		fmt.Println(line)
+	}
+
+}
+
+func TestCmiiK8sOperator_DeploymentStatusCheck(t *testing.T) {
+
+	cmiiEnv := "devflight"
+	appName := "cmii-uav-gateway"
+
+	check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
+	assert.Equal(t, check, true, "deployment run failed!")
+
+}
+
+func TestCmiiK8sOperator_NodeAll(t *testing.T) {
 	start := time.Now()
-	allNodeNotHealthy := FindAllNodeNotHealthy()
+	nodeList := DefaultCmiiOperator.NodeAll("Dev")
 	elapsed := time.Since(start).Milliseconds()
 	fmt.Printf("执行耗时： %d ms\n", elapsed)
 
-	allNodeNotHealthy = FilterAllCmiiNodeSoft(allNodeNotHealthy)
+	for _, node := range nodeList {
 
-	assert.Equal(t, len(allNodeNotHealthy), 0, "have unhealthy pod !")
+		println()
+		utils.BeautifulPrint(node)
+		println()
+	}
+}
 
-	for _, nodeInterface := range allNodeNotHealthy {
+func TestCmiiK8sOperator_NodeAllInterface(t *testing.T) {
+	cmiiNodeInterfaces := DefaultCmiiOperator.NodeAllInterface(config.Demo)
+
+	for _, nodeInterface := range cmiiNodeInterfaces {
 		println()
 		utils.BeautifulPrint(nodeInterface)
 		println()
 	}
-
-}
-
-func TestFindPodNotHealthy(t *testing.T) {
-
-	podNotHealthy := FindPodNotHealthy("devfl")
-	podNotHealthy = FilterAllCmiiPodSoft(podNotHealthy)
-
-	for _, podInterface := range podNotHealthy {
-		t.Logf("[%s] [%s]", podInterface.Name, podInterface.PodPhase)
-	}
-}
-
-func TestFindPodNotHealthy_And_Delete(t *testing.T) {
-	podNotHealthy := FindPodNotHealthy("devf")
-	podNotHealthy = FilterAllCmiiPodSoft(podNotHealthy)
-
-	for _, podInterface := range podNotHealthy {
-		t.Logf("[%s] [%s]", podInterface.Name, podInterface.PodPhase)
-		podDelete := DefaultCmiiOperator.PodDelete(podInterface.Namespace, podInterface.Name)
-
-		assert.Equal(t, podDelete, true, "delete of ", podInterface.Namespace, podInterface.Name, " failed !")
-	}
-
-}
-
-func TestFilterAllCmiiAppStrict(t *testing.T) {
-	allInterface := DefaultCmiiOperator.DeploymentAllInterface("devflight")
-	FilterAllCmiiAppStrict(allInterface)
-}
-
-func TestRestartDeploymentFromList(t *testing.T) {
-	allInterface := DefaultCmiiOperator.DeploymentAllInterface("devflight")
-	allInterface = FilterAllCmiiAppSoft(allInterface)
-
-	RestartDeploymentFromList(allInterface)
-
-}
-
-func TestBackupAllCmiiDeploymentToMap(t *testing.T) {
-
-	backendMap, frontendMap, srsMap := BackupAllCmiiDeploymentToMap(demo)
-
-	utils.BeautifulPrint(backendMap)
-	utils.BeautifulPrint(frontendMap)
-	utils.BeautifulPrint(srsMap)
-}
-
-func TestBackupAllCmiiDeploymentToList(t *testing.T) {
-	allCmiiImageList := BackupAllCmiiDeploymentToList(demo, true)
-
-	utils.BeautifulPrint(allCmiiImageList)
-}
-
-// Update DEMO by Tag Update
-func TestUpdateCmiiImageTagFromNameTagMap(t *testing.T) {
-
-	backendMap := map[string]string{
-		"cmii-admin-data":               "6.0.0",
-		"cmii-admin-gateway":            "6.0.0",
-		"cmii-admin-user":               "6.0.0",
-		"cmii-open-gateway":             "6.0.0",
-		"cmii-suav-supervision":         "6.0.0",
-		"cmii-uav-airspace":             "6.0.0",
-		"cmii-uav-alarm":                "6.0.0",
-		"cmii-uav-brain":                "6.0.0",
-		"cmii-uav-cloud-live":           "6.0.0",
-		"cmii-uav-cms":                  "6.0.0",
-		"cmii-uav-data-post-process":    "6.0.0",
-		"cmii-uav-developer":            "6.0.0",
-		"cmii-uav-device":               "6.0.0",
-		"cmii-uav-emergency":            "6.0.0",
-		"cmii-uav-gateway":              "6.0.0",
-		"cmii-uav-gis-server":           "6.0.0",
-		"cmii-uav-industrial-portfolio": "6.0.0",
-		"cmii-uav-integration":          "6.0.0",
-		"cmii-uav-logger":               "6.0.0",
-		"cmii-uav-material-warehouse":   "6.0.0",
-		"cmii-uav-mission":              "6.0.0",
-		"cmii-uav-mqtthandler":          "6.0.0",
-		"cmii-uav-notice":               "6.0.0",
-		"cmii-uav-oauth":                "6.0.0",
-		"cmii-uav-process":              "6.0.0",
-		"cmii-uav-surveillance":         "6.0.0",
-		"cmii-uav-threedsimulation":     "6.0.0",
-		"cmii-uav-tower":                "6.0.0",
-		"cmii-uav-user":                 "6.0.0",
-		"cmii-uav-waypoint":             "6.0.0",
-		"cmii-uav-sense-adapter":        "6.0.0",
-		"cmii-uas-lifecycle":            "6.0.0",
-		"cmii-uas-gateway":              "6.0.0",
-	}
-
-	frontendMap := map[string]string{
-		"cmii-suav-platform-supervision":   "6.0.0",
-		"cmii-suav-platform-supervisionh5": "6.0.0",
-		"cmii-uav-platform":                "6.0.0",
-		"cmii-uav-platform-media":          "6.0.0",
-		"cmii-uav-platform-ai-brain":       "6.0.0",
-		"cmii-uav-platform-cms-portal":     "6.0.0",
-		"cmii-uav-platform-armypeople":     "6.0.0",
-		"cmii-uav-platform-mws":            "6.0.0",
-		"cmii-uav-platform-oms":            "6.0.0",
-		"cmii-uav-platform-open":           "6.0.0",
-		"cmii-uav-platform-securityh5":     "6.0.0",
-		"cmii-uav-platform-share":          "6.0.0",
-		"cmii-uav-platform-uasms":          "6.0.0",
-		"cmii-uav-platform-uas":            "6.0.0",
-		//"cmii-uav-platform-base":             "5.7.0",
-		//"cmii-uav-platform-detection":        "5.7.0",
-		//"cmii-uav-platform-emergency-rescue": "5.7.0",
-		//"cmii-uav-platform-logistics":        "5.7.0",
-		//"cmii-uav-platform-multiterminal":    "5.7.0",
-		//"cmii-uav-platform-seniclive":        "5.7.0",
-		//"cmii-uav-platform-splice":           "5.7.0",
-		//"cmii-uav-platform-threedsimulation": "5.7.0",
-		//"cmii-uav-platform-visualization":    "5.7.0",
-		//"cmii-uav-platform-security":         "4.1.6",
-	}
-
-	result := UpdateCmiiImageTagFromNameTagMap(demo, backendMap)
-	utils.BeautifulPrint(result)
-
-	result = UpdateCmiiImageTagFromNameTagMap(demo, frontendMap)
-	utils.BeautifulPrint(result)
-
-}
-
-func TestScaleCmiiFrontendDeploymentToDesiredReplicas(t *testing.T) {
-	ScaleCmiiFrontendDeploymentToDesiredReplicas(dev, 0)
-}
-
-func TestScaleCmiiBackendDeploymentToDesiredReplicas(t *testing.T) {
-	ScaleCmiiBackendDeploymentToDesiredReplicas(dev, 0)
-}
-
-func TestBackupAllDeploymentFromEnv(t *testing.T) {
-
-	BackupAllDeploymentFromEnvToFile(demo)
-
-}
-
-func TestBackUpAllCmiiAppImageNameFromEnv(t *testing.T) {
-
-	BackUpAllCmiiAppImageNameFromEnv(demo)
-
-}
-
-func TestRestartCmiiDeployment(t *testing.T) {
-	cmiiEnv := integration
-	appName := "cmii-uav-platform"
-
-	kill := DefaultCmiiOperator.DeploymentRestartByKill(cmiiEnv, appName)
-	assert.Equal(t, kill, true, "have unhealthy pod !")
-
-	check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
-	assert.Equal(t, check, true, "DeploymentStatusCheck failed !")
-}
-
-func TestUpdateCmiiDeploymentImageTag(t *testing.T) {
-
-	//计算20:00的时间
-
-	now := time.Now()
-
-	targetTime := time.Date(now.Year(), now.Month(), now.Day(), 9, 28, 00, 0, now.Location())
-
-	duration := time.Duration(0)
-
-	if !now.After(targetTime) {
-		// 计算到20:00的剩余时间
-		duration = targetTime.Sub(now)
-	} else {
-		// 如果当前时间已经过了20:00，那么就跳到下一天
-		//targetTime = targetTime.Add(24 * time.Hour)
-	}
-
-	fmt.Println(duration)
-
-	// 等待到20:00
-	time.Sleep(duration)
-
-	cmiiEnv := demo
-
-	appNameTagMap := map[string]string{
-		"cmii-uas-lifecycle": "6.0.0-111201",
-	}
-
-	for appName, newTag := range appNameTagMap {
-		ok, oldImageTag, newImageTag := UpdateCmiiDeploymentImageTag(cmiiEnv, appName, newTag)
-
-		if !ok {
-			log.ErrorF("update image tag failed !")
-			UpdateCmiiDeploymentImageTag(cmiiEnv, appName, oldImageTag)
-		}
-		utils.SplitLinePrint()
-
-		check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 300)
-		assert.Equal(t, check, true, "deployment run failed!")
-		if !check {
-			UpdateCmiiDeploymentImageTag(cmiiEnv, appName, oldImageTag)
-		}
-
-		deploy := DefaultCmiiOperator.DeploymentOneInterface(cmiiEnv, appName)
-
-		// push message
-		message := pusher.CmiiUpdateMessage{
-			Namespace:    cmiiEnv,
-			AppName:      appName,
-			FromTag:      oldImageTag,
-			ToTag:        newImageTag,
-			Replicas:     strconv.FormatInt(int64(deploy.Replicas), 10),
-			DeployStatus: check,
-		}
-		message.SendMessage()
-
-	}
-
 }

agent-operator/K8sOperator_test.go

@@ -1,320 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"testing"
-	"time"
-	"wdd.io/agent-common/assert"
-	"wdd.io/agent-common/utils"
-)
-
-func TestCmiiK8sOperator_DeploymentAll(t *testing.T) {
-
-	start := time.Now()
-	deploymentList := DefaultCmiiOperator.DeploymentAll("devflight")
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-
-	var nameList []string
-
-	count := 1
-	for _, deployment := range deploymentList {
-		if deployment.Spec.Replicas != nil {
-			count++
-		}
-		nameList = append(nameList, deployment.Name)
-	}
-
-	t.Logf("deployment list lenght is => %d", count)
-	t.Logf("deployment name list are => %d", count)
-
-	utils.BeautifulPrint(nameList)
-	//for _, deployment := range deploymentList {
-	//	utils.BeautifulPrint(deployment)
-	//	println()
-	//}
-
-}
-func TestCmiiK8sOperator_DeploymentAllInterface(t *testing.T) {
-
-	start := time.Now()
-	deploymentList := DefaultCmiiOperator.DeploymentAllInterface("devflight")
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-
-	t.Logf("deployment list lenght is => %d", len(deploymentList))
-
-	for _, deployment := range deploymentList {
-		utils.BeautifulPrint(deployment)
-		println()
-	}
-}
-
-func TestCmiiK8sOperator_DeploymentFizz(t *testing.T) {
-
-	start := time.Now()
-	deploymentFizz := DefaultCmiiOperator.DeploymentFizz("int", "cmii-suav-supervision")
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-
-	t.Logf("deployment list lenght is => %d", len(deploymentFizz))
-
-	cmiiDeploymentInterface := CmiiDeploymentInterface{}
-	for _, pod := range deploymentFizz {
-		convert := cmiiDeploymentInterface.Convert(pod)
-		utils.BeautifulPrint(convert)
-
-		utils.BeautifulPrint(pod)
-	}
-
-	// elastic search
-
-}
-
-func TestCmiiK8sOperator_DeploymentScale(t *testing.T) {
-	start := time.Now()
-
-	DefaultCmiiOperator.DeploymentScale(demo, "cmii-uav-industrial-portfolio", 1)
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-
-}
-
-func TestCmiiK8sOperator_DeploymentUpdateTag(t *testing.T) {
-
-	start := time.Now()
-	DefaultCmiiOperator.DeploymentUpdateTag("demo", "cmii-uav-gateway", "5.7.0")
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-}
-
-func TestCmiiK8sOperator_DeploymentRestart(t *testing.T) {
-
-	cmiiEnv := integration
-	appName := "cmii-uav-data-post-process"
-
-	DefaultCmiiOperator.DeploymentRestart(cmiiEnv, appName)
-
-	utils.SplitLinePrint()
-
-	check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
-	assert.Equal(t, check, true, "deployment run failed!")
-}
-
-func TestCmiiK8sOperator_DeploymentRestartByKill(t *testing.T) {
-	cmiiEnv := "demo"
-	appName := "cmii-uav-platform"
-
-	kill := DefaultCmiiOperator.DeploymentRestartByKill(cmiiEnv, appName)
-	assert.Equal(t, kill, true, "deployment restart by kill failed !")
-
-	utils.SplitLinePrint()
-
-	check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
-	assert.Equal(t, check, true, "deployment run failed!")
-
-}
-
-func TestCmiiK8sOperator_DeploymentOneInterface(t *testing.T) {
-	start := time.Now()
-	deploy := DefaultCmiiOperator.DeploymentOneInterface("devflight", "cmii-uav-depotautoreturn")
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-
-	utils.BeautifulPrint(*deploy)
-}
-
-func TestCmiiK8sOperator_ReplicaSetExists(t *testing.T) {
-
-	cmiiEnv := "uavcloud-devflight"
-	appName := "cmii-admin-data-bf8f87cb7"
-
-	exists := DefaultCmiiOperator.ReplicaSetExists(cmiiEnv, appName)
-
-	utils.BeautifulPrint(*exists)
-}
-
-func TestCmiiK8sOperator_ReplicaSetByAppName(t *testing.T) {
-
-	cmiiEnv := "uavcloud-devflight"
-	appName := "cmii-admin-data"
-
-	exists := DefaultCmiiOperator.ReplicaSetByAppName(cmiiEnv, appName)
-
-	for _, replicaSet := range exists {
-		utils.BeautifulPrint(replicaSet)
-	}
-}
-
-func TestCmiiK8sOperator_PodAll(t *testing.T) {
-	start := time.Now()
-	podList := DefaultCmiiOperator.PodAll("devflight")
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-
-	for _, pod := range podList {
-		println()
-		utils.BeautifulPrint(pod)
-		println()
-		break
-	}
-}
-
-func TestCmiiK8sOperator_PodFizz(t *testing.T) {
-	start := time.Now()
-	podList := DefaultCmiiOperator.PodFizz("devflight", "cmii-uav-data-post-process")
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-	t.Logf("pod list lenght is => %d", len(podList))
-
-	cmiiPodInterface := CmiiPodInterface{}
-	for _, pod := range podList {
-		println()
-		utils.BeautifulPrint(pod)
-		println()
-		convert := cmiiPodInterface.Convert(pod)
-		utils.BeautifulPrint(convert)
-	}
-
-}
-
-func TestCmiiK8sOperator_PodByAppName(t *testing.T) {
-	cmiiEnv := "uat"
-	appName := "cmii-admin-data"
-
-	exists := DefaultCmiiOperator.PodByNodeName(cmiiEnv, appName)
-
-	for _, podInterface := range exists {
-		utils.BeautifulPrint(podInterface)
-	}
-}
-
-func TestCmiiK8sOperator_PodFizz2(t *testing.T) {
-
-	start := time.Now()
-	podList := DefaultCmiiOperator.PodFizz("devflight", "notice")
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-	t.Logf("pod list lenght is => %d", len(podList))
-
-	podInterface := CmiiPodInterface{}
-
-	for _, pod := range podList {
-		convert := podInterface.Convert(pod)
-
-		println()
-		utils.BeautifulPrint(&convert)
-		println()
-	}
-
-}
-
-func TestCmiiK8sOperator_PodByNodeName(t *testing.T) {
-
-	cmiiEnv := devOperation
-	nodeName := "dev-master-01"
-
-	exists := DefaultCmiiOperator.PodByNodeName(cmiiEnv, nodeName)
-	exists = FilterAllCmiiPodSoft(exists)
-	for _, podInterface := range exists {
-		utils.BeautifulPrint(podInterface)
-
-		if !podInterface.PodStatus {
-			podDelete := DefaultCmiiOperator.PodDelete(podInterface.Namespace, podInterface.Name)
-			assert.Equal(t, podDelete, true, "delete pod failed !")
-		}
-	}
-}
-
-func TestCmiiK8sOperator_NodeCordon(t *testing.T) {
-	cmiiEnv := devOperation
-	nodeName := "dev-master-01"
-
-	cordon := DefaultCmiiOperator.NodeCordon(cmiiEnv, nodeName)
-	assert.Equal(t, cordon, true, "cordon node failed !")
-}
-
-func TestCmiiK8sOperator_NodeUnCordon(t *testing.T) {
-	cmiiEnv := devOperation
-	nodeName := "dev-06.ecs.io"
-
-	uncordon := DefaultCmiiOperator.NodeUnCordon(cmiiEnv, nodeName)
-	assert.Equal(t, uncordon, true, "uncordon node failed !")
-}
-
-func TestCmiiK8sOperator_PodEvictFromNode(t *testing.T) {
-	cmiiEnv := devOperation
-	nodeName := "dev-04.ecs.io"
-
-	podList := DefaultCmiiOperator.PodEvictFromNode(cmiiEnv, nodeName)
-
-	for _, podInterface := range podList {
-		utils.BeautifulPrint(podInterface)
-	}
-
-}
-
-func TestCmiiK8sOperator_PodExec(t *testing.T) {
-
-	podList := DefaultCmiiOperator.PodByAppName(devFlight, "cmii-uav-gateway")
-
-	stdout, stderr := DefaultCmiiOperator.PodExec(devFlight, podList[0], []string{
-		"env",
-	})
-
-	scanner := bufio.NewScanner(stdout)
-
-	for scanner.Scan() {
-		// Get the current line
-		line := scanner.Text()
-
-		// Check if the current line contains the search term
-		fmt.Println(line)
-	}
-	utils.SplitLinePrint()
-
-	scanner = bufio.NewScanner(stderr)
-	for scanner.Scan() {
-		// Get the current line
-		line := scanner.Text()
-
-		// Check if the current line contains the search term
-		fmt.Println(line)
-	}
-
-}
-
-func TestCmiiK8sOperator_DeploymentStatusCheck(t *testing.T) {
-
-	cmiiEnv := "devflight"
-	appName := "cmii-uav-gateway"
-
-	check := DefaultCmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
-	assert.Equal(t, check, true, "deployment run failed!")
-
-}
-
-func TestCmiiK8sOperator_NodeAll(t *testing.T) {
-	start := time.Now()
-	nodeList := DefaultCmiiOperator.NodeAll("dev")
-	elapsed := time.Since(start).Milliseconds()
-	fmt.Printf("执行耗时： %d ms\n", elapsed)
-
-	for _, node := range nodeList {
-
-		println()
-		utils.BeautifulPrint(node)
-		println()
-	}
-}
-
-func TestCmiiK8sOperator_NodeAllInterface(t *testing.T) {
-	cmiiNodeInterfaces := DefaultCmiiOperator.NodeAllInterface("uat")
-
-	for _, nodeInterface := range cmiiNodeInterfaces {
-		println()
-		utils.BeautifulPrint(nodeInterface)
-		println()
-	}
-}

agent-operator/config/CmiiEnvConfig.go

@@ -0,0 +1,12 @@
+package config
+
+const (
+	Dev          = "uavcloud-dev"
+	DevFlight    = "uavcloud-devflight"
+	DevOperation = "uavcloud-devoperation"
+	Validation   = "uavcloud-feature"
+	Integration  = "uavcloud-test"
+	Uat          = "uavcloud-uat"
+	Demo         = "uavcloud-demo"
+	Uavms        = "uavcloud-uavms"
+)

agent-operator/config/CmiiK8sInterface.go

@@ -1,12 +1,15 @@
-package main
+package config
 
 import (
 	v1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	"strings"
+	"wdd.io/agent-common/logger"
 	"wdd.io/agent-common/utils"
 )
 
+var log = logger.Log
+
 type CmiiInterfaceConvert interface {
 }
 

agent-operator/log/cmii-update-log.txt

@@ -277,3 +277,7 @@
 2024-09-03-17-23-44 uavcloud-demo  cmii-uav-platform                       5.8.0-0902                    5.8.0-090301
 2024-09-04-09-43-45 uavcloud-demo  cmii-uav-industrial-portfolio           5.7.0-31369-yunnan-090302     5.7.0-31369-yunnan-090401
 2024-09-05-13-52-57 uavcloud-demo  cmii-uav-industrial-portfolio           5.7.0-31369-yunnan-090401     5.7.0-31369-yunnan-090501
+2024-11-28-17-58-21 uavcloud-demo  cmii-uas-lifecycle                      6.1.0-20241125-112802         6.1.0-20241125-112803
+2024-11-29-11-37-17 uavcloud-demo  cmii-uas-lifecycle                      6.1.0-20241125-112803         6.1.0-20241125-112901
+2024-11-29-12-21-07 uavcloud-demo  cmii-uav-platform                       6.1.0-20241125-112801         6.1.0-20241125-112901
+2024-12-02-17-56-35 uavcloud-demo  cmii-uav-platform                       6.1.0-20241125-112901         6.1.0-20241125-120201

agent-operator/minio/MinioOperator.go

@@ -1,8 +1,9 @@
-package main
+package minio
 
 import (
 	"os"
 	"strings"
+	"wdd.io/agent-common/logger"
 
 	"github.com/minio/minio-go"
 	"wdd.io/agent-common/utils"
@@ -16,6 +17,8 @@ type CmiiMinioOperator struct {
 
 var DefaultCmiiMinioOperator = newInstance()
 
+var log = logger.Log
+
 func newInstance() *CmiiMinioOperator {
 
 	op := &CmiiMinioOperator{}

agent-operator/minio/MinioOperator_test.go

@@ -1,4 +1,4 @@
-package main
+package minio
 
 import "testing"