docker k8s二次开发(二)api的实现

package k8sengine

import (
	"errors"
	"io"
	"net/http"

	restful "github.com/emicklei/go-restful"
	restclient "k8s.io/client-go/rest"
	client "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"

	"wdcp-build/apiserver/options"
	"wdcp-build/pkg/api/unversioned"
	"wdcp-build/pkg/db"
	"wdcp-build/pkg/util"

	"github.com/golang/glog"
	utilerrors "k8s.io/apimachinery/pkg/util/errors"
)

type K8sCli struct {
	k8sParam     unversioned.K8sParam
	k8sRunOption *options.ServerRunOptions
}

func CreateK8sHandler(request *restful.Request, response *restful.Response) {
	param := new(unversioned.K8sParam)
	err := request.ReadEntity(¶m)
	if err != nil {
		response.WriteError(http.StatusInternalServerError, err)
	}

	glog.Info("createK8sHandler>>>%s", param)
	glog.Info("createK8sHandler>>>%s", param.Protocol)
	glog.Info("createK8sHandler>>>%s", param.TargetPort)
	k8sCli := K8sCli{
		k8sParam:     *param,
		k8sRunOption: util.RunOption,
	}

	var kubeClient *client.Clientset
	kubeOption, err := util.GetKubeConfig(param.ClusterLevel)
	kubeClient = client.NewForConfigOrDie(&restclient.Config{
		Host: *kubeOption.KubeProxyURL,
	})

	if k8sCli.k8sParam.IsStateful {
		err = k8sCli.CreateKubeStatefulSet(kubeClient)
		if err != nil {
			apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
			io.WriteString(response, apiResponse)
			return
		}
	} else {
		err = k8sCli.CreateKubeDeployment(kubeClient)
		if err != nil {
			apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
			io.WriteString(response, apiResponse)
			return
		}
	}

	if err = k8sCli.CreateKubeService(kubeClient); err != nil {
		if k8sCli.k8sParam.IsStateful {
			k8sCli.DeleteKubeStatefulSet(kubeClient)
		} else {
			k8sCli.DeleteKubeDeployment(kubeClient)
		}
		apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
		io.WriteString(response, apiResponse)

		return
	}

	var mappingPort int32
	glog.Info("create_k8s_handler_post>>%s", param)
	if mappingPort, err = GenMappingPort(param); err != nil || mappingPort == 0 {
		if k8sCli.k8sParam.IsStateful {
			k8sCli.DeleteKubeStatefulSet(kubeClient)
		} else {
			k8sCli.DeleteKubeDeployment(kubeClient)
		}
		k8sCli.DeleteKubeService(kubeClient)
		if err != nil {
			glog.Error("genMappingPort err:%s", err)
			apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
			io.WriteString(response, apiResponse)
		}
		if mappingPort == 0 {
			err = errors.New("mapping port is 0")
			glog.Error("genMappingPort err:%s", err)
			apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
			io.WriteString(response, apiResponse)
		}

		return
	}
	k8sCli.k8sParam.ServicePort = mappingPort
	if err = k8sCli.CreateKubeIngress(mappingPort, kubeClient); err != nil {
		if k8sCli.k8sParam.IsStateful {
			k8sCli.DeleteKubeStatefulSet(kubeClient)
		} else {
			k8sCli.DeleteKubeDeployment(kubeClient)
		}
		k8sCli.DeleteKubeService(kubeClient)

		apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
		io.WriteString(response, apiResponse)

		return
	}

	apiK8sResponse := util.ApiK8sResponse(unversioned.RetCodeSuccess, unversioned.RetMsgSuccess, k8sCli.k8sParam.ServicePort, k8sCli.k8sParam.IngressClusterConfig)
	io.WriteString(response, apiK8sResponse)

}

func UpdateK8sHandler(request *restful.Request, response *restful.Response) {
	param := new(unversioned.K8sParam)
	err := request.ReadEntity(¶m)
	if err != nil {
		response.WriteError(http.StatusInternalServerError, err)
	}
	k8sCli := K8sCli{
		k8sParam:     *param,
		k8sRunOption: util.RunOption,
	}

	var kubeClient *client.Clientset
	kubeOption, err := util.GetKubeConfig(param.ClusterLevel)
	kubeClient = client.NewForConfigOrDie(&restclient.Config{
		Host: *kubeOption.KubeProxyURL,
	})

	if k8sCli.k8sParam.IsStateful {
		err = k8sCli.UpdateKubeStatefulSet(kubeClient)
	} else {
		err = k8sCli.UpdateKubeDeployment(kubeClient)
	}

	if err != nil {
		apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
		io.WriteString(response, apiResponse)

		return
	}
	if err = k8sCli.UpdateKubeService(kubeClient); err != nil {
		apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
		io.WriteString(response, apiResponse)

		return
	}

	var mappingPort int32
	glog.Info("create_k8s_handler_put>>%s", param)
	if mappingPort, err = GenMappingPort(param); err != nil {
		apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
		io.WriteString(response, apiResponse)

		return
	}
	k8sCli.k8sParam.ServicePort = mappingPort
	if err = k8sCli.UpdateKubeIngress(mappingPort, kubeClient); err != nil {
		apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
		io.WriteString(response, apiResponse)

		return
	}
	apiK8sResponse := util.ApiK8sResponse(unversioned.RetCodeSuccess, unversioned.RetMsgSuccess, k8sCli.k8sParam.ServicePort, k8sCli.k8sParam.IngressClusterConfig)
	io.WriteString(response, apiK8sResponse)

}

func DeleteHandler(request *restful.Request, response *restful.Response) {
	param := new(unversioned.K8sParam)
	err := request.ReadEntity(¶m)
	if err != nil {
		response.WriteError(http.StatusInternalServerError, err)
	}
	k8sCli := K8sCli{
		k8sParam:     *param,
		k8sRunOption: util.RunOption,
	}

	var kubeClient *client.Clientset
	kubeOption, err := util.GetKubeConfig(param.ClusterLevel)
	kubeClient = client.NewForConfigOrDie(&restclient.Config{
		Host: *kubeOption.KubeProxyURL,
	})
	errs := make([]error, 0)
	if k8sCli.k8sParam.IsStateful {
		err = k8sCli.DeleteKubeStatefulSet(kubeClient)
	} else {
		err = k8sCli.DeleteKubeDeployment(kubeClient)
	}

	if err != nil {
		errs = append(errs, err)

	}
	err = k8sCli.DeleteKubeService(kubeClient)
	if err != nil {
		errs = append(errs, err)
	}
	err = k8sCli.DeleteKubeIngress(kubeClient)
	if err != nil {
		errs = append(errs, err)
	}

	err = utilerrors.NewAggregate(errs)

	if err != nil {
		apiResponse := util.ApiResponse(unversioned.RetCodeFailed, err.Error(), []db.TaskEventLog{})
		io.WriteString(response, apiResponse)
		return
	}

	apiK8sResponse := util.ApiResponse(unversioned.RetCodeSuccess, unversioned.RetMsgSuccess, []db.TaskEventLog{})
	io.WriteString(response, apiK8sResponse)

}

func GetDeploymentHandler(request *restful.Request, response *restful.Response) {
	cluster_level := request.PathParameter("cluster_level")
	namespace := request.PathParameter("tenant")
	project_name := request.PathParameter("project_name")
	param := &unversioned.K8sParam{
		NameSpace:    namespace,
		ClusterLevel: cluster_level,
		ProjectName:  project_name,
	}

	k8sCli := K8sCli{
		k8sParam:     *param,
		k8sRunOption: util.RunOption,
	}

	var kubeClient *client.Clientset
	kubeOption, err := util.GetKubeConfig(param.ClusterLevel)
	kubeClient = client.NewForConfigOrDie(&restclient.Config{
		Host: *kubeOption.KubeProxyURL,
	})

	deployment, err := k8sCli.GetKubeDeployment(kubeClient)
	if err != nil {
		apiResponse := util.ApiDeploymentResponse(unversioned.RetCodeFailed, err.Error(), deployment)
		io.WriteString(response, apiResponse)
		return
	}
	apiResponse := util.ApiDeploymentResponse(unversioned.RetCodeSuccess, unversioned.RetMsgSuccess, deployment)
	io.WriteString(response, apiResponse)
	return

}

func GetStatefulSetHandler(request *restful.Request, response *restful.Response) {
	cluster_level := request.PathParameter("cluster_level")
	namespace := request.PathParameter("tenant")
	project_name := request.PathParameter("project_name")
	param := &unversioned.K8sParam{
		NameSpace:    namespace,
		ClusterLevel: cluster_level,
		ProjectName:  project_name,
	}

	k8sCli := K8sCli{
		k8sParam:     *param,
		k8sRunOption: util.RunOption,