add vm status handler

README.md

 # hashrate-Node
 
+abigen  --abi  VmContract/Vm.abi  --pkg  vm  --type  Vm  --out  VmContract/Vm.go
+
+abigen  --abi  VmCreateContract/VmCreate.abi  --pkg  vmCreate  --type  VmCreate  --out  VmCreateContract/VmCreate.go
+

asyncLog/pullEvent.go

@@ -75,6 +75,15 @@ func init() {
 				pullTask.contractHandler[addr] = VmCreateContractHandler
 			}
 		}
+
+		vmAddrArr := getAddress(hashrateCommon.VmContract)
+		for _, stakeAddr := range vmAddrArr {
+			if len(stakeAddr) > 0 {
+				addr := common.HexToAddress(stakeAddr)
+				pullTask.contractList = append(pullTask.contractList, addr)
+				pullTask.contractHandler[addr] = VmStatusContractHandler
+			}
+		}
 	}
 }
 
@@ -116,7 +125,6 @@ func (p *PullEvent) GetLogs() {
 					err := handle(vlog)
 					if err != nil {
 						log.Error("handle logs failed", err)
-						return
 					}
 				}
 			}

asyncLog/vmEventHandler.go

+package asyncLog
+
+import (
+	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/logs"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"hashrateNode/cache"
+	hashrateCommon "hashrateNode/common"
+	"hashrateNode/commonApi"
+	vm "hashrateNode/contract/VmContract"
+	"hashrateNode/log"
+	"hashrateNode/models"
+	"hashrateNode/utils"
+	"math/big"
+	"strings"
+	"time"
+)
+
+func VmStatusContractHandler(vLog types.Log) error {
+	logs.Info("handle vm create contract logs.")
+	vmAbiInfo, _ := abi.JSON(strings.NewReader(vm.VmABI))
+	{
+		method := vLog.Topics[0]
+		switch method.String() {
+		case hashrateCommon.VmStatusEvent:
+			{
+				vmStatusEvent := &models.VmStatusEvent{}
+				err = vmAbiInfo.UnpackIntoInterface(vmStatusEvent, "UpdateVmStatus", vLog.Data)
+				if err != nil {
+					err := cache.Redis.LpushByte(hashrateCommon.EventList, utils.Marshal(vmStatusEvent))
+					if err != nil {
+						log.Error("cache redis lPush Byte error:", err.Error())
+						return err
+					}
+				}
+				isSuccess, err := handlerVm(vmStatusEvent)
+				if err != nil {
+					return err
+				}
+				if isSuccess {
+					log.Info("VM status update successful")
+					return nil
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func handlerVm(vmStatus *models.VmStatusEvent) (bool, error) {
+	ticket, err := commonApi.GetCreateVmTicket()
+	if err != nil {
+		log.Error("GetCreateVmTicket error:", err)
+		return false, err
+
+	}
+	vmInfo := &models.VM{
+		NewId:      vmStatus.VmId.String(),
+		HeaderInfo: ticket,
+	}
+	switch vmStatus.Status {
+	case hashrateCommon.VmStatusEnabled:
+		{
+			_, err := commonApi.StartVm(vmInfo)
+			if err != nil {
+				log.Error("Start vm error:", err)
+				return false, err
+			}
+		}
+	case hashrateCommon.VmStatusDisable:
+		{
+			_, err := commonApi.ShutdownVm(vmInfo)
+			if err != nil {
+				log.Error(" Shutdown vm error:", err)
+				return false, err
+			}
+		}
+	case hashrateCommon.VmStatusReboot:
+		{
+			_, err := commonApi.RebootVm(vmInfo)
+			if err != nil {
+				log.Error("Reboot vm error:", err)
+				return false, err
+			}
+		}
+	case hashrateCommon.VmStatusDelete:
+		{
+
+		}
+
+	}
+	vmCurrentStatus, err := commonApi.VmStatus(vmInfo)
+	if err != nil {
+		log.Error("VmStatus error:", err)
+		return false, err
+	}
+
+	rpcUrl := beego.AppConfig.String("chain_rpc_url")
+	client, err := ethclient.Dial(rpcUrl)
+	if err != nil {
+		log.Error("Eth client.Dial error:", err)
+		return false, err
+	}
+	defer client.Close()
+	nonce, err = utils.EthGetTransactionCount(client, fromAddr)
+	if err != nil {
+		log.Error("EthGetTransactionCount error:", err)
+		return false, err
+	}
+	if (vmStatus.Status == hashrateCommon.VmStatusDisable) && vmCurrentStatus.Status != hashrateCommon.Stopped {
+		time.Sleep(time.Second * 10)
+	}
+	if (vmStatus.Status == hashrateCommon.VmStatusEnabled || vmStatus.Status == hashrateCommon.VmStatusReboot) && vmCurrentStatus.Status != hashrateCommon.Running {
+		time.Sleep(time.Second * 10)
+	}
+	if vmStatus.Status == hashrateCommon.VmStatusReboot {
+		vmStatus.Status = hashrateCommon.VmStatusEnabled
+	}
+	vmContract, err := vm.NewVm(common.HexToAddress(hashrateCommon.VmContract), client)
+	if err != nil {
+		log.Error("NewVm error:", err)
+		return false, err
+	}
+	nonceBigInt := new(big.Int).SetUint64(nonce)
+	tranOpts.Nonce = nonceBigInt
+	status, err := vmContract.UpdateVmStatus(tranOpts, vmStatus.VmId, vmStatus.Status)
+	if err != nil {
+		log.Error("UpdateVmStatus error:", err)
+		return false, err
+	}
+	log.Info("UpdateVmStatus success:", status.Hash())
+	return true, nil
+}

asyncLog/contractEventHandler.go → asyncLog/vmTaskEventHandler.go

@@ -21,6 +21,7 @@ import (
 	"math/big"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"time"
 )
 
@@ -37,8 +38,8 @@ func init() {
 	}
 	hostName = beego.AppConfig.String("pve::host_name")
 	fromAddr = beego.AppConfig.String("sendTranAddress")
-	vncDefaultPort = beego.AppConfig.String("vncDefaultPort")
-	sshDefaultPort = beego.AppConfig.String("vncDefaultPort")
+	vncDefaultPort = hashrateCommon.DefaultVncPort
+	sshDefaultPort = hashrateCommon.DefaultSshPort
 }
 
 func VmCreateContractHandler(vLog types.Log) error {
@@ -130,12 +131,16 @@ func snatchTask(vmCfg *models.VmConfig) (bool, error) {
 
 	ticket, err := commonApi.GetCreateVmTicket()
 	if err != nil {
+		log.Error("GetCreateVmTicket error:", err)
 		return false, err
 	}
+	log.Info("CreateVmTicket success")
+
 	vmId, newId, supportType := getCloneVmInfo(vmCfg.OsType, ticket)
 	if vmId == "" || newId == "" {
 		return false, nil
 	}
+	log.Info("get clone vm info success")
 	user, password := generateUser()
 	vmInfo := &models.VM{
 		VmId:        vmId,
@@ -155,11 +160,13 @@ func snatchTask(vmCfg *models.VmConfig) (bool, error) {
 		log.Error("Create vm error:", err.Error())
 		return false, err
 	}
+	log.Info("VM created successfully")
 	setRes, err := commonApi.SetVmConfig(vmInfo)
 	if err != nil || setRes == nil {
 		log.Error("Set vm config error:", err.Error())
 		return false, err
 	}
+	log.Info("Set vm config success:", setRes)
 
 	updateTranOptsNonce(1)
 	updateVmProgress(vmCreateInstance, vmInfo.VmCfg.TaskId, big.NewInt(2), bigThirty)
@@ -170,6 +177,7 @@ func snatchTask(vmCfg *models.VmConfig) (bool, error) {
 		log.Error("Start vm error:", err.Error())
 		return false, err
 	}
+	log.Info("Start vm success")
 	updateTranOptsNonce(1)
 	updateVmProgress(vmCreateInstance, vmInfo.VmCfg.TaskId, big.NewInt(3), bigForty)
 
@@ -186,22 +194,24 @@ func snatchTask(vmCfg *models.VmConfig) (bool, error) {
 		}
 		time.Sleep(time.Second * 2)
 	}
-	time.Sleep(time.Second * 60)
+	time.Sleep(time.Second * 100)
 	netWorks, err := commonApi.GetVmNetWork(vmInfo)
 	if err != nil {
 		log.Error("Get vm net work info error:", err.Error())
 		return false, err
 	}
+	log.Info("Get vm net work info ok:", &netWorks)
 	updateTranOptsNonce(1)
-	updateVmProgress(vmCreateInstance, vmInfo.VmCfg.TaskId, big.NewInt(5), bigEighty)
+	updateVmProgress(vmCreateInstance, vmInfo.VmCfg.TaskId, big.NewInt(5), bigSixty)
+
+	//_, err = commonApi.SetVmLoginUser(vmInfo)
+	//if err != nil {
+	//	log.Error("Set vm login user error:", err.Error())
+	//	return false, err
+	//}
 
-	_, err = commonApi.SetVmLoginUser(vmInfo)
-	if err != nil {
-		log.Error("Set vm login user error:", err.Error())
-		return false, err
-	}
 	updateTranOptsNonce(1)
-	updateVmProgress(vmCreateInstance, vmInfo.VmCfg.TaskId, big.NewInt(5), bigNinety)
+	updateVmProgress(vmCreateInstance, vmInfo.VmCfg.TaskId, big.NewInt(5), bigSeventy)
 
 	updateRes, err := updateVmNetWorkInfo(client, netWorks, vmInfo)
 	if err != nil {
@@ -209,26 +219,26 @@ func snatchTask(vmCfg *models.VmConfig) (bool, error) {
 		return updateRes, err
 	}
 	updateTranOptsNonce(1)
+	updateVmProgress(vmCreateInstance, vmInfo.VmCfg.TaskId, big.NewInt(5), bigEighty)
+
+	updateTranOptsNonce(1)
+	bigVmId := big.NewInt(0)
+	bigVmId.SetString(vmInfo.NewId, 10)
+	finish, err := vmCreateInstance.FinishTask(tranOpts, vmInfo.VmCfg.Owner, vmInfo.VmCfg.TaskId, bigVmId)
+	if err != nil {
+		log.Error("FinishTask error:", err)
+		return false, err
+	}
+	log.Info("FinishTask finished:", finish.Hash().String())
+	updateTranOptsNonce(1)
 	updateVmProgress(vmCreateInstance, vmInfo.VmCfg.TaskId, big.NewInt(5), bigHundred)
 	return true, nil
 }
 
 // updateVmNetWorkInfo  更新vm的网络信息
 func updateVmNetWorkInfo(client *ethclient.Client, networkInfos []*models.NetworkInfo, vmInfo *models.VM) (bool, error) {
-	internalIp := ""
-	for _, netWork := range networkInfos {
-		//if netWork.Name == hashrateCommon.Ens18 {
-		for _, ipInfo := range netWork.IpAddresses {
-			if ipInfo.IpAddressType == hashrateCommon.Ipv4 && ipInfo.IpAddress != hashrateCommon.LocalHost {
-				internalIp = ipInfo.IpAddress
-				log.Info("internalIp:", internalIp)
-				break
-			}
-		}
-		//}
-	}
+	internalIp := getInternalIp(networkInfos)
 	if internalIp == "" {
-		log.Error("In networkInfo is not found ip info")
 		return false, errors.New("internalIp is not found")
 	}
 	vmContract, err := vm.NewVm(common.HexToAddress(hashrateCommon.VmContract), client)
@@ -242,18 +252,20 @@ func updateVmNetWorkInfo(client *ethclient.Client, networkInfos []*models.Networ
 		log.Error("npsMappingNetwork is failed")
 		return false, errors.New("vmNetWorkInfo is not found")
 	}
+	log.Info("nps Mapping Network successfully")
+
 	vmId := new(big.Int)
 	vmId.SetString(vmInfo.NewId, 10)
 	updateTranOptsNonce(1)
 	addVirtualMachine, err := vmContract.AddVirtualMachine(tranOpts, vmInfo.VmCfg.Owner, vmId, "", "", hostName, vmInfo.VmCfg.Name, vmInfo.VmCfg.OsType)
 	if err != nil {
-		log.Error("addVirtualMachine failed", err.Error())
+		log.Error("addVirtualMachine failed:", err.Error())
 		return false, err
 	}
 	log.Info("Add virtual machine success:", addVirtualMachine.Hash())
 
 	updateTranOptsNonce(1)
-	updateVmNetworkInfo, err := vmContract.UpdateVmNetworkInfo(tranOpts, vmId, vmNetWorkInfo.InternalIp, vmNetWorkInfo.ExternalIp, vmNetWorkInfo.ExSshPort, vmNetWorkInfo.ExVncPort, strconv.FormatInt(vmNetWorkInfo.InSshPort, 10), strconv.FormatInt(vmNetWorkInfo.InVncPort, 10))
+	updateVmNetworkInfo, err := vmContract.UpdateVmNetworkInfo(tranOpts, vmId, vmNetWorkInfo.InternalIp, vmNetWorkInfo.ExternalIp, vmNetWorkInfo.ExSshPort, vmNetWorkInfo.ExVncPort, vmNetWorkInfo.InSshPort, vmNetWorkInfo.InVncPort)
 	if err != nil {
 		log.Error("Update virtual machine", err.Error())
 		return false, err
@@ -278,6 +290,20 @@ func updateVmNetWorkInfo(client *ethclient.Client, networkInfos []*models.Networ
 	return true, nil
 }
 
+func getInternalIp(networkInfos []*models.NetworkInfo) string {
+	internalIp := ""
+	for _, netWork := range networkInfos {
+		for _, ipInfo := range netWork.IpAddresses {
+			if ipInfo.IpAddressType == hashrateCommon.Ipv4 && ipInfo.IpAddress != hashrateCommon.LocalHost {
+				internalIp = ipInfo.IpAddress
+				log.Info("internalIp:", internalIp)
+				break
+			}
+		}
+	}
+	return internalIp
+}
+
 func npsMappingNetwork(internalIp string, supportType int) *models.VmNetWork {
 	// 获取本机的外网Ip
 	externalIp := getExternalIp()
@@ -298,8 +324,8 @@ func npsMappingNetwork(internalIp string, supportType int) *models.VmNetWork {
 	}
 	vmNetWorkInfo := &models.VmNetWork{
 		InternalIp:  internalIp,
-		InSshPort:   hashrateCommon.DefaultSshPort,
-		InVncPort:   hashrateCommon.DefaultVncPort,
+		InSshPort:   sshDefaultPort,
+		InVncPort:   vncDefaultPort,
 		ExternalIp:  externalIp,
 		SupportType: int64(supportType),
 	}
@@ -335,7 +361,7 @@ func npsMappingNetwork(internalIp string, supportType int) *models.VmNetWork {
 	} else {
 		addRes := commonApi.AddTunnel(tunnelModel)
 		if addRes.Status == hashrateCommon.NpsReqFailedStatus {
-			log.Error("Add tunnel failed error msg:", addRes.Msg)
+			log.Errorf("Add tunnel failed error msg:%s , port:%s", addRes.Msg, tunnelModel.Port)
 			return nil
 		}
 	}
@@ -390,15 +416,15 @@ func getCloneVmInfo(osType string, headerInfo *models.HeaderInfo) (string, strin
 			osNameTem := templateInfo[0]
 			versionTem := templateInfo[1]
 			supportTypeTem := templateInfo[2]
-			supportType, err = strconv.Atoi(supportTypeTem)
-			if err != nil {
-				log.Error("strconv os support type type error:", err.Error())
-				return "", "", 0
-			}
 			osInfo := strings.Split(osType, hashrateCommon.SplitSupportType)
 			osNameReq := osInfo[0]
 			versionReq := osInfo[1]
 			if osNameReq == osNameTem && versionTem == versionReq {
+				supportType, err = strconv.Atoi(supportTypeTem)
+				if err != nil {
+					log.Error("strconv os support type type error:", err.Error())
+					return "", "", 0
+				}
 				cloneId = strconv.FormatInt(qemu.VmId, 10)
 			}
 		}
@@ -409,6 +435,7 @@ func getCloneVmInfo(osType string, headerInfo *models.HeaderInfo) (string, strin
 
 // updateVmProgress  更新vm的创建进度
 func updateVmProgress(contractInstance *vmCreate.VmCreate, taskId string, stage *big.Int, progress *big.Int) bool {
+	time.Sleep(time.Second * 4)
 	task, err := contractInstance.UpdateVmCreateProgress(tranOpts, taskId, stage, progress)
 	if err != nil {
 		log.Error("UpdateVmCreateProgress error:", err)
@@ -420,7 +447,8 @@ func updateVmProgress(contractInstance *vmCreate.VmCreate, taskId string, stage
 
 // updateTranOptsNonce 	更新Nonce
 func updateTranOptsNonce(incrementNum uint64) {
-	nonce += incrementNum
+	nonce = atomic.AddUint64(&nonce, incrementNum)
 	nonceUint64 := new(big.Int).SetUint64(nonce)
 	tranOpts.Nonce = nonceUint64
+	log.Info("Send transaction nonce:", tranOpts.Nonce)
 }

common/constant.go

 package common
 
 const (
-	Stopped                   = "stopped"
-	Running                   = "running"
-	Ens18                     = "ens18"
-	Ipv4                      = "ipv4"
-	Ipv6                      = "ipv6"
-	SuccessCode               = 200
-	LocalHost                 = "127.0.0.1"
-	DefaultSshPort            = 22
-	DefaultVncPort            = 5900
-	NpsReqFailedStatus  int64 = 0
-	SplitSupportType          = "-"
-	VmSupportConnectVnc       = 1
-	VmSupportConnectSsh       = 2
-	VmSupportConnectAll       = 3
+	Stopped                                                                = "stopped"
+	Running                                                                = "running"
+	Ens18                                                                  = "ens18"
+	Ipv4                                                                   = "ipv4"
+	Ipv6                                                                   = "ipv6"
+	SuccessCode                                                            = 200
+	LocalHost                                                              = "127.0.0.1"
+	DefaultSshPort                                                         = "22"
+	DefaultVncPort                                                         = "5901"
+	NpsReqFailedStatus                                               int64 = 0
+	SplitSupportType                                                       = "-"
+	VmSupportConnectVnc                                                    = 1
+	VmSupportConnectSsh                                                    = 2
+	VmSupportConnectAll                                                    = 3
+	VmStatusEnabled, VmStatusDisable, VmStatusReboot, VmStatusDelete uint8 = 1, 2, 3, 4
 )

common/event.go

@@ -7,10 +7,11 @@ const (
 // VmCreateEvent 虚拟机创建事件
 const (
 	VmCreateEvent = "0x14cfc769ae51024fff38f2bdd079158750cf8a7676da49060b89e554166c9a2d"
+	VmStatusEvent = "0x00b24135945b85e5acabcae660e6ba246745ca707d5d8ee22aa5ebf8b199e1f6"
 )
 
 // VmCreateContract 虚拟机创建合约
 const (
-	VmContract       = "0x5Ea6719343d035A6695054278c087D7a971CA802"
-	VmCreateContract = "0x94186f71FD90486b65aC318ed6C08D4d78042307"
+	VmContract       = "0x3354D08f158d2BEFA7071F459A0a4ca2Ef797974"
+	VmCreateContract = "0xEE436a4C761f79d42154a4e526019063d3a7da41"
 )

commonApi/npsApi.go

@@ -31,22 +31,22 @@ func GetClientList() []*models.NpsClientInfo {
 	getClientListApi := npsApi + hashrateCommon.NpsGetClientList
 	formData := make(map[string]interface{})
 	formData["start"] = "0"
-	formData["limit"] = "10"
+	formData["limit"] = "1000"
 	formData["order"] = "asc"
 	request, res, err := sendNpsPostRequest(getClientListApi, formData)
 	if err != nil || !request {
-		log.Error("Nps send get client list req err:", err.Error())
+		log.Error("Nps send get client list req err:", err)
 		return nil
 	}
 	npsClientArr := make([]*models.NpsClientInfo, 0)
 	marshal, err := json.Marshal(res["rows"])
 	if err != nil {
-		log.Error("GetClientList json marshal error:", err.Error())
+		log.Error("GetClientList json marshal error:", err)
 		return nil
 	}
 	err = json.Unmarshal(marshal, &npsClientArr)
 	if err != nil {
-		log.Error("GetClientList json Unmarshal error:", err.Error())
+		log.Error("GetClientList json Unmarshal error:", err)
 		return nil
 	}
 	return npsClientArr
@@ -58,22 +58,22 @@ func GetTunnel(clientId string) []*models.TcpTunnelInfo {
 	formData["client_id"] = clientId
 	formData["type"] = "tcp"
 	formData["offset"] = "0"
-	formData["limit"] = "10"
+	formData["limit"] = "1000"
 	formData["order"] = "asc"
 	request, resMap, err := sendNpsPostRequest(getTunnelsApi, formData)
 	if !request || err != nil {
-		log.Errorf("Nps AddTunnel error, error:%s", err.Error())
+		log.Errorf("Nps AddTunnel error, error:%s", err)
 		return nil
 	}
 	res := make([]*models.TcpTunnelInfo, 0)
 	tunnelList, err := json.Marshal(resMap["rows"])
 	if err != nil {
-		log.Error("GetTunnel json marshal error:", err.Error())
+		log.Error("GetTunnel json marshal error:", err)
 		return nil
 	}
 	err = json.Unmarshal(tunnelList, &res)
 	if err != nil {
-		log.Error("GetTunnel json unmarshal error:", err.Error())
+		log.Error("GetTunnel json unmarshal error:", err)
 		return nil
 	}
 	return res
@@ -92,13 +92,13 @@ func AddTunnel(tunnelRequest *models.AddTunnelRequest) *models.NpsOperateResp {
 	}
 	request, resMap, err := sendNpsPostRequest(addTunnelApi, mapReq)
 	if !request || err != nil {
-		log.Errorf("Nps AddTunnel error, isSuccess:%s error:%s", request, err.Error())
+		log.Errorf("Nps AddTunnel error, isSuccess:%s error:%s", request, err)
 		return nil
 	}
 	res := &models.NpsOperateResp{}
 	err = mapstructure.Decode(resMap, res)
 	if err != nil {
-		log.Errorf("Nps AddTunnel mapStructure decode error:", err.Error())
+		log.Errorf("Nps AddTunnel mapStructure decode error:", err)
 		return nil
 	}
 	return res
@@ -162,18 +162,18 @@ func sendNpsPostRequest(uri string, formData map[string]interface{}) (bool, map[
 	request, err := http.NewRequest("POST", uri, payload)
 	request.Header.Set("Content-Type", writer.FormDataContentType())
 	if err != nil {
-		log.Error("Nps api new request error:", err.Error())
+		log.Error("Nps api new request error:", err)
 		return false, nil, nil
 	}
 	resp, err := client.Do(request)
 	if err != nil {
-		log.Errorf("Nps api send post request uri:%s , error:%s", uri, err.Error())
+		log.Errorf("Nps api send post request uri:%s , error:%s", uri, err)
 		return false, nil, nil
 	}
 	defer func(Body io.ReadCloser) {
 		err := Body.Close()
 		if err != nil {
-			log.Error("Nps api close body error:", err.Error())
+			log.Error("Nps api close body error:", err)
 			return
 		}
 	}(resp.Body)
@@ -188,7 +188,7 @@ func sendNpsPostRequest(uri string, formData map[string]interface{}) (bool, map[
 	var res map[string]interface{}
 	err = json.Unmarshal(body, &res)
 	if err != nil {
-		log.Error("Nps api unmarshal resp error:", err.Error())
+		log.Error("Nps api unmarshal resp error:", err)
 		return false, nil, err
 	}
 	return true, res, nil

commonApi/pveApi.go

@@ -70,6 +70,32 @@ func StartVm(vm *models.VM) (interface{}, error) {
 	return result, nil
 }
 
+func ShutdownVm(vm *models.VM) (interface{}, error) {
+	uriSuffix := fmt.Sprintf("/%s/status/shutdown", vm.NewId)
+	uri := pveNodesPrefixApi + uriSuffix
+	data := url.Values{}
+	data.Set("node", hostName)
+	data.Set("vmid", vm.NewId)
+	isSuccess, _, result, err := sendPvePostForm(uri, data, vm.HeaderInfo)
+	if err != nil || !isSuccess {
+		return nil, err
+	}
+	return result, nil
+}
+
+func RebootVm(vm *models.VM) (interface{}, error) {
+	uriSuffix := fmt.Sprintf("/%s/status/reboot", vm.NewId)
+	uri := pveNodesPrefixApi + uriSuffix
+	data := url.Values{}
+	data.Set("node", hostName)
+	data.Set("vmid", vm.NewId)
+	isSuccess, _, result, err := sendPvePostForm(uri, data, vm.HeaderInfo)
+	if err != nil || !isSuccess {
+		return nil, err
+	}
+	return result, nil
+}
+
 // CreateVm 通过模版克隆对应的vm
 func CreateVm(vm *models.VM) (interface{}, error) {
 	uriSuffix := fmt.Sprintf("/%s/clone", vm.VmId)

conf/app.conf

@@ -14,11 +14,11 @@ sendTranAddress = 0x257A1F95F3C09a0A2F4d82d3f916E8DbCE084659
 sendTranPrv = 0xfd5cc6f5e7e2805e920ac5dc83d5af1106f9c92f0c04f9d5e1fd4261b4b4464a
 deployedBlock = 1
 
-vncDefaultPort = 5900
+vncDefaultPort = 5901
 sshDefaultPort = 22
 
 [nps]
-api_host = http://124.193.167.71
+api_host = 124.193.167.71
 api_port = 8090
 auth_crypt_key = 90ac0231b59d4f7e
 

contract/VmContract/Vm.abi

- [
+[
     {
       "inputs": [
         {
@@ -152,6 +152,25 @@
       "name": "UpdateVMInfoEvent",
       "type": "event"
     },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "vmId",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint8",
+          "name": "status",
+          "type": "uint8"
+        }
+      ],
+      "name": "UpdateVmStatus",
+      "type": "event"
+    },
     {
       "inputs": [],
       "name": "_const",
@@ -257,6 +276,79 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "vmId",
+          "type": "uint256"
+        }
+      ],
+      "name": "delVm",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "vmId",
+          "type": "uint256"
+        }
+      ],
+      "name": "disableVm",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "vmId",
+          "type": "uint256"
+        }
+      ],
+      "name": "enableVm",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "vmId",
+          "type": "uint256"
+        }
+      ],
+      "name": "getVmConfigInfo",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "cpuCores",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "memNum",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "gpuNum",
+          "type": "uint256"
+        },
+        {
+          "internalType": "string",
+          "name": "osName",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -310,6 +402,25 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "vmId",
+          "type": "uint256"
+        }
+      ],
+      "name": "getVmStatus",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -366,6 +477,19 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "vmId",
+          "type": "uint256"
+        }
+      ],
+      "name": "rebootVm",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [],
       "name": "renounceOwnership",
@@ -508,6 +632,24 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "vmId",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint8",
+          "name": "status",
+          "type": "uint8"
+        }
+      ],
+      "name": "updateVmStatus",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -532,6 +674,68 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "name": "vmIdCreator",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "name": "vmIdOwner",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "name": "vmIds",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -555,5 +759,24 @@
       ],
       "stateMutability": "view",
       "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "name": "vmStatus",
+      "outputs": [
+        {
+          "internalType": "uint8",
+          "name": "",
+          "type": "uint8"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
     }
   ]
\ No newline at end of file

contract/VmCreateContract/VmCreate.abi

- [
+[
     {
       "inputs": [
         {
@@ -384,6 +384,30 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "name": "taskOwnerMapping",
+      "outputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -408,6 +432,68 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "name": "taskSnatchMapping",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "name": "taskTimeMapping",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        },
+        {
+          "internalType": "string",
+          "name": "",
+          "type": "string"
+        }
+      ],
+      "name": "taskVmidMapping",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [
         {

models/contractEvent.go

@@ -8,6 +8,6 @@ type CreteVmEvent struct {
 }
 
 type VmStatusEvent struct {
-	TaskId   string   `json:"taskId"`
-	Progress *big.Int `json:"progress"`
+	VmId   *big.Int `json:"vmId"`
+	Status uint8    `json:"status"`
 }

models/pveRequest.go

@@ -42,8 +42,8 @@ type VmConfig struct {
 
 type VmNetWork struct {
 	InternalIp  string `json:"internal_ip"`
-	InSshPort   int64  `json:"in_ssh_port"`
-	InVncPort   int64  `json:"in_vnc_port"`
+	InSshPort   string `json:"in_ssh_port"`
+	InVncPort   string `json:"in_vnc_port"`
 	ExternalIp  string `json:"external_ip"`
 	ExSshPort   string `json:"ex_ssh_port"`
 	ExVncPort   string `json:"ex_vnc_port"`