- instance snapshot

- instance clone

- create form snapshot don't reset passwd

pkg/compute/tasks/disk_reset_task.go

@@ -55,7 +55,7 @@ func (self *DiskResetTask) TaskCompleted(ctx context.Context, disk *models.SDisk
 			guests[0].StartGueststartTask(ctx, self.UserCred, nil, self.GetTaskId())
 		}
 	} else {
-		if len(guests) == 1 {
+		if len(guests) == 1 && !self.IsSubtask() {
 			guests[0].SetStatus(self.UserCred, api.VM_READY, "")
 		}
 		// data不能为空指针，否则会导致AddActionLog抛空指针异常

pkg/compute/tasks/guest_disk_snapshot_task.go

@@ -52,7 +52,9 @@ func (self *GuestDiskSnapshotTask) DoDiskSnapshot(ctx context.Context, guest *mo
 		self.TaskFailed(ctx, guest, err.Error())
 		return
 	}
-	self.SetStage("OnDiskSnapshotComplete", nil)
+	params := jsonutils.NewDict()
+	params.Set("guest_old_status", jsonutils.NewString(guest.Status))
+	self.SetStage("OnDiskSnapshotComplete", params)
 	guest.SetStatus(self.UserCred, api.VM_SNAPSHOT, "")
 	err = guest.GetDriver().RequestDiskSnapshot(ctx, guest, self, snapshotId, diskId)
 	if err != nil {
@@ -87,7 +89,8 @@ func (self *GuestDiskSnapshotTask) OnDiskSnapshotCompleteFailed(ctx context.Cont
 
 func (self *GuestDiskSnapshotTask) TaskComplete(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
 	logclient.AddActionLogWithStartable(self, guest, logclient.ACT_DISK_CREATE_SNAPSHOT, nil, self.UserCred, true)
-	guest.StartSyncstatus(ctx, self.UserCred, "")
+	status, _ := self.Params.GetString("guest_old_status")
+	guest.SetStatus(self.UserCred, status, "on guest disk snapshot complete")
 	self.SetStageComplete(ctx, nil)
 }
 

pkg/compute/tasks/instance_snapshot_and_clone_task.go

@@ -0,0 +1,130 @@
+package tasks
+
+import (
+	"context"
+	"fmt"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/log"
+
+	"yunion.io/x/onecloud/pkg/apis/compute"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
+	"yunion.io/x/onecloud/pkg/compute/models"
+	"yunion.io/x/onecloud/pkg/util/logclient"
+	"yunion.io/x/onecloud/pkg/util/rbacutils"
+)
+
+type InstanceSnapshotAndCloneTask struct {
+	taskman.STask
+}
+
+func init() {
+	taskman.RegisterTask(InstanceSnapshotAndCloneTask{})
+}
+
+func (self *InstanceSnapshotAndCloneTask) taskFailed(
+	ctx context.Context, isp *models.SInstanceSnapshot, reason string) {
+	guest := models.GuestManager.FetchGuestById(isp.GuestId)
+	guest.SetStatus(self.UserCred, compute.VM_SNAPSHOT_AND_CLONE_FAILED, reason)
+	logclient.AddActionLogWithContext(
+		ctx, guest, logclient.ACT_VM_SNAPSHOT_AND_CLONE, reason, self.UserCred, false,
+	)
+	db.OpsLog.LogEvent(guest, db.ACT_VM_SNAPSHOT_AND_CLONE_FAILED, reason, self.UserCred)
+	self.SetStageFailed(ctx, reason)
+}
+
+func (self *InstanceSnapshotAndCloneTask) taskComplete(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+	self.finalReleasePendingUsage(ctx)
+	guest := models.GuestManager.FetchGuestById(isp.GuestId)
+	guest.StartSyncstatus(ctx, self.UserCred, "")
+	db.OpsLog.LogEvent(guest, db.ACT_VM_SNAPSHOT_AND_CLONE, "", self.UserCred)
+	logclient.AddActionLogWithContext(
+		ctx, guest, logclient.ACT_VM_SNAPSHOT_AND_CLONE, "", self.UserCred, true)
+	self.SetStageComplete(ctx, nil)
+}
+
+func (self *InstanceSnapshotAndCloneTask) SetStageFailed(ctx context.Context, reason string) {
+	self.finalReleasePendingUsage(ctx)
+	self.STask.SetStageFailed(ctx, reason)
+}
+
+func (self *InstanceSnapshotAndCloneTask) finalReleasePendingUsage(ctx context.Context) {
+	pendingUsage := models.SQuota{}
+	err := self.GetPendingUsage(&pendingUsage)
+	if err == nil && !pendingUsage.IsEmpty() {
+		isp := self.GetObject().(*models.SInstanceSnapshot)
+		guest := models.GuestManager.FetchGuestById(isp.GuestId)
+		quotaPlatform := guest.GetQuotaPlatformID()
+		models.QuotaManager.CancelPendingUsage(
+			ctx, self.UserCred, rbacutils.ScopeProject,
+			guest.GetOwnerId(), quotaPlatform, &pendingUsage, &pendingUsage,
+		)
+	}
+}
+
+func (self *InstanceSnapshotAndCloneTask) OnInit(
+	ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
+
+	isp := obj.(*models.SInstanceSnapshot)
+	guest := models.GuestManager.FetchGuestById(isp.GuestId)
+
+	self.SetStage("OnCreateInstanceSnapshot", nil)
+	err := isp.StartCreateInstanceSnapshotTask(ctx, self.UserCred, guest.GetOwnerId(), nil, self.Id)
+	if err != nil {
+		self.taskFailed(ctx, isp, err.Error())
+		return
+	}
+}
+
+func (self *InstanceSnapshotAndCloneTask) OnCreateInstanceSnapshot(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+	// start create server
+	params, err := self.Params.Get("guest_params")
+	if err != nil {
+		self.taskFailed(ctx, isp, "Failed get new guest params")
+		return
+	}
+	count, _ := params.Int("count")
+	if count == 0 {
+		count = 1
+	}
+	err = self.doGuestCreate(ctx, isp, params, int(count))
+	if err != nil {
+		self.taskFailed(ctx, isp, err.Error())
+		return
+	}
+	self.taskComplete(ctx, isp, nil)
+}
+
+func (self *InstanceSnapshotAndCloneTask) doGuestCreate(
+	ctx context.Context, isp *models.SInstanceSnapshot, params jsonutils.JSONObject, count int) error {
+	dictParmas := params.(*jsonutils.JSONDict)
+	var errStr string
+	for i := 0; i < count; i++ {
+		newGuest, input, err := models.GuestManager.CreateGuestFromInstanceSnapshot(
+			ctx, self.UserCred, dictParmas.DeepCopy().(*jsonutils.JSONDict), isp, i+1)
+		if err != nil {
+			log.Errorln(err)
+			errStr += err.Error() + "\n"
+			continue
+		}
+		models.GuestManager.OnCreateComplete(ctx, []db.IModel{newGuest}, self.UserCred, nil, input)
+	}
+	if len(errStr) > 0 {
+		return fmt.Errorf(errStr)
+	}
+	return nil
+}
+
+func (self *InstanceSnapshotAndCloneTask) OnGuestCreated(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+
+	self.taskComplete(ctx, isp, data)
+}
+
+func (self *InstanceSnapshotAndCloneTask) OnCreateInstanceSnapshotFailed(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+	self.taskFailed(ctx, isp, data.String())
+}

pkg/compute/tasks/instance_snapshot_create_task.go

@@ -0,0 +1,144 @@
+package tasks
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"time"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/pkg/util/timeutils"
+
+	"yunion.io/x/onecloud/pkg/apis/compute"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
+	"yunion.io/x/onecloud/pkg/cloudcommon/notifyclient"
+	"yunion.io/x/onecloud/pkg/compute/models"
+	"yunion.io/x/onecloud/pkg/util/logclient"
+	"yunion.io/x/onecloud/pkg/util/rbacutils"
+)
+
+type InstanceSnapshotCreateTask struct {
+	taskman.STask
+}
+
+func init() {
+	taskman.RegisterTask(InstanceSnapshotCreateTask{})
+}
+
+func (self *InstanceSnapshotCreateTask) SetStageFailed(ctx context.Context, reason string) {
+	self.finalReleasePendingUsage(ctx)
+	self.STask.SetStageFailed(ctx, reason)
+}
+
+func (self *InstanceSnapshotCreateTask) finalReleasePendingUsage(ctx context.Context) {
+	pendingUsage := models.SQuota{}
+	err := self.GetPendingUsage(&pendingUsage)
+	if err == nil && !pendingUsage.IsEmpty() {
+		isp := self.GetObject().(*models.SInstanceSnapshot)
+		guest := models.GuestManager.FetchGuestById(isp.GuestId)
+		quotaPlatform := guest.GetQuotaPlatformID()
+		models.QuotaManager.CancelPendingUsage(
+			ctx, self.UserCred, rbacutils.ScopeProject,
+			guest.GetOwnerId(), quotaPlatform, &pendingUsage, &pendingUsage,
+		)
+	}
+}
+
+func (self *InstanceSnapshotCreateTask) taskFail(
+	ctx context.Context, isp *models.SInstanceSnapshot, guest *models.SGuest, reason string) {
+
+	if guest == nil {
+		guest = models.GuestManager.FetchGuestById(isp.GuestId)
+	}
+	isp.SetStatus(self.UserCred, compute.INSTANCE_SNAPSHOT_FAILED, reason)
+	guest.SetStatus(self.UserCred, compute.VM_INSTANCE_SNAPSHOT_FAILED, reason)
+
+	db.OpsLog.LogEvent(isp, db.ACT_ALLOCATE_FAIL, reason, self.UserCred)
+	logclient.AddActionLogWithStartable(self, isp, logclient.ACT_CREATE, false, self.UserCred, false)
+	notifyclient.NotifySystemError(isp.GetId(), isp.Name, compute.INSTANCE_SNAPSHOT_FAILED, reason)
+	self.SetStageFailed(ctx, reason)
+}
+
+func (self *InstanceSnapshotCreateTask) taskComplete(
+	ctx context.Context, isp *models.SInstanceSnapshot, guest *models.SGuest, data jsonutils.JSONObject) {
+
+	self.finalReleasePendingUsage(ctx)
+	if guest == nil {
+		guest = models.GuestManager.FetchGuestById(isp.GuestId)
+	}
+	isp.SetStatus(self.UserCred, compute.INSTANCE_SNAPSHOT_READY, "")
+	guest.StartSyncstatus(ctx, self.UserCred, "")
+
+	db.OpsLog.LogEvent(isp, db.ACT_ALLOCATE, "instance snapshot create success", self.UserCred)
+	logclient.AddActionLogWithStartable(self, isp, logclient.ACT_CREATE, false, self.UserCred, true)
+	self.SetStageComplete(ctx, nil)
+}
+
+func (self *InstanceSnapshotCreateTask) OnInit(
+	ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
+
+	isp := obj.(*models.SInstanceSnapshot)
+	guest := models.GuestManager.FetchGuestById(isp.GuestId)
+
+	self.GuestDiskCreateSnapshot(ctx, isp, guest, 0)
+}
+
+func (self *InstanceSnapshotCreateTask) GuestDiskCreateSnapshot(
+	ctx context.Context, isp *models.SInstanceSnapshot, guest *models.SGuest, diskIndex int) {
+
+	disks := guest.GetDisks()
+	if diskIndex >= len(disks) {
+		self.taskComplete(ctx, isp, guest, nil)
+		return
+	}
+
+	snapshot, err := models.SnapshotManager.CreateSnapshot(
+		ctx, self.UserCred, compute.SNAPSHOT_MANUAL, disks[diskIndex].DiskId, guest.Id,
+		"", fmt.Sprintf("%s-snapshot-%s", guest.Name, timeutils.CompactTime(time.Now())), -1)
+	if err != nil {
+		self.taskFail(ctx, isp, guest, err.Error())
+		return
+	}
+
+	params := jsonutils.NewDict()
+	params.Set("disk_index", jsonutils.NewInt(int64(diskIndex)))
+	params.Set(strconv.Itoa(diskIndex), jsonutils.NewString(snapshot.Id))
+	self.SetStage("OnDiskSnapshot", params)
+
+	if err := snapshot.StartSnapshotCreateTask(ctx, self.UserCred, nil, self.Id); err != nil {
+		self.taskFail(ctx, isp, guest, err.Error())
+		return
+	}
+}
+
+func (self *InstanceSnapshotCreateTask) OnDiskSnapshot(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+
+	guest := models.GuestManager.FetchGuestById(isp.GuestId)
+
+	diskIndex, err := self.Params.Int("disk_index")
+	if err != nil {
+		self.taskFail(ctx, isp, guest, err.Error())
+		return
+	}
+
+	snapshotId, err := self.Params.GetString(strconv.Itoa(int(diskIndex)))
+	if err != nil {
+		self.taskFail(ctx, isp, guest, err.Error())
+		return
+	}
+
+	err = models.InstanceSnapshotJointManager.CreateJoint(isp.Id, snapshotId, int8(diskIndex))
+	if err != nil {
+		self.taskFail(ctx, isp, guest, err.Error())
+		return
+	}
+
+	self.GuestDiskCreateSnapshot(ctx, isp, guest, int(diskIndex+1))
+}
+
+func (self *InstanceSnapshotCreateTask) OnDiskSnapshotFailed(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+	self.taskFail(ctx, isp, nil, data.String())
+}

pkg/compute/tasks/instance_snapshot_delete_task.go

@@ -0,0 +1,93 @@
+package tasks
+
+import (
+	"context"
+
+	"yunion.io/x/jsonutils"
+
+	"yunion.io/x/onecloud/pkg/apis/compute"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
+	"yunion.io/x/onecloud/pkg/compute/models"
+	"yunion.io/x/onecloud/pkg/util/logclient"
+)
+
+type InstanceSnapshotDeleteTask struct {
+	taskman.STask
+}
+
+func init() {
+	taskman.RegisterTask(InstanceSnapshotDeleteTask{})
+}
+
+func (self *InstanceSnapshotDeleteTask) taskFail(
+	ctx context.Context, isp *models.SInstanceSnapshot, reason string) {
+
+	isp.SetStatus(self.UserCred, compute.INSTANCE_SNAPSHOT_DELETE_FAILED, "on delete failed")
+	db.OpsLog.LogEvent(isp, db.ACT_DELETE_FAIL, reason, self.UserCred)
+	logclient.AddActionLogWithContext(ctx, isp, logclient.ACT_DELETE, reason, self.UserCred, false)
+	self.SetStageFailed(ctx, reason)
+}
+
+func (self *InstanceSnapshotDeleteTask) taskComplete(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+
+	isp.RealDelete(ctx, self.UserCred)
+	logclient.AddActionLogWithContext(ctx, isp, logclient.ACT_DELETE, nil, self.UserCred, true)
+	self.SetStageComplete(ctx, nil)
+}
+
+func (self *InstanceSnapshotDeleteTask) OnInit(
+	ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
+
+	isp := obj.(*models.SInstanceSnapshot)
+	self.SetStage("OnSnapshotDelete", nil)
+	self.StartSnapshotDelete(ctx, isp)
+}
+
+func (self *InstanceSnapshotDeleteTask) StartSnapshotDelete(
+	ctx context.Context, isp *models.SInstanceSnapshot) {
+
+	snapshots, err := isp.GetSnapshots()
+	if err != nil {
+		self.taskFail(ctx, isp, err.Error())
+		return
+	}
+	if len(snapshots) == 0 {
+		self.taskComplete(ctx, isp, nil)
+		return
+	}
+
+	// detach snapshot and instance
+	isjp := new(models.SInstanceSnapshotJoint)
+	err = models.InstanceSnapshotJointManager.Query().
+		Equals("instance_snapshot_id", isp.Id).Equals("snapshot_id", snapshots[0].Id).First(isjp)
+	if err != nil {
+		self.taskFail(ctx, isp, err.Error())
+		return
+	}
+	isjp.SetModelManager(models.InstanceSnapshotJointManager, isjp)
+	err = isjp.Delete(ctx, self.UserCred)
+	if err != nil {
+		self.taskFail(ctx, isp, err.Error())
+		return
+	}
+
+	err = snapshots[0].StartSnapshotDeleteTask(ctx, self.UserCred, false, self.Id)
+	if err != nil {
+		self.taskFail(ctx, isp, err.Error())
+		return
+	}
+}
+
+func (self *InstanceSnapshotDeleteTask) OnSnapshotDelete(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+
+	self.StartSnapshotDelete(ctx, isp)
+}
+
+func (self *InstanceSnapshotDeleteTask) OnSnapshotDeleteFailed(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+
+	self.taskFail(ctx, isp, data.String())
+}

pkg/compute/tasks/instance_snapshot_reset_task.go

@@ -0,0 +1,103 @@
+package tasks
+
+import (
+	"context"
+
+	"yunion.io/x/jsonutils"
+
+	"yunion.io/x/onecloud/pkg/apis/compute"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
+	"yunion.io/x/onecloud/pkg/cloudcommon/notifyclient"
+	"yunion.io/x/onecloud/pkg/compute/models"
+	"yunion.io/x/onecloud/pkg/util/logclient"
+)
+
+type InstanceSnapshotResetTask struct {
+	taskman.STask
+}
+
+func init() {
+	taskman.RegisterTask(InstanceSnapshotResetTask{})
+}
+
+func (self *InstanceSnapshotResetTask) taskFail(
+	ctx context.Context, isp *models.SInstanceSnapshot, guest *models.SGuest, reason string) {
+
+	if guest == nil {
+		guest = models.GuestManager.FetchGuestById(isp.GuestId)
+	}
+	guest.SetStatus(self.UserCred, compute.VM_SNAPSHOT_RESET_FAILED, reason)
+
+	db.OpsLog.LogEvent(guest, db.ACT_VM_RESET_SNAPSHOT_FAILED, reason, self.UserCred)
+	logclient.AddActionLogWithStartable(self, guest, logclient.ACT_VM_RESET, false, self.UserCred, false)
+	notifyclient.NotifySystemError(guest.GetId(), isp.Name, compute.VM_SNAPSHOT_RESET_FAILED, reason)
+	self.SetStageFailed(ctx, reason)
+}
+
+func (self *InstanceSnapshotResetTask) taskComplete(
+	ctx context.Context, isp *models.SInstanceSnapshot, guest *models.SGuest, data jsonutils.JSONObject) {
+
+	if guest == nil {
+		guest = models.GuestManager.FetchGuestById(isp.GuestId)
+	}
+	guest.StartSyncstatus(ctx, self.UserCred, "")
+
+	db.OpsLog.LogEvent(isp, db.ACT_VM_RESET_SNAPSHOT, "instance snapshot reset success", self.UserCred)
+	logclient.AddActionLogWithStartable(self, guest, logclient.ACT_VM_RESET, false, self.UserCred, true)
+	self.SetStageComplete(ctx, nil)
+}
+
+func (self *InstanceSnapshotResetTask) OnInit(
+	ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
+
+	isp := obj.(*models.SInstanceSnapshot)
+	guest := models.GuestManager.FetchGuestById(isp.GuestId)
+
+	self.GuestDiskResetTask(ctx, isp, guest, 0)
+}
+
+func (self *InstanceSnapshotResetTask) GuestDiskResetTask(
+	ctx context.Context, isp *models.SInstanceSnapshot, guest *models.SGuest, diskIndex int) {
+
+	disks := guest.GetDisks()
+	if diskIndex >= len(disks) {
+		self.taskComplete(ctx, isp, guest, nil)
+		return
+	}
+
+	isj, err := isp.GetInstanceSnapshotJointAt(diskIndex)
+	if err != nil {
+		self.taskFail(ctx, isp, guest, err.Error())
+		return
+	}
+
+	params := jsonutils.NewDict()
+	params.Set("disk_index", jsonutils.NewInt(int64(diskIndex)))
+	self.SetStage("OnDiskReset", params)
+
+	disk := disks[diskIndex].GetDisk()
+	err = disk.StartResetDisk(ctx, self.UserCred, isj.SnapshotId, false, guest, self.Id)
+	if err != nil {
+		self.taskFail(ctx, isp, guest, err.Error())
+		return
+	}
+}
+
+func (self *InstanceSnapshotResetTask) OnDiskReset(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+
+	guest := models.GuestManager.FetchGuestById(isp.GuestId)
+
+	diskIndex, err := self.Params.Int("disk_index")
+	if err != nil {
+		self.taskFail(ctx, isp, guest, err.Error())
+		return
+	}
+	self.GuestDiskResetTask(ctx, isp, guest, int(diskIndex+1))
+}
+
+func (self *InstanceSnapshotResetTask) OnDiskResetFailed(
+	ctx context.Context, isp *models.SInstanceSnapshot, data jsonutils.JSONObject) {
+	self.taskFail(ctx, isp, nil, data.String())
+}