コード例 #1
0
ファイル: node.go プロジェクト: fugr/APIServer
// @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.CopyBody(beego.BConfig.MaxMemory), &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 {
		err, node := models.CreateNode(body[i])

		if err == nil {
			resp[i].ID = node.ID
			resp[i].TaskID = utils.Generate32UUID()
			resp[i].NodeID = body[i].NodeID
		} else {
			resp[i].ID = node.ID
			resp[i].Error = "CreateNode " + node.ID + " err"
		}
	}

	self.Data["json"] = resp
	self.ServeJSON()
}
コード例 #2
0
ファイル: service.go プロジェクト: fugr/APIServer
func CreateService(body PostService) (error, Service) {
	o := orm.NewOrm()
	service := Service{
		ID:     "service_" + utils.Generate32UUID(),
		Status: Enable,
	}
	_, err := o.Insert(&service)
	if err != nil {
		fmt.Println("CreateService err:" + err.Error())
	}
	return err, service
}
コード例 #3
0
ファイル: storage.go プロジェクト: fugr/APIServer
func CreateSAN(body SAN) (error, SAN) {
	o := orm.NewOrm()
	o.Begin()
	lc := LoginConfig{
		ID:        "LoginConfig_" + utils.Generate32UUID(),
		Name:      body.Login.Name,
		Type:      body.Login.Type,
		IPAddress: body.Login.IPAddress,
		UserName:  body.Login.UserName,
		Password:  body.Login.Password,
	}

	san := SAN{
		ID:       "san_" + utils.Generate32UUID(),
		Name:     body.Name,
		Vender:   body.Vender,
		Login:    &lc,
		LUNRange: body.LUNRange,
		HLURange: body.HLURange,
		TotalMB:  body.TotalMB,
		FreeMB:   body.FreeMB,
		Error:    body.Error,
	}
	_, err := o.Insert(&lc)
	if err == nil {
		_, err = o.Insert(&san)
		if err != nil {
			fmt.Println("CreateSAN err:" + err.Error())
			o.Rollback()
		}
	} else {
		fmt.Println("CreateSAN LoginConfig err:" + err.Error())
		o.Rollback()
	}
	if err == nil {
		o.Commit()
	}
	return err, san
}
コード例 #4
0
ファイル: storage.go プロジェクト: fugr/APIServer
func CreateRaidGroup(body PostRaidGroup) (error, RaidGroup) {
	o := orm.NewOrm()
	rg := RaidGroup{
		ID:     "raidgroup_" + utils.Generate32UUID(),
		SANID:  body.SANID,
		Number: body.Number,
		Status: Enable,
	}
	_, err := o.Insert(&rg)
	if err != nil {
		fmt.Println("CreateRaidGroup err:" + err.Error())
	}
	return err, rg
}
コード例 #5
0
ファイル: network.go プロジェクト: fugr/APIServer
func CreateIPtable(body IPtable) (error, IPtable) {
	o := orm.NewOrm()
	iptable := IPtable{
		ID:        "network_" + utils.Generate32UUID(),
		Type:      body.Type,
		IPAddress: body.IPAddress,
		Netmask:   body.Netmask,
		Gateway:   body.Gateway,
		Total:     body.Total,
		Used:      body.Used,
		Status:    Enable,
		Error:     body.Error,
	}
	_, err := o.Insert(&iptable)
	if err != nil {
		fmt.Println("CreateIPtable err:" + err.Error())
	}
	return err, iptable
}
コード例 #6
0
ファイル: node.go プロジェクト: fugr/APIServer
func CreateNode(body PostNode) (error, Node) {
	o := orm.NewOrm()
	node := Node{
		ID:          "node_" + utils.Generate32UUID(),
		ClusterID:   body.ClusterID,
		SoftwareID:  body.SoftwareID,
		Status:      Enable,
		Runtime:     "running",
		MaxInstance: body.MaxInstance,
		IPAddress:   "12.168.1.1",
		NCPU:        24,
		Mem_MB:      102400,
	}
	_, err := o.Insert(&node)
	if err != nil {
		fmt.Println("CreateNode err:" + err.Error())
	}
	//TODO task
	return err, node
}
コード例 #7
0
ファイル: cluster.go プロジェクト: fugr/APIServer
func CreateCluster(body PostCluster) (error, ClusterInfo) {
	if strings.TrimSpace(body.StorageSystemID) == "" {
		err := "Create Cluster " + body.Name + " 'storage err:"
		fmt.Println(err)
		return errors.New(err), *new(ClusterInfo)
	}
	o := orm.NewOrm()
	o.Begin()
	storage := Storage{
		Type: body.StorageType,
		ID:   body.StorageSystemID,
	}
	clusterInfo := ClusterInfo{
		ID:                "cluster_" + utils.Generate32UUID(),
		Name:              body.Name,
		Type:              body.Type,
		Status:            Enable,
		MaxNodeUsageLimit: body.MaxNodeUsageLimit,
		Storage:           &storage,
	}
	_, err := o.Insert(&storage)
	if err == nil {
		_, err = o.Insert(&clusterInfo)
		if err != nil {
			fmt.Println("CreateCluster err:" + err.Error())
			o.Rollback()
		}
	} else {
		fmt.Println("CreateCluster storage err:" + err.Error())
		o.Rollback()
	}
	if err == nil {
		o.Commit()
	}
	return err, clusterInfo
}
コード例 #8
0
ファイル: default_test.go プロジェクト: fugr/APIServer
func TestAPIServer(t *testing.T) {

	objs := []string{"cluster", "network", "node", "service", "software", "storage/san", "storage/san/rg", "storage/nas"}
	//objs := []string{"cluster"}

	var req *httplib.BeegoHTTPRequest
	var b []byte
	for _, obj := range objs {
		if obj != "service" && obj != "software" {
			if strings.Contains(obj, "storage/san") == false {
				//GetTest
				req = httplib.Get("http://localhost:8080/v1.0/" + obj + "/" + "1001")
				actionTestTemplate(t, req, obj, "Get")

				if obj != "storage/nas" {
					//GetAllTest
					req = httplib.Get("http://localhost:8080/v1.0/" + obj)
					actionTestTemplate(t, req, obj, "GetAll")
				}
			}

			if obj != "storage/nas" {
				//ListTrueTest
				listBody := models.CommonRequestBody{
					All: true,
					ID:  []string{"1001", "9999"},
				}
				req = httplib.Post("http://localhost:8080/v1.0/" + obj + "/list")
				b, _ = json.Marshal(listBody)
				req.Body(b)
				actionTestTemplate(t, req, obj, "ListTrue")

				//ListFalseTest
				listBody.All = false
				req = httplib.Post("http://localhost:8080/v1.0/" + obj + "/list")
				b, _ = json.Marshal(listBody)
				req.Body(b)
				actionTestTemplate(t, req, obj, "ListFalse")
			}
		}

		//PostTest
		req = httplib.Post("http://localhost:8080/v1.0/" + obj)
		switch obj {
		case "cluster":
			postBody := models.PostCluster{
				Name:              "ClusterPostName",
				Type:              "PostType",
				StorageType:       "StoragePostType",
				StorageSystemID:   "storage_" + utils.Generate32UUID(),
				MaxNodeUsageLimit: 100,
				MaxNodeNum:        200,
			}
			b, _ = json.Marshal(postBody)
			req.Body(b)
			actionTestTemplate(t, req, obj, "Post")
		case "network":
			postBody := models.IPtable{
				Type:      "PostType",
				IPAddress: "0.0.0.2",
				Netmask:   "255.255.255.2",
				//Gateway   "" //miss property,
				Total: 10,
				Used:  2,
				//Status
				//Error
			}
			b, _ = json.Marshal(postBody)
			req.Body(b)
			actionTestTemplate(t, req, obj, "Post")
		case "node":
			postBodyList := make([]models.PostNode, 2)
			postBodyList[0] = models.PostNode{
				NodeID:      "node_9001",
				ClusterID:   "cluster_1001",
				SoftwareID:  "software_1001",
				MaxInstance: 11,
			}
			postBodyList[1] = models.PostNode{
				NodeID:      "node_9002",
				ClusterID:   "cluster_1002",
				SoftwareID:  "software_1002",
				MaxInstance: 12,
			}
			b, _ = json.Marshal(postBodyList)
			req.Body(b)
			actionTestTemplate(t, req, obj, "Post")
		case "service":
			postBody := models.PostService{}
			b, _ = json.Marshal(postBody)
			req.Body(b)
			actionTestTemplate(t, req, obj, "Post")
		case "software":
			postBody := models.Software{
				ID:       "software_9999",
				Name:     "software_name_9999",
				Version:  "V999",
				Type:     "999",
				StoreURL: "Z:\\",
				MD5:      "",
			}
			b, _ = json.Marshal(postBody)
			req.Body(b)
			actionTestTemplate(t, req, obj, "Post")
		case "storage/san":
			san := new(models.SAN)
			san.ID = "san_1001"
			san.Name = "san_name_1001"
			san.Vender = "san_vender_1001"
			lc := new(models.LoginConfig)
			lc.Name = "lc_name_1001"
			lc.Type = "A"
			lc.IPAddress = "0.0.0.1"
			lc.UserName = "******"
			lc.Password = "******"
			san.Login = lc
			san.LUNRange = "a1"
			san.HLURange = "b1"
			san.TotalMB = 100
			san.FreeMB = 50
			san.Error = "NONE1"
			postBody := san
			b, _ = json.Marshal(postBody)
			req.Body(b)
			actionTestTemplate(t, req, obj, "Post")
		case "storage/rg":
			postBody := models.PostRaidGroup{
				SANID:  "PostRaidGroup_9999",
				Number: 111,
			}
			b, _ = json.Marshal(postBody)
			req.Body(b)
			actionTestTemplate(t, req, obj, "Post")
		case "storage/nas":
			postBody := models.NAS{
				ID:           "NAS_9999",
				ServerIPAddr: "0.0.0.9",
				ShareDir:     "Z:\\",
			}
			b, _ = json.Marshal(postBody)
			req.Body(b)
			actionTestTemplate(t, req, obj, "Post")
		}

		//PostRollbackTest
		if obj == "cluster" {
			postBody := models.PostCluster{
				Name:              "ClusterPostName",
				Type:              "PostType",
				StorageType:       "StoragePostType",
				StorageSystemID:   "",
				MaxNodeUsageLimit: 100,
				MaxNodeNum:        200,
			}
			req = httplib.Post("http://localhost:8080/v1.0/" + obj)
			b, _ = json.Marshal(postBody)
			req.Body(b)
			actionTestTemplate(t, req, obj, "PostRollback")
		}

		//PutTest
		if obj == "node" {
			req = httplib.Put("http://localhost:8080/v1.0/" + obj + "/" + "1001")
			putBody := models.Node{
				Status:      models.Enable,
				MaxInstance: 99,
			}
			b, _ = json.Marshal(putBody)
			req.Body(b)
			actionTestTemplate(t, req, obj, "Put")
		}
		if obj != "software" && obj != "storage/san" && obj != "storage/nas" {
			//EnableTest
			req = httplib.Put("http://localhost:8080/v1.0/" + obj + "/" + "1001/enable")
			actionTestTemplate(t, req, obj, "Enable")
			//DisableTest
			req = httplib.Put("http://localhost:8080/v1.0/" + obj + "/" + "1001/disable")
			actionTestTemplate(t, req, obj, "Disable")
		}

		//DeleteTest
		if obj != "storage/nas" {
			req = httplib.Delete("http://localhost:8080/v1.0/" + obj + "/" + "1001")
			actionTestTemplate(t, req, obj, "Delete")
		}

	}
}