cloudpods/pkg/compute/tasks/guest_change_config_task.go

package tasks

import (
	"context"
	"fmt"

	"yunion.io/x/jsonutils"

	"yunion.io/x/onecloud/pkg/cloudcommon/db"
	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
	"yunion.io/x/onecloud/pkg/compute/models"
	"yunion.io/x/onecloud/pkg/util/logclient"
)

type GuestChangeConfigTask struct {
	SGuestBaseTask
}

func init() {
	taskman.RegisterTask(GuestChangeConfigTask{})
}

func (self *GuestChangeConfigTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
	_, err := self.Params.Get("resize")
	if err == nil {
		self.SetStage("on_disks_resize_complete", nil)
		self.OnDisksResizeComplete(ctx, obj, data)
	} else {
		guest := obj.(*models.SGuest)
		self.DoCreateDisksTask(ctx, guest)
	}
}

func (self *GuestChangeConfigTask) OnDisksResizeComplete(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
	guest := obj.(*models.SGuest)

	iResizeDisks, err := self.Params.Get("resize")
	if iResizeDisks == nil || err != nil {
		self.markStageFailed(ctx, guest, err.Error())
		return
	}
	resizeDisks := iResizeDisks.(*jsonutils.JSONArray)
	for i := 0; i < resizeDisks.Length(); i++ {
		iResizeSet, err := resizeDisks.GetAt(i)
		if err != nil {
			self.markStageFailed(ctx, guest, fmt.Sprintf("resizeDisks.GetAt fail %s", err))
			return
		}
		resizeSet := iResizeSet.(*jsonutils.JSONArray)
		diskId, err := resizeSet.GetAt(0)
		if err != nil {
			self.markStageFailed(ctx, guest, fmt.Sprintf("resizeSet.GetAt(0) fail %s", err))
			return
		}
		idStr, err := diskId.GetString()
		if err != nil {
			self.markStageFailed(ctx, guest, fmt.Sprintf("diskId.GetString fail %s", err))
			return
		}
		jSize, err := resizeSet.GetAt(1)
		if err != nil {
			self.markStageFailed(ctx, guest, fmt.Sprintf("resizeSet.GetAt(1) fail %s", err))
			return
		}
		size, err := jSize.Int()
		if err != nil {
			self.markStageFailed(ctx, guest, fmt.Sprintf("jSize.Int fail %s", err))
			return
		}
		iDisk, err := models.DiskManager.FetchById(idStr)
		if err != nil {
			self.markStageFailed(ctx, guest, fmt.Sprintf("models.DiskManager.FetchById(idStr) fail %s", err))
			return
		}
		disk := iDisk.(*models.SDisk)
		if disk.DiskSize < int(size) {
			var pendingUsage models.SQuota
			err = self.GetPendingUsage(&pendingUsage)
			if err != nil {
				self.markStageFailed(ctx, guest, fmt.Sprintf("self.GetPendingUsage(&pendingUsage) fail %s", err))
				return
			}
			err = disk.StartDiskResizeTask(ctx, self.UserCred, size, self.GetTaskId(), &pendingUsage, guest)
			if err != nil {
				self.markStageFailed(ctx, guest, fmt.Sprintf("disk.StartDiskResizeTask fail %s", err))
				return
			}
			return
		}
	}

	self.DoCreateDisksTask(ctx, guest)
}

func (self *GuestChangeConfigTask) DoCreateDisksTask(ctx context.Context, guest *models.SGuest) {
	iCreateData, err := self.Params.Get("create")
	if err != nil || iCreateData == nil {
		self.OnCreateDisksComplete(ctx, guest, nil)
		return
	}
	data := (iCreateData).(*jsonutils.JSONDict)
	self.SetStage("on_create_disks_complete", nil)
	guest.StartGuestCreateDiskTask(ctx, self.UserCred, data, self.GetTaskId())
}

func (self *GuestChangeConfigTask) OnCreateDisksCompleteFailed(ctx context.Context, obj db.IStandaloneModel, err jsonutils.JSONObject) {
	guest := obj.(*models.SGuest)
	self.markStageFailed(ctx, guest, fmt.Sprintf("OnCreateDisksCompleteFailed %s", err))
}

func (self *GuestChangeConfigTask) OnCreateDisksComplete(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
	guest := obj.(*models.SGuest)

	if self.Params.Contains("instance_type") || self.Params.Contains("vcpu_count") || self.Params.Contains("vmem_size") {
		self.SetStage("OnGuestChangeCpuMemSpecComplete", nil)
		instanceType, _ := self.Params.GetString("instance_type")
		vcpuCount, _ := self.Params.Int("vcpu_count")
		vmemSize, _ := self.Params.Int("vmem_size")
		if vcpuCount == 0 {
			vcpuCount = int64(guest.VcpuCount)
		}
		if vmemSize == 0 {
			vmemSize = int64(guest.VmemSize)
		}
		self.startGuestChangeCpuMemSpec(ctx, guest, instanceType, vcpuCount, vmemSize)
	} else {
		self.OnGuestChangeCpuMemSpecComplete(ctx, obj, data)
	}
}

func (self *GuestChangeConfigTask) startGuestChangeCpuMemSpec(ctx context.Context, guest *models.SGuest, instanceType string, vcpuCount int64, vmemSize int64) {
	err := guest.GetDriver().RequestChangeVmConfig(ctx, guest, self, instanceType, vcpuCount, vmemSize)
	if err != nil {
		self.markStageFailed(ctx, guest, fmt.Sprintf("guest.GetDriver().RequestChangeVmConfig fail %s", err))
		return
	}
}

func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecCompleteFailed(ctx context.Context, obj db.IStandaloneModel, err jsonutils.JSONObject) {
	guest := obj.(*models.SGuest)
	self.markStageFailed(ctx, guest, fmt.Sprintf("guest.GetDriver().RequestChangeVmConfig fail %s", err))
}

func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecComplete(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
	guest := obj.(*models.SGuest)

	instanceType, _ := self.Params.GetString("instance_type")
	vcpuCount, _ := self.Params.Int("vcpu_count")
	vmemSize, _ := self.Params.Int("vmem_size")

	addCpu := int(vcpuCount - int64(guest.VcpuCount))
	addMem := int(vmemSize - int64(guest.VmemSize))

	_, err := guest.GetModelManager().TableSpec().Update(guest, func() error {
		if vcpuCount > 0 {
			guest.VcpuCount = int8(vcpuCount)
		}
		if vmemSize > 0 {
			guest.VmemSize = int(vmemSize)
		}
		if len(instanceType) > 0 {
			guest.InstanceType = instanceType
		}
		return nil
	})
	if err != nil {
		self.markStageFailed(ctx, guest, fmt.Sprintf("Update fail %s", err))
		return
	}

	var pendingUsage models.SQuota
	err = self.GetPendingUsage(&pendingUsage)
	if err != nil {
		self.markStageFailed(ctx, guest, fmt.Sprintf("GetPendingUsage %s", err))
		return
	}
	var cancelUsage models.SQuota
	if addCpu > 0 {
		cancelUsage.Cpu = addCpu
	}
	if addMem > 0 {
		cancelUsage.Memory = addMem
	}

	lockman.LockClass(ctx, guest.GetModelManager(), guest.ProjectId)
	defer lockman.ReleaseClass(ctx, guest.GetModelManager(), guest.ProjectId)

	err = models.QuotaManager.CancelPendingUsage(ctx, self.UserCred, guest.ProjectId, &pendingUsage, &cancelUsage)
	if err != nil {
		self.markStageFailed(ctx, guest, fmt.Sprintf("CancelPendingUsage fail %s", err))
		return
	}
	err = self.SetPendingUsage(&pendingUsage)
	if err != nil {
		self.markStageFailed(ctx, guest, fmt.Sprintf("SetPendingUsage fail %s", err))
		return
	}

	self.OnGuestChangeCpuMemSpecFinish(ctx, guest)
}

func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecFinish(ctx context.Context, guest *models.SGuest) {
	self.SetStage("on_sync_config_complete", nil)
	err := guest.StartSyncTask(ctx, self.UserCred, false, self.GetTaskId())
	if err != nil {
		self.markStageFailed(ctx, guest, fmt.Sprintf("StartSyncstatus fail %s", err))
		return
	}
}

func (self *GuestChangeConfigTask) OnSyncConfigComplete(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
	guest := obj.(*models.SGuest)

	self.SetStage("on_sync_status_complete", nil)
	err := guest.StartSyncstatus(ctx, self.UserCred, self.GetTaskId())
	if err != nil {
		self.markStageFailed(ctx, guest, fmt.Sprintf("StartSyncstatus fail %s", err))
		return
	}
}

func (self *GuestChangeConfigTask) OnSyncStatusComplete(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
	guest := obj.(*models.SGuest)
	if guest.Status == models.VM_READY && jsonutils.QueryBoolean(self.Params, "auto_start", false) {
		self.SetStage("on_guest_start_complete", nil)
		guest.StartGueststartTask(ctx, self.UserCred, nil, self.GetTaskId())
	} else {
		dt := jsonutils.NewDict()
		dt.Add(jsonutils.NewString(guest.Id), "id")
		self.SetStageComplete(ctx, dt)
	}
	logclient.AddActionLogWithStartable(self, guest, logclient.ACT_VM_CHANGE_FLAVOR, "", self.UserCred, true)
}

func (self *GuestChangeConfigTask) OnGuestStartComplete(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
	guest := obj.(*models.SGuest)
	dt := jsonutils.NewDict()
	dt.Add(jsonutils.NewString(guest.Id), "id")
	self.SetStageComplete(ctx, dt)
}

func (self *GuestChangeConfigTask) markStageFailed(ctx context.Context, guest *models.SGuest, reason string) {
	guest.SetStatus(self.UserCred, models.VM_CHANGE_FLAVOR_FAIL, reason)
	db.OpsLog.LogEvent(guest, db.ACT_CHANGE_FLAVOR_FAIL, reason, self.UserCred)
	logclient.AddActionLogWithStartable(self, guest, logclient.ACT_VM_CHANGE_FLAVOR, reason, self.UserCred, false)
	self.SetStageFailed(ctx, reason)
}