DKube v1.0

service/configmap.go

@@ -0,0 +1,102 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"github.com/wonderivan/logger"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var ConfigMap configMap
+
+type configMap struct{}
+
+type ConfigMapsResp struct {
+	Items []corev1.ConfigMap `json:"items"`
+	Total int                `json:"total"`
+}
+
+func (c *configMap) GetConfigMaps(filterName, namespace string, limit, page int) (configMapsResp *ConfigMapsResp, err error) {
+	configMapList, err := K8s.ClientSet.CoreV1().ConfigMaps(namespace).List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取ConfigMap列表失败, " + err.Error()))
+		return nil, errors.New("获取ConfigMap列表失败, " + err.Error())
+	}
+	selectableData := &dataSelector{
+		GenericDataList: c.toCells(configMapList.Items),
+		DataSelect: &DataSelectQuery{
+			Filter: &FilterQuery{Name: filterName},
+			Paginate: &PaginateQuery{
+				Limit: limit,
+				Page:  page,
+			},
+		},
+	}
+
+	filtered := selectableData.Filter()
+	total := len(filtered.GenericDataList)
+	data := filtered.Sort().Paginate()
+
+	configMaps := c.fromCells(data.GenericDataList)
+
+	return &ConfigMapsResp{
+		Items: configMaps,
+		Total: total,
+	}, nil
+}
+
+func (c *configMap) GetConfigMapDetail(configMapName, namespace string) (configMap *corev1.ConfigMap, err error) {
+	configMap, err = K8s.ClientSet.CoreV1().ConfigMaps(namespace).Get(context.TODO(), configMapName, metav1.GetOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取ConfigMap详情失败, " + err.Error()))
+		return nil, errors.New("获取ConfigMap详情失败, " + err.Error())
+	}
+
+	return configMap, nil
+}
+
+func (c *configMap) DeleteConfigMap(configMapName, namespace string) (err error) {
+	err = K8s.ClientSet.CoreV1().ConfigMaps(namespace).Delete(context.TODO(), configMapName, metav1.DeleteOptions{})
+	if err != nil {
+		logger.Error(errors.New("删除ConfigMap失败, " + err.Error()))
+		return errors.New("删除ConfigMap失败, " + err.Error())
+	}
+
+	return nil
+}
+
+func (c *configMap) UpdateConfigMap(namespace, content string) (err error) {
+	var configMap = &corev1.ConfigMap{}
+
+	err = json.Unmarshal([]byte(content), configMap)
+	if err != nil {
+		logger.Error(errors.New("反序列化失败, " + err.Error()))
+		return errors.New("反序列化失败, " + err.Error())
+	}
+
+	_, err = K8s.ClientSet.CoreV1().ConfigMaps(namespace).Update(context.TODO(), configMap, metav1.UpdateOptions{})
+	if err != nil {
+		logger.Error(errors.New("更新ConfigMap失败, " + err.Error()))
+		return errors.New("更新ConfigMap失败, " + err.Error())
+	}
+	return nil
+}
+
+func (c *configMap) toCells(std []corev1.ConfigMap) []DataCell {
+	cells := make([]DataCell, len(std))
+	for i := range std {
+		cells[i] = configMapCell(std[i])
+	}
+	return cells
+}
+
+func (c *configMap) fromCells(cells []DataCell) []corev1.ConfigMap {
+	configMaps := make([]corev1.ConfigMap, len(cells))
+	for i := range cells {
+		configMaps[i] = corev1.ConfigMap(cells[i].(configMapCell))
+	}
+
+	return configMaps
+}

service/daemonset.go

@@ -0,0 +1,102 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"github.com/wonderivan/logger"
+	appsv1 "k8s.io/api/apps/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var DaemonSet daemonSet
+
+type daemonSet struct{}
+
+type DaemonSetsResp struct {
+	Items []appsv1.DaemonSet `json:"items"`
+	Total int                `json:"total"`
+}
+
+func (d *daemonSet) GetDaemonSets(filterName, namespace string, limit, page int) (daemonSetsResp *DaemonSetsResp, err error) {
+	daemonSetList, err := K8s.ClientSet.AppsV1().DaemonSets(namespace).List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取DaemonSet列表失败, " + err.Error()))
+		return nil, errors.New("获取DaemonSet列表失败, " + err.Error())
+	}
+	selectableData := &dataSelector{
+		GenericDataList: d.toCells(daemonSetList.Items),
+		DataSelect: &DataSelectQuery{
+			Filter: &FilterQuery{Name: filterName},
+			Paginate: &PaginateQuery{
+				Limit: limit,
+				Page:  page,
+			},
+		},
+	}
+
+	filtered := selectableData.Filter()
+	total := len(filtered.GenericDataList)
+	data := filtered.Sort().Paginate()
+
+	daemonSets := d.fromCells(data.GenericDataList)
+
+	return &DaemonSetsResp{
+		Items: daemonSets,
+		Total: total,
+	}, nil
+}
+
+func (d *daemonSet) GetDaemonSetDetail(daemonSetName, namespace string) (daemonSet *appsv1.DaemonSet, err error) {
+	daemonSet, err = K8s.ClientSet.AppsV1().DaemonSets(namespace).Get(context.TODO(), daemonSetName, metav1.GetOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取DaemonSet详情失败, " + err.Error()))
+		return nil, errors.New("获取DaemonSet详情失败, " + err.Error())
+	}
+
+	return daemonSet, nil
+}
+
+func (d *daemonSet) DeleteDaemonSet(daemonSetName, namespace string) (err error) {
+	err = K8s.ClientSet.AppsV1().DaemonSets(namespace).Delete(context.TODO(), daemonSetName, metav1.DeleteOptions{})
+	if err != nil {
+		logger.Error(errors.New("删除DaemonSet失败, " + err.Error()))
+		return errors.New("删除DaemonSet失败, " + err.Error())
+	}
+
+	return nil
+}
+
+func (d *daemonSet) UpdateDaemonSet(namespace, content string) (err error) {
+	var daemonSet = &appsv1.DaemonSet{}
+
+	err = json.Unmarshal([]byte(content), daemonSet)
+	if err != nil {
+		logger.Error(errors.New("反序列化失败, " + err.Error()))
+		return errors.New("反序列化失败, " + err.Error())
+	}
+
+	_, err = K8s.ClientSet.AppsV1().DaemonSets(namespace).Update(context.TODO(), daemonSet, metav1.UpdateOptions{})
+	if err != nil {
+		logger.Error(errors.New("更新DaemonSet失败, " + err.Error()))
+		return errors.New("更新DaemonSet失败, " + err.Error())
+	}
+	return nil
+}
+
+func (d *daemonSet) toCells(std []appsv1.DaemonSet) []DataCell {
+	cells := make([]DataCell, len(std))
+	for i := range std {
+		cells[i] = daemonSetCell(std[i])
+	}
+	return cells
+}
+
+func (d *daemonSet) fromCells(cells []DataCell) []appsv1.DaemonSet {
+	daemonSets := make([]appsv1.DaemonSet, len(cells))
+	for i := range cells {
+		daemonSets[i] = appsv1.DaemonSet(cells[i].(daemonSetCell))
+	}
+
+	return daemonSets
+}

service/dataselector.go

@@ -9,19 +9,16 @@ import (
 	"time"
 )
 
-
 type dataSelector struct {
 	GenericDataList []DataCell
 	DataSelect      *DataSelectQuery
 }
 
-
 type DataCell interface {
 	GetCreation() time.Time
 	GetName() string
 }
 
-
 type DataSelectQuery struct {
 	Filter   *FilterQuery
 	Paginate *PaginateQuery
@@ -36,12 +33,10 @@ type PaginateQuery struct {
 	Page  int
 }
 
-
 func (d *dataSelector) Len() int {
 	return len(d.GenericDataList)
 }
 
-
 func (d *dataSelector) Swap(i, j int) {
 	d.GenericDataList[i], d.GenericDataList[j] = d.GenericDataList[j], d.GenericDataList[i]
 }
@@ -49,6 +44,7 @@ func (d *dataSelector) Swap(i, j int) {
 func (d *dataSelector) Less(i, j int) bool {
 	a := d.GenericDataList[i].GetCreation()
 	b := d.GenericDataList[j].GetCreation()
+
 	return b.Before(a)
 }
 
@@ -65,7 +61,7 @@ func (d *dataSelector) Filter() *dataSelector {
 	for _, value := range d.GenericDataList {
 		matches := true
 		objName := value.GetName()
-		if strings.Contains(objName, d.DataSelect.Filter.Name) {
+		if !strings.Contains(objName, d.DataSelect.Filter.Name) {
 			matches = false
 			continue
 		}
@@ -73,7 +69,6 @@ func (d *dataSelector) Filter() *dataSelector {
 			filtered = append(filtered, value)
 		}
 	}
-
 	d.GenericDataList = filtered
 	return d
 }
@@ -81,11 +76,9 @@ func (d *dataSelector) Filter() *dataSelector {
 func (d *dataSelector) Paginate() *dataSelector {
 	limit := d.DataSelect.Paginate.Limit
 	page := d.DataSelect.Paginate.Page
-
 	if limit <= 0 || page <= 0 {
 		return d
 	}
-
 	startIndex := limit * (page - 1)
 	endIndex := limit*page - 1
 
@@ -118,6 +111,56 @@ func (d deploymentCell) GetName() string {
 	return d.Name
 }
 
+type daemonSetCell appsv1.DaemonSet
+
+func (d daemonSetCell) GetCreation() time.Time {
+	return d.CreationTimestamp.Time
+}
+
+func (d daemonSetCell) GetName() string {
+	return d.Name
+}
+
+type statefulSetCell appsv1.StatefulSet
+
+func (s statefulSetCell) GetCreation() time.Time {
+	return s.CreationTimestamp.Time
+}
+
+func (s statefulSetCell) GetName() string {
+	return s.Name
+}
+
+type nodeCell corev1.Node
+
+func (n nodeCell) GetCreation() time.Time {
+	return n.CreationTimestamp.Time
+}
+
+func (n nodeCell) GetName() string {
+	return n.Name
+}
+
+type namespaceCell corev1.Namespace
+
+func (n namespaceCell) GetCreation() time.Time {
+	return n.CreationTimestamp.Time
+}
+
+func (n namespaceCell) GetName() string {
+	return n.Name
+}
+
+type pvCell corev1.PersistentVolume
+
+func (p pvCell) GetCreation() time.Time {
+	return p.CreationTimestamp.Time
+}
+
+func (p pvCell) GetName() string {
+	return p.Name
+}
+
 type serviceCell corev1.Service
 
 func (s serviceCell) GetCreation() time.Time {
@@ -137,3 +180,33 @@ func (i ingressCell) GetCreation() time.Time {
 func (i ingressCell) GetName() string {
 	return i.Name
 }
+
+type configMapCell corev1.ConfigMap
+
+func (c configMapCell) GetCreation() time.Time {
+	return c.CreationTimestamp.Time
+}
+
+func (c configMapCell) GetName() string {
+	return c.Name
+}
+
+type secretCell corev1.Secret
+
+func (s secretCell) GetCreation() time.Time {
+	return s.CreationTimestamp.Time
+}
+
+func (s secretCell) GetName() string {
+	return s.Name
+}
+
+type pvcCell corev1.PersistentVolumeClaim
+
+func (p pvcCell) GetCreation() time.Time {
+	return p.CreationTimestamp.Time
+}
+
+func (p pvcCell) GetName() string {
+	return p.Name
+}

service/deployment.go

@@ -41,7 +41,6 @@ type DeploysNp struct {
 	DeployNum int    `json:"deployment_num"`
 }
 
-//获取deployment列表，支持过滤、排序、分页
 func (d *deployment) GetDeployments(filterName, namespace string, limit, page int) (deploymentsResp *DeploymentsResp, err error) {
 	deploymentList, err := K8s.ClientSet.AppsV1().Deployments(namespace).List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
@@ -71,7 +70,6 @@ func (d *deployment) GetDeployments(filterName, namespace string, limit, page in
 	}, nil
 }
 
-//获取deployment详情
 func (d *deployment) GetDeploymentDetail(deploymentName, namespace string) (deployment *appsv1.Deployment, err error) {
 	deployment, err = K8s.ClientSet.AppsV1().Deployments(namespace).Get(context.TODO(), deploymentName, metav1.GetOptions{})
 	if err != nil {
@@ -82,14 +80,12 @@ func (d *deployment) GetDeploymentDetail(deploymentName, namespace string) (depl
 	return deployment, nil
 }
 
-//设置deployment副本数
 func (d *deployment) ScaleDeployment(deploymentName, namespace string, scaleNum int) (replica int32, err error) {
 	scale, err := K8s.ClientSet.AppsV1().Deployments(namespace).GetScale(context.TODO(), deploymentName, metav1.GetOptions{})
 	if err != nil {
 		logger.Error(errors.New("获取Deployment副本数信息失败, " + err.Error()))
 		return 0, errors.New("获取Deployment副本数信息失败, " + err.Error())
 	}
-
 	scale.Spec.Replicas = int32(scaleNum)
 	newScale, err := K8s.ClientSet.AppsV1().Deployments(namespace).UpdateScale(context.TODO(), deploymentName, scale, metav1.UpdateOptions{})
 	if err != nil {
@@ -100,7 +96,6 @@ func (d *deployment) ScaleDeployment(deploymentName, namespace string, scaleNum
 	return newScale.Spec.Replicas, nil
 }
 
-//创建deployment，接收DeployCreate对象
 func (d *deployment) CreateDeployment(data *DeployCreate) (err error) {
 	deployment := &appsv1.Deployment{
 		ObjectMeta: metav1.ObjectMeta{
@@ -137,7 +132,7 @@ func (d *deployment) CreateDeployment(data *DeployCreate) (err error) {
 		},
 		Status: appsv1.DeploymentStatus{},
 	}
-	//判断健康检查功能是否打开，若打开，则增加健康检查功能
+
 	if data.HealthCheck {
 		deployment.Spec.Template.Spec.Containers[0].ReadinessProbe = &corev1.Probe{
 			ProbeHandler: corev1.ProbeHandler{
@@ -168,7 +163,7 @@ func (d *deployment) CreateDeployment(data *DeployCreate) (err error) {
 			PeriodSeconds:       5,
 		}
 	}
-	//定义容器的limit和request资源
+
 	deployment.Spec.Template.Spec.Containers[0].Resources.Limits = map[corev1.ResourceName]resource.Quantity{
 		corev1.ResourceCPU:    resource.MustParse(data.Cpu),
 		corev1.ResourceMemory: resource.MustParse(data.Memory),
@@ -188,7 +183,6 @@ func (d *deployment) CreateDeployment(data *DeployCreate) (err error) {
 	return nil
 }
 
-//删除deployment
 func (d *deployment) DeleteDeployment(deploymentName, namespace string) (err error) {
 	err = K8s.ClientSet.AppsV1().Deployments(namespace).Delete(context.TODO(), deploymentName, metav1.DeleteOptions{})
 	if err != nil {
@@ -199,7 +193,6 @@ func (d *deployment) DeleteDeployment(deploymentName, namespace string) (err err
 	return nil
 }
 
-//重启deployment
 func (d *deployment) RestartDeployment(deploymentName, namespace string) (err error) {
 	patchData := map[string]interface{}{
 		"spec": map[string]interface{}{
@@ -217,7 +210,6 @@ func (d *deployment) RestartDeployment(deploymentName, namespace string) (err er
 			},
 		},
 	}
-
 	patchByte, err := json.Marshal(patchData)
 	if err != nil {
 		logger.Error(errors.New("json序列化失败, " + err.Error()))
@@ -232,7 +224,6 @@ func (d *deployment) RestartDeployment(deploymentName, namespace string) (err er
 	return nil
 }
 
-//更新deployment
 func (d *deployment) UpdateDeployment(namespace, content string) (err error) {
 	var deploy = &appsv1.Deployment{}
 
@@ -250,7 +241,6 @@ func (d *deployment) UpdateDeployment(namespace, content string) (err error) {
 	return nil
 }
 
-//获取每个namespace的deployment数量
 func (d *deployment) GetDeployNumPerNp() (deploysNps []*DeploysNp, err error) {
 	namespaceList, err := K8s.ClientSet.CoreV1().Namespaces().List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
@@ -272,7 +262,6 @@ func (d *deployment) GetDeployNumPerNp() (deploysNps []*DeploysNp, err error) {
 	return deploysNps, nil
 }
 
-//类型转换
 func (d *deployment) toCells(deployments []appsv1.Deployment) []DataCell {
 	cells := make([]DataCell, len(deployments))
 	for i := range deployments {
@@ -284,7 +273,6 @@ func (d *deployment) toCells(deployments []appsv1.Deployment) []DataCell {
 func (d *deployment) fromCells(cells []DataCell) []appsv1.Deployment {
 	deployments := make([]appsv1.Deployment, len(cells))
 	for i := range cells {
-		//cells[i].(podCell)是将DataCell类型转成podCell
 		deployments[i] = appsv1.Deployment(cells[i].(deploymentCell))
 	}
 	return deployments

service/ingress.go

@@ -18,7 +18,6 @@ type IngressesResp struct {
 	Total int            `json:"total"`
 }
 
-//定义ServiceCreate结构体，用于创建service需要的参数属性的定义
 type IngressCreate struct {
 	Name      string                 `json:"name"`
 	Namespace string                 `json:"namespace"`
@@ -26,7 +25,6 @@ type IngressCreate struct {
 	Hosts     map[string][]*HttpPath `json:"hosts"`
 }
 
-//定义ingress的path结构体
 type HttpPath struct {
 	Path        string        `json:"path"`
 	PathType    nwv1.PathType `json:"path_type"`
@@ -34,15 +32,12 @@ type HttpPath struct {
 	ServicePort int32         `json:"service_port"`
 }
 
-//获取ingress列表，支持过滤、排序、分页
 func (i *ingress) GetIngresses(filterName, namespace string, limit, page int) (ingressesResp *IngressesResp, err error) {
-	//获取ingressList类型的ingress列表
 	ingressList, err := K8s.ClientSet.NetworkingV1().Ingresses(namespace).List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
 		logger.Error(errors.New("获取Ingress列表失败, " + err.Error()))
 		return nil, errors.New("获取Ingress列表失败, " + err.Error())
 	}
-	//将ingressList中的ingress列表(Items)，放进dataselector对象中，进行排序
 	selectableData := &dataSelector{
 		GenericDataList: i.toCells(ingressList.Items),
 		DataSelect: &DataSelectQuery{
@@ -58,7 +53,6 @@ func (i *ingress) GetIngresses(filterName, namespace string, limit, page int) (i
 	total := len(filtered.GenericDataList)
 	data := filtered.Sort().Paginate()
 
-	//将[]DataCell类型的ingress列表转为v1.ingress列表
 	ingresss := i.fromCells(data.GenericDataList)
 
 	return &IngressesResp{
@@ -67,7 +61,6 @@ func (i *ingress) GetIngresses(filterName, namespace string, limit, page int) (i
 	}, nil
 }
 
-//获取ingress详情
 func (i *ingress) GetIngresstDetail(ingressName, namespace string) (ingress *nwv1.Ingress, err error) {
 	ingress, err = K8s.ClientSet.NetworkingV1().Ingresses(namespace).Get(context.TODO(), ingressName, metav1.GetOptions{})
 	if err != nil {
@@ -78,12 +71,9 @@ func (i *ingress) GetIngresstDetail(ingressName, namespace string) (ingress *nwv
 	return ingress, nil
 }
 
-//创建ingress
 func (i *ingress) CreateIngress(data *IngressCreate) (err error) {
-	//声明nwv1.IngressRule和nwv1.HTTPIngressPath变量，后面组装数据于鏊用到
 	var ingressRules []nwv1.IngressRule
 	var httpIngressPATHs []nwv1.HTTPIngressPath
-	//将data中的数据组装成nwv1.Ingress对象
 	ingress := &nwv1.Ingress{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      data.Name,
@@ -92,41 +82,33 @@ func (i *ingress) CreateIngress(data *IngressCreate) (err error) {
 		},
 		Status: nwv1.IngressStatus{},
 	}
-	//第一层for循环是将host组装成nwv1.IngressRule类型的对象
-	// 一个host对应一个ingressrule，每个ingressrule中包含一个host和多个path
+
 	for key, value := range data.Hosts {
 		ir := nwv1.IngressRule{
 			Host: key,
-			//这里现将nwv1.HTTPIngressRuleValue类型中的Paths置为空，后面组装好数据再赋值
 			IngressRuleValue: nwv1.IngressRuleValue{
 				HTTP: &nwv1.HTTPIngressRuleValue{Paths: nil},
 			},
 		}
-		//第二层for循环是将path组装成nwv1.HTTPIngressPath类型的对象
 		for _, httpPath := range value {
 			hip := nwv1.HTTPIngressPath{
 				Path:     httpPath.Path,
 				PathType: &httpPath.PathType,
 				Backend: nwv1.IngressBackend{
 					Service: &nwv1.IngressServiceBackend{
-						Name: httpPath.ServiceName,
+						Name: getServiceName(httpPath.ServiceName),
 						Port: nwv1.ServiceBackendPort{
 							Number: httpPath.ServicePort,
 						},
 					},
 				},
 			}
-			//将每个hip对象组装成数组
 			httpIngressPATHs = append(httpIngressPATHs, hip)
 		}
-		//给Paths赋值，前面置为空了
 		ir.IngressRuleValue.HTTP.Paths = httpIngressPATHs
-		//将每个ir对象组装成数组，这个ir对象就是IngressRule，每个元素是一个host和多个path
 		ingressRules = append(ingressRules, ir)
 	}
-	//将ingressRules对象加入到ingress的规则中
 	ingress.Spec.Rules = ingressRules
-	//创建ingress
 	_, err = K8s.ClientSet.NetworkingV1().Ingresses(data.Namespace).Create(context.TODO(), ingress, metav1.CreateOptions{})
 	if err != nil {
 		logger.Error(errors.New("创建Ingress失败, " + err.Error()))
@@ -136,7 +118,6 @@ func (i *ingress) CreateIngress(data *IngressCreate) (err error) {
 	return nil
 }
 
-//删除ingress
 func (i *ingress) DeleteIngress(ingressName, namespace string) (err error) {
 	err = K8s.ClientSet.NetworkingV1().Ingresses(namespace).Delete(context.TODO(), ingressName, metav1.DeleteOptions{})
 	if err != nil {
@@ -147,7 +128,6 @@ func (i *ingress) DeleteIngress(ingressName, namespace string) (err error) {
 	return nil
 }
 
-//更新ingress
 func (i *ingress) UpdateIngress(namespace, content string) (err error) {
 	var ingress = &nwv1.Ingress{}
 

service/init.go

@@ -7,25 +7,22 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 )
 
-//用于初始化k8s clientset
 var K8s k8s
 
 type k8s struct {
 	ClientSet *kubernetes.Clientset
 }
 
-//初始化方法
 func (k *k8s) Init() {
 	conf, err := clientcmd.BuildConfigFromFlags("", config.Kubeconfig)
 	if err != nil {
-		panic("获取k8s clinet配置失败," + err.Error())
+		logger.Error("获取k8s client配置失败," + err.Error())
 	}
-
 	clientset, err := kubernetes.NewForConfig(conf)
 	if err != nil {
-		panic("创建k8s clinet失败," + err.Error())
+		logger.Error("创建k8s client失败," + err.Error())
 	} else {
-		logger.Info("k8s client 初始化成功")
+		logger.Info("k8s client 初始化成功!")
 	}
 
 	k.ClientSet = clientset

service/login.go

@@ -0,0 +1,21 @@
+package service
+
+import (
+	"dkube/config"
+	"errors"
+	"github.com/wonderivan/logger"
+)
+
+var Login login
+
+type login struct{}
+
+func (l *login) Auth(username, password string) (err error) {
+	if username == config.AdminUser && password == config.AdminPwd {
+		return nil
+	} else {
+		logger.Error("登录失败, 用户名或密码错误")
+		return errors.New("登录失败, 用户名或密码错误")
+	}
+	return nil
+}

service/namespace.go

@@ -0,0 +1,84 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"github.com/wonderivan/logger"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var Namespace namespace
+
+type namespace struct{}
+
+type NamespacesResp struct {
+	Items []corev1.Namespace `json:"items"`
+	Total int                `json:"total"`
+}
+
+func (n *namespace) GetNamespaces(filterName string, limit, page int) (namespacesResp *NamespacesResp, err error) {
+	namespaceList, err := K8s.ClientSet.CoreV1().Namespaces().List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Namespace列表失败, " + err.Error()))
+		return nil, errors.New("获取Namespace列表失败, " + err.Error())
+	}
+	selectableData := &dataSelector{
+		GenericDataList: n.toCells(namespaceList.Items),
+		DataSelect: &DataSelectQuery{
+			Filter: &FilterQuery{Name: filterName},
+			Paginate: &PaginateQuery{
+				Limit: limit,
+				Page:  page,
+			},
+		},
+	}
+
+	filtered := selectableData.Filter()
+	total := len(filtered.GenericDataList)
+	data := filtered.Sort().Paginate()
+
+	namespaces := n.fromCells(data.GenericDataList)
+
+	return &NamespacesResp{
+		Items: namespaces,
+		Total: total,
+	}, nil
+}
+
+func (n *namespace) GetNamespaceDetail(namespaceName string) (namespace *corev1.Namespace, err error) {
+	namespace, err = K8s.ClientSet.CoreV1().Namespaces().Get(context.TODO(), namespaceName, metav1.GetOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Namespace详情失败, " + err.Error()))
+		return nil, errors.New("获取Namespace详情失败, " + err.Error())
+	}
+
+	return namespace, nil
+}
+
+func (n *namespace) DeleteNamespace(namespaceName string) (err error) {
+	err = K8s.ClientSet.CoreV1().Namespaces().Delete(context.TODO(), namespaceName, metav1.DeleteOptions{})
+	if err != nil {
+		logger.Error(errors.New("删除Namespace失败, " + err.Error()))
+		return errors.New("删除Namespace失败, " + err.Error())
+	}
+
+	return nil
+}
+
+func (n *namespace) toCells(std []corev1.Namespace) []DataCell {
+	cells := make([]DataCell, len(std))
+	for i := range std {
+		cells[i] = namespaceCell(std[i])
+	}
+	return cells
+}
+
+func (n *namespace) fromCells(cells []DataCell) []corev1.Namespace {
+	namespaces := make([]corev1.Namespace, len(cells))
+	for i := range cells {
+		namespaces[i] = corev1.Namespace(cells[i].(namespaceCell))
+	}
+
+	return namespaces
+}

service/node.go

@@ -0,0 +1,74 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"github.com/wonderivan/logger"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var Node node
+
+type node struct{}
+
+type NodesResp struct {
+	Items []corev1.Node `json:"items"`
+	Total int           `json:"total"`
+}
+
+func (n *node) GetNodes(filterName string, limit, page int) (nodesResp *NodesResp, err error) {
+	nodeList, err := K8s.ClientSet.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Node列表失败, " + err.Error()))
+		return nil, errors.New("获取Node列表失败, " + err.Error())
+	}
+	selectableData := &dataSelector{
+		GenericDataList: n.toCells(nodeList.Items),
+		DataSelect: &DataSelectQuery{
+			Filter: &FilterQuery{Name: filterName},
+			Paginate: &PaginateQuery{
+				Limit: limit,
+				Page:  page,
+			},
+		},
+	}
+
+	filtered := selectableData.Filter()
+	total := len(filtered.GenericDataList)
+	data := filtered.Sort().Paginate()
+
+	nodes := n.fromCells(data.GenericDataList)
+
+	return &NodesResp{
+		Items: nodes,
+		Total: total,
+	}, nil
+}
+
+func (n *node) GetNodeDetail(nodeName string) (node *corev1.Node, err error) {
+	node, err = K8s.ClientSet.CoreV1().Nodes().Get(context.TODO(), nodeName, metav1.GetOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Node详情失败, " + err.Error()))
+		return nil, errors.New("获取Node详情失败, " + err.Error())
+	}
+
+	return node, nil
+}
+
+func (n *node) toCells(std []corev1.Node) []DataCell {
+	cells := make([]DataCell, len(std))
+	for i := range std {
+		cells[i] = nodeCell(std[i])
+	}
+	return cells
+}
+
+func (n *node) fromCells(cells []DataCell) []corev1.Node {
+	nodes := make([]corev1.Node, len(cells))
+	for i := range cells {
+		nodes[i] = corev1.Node(cells[i].(nodeCell))
+	}
+
+	return nodes
+}

service/pod.go

@@ -21,13 +21,11 @@ type PodsResp struct {
 	Items []corev1.Pod `json:"items"`
 }
 
-
 type PodsNp struct {
 	Namespace string
 	PodNum    int
 }
 
-
 func (p *pod) GetPods(filterName, namespace string, limit, page int) (podsResp *PodsResp, err error) {
 	podList, err := K8s.ClientSet.CoreV1().Pods(namespace).List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
@@ -44,42 +42,37 @@ func (p *pod) GetPods(filterName, namespace string, limit, page int) (podsResp *
 			},
 		},
 	}
-
 	filtered := selectableData.Filter()
 	total := len(filtered.GenericDataList)
-	//排序和分页
 	data := filtered.Sort().Paginate()
-
 	pods := p.fromCells(data.GenericDataList)
 
 	return &PodsResp{
 		Total: total,
 		Items: pods,
 	}, nil
-
 }
 
-//获取Pod详情
 func (p *pod) GetPodDetail(podName, namespace string) (pod *corev1.Pod, err error) {
 	pod, err = K8s.ClientSet.CoreV1().Pods(namespace).Get(context.TODO(), podName, metav1.GetOptions{})
 	if err != nil {
 		logger.Error("获取Pod详情失败," + err.Error())
 		return nil, errors.New("获取Pod详情失败," + err.Error())
 	}
+
 	return pod, nil
 }
 
-//删除Pod
 func (p *pod) DeletePod(podName, namespace string) (err error) {
 	err = K8s.ClientSet.CoreV1().Pods(namespace).Delete(context.TODO(), podName, metav1.DeleteOptions{})
 	if err != nil {
 		logger.Error("删除Pod失败," + err.Error())
 		return errors.New("删除Pod失败," + err.Error())
 	}
+
 	return nil
 }
 
-//更新Pod
 func (p *pod) UpdatePod(namespace, content string) (err error) {
 	pod := &corev1.Pod{}
 	err = json.Unmarshal([]byte(content), pod)
@@ -92,12 +85,11 @@ func (p *pod) UpdatePod(namespace, content string) (err error) {
 		logger.Error("更新Pod失败," + err.Error())
 		return errors.New("更新Pod失败," + err.Error())
 	}
+
 	return nil
 }
 
-//获取Pod容器名列表
 func (p *pod) GetPodContainer(podName, namespace string) (containers []string, err error) {
-	//获取Pod详情
 	pod, err := p.GetPodDetail(podName, namespace)
 	if err != nil {
 		return nil, err
@@ -105,43 +97,39 @@ func (p *pod) GetPodContainer(podName, namespace string) (containers []string, e
 	for _, container := range pod.Spec.Containers {
 		containers = append(containers, container.Name)
 	}
+
 	return containers, nil
 }
 
-//获取Pod内容器日志
 func (p *pod) GetPodLog(containerName, podName, namespace string) (log string, err error) {
 	lineLimit := int64(config.PodLogTailLine)
 	option := &corev1.PodLogOptions{
 		Container: containerName,
 		TailLines: &lineLimit,
 	}
-	//获取request实例
 	req := K8s.ClientSet.CoreV1().Pods(namespace).GetLogs(podName, option)
 	podLogs, err := req.Stream(context.TODO())
 	if err != nil {
-		logger.Error(errors.New("获取PodLogs失败," + err.Error()))
-		return "", errors.New("获取PodLogs失败," + err.Error())
+		logger.Error(errors.New("获取PodLog失败, " + err.Error()))
+		return "", errors.New("获取PodLog失败, " + err.Error())
 	}
-	defer podLogs.Close() //处理完关闭
+	defer podLogs.Close()
 	buf := new(bytes.Buffer)
 	_, err = io.Copy(buf, podLogs)
 	if err != nil {
-		logger.Error(errors.New("获取PodLogs失败," + err.Error()))
-		return "", errors.New("获取PodLogs失败," + err.Error())
+		logger.Error(errors.New("复制PodLog失败, " + err.Error()))
+		return "", errors.New("复制PodLog失败, " + err.Error())
 	}
 
 	return buf.String(), nil
 }
 
-//获取每个namespace的pod数量
 func (p *pod) GetPodNumPerNp() (podsNps []*PodsNp, err error) {
-	//获取namespace列表
 	namespaceList, err := K8s.ClientSet.CoreV1().Namespaces().List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
 		return nil, err
 	}
 	for _, namespace := range namespaceList.Items {
-		//获取pod列表
 		podList, err := K8s.ClientSet.CoreV1().Pods(namespace.Name).List(context.TODO(), metav1.ListOptions{})
 		if err != nil {
 			return nil, err
@@ -169,4 +157,4 @@ func (p *pod) fromCells(cells []DataCell) []corev1.Pod {
 		pods[i] = corev1.Pod(cells[i].(podCell))
 	}
 	return pods
-}
+}

service/pv.go

@@ -0,0 +1,84 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"github.com/wonderivan/logger"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var Pv pv
+
+type pv struct{}
+
+type PvsResp struct {
+	Items []corev1.PersistentVolume `json:"items"`
+	Total int                       `json:"total"`
+}
+
+func (p *pv) GetPvs(filterName string, limit, page int) (pvsResp *PvsResp, err error) {
+	pvList, err := K8s.ClientSet.CoreV1().PersistentVolumes().List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Pv列表失败, " + err.Error()))
+		return nil, errors.New("获取Pv列表失败, " + err.Error())
+	}
+	selectableData := &dataSelector{
+		GenericDataList: p.toCells(pvList.Items),
+		DataSelect: &DataSelectQuery{
+			Filter: &FilterQuery{Name: filterName},
+			Paginate: &PaginateQuery{
+				Limit: limit,
+				Page:  page,
+			},
+		},
+	}
+
+	filtered := selectableData.Filter()
+	total := len(filtered.GenericDataList)
+	data := filtered.Sort().Paginate()
+
+	pvs := p.fromCells(data.GenericDataList)
+
+	return &PvsResp{
+		Items: pvs,
+		Total: total,
+	}, nil
+}
+
+func (p *pv) GetPvDetail(pvName string) (pv *corev1.PersistentVolume, err error) {
+	pv, err = K8s.ClientSet.CoreV1().PersistentVolumes().Get(context.TODO(), pvName, metav1.GetOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Pv详情失败, " + err.Error()))
+		return nil, errors.New("获取Pv详情失败, " + err.Error())
+	}
+
+	return pv, nil
+}
+
+func (p *pv) DeletePv(pvName string) (err error) {
+	err = K8s.ClientSet.CoreV1().PersistentVolumes().Delete(context.TODO(), pvName, metav1.DeleteOptions{})
+	if err != nil {
+		logger.Error(errors.New("删除Pv失败, " + err.Error()))
+		return errors.New("删除Pv失败, " + err.Error())
+	}
+
+	return nil
+}
+
+func (p *pv) toCells(std []corev1.PersistentVolume) []DataCell {
+	cells := make([]DataCell, len(std))
+	for i := range std {
+		cells[i] = pvCell(std[i])
+	}
+	return cells
+}
+
+func (p *pv) fromCells(cells []DataCell) []corev1.PersistentVolume {
+	pvs := make([]corev1.PersistentVolume, len(cells))
+	for i := range cells {
+		pvs[i] = corev1.PersistentVolume(cells[i].(pvCell))
+	}
+
+	return pvs
+}

service/pvc.go

@@ -0,0 +1,101 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"github.com/wonderivan/logger"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var Pvc pvc
+
+type pvc struct{}
+
+type PvcsResp struct {
+	Items []corev1.PersistentVolumeClaim `json:"items"`
+	Total int                            `json:"total"`
+}
+
+func (p *pvc) GetPvcs(filterName, namespace string, limit, page int) (pvcsResp *PvcsResp, err error) {
+	pvcList, err := K8s.ClientSet.CoreV1().PersistentVolumeClaims(namespace).List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Pvc列表失败, " + err.Error()))
+		return nil, errors.New("获取Pvc列表失败, " + err.Error())
+	}
+	selectableData := &dataSelector{
+		GenericDataList: p.toCells(pvcList.Items),
+		DataSelect: &DataSelectQuery{
+			Filter: &FilterQuery{Name: filterName},
+			Paginate: &PaginateQuery{
+				Limit: limit,
+				Page:  page,
+			},
+		},
+	}
+
+	filtered := selectableData.Filter()
+	total := len(filtered.GenericDataList)
+	data := filtered.Sort().Paginate()
+	pvcs := p.fromCells(data.GenericDataList)
+
+	return &PvcsResp{
+		Items: pvcs,
+		Total: total,
+	}, nil
+}
+
+func (p *pvc) GetPvcDetail(pvcName, namespace string) (pvc *corev1.PersistentVolumeClaim, err error) {
+	pvc, err = K8s.ClientSet.CoreV1().PersistentVolumeClaims(namespace).Get(context.TODO(), pvcName, metav1.GetOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Pvc详情失败, " + err.Error()))
+		return nil, errors.New("获取Pvc详情失败, " + err.Error())
+	}
+
+	return pvc, nil
+}
+
+func (p *pvc) DeletePvc(pvcName, namespace string) (err error) {
+	err = K8s.ClientSet.CoreV1().PersistentVolumeClaims(namespace).Delete(context.TODO(), pvcName, metav1.DeleteOptions{})
+	if err != nil {
+		logger.Error(errors.New("删除Pvc失败, " + err.Error()))
+		return errors.New("删除Pvc失败, " + err.Error())
+	}
+
+	return nil
+}
+
+func (p *pvc) UpdatePvc(namespace, content string) (err error) {
+	var pvc = &corev1.PersistentVolumeClaim{}
+
+	err = json.Unmarshal([]byte(content), pvc)
+	if err != nil {
+		logger.Error(errors.New("反序列化失败, " + err.Error()))
+		return errors.New("反序列化失败, " + err.Error())
+	}
+
+	_, err = K8s.ClientSet.CoreV1().PersistentVolumeClaims(namespace).Update(context.TODO(), pvc, metav1.UpdateOptions{})
+	if err != nil {
+		logger.Error(errors.New("更新Pvc失败, " + err.Error()))
+		return errors.New("更新Pvc失败, " + err.Error())
+	}
+	return nil
+}
+
+func (p *pvc) toCells(std []corev1.PersistentVolumeClaim) []DataCell {
+	cells := make([]DataCell, len(std))
+	for i := range std {
+		cells[i] = pvcCell(std[i])
+	}
+	return cells
+}
+
+func (p *pvc) fromCells(cells []DataCell) []corev1.PersistentVolumeClaim {
+	pvcs := make([]corev1.PersistentVolumeClaim, len(cells))
+	for i := range cells {
+		pvcs[i] = corev1.PersistentVolumeClaim(cells[i].(pvcCell))
+	}
+
+	return pvcs
+}

service/secret.go

@@ -0,0 +1,100 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"github.com/wonderivan/logger"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var Secret secret
+
+type secret struct{}
+
+type SecretsResp struct {
+	Items []corev1.Secret `json:"items"`
+	Total int             `json:"total"`
+}
+
+func (s *secret) GetSecrets(filterName, namespace string, limit, page int) (secretsResp *SecretsResp, err error) {
+	secretList, err := K8s.ClientSet.CoreV1().Secrets(namespace).List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Secret列表失败, " + err.Error()))
+		return nil, errors.New("获取Secret列表失败, " + err.Error())
+	}
+	selectableData := &dataSelector{
+		GenericDataList: s.toCells(secretList.Items),
+		DataSelect: &DataSelectQuery{
+			Filter: &FilterQuery{Name: filterName},
+			Paginate: &PaginateQuery{
+				Limit: limit,
+				Page:  page,
+			},
+		},
+	}
+
+	filtered := selectableData.Filter()
+	total := len(filtered.GenericDataList)
+	data := filtered.Sort().Paginate()
+	secrets := s.fromCells(data.GenericDataList)
+	return &SecretsResp{
+		Items: secrets,
+		Total: total,
+	}, nil
+}
+
+func (s *secret) GetSecretDetail(secretName, namespace string) (secret *corev1.Secret, err error) {
+	secret, err = K8s.ClientSet.CoreV1().Secrets(namespace).Get(context.TODO(), secretName, metav1.GetOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取Secret详情失败, " + err.Error()))
+		return nil, errors.New("获取Secret详情失败, " + err.Error())
+	}
+
+	return secret, nil
+}
+
+func (s *secret) DeleteSecret(secretName, namespace string) (err error) {
+	err = K8s.ClientSet.CoreV1().Secrets(namespace).Delete(context.TODO(), secretName, metav1.DeleteOptions{})
+	if err != nil {
+		logger.Error(errors.New("删除Secret失败, " + err.Error()))
+		return errors.New("删除Secret失败, " + err.Error())
+	}
+
+	return nil
+}
+
+func (s *secret) UpdateSecret(namespace, content string) (err error) {
+	var secret = &corev1.Secret{}
+
+	err = json.Unmarshal([]byte(content), secret)
+	if err != nil {
+		logger.Error(errors.New("反序列化失败, " + err.Error()))
+		return errors.New("反序列化失败, " + err.Error())
+	}
+
+	_, err = K8s.ClientSet.CoreV1().Secrets(namespace).Update(context.TODO(), secret, metav1.UpdateOptions{})
+	if err != nil {
+		logger.Error(errors.New("更新Secret失败, " + err.Error()))
+		return errors.New("更新Secret失败, " + err.Error())
+	}
+	return nil
+}
+
+func (s *secret) toCells(std []corev1.Secret) []DataCell {
+	cells := make([]DataCell, len(std))
+	for i := range std {
+		cells[i] = secretCell(std[i])
+	}
+	return cells
+}
+
+func (s *secret) fromCells(cells []DataCell) []corev1.Secret {
+	secrets := make([]corev1.Secret, len(cells))
+	for i := range cells {
+		secrets[i] = corev1.Secret(cells[i].(secretCell))
+	}
+
+	return secrets
+}

service/service.go

@@ -29,7 +29,6 @@ type ServiceCreate struct {
 	Label         map[string]string `json:"label"`
 }
 
-//获取service列表，支持过滤、排序、分页
 func (s *servicev1) GetServices(filterName, namespace string, limit, page int) (servicesResp *ServicesResp, err error) {
 	serviceList, err := K8s.ClientSet.CoreV1().Services(namespace).List(context.TODO(), metav1.ListOptions{})
 	if err != nil {
@@ -50,8 +49,6 @@ func (s *servicev1) GetServices(filterName, namespace string, limit, page int) (
 	filtered := selectableData.Filter()
 	total := len(filtered.GenericDataList)
 	data := filtered.Sort().Paginate()
-
-	//将[]DataCell类型的service列表转为v1.service列表
 	services := s.fromCells(data.GenericDataList)
 
 	return &ServicesResp{
@@ -60,7 +57,6 @@ func (s *servicev1) GetServices(filterName, namespace string, limit, page int) (
 	}, nil
 }
 
-//获取service详情
 func (s *servicev1) GetServicetDetail(serviceName, namespace string) (service *corev1.Service, err error) {
 	service, err = K8s.ClientSet.CoreV1().Services(namespace).Get(context.TODO(), serviceName, metav1.GetOptions{})
 	if err != nil {
@@ -73,13 +69,11 @@ func (s *servicev1) GetServicetDetail(serviceName, namespace string) (service *c
 
 func (s *servicev1) CreateService(data *ServiceCreate) (err error) {
 	service := &corev1.Service{
-		//ObjectMeta中定义资源名、命名空间以及标签
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      data.Name,
 			Namespace: data.Namespace,
 			Labels:    data.Label,
 		},
-
 		Spec: corev1.ServiceSpec{
 			Type: corev1.ServiceType(data.Type),
 			Ports: []corev1.ServicePort{
@@ -99,7 +93,6 @@ func (s *servicev1) CreateService(data *ServiceCreate) (err error) {
 	if data.NodePort != 0 && data.Type == "NodePort" {
 		service.Spec.Ports[0].NodePort = data.NodePort
 	}
-	//创建Service
 	_, err = K8s.ClientSet.CoreV1().Services(data.Namespace).Create(context.TODO(), service, metav1.CreateOptions{})
 	if err != nil {
 		logger.Error(errors.New("创建Service失败, " + err.Error()))
@@ -109,7 +102,6 @@ func (s *servicev1) CreateService(data *ServiceCreate) (err error) {
 	return nil
 }
 
-//删除service
 func (s *servicev1) DeleteService(serviceName, namespace string) (err error) {
 	err = K8s.ClientSet.CoreV1().Services(namespace).Delete(context.TODO(), serviceName, metav1.DeleteOptions{})
 	if err != nil {
@@ -120,7 +112,6 @@ func (s *servicev1) DeleteService(serviceName, namespace string) (err error) {
 	return nil
 }
 
-//更新service
 func (s *servicev1) UpdateService(namespace, content string) (err error) {
 	var service = &corev1.Service{}
 

service/statefulset.go

@@ -0,0 +1,101 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"github.com/wonderivan/logger"
+	appsv1 "k8s.io/api/apps/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+var StatefulSet statefulSet
+
+type statefulSet struct{}
+
+type StatusfulSetsResp struct {
+	Items []appsv1.StatefulSet `json:"items"`
+	Total int                  `json:"total"`
+}
+
+func (s *statefulSet) GetStatefulSets(filterName, namespace string, limit, page int) (statusfulSetsResp *StatusfulSetsResp, err error) {
+	statefulSetList, err := K8s.ClientSet.AppsV1().StatefulSets(namespace).List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取StatefulSet列表失败, " + err.Error()))
+		return nil, errors.New("获取StatefulSet列表失败, " + err.Error())
+	}
+	selectableData := &dataSelector{
+		GenericDataList: s.toCells(statefulSetList.Items),
+		DataSelect: &DataSelectQuery{
+			Filter: &FilterQuery{Name: filterName},
+			Paginate: &PaginateQuery{
+				Limit: limit,
+				Page:  page,
+			},
+		},
+	}
+
+	filtered := selectableData.Filter()
+	total := len(filtered.GenericDataList)
+	data := filtered.Sort().Paginate()
+	statefulSets := s.fromCells(data.GenericDataList)
+
+	return &StatusfulSetsResp{
+		Items: statefulSets,
+		Total: total,
+	}, nil
+}
+
+func (s *statefulSet) GetStatefulSetDetail(statefulSetName, namespace string) (statefulSet *appsv1.StatefulSet, err error) {
+	statefulSet, err = K8s.ClientSet.AppsV1().StatefulSets(namespace).Get(context.TODO(), statefulSetName, metav1.GetOptions{})
+	if err != nil {
+		logger.Error(errors.New("获取StatefulSet详情失败, " + err.Error()))
+		return nil, errors.New("获取StatefulSet详情失败, " + err.Error())
+	}
+
+	return statefulSet, nil
+}
+
+func (s *statefulSet) DeleteStatefulSet(statefulSetName, namespace string) (err error) {
+	err = K8s.ClientSet.AppsV1().StatefulSets(namespace).Delete(context.TODO(), statefulSetName, metav1.DeleteOptions{})
+	if err != nil {
+		logger.Error(errors.New("删除StatefulSet失败, " + err.Error()))
+		return errors.New("删除StatefulSet失败, " + err.Error())
+	}
+
+	return nil
+}
+
+func (s *statefulSet) UpdateStatefulSet(namespace, content string) (err error) {
+	var statefulSet = &appsv1.StatefulSet{}
+
+	err = json.Unmarshal([]byte(content), statefulSet)
+	if err != nil {
+		logger.Error(errors.New("反序列化失败, " + err.Error()))
+		return errors.New("反序列化失败, " + err.Error())
+	}
+
+	_, err = K8s.ClientSet.AppsV1().StatefulSets(namespace).Update(context.TODO(), statefulSet, metav1.UpdateOptions{})
+	if err != nil {
+		logger.Error(errors.New("更新StatefulSet失败, " + err.Error()))
+		return errors.New("更新StatefulSet失败, " + err.Error())
+	}
+	return nil
+}
+
+func (s *statefulSet) toCells(std []appsv1.StatefulSet) []DataCell {
+	cells := make([]DataCell, len(std))
+	for i := range std {
+		cells[i] = statefulSetCell(std[i])
+	}
+	return cells
+}
+
+func (s *statefulSet) fromCells(cells []DataCell) []appsv1.StatefulSet {
+	statefulSets := make([]appsv1.StatefulSet, len(cells))
+	for i := range cells {
+		statefulSets[i] = appsv1.StatefulSet(cells[i].(statefulSetCell))
+	}
+
+	return statefulSets
+}

service/terminal.go

@@ -0,0 +1,175 @@
+package service
+
+import (
+	"dkube/config"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/gorilla/websocket"
+	"github.com/wonderivan/logger"
+	v1 "k8s.io/api/core/v1"
+	"k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/client-go/tools/remotecommand"
+	"log"
+	"net/http"
+	"time"
+)
+
+var Terminal terminal
+
+type terminal struct{}
+
+func (t *terminal) WsHandler(w http.ResponseWriter, r *http.Request) {
+	conf, err := clientcmd.BuildConfigFromFlags("", config.Kubeconfig)
+	if err != nil {
+		logger.Error("加载k8s配置失败, " + err.Error())
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		logger.Error("解析参数失败, " + err.Error())
+		return
+	}
+	namespace := r.Form.Get("namespace")
+	podName := r.Form.Get("pod_name")
+	containerName := r.Form.Get("container_name")
+	logger.Info("exec pod: %s, container: %s, namespace: %s\n", podName, containerName, namespace)
+
+	pty, err := NewTerminalSession(w, r, nil)
+	if err != nil {
+		logger.Error("实例化TerminalSession失败, " + err.Error())
+		return
+	}
+	defer func() {
+		logger.Info("关闭TerminalSession")
+		pty.Close()
+	}()
+	req := K8s.ClientSet.CoreV1().RESTClient().Post().
+		Resource("pods").
+		Name(podName).
+		Namespace(namespace).
+		SubResource("exec").
+		VersionedParams(&v1.PodExecOptions{
+			Stdin:     true,
+			Stdout:    true,
+			Stderr:    true,
+			TTY:       true,
+			Container: containerName,
+			Command:   []string{"/bin/bash"},
+		}, scheme.ParameterCodec)
+	logger.Info("exec post request url: ", req)
+
+	executor, err := remotecommand.NewSPDYExecutor(conf, "POST", req.URL())
+	if err != nil {
+		logger.Error("建立SPDY连接失败, " + err.Error())
+		return
+	}
+	err = executor.Stream(remotecommand.StreamOptions{
+		Stdin:             pty,
+		Stdout:            pty,
+		Stderr:            pty,
+		Tty:               true,
+		TerminalSizeQueue: pty,
+	})
+
+	if err != nil {
+		logger.Error("执行 pod 命令失败, " + err.Error())
+		pty.Write([]byte("执行 pod 命令失败, " + err.Error()))
+		pty.Done()
+	}
+}
+
+type terminalMessage struct {
+	Operation string `json:"operation"`
+	Data      string `json:"data"`
+	Rows      uint16 `json:"rows"`
+	Cols      uint16 `json:"cols"`
+}
+
+type TerminalSession struct {
+	wsConn   *websocket.Conn
+	sizeChan chan remotecommand.TerminalSize
+	doneChan chan struct{}
+}
+
+var upgrader = func() websocket.Upgrader {
+	upgrader := websocket.Upgrader{}
+	upgrader.HandshakeTimeout = time.Second * 2
+	upgrader.CheckOrigin = func(r *http.Request) bool {
+		return true
+	}
+	return upgrader
+}()
+
+func NewTerminalSession(w http.ResponseWriter, r *http.Request, responseHeader http.Header) (*TerminalSession, error) {
+	conn, err := upgrader.Upgrade(w, r, responseHeader)
+	if err != nil {
+		return nil, errors.New("升级websocket失败," + err.Error())
+	}
+	session := &TerminalSession{
+		wsConn:   conn,
+		sizeChan: make(chan remotecommand.TerminalSize),
+		doneChan: make(chan struct{}),
+	}
+
+	return session, nil
+}
+
+func (t *TerminalSession) Read(p []byte) (int, error) {
+	_, message, err := t.wsConn.ReadMessage()
+	if err != nil {
+		log.Printf("read message err: %v", err)
+		return 0, err
+	}
+	var msg terminalMessage
+	if err := json.Unmarshal(message, &msg); err != nil {
+		log.Printf("read parse message err: %v", err)
+		return 0, err
+	}
+	switch msg.Operation {
+	case "stdin":
+		return copy(p, msg.Data), nil
+	case "resize":
+		t.sizeChan <- remotecommand.TerminalSize{Width: msg.Cols, Height: msg.Rows}
+		return 0, nil
+	case "ping":
+		return 0, nil
+	default:
+		log.Printf("unknown message type '%s'", msg.Operation)
+		return 0, fmt.Errorf("unknown message type '%s'", msg.Operation)
+	}
+}
+
+func (t *TerminalSession) Write(p []byte) (int, error) {
+	msg, err := json.Marshal(terminalMessage{
+		Operation: "stdout",
+		Data:      string(p),
+	})
+	if err != nil {
+		log.Printf("write parse message err: %v", err)
+		return 0, err
+	}
+	if err := t.wsConn.WriteMessage(websocket.TextMessage, msg); err != nil {
+		log.Printf("write message err: %v", err)
+		return 0, err
+	}
+
+	return len(p), nil
+}
+
+func (t *TerminalSession) Done() {
+	close(t.doneChan)
+}
+
+func (t *TerminalSession) Close() {
+	t.wsConn.Close()
+}
+
+func (t *TerminalSession) Next() *remotecommand.TerminalSize {
+	select {
+	case size := <-t.sizeChan:
+		return &size
+	case <-t.doneChan:
+		return nil
+	}
+}

service/workflow.go

@@ -0,0 +1,167 @@
+package service
+
+import (
+	"dkube/dao"
+	"dkube/model"
+)
+
+var Workflow workflow
+
+type workflow struct{}
+
+type WorkflowCreate struct {
+	Name          string                 `json:"name"`
+	Namespace     string                 `json:"namespace"`
+	Replicas      int32                  `json:"replicas"`
+	Image         string                 `json:"image"`
+	Label         map[string]string      `json:"label"`
+	Cpu           string                 `json:"cpu"`
+	Memory        string                 `json:"memory"`
+	ContainerPort int32                  `json:"container_port"`
+	HealthCheck   bool                   `json:"health_check"`
+	HealthPath    string                 `json:"health_path"`
+	Type          string                 `json:"type"`
+	Port          int32                  `json:"port"`
+	NodePort      int32                  `json:"node_port"`
+	Hosts         map[string][]*HttpPath `json:"hosts"`
+}
+
+func (w *workflow) GetList(name, namespace string, page, limit int) (data *dao.WorkflowResp, err error) {
+	data, err = dao.Workflow.GetWorkflows(name, namespace, page, limit)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+func (w *workflow) GetById(id int) (data *model.Workflow, err error) {
+	data, err = dao.Workflow.GetById(id)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+func (w *workflow) CreateWorkFlow(data *WorkflowCreate) (err error) {
+	var ingressName string
+	if data.Type == "Ingress" {
+		ingressName = getIngressName(data.Name)
+	} else {
+		ingressName = ""
+	}
+
+	workflow := &model.Workflow{
+		Name:       data.Name,
+		Namespace:  data.Namespace,
+		Replicas:   data.Replicas,
+		Deployment: data.Name,
+		Service:    getServiceName(data.Name),
+		Ingress:    ingressName,
+		Type:       data.Type,
+	}
+	err = dao.Workflow.Add(workflow)
+	if err != nil {
+		return err
+	}
+	err = createWorkflowRes(data)
+	if err != nil {
+		return err
+	}
+	return err
+}
+
+func (w *workflow) DelById(id int) (err error) {
+	workflow, err := dao.Workflow.GetById(id)
+	if err != nil {
+		return err
+	}
+	err = delWorkflowRes(workflow)
+	if err != nil {
+		return err
+	}
+	err = dao.Workflow.DelById(id)
+	if err != nil {
+		return err
+	}
+	return
+}
+
+func delWorkflowRes(workflow *model.Workflow) (err error) {
+	err = Deployment.DeleteDeployment(workflow.Name, workflow.Namespace)
+	if err != nil {
+		return err
+	}
+	err = Servicev1.DeleteService(getServiceName(workflow.Name), workflow.Namespace)
+	if err != nil {
+		return err
+	}
+
+	if workflow.Type == "Ingress" {
+		err = Ingress.DeleteIngress(getIngressName(workflow.Name), workflow.Namespace)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func createWorkflowRes(data *WorkflowCreate) (err error) {
+	dc := &DeployCreate{
+		Name:          data.Name,
+		Namespace:     data.Namespace,
+		Replicas:      data.Replicas,
+		Image:         data.Image,
+		Label:         data.Label,
+		Cpu:           data.Cpu,
+		Memory:        data.Memory,
+		ContainerPort: data.ContainerPort,
+		HealthCheck:   data.HealthCheck,
+		HealthPath:    data.HealthPath,
+	}
+	err = Deployment.CreateDeployment(dc)
+	if err != nil {
+		return err
+	}
+	var serviceType string
+	if data.Type != "Ingress" {
+		serviceType = data.Type
+	} else {
+		serviceType = "ClusterIP"
+	}
+	sc := &ServiceCreate{
+		Name:          getServiceName(data.Name),
+		Namespace:     data.Namespace,
+		Type:          serviceType,
+		ContainerPort: data.ContainerPort,
+		Port:          data.Port,
+		NodePort:      data.NodePort,
+		Label:         data.Label,
+	}
+	if err := Servicev1.CreateService(sc); err != nil {
+		return err
+	}
+	var ic *IngressCreate
+	if data.Type == "Ingress" {
+		ic = &IngressCreate{
+			Name:      getIngressName(data.Name),
+			Namespace: data.Namespace,
+			Label:     data.Label,
+			Hosts:     data.Hosts,
+		}
+		err = Ingress.CreateIngress(ic)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func getServiceName(workflowName string) (serviceName string) {
+	return workflowName + "-svc"
+}
+
+func getIngressName(workflowName string) (ingressName string) {
+	return workflowName + "-ing"
+}