fix(region,host): slvm misc fix (#20271)

pkg/compute/hostdrivers/baremetal.go

@@ -139,6 +139,6 @@ func (self *SBaremetalHostDriver) RequestSaveUploadImageOnHost(ctx context.Conte
 	return fmt.Errorf("not supported")
 }
 
-func (self *SBaremetalHostDriver) RequestUncacheImage(ctx context.Context, host *models.SHost, storageCache *models.SStoragecache, task taskman.ITask) error {
+func (self *SBaremetalHostDriver) RequestUncacheImage(ctx context.Context, host *models.SHost, storageCache *models.SStoragecache, task taskman.ITask, deactivateImage bool) error {
 	return fmt.Errorf("not supported")
 }

pkg/compute/hostdrivers/kvm.go

@@ -252,7 +252,7 @@ func (self *SKVMHostDriver) CheckAndSetCacheImage(ctx context.Context, userCred
 	return nil
 }
 
-func (self *SKVMHostDriver) RequestUncacheImage(ctx context.Context, host *models.SHost, storageCache *models.SStoragecache, task taskman.ITask) error {
+func (self *SKVMHostDriver) RequestUncacheImage(ctx context.Context, host *models.SHost, storageCache *models.SStoragecache, task taskman.ITask, deactivateImage bool) error {
 	type contentStruct struct {
 		ImageId        string
 		StoragecacheId string
@@ -272,6 +272,9 @@ func (self *SKVMHostDriver) RequestUncacheImage(ctx context.Context, host *model
 
 	body := jsonutils.NewDict()
 	body.Add(jsonutils.Marshal(&content), "disk")
+	if deactivateImage {
+		body.Add(jsonutils.JSONTrue, "deactivate_image")
+	}
 
 	header := task.GetTaskRequestHeader()
 

pkg/compute/hostdrivers/managedvirtual.go

@@ -160,7 +160,7 @@ func (self *SManagedVirtualizationHostDriver) CheckAndSetCacheImage(ctx context.
 	return nil
 }
 
-func (self *SManagedVirtualizationHostDriver) RequestUncacheImage(ctx context.Context, host *models.SHost, storageCache *models.SStoragecache, task taskman.ITask) error {
+func (self *SManagedVirtualizationHostDriver) RequestUncacheImage(ctx context.Context, host *models.SHost, storageCache *models.SStoragecache, task taskman.ITask, deactivateImage bool) error {
 	params := task.GetParams()
 	imageId, err := params.GetString("image_id")
 	if err != nil {

pkg/compute/models/hostdrivers.go

@@ -38,7 +38,7 @@ type IHostDriver interface {
 	RequestSyncBaremetalHostConfig(ctx context.Context, userCred mcclient.TokenCredential, baremetal *SHost, task taskman.ITask) error
 
 	CheckAndSetCacheImage(ctx context.Context, userCred mcclient.TokenCredential, host *SHost, storagecache *SStoragecache, task taskman.ITask) error
-	RequestUncacheImage(ctx context.Context, host *SHost, storageCache *SStoragecache, task taskman.ITask) error
+	RequestUncacheImage(ctx context.Context, host *SHost, storageCache *SStoragecache, task taskman.ITask, deactivateImage bool) error
 
 	ValidateUpdateDisk(ctx context.Context, userCred mcclient.TokenCredential, input *api.DiskUpdateInput) (*api.DiskUpdateInput, error)
 	ValidateResetDisk(ctx context.Context, userCred mcclient.TokenCredential, disk *SDisk, snapshot *SSnapshot, guests []SGuest, input *api.DiskResetInput) (*api.DiskResetInput, error)

pkg/compute/models/storages.go

@@ -243,6 +243,10 @@ func (manager *SStorageManager) GetStorageTypesByProvider(provider string) ([]st
 	return storages, nil
 }
 
+func (self *SStorage) IsNeedDeactivateOnAllHost() bool {
+	return self.StorageType == api.STORAGE_SLVM
+}
+
 func (manager *SStorageManager) GetStorageTypesByHostType(hostType string) ([]string, error) {
 	q := manager.Query("storage_type")
 	hosts := HostManager.Query().SubQuery()
@@ -892,6 +896,16 @@ func (manager *SStorageManager) getStoragesByZone(zone *SZone, provider *SCloudp
 	return storages, nil
 }
 
+func (manager *SStorageManager) GetStorageByStoragecache(storagecacheId string) (*SStorage, error) {
+	s := SStorage{}
+	s.SetModelManager(StorageManager, &s)
+	err := manager.Query().Equals("storagecache_id", storagecacheId).First(&s)
+	if err != nil {
+		return nil, errors.Wrap(err, "get storage by storagecache")
+	}
+	return &s, nil
+}
+
 func (manager *SStorageManager) scanLegacyStorages() error {
 	storages := make([]SStorage, 0)
 	table := manager.Query().SubQuery()

pkg/compute/tasks/guest_insert_iso_task.go

@@ -56,6 +56,7 @@ func (self *GuestInsertIsoTask) prepareIsoImage(ctx context.Context, obj db.ISta
 			ImageId:      imageId,
 			Format:       "iso",
 			ParentTaskId: self.GetTaskId(),
+			ServerId:     guest.Id,
 		}
 		storageCache.StartImageCacheTask(ctx, self.UserCred, input)
 	} else {

pkg/compute/tasks/storage_cache_image_task.go

@@ -65,19 +65,25 @@ func (self *StorageCacheImageTask) OnRelinquishLeastUsedCachedImageComplete(ctx
 
 	self.SetStage("OnImageCacheComplete", nil)
 
-	host, err := storageCache.GetMasterHost()
-	if err != nil {
-		errData := taskman.Error2TaskData(err)
-		self.OnImageCacheCompleteFailed(ctx, storageCache, errData)
-		return
-	}
-
+	var host *models.SHost
+	var err error
 	serverId, _ := self.Params.GetString("server_id")
 	if len(serverId) > 0 {
-		guest, _ := models.GuestManager.FetchById(serverId)
-		if guest != nil {
-			server := guest.(*models.SGuest)
-			server.SetStatus(ctx, self.GetUserCred(), api.VM_IMAGE_CACHING, "")
+		guest, err := models.GuestManager.FetchById(serverId)
+		if err != nil {
+			errData := taskman.Error2TaskData(err)
+			self.OnImageCacheCompleteFailed(ctx, storageCache, errData)
+			return
+		}
+		server := guest.(*models.SGuest)
+		server.SetStatus(ctx, self.GetUserCred(), api.VM_IMAGE_CACHING, "")
+		host, _ = server.GetHost()
+	} else {
+		host, err = storageCache.GetMasterHost()
+		if err != nil {
+			errData := taskman.Error2TaskData(err)
+			self.OnImageCacheCompleteFailed(ctx, storageCache, errData)
+			return
 		}
 	}
 

pkg/compute/tasks/storage_uncache_image_task.go

@@ -21,6 +21,7 @@ import (
 	"yunion.io/x/log"
 	"yunion.io/x/pkg/errors"
 
+	"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"
@@ -56,6 +57,45 @@ func (self *StorageUncacheImageTask) OnInit(ctx context.Context, obj db.IStandal
 		return
 	}
 
+	storage, err := models.StorageManager.GetStorageByStoragecache(storageCache.Id)
+	if err != nil {
+		self.OnTaskFailed(ctx, storageCache, errors.Wrap(err, "fail to get storage by storagecache"))
+		return
+	}
+	if storage.IsNeedDeactivateOnAllHost() {
+		self.RequestUncacheDeactivateImage(ctx, storageCache)
+		return
+	}
+	self.RequestUncacheRemoveImage(ctx, storageCache)
+}
+
+func (self *StorageUncacheImageTask) RequestUncacheDeactivateImage(ctx context.Context, storageCache *models.SStoragecache) {
+	hosts, err := storageCache.GetHosts()
+	if err != nil {
+		self.OnTaskFailed(ctx, storageCache, errors.Wrap(err, "fail to get hosts"))
+		return
+	}
+	for i := range hosts {
+		if !hosts[i].Enabled.IsTrue() || hosts[i].HostStatus != compute.HOST_ONLINE {
+			continue
+		}
+		driver, err := hosts[i].GetHostDriver()
+		if err != nil {
+			self.OnTaskFailed(ctx, storageCache, errors.Wrapf(err, "GetHostDriver"))
+			return
+		}
+
+		err = driver.RequestUncacheImage(ctx, &hosts[i], storageCache, self, true)
+		if err != nil {
+			self.OnTaskFailed(ctx, storageCache, errors.Wrap(err, "RequestUncacheImage"))
+			return
+		}
+	}
+
+	self.RequestUncacheRemoveImage(ctx, storageCache)
+}
+
+func (self *StorageUncacheImageTask) RequestUncacheRemoveImage(ctx context.Context, storageCache *models.SStoragecache) {
 	host, err := storageCache.GetMasterHost()
 	if err != nil {
 		self.OnTaskFailed(ctx, storageCache, errors.Wrapf(err, "GetMasterHost"))
@@ -69,8 +109,7 @@ func (self *StorageUncacheImageTask) OnInit(ctx context.Context, obj db.IStandal
 	}
 
 	self.SetStage("OnImageUncacheComplete", nil)
-
-	err = driver.RequestUncacheImage(ctx, host, storageCache, self)
+	err = driver.RequestUncacheImage(ctx, host, storageCache, self, false)
 	if err != nil {
 		self.OnTaskFailed(ctx, storageCache, errors.Wrapf(err, "RequestUncacheImage"))
 	}

pkg/hostman/guestman/qemu-kvm.go

@@ -2006,7 +2006,13 @@ func (s *SKVMGuestInstance) DeployFs(ctx context.Context, userCred mcclient.Toke
 			return nil, errors.Wrapf(err, "GetDiskByPath(%s)", diskPath)
 		}
 		diskInfo.Path = disk.GetPath()
-		return disk.DeployGuestFs(&diskInfo, s.Desc, deployInfo)
+		ret, err := disk.DeployGuestFs(&diskInfo, s.Desc, deployInfo)
+		if utils.IsInStringArray(disk.GetType(), []string{api.STORAGE_SLVM, api.STORAGE_CLVM}) {
+			if errDeactive := lvmutils.LVDeactivate(diskPath); err != nil {
+				log.Errorf("failed deactive disk %s: %s", diskPath, errDeactive)
+			}
+		}
+		return ret, err
 	} else {
 		return nil, fmt.Errorf("Guest dosen't have disk ??")
 	}
@@ -3352,6 +3358,7 @@ func (s *SKVMGuestInstance) IsSharedStorage() bool {
 }
 
 func (s *SKVMGuestInstance) generateDiskSetupScripts(disks []*desc.SGuestDisk) (string, error) {
+	slvmImages := map[string]string{}
 	cmd := " "
 	for i := range disks {
 		diskPath := disks[i].Path
@@ -3359,12 +3366,21 @@ func (s *SKVMGuestInstance) generateDiskSetupScripts(disks []*desc.SGuestDisk) (
 		if err != nil {
 			return "", errors.Wrapf(err, "GetDiskByPath(%s)", diskPath)
 		}
+		if d.GetType() == api.STORAGE_SLVM && disks[i].TemplateId != "" {
+			slvmImages[disks[i].StorageId] = disks[i].TemplateId
+		}
 		if len(disks[i].StorageType) == 0 {
 			disks[i].StorageType = d.GetType()
 		}
 		diskIndex := disks[i].Index
 		cmd += d.GetDiskSetupScripts(int(diskIndex))
 	}
+
+	for storageId, imageId := range slvmImages {
+		storage := storageman.GetManager().GetStorage(storageId)
+		imageCacheManager := storageman.GetManager().GetStoragecacheById(storage.GetStoragecacheId())
+		imageCacheManager.LoadImageCache(imageId)
+	}
 	return cmd, nil
 }
 

pkg/hostman/storageman/disk_lvm.go

@@ -77,7 +77,7 @@ func (d *SLVMDisk) GetPath() string {
 
 // The LVM logical volume name is limited to 64 characters.
 func (d *SLVMDisk) GetSnapshotName(snapshotId string) string {
-	return "snap_" + d.Id + snapshotId
+	return "snap_" + d.Id + "_" + snapshotId
 }
 
 func (d *SLVMDisk) GetSnapshotPath(snapshotId string) string {

pkg/hostman/storageman/disk_slvm.go

@@ -28,6 +28,7 @@ import (
 	"yunion.io/x/onecloud/pkg/hostman/storageman/lvmutils"
 	"yunion.io/x/onecloud/pkg/util/fileutils2"
 	"yunion.io/x/onecloud/pkg/util/qemuimg"
+	"yunion.io/x/onecloud/pkg/util/seclib2"
 )
 
 // shared lvm
@@ -170,3 +171,40 @@ func (d *SSLVMDisk) Delete(ctx context.Context, params interface{}) (jsonutils.J
 	}
 	return d.SLVMDisk.Delete(ctx, params)
 }
+
+func (d *SSLVMDisk) CreateSnapshot(snapshotId string, encryptKey string, encFormat qemuimg.TEncryptFormat, encAlg seclib2.TSymEncAlg) error {
+	err := lvmutils.LVActive(d.GetPath(), false, true)
+	if err != nil {
+		return errors.Wrap(err, "lvactive exclusive")
+	}
+	err = d.SLVMDisk.CreateSnapshot(snapshotId, encryptKey, encFormat, encAlg)
+	if err != nil {
+		err := lvmutils.LVActive(d.GetPath(), true, false)
+		if err != nil {
+			log.Errorf("failed lvactive share %s", err)
+		}
+		return err
+	}
+	snapPath := d.GetSnapshotPath(snapshotId)
+	err = lvmutils.LVActive(snapPath, false, true)
+	if err != nil {
+		return errors.Wrap(err, "lvactive snapshot share")
+	}
+	return nil
+}
+
+func (d *SSLVMDisk) ResetFromSnapshot(ctx context.Context, params interface{}) (jsonutils.JSONObject, error) {
+	err := lvmutils.LVActive(d.GetPath(), false, true)
+	if err != nil {
+		return nil, errors.Wrap(err, "lvactive exclusive")
+	}
+	ret, err := d.SLVMDisk.ResetFromSnapshot(ctx, params)
+	if err != nil {
+		err := lvmutils.LVActive(d.GetPath(), true, false)
+		if err != nil {
+			log.Errorf("failed lvactive share %s", err)
+		}
+		return nil, err
+	}
+	return ret, nil
+}

pkg/hostman/storageman/diskhandlers/diskhandler.go

@@ -118,7 +118,16 @@ func performImageCache(
 	if performAction == "perfetch" {
 		performTask = storagecache.PrefetchImageCache
 	} else {
-		performTask = storagecache.DeleteImageCache
+		if jsonutils.QueryBoolean(body, "deactivate_image", false) {
+			_, err := storagecache.DeleteImageCache(ctx, body)
+			if err != nil {
+				hostutils.Response(ctx, w, err)
+			}
+			hostutils.ResponseOk(ctx, w)
+			return
+		} else {
+			performTask = storagecache.DeleteImageCache
+		}
 	}
 
 	hostutils.DelayTask(ctx, performTask, disk)

pkg/hostman/storageman/imagecache_lvm.go

@@ -24,6 +24,7 @@ import (
 	"yunion.io/x/log"
 	"yunion.io/x/pkg/errors"
 	"yunion.io/x/pkg/util/httputils"
+	"yunion.io/x/pkg/util/qemuimgfmt"
 
 	api "yunion.io/x/onecloud/pkg/apis/compute"
 	"yunion.io/x/onecloud/pkg/hostman/hostutils"
@@ -123,9 +124,13 @@ func (c *SLVMImageCache) Acquire(
 			}
 		}
 
+		targetImageFormat := "qcow2"
+		if localImg.Format != qemuimgfmt.QCOW2 {
+			targetImageFormat = "raw"
+		}
 		log.Infof("convert local image %s to lvm %s", c.imageId, c.GetPath())
 		out, err := procutils.NewRemoteCommandAsFarAsPossible(qemutils.GetQemuImg(),
-			"convert", "-W", "-m", "16", "-O", "qcow2", localImageCache.GetPath(), c.GetPath()).Output()
+			"convert", "-W", "-m", "16", "-O", targetImageFormat, localImageCache.GetPath(), c.GetPath()).Output()
 		if err != nil {
 			return errors.Wrapf(err, "convert local image %s to lvm %s: %s", c.imageId, c.GetPath(), out)
 		}

pkg/hostman/storageman/imagecache_rbd.go

@@ -88,7 +88,7 @@ func (r *SRbdImageCache) Acquire(ctx context.Context, input api.CacheImageInput,
 		err := procutils.NewRemoteCommandAsFarAsPossible(qemutils.GetQemuImg(),
 			"convert", "-W", "-m", "16", "-O", "raw", localImageCache.GetPath(), r.GetPath()).Run()
 		if err != nil {
-			return errors.Wrapf(err, "convert loca image %s to rbd pool %s at host %s", r.imageId, r.Manager.GetPath(), options.HostOptions.Hostname)
+			return errors.Wrapf(err, "convert local image %s to rbd pool %s at host %s", r.imageId, r.Manager.GetPath(), options.HostOptions.Hostname)
 		}
 		if len(input.ServerId) > 0 {
 			modules.Servers.Update(hostutils.GetComputeSession(context.Background()), input.ServerId, jsonutils.Marshal(map[string]float32{"progress": 100.0}))

pkg/hostman/storageman/imagecachemanager_lvm.go

@@ -165,7 +165,22 @@ func (c *SLVMImageCacheManager) DeleteImageCache(ctx context.Context, data inter
 	}
 
 	imageId, _ := body.GetString("image_id")
-	return nil, c.RemoveImage(ctx, imageId)
+	if jsonutils.QueryBoolean(body, "deactivate_image", false) {
+		return nil, c.DeactiveImageCacahe(ctx, imageId)
+	} else {
+		return nil, c.RemoveImage(ctx, imageId)
+	}
+}
+
+func (c *SLVMImageCacheManager) DeactiveImageCacahe(ctx context.Context, imageId string) error {
+	lockman.LockRawObject(ctx, "image-cache", imageId)
+	defer lockman.ReleaseRawObject(ctx, "image-cache", imageId)
+
+	if img, ok := c.cachedImages.Load(imageId); ok {
+		c.cachedImages.Delete(imageId)
+		return lvmutils.LVDeactivate(img.(IImageCache).GetPath())
+	}
+	return nil
 }
 
 func (c *SLVMImageCacheManager) RemoveImage(ctx context.Context, imageId string) error {