[ CMII ] [ Operator ] - 抽离为单独的项目

This commit is contained in:
zeaslity
2024-01-22 14:33:55 +08:00
parent f1fb7e8309
commit 9aaabc0337
21 changed files with 911 additions and 42 deletions

View File

@@ -1,10 +1,10 @@
package executor
import (
"agent-go/register"
"fmt"
"net"
"strings"
"wdd.io/agent-go/register"
)
type BaseFunc interface {

View File

@@ -1,13 +1,13 @@
package executor
import (
logger2 "agent-go/logger"
"bufio"
"bytes"
"fmt"
"os/exec"
"strconv"
"strings"
logger2 "wdd.io/agent-go/logger"
)
type ExecutionMessage struct {

View File

@@ -1,10 +1,10 @@
package executor
import (
"agent-go/status"
"encoding/json"
"strconv"
"strings"
"wdd.io/agent-go/status"
)
func BuildAgentOsOperator(agentInfo *status.AgentInfo, ossOfflinePrefix string) *AgentOsOperator {

View File

@@ -1,9 +1,9 @@
package g
import (
logger2 "agent-go/logger"
"github.com/panjf2000/ants/v2"
"github.com/spf13/viper"
logger2 "wdd.io/agent-go/logger"
)
type Global struct {

View File

@@ -1,4 +1,4 @@
module agent-go
module wdd.io/agent-go
go 1.18
@@ -16,7 +16,6 @@ require (
k8s.io/api v0.25.2
k8s.io/apimachinery v0.26.2
k8s.io/client-go v0.25.2
sigs.k8s.io/yaml v1.3.0
)
require (
@@ -49,7 +48,6 @@ require (
github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect
github.com/mailru/easyjson v0.7.7 // indirect
github.com/mitchellh/mapstructure v1.5.0 // indirect
github.com/moby/spdystream v0.2.0 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
@@ -87,4 +85,5 @@ require (
k8s.io/utils v0.0.0-20221107191617-1a15be271d1d // indirect
sigs.k8s.io/json v0.0.0-20220713155537-f223a00ba0e2 // indirect
sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect
sigs.k8s.io/yaml v1.3.0 // indirect
)

View File

@@ -40,7 +40,6 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03
github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
github.com/asaskevich/govalidator v0.0.0-20200907205600-7a23bdc65eef/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so=
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
@@ -58,7 +57,6 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153 h1:yUdfgN0XgIJw7foRItutHYUIhlcKzcSf5vDpdhQAKTc=
github.com/emicklei/go-restful/v3 v3.8.0 h1:eCZ8ulSerjdAiaNpF7GxXIE7ZCMo1moN1qX+S609eVw=
github.com/emicklei/go-restful/v3 v3.8.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=
github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
@@ -215,7 +213,6 @@ github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g=
github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
@@ -265,8 +262,6 @@ github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyua
github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
github.com/mittwald/goharbor-client/v5 v5.4.2 h1:1wH49SsBU9wc5czO5s1yEtnMODCbqJMk6ed0Byu0cpQ=
github.com/mittwald/goharbor-client/v5 v5.4.2/go.mod h1:fuOkU/lHZI441jF39mH6bqWMVlVYWJIYZAxpP5B2XzU=
github.com/moby/spdystream v0.2.0 h1:cjW1zVyyoiM0T7b6UoySUFqzXMoqRckQtXwGPiBhOM8=
github.com/moby/spdystream v0.2.0/go.mod h1:f7i0iNDQJ059oMTcWxx8MA/zKFIuD/lY+0GqbN2Wy8c=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=

View File

@@ -1,45 +0,0 @@
package k8s_exec
import (
"agent-go/utils"
"bytes"
v1 "k8s.io/api/apps/v1"
appsv1 "k8s.io/client-go/applyconfigurations/apps/v1"
"sigs.k8s.io/yaml"
"text/template"
)
type CmiiBackendDeploymentConfig struct {
Namespace string
AppName string
ImageTag string
TagVersion string
Replicas string
}
func (backend CmiiBackendDeploymentConfig) ParseToApplyConf() *appsv1.DeploymentApplyConfiguration {
// 解析模板
tmpl, err := template.New("cmiiBackendDeploymentTemplate").Parse(cmiiBackendDeploymentTemplate)
if err != nil {
panic(err)
}
// 应用数据并打印结果
var result bytes.Buffer
err = tmpl.Execute(&result, backend)
if err != nil {
panic(err)
}
// 创建Deployment对象
deployment := v1.Deployment{}
err = yaml.Unmarshal(result.Bytes(), &deployment)
if err != nil {
panic(err)
}
utils.BeautifulPrint(&deployment)
return nil
}

View File

@@ -1,120 +0,0 @@
package k8s_exec
const cmiiBackendDeploymentTemplate = `
apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ .AppName }}
namespace: {{ .Namespace }}
labels:
cmii.type: backend
cmii.app: {{ .AppName }}
octopus/control: backend-app-1.0.0
app.kubernetes.io/managed-by: octopus/control
app.kubernetes.io/app-version: {{ .TagVersion }}
spec:
replicas: {{ .Replicas }}
strategy:
rollingUpdate:
maxUnavailable: 1
selector:
matchLabels:
cmii.type: backend
cmii.app: {{ .AppName }}
template:
metadata:
labels:
cmii.type: backend
cmii.app: {{ .AppName }}
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: uavcloud.env
operator: In
values:
- demo
imagePullSecrets:
- name: harborsecret
containers:
- name: {{ .AppName }}
image: "harbor.cdcyy.com.cn/cmii/{{ .AppName }}:{{ .ImageTag }}"
imagePullPolicy: Always
env:
- name: K8S_NAMESPACE
value: "{{ .Namespace }}"
- name: APPLICATION_NAME
value: "{{ .AppName }}"
- name: CUST_JAVA_OPTS
value: "-Xms500m -Xmx1500m -Dlog4j2.formatMsgNoLookups=true"
- name: NACOS_REGISTRY
value: "helm-nacos:8848"
- name: NACOS_DISCOVERY_IP
valueFrom:
fieldRef:
fieldPath: status.podIP
- name: NACOS_DISCOVERY_PORT
value: "8080"
- name: BIZ_CONFIG_GROUP
value: {{ .TagVersion }}
- name: SYS_CONFIG_GROUP
value: {{ .TagVersion }}
- name: IMAGE_VERSION
value: {{ .TagVersion }}
- name: NACOS_USERNAME
value: "developer"
- name: NACOS_PASSWORD
value: "Deve@9128201"
ports:
- name: pod-port
containerPort: 8080
protocol: TCP
resources:
limits:
memory: 2Gi
cpu: 2
requests:
memory: 1Gi
cpu: 200m
livenessProbe:
httpGet:
path: /cmii/ping
port: pod-port
scheme: HTTP
initialDelaySeconds: 60
timeoutSeconds: 5
periodSeconds: 20
successThreshold: 1
failureThreshold: 3
readinessProbe:
httpGet:
path: /cmii/ping
port: pod-port
scheme: HTTP
initialDelaySeconds: 60
timeoutSeconds: 5
periodSeconds: 20
successThreshold: 1
failureThreshold: 3
startupProbe:
httpGet:
path: /cmii/ping
port: pod-port
scheme: HTTP
initialDelaySeconds: 60
timeoutSeconds: 3
periodSeconds: 20
successThreshold: 1
failureThreshold: 5
volumeMounts:
- name: glusterfs-backend-log-volume
mountPath: /cmii/logs
readOnly: false
subPath: {{ .Namespace }}/{{ .AppName }}
volumes:
- name: glusterfs-backend-log-volume
persistentVolumeClaim:
claimName: glusterfs-backend-log-pvc
`

View File

@@ -1,17 +0,0 @@
package k8s_exec
import "testing"
func TestCmiiBackendDeploymentConfig_ParseToApplyConf(t *testing.T) {
deploymentConfig := CmiiBackendDeploymentConfig{
Namespace: "uavcloud-dev",
AppName: "cmii-uav-gateway",
ImageTag: "5.2.0-123",
TagVersion: "5.2.0",
Replicas: "2",
}
deploymentConfig.ParseToApplyConf()
}

View File

@@ -1,193 +0,0 @@
package k8s_exec
var CmiiFrontendAppName = []string{
"cmii-uav-platform",
"cmii-uav-platform-oms",
"cmii-uav-platform-mws",
"cmii-uav-platform-cms-portal",
"cmii-uav-platform-armypeople",
"cmii-uav-platform-share",
"cmii-suav-platform-supervisionh5",
"cmii-suav-platform-supervision",
"cmii-uav-platform-ai-brain",
"cmii-uav-platform-base",
"cmii-uav-platform-detection",
"cmii-uav-platform-emergency-rescue",
"cmii-uav-platform-logistics",
"cmii-uav-platform-media",
"cmii-uav-platform-open",
"cmii-uav-platform-security",
"cmii-uav-platform-securityh5",
"cmii-uav-platform-seniclive",
"cmii-uav-platform-threedsimulation",
"cmii-uav-platform-visualization",
}
var CmiiBackendAppMap = map[string]string{
"cmii-admin-data": "5.2.0",
"cmii-admin-gateway": "5.2.0",
"cmii-admin-user": "5.2.0",
"cmii-app-release": "4.2.0-validation",
"cmii-open-gateway": "5.2.0",
"cmii-suav-supervision": "5.2.0",
"cmii-uav-airspace": "5.2.0",
"cmii-uav-alarm": "5.2.0",
"cmii-uav-autowaypoint": "4.1.6-cm-0828",
"cmii-uav-brain": "5.2.0",
"cmii-uav-cloud-live": "5.2.0",
"cmii-uav-clusters": "5.2.0",
"cmii-uav-cms": "5.2.0",
"cmii-uav-data-post-process": "5.2.0",
"cmii-uav-depotautoreturn": "4.2.0",
"cmii-uav-developer": "5.2.0-25858",
"cmii-uav-device": "5.2.0",
"cmii-uav-emergency": "5.2.0",
"cmii-uav-gateway": "5.2.0",
"cmii-uav-gis-server": "5.2.0",
"cmii-uav-grid-datasource": "5.2.0-24810",
"cmii-uav-grid-engine": "5.1.0",
"cmii-uav-grid-manage": "5.1.0",
"cmii-uav-industrial-portfolio": "5.2.0-25268-10",
"cmii-uav-integration": "5.2.0-25447",
"cmii-uav-kpi-monitor": "5.2.0",
"cmii-uav-logger": "5.2.0",
"cmii-uav-material-warehouse": "5.2.0",
"cmii-uav-mission": "5.2.0-25840",
"cmii-uav-mqtthandler": "5.2.0-25340",
"cmii-uav-notice": "5.2.0",
"cmii-uav-oauth": "5.2.0",
"cmii-uav-process": "5.2.0",
"cmii-uav-surveillance": "5.2.0-25854",
"cmii-uav-threedsimulation": "5.2.0",
"cmii-uav-tower": "5.2.0",
"cmii-uav-user": "5.2.0",
"cmii-uav-waypoint": "5.2.0",
}
var CmiiFrontendAppMap = map[string]string{
"cmii-suav-platform-supervision": "5.2.0",
"cmii-suav-platform-supervisionh5": "5.2.0",
"cmii-uav-platform": "5.2.0-011004",
"cmii-uav-platform-ai-brain": "5.2.0",
"cmii-uav-platform-armypeople": "5.2.0-24538",
"cmii-uav-platform-base": "5.2.0",
"cmii-uav-platform-cms-portal": "5.2.0",
"cmii-uav-platform-detection": "5.2.0",
"cmii-uav-platform-emergency-rescue": "5.2.0",
"cmii-uav-platform-hljtt": "5.2.0",
"cmii-uav-platform-jiangsuwenlv": "4.1.3-jiangsu-0427",
"cmii-uav-platform-logistics": "5.2.0",
"cmii-uav-platform-media": "5.2.0",
"cmii-uav-platform-multiterminal": "5.2.0",
"cmii-uav-platform-mws": "5.2.0",
"cmii-uav-platform-oms": "5.2.0",
"cmii-uav-platform-open": "5.2.0",
"cmii-uav-platform-qingdao": "4.1.6-24238-qingdao",
"cmii-uav-platform-qinghaitourism": "4.1.0-21377-0508",
"cmii-uav-platform-security": "4.1.6",
"cmii-uav-platform-securityh5": "5.2.0",
"cmii-uav-platform-seniclive": "5.2.0",
"cmii-uav-platform-share": "5.2.0",
"cmii-uav-platform-splice": "5.2.0",
"cmii-uav-platform-threedsimulation": "5.2.0-21392",
"cmii-uav-platform-visualization": "5.2.0",
}
var CmiiMiddlewareNameMap = map[string]string{
"helm-nacos": "single",
"helm-emqxs": "single",
"helm-mysql": "single",
"helm-redis": "replication",
"helm-rabbitmq": "single",
}
var CmiiBackendAppName = []string{
"cmii-uav-gateway",
"cmii-uav-oauth",
"cmii-uav-user",
"cmii-uav-material-warehouse",
"cmii-uav-device",
"cmii-uav-mission",
"cmii-uav-mqtthandler",
"cmii-uav-surveillance",
"cmii-uav-waypoint",
"cmii-uav-airspace",
"cmii-uav-industrial-portfolio",
"cmii-uav-integration",
"cmii-admin-data",
"cmii-admin-gateway",
"cmii-admin-user",
"cmii-uav-cloud-live",
"cmii-uav-emergency",
"cmii-uav-cms",
"cmii-open-gateway",
"cmii-uav-cloud-live",
"cmii-uav-alarm",
"cmii-uav-brain",
"cmii-app-release",
"cmii-uav-notice",
"cmii-suav-supervision",
"cmii-uav-autowaypoint",
"cmii-uav-data-post-process",
"cmii-uav-depotautoreturn",
"cmii-uav-developer",
"cmii-uav-kpi-monitor",
"cmii-uav-logger",
"cmii-uav-process",
"cmii-uav-threedsimulation",
"cmii-uav-tower",
}
var CmiiStreamAppName = []string{
"cmii-uav-cloud-live",
"helm-live-op-v2",
"helm-live-rtsp-op",
"helm-live-rtsp-zlm",
"helm-vms-deploy",
}
var CmiiGISAppName = []string{
"cmii-uav-gis-server",
"cmii-uav-grid-datasource",
"cmii-uav-grid-engine",
"cmii-uav-grid-manage",
}
var CmiiDevK8sConfig = `apiVersion: v1
clusters:
- cluster:
certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUN5RENDQWJDZ0F3SUJBZ0lCQURBTkJna3Foa2lHOXcwQkFRc0ZBREFWTVJNd0VRWURWUVFERXdwcmRXSmwKY201bGRHVnpNQjRYRFRJeE1ERXhPREEyTURZeU5Gb1hEVE14TURFeE5qQTJNRFl5TkZvd0ZURVRNQkVHQTFVRQpBeE1LYTNWaVpYSnVaWFJsY3pDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFBRGdnRVBBRENDQVFvQ2dnRUJBS2ZNCjFjTjBNUnhUTkRGdEZxcnRIZ0RPM29SV0dicmVob3VFcDJ3VUVRbU8yRUFyZDdkMUFReTJsSm9WM0RUVmhXbUwKcUFUOFcxaWRaS0x0Wm5mNjEva3JPeDd0U2lJeU4xa1ErN3NYRUhnTjVMc01EOVlKcndpUFdFY2FXdU9HVmI1aApMWDZWOTRjN0U5UlFDOENtd09iSkRCNG45ZE8zcDVlTDJHaFRpMkNrRWt3ZkRPR0tEL1IxeUNaK0tFcDRWWlplCnpwcnUzRG5zOUNqZHVOT1VBWTZzUGxjazNvdEdIVnhnRC9IRlRjUEhNbGhvUVQ4dmNDOTZwc0FtYXZPR1BZQ0YKa3RtN0VWYkZDOHN5Q1BMT3AwWWhTWHRkbGtKaC9UWHBaM0hSUWJxSzVPNXR4K1dGL05qMGJVc202ZldSMzZWQgpKQVVscUJIeFhSTzhGTFNrVHkwQ0F3RUFBYU1qTUNFd0RnWURWUjBQQVFIL0JBUURBZ0trTUE4R0ExVWRFd0VCCi93UUZNQU1CQWY4d0RRWUpLb1pJaHZjTkFRRUxCUUFEZ2dFQkFKeWZ2T3hHVVYvT2wybGRQNnYxeWFSTkd5RVkKWkVxTmM2Y29LSklsd0VQNUxNYzdZNGFReWorZCtVTE4zYmIrOXZsZXdHamluTHRrUW5HZ1R3Q3pKTU5ZNlNJNQo2NzJGZEtQTE85Szdpalhway9qRE9FVHJWS25aMXJBTytOUVBmSVhpcXQ3Y1RyVHlaVzdKTVl3emZNa2VlTGErCnREdmY1Rm5vQTBLN2U3a0ZXNTBpN2pXcGh4RXRMNEJpNzAwNnU4NEpqTU5weVp1MzhKMjFXZkR1RjBoU0NQREgKS0x4cnZIZ0FOYzJWU1c2L3JPaVVCQjdiV0JkcWcyQUNVRWZwN0V3UGs2S1BsdGNiNTJtdFhCU2xiQ3pRWWw4UQpmNmVGRFIrbnRjeXNGbU1FMFI3M1lNSHJwR0dGdlduSDVaTmEyVEJYdHpwN2tNNkVPREE5a2R4WkI1dz0KLS0tLS1FTkQgQ0VSVElGSUNBVEUtLS0tLQo=
server: https://192.168.11.170:16443
name: kubernetes
contexts:
- context:
cluster: kubernetes
user: kubernetes-admin
name: kubernetes-admin@kubernetes
current-context: kubernetes-admin@kubernetes
kind: Config
preferences: {}
users:
- name: kubernetes-admin
user:
client-certificate-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUM4ekNDQWR1Z0F3SUJBZ0lKQU9SWThQZlhadWQyTUEwR0NTcUdTSWIzRFFFQkN3VUFNQlV4RXpBUkJnTlYKQkFNVENtdDFZbVZ5Ym1WMFpYTXdIaGNOTWpJd01URTRNRFl6TmpRMFdoY05Nekl3TVRFMk1EWXpOalEwV2pBMApNUmN3RlFZRFZRUUtEQTV6ZVhOMFpXMDZiV0Z6ZEdWeWN6RVpNQmNHQTFVRUF3d1FhM1ZpWlhKdVpYUmxjeTFoClpHMXBiakNDQVNJd0RRWUpLb1pJaHZjTkFRRUJCUUFEZ2dFUEFEQ0NBUW9DZ2dFQkFPNTZ0ZG51M24rWUsxM3oKZmNlTzNiSmhBL2J0SGpoQXpvRnNObmZjeEY3dlRTZGczSUxySmVNVkFGbG50MHpUL2xacFBlU0ZUN25iL1g1Ygo4RjErSHA2dVR0b0hRVGJHR2VzbEprdkpFMjB3OGJ0Z3VrdlNmTnROOS9NNlFTWWkvTGlHeTZpd2kveGdBVUtKClFtVW1vZmhZSHNKMllFbXJCcExOVFhtenl2a2lUTlJZVC9iNlJJRzNiT3lIVm1Lc1cwQkNQNVZTTFJsLzErZlMKM0dCUUZ2UTNXdTdmVWlzMW9DSXhsc1k5V2VJUmpGOWJDbWtKNnZsT3BWbGlsTlA0cEtSSnl4aXNBNzExNENNWAprRGJvRFBXb2lxMktubzYveXI2L0xwMktsVVVSa1JhQklodEl5eXV2TldPbjhiTW90SUpCNWNOems4UkxYTm5TCklPZEtMVDhDQXdFQUFhTW5NQ1V3RGdZRFZSMFBBUUgvQkFRREFnV2dNQk1HQTFVZEpRUU1NQW9HQ0NzR0FRVUYKQndNQ01BMEdDU3FHU0liM0RRRUJDd1VBQTRJQkFRQ1lwVk9NemlGRUFta1A4S3B2ZWttR3laVGV3dzQreVhyUwo3TEpoWTdTR2pGY210ZldMSW9PWEhmWmZlZWNsN3M5Snh1SytPZlhqU0d0UU9jWXk0WHo5OVFWY2FRandJMEg5Cnc3aWJiYUw3M093RGZrRDMrdlNhME9ZRWZKSFlsNXErQXBnQVpLVWRWazMvZHpJSmhRR0V6L0UxcjdYTlNabDUKL1hOT3pwbzl0VHV2dDAxRlllV0RMN01DeWZGRHFTelpQdnNyWW81bDFiTE5yeEZHb1dvSTdUMlJzR205VXJyYwoyTy84R2hMYTkwZ2tLeE9JTEpYdlJCY2RrOUN4N01ROGFGVHBuSmtPMXJzVzUxMTFoTG5hNm9WRHhISlVrbjRkCmNhODFDV3R1Yk44dkpSYlFwVmkySTJ5K3ljZ3lrNTMzR21GQXNVS3dkdm5rVjNqTVJVbFYKLS0tLS1FTkQgQ0VSVElGSUNBVEUtLS0tLQo=
client-key-data: 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`
var CmiiCoreK8sConfig = `apiVersion: v1
clusters:
- cluster:
certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUN5RENDQWJDZ0F3SUJBZ0lCQURBTkJna3Foa2lHOXcwQkFRc0ZBREFWTVJNd0VRWURWUVFERXdwcmRXSmwKY201bGRHVnpNQjRYRFRJd01URXhOakUwTURJd09Wb1hEVE13TVRFeE5ERTBNREl3T1Zvd0ZURVRNQkVHQTFVRQpBeE1LYTNWaVpYSnVaWFJsY3pDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFBRGdnRVBBRENDQVFvQ2dnRUJBTEZhCjV4N0M2MisrZjA5UXUzVWR6UUFXRDN4NDRkTVV6bkxvTjc5Y0RTbzduYjhTd0JmMzk2aFEwaEdiT2lDUXhLc1IKczJhcXl2N0dLUXAvdTVNbUU0bXF1YWEybE1yUkc1UWFJOWhHNlp5SDdxYkFlU0dZSVplZGVoMWF6bzVnblBWRwoyck5aVWR3WU5tUXYvemF6V3dSbi9QQUNuNEt4MkxjYVVJUm16YkZHRnJ2VXl3UDl4UTc2MlNvRWZoMENycEpvCmltTHR3ZGFOU3dweGRCTFpkcXlRY05xRVV0dUI2VXVVM0Z3Y2FBckJpNTZ1OTFJbHVEWS9Dd1UyeDJCSHR1WkwKR2RuQUM0c1VhWm9oZzRFZ0U3UEp6RnFXTUtyaGRmekRzc05EK1VhV2sxRmhvRzViVWZiQ051Zy9KUnNlRzJBZQpodjAvU1ZNcSs5WWYyR0dheC9NQ0F3RUFBYU1qTUNFd0RnWURWUjBQQVFIL0JBUURBZ0trTUE4R0ExVWRFd0VCCi93UUZNQU1CQWY4d0RRWUpLb1pJaHZjTkFRRUxCUUFEZ2dFQkFGdVYxK3Z4UGVrUm82T2U2YTI4NmFHQjduWG0KMUlGVllwSWUxeTVoZy9aTlhKN1RndXFPb2Zjc3JnZ1h2MmdaQkdFN0pheTM0SkhuRFB3Y3ZCMzhHQUxtZmZWeAo2THJVN2ZtSWlpajRIc1NyaHRrMWQzcmhjdFkwMEw2dGJMMzVvTWJnUGwzSERUbGh0M0wxM0gvUVFScXR3TXFOCnBHeWk3VWprbFNpNWVsRWJrbnlUUy9OWTA1Y1JyMTU2N0p4N3F3QlpmUlZaZURUOHdidHpMZ05UWlFZRzVoM2EKQmp6dnlINFoyR2YrNnM4aXZlbGFUMjdPbGpOUTJvUUdyenhHV0ErZGJKSzNIdDVRRkVCeDdVaEsrNWtwYXViNwpWZTB1ekdGK1ZDb2ZFV2FtNk9CUFAycE51SW85d0Jsa24vbU9FUW5SU1FNMW15dmlIWHBaMnVKd1ozbz0KLS0tLS1FTkQgQ0VSVElGSUNBVEUtLS0tLQo=
server: https://vip.ecs.io:6444
name: kubernetes
contexts:
- context:
cluster: kubernetes
user: kubernetes-admin
name: kubernetes-admin@kubernetes
current-context: kubernetes-admin@kubernetes
kind: Config
preferences: {}
users:
- name: kubernetes-admin
user:
client-certificate-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUM4ekNDQWR1Z0F3SUJBZ0lKQU5ZM0hyTXZseUZjTUEwR0NTcUdTSWIzRFFFQkN3VUFNQlV4RXpBUkJnTlYKQkFNVENtdDFZbVZ5Ym1WMFpYTXdIaGNOTWpFd01URTFNRGd6T0RNNFdoY05NekV3TVRFek1EZ3pPRE00V2pBMApNUmN3RlFZRFZRUUtEQTV6ZVhOMFpXMDZiV0Z6ZEdWeWN6RVpNQmNHQTFVRUF3d1FhM1ZpWlhKdVpYUmxjeTFoClpHMXBiakNDQVNJd0RRWUpLb1pJaHZjTkFRRUJCUUFEZ2dFUEFEQ0NBUW9DZ2dFQkFMS21TZDJIeVdYN2VTdnYKdS8yRnBZQWM5SWRBcFlQbmtESk5wR0Z1SEVlOUJWVXMyL1o3L3BQWGY3NTljVFdZUkV2V0dybDBNS1dTajhycAowQ2JTN3dvdkg2NnpTcWNKRDUzMW11OTgvaE0zenZzaTVqalIxOU5yTEFIL0QzbEZ6d2VnVHpNUWFvenNPc2VOCm0vNmI5cGRLNUcwYkNPRkJlZTRzeW1VdnVjT1NKblg5YkpZUnhNbVI5WHl3REowcnpTSHJrVE9ocVErUXYzdTAKMGZvVk9NSm9BdWkvR2JEV3ZpTEQrRmlDMnFJY0FYRGhNaGd2eVJwTFBPNFlZc0tCc2xjUVJwbkpjei9heFRBUQovM0c3T1pYWjJkNWVDQmRDY0pqL2orNlkyNVJsVXNDNDZzZWR1cTR0SGMrbEJ3UG5FSDYvTG53SUE0VHVaRXBpCkI3Q3RyU0VDQXdFQUFhTW5NQ1V3RGdZRFZSMFBBUUgvQkFRREFnV2dNQk1HQTFVZEpRUU1NQW9HQ0NzR0FRVUYKQndNQ01BMEdDU3FHU0liM0RRRUJDd1VBQTRJQkFRQ0llSU0wSllLVjNiNUhISEdzMmV0eEt0VnQwaGNBTzNmcgpCcU5Ba3lPNkpvWkU2dnh3Nm5lQXNhc3V5RXh1NDFiMmlwYTJFdFlsTUNWbHE0anhjQWptMnU4b0xWb3NoWWIxClU4MkRqMkJuV2Z6TnhKV3dqSnQ5UzFhUXZmOXFxaDhueGJTeUVhNmxMZmEvTEpFQURzMDZNR05tQUJxbk5ZUVEKcEh1UnNXQlhwT3lSaWhtMHdlK21UNGwxYklMZ0Zpa2ZSaUw1WkRnWVlTNG9BRVpGY1NBbldKRFhSVTI0S0JIRQppYXk4SlNIcks1Ym12TWVpR1ZkL054WlhmSFdCcUcvZUI1SDRuaFhtVzhWbEdjQnhvdDBvckVta2FsblFpYnEwCnBWNUlwcXFBU3JjcjZnVUxrRmtvdWo1aG9rNWdIdWpqakFkenVSa3hyYTJiNERFa05jTTQKLS0tLS1FTkQgQ0VSVElGSUNBVEUtLS0tLQo=
client-key-data: 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`

View File

@@ -1,570 +0,0 @@
package k8s_exec
import (
"agent-go/executor"
"agent-go/utils"
"bufio"
"strings"
"time"
)
var CmiiOperator = CmiiK8sOperator{}
var updateLogPath = "C:\\Users\\wddsh\\Documents\\IdeaProjects\\ProjectOctopus\\agent-go\\k8s_exec\\log\\cmii-update-log.txt"
// FindAppNotHealthyOrRestartCountGreaterThanN 重启次数大于N的所有Deployment
func FindAppNotHealthyOrRestartCountGreaterThanN(cmiiEnv string, restartCount int32) []CmiiDeploymentInterface {
//podInterface := CmiiPodInterface{}
// get all pods
podAll := CmiiOperator.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([]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 := CmiiOperator.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 []CmiiDeploymentInterface) {
// get all deployments
cmiiDeploymentInterfaces := CmiiOperator.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 []CmiiDeploymentInterface) {
// all unhealthy pods
allInterface := CmiiOperator.PodAllInterface(cmiiEnv)
// find the deployments
for _, podInterface := range allInterface {
if !podInterface.PodStatus {
// unhealthy pod
deploymentInterface := CmiiOperator.DeploymentOneInterface(cmiiEnv, podInterface.ContainerName)
if deploymentInterface != nil {
deploymentList = append(deploymentList, *deploymentInterface)
}
}
}
return deploymentList
}
func FindAllNodeNotHealthy() (nodeList []CmiiNodeInterface) {
// dev-cluster
devNodeList := CmiiOperator.NodeAllInterface("dev")
// core-cluster
coreNodeList := CmiiOperator.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 []CmiiPodInterface) {
// all unhealthy pods
allInterface := CmiiOperator.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 := CmiiOperator.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 := CmiiOperator.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 []CmiiPodInterface) {
cmiiPodInterfaces := CmiiOperator.PodAllInterface(cmiiEnv)
for _, podInterface := range cmiiPodInterfaces {
for key, _ := range CmiiMiddlewareNameMap {
if strings.Contains(podInterface.Name, key) {
podList = append(podList, podInterface)
}
}
}
return podList
}
func RestartDeploymentFromList(deploymentList []CmiiDeploymentInterface) bool {
result := true
for _, deployment := range deploymentList {
result = CmiiOperator.DeploymentScale(deployment.Namespace, deployment.Name, 0)
if !result {
return result
}
time.Sleep(time.Second)
result = CmiiOperator.DeploymentScale(deployment.Namespace, deployment.Name, deployment.Replicas)
if !result {
return result
}
}
return result
}
func RestartCmiiBackendDeployment(cmiiEnv string) {
cmiiDeploymentInterfaces := CmiiOperator.DeploymentAllInterface(cmiiEnv)
for _, deploymentInterface := range cmiiDeploymentInterfaces {
_, ok := CmiiBackendAppMap[deploymentInterface.Name]
if ok {
if !CmiiOperator.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 !", CmiiOperator.CurrentNamespace)
}
func RestartCmiiFrontendDeployment(cmiiEnv string) {
cmiiDeploymentInterfaces := CmiiOperator.DeploymentAllInterface(cmiiEnv)
for _, deploymentInterface := range cmiiDeploymentInterfaces {
_, ok := CmiiFrontendAppMap[deploymentInterface.Name]
if ok {
if !CmiiOperator.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 !", CmiiOperator.CurrentNamespace)
}
func UpdateCmiiDeploymentImageTag(cmiiEnv, appName, newTag string) bool {
deployment := CmiiOperator.DeploymentExist(cmiiEnv, appName)
if deployment == nil {
log.ErrorF("[UpdateCmiiDeploymentImageTag] - [%s] [%s] not exists !", cmiiEnv, appName)
return false
}
deploymentInterface := CmiiDeploymentInterface{}
cmiiDeploymentInterface := deploymentInterface.Convert(*deployment)
// check if need to update
if cmiiDeploymentInterface.ImageTag == newTag {
log.DebugF("[UpdateCmiiDeploymentImageTag] - [%s] [%s] image tag are the same ! no need to update !", cmiiEnv, appName)
// restart
if CmiiOperator.DeploymentRestart(cmiiEnv, appName) {
return true
} else {
return false
}
}
content := executor.BasicWordSpaceCompletion(utils.TimeSplitFormatString()+" "+cmiiDeploymentInterface.Namespace, 45)
content = executor.BasicWordSpaceCompletion(content+cmiiDeploymentInterface.Name, 85)
content = executor.BasicWordSpaceCompletion(content+cmiiDeploymentInterface.ImageTag, 105)
content = content + newTag + "\n"
log.DebugF("[UpdateCmiiDeploymentImageTag] - prepare to update [%s]!", content)
// update
tag := CmiiOperator.DeploymentUpdateTag(cmiiDeploymentInterface.Namespace, cmiiDeploymentInterface.Name, newTag)
if !tag {
log.ErrorF("[UpdateCmiiDeploymentImageTag] - [%s] update failed !", content)
return false
}
// append log
executor.BasicAppendContentToFile(content, updateLogPath)
// re-get from env
time.Sleep(time.Second)
deploy := CmiiOperator.DeploymentOneInterface(cmiiEnv, appName)
if deploy == nil {
log.ErrorF("[UpdateCmiiDeploymentImageTag] - unknown error happened ! [%s] [%s] not exists !", cmiiEnv, appName)
return false
}
// log
log.InfoF("[UpdateCmiiDeploymentImageTag] - real image tag are [%s] \n update tag [%s] success ! ", deploy.Image, content)
return true
}
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) {
if UpdateCmiiDeploymentImageTag(cmiiEnv, appName, newTag) {
result[appName] = newTag
} else {
result[appName] = "false"
}
}
}
return result
}
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)
rollback := UpdateCmiiDeploymentImageTag(cmiiEnv, appName, fromTag)
return rollback
}
// BackupAllDeploymentFromEnv 从DEMO提取全部的CMII的应用
func BackupAllDeploymentFromEnv(cmiiEnv string) bool {
allInterface := CmiiOperator.DeploymentAllInterface(cmiiEnv)
// must filter
allInterface = FilterAllCmiiAppSoft(allInterface)
filePath := "C:\\Users\\wddsh\\Documents\\IdeaProjects\\ProjectOctopus\\agent-go\\k8s_exec\\log\\all-" + CmiiOperator.CurrentNamespace + "-" + utils.TimeSplitFormatString() + ".txt"
log.InfoF("[BackupAllDeploymentFromEnv] - backup all image from %s => %s", CmiiOperator.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 := executor.BasicWordSpaceCompletion(deploymentInterface.Name, firstCol)
content = executor.BasicWordSpaceCompletion(content+deploymentInterface.ImageTag, secondCol)
content = executor.BasicWordSpaceCompletion(content+deploymentInterface.GitBranch, thirdCol)
content = executor.BasicWordSpaceCompletion(content+deploymentInterface.GitCommit, fourthCol)
content += "\n"
if !executor.BasicAppendContentToFile(content, filePath) {
log.ErrorF("[BackupAllDeploymentFromEnv] - write to file %s error with contend %s", filePath, content)
return false
}
}
return true
}
func BackupAllCmiiDeploymentToMap(cmiiEnv string) (backendMap, frontendMap map[string]string) {
allInterface := CmiiOperator.DeploymentAllInterface(cmiiEnv)
allInterface = FilterAllCmiiAppSoft(allInterface)
backendMap = make(map[string]string, len(allInterface))
frontendMap = 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
}
}
return backendMap, frontendMap
}
func FilterAllCmiiAppStrict(source []CmiiDeploymentInterface) (result []CmiiDeploymentInterface) {
for _, c := range source {
_, ok := CmiiBackendAppMap[c.ContainerName]
if !ok {
_, ok = CmiiFrontendAppMap[c.ContainerName]
if !ok {
log.WarnF("[FilterAllCmiiAppStrict] - [%s] not cmii pod ", c.ContainerName)
continue
}
}
result = append(result, c)
}
return result
}
func FilterAllCmiiAppSoft(source []CmiiDeploymentInterface) (result []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 []CmiiPodInterface) (result []CmiiPodInterface) {
for _, c := range podList {
_, ok := CmiiBackendAppMap[c.ContainerName]
if !ok {
_, ok = CmiiFrontendAppMap[c.ContainerName]
if !ok {
log.WarnF("[FilterAllCmiiPodStrict] - [%s] not cmii pod ", c.ContainerName)
continue
}
}
result = append(result, c)
}
return result
}
func FilterAllCmiiPodSoft(podList []CmiiPodInterface) (result []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 []CmiiNodeInterface) (result []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
}
func AppNameBelongsToCmiiImage(appName string) bool {
_, ok := CmiiBackendAppMap[appName]
if !ok {
_, ok = CmiiFrontendAppMap[appName]
if !ok {
log.WarnF("[AppNameBelongsToCmiiImage] - [%s] not cmii app ", appName)
return false
} else {
return true
}
} else {
return true
}
}

View File

@@ -1,230 +0,0 @@
package k8s_exec
import (
"agent-go/utils"
"fmt"
"github.com/magiconair/properties/assert"
"testing"
"time"
)
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(integration)
for _, middlePod := range middlewarePodInterface {
println()
utils.BeautifulPrint(middlePod)
println()
}
}
func TestBackupAllDeploymentFromEnv(t *testing.T) {
BackupAllDeploymentFromEnv(integration)
}
func TestBackupAllCmiiDeploymentToMap(t *testing.T) {
backendMap, frontendMap := BackupAllCmiiDeploymentToMap("demo")
utils.BeautifulPrint(backendMap)
utils.BeautifulPrint(frontendMap)
}
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 := CmiiOperator.PodDelete(podInterface.Namespace, podInterface.Name)
assert.Equal(t, podDelete, true, "delete of ", podInterface.Namespace, podInterface.Name, " failed !")
}
}
func TestFilterAllCmiiAppStrict(t *testing.T) {
allInterface := CmiiOperator.DeploymentAllInterface("devflight")
FilterAllCmiiAppStrict(allInterface)
}
func TestRestartDeploymentFromList(t *testing.T) {
allInterface := CmiiOperator.DeploymentAllInterface("devflight")
allInterface = FilterAllCmiiAppSoft(allInterface)
RestartDeploymentFromList(allInterface)
}
func TestUpdateCmiiImageTagFromNameTagMap(t *testing.T) {
cmii530BackendMap := map[string]string{
"cmii-admin-data": "5.3.0",
"cmii-admin-gateway": "5.3.0",
"cmii-admin-user": "5.3.0",
"cmii-open-gateway": "5.3.0",
"cmii-suav-supervision": "5.3.0",
"cmii-uav-airspace": "5.3.0",
"cmii-uav-alarm": "5.3.0",
"cmii-uav-brain": "5.3.0",
"cmii-uav-cloud-live": "5.3.0",
"cmii-uav-cms": "5.3.0",
"cmii-uav-data-post-process": "5.3.0",
"cmii-uav-developer": "5.3.0",
"cmii-uav-device": "5.3.0",
"cmii-uav-emergency": "5.3.0",
"cmii-uav-gateway": "5.3.0",
"cmii-uav-gis-server": "5.3.0",
"cmii-uav-industrial-portfolio": "5.3.0",
"cmii-uav-integration": "5.3.0",
"cmii-uav-logger": "5.3.0",
"cmii-uav-material-warehouse": "5.3.0",
"cmii-uav-mission": "5.3.0",
"cmii-uav-mqtthandler": "5.3.0",
"cmii-uav-notice": "5.3.0",
"cmii-uav-oauth": "5.3.0",
"cmii-uav-process": "5.3.0",
"cmii-uav-surveillance": "5.3.0",
"cmii-uav-threedsimulation": "5.3.0",
"cmii-uav-tower": "5.3.0",
"cmii-uav-user": "5.3.0",
"cmii-uav-waypoint": "5.3.0",
//"cmii-uav-grid-datasource": "5.2.0-24810",
//"cmii-uav-grid-engine": "5.1.0",
//"cmii-uav-grid-manage": "5.1.0",
}
cmii530FrontendMap := map[string]string{
"cmii-suav-platform-supervision": "5.3.0",
"cmii-suav-platform-supervisionh5": "5.3.0",
"cmii-uav-platform": "5.3.0",
"cmii-uav-platform-ai-brain": "5.3.0",
"cmii-uav-platform-armypeople": "5.3.0",
"cmii-uav-platform-base": "5.3.0",
"cmii-uav-platform-cms-portal": "5.3.0",
"cmii-uav-platform-detection": "5.3.0",
"cmii-uav-platform-emergency-rescue": "5.3.0",
"cmii-uav-platform-logistics": "5.3.0",
"cmii-uav-platform-media": "5.3.0",
"cmii-uav-platform-multiterminal": "5.3.0",
"cmii-uav-platform-mws": "5.3.0",
"cmii-uav-platform-oms": "5.3.0",
"cmii-uav-platform-open": "5.3.0",
"cmii-uav-platform-securityh5": "5.3.0",
"cmii-uav-platform-seniclive": "5.3.0",
"cmii-uav-platform-share": "5.3.0",
"cmii-uav-platform-splice": "5.3.0",
"cmii-uav-platform-threedsimulation": "5.3.0",
"cmii-uav-platform-visualization": "5.3.0",
//"cmii-uav-platform-security": "4.1.6",
}
result := UpdateCmiiImageTagFromNameTagMap("demo", cmii530BackendMap)
utils.BeautifulPrint(result)
result = UpdateCmiiImageTagFromNameTagMap("demo", cmii530FrontendMap)
utils.BeautifulPrint(result)
}
func TestUpdateCmiiDeploymentImageTag(t *testing.T) {
cmiiEnv := "test"
appName := "cmii-suav-supervision"
newTag := "5.2.0-011901"
tag := UpdateCmiiDeploymentImageTag(cmiiEnv, appName, newTag)
assert.Equal(t, tag, true, "update image tag failed !")
utils.SplitLinePrint()
check := CmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
assert.Equal(t, check, true, "deployment run failed!")
}

View File

@@ -1,219 +0,0 @@
package k8s_exec
import (
"agent-go/utils"
v1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
"strings"
)
type CmiiInterfaceConvert interface {
}
type CmiiPodInterface struct {
Name string
Namespace string
//ReplicaSetName string
ContainerImageMap map[string]string
PodIP string
HostIP string
NodeName string
RestartCountMap map[string]int32
RestartCount int32
ContainerName string
Image string
ImageTag string
GitBranch string
GitCommit string
PodStatus bool
PodPhase corev1.PodPhase
}
type CmiiDeploymentInterface struct {
Name string
Namespace string
AvailableReplicas int32
Replicas int32
ContainerImageMap map[string]string
ContainerName string
Image string
ImageTag string
GitBranch string
GitCommit string
StatusOk bool
}
type CmiiNodeInterface struct {
Name string
Hostname string
InternalIP string
KernelVersion string
OsImage string
Architecture string
KubeletVersion string
CpuCapacity string
MemoryCapacity string
PodCapacity string
StorageCapacity string
Labels map[string]string
Unschedulable bool
NodeStatus bool
MemoryPressure bool
DiskPressure bool
PIDPressure bool
NetworkUnavailable bool
}
func (deploy CmiiDeploymentInterface) Convert(deployment v1.Deployment) CmiiDeploymentInterface {
containers := deployment.Spec.Template.Spec.Containers
containerImageMap := make(map[string]string, len(containers))
if len(containers) > 1 {
log.WarnF("[CmiiDeploymentInterface Convert] - deployment [%s] [%s] container greater than one !", deployment.Namespace, deployment.Name)
}
for _, container := range containers {
containerImageMap[container.Name] = container.Image
deploy.Image = container.Image
deploy.ContainerName = container.Name
deploy.ImageTag = strings.Split(container.Image, ":")[1]
for _, envVar := range container.Env {
if strings.HasPrefix(envVar.Name, "GIT_BRANCH") {
deploy.GitBranch = envVar.Value
}
if strings.HasPrefix(envVar.Name, "GIT_COMMIT") {
deploy.GitCommit = envVar.Value
}
}
}
deploy.Name = deployment.Name
deploy.Namespace = deployment.Namespace
deploy.AvailableReplicas = deployment.Status.AvailableReplicas
deploy.Replicas = *deployment.Spec.Replicas
deploy.ContainerImageMap = containerImageMap
deploy.StatusOk = deployment.Status.AvailableReplicas == *deployment.Spec.Replicas
return deploy
}
func (pod CmiiPodInterface) Convert(podDetail corev1.Pod) CmiiPodInterface {
containers := podDetail.Spec.Containers
containerImageMap := make(map[string]string, len(containers))
if len(containers) > 1 {
log.WarnF("[CmiiDeploymentInterface Convert] - pod [%s] [%s] container greater than one !", podDetail.Namespace, podDetail.Name)
}
for _, container := range containers {
containerImageMap[container.Name] = container.Image
pod.Image = container.Image
pod.ContainerName = container.Name
if strings.Contains(container.Image, ":") {
pod.ImageTag = strings.Split(container.Image, ":")[1]
}
for _, envVar := range container.Env {
if strings.HasPrefix(envVar.Name, "GIT_BRANCH") {
pod.GitBranch = envVar.Value
}
if strings.HasPrefix(envVar.Name, "GIT_COMMIT") {
pod.GitCommit = envVar.Value
}
}
}
containerStatuses := podDetail.Status.ContainerStatuses
containerStatusMap := make(map[string]int32, len(containerStatuses))
for _, containerStatus := range containerStatuses {
containerStatusMap[containerStatus.Name] = containerStatus.RestartCount
pod.RestartCount = utils.MaxInt32(pod.RestartCount, containerStatus.RestartCount)
}
pod.Name = podDetail.Name
pod.Namespace = podDetail.Namespace
pod.ContainerImageMap = containerImageMap
pod.RestartCountMap = containerStatusMap
pod.PodIP = podDetail.Status.PodIP
pod.HostIP = podDetail.Status.HostIP
pod.NodeName = podDetail.Spec.NodeName
pod.PodPhase = podDetail.Status.Phase
switch podDetail.Status.Phase {
case corev1.PodFailed:
pod.PodStatus = false
break
case corev1.PodPending:
pod.PodStatus = false
break
case corev1.PodReasonUnschedulable:
pod.PodStatus = false
break
default:
pod.PodStatus = true
break
}
return pod
}
func (node CmiiNodeInterface) Convert(sourceNode corev1.Node) CmiiNodeInterface {
node.Name = sourceNode.Name
for _, nodeAddress := range sourceNode.Status.Addresses {
if nodeAddress.Type == corev1.NodeInternalIP {
node.InternalIP = nodeAddress.Address
}
if nodeAddress.Type == corev1.NodeHostName {
node.Hostname = nodeAddress.Address
}
}
node.KernelVersion = sourceNode.Status.NodeInfo.KernelVersion
node.OsImage = sourceNode.Status.NodeInfo.OSImage
node.KubeletVersion = sourceNode.Status.NodeInfo.KubeletVersion
node.Architecture = sourceNode.Status.NodeInfo.Architecture
node.CpuCapacity = sourceNode.Status.Capacity.Cpu().String()
node.MemoryCapacity = sourceNode.Status.Capacity.Memory().String()
node.PodCapacity = sourceNode.Status.Capacity.Pods().String()
node.StorageCapacity = sourceNode.Status.Capacity.Storage().String()
node.Labels = sourceNode.Labels
for _, nodeCondition := range sourceNode.Status.Conditions {
switch nodeCondition.Type {
case corev1.NodeReady:
node.NodeStatus = uniformNodeConditionStatus(nodeCondition.Status)
break
case corev1.NodeMemoryPressure:
node.MemoryPressure = uniformNodeConditionStatus(nodeCondition.Status)
break
case corev1.NodeDiskPressure:
node.DiskPressure = uniformNodeConditionStatus(nodeCondition.Status)
break
case corev1.NodePIDPressure:
node.PIDPressure = uniformNodeConditionStatus(nodeCondition.Status)
break
case corev1.NodeNetworkUnavailable:
node.NetworkUnavailable = uniformNodeConditionStatus(nodeCondition.Status)
break
}
}
node.Unschedulable = sourceNode.Spec.Unschedulable
return node
}
func uniformNodeConditionStatus(conditionType corev1.ConditionStatus) bool {
if conditionType == corev1.ConditionTrue {
return true
} else {
return false
}
}

View File

@@ -1,820 +0,0 @@
package k8s_exec
import (
"agent-go/g"
"agent-go/logger"
"agent-go/utils"
"bytes"
"context"
v1 "k8s.io/api/apps/v1"
autoscalingv1 "k8s.io/api/autoscaling/v1"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/kubernetes/scheme"
restclient "k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
"k8s.io/client-go/tools/remotecommand"
"os"
"strings"
"sync"
"time"
)
var log = logger.Log
var pool = g.G.P
type CmiiK8sOperator struct {
DevClient *kubernetes.Clientset
CoreClient *kubernetes.Clientset
CurrentNamespace string
CurrentClient *kubernetes.Clientset
DevConfig *restclient.Config
CoreConfig *restclient.Config
CurrentConfig *restclient.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"
workerThread = 4
)
func (op *CmiiK8sOperator) checkAndBuildCmiiK8sOperator() {
if op.DevClient == nil {
log.InfoF("[client] - build devFlight k8s operator client !")
devConfig, err := clientcmd.RESTConfigFromKubeConfig([]byte(CmiiDevK8sConfig))
if err != nil {
msg := "[client] - build devFlight k8s operator error !"
log.Error(msg)
panic(msg)
}
op.DevConfig = devConfig
op.DevClient, err = kubernetes.NewForConfig(devConfig)
if err != nil {
panic(err.Error())
}
}
if op.CoreClient == nil {
log.InfoF("[client] - build core k8s operator client !")
coreConfig, err := clientcmd.RESTConfigFromKubeConfig([]byte(CmiiCoreK8sConfig))
if err != nil {
msg := "[client] - build devFlight k8s operator error !"
log.Error(msg)
panic(msg)
}
op.CoreConfig = coreConfig
op.CoreClient, err = kubernetes.NewForConfig(coreConfig)
if err != nil {
panic(err.Error())
}
}
}
func (op *CmiiK8sOperator) changeOperatorEnv(cmiiEnv string) {
// ok
op.checkAndBuildCmiiK8sOperator()
if strings.Contains(cmiiEnv, "dev") {
op.CurrentClient = op.DevClient
op.CurrentConfig = op.DevConfig
} else {
op.CurrentClient = op.CoreClient
op.CurrentConfig = op.CoreConfig
}
if strings.Contains(cmiiEnv, "dev") {
if strings.Contains(cmiiEnv, "devf") {
op.CurrentNamespace = devFlight
} else if strings.Contains(cmiiEnv, "devo") {
op.CurrentNamespace = devOperation
} else {
op.CurrentNamespace = dev
}
}
if strings.Contains(cmiiEnv, "int") || strings.Contains(cmiiEnv, "test") {
op.CurrentNamespace = integration
}
if strings.Contains(cmiiEnv, "fe") || strings.Contains(cmiiEnv, "val") {
op.CurrentNamespace = validation
}
if strings.Contains(cmiiEnv, "uat") {
op.CurrentNamespace = uat
}
if strings.Contains(cmiiEnv, "demo") {
op.CurrentNamespace = demo
}
if strings.Contains(cmiiEnv, "uavms") {
op.CurrentNamespace = uavms
}
if op.CurrentNamespace == "" {
op.CurrentNamespace = dev
}
log.InfoF("[k8s env] - current env is => %s", op.CurrentNamespace)
}
func (op *CmiiK8sOperator) DeploymentAll(cmiiEnv string) []v1.Deployment {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
deploymentList, err := client.AppsV1().Deployments(op.CurrentNamespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
log.ErrorF("[DeploymentAll] - list deployment in [%s] [%s] error => %s", cmiiEnv, op.CurrentNamespace, err.Error())
}
deployments := deploymentList.Items
length := len(deployments)
log.InfoF("[DeploymentAll] - deployment in [%s] count is => %d", op.CurrentNamespace, length)
results := make([]v1.Deployment, length)
//var results []v1.Deployment
//ccc := make(chan v1.Deployment, length)
var wg sync.WaitGroup
//var mutex sync.Mutex
worker := workerThread
if length <= worker {
for i, deployment := range deployments {
objectMeta := deployment.ObjectMeta
objectMeta.SetAnnotations(nil)
objectMeta.SetManagedFields(nil)
deployment.ObjectMeta = objectMeta
results[i] = deployment
}
return results
}
pinch := (length + worker - 1) / worker
wg.Add(worker)
for splice := 0; splice < worker; splice++ {
// 计算每个goroutine处理的切片段
start := splice * pinch
end := start + pinch
if end > length {
end = length
}
//log.DebugF("[DeploymentAll] - deployment pinch from [%d - %d]", start, end)
go func(deploymentList []v1.Deployment, start int, results *[]v1.Deployment) {
for index, deployment := range deploymentList {
objectMeta := deployment.ObjectMeta
objectMeta.SetAnnotations(nil)
objectMeta.SetManagedFields(nil)
deployment.ObjectMeta = objectMeta
//ccc <- deployment
i := *results
i[index+start] = deployment
}
wg.Done()
}(deployments[start:end], start, &results)
}
//go func() {
// wg.Wait()
// close(ccc)
//}()
wg.Wait()
//for deployment := range ccc {
// results = append(results, deployment)
//}
return results
}
func (op *CmiiK8sOperator) DeploymentAllInterface(cmiiEnv string) []CmiiDeploymentInterface {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
deploymentList, err := client.AppsV1().Deployments(op.CurrentNamespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
log.ErrorF("[DeploymentAllInterface] - list deployment in [%s] [%s] error => %s", cmiiEnv, op.CurrentNamespace, err.Error())
}
deployments := deploymentList.Items
length := len(deployments)
results := make([]CmiiDeploymentInterface, length)
ccc := make(chan CmiiDeploymentInterface, length)
var wg sync.WaitGroup
worker := workerThread
if length <= worker {
for i, deployment := range deployments {
objectMeta := deployment.ObjectMeta
objectMeta.SetAnnotations(nil)
objectMeta.SetManagedFields(nil)
deployment.ObjectMeta = objectMeta
results[i] = CmiiDeploymentInterface{}.Convert(deployment)
}
return results
}
pinch := length / worker
wg.Add(worker)
for splice := 0; splice < worker; splice++ {
go func(deploymentList []v1.Deployment) {
defer wg.Done()
for _, deployment := range deploymentList {
objectMeta := deployment.ObjectMeta
objectMeta.SetAnnotations(nil)
objectMeta.SetManagedFields(nil)
deployment.ObjectMeta = objectMeta
ccc <- CmiiDeploymentInterface{}.Convert(deployment)
}
}(deployments[splice*pinch : utils.MinInt((splice+1)*pinch, length)])
}
go func() {
wg.Wait()
close(ccc)
}()
index := 0
for deployment := range ccc {
results[index] = deployment
index++
}
return results[:index]
}
func (op *CmiiK8sOperator) DeploymentFizz(cmiiEnv, appFizz string) (fizzDeployment []v1.Deployment) {
deploymentAll := op.DeploymentAll(cmiiEnv)
if deploymentAll == nil {
log.ErrorF("[DeploymentFizz] - namespace [%s] can not get deployment [%s]", cmiiEnv, appFizz)
return nil
}
for _, deployment := range deploymentAll {
if strings.Contains(deployment.Name, appFizz) {
fizzDeployment = append(fizzDeployment, deployment)
}
}
return fizzDeployment
}
func (op *CmiiK8sOperator) DeploymentExist(cmiiEnv, appName string) (exists *v1.Deployment) {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
deployment, err := client.AppsV1().Deployments(op.CurrentNamespace).Get(context.TODO(), appName, metav1.GetOptions{})
if err != nil {
log.ErrorF("[DeploymentExist] - deployments [%s] [%s] not exists ! %s", cmiiEnv, appName, err.Error())
return nil
}
return deployment
}
func (op *CmiiK8sOperator) DeploymentOneInterface(cmiiEnv, appName string) (deploy *CmiiDeploymentInterface) {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
deploymentInterface := CmiiDeploymentInterface{}
deployment, err := client.AppsV1().Deployments(op.CurrentNamespace).Get(context.TODO(), appName, metav1.GetOptions{})
if err != nil {
log.ErrorF("[DeploymentExist] - deployments [%s] [%s] not exists ! %s", cmiiEnv, appName, err.Error())
return nil
}
convert := deploymentInterface.Convert(*deployment)
return &convert
}
func (op *CmiiK8sOperator) DeploymentScale(cmiiEnv, appName string, scaleCount int32) bool {
deployment := op.DeploymentOneInterface(cmiiEnv, appName)
client := op.CurrentClient
log.DebugF("[DeploymentScale] - start to scale [%s] [%s] to %d", deployment.Namespace, deployment.Name, scaleCount)
scale := &autoscalingv1.Scale{
ObjectMeta: metav1.ObjectMeta{
Name: deployment.Name,
Namespace: deployment.Namespace,
},
Spec: autoscalingv1.ScaleSpec{
Replicas: scaleCount,
},
}
updateScale, err := client.AppsV1().Deployments(deployment.Namespace).UpdateScale(
context.TODO(),
deployment.Name,
scale,
metav1.UpdateOptions{},
)
if err != nil {
log.ErrorF("[DeploymentScale] - scale error %s", err.Error())
return false
}
log.InfoF("[DeploymentScale] - scale of [%s] [%s] to %d success !", updateScale.Namespace, updateScale.Name, scaleCount)
return true
}
func (op *CmiiK8sOperator) DeploymentUpdateTag(cmiiEnv, appName, newTag string) bool {
if newTag == "" {
log.WarnF("[DeploymentUpdateTag] - can not update image tag to null!")
return false
}
deployment := op.DeploymentExist(cmiiEnv, appName)
if deployment == nil {
return false
}
containers := deployment.Spec.Template.Spec.Containers
if len(containers) == 1 {
// only update this kind
container := containers[0]
split := strings.Split(container.Image, ":")
container.Image = split[0] + ":" + newTag
log.InfoF("[DeploymentUpdateTag] - update [%s] [%s] from [%s] to [%s]", op.CurrentNamespace, appName, split[1], container.Image)
// re assign
deployment.Spec.Template.Spec.Containers[0] = container
// update
_, err := op.CurrentClient.AppsV1().Deployments(deployment.Namespace).Update(context.TODO(), deployment, metav1.UpdateOptions{})
if err != nil {
log.ErrorF("[DeploymentUpdateTag] - update [%s] [%s] from [%s] to [%s] error ! %s", op.CurrentNamespace, appName, split[1], container.Image, err.Error())
return false
}
}
return true
}
func (op *CmiiK8sOperator) DeploymentRestart(cmiiEnv, appName string) bool {
op.changeOperatorEnv(cmiiEnv)
result := true
deployment := op.DeploymentOneInterface(cmiiEnv, appName)
if deployment == nil {
log.ErrorF("[DeploymentRestart] - [%s] [%s] not exists !", cmiiEnv, appName)
return false
}
result = op.DeploymentScale(deployment.Namespace, deployment.Name, 0)
if !result {
return result
}
time.Sleep(time.Millisecond * 200)
result = op.DeploymentScale(deployment.Namespace, deployment.Name, deployment.Replicas)
if !result {
return result
}
return result
}
func (op *CmiiK8sOperator) DeploymentRestartByKill(cmiiEnv, appName string) bool {
deployment := op.DeploymentOneInterface(cmiiEnv, appName)
if deployment == nil {
log.ErrorF("[DeploymentRestart] - [%s] [%s] not exists !", cmiiEnv, appName)
return false
}
podList := op.PodByAppName(deployment.Namespace, deployment.Name)
if podList == nil {
log.ErrorF("[DeploymentRestart] - [%s] [%s] no pod success !", deployment.Namespace, deployment.Name)
return true
}
for _, podInterface := range podList {
if !op.PodDelete(cmiiEnv, podInterface.Name) {
log.ErrorF("[DeploymentRestart] - [%s] [%s] delete pod failed !", podInterface.Namespace, podInterface.Name)
} else {
log.DebugF("[DeploymentRestart] - [%s] [%s] delete pod success !", podInterface.Namespace, podInterface.Name)
}
}
return true
}
func (op *CmiiK8sOperator) DeploymentNew(cmiiEnv, appName string, waitTimeOut int) bool {
op.changeOperatorEnv(cmiiEnv)
//op.CurrentClient.AppsV1().Deployments(op.CurrentNamespace).Apply()
return true
}
func (op *CmiiK8sOperator) DeploymentStatusCheck(cmiiEnv, appName string, waitTimeOut int) bool {
op.changeOperatorEnv(cmiiEnv)
// 设置超时时间和时间间隔
timeout := time.After(time.Duration(waitTimeOut) * time.Second)
tick := time.Tick(time.Second)
// 监控Pod状态
for {
select {
case <-timeout:
log.ErrorF("[DeploymentStatusCheck] - [%s] [%s] 状态: 失败!", cmiiEnv, appName)
return false
case <-tick:
// check deployment exists
deployment := op.DeploymentOneInterface(cmiiEnv, appName)
if deployment == nil {
log.ErrorF("[DeploymentStatusCheck] - [%s] [%s] not exists !", cmiiEnv, appName)
return false
}
if deployment.AvailableReplicas == deployment.Replicas {
log.InfoF("[DeploymentStatusCheck] - [%s] [%s] Available: %d, Total: %d success !", deployment.Namespace, deployment.Name, deployment.AvailableReplicas, deployment.Replicas)
return true
}
log.DebugF("[DeploymentStatusCheck] - [%s] [%s] Available: %d, Total: %d waiting !", deployment.Namespace, deployment.Name, deployment.AvailableReplicas, deployment.Replicas)
}
}
}
func (op *CmiiK8sOperator) ReplicaSetExists(cmiiEnv, replicaSetName string) *v1.ReplicaSet {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
replicaSet, err := client.AppsV1().ReplicaSets(op.CurrentNamespace).Get(context.TODO(), replicaSetName, metav1.GetOptions{})
if err != nil {
log.ErrorF("[ReplicaSetExists] - [%s] [%s] not exists !", cmiiEnv, replicaSetName)
return nil
}
return replicaSet
}
func (op *CmiiK8sOperator) ReplicaSetByAppName(cmiiEnv, appName string) (replicaList []v1.ReplicaSet) {
deploy := op.DeploymentExist(cmiiEnv, appName)
if deploy == nil {
log.ErrorF("[ReplicaSetByAppName] - [%s] [%s] app not exists !", cmiiEnv, appName)
return nil
}
labelSelector := metav1.FormatLabelSelector(deploy.Spec.Selector)
//Get the replica sets that belong to the deployment.
replicaSets, err := op.CurrentClient.AppsV1().ReplicaSets(op.CurrentNamespace).List(context.TODO(), metav1.ListOptions{
LabelSelector: labelSelector,
})
if err != nil {
log.ErrorF("[ReplicaSetByAppName] - [%s] [%s] list replicaset error %s", cmiiEnv, appName, err.Error())
return nil
}
for _, replicaSet := range replicaSets.Items {
replicaSet.SetManagedFields(nil)
replicaList = append(replicaList, replicaSet)
}
return replicaList
}
func (op *CmiiK8sOperator) PodAll(cmiiEnv string) []corev1.Pod {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
podList, err := client.CoreV1().Pods(op.CurrentNamespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
log.ErrorF("[PodAll] - list c in [%s] [%s] error => %s", cmiiEnv, op.CurrentNamespace, err.Error())
return nil
}
pods := podList.Items
length := len(pods)
results := make([]corev1.Pod, length)
ccc := make(chan corev1.Pod, length)
var wg sync.WaitGroup
worker := workerThread
if length <= worker {
for i, pod := range pods {
objectMeta := pod.ObjectMeta
objectMeta.SetAnnotations(nil)
objectMeta.SetManagedFields(nil)
pod.ObjectMeta = objectMeta
results[i] = pod
}
return results
}
pinch := length / worker
wg.Add(worker)
for splice := 0; splice < worker; splice++ {
go func(podList []corev1.Pod) {
defer wg.Done()
for _, pod := range podList {
objectMeta := pod.ObjectMeta
objectMeta.SetAnnotations(nil)
objectMeta.SetManagedFields(nil)
pod.ObjectMeta = objectMeta
ccc <- pod
}
}(pods[splice*pinch : utils.MinInt((splice+1)*pinch, length)])
}
go func() {
wg.Wait()
close(ccc)
}()
index := 0
for c := range ccc {
results[index] = c
index++
}
return results[:index]
}
func (op *CmiiK8sOperator) PodAllInterface(cmiiEnv string) []CmiiPodInterface {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
podList, err := client.CoreV1().Pods(op.CurrentNamespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
log.ErrorF("[PodAll] - list c in [%s] [%s] error => %s", cmiiEnv, op.CurrentNamespace, err.Error())
return nil
}
pods := podList.Items
length := len(pods)
results := make([]CmiiPodInterface, length)
ccc := make(chan CmiiPodInterface, length)
var wg sync.WaitGroup
podInterface := CmiiPodInterface{}
worker := workerThread
if length <= worker {
for i, pod := range pods {
objectMeta := pod.ObjectMeta
objectMeta.SetAnnotations(nil)
objectMeta.SetManagedFields(nil)
pod.ObjectMeta = objectMeta
results[i] = podInterface.Convert(pod)
}
return results
}
pinch := length / worker
wg.Add(worker)
for splice := 0; splice < worker; splice++ {
go func(podList []corev1.Pod) {
defer wg.Done()
for _, pod := range podList {
objectMeta := pod.ObjectMeta
objectMeta.SetAnnotations(nil)
objectMeta.SetManagedFields(nil)
pod.ObjectMeta = objectMeta
ccc <- podInterface.Convert(pod)
}
}(pods[splice*pinch : utils.MinInt((splice+1)*pinch, length)])
}
go func() {
wg.Wait()
close(ccc)
}()
index := 0
for c := range ccc {
results[index] = c
index++
}
return results[:index]
}
func (op *CmiiK8sOperator) PodByAppName(cmiiEnv, appName string) (podList []CmiiPodInterface) {
deploy := op.DeploymentExist(cmiiEnv, appName)
if deploy == nil {
log.ErrorF("[PodByAppName] - [%s] [%s] app not exists !", cmiiEnv, appName)
return nil
}
labelSelector := metav1.FormatLabelSelector(deploy.Spec.Selector)
//Get the replica sets that belong to the deployment.
pods, err := op.CurrentClient.CoreV1().Pods(op.CurrentNamespace).List(context.TODO(), metav1.ListOptions{
LabelSelector: labelSelector,
})
if err != nil {
log.ErrorF("[PodByAppName] - [%s] [%s] list pods error %s", cmiiEnv, appName, err.Error())
return nil
}
cmiiPodInterface := CmiiPodInterface{}
for _, pod := range pods.Items {
pod.SetManagedFields(nil)
podInterface := cmiiPodInterface.Convert(pod)
podList = append(podList, podInterface)
}
return podList
}
func (op *CmiiK8sOperator) PodByNodeName(cmiiEnv, nodeName string) (podList []CmiiPodInterface) {
node := op.NodeExists(cmiiEnv, nodeName)
if node == nil {
return nil
}
list, err := op.CurrentClient.CoreV1().Pods("").List(context.TODO(), metav1.ListOptions{
FieldSelector: "spec.nodeName=" + nodeName,
})
if err != nil {
log.ErrorF("[PodByNodeName] - [%s] [%s] list pod error %s !", cmiiEnv, nodeName, err.Error())
return nil
}
podInterface := CmiiPodInterface{}
for _, pod := range list.Items {
cmiiPodInterface := podInterface.Convert(pod)
podList = append(podList, cmiiPodInterface)
}
return podList
}
func (op *CmiiK8sOperator) PodFizz(cmiiEnv, appFizz string) (fizzPod []corev1.Pod) {
podAll := op.PodAll(cmiiEnv)
if podAll == nil {
log.ErrorF("[DeploymentFizz] - no app find in [%s] !", cmiiEnv)
return nil
}
for _, pod := range podAll {
if strings.Contains(pod.Name, appFizz) {
fizzPod = append(fizzPod, pod)
}
}
return fizzPod
}
func (op *CmiiK8sOperator) PodDelete(cmiiEnv, podName string) bool {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
pod, err := client.CoreV1().Pods(op.CurrentNamespace).Get(context.TODO(), podName, metav1.GetOptions{})
if err != nil {
log.ErrorF("[PodDelete] - [%s] [%s] not exists", cmiiEnv, podName)
return false
}
// pod exists
err = client.CoreV1().Pods(op.CurrentNamespace).Delete(context.TODO(), pod.Name, metav1.DeleteOptions{})
if err != nil {
log.ErrorF("[PodDelete] - [%s] [%s] delete error ! %s", cmiiEnv, podName, err.Error())
return false
}
return true
}
func (op *CmiiK8sOperator) PodExec(cmiiEnv string, podInterface CmiiPodInterface, commandList []string) (stdout, stderr *bytes.Buffer) {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
execRequest := client.CoreV1().RESTClient().
Post().
Resource("pods").
Name(podInterface.Name).
Namespace(op.CurrentNamespace).
SubResource("exec").
VersionedParams(&corev1.PodExecOptions{
Stdin: false,
Stdout: true,
Stderr: true,
TTY: false,
Container: podInterface.ContainerName,
Command: commandList,
}, scheme.ParameterCodec)
stdout = &bytes.Buffer{}
stderr = &bytes.Buffer{}
log.DebugF("PodExec] - [%s] [%s] exec %s, url %s", cmiiEnv, podInterface.Name, commandList, execRequest.URL())
exec, err := remotecommand.NewSPDYExecutor(op.CurrentConfig, "POST", execRequest.URL())
if err != nil {
log.ErrorF("[PodExec] - NewSPDYExecutor error => %s", err.Error())
return stdout, stderr
}
err = exec.Stream(remotecommand.StreamOptions{
Stdin: nil,
Stdout: stdout,
Stderr: stderr,
Tty: false,
TerminalSizeQueue: nil,
})
if err != nil {
log.ErrorF("[PodExec] - exec.Stream error => %s", err.Error())
os.Exit(1)
}
return stdout, stderr
}
func (op *CmiiK8sOperator) NodeAll(cmiiEnv string) (nodeListR []corev1.Node) {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
nodeList, err := client.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
if err != nil {
log.ErrorF("[NodeAll] - [%s] list all node failed %s", cmiiEnv, err.Error())
return nil
}
for _, node := range nodeList.Items {
node.SetManagedFields(nil)
nodeListR = append(nodeListR, node)
}
return nodeListR
}
func (op *CmiiK8sOperator) NodeAllInterface(cmiiEnv string) (nodeList []CmiiNodeInterface) {
nodeListR := op.NodeAll(cmiiEnv)
nodeInterface := CmiiNodeInterface{}
for _, node := range nodeListR {
nodeList = append(nodeList, nodeInterface.Convert(node))
}
return nodeList
}
func (op *CmiiK8sOperator) NodeExists(cmiiEnv, nodeName string) (node *CmiiNodeInterface) {
op.changeOperatorEnv(cmiiEnv)
client := op.CurrentClient
nodeInterface := CmiiNodeInterface{}
nodeList, err := client.CoreV1().Nodes().Get(context.TODO(), nodeName, metav1.GetOptions{})
if err != nil {
log.ErrorF("[NodeExists] - [%s] [%s] not exists !", cmiiEnv, nodeName)
return nil
}
convert := nodeInterface.Convert(*nodeList)
return &convert
}

View File

@@ -1,292 +0,0 @@
package k8s_exec
import (
"agent-go/utils"
"bufio"
"fmt"
"github.com/magiconair/properties/assert"
"testing"
"time"
)
func TestCmiiK8sOperator_DeploymentAll(t *testing.T) {
start := time.Now()
deploymentList := CmiiOperator.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 := CmiiOperator.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 := CmiiOperator.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()
CmiiOperator.DeploymentScale("devflight", "cmii-uav-depotautoreturn", 0)
elapsed := time.Since(start).Milliseconds()
fmt.Printf("执行耗时: %d ms\n", elapsed)
}
func TestCmiiK8sOperator_DeploymentUpdateTag(t *testing.T) {
start := time.Now()
CmiiOperator.DeploymentUpdateTag("demo", "cmii-uav-platform", "5.2.0-011001")
elapsed := time.Since(start).Milliseconds()
fmt.Printf("执行耗时: %d ms\n", elapsed)
}
func TestCmiiK8sOperator_DeploymentRestart(t *testing.T) {
cmiiEnv := "int"
appName := "cmii-uav-gis-server"
CmiiOperator.DeploymentRestart(cmiiEnv, appName)
utils.SplitLinePrint()
check := CmiiOperator.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 := CmiiOperator.DeploymentRestartByKill(cmiiEnv, appName)
assert.Equal(t, kill, true, "deployment restart by kill failed !")
utils.SplitLinePrint()
check := CmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
assert.Equal(t, check, true, "deployment run failed!")
}
func TestCmiiK8sOperator_DeploymentOneInterface(t *testing.T) {
start := time.Now()
deploy := CmiiOperator.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 := CmiiOperator.ReplicaSetExists(cmiiEnv, appName)
utils.BeautifulPrint(*exists)
}
func TestCmiiK8sOperator_ReplicaSetByAppName(t *testing.T) {
cmiiEnv := "uavcloud-devflight"
appName := "cmii-admin-data"
exists := CmiiOperator.ReplicaSetByAppName(cmiiEnv, appName)
for _, replicaSet := range exists {
utils.BeautifulPrint(replicaSet)
}
}
func TestCmiiK8sOperator_PodAll(t *testing.T) {
start := time.Now()
podList := CmiiOperator.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 := CmiiOperator.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 := CmiiOperator.PodByNodeName(cmiiEnv, appName)
for _, podInterface := range exists {
utils.BeautifulPrint(podInterface)
}
}
func TestCmiiK8sOperator_PodFizz2(t *testing.T) {
start := time.Now()
podList := CmiiOperator.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 := "uat"
nodeName := "test-03.ecs.io"
exists := CmiiOperator.PodByNodeName(cmiiEnv, nodeName)
exists = FilterAllCmiiPodSoft(exists)
for _, podInterface := range exists {
utils.BeautifulPrint(podInterface)
if !podInterface.PodStatus {
podDelete := CmiiOperator.PodDelete(podInterface.Namespace, podInterface.Name)
assert.Equal(t, podDelete, true, "delete pod failed !")
}
}
}
func TestCmiiK8sOperator_PodExec(t *testing.T) {
podList := CmiiOperator.PodByAppName(devFlight, "cmii-uav-gateway")
stdout, stderr := CmiiOperator.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 := CmiiOperator.DeploymentStatusCheck(cmiiEnv, appName, 180)
assert.Equal(t, check, true, "deployment run failed!")
}
func TestCmiiK8sOperator_NodeAll(t *testing.T) {
start := time.Now()
nodeList := CmiiOperator.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 := CmiiOperator.NodeAllInterface("uat")
for _, nodeInterface := range cmiiNodeInterfaces {
println()
utils.BeautifulPrint(nodeInterface)
println()
}
}

View File

@@ -1,26 +0,0 @@
2024-01-10-14-54-51 uavcloud-demo cmii-uav-platform 5.2.0-011002 5.2.0-011003
2024-01-10-14-59-07 uavcloud-devflight cmii-uav-depotautoreturn 123sdsa45678 12345678
2024-01-10-15-09-29 uavcloud-demo cmii-uav-platform 5.2.0-011003 5.2.0-011004
2024-01-10-17-15-04 uavcloud-test cmii-suav-supervision 5.2.0-validation 5.2.0-011001
2024-01-11-11-06-10 uavcloud-demo cmii-uav-platform 5.2.0-011004 5.2.0-011101
2024-01-11-11-36-56 uavcloud-demo cmii-uav-waypoint 5.2.0 5.2.0-011101
2024-01-11-11-58-15 uavcloud-uavms uavms-lowaltitude-platform 5.1.0 5.2.0-011101
2024-01-11-14-00-34 uavcloud-uavms uavms-lowaltitude-platform 5.1.0-011102 5.1.0-011103
2024-01-11-14-49-53 uavcloud-demo cmii-uav-waypoint 5.2.0-011101 5.2.0-011102
2024-01-11-15-32-28 uavcloud-demo cmii-uav-platform 5.2.0-011101 5.2.0-011102
2024-01-11-17-09-44 uavcloud-feature cmii-uav-platform 5.2.0-validation 5.2.0-011102
2024-01-11-17-35-47 uavcloud-uavms cmii-uav-surveillance 5.1.0-LAIN05A 5.1.0-011101
2024-01-11-17-38-06 uavcloud-uavms uavms-lowaltitude-platform 5.1.0-011103 5.1.0-011102
2024-01-11-17-49-09 uavcloud-uavms uavms-lowaltitude-platform 5.1.0-011102 5.1.0-011104
2024-01-12-10-38-30 uavcloud-uavms uavms-lowaltitude-platform 5.1.0-011105 5.2.0-011201
2024-01-12-12-09-59 uavcloud-uavms uavms-lowaltitude-platform 5.2.0-011201 5.2.0-011202
2024-01-12-17-13-32 uavcloud-test cmii-suav-supervision 5.2.0-011001 5.2.0-011201
2024-01-12-17-22-47 uavcloud-demo cmii-uav-platform 5.2.0-011102 5.2.0-011201
2024-01-15-11-56-33 uavcloud-test cmii-suav-supervision 5.2.0-011201 5.2.0-011501
2024-01-16-10-22-02 uavcloud-test cmii-suav-supervision 5.2.0-011501 5.2.0-011601
2024-01-16-11-40-31 uavcloud-uavms uavms-lowaltitude-platform 5.2.0-011202 5.2.0-snapshot
2024-01-16-11-58-30 uavcloud-test cmii-suav-supervision 5.2.0-011601 5.2.0-011602
2024-01-16-13-55-32 uavcloud-test cmii-suav-supervision 5.2.0-011602 5.2.0-011603
2024-01-16-14-51-05 uavcloud-test cmii-suav-supervision 5.2.0-011603 5.2.0-011604
2024-01-17-16-13-39 uavcloud-test cmii-suav-supervision 5.2.0-011604 5.2.0-0117
2024-01-19-14-17-03 uavcloud-test cmii-suav-supervision 5.2.0-0117 5.2.0-011901

View File

@@ -1,10 +1,10 @@
package status
import (
"agent-go/g"
logger2 "agent-go/logger"
"fmt"
"time"
"wdd.io/agent-go/g"
logger2 "wdd.io/agent-go/logger"
)
var log = logger2.Log

View File

@@ -1,9 +1,9 @@
package utils
import (
"agent-go/logger"
"encoding/json"
"fmt"
"wdd.io/agent-go/logger"
)
var log = logger.Log