func getNodeTopology(request *restful.Request, response *restful.Response) {
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
regionSlice, err := control.GetNodeTopology(kubeApiServerEndPoint, kubeApiServerToken)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get node topology failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
response.WriteJson(regionSlice, "[]Region")
}
func CreateCommand() (*slb.Command, error) {
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
log.Error(err)
return nil, err
}
command := &slb.Command{
time.Now(),
nil,
nil,
}
err = addCommandFromAllDeployInformation(command, kubeApiServerEndPoint, kubeApiServerToken)
if err != nil {
log.Error(err)
return nil, err
}
err = addCommandFromAllBlueGreenDeployment(command, kubeApiServerEndPoint, kubeApiServerToken)
if err != nil {
log.Error(err)
return nil, err
}
return command, nil
}
func deleteReplicationController(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
replicationController := request.PathParameter("replicationcontroller")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["replicationController"] = replicationController
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
err = control.DeleteReplicationControllerAndRelatedPod(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationController)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Delete replication controller failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["replicationController"] = replicationController
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func getReplicationControllerMetric(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
replicationControllerName := request.PathParameter("replicationcontroller")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["replicationControllerName"] = replicationControllerName
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
replicationControllerMetric, err := monitor.MonitorReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get replication controller metric failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["replicationControllerName"] = replicationControllerName
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
response.WriteJson(replicationControllerMetric, "ReplicationControllerMetric")
}
func deleteDeployClusterApplication(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
clusterApplication := request.PathParameter("clusterapplication")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["clusterApplication"] = clusterApplication
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
err = deploy.DeleteDeployClusterApplication(kubeApiServerEndPoint, kubeApiServerToken, namespace, clusterApplication)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Delete cluster application deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["clusterApplication"] = clusterApplication
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func getAllKubernetesService(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
serviceSlice, err := control.GetAllService(kubeApiServerEndPoint, kubeApiServerToken, namespace)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get all service failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
response.WriteJson(serviceSlice, "[]Service")
}
func getPodLog(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
pod := request.PathParameter("pod")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["pod"] = pod
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
logJsonMap, err := control.GetPodLog(kubeApiServerEndPoint, kubeApiServerToken, namespace, pod)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get pod log failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["pod"] = pod
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
response.WriteJson(logJsonMap, "{}")
}
func postLaunchStatelessApplication(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
name := request.PathParameter("statelessapplication")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["name"] = name
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
environmentSlice := make([]interface{}, 0)
err = request.ReadEntity(&environmentSlice)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["name"] = name
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
exist, err := monitor.ExistReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespace, name)
if exist {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "The replication controller to use already exists"
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["name"] = name
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(409, string(errorMessageByteSlice))
return
}
err = application.LaunchStatelessApplication(kubeApiServerEndPoint, kubeApiServerToken, namespace, name, environmentSlice)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Launch stateless application failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["name"] = name
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func (hostControl *HostControl) GetKubernetesAllNodeIP() ([]string, error) {
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
log.Error(err)
return nil, err
}
return control.GetAllNodeIP(kubeApiServerEndPoint, kubeApiServerToken)
}
func putDeployResize(request *restful.Request, response *restful.Response) {
sizeText := request.QueryParameter("size")
namespace := request.PathParameter("namespace")
imageinformation := request.PathParameter("imageinformation")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["imageinformation"] = imageinformation
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
if sizeText == "" {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Input is incorrect. The fields sizeText is required."
jsonMap["sizeText"] = sizeText
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
size, err := strconv.Atoi(sizeText)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Could not parse sizeText"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["sizeText"] = sizeText
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = deploy.DeployResize(kubeApiServerEndPoint, kubeApiServerToken, namespace, imageinformation, size)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Resize deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["imageinformation"] = imageinformation
jsonMap["size"] = size
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func postKubernetesService(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
service := new(control.Service)
err = request.ReadEntity(&service)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
if service.Namespace != namespace {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Path parameter namespace is different from namespace in the body"
jsonMap["path"] = namespace
jsonMap["body"] = service.Namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = control.CreateService(kubeApiServerEndPoint, kubeApiServerToken, namespace, *service)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Create service failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["service"] = service
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func putDeployUpdate(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
deployUpdateInput := new(DeployUpdateInput)
err = request.ReadEntity(&deployUpdateInput)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = deploy.DeployUpdate(
kubeApiServerEndPoint,
kubeApiServerToken,
namespace,
deployUpdateInput.ImageInformationName,
deployUpdateInput.Version,
deployUpdateInput.Description,
deployUpdateInput.EnvironmentSlice,
)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Update deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["deployUpdateInput"] = deployUpdateInput
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func deleteDeployBlueGreen(request *restful.Request, response *restful.Response) {
imageInformation := request.PathParameter("imageinformation")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
err = deploy.GetStorage().DeleteDeployBlueGreen(imageInformation)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Delete blue green deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["imageInformation"] = imageInformation
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
err = deploy.CleanAllServiceUnderBlueGreenDeployment(kubeApiServerEndPoint, kubeApiServerToken, imageInformation)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Delete all services under blue green deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["imageInformation"] = imageInformation
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
err = slb.SendCommandToAllSLBDaemon()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Configure SLB failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func putDeployBlueGreen(request *restful.Request, response *restful.Response) {
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
deployBlueGreen := new(deploy.DeployBlueGreen)
err = request.ReadEntity(&deployBlueGreen)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = deploy.UpdateDeployBlueGreen(kubeApiServerEndPoint, kubeApiServerToken, deployBlueGreen)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Update blue green deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["deployBlueGreen"] = deployBlueGreen
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
err = slb.SendCommandToAllSLBDaemon()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Configure SLB failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func putReplicationControllerSize(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
replicationController := request.PathParameter("replicationcontroller")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["replicationController"] = replicationController
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
sizeInput := SizeInput{}
err = request.ReadEntity(&sizeInput)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["replicationController"] = replicationController
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = control.UpdateReplicationControllerSize(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationController, sizeInput.Size)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Resize replication controller failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["replicationController"] = replicationController
jsonMap["size"] = sizeInput.Size
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func putKubernetesServiceFromJson(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
serviceName := request.PathParameter("service")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["serviceName"] = serviceName
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
service := make(map[string]interface{})
err = request.ReadEntity(&service)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = control.UpdateServiceWithJson(kubeApiServerEndPoint, kubeApiServerToken, namespace, serviceName, service)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Update service failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["service"] = service
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func getAllReplicationControllerMetric(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
nameSlice, err := control.GetAllReplicationControllerName(kubeApiServerEndPoint, kubeApiServerToken, namespace)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get all replication controller name failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
replicationControllerMetricSlice := make([]monitor.ReplicationControllerMetric, 0)
errorSlice := make([]error, 0)
for _, name := range nameSlice {
replicationControllerMetric, err := monitor.MonitorReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespace, name)
if replicationControllerMetric != nil {
replicationControllerMetricSlice = append(replicationControllerMetricSlice, *replicationControllerMetric)
}
errorSlice = append(errorSlice, err)
}
returnedJsonMap := make(map[string]interface{})
returnedJsonMap["ReplicationControllerMetricSlice"] = replicationControllerMetricSlice
returnedJsonMap["ErrorSlice"] = errorSlice
response.WriteJson(returnedJsonMap, "ReplicationControllerMetricSlice/ErrorSlice")
}
func postKubernetesNamespace(request *restful.Request, response *restful.Response) {
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
namespace := new(Namesapce)
err = request.ReadEntity(&namespace)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = control.CreateNamespace(kubeApiServerEndPoint, kubeApiServerToken, namespace.Name)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Create namespace failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func postGithub(request *restful.Request, response *restful.Response) {
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
githubPost := GithubPost{}
err = request.ReadEntity(&githubPost)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = webhook.Notify(githubPost.User, githubPost.ImageInformation, githubPost.Signature, githubPost.Payload, kubeApiServerEndPoint, kubeApiServerToken)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Notify webhook failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func putImageInformationUpgrade(request *restful.Request, response *restful.Response) {
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
imageInformationUpgradeInput := new(ImageInformationUpgradeInput)
err = request.ReadEntity(&imageInformationUpgradeInput)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
if lock.LockAvailable(image.LockKind, imageInformationUpgradeInput.ImageInformationName) == false {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Duplicated command failure"
jsonMap["ErrorMessage"] = "Image is under construction"
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(403, string(errorMessageByteSlice))
return
}
// Initialize the output file for websocket
image.TouchOutMessageFile(imageInformationUpgradeInput.ImageInformationName)
go func() {
_, err := image.BuildUpgrade(
imageInformationUpgradeInput.ImageInformationName,
imageInformationUpgradeInput.Description)
if err == nil {
// Build sccessfully
// Auto rolling update the deployment if configured
imageInformation, err := image.GetStorage().LoadImageInformation(imageInformationUpgradeInput.ImageInformationName)
if err != nil {
log.Error(err)
} else {
deployInformationSlice, err := deploy.GetDeployInformationWithAutoUpdateForNewBuild(imageInformationUpgradeInput.ImageInformationName)
if err != nil {
log.Error(err)
} else {
for _, deployInformation := range deployInformationSlice {
description := "Trigged by version " + imageInformation.CurrentVersion
err := deploy.DeployUpdate(
kubeApiServerEndPoint,
kubeApiServerToken,
deployInformation.Namespace,
imageInformation.Name,
imageInformation.CurrentVersion,
description,
deployInformation.EnvironmentSlice)
if err != nil {
log.Error(err)
}
}
}
}
}
}()
/*
outputMessage, err := image.BuildUpgrade(
imageInformationUpgradeInput.ImageInformationName,
imageInformationUpgradeInput.Description)
resultJsonMap := make(map[string]interface{})
resultJsonMap["OutputMessage"] = outputMessage
statusCode := 200
if err != nil {
statusCode = 422
resultJsonMap["Error"] = "Upgrade build failure"
resultJsonMap["ErrorMessage"] = err.Error()
resultJsonMap["imageInformationUpgradeInput"] = imageInformationUpgradeInput
log.Error(resultJsonMap)
}
result, err := json.Marshal(resultJsonMap)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Marshal output message failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["resultJsonMap"] = resultJsonMap
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
response.WriteErrorString(statusCode, string(result))
return
*/
}
func putDeployClusterApplicationSize(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
clusterApplication := request.PathParameter("clusterapplication")
sizeText := request.QueryParameter("size")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["clusterApplication"] = clusterApplication
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
if sizeText == "" {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Input is incorrect. The fields sizeText is required."
jsonMap["sizeText"] = sizeText
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
size, err := strconv.Atoi(sizeText)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Could not parse sizeText"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["sizeText"] = sizeText
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
environmentSlice := make([]interface{}, 0)
err = request.ReadEntity(&environmentSlice)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["clusterApplication"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = deploy.ResizeDeployClusterApplication(kubeApiServerEndPoint, kubeApiServerToken, namespace, clusterApplication, environmentSlice, size)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Resize cluster application deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["clusterApplication"] = clusterApplication
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func putReplicationControllerNotifier(request *restful.Request, response *restful.Response) {
replicationControllerNotifierSerializable := new(notification.ReplicationControllerNotifierSerializable)
err := request.ReadEntity(&replicationControllerNotifierSerializable)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
replicationControllerNotifierSerializable.KubeApiServerEndPoint = kubeApiServerEndPoint
replicationControllerNotifierSerializable.KubeApiServerToken = kubeApiServerToken
switch replicationControllerNotifierSerializable.Kind {
case "application":
_, err := deploy.GetStorage().LoadDeployInformation(replicationControllerNotifierSerializable.Namespace, replicationControllerNotifierSerializable.Name)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Check whether the application exists or not failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["replicationControllerNotifierSerializable"] = replicationControllerNotifierSerializable
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
case "selector":
nameSlice, err := monitor.GetReplicationControllerNameFromSelector(replicationControllerNotifierSerializable.KubeApiServerEndPoint, replicationControllerNotifierSerializable.KubeApiServerToken, replicationControllerNotifierSerializable.Namespace, replicationControllerNotifierSerializable.Name)
if err != nil {
for _, name := range nameSlice {
exist, err := monitor.ExistReplicationController(replicationControllerNotifierSerializable.KubeApiServerEndPoint, replicationControllerNotifierSerializable.KubeApiServerToken, replicationControllerNotifierSerializable.Namespace, name)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Check whether the replication controller exists or not failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["replicationControllerNotifierSerializable"] = replicationControllerNotifierSerializable
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
if exist == false {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "The replication controller to notify doesn't exist"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["replicationControllerNotifierSerializable"] = replicationControllerNotifierSerializable
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
}
}
case "replicationController":
exist, err := monitor.ExistReplicationController(replicationControllerNotifierSerializable.KubeApiServerEndPoint, replicationControllerNotifierSerializable.KubeApiServerToken, replicationControllerNotifierSerializable.Namespace, replicationControllerNotifierSerializable.Name)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Check whether the replication controller exists or not failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["replicationControllerNotifierSerializable"] = replicationControllerNotifierSerializable
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
if exist == false {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "The replication controller to notify doesn't exist"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["replicationControllerNotifierSerializable"] = replicationControllerNotifierSerializable
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
default:
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "No such kind"
jsonMap["replicationControllerNotifierSerializable"] = replicationControllerNotifierSerializable
jsonMap["kind"] = replicationControllerNotifierSerializable.Kind
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
replicationControllerNotifier, err := notification.ConvertFromSerializable(*replicationControllerNotifierSerializable)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Convert replication controller notifier failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["replicationControllerNotifierSerializable"] = replicationControllerNotifierSerializable
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = notification.GetStorage().SaveReplicationControllerNotifierSerializable(replicationControllerNotifierSerializable)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Save replication controller notifier failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["replicationControllerNotifierSerializable"] = replicationControllerNotifierSerializable
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
execute.AddReplicationControllerNotifier(&replicationControllerNotifier)
}
func putReplicationControllerFromJson(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
replicationcontrollerName := request.PathParameter("replicationcontroller")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["replicationcontrollerName"] = replicationcontrollerName
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
replicationController := make(map[string]interface{})
err = request.ReadEntity(&replicationController)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
err = control.UpdateReplicationControllerWithJson(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationcontrollerName, replicationController)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Update replication controller failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["replicationController"] = replicationController
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
podNameSlice, err := control.GetAllPodNameBelongToReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationcontrollerName)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get all pod name belonging to replication controller failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["replicationController"] = replicationController
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
hasError := false
errorByteBuffer := bytes.Buffer{}
for _, podName := range podNameSlice {
err := control.DeletePod(kubeApiServerEndPoint, kubeApiServerToken, namespace, podName)
if err != nil {
hasError = true
errorByteBuffer.WriteString(err.Error())
errorByteBuffer.WriteString(" ")
}
}
if hasError {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Delete pods belonging to replication controller failure"
jsonMap["ErrorMessage"] = errorByteBuffer.String()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["replicationController"] = replicationController
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func postLaunchClusterApplication(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
name := request.PathParameter("clusterapplication")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
jsonMap["name"] = name
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
clusterLaunch := ClusterLaunch{}
err = request.ReadEntity(&clusterLaunch)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["name"] = name
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
oldDeployClusterApplication, _ := deploy.GetDeployClusterApplication(namespace, name)
if oldDeployClusterApplication != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "The cluster application already exists"
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["name"] = name
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(409, string(errorMessageByteSlice))
return
}
err = application.LaunchClusterApplication(kubeApiServerEndPoint, kubeApiServerToken, namespace, name, clusterLaunch.EnvironmentSlice, clusterLaunch.Size, clusterLaunch.ReplicationControllerExtraJsonMap)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Launch cluster application deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["name"] = name
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
err = deploy.InitializeDeployClusterApplication(kubeApiServerEndPoint, kubeApiServerToken, namespace, name, clusterLaunch.EnvironmentSlice, clusterLaunch.Size, clusterLaunch.ReplicationControllerExtraJsonMap)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Create cluster application deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
jsonMap["name"] = name
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}
func postDeployCreate(request *restful.Request, response *restful.Response) {
namespace := request.PathParameter("namespace")
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Get kube apiserver endpoint and token failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(404, string(errorMessageByteSlice))
return
}
deployCreateInput := new(DeployCreateInput)
err = request.ReadEntity(&deployCreateInput)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Read body failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerEndPoint"] = kubeApiServerEndPoint
jsonMap["namespace"] = namespace
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(400, string(errorMessageByteSlice))
return
}
deploymentInformation, _ := deploy.GetStorage().LoadDeployInformation(namespace, deployCreateInput.ImageInformationName)
if deploymentInformation != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Duplicate deployment error"
jsonMap["ErrorMessage"] = "Already exists"
jsonMap["kubeApiServerToken"] = kubeApiServerToken
jsonMap["namespace"] = namespace
jsonMap["deployCreateInput"] = deployCreateInput
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
err = deploy.DeployCreate(
kubeApiServerEndPoint,
kubeApiServerToken,
namespace,
deployCreateInput.ImageInformationName,
deployCreateInput.Version,
deployCreateInput.Description,
deployCreateInput.ReplicaAmount,
deployCreateInput.PortSlice,
deployCreateInput.EnvironmentSlice,
deployCreateInput.ResourceMap,
deployCreateInput.ExtraJsonMap,
deployCreateInput.AutoUpdateForNewBuild,
)
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Create deployment failure"
jsonMap["ErrorMessage"] = err.Error()
jsonMap["kubeApiServerToken"] = kubeApiServerToken
jsonMap["namespace"] = namespace
jsonMap["deployCreateInput"] = deployCreateInput
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
err = slb.SendCommandToAllSLBDaemon()
if err != nil {
jsonMap := make(map[string]interface{})
jsonMap["Error"] = "Configure SLB failure"
jsonMap["ErrorMessage"] = err.Error()
errorMessageByteSlice, _ := json.Marshal(jsonMap)
log.Error(jsonMap)
response.WriteErrorString(422, string(errorMessageByteSlice))
return
}
}