Golang models.NewInternalError函数代码示例

// @Title update
// @Description update the node
// @Param	nodeID		path 	string	true		"The node id you want to update"
// @Param	body		body 	models.Node	true		"body for node content"
// @Success 200
// @Failure 400 invalid request message
// @router /:nid [put]
func (self *NodeController) Put() {
	nid := self.GetString(":nid")
	var body models.Node
	err := json.Unmarshal(self.Ctx.Input.RequestBody, &body)
	if err != nil {
		self.Data["json"] = models.NewInternalError(400, err)
		self.Ctx.Output.SetStatus(400)
		self.ServeJSON()
		return
	}
	if node, ok := objects.Get(nid).(*models.Node); ok {
		clone := *node
		if clone.Status != body.Status && body.Status != 0 {
			clone.Status = body.Status
		}
		if clone.MaxInstance != body.MaxInstance && body.MaxInstance != 0 {
			clone.MaxInstance = body.MaxInstance
		}
		objects.Set(clone.ID, &clone)
	} else {
		self.Data["json"] = models.NewInternalError(1, ErrNotFound)
		self.Ctx.Output.SetStatus(403)
	}
	self.ServeJSON()
}

// @Title create
// @Description create users
// @Param	body		body 	models.PostNode	true		"body for node content"
// @Success 200 {object} models.ResponsePostNode
// @Failure 400 invalid request message
// @router / [post]
func (self *NodeController) Post() {
	var body []models.PostNode
	err := json.Unmarshal(self.Ctx.Input.RequestBody, &body)
	if err != nil {
		self.Data["json"] = models.NewInternalError(400, err)
		self.Ctx.Output.SetStatus(400)
		self.ServeJSON()
		return
	}

	resp := make([]models.ResponsePostNode, len(body))
	for i := range body {
		node := models.Node{
			ID:          "node_" + utils.Generate32UUID(),
			ClusterID:   body[i].ClusterID,
			SoftwareID:  body[i].SoftwareID,
			Status:      models.Enable,
			Runtime:     "running",
			MaxInstance: body[i].MaxInstance,
			IPAddress:   "12.168.1.1",
			NCPU:        24,
			Mem_MB:      102400,
		}

		objects.Set(node.ID, &node)

		resp[i].ID = node.ID
		resp[i].TaskID = utils.Generate32UUID()
		resp[i].NodeID = body[i].NodeID
	}

	self.Data["json"] = resp
	self.ServeJSON()
}

// @Title Get
// @Description find network by networkID
// @Param	netwrokID		path 	string	true		"The networkID you want to get"
// @Success 200 {object} models.IPtable
// @Failure 403 :networkID is empty
// @router /:id [get]
func (self *NetworkController) Get() {
	id := self.GetString(":id")
	if strings.TrimSpace(id) != "" {
		if ob, ok := objects.Get(id).(*models.IPtable); ok {
			self.Data["json"] = ob
		} else {
			self.Data["json"] = models.NewInternalError(403, ErrNotFound)
			self.Ctx.Output.SetStatus(403)
		}
	} else {
		self.Data["json"] = models.NewInternalError(403,
			fmt.Errorf("%s cluster_id is empty", id))
		self.Ctx.Output.SetStatus(403)
	}
	self.ServeJSON()
}

// @Title create
// @Description create cluster
// @Param	body		body 	models.Cluster  	true		"body for cluste content"
// @Success 200 {string} models.ClusterInfo.ID
// @Failure 400 invalid request message
// @router / [post]
func (self *ClusterController) Post() {
	var body models.PostCluster
	err := json.Unmarshal(self.Ctx.Input.RequestBody, &body)
	if err != nil {
		self.Data["json"] = models.NewInternalError(400, err)
		self.Ctx.Output.SetStatus(400)
		self.ServeJSON()
		return
	}

	cluster := models.ClusterInfo{
		ID:                "cluster_" + utils.Generate32UUID(),
		Name:              body.Name,
		Type:              body.Type,
		Status:            models.Enable,
		MaxNodeUsageLimit: body.MaxNodeUsageLimit,
		Storage: models.Storage{
			Type: body.StorageType,
			ID:   body.StorageSystemID,
		},
	}
	objects.Set(cluster.ID, &cluster)

	self.Data["json"] = map[string]string{"id": cluster.ID}
	//self.Ctx.Output.SetStatus(201)
	self.ServeJSON()
}

// @Title List
// @Description find node by node_ID
// @Param	body		body 	models.CommonRequestBody	true		"the nodes you want to get"
// @Success 200 {object} models.ResponseNode
// @Failure 400 invalid request message
// @router /list [post]
func (self *NodeController) List() {
	var body models.CommonRequestBody
	err := json.Unmarshal(self.Ctx.Input.RequestBody, &body)
	if err != nil {
		self.Data["json"] = models.NewInternalError(400, err)
		self.Ctx.Output.SetStatus(400)
		self.ServeJSON()
		return
	}
	m := objects.Items()
	if body.All {
		list := make([]models.ResponseNode, 0, 100)
		for k, v := range m {
			if id, ok := k.(string); ok && strings.HasPrefix(id, "node_") {
				if object, ok := v.(*models.Node); ok {
					list = append(list, models.ResponseNode{
						ID:        object.ID,
						IPAddress: object.IPAddress,
						NCPU:      object.NCPU,
						Mem_MB:    object.Mem_MB,
						Status:    object.Status,
						Runtime:   object.Runtime,
					})
				}
			}
		}
		self.Data["json"] = list
		self.ServeJSON()
		return
	}

	list := make([]models.ResponseNode, len(body.ID))
	for i, id := range body.ID {
		if strings.TrimSpace(id) == "" {
			continue
		}
		if object, ok := m[id].(*models.Node); ok {
			list[i] = models.ResponseNode{
				ID:        object.ID,
				IPAddress: object.IPAddress,
				NCPU:      object.NCPU,
				Mem_MB:    object.Mem_MB,
				Status:    object.Status,
				Runtime:   object.Runtime,
			}
		} else {
			list[i] = models.ResponseNode{
				ID:    id,
				Error: ErrNotFound.Error(),
			}
		}
	}
	self.Data["json"] = list
	self.ServeJSON()
}

// @Title disable
// @Description update the object
// @Param	RaidGroupID		path 	string	true		"The RaidGroup you want to update"
// @Success 200
// @Failure 403 :id not exist
// @router /san/rg/:ID/disable [put]
func (self *StorageController) Disable() {
	id := self.GetString(":ID")

	if rg, ok := objects.Get(id).(*models.RaidGroup); ok {
		clone := *rg
		clone.Status = models.Disable
		objects.Set(clone.ID, &clone)
	} else {
		self.Data["json"] = models.NewInternalError(1, ErrNotFound)
		self.Ctx.Output.SetStatus(403)
	}
	self.ServeJSON()
}

// @Title enable
// @Description update the object
// @Param	networkID		path 	string	true		"The network you want to update"
// @Success 200
// @Failure 403 :networkID not exist
// @router /:id/enable [put]
func (self *NetworkController) Enable() {
	id := self.GetString(":id")

	if table, ok := objects.Get(id).(*models.IPtable); ok {
		clone := *table
		clone.Status = models.Enable
		objects.Set(clone.ID, &clone)
	} else {
		self.Data["json"] = models.NewInternalError(1, ErrNotFound)
		self.Ctx.Output.SetStatus(403)
	}
	self.ServeJSON()
}

// @Title disable
// @Description update the object
// @Param	clusterID		path 	string	true		"The clusterID you want to update"
// @Success 200
// @Failure 403 :clusterID is empty
// @router /:clusterID/disable [put]
func (self *ClusterController) Disable() {
	cid := self.GetString(":clusterID")

	if cluster, ok := objects.Get(cid).(*models.ClusterInfo); ok {
		clone := *cluster
		clone.Status = models.Disable
		objects.Set(clone.ID, &clone)
	} else {
		self.Data["json"] = models.NewInternalError(1, ErrNotFound)
		self.Ctx.Output.SetStatus(403)
	}
	self.ServeJSON()
}

// @Title disable
// @Description update the object
// @Param	serviceID		path 	string	true		"The serviceID you want to update"
// @Success 200
// @Failure 403 :serviceID is empty
// @router /:id/disable [put]
func (self *ServiceController) Disable() {
	id := self.GetString(":id")

	if svc, ok := objects.Get(id).(*models.Service); ok {
		clone := *svc
		clone.Status = models.Disable
		objects.Set(clone.ID, &clone)
	} else {
		self.Data["json"] = models.NewInternalError(1, ErrNotFound)
		self.Ctx.Output.SetStatus(403)
	}
	self.ServeJSON()
}

// @Title Get
// @Description find node by nodeID
// @Param	nodeID		path 	string	true		"The nodeID you want to get"
// @Success 200 {object} models.ResponseNode
// @Failure 403 :nodeID is empty
// @router /:id [get]
func (self *NodeController) Get() {
	id := self.GetString(":id")
	if strings.TrimSpace(id) != "" {
		if object, ok := objects.Get(id).(*models.Node); ok {
			self.Data["json"] = models.ResponseNode{
				ID:        object.ID,
				IPAddress: object.IPAddress,
				NCPU:      object.NCPU,
				Mem_MB:    object.Mem_MB,
				Status:    object.Status,
				Runtime:   object.Runtime,
			}
		} else {
			self.Data["json"] = models.NewInternalError(403, ErrNotFound)
			self.Ctx.Output.SetStatus(403)
		}
	} else {
		self.Data["json"] = models.NewInternalError(403,
			fmt.Errorf("%s cluster_id is empty", id))
		self.Ctx.Output.SetStatus(403)
	}
	self.ServeJSON()
}

// @Title create
// @Description create cluster
// @Param	body		body 	models.Cluster  	true		"body for cluste content"
// @Success 200 {string} models.ClusterInfo.ID
// @Failure 403 body is empty
// @router /nas [post]
func (self *StorageController) PostNAS() {
	var body models.NAS
	err := json.Unmarshal(self.Ctx.Input.RequestBody, &body)
	if err != nil {
		self.Data["json"] = models.NewInternalError(400, err)
		self.Ctx.Output.SetStatus(403)
		self.ServeJSON()
		return
	}

	objects.Set(body.ID, &body)

	//self.Ctx.Output.SetStatus(201)
	self.ServeJSON()
}

// @Title Get
// @Description find  SANs by condition
// @Param	body		body 	models.CommonRequestBody	true		"the cluster_IDs you want to get"
// @Success 200 {object} models.SAN
// @router /nas/:id [get]
func (self *StorageController) GetNAS() {
	id := self.GetString(":ID")

	if nas, ok := objects.Get(id).(*models.NAS); ok {
		self.Data["json"] = models.ResponseNAS{
			ID:      nas.ID,
			TotalMB: 1024000,
			FreeMB:  100000,
		}
	} else {
		self.Data["json"] = models.NewInternalError(403, ErrNotFound)
	}

	self.ServeJSON()
}

// @Title add
// @Description add software
// @Param	body		body 	models.Software  	true		"body for software content"
// @Success 200 {string} taskID
// @Failure 400 invalid request message
// @router / [post]
func (self *SoftwareController) Post() {
	var body models.Software
	err := json.Unmarshal(self.Ctx.Input.RequestBody, &body)
	if err != nil {
		self.Data["json"] = models.NewInternalError(400, err)
		self.Ctx.Output.SetStatus(400)
		self.ServeJSON()
		return
	}

	objects.Set(body.ID, &body)

	self.Data["json"] = map[string]string{"task_id": "task_" + utils.Generate32UUID()}
	//self.Ctx.Output.SetStatus(201)
	self.ServeJSON()
}

// @Title create
// @Description create network
// @Param	body		body 	models.IPtable  	true		"body for network content"
// @Success 200 {string} models.IPtable.ID
// @Failure 400 invalid request message
// @router / [post]
func (self *NetworkController) Post() {
	var body models.IPtable
	err := json.Unmarshal(self.Ctx.Input.RequestBody, &body)
	if err != nil {
		self.Data["json"] = models.NewInternalError(400, err)
		self.Ctx.Output.SetStatus(400)
		self.ServeJSON()
		return
	}

	body.ID = "network_" + utils.Generate32UUID()
	body.Status = models.Enable
	objects.Set(body.ID, &body)

	self.Data["json"] = map[string]string{"id": body.ID}
	//self.Ctx.Output.SetStatus(201)
	self.ServeJSON()
}

// @Title List
// @Description find networks by condition
// @Param	body		body 	models.CommonRequestBody	true		"the networks you want to get"
// @Success 200 {object} models.IPtable
// @Failure 400 invalid request message
// @router /list [post]
func (self *NetworkController) List() {
	var body models.CommonRequestBody
	err := json.Unmarshal(self.Ctx.Input.RequestBody, &body)
	if err != nil {
		self.Data["json"] = models.NewInternalError(400, err)
		self.Ctx.Output.SetStatus(403)
		self.ServeJSON()
		return
	}

	m := objects.Items()
	if body.All {
		list := make([]*models.IPtable, 0, 100)
		for k, v := range m {
			if id, ok := k.(string); ok && strings.HasPrefix(id, "network_") {
				if ob, ok := v.(*models.IPtable); ok {
					list = append(list, ob)
				}
			}
		}
		self.Data["json"] = list
		self.ServeJSON()
		return
	}

	list := make([]*models.IPtable, len(body.ID))
	for i, id := range body.ID {
		if strings.TrimSpace(id) == "" {
			continue
		}
		if ob, ok := m[id].(*models.IPtable); ok {
			list[i] = ob
		} else {
			list[i] = &models.IPtable{
				ID:    id,
				Error: ErrNotFound.Error(),
			}
		}
	}
	self.Data["json"] = list
	self.ServeJSON()
}