StorageClass管理 原创

1、功能

2、类型转换

2.1、实现类型转换

在 internal/pkg/k8s/storageclass/common.go 文件中新增 StorageClassCell，实现和 storagev1.StorageClassCell 进行类型转换，如下：

package storageclass

import (
	storagev1 "k8s.io/api/storage/v1"
	"time"

	"github.com/joker-bai/hawkeye/internal/pkg/k8s/dataselect"
)

type StorageClassCell storagev1.StorageClass

func (p StorageClassCell) GetCreation() time.Time {
	return p.CreationTimestamp.Time
}

func (p StorageClassCell) GetName() string {
	return p.Name
}

// toCells storagev1.StorageClass 类型 转换成 DataCell 类型
// @description: StorageClass类型转换成DataCell
func toCells(sts []storagev1.StorageClass) []dataselect.DataCell {
	cells := make([]dataselect.DataCell, len(sts))
	for i := range sts {
		cells[i] = StorageClassCell(sts[i])
	}
	return cells
}

// fromCells DataCell 类型转换成 batchv1.StorageClass 类型
// @description: DataCell类型转换成StorageClass
func fromCells(cells []dataselect.DataCell) []storagev1.StorageClass {
	ds := make([]storagev1.StorageClass, len(cells))
	for i := range cells {
		ds[i] = storagev1.StorageClass(cells[i].(StorageClassCell))
	}
	return ds
}

2.2、实现增删改查

（1）在 internal/pkg/k8s/storageclass/delete.go 中创建以下内容，用户删除 storageclass

package storageclass

import (
	"context"
	"github.com/joker-bai/hawkeye/global"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func DeleteStorageClass(name string) error {
	return global.K8S.StorageV1().StorageClasses().Delete(context.TODO(), name, metav1.DeleteOptions{})
}

（2）在 internal/pkg/k8s/storageclass/list.go 中创建以下内容，用于列出 storageclass 列表

package storageclass

import (
	"context"
	"github.com/joker-bai/hawkeye/global"
	"github.com/joker-bai/hawkeye/internal/pkg/k8s/dataselect"
	storagev1 "k8s.io/api/storage/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func ListStorageClass(name string, page, limit int) ([]storagev1.StorageClass, error) {
	global.Log.Info("获取ingress的列表")
	list, err := global.K8S.StorageV1().StorageClasses().List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		return nil, err
	}

	// 做排序
	selector := dataselect.DataSelector{
		GenericDataList: toCells(list.Items),
		DataSelectQuery: &dataselect.DataSelectQuery{
			Filter: &dataselect.FilterQuery{
				Name: name,
			},
			Paginate: &dataselect.PaginateQuery{
				Limit: limit,
				Page:  page,
			},
		},
	}

	filted := selector.Filter()
	data := filted.Sort().Paginate()
	return fromCells(data.GenericDataList), nil
}

（3）在 internal/pkg/k8s/storageclass/update.go 中创建以下内容，用于更新 storageclass

package storageclass

import (
	"context"
	"encoding/json"
	"github.com/joker-bai/hawkeye/global"
	storagev1 "k8s.io/api/storage/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func UpdateStorageClass(content string) error {
	var sts storagev1.StorageClass
	if err := json.Unmarshal([]byte(content), &sts); err != nil {
		return err
	}

	if _, err := global.K8S.StorageV1().StorageClasses().Update(context.TODO(), &sts, metav1.UpdateOptions{}); err != nil {
		return err
	}

	return nil
}

（4）在 internal/pkg/k8s/storageclass/detail.go 中创建以下内容，用于获取 storageclass 详情

package storageclass

import (
	"context"
	"github.com/joker-bai/hawkeye/global"
	storagev1 "k8s.io/api/storage/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func GetStorageClassDetail(name string) (*storagev1.StorageClass, error) {
	sts, err := global.K8S.StorageV1().StorageClasses().Get(context.TODO(), name, metav1.GetOptions{})
	if err != nil {
		return nil, err
	}
	return sts, nil
}

3、实现 services 方法

3.1、请求参数校验

在 internal/app/requests 目录中新建 k8s_storageclass.go 文件，写入以下内容以完成请求参数校验：

package requests

import (
	"github.com/gin-gonic/gin"
	"github.com/joker-bai/hawkeye/pkg/app"
	"github.com/thedevsaddam/govalidator"
)

type K8sStorageClassUpdateRequest struct {
	Namespace string `json:"namespace" form:"namespace" valid:"namespace"`
	Content   string `json:"content" form:"content" valid:"content"`
}

func ValidK8sStorageClassUpdateRequest(data interface{}, ctx *gin.Context) map[string][]string {
	rules := govalidator.MapData{
		"namespace": []string{"required"},
		"content":   []string{"required"},
	}
	messages := govalidator.MapData{
		"namespace": []string{
			"required: namespace 不能为空",
		},
		"content": []string{
			"required: content 不能为空",
		},
	}

	// 校验入参

	return app.ValidateOptions(data, rules, messages)
}

type K8sStorageClassListRequest struct {
	K8sCommonRequest
	Page  int `json:"page" form:"page" valid:"page"`    // 页数
	Limit int `json:"limit" form:"limit" valid:"limit"` // 每页条数
}

func ValidK8sStorageClassListRequest(data interface{}, ctx *gin.Context) map[string][]string {
	rules := govalidator.MapData{
		"page":  []string{"required"},
		"limit": []string{"required"},
	}
	messages := govalidator.MapData{
		"page": []string{
			"required: page不能为空",
		},
		"limit": []string{
			"required: limit不能为空",
		},
	}

	// 校验入参

	return app.ValidateOptions(data, rules, messages)
}

3.2、实现 services 方法

在 internal/app/services/k8s_storageclass.go 文件中新增 StorageClass 操作的 services 方法，如下：

package services

import (
	"github.com/joker-bai/hawkeye/internal/app/requests"
	"github.com/joker-bai/hawkeye/internal/pkg/k8s/storageclass"
	storagev1 "k8s.io/api/storage/v1"
)

// StorageClass

func (s *Services) K8sStorageClassList(param *requests.K8sStorageClassListRequest) ([]storagev1.StorageClass, error) {
	return storageclass.ListStorageClass(param.Name, param.Page, param.Limit)
}

func (s *Services) K8sStorageClassDelete(param *requests.K8sCommonRequest) error {
	return storageclass.DeleteStorageClass(param.Name)
}

func (s *Services) K8sStorageClassUpdate(param *requests.K8sStorageClassUpdateRequest) error {
	return storageclass.UpdateStorageClass(param.Content)
}

func (s *Services) K8sStorageClassDetail(param *requests.K8sCommonRequest) (*storagev1.StorageClass, error) {
	return storageclass.GetStorageClassDetail(param.Name)
}

4、新增 controllers 方法

在 internal/app/controllers/api/v1/k8s 目录中新增 storageclass.go 文件，实现如下方法：

package k8s

import (
	"github.com/gin-gonic/gin"
	"github.com/joker-bai/hawkeye/global"
	"github.com/joker-bai/hawkeye/internal/app/requests"
	"github.com/joker-bai/hawkeye/internal/app/services"
	"github.com/joker-bai/hawkeye/pkg/app"
	"github.com/joker-bai/hawkeye/pkg/errorcode"
	"go.uber.org/zap"
)

type StorageClassController struct{}

// List godoc
// @Summary 列出K8s StorageClass
// @Description 列出K8s StorageClass
// @Tags K8s StorageClass管理
// @Produce json
// @Param name query string false "StorageClass名" maxlength(100)
// @Param namespace query string false "命名空间" maxlength(100)
// @Param page query int true "页码"
// @Param limit query int true "每页数量"
// @Success 200 {object} string "成功"
// @Failure 400 {object} errorcode.Error "请求错误"
// @Failure 500 {object} errorcode.Error "内部错误"
// @Router /api/v1/k8s/storageclass/list [get]
func (k *StorageClassController) List(ctx *gin.Context) {
	param := requests.K8sStorageClassListRequest{}
	response := app.NewResponse(ctx)

	if ok := app.Validate(ctx, &param, requests.ValidK8sStorageClassListRequest); !ok {
		return
	}

	svc := services.New(ctx)
	storageclasss, err := svc.K8sStorageClassList(&param)
	if err != nil {
		global.Log.Error("获取StorageClass列表失败", zap.String("error", err.Error()))
		response.ToErrorResponse(errorcode.ErrorK8sStorageClassListFail)
		return
	}

	response.ToResponseList(storageclasss, len(storageclasss))
}

// Update godoc
// @Summary 更新StorageClass
// @Description 更新StorageClass
// @Tags K8s StorageClass管理
// @Produce json
// @Param body body requests.K8sStorageClassUpdateRequest true "body"
// @Success 200 {object} string "成功"
// @Failure 400 {object} errorcode.Error "请求错误"
// @Failure 500 {object} errorcode.Error "内部错误"
// @Router /api/v1/k8s/storageclass/update [post]
func (k *StorageClassController) Update(ctx *gin.Context) {
	param := requests.K8sStorageClassUpdateRequest{}
	response := app.NewResponse(ctx)

	if ok := app.Validate(ctx, &param, requests.ValidK8sStorageClassUpdateRequest); !ok {
		return
	}

	svc := services.New(ctx)
	err := svc.K8sStorageClassUpdate(&param)
	if err != nil {
		global.Log.Error("更新StorageClass失败", zap.String("error", err.Error()))
		response.ToErrorResponse(errorcode.ErrorK8sStorageClassUpdateFail)
		return
	}

	response.ToResponse(gin.H{
		"msg": "StorageClass更新成功",
	})
}

// Delete godoc
// @Summary 删除StorageClass
// @Description 删除StorageClass
// @Tags K8s StorageClass管理
// @Produce json
// @Param body body requests.K8sCommonRequest true "body"
// @Success 200 {object} string "成功"
// @Failure 400 {object} errorcode.Error "请求错误"
// @Failure 500 {object} errorcode.Error "内部错误"
// @Router /api/v1/k8s/storageclass/delete [post]
func (k *StorageClassController) Delete(ctx *gin.Context) {
	param := requests.K8sCommonRequest{}
	response := app.NewResponse(ctx)

	if ok := app.Validate(ctx, &param, requests.ValidK8sCommonRequest); !ok {
		return
	}

	svc := services.New(ctx)
	err := svc.K8sStorageClassDelete(&param)
	if err != nil {
		global.Log.Error("删除StorageClasss失败", zap.String("error", err.Error()))
		response.ToErrorResponse(errorcode.ErrorK8sStorageClassDeleteFail)
		return
	}

	response.ToResponse(gin.H{
		"msg": "StorageClass删除成功",
	})
}

// Detail godoc
// @Summary 获取StorageClass的详情
// @Description 获取StorageClass的详情
// @Tags K8s StorageClass管理
// @Produce json
// @Param name query string false "StorageClass名" maxlength(100)
// @Param namespace query string false "命名空间" maxlength(100)
// @Success 200 {object} string "成功"
// @Failure 400 {object} errorcode.Error "请求错误"
// @Failure 500 {object} errorcode.Error "内部错误"
// @Router /api/v1/k8s/storageclass/detail [get]
func (k *StorageClassController) Detail(ctx *gin.Context) {
	param := requests.K8sCommonRequest{}
	response := app.NewResponse(ctx)

	if ok := app.Validate(ctx, &param, requests.ValidK8sCommonRequest); !ok {
		return
	}

	svc := services.New(ctx)
	storageclass, err := svc.K8sStorageClassDetail(&param)
	if err != nil {
		global.Log.Error("获取获取StorageClass的详情失败", zap.String("error", err.Error()))
		response.ToErrorResponse(errorcode.ErrorK8sStorageClassDetailFail)
		return
	}

	response.ToResponse(gin.H{
		"data": storageclass,
		"msg":  "获取StorageClass的详情成功",
	})
}

再到 pkg/errorcode/k8s.go 文件中新增如下错误代码：

package errorcode

var (
	......
	// K8s StorageClass 错误码

	ErrorK8sStorageClassUpdateFail = NewError(500111, "更新K8s StorageClass 失败")
	ErrorK8sStorageClassDeleteFail = NewError(500112, "删除K8s StorageClass 失败")
	ErrorK8sStorageClassListFail   = NewError(500113, "获取K8s StorageClass 列表失败")
	ErrorK8sStorageClassDetailFail = NewError(500114, "获取K8s StorageClass 详情失败")
)

5、新增路由

在 internal/app/routers/k8s.go 文件中新增 CronJob 操作的路由，如下：

package routers

import (
	"github.com/gin-gonic/gin"
	v1 "github.com/joker-bai/kubemana/internal/app/controllers/api/v1"
)

type K8sRouter struct{}

func (r *K8sRouter) Inject(router *gin.RouterGroup) {

	k8s := router.Group("/k8s")
	{
		......

		// StorageClass 管理
		scc := new(k8s.StorageClassController)
		ks.GET("/storageclass/list", scc.List)
		ks.POST("/storageclass/update", scc.Update)
		ks.POST("/storageclass/delete", scc.Delete)
		ks.GET("/storageclass/detail", scc.Detail)
	}
}

6、测试一下

PS：测试之前都需要先初始化集群，在 4.3.1 Pod 章节有介绍。

这里简单测试列出StorageClass接口，如下：

其他接口自行下去测试。

7、代码版本

本节开发完成后，记得生成 swag 和标记代码版本，如下：

$ swag init
$ git add .
$ git commit -m "新增k8s集群StorageClass操作"