Merge pull request #840 from ioito/hotfix/qx-image-cache-name

上传到云上的镜像名称和本地保持一致

pkg/cloudprovider/images.go

@@ -71,3 +71,14 @@ func CloudImage2Image(image ICloudImage) SImage {
 		Status:    image.GetImageStatus(),
 	}
 }
+
+type SImageCreateOption struct {
+	ImageId        string
+	ExternalId     string
+	ImageName      string
+	OsType         string
+	OsArch         string
+	OsDistribution string
+	OsVersion      string
+	OsFullVersion  string
+}

pkg/cloudprovider/resources.go

@@ -141,7 +141,7 @@ type ICloudStoragecache interface {
 
 	DownloadImage(userCred mcclient.TokenCredential, imageId string, extId string, path string) (jsonutils.JSONObject, error)
 
-	UploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool) (string, error)
+	UploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *SImageCreateOption, isForce bool) (string, error)
 }
 
 type ICloudStorage interface {

pkg/compute/hostdrivers/managedvirtual.go

@@ -18,6 +18,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+
 	"yunion.io/x/pkg/utils"
 
 	"yunion.io/x/jsonutils"
@@ -37,30 +38,29 @@ type SManagedVirtualizationHostDriver struct {
 
 func (self *SManagedVirtualizationHostDriver) CheckAndSetCacheImage(ctx context.Context, host *models.SHost, storageCache *models.SStoragecache, task taskman.ITask) error {
 	params := task.GetParams()
-	imageId, err := params.GetString("image_id")
+	image := &cloudprovider.SImageCreateOption{}
+	err := params.Unmarshal(image)
 	if err != nil {
 		return err
 	}
 
-	osArch, _ := params.GetString("os_arch")
-	osType, _ := params.GetString("os_type")
-	osDist, _ := params.GetString("os_distribution")
-	var osVersion string
+	if len(image.ImageId) == 0 {
+		return fmt.Errorf("no image_id params")
+	}
+
 	providerName := storageCache.GetProviderName()
 	if utils.IsInStringArray(providerName, []string{api.CLOUD_PROVIDER_HUAWEI, api.CLOUD_PROVIDER_UCLOUD}) {
-		osVersion, _ = params.GetString("os_full_version")
-	} else {
-		osVersion, _ = params.GetString("os_version")
+		image.OsVersion, _ = params.GetString("os_full_version")
 	}
 
 	isForce := jsonutils.QueryBoolean(params, "is_force", false)
 	userCred := task.GetUserCred()
 	taskman.LocalTaskRun(task, func() (jsonutils.JSONObject, error) {
 
-		lockman.LockRawObject(ctx, "cachedimages", fmt.Sprintf("%s-%s", storageCache.Id, imageId))
-		defer lockman.ReleaseRawObject(ctx, "cachedimages", fmt.Sprintf("%s-%s", storageCache.Id, imageId))
+		lockman.LockRawObject(ctx, "cachedimages", fmt.Sprintf("%s-%s", storageCache.Id, image.ImageId))
+		defer lockman.ReleaseRawObject(ctx, "cachedimages", fmt.Sprintf("%s-%s", storageCache.Id, image.ImageId))
 
-		scimg := models.StoragecachedimageManager.Register(ctx, task.GetUserCred(), storageCache.Id, imageId, "")
+		scimg := models.StoragecachedimageManager.Register(ctx, task.GetUserCred(), storageCache.Id, image.ImageId, "")
 
 		cachedImage := scimg.GetCachedimage()
 		if cachedImage == nil {
@@ -72,16 +72,16 @@ func (self *SManagedVirtualizationHostDriver) CheckAndSetCacheImage(ctx context.
 			return nil, err
 		}
 
-		var extImgId string
+		image.ExternalId = scimg.ExternalId
 		if cachedImage.ImageType == cloudprovider.CachedImageTypeCustomized {
-			extImgId, err = iStorageCache.UploadImage(ctx, userCred, imageId, osArch, osType, osDist, osVersion, scimg.ExternalId, isForce)
+			image.ExternalId, err = iStorageCache.UploadImage(ctx, userCred, image, isForce)
 		} else {
 			_, err = iStorageCache.GetIImageById(cachedImage.ExternalId)
 			if err != nil {
 				log.Errorf("remote image fetch error %s", err)
 				return nil, err
 			}
-			extImgId = cachedImage.ExternalId
+			image.ExternalId = cachedImage.ExternalId
 		}
 
 		if err != nil {
@@ -91,7 +91,7 @@ func (self *SManagedVirtualizationHostDriver) CheckAndSetCacheImage(ctx context.
 		// scimg.SetExternalId(extImgId)
 
 		ret := jsonutils.NewDict()
-		ret.Add(jsonutils.NewString(extImgId), "image_id")
+		ret.Add(jsonutils.NewString(image.ExternalId), "image_id")
 		return ret, nil
 	})
 	return nil

pkg/compute/models/storagecaches.go

@@ -318,6 +318,7 @@ func (self *SStoragecache) StartImageCacheTask(ctx context.Context, userCred mcc
 		data.Add(jsonutils.NewString(imgInfo.OsDistro), "os_distribution")
 		data.Add(jsonutils.NewString(imgInfo.OsVersion), "os_version")
 		data.Add(jsonutils.NewString(imgInfo.OsFullVersion), "os_full_version")
+		data.Add(jsonutils.NewString(image.Name), "image_name")
 	}
 
 	if isForce {

pkg/util/aliyun/storagecache.go

@@ -112,17 +112,17 @@ func (self *SStoragecache) GetPath() string {
 	return ""
 }
 
-func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool) (string, error) {
+func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
 
-	if len(extId) > 0 {
-		log.Debugf("UploadImage: Image external ID exists %s", extId)
+	if len(image.ExternalId) > 0 {
+		log.Debugf("UploadImage: Image external ID exists %s", image.ExternalId)
 
-		status, err := self.region.GetImageStatus(extId)
+		status, err := self.region.GetImageStatus(image.ExternalId)
 		if err != nil {
 			log.Errorf("GetImageStatus error %s", err)
 		}
 		if status == ImageStatusAvailable && !isForce {
-			return extId, nil
+			return image.ExternalId, nil
 		}
 		// 不能直接删除 ImageStatusCreating 状态的image ,需要先取消importImage Task
 		if status == ImageStatusCreating {
@@ -132,23 +132,23 @@ func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.To
 			}
 		}
 		if len(status) > 0 {
-			err = self.region.DeleteImage(extId)
+			err = self.region.DeleteImage(image.ExternalId)
 			if err != nil {
-				log.Errorf("failed to delete image %s(%s) error: %v", extId, status, err)
+				log.Errorf("failed to delete image %s(%s) error: %v", image.ExternalId, status, err)
 			}
 		}
 	} else {
 		log.Debugf("UploadImage: no external ID")
 	}
 
-	return self.uploadImage(ctx, userCred, imageId, osArch, osType, osDist, isForce)
+	return self.uploadImage(ctx, userCred, image, isForce)
 }
 
-func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist string, isForce bool) (string, error) {
+func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
 	// first upload image to oss
 	s := auth.GetAdminSession(ctx, options.Options.Region, "")
 
-	meta, reader, err := modules.Images.Download(s, imageId, string(qemuimg.QCOW2), false)
+	meta, reader, err := modules.Images.Download(s, image.ImageId, string(qemuimg.QCOW2), false)
 	if err != nil {
 		return "", err
 	}
@@ -158,7 +158,7 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		log.Errorf("GetOssClient err %s", err)
 		return "", err
 	}
-	bucketName := strings.ToLower(fmt.Sprintf("imgcache-%s-%s", self.region.GetId(), imageId))
+	bucketName := strings.ToLower(fmt.Sprintf("imgcache-%s-%s", self.region.GetId(), image.ImageId))
 	exist, err := oss.IsBucketExist(bucketName)
 	if err != nil {
 		log.Errorf("IsBucketExist err %s", err)
@@ -183,17 +183,17 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		return "", err
 	}
 	log.Debugf("To upload image to bucket %s ...", bucketName)
-	err = bucket.PutObject(imageId, reader)
+	err = bucket.PutObject(image.ImageId, reader)
 	if err != nil {
-		log.Errorf("PutObject error %s %s", imageId, err)
+		log.Errorf("PutObject error %s %s", image.ImageId, err)
 		return "", err
 	}
 
-	defer bucket.DeleteObject(imageId) // remove object
+	defer bucket.DeleteObject(image.ImageId) // remove object
 
-	imageBaseName := imageId
+	imageBaseName := image.ImageId
 	if imageBaseName[0] >= '0' && imageBaseName[0] <= '9' {
-		imageBaseName = fmt.Sprintf("img%s", imageId)
+		imageBaseName = fmt.Sprintf("img%s", image.ImageId)
 	}
 	imageName := imageBaseName
 	nameIdx := 1
@@ -221,10 +221,10 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		return "", err
 	}
 
-	task, err := self.region.ImportImage(imageName, osArch, osType, osDist, bucketName, imageId)
+	task, err := self.region.ImportImage(imageName, image.OsArch, image.OsType, image.OsDistribution, bucketName, image.ImageId)
 
 	if err != nil {
-		log.Errorf("ImportImage error %s %s %s", imageId, bucketName, err)
+		log.Errorf("ImportImage error %s %s %s", image.ImageId, bucketName, err)
 		return "", err
 	}
 

pkg/util/aws/storagecache.go

@@ -120,22 +120,22 @@ func (self *SStoragecache) DownloadImage(userCred mcclient.TokenCredential, imag
 	return self.downloadImage(userCred, imageId, extId)
 }
 
-func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool) (string, error) {
-	if len(extId) > 0 {
-		log.Debugf("UploadImage: Image external ID exists %s", extId)
+func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
+	if len(image.ExternalId) > 0 {
+		log.Debugf("UploadImage: Image external ID exists %s", image.ExternalId)
 
-		status, err := self.region.GetImageStatus(extId)
+		status, err := self.region.GetImageStatus(image.ExternalId)
 		if err != nil {
 			log.Errorf("GetImageStatus error %s", err)
 		}
 		if status == ImageStatusAvailable && !isForce {
-			return extId, nil
+			return image.ExternalId, nil
 		}
 	} else {
 		log.Debugf("UploadImage: no external ID")
 	}
 
-	return self.uploadImage(ctx, userCred, imageId, osArch, osType, osDist, isForce)
+	return self.uploadImage(ctx, userCred, image, isForce)
 
 }
 
@@ -152,8 +152,8 @@ func (self *SStoragecache) fetchImages() error {
 	return nil
 }
 
-func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist string, isForce bool) (string, error) {
-	bucketName := GetBucketName(self.region.GetId(), imageId)
+func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
+	bucketName := GetBucketName(self.region.GetId(), image.ImageId)
 	err := self.region.initVmimport(bucketName)
 	if err != nil {
 		return "", err
@@ -169,10 +169,10 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 
 	var diskFormat string
 	s := auth.GetAdminSession(ctx, options.Options.Region, "")
-	_, err = s3client.GetObject(&s3.GetObjectInput{Bucket: &bucketName, Key: &imageId})
+	_, err = s3client.GetObject(&s3.GetObjectInput{Bucket: &bucketName, Key: &image.ImageId})
 	if err != nil {
 		// first upload image to oss
-		meta, reader, err := modules.Images.Download(s, imageId, string(qemuimg.VMDK), false)
+		meta, reader, err := modules.Images.Download(s, image.ImageId, string(qemuimg.VMDK), false)
 		if err != nil {
 			return "", err
 		}
@@ -186,7 +186,7 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		// uploader to aws s3
 		input := &s3manager.UploadInput{
 			Bucket: &bucketName,
-			Key:    &imageId,
+			Key:    &image.ImageId,
 			Body:   reader,
 		}
 
@@ -200,9 +200,9 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		if err != nil {
 			return "", err
 		}
-		defer s3client.DeleteObject(&s3.DeleteObjectInput{Bucket: &bucketName, Key: &imageId}) // remove object
+		defer s3client.DeleteObject(&s3.DeleteObjectInput{Bucket: &bucketName, Key: &image.ImageId}) // remove object
 	} else {
-		meta, _, err := modules.Images.Download(s, imageId, string(qemuimg.VMDK), false)
+		meta, _, err := modules.Images.Download(s, image.ImageId, string(qemuimg.VMDK), false)
 		if err != nil {
 			return "", err
 		}
@@ -213,9 +213,9 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		}
 	}
 
-	imageBaseName := imageId
+	imageBaseName := image.ImageId
 	if imageBaseName[0] >= '0' && imageBaseName[0] <= '9' {
-		imageBaseName = fmt.Sprintf("img%s", imageId)
+		imageBaseName = fmt.Sprintf("img%s", image.ImageId)
 	}
 	imageName := imageBaseName
 	nameIdx := 1
@@ -236,10 +236,10 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		log.Debugf("uploadImage Match remote name %s", imageName)
 	}
 
-	task, err := self.region.ImportImage(imageName, osArch, osType, osDist, diskFormat, bucketName, imageId)
+	task, err := self.region.ImportImage(imageName, image.OsArch, image.OsType, image.OsDistribution, diskFormat, bucketName, image.ImageId)
 
 	if err != nil {
-		log.Errorf("ImportImage error %s %s %s", imageId, bucketName, err)
+		log.Errorf("ImportImage error %s %s %s", image.ImageId, bucketName, err)
 		return "", err
 	}
 
@@ -260,7 +260,7 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		for _, item := range ret.ImportImageTasks {
 			if *item.Status == "completed" {
 				// add name tag
-				self.region.addTags(*item.ImageId, "Name", imageId)
+				self.region.addTags(*item.ImageId, "Name", image.ImageId)
 				return *item.ImageId, nil
 			}
 		}

pkg/util/azure/storagecache.go

@@ -110,20 +110,20 @@ func (self *SStoragecache) GetPath() string {
 	return ""
 }
 
-func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool) (string, error) {
-	if len(extId) > 0 {
-		log.Debugf("UploadImage: Image external ID exists %s", extId)
-		status, err := self.region.GetImageStatus(extId)
+func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
+	if len(image.ExternalId) > 0 {
+		log.Debugf("UploadImage: Image external ID exists %s", image.ExternalId)
+		status, err := self.region.GetImageStatus(image.ExternalId)
 		if err != nil {
 			log.Errorf("GetImageStatus error %s", err)
 		}
 		if status == ImageStatusAvailable && !isForce {
-			return extId, nil
+			return image.ExternalId, nil
 		}
 	} else {
 		log.Debugf("UploadImage: no external ID")
 	}
-	return self.uploadImage(ctx, userCred, imageId, osArch, osType, osDist, isForce, options.Options.TempPath)
+	return self.uploadImage(ctx, userCred, image, isForce, options.Options.TempPath)
 }
 
 func (self *SStoragecache) checkStorageAccount() (*SStorageAccount, error) {
@@ -158,9 +158,9 @@ func (self *SStoragecache) checkStorageAccount() (*SStorageAccount, error) {
 	return storageaccount, nil
 }
 
-func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist string, isForce bool, tmpPath string) (string, error) {
+func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool, tmpPath string) (string, error) {
 	s := auth.GetAdminSession(ctx, options.Options.Region, "")
-	meta, reader, err := modules.Images.Download(s, imageId, string(qemuimg.VHD), false)
+	meta, reader, err := modules.Images.Download(s, image.ImageId, string(qemuimg.VHD), false)
 	if err != nil {
 		return "", err
 	}
@@ -216,11 +216,11 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 
 	size, _ := meta.Int("size")
 
-	image, err := self.region.CreateImageByBlob(imageId, osType, blobURI, int32(size>>30))
+	img, err := self.region.CreateImageByBlob(image.ImageId, image.OsType, blobURI, int32(size>>30))
 	if err != nil {
 		return "", err
 	}
-	return image.GetGlobalId(), nil
+	return img.GetGlobalId(), nil
 }
 
 func (self *SStoragecache) CreateIImage(snapshotId, imageName, osType, imageDesc string) (cloudprovider.ICloudImage, error) {

pkg/util/esxi/storagecache.go

@@ -143,8 +143,6 @@ func (self *SDatastoreImageCache) DownloadImage(userCred mcclient.TokenCredentia
 	return nil, cloudprovider.ErrNotImplemented
 }
 
-func (self *SDatastoreImageCache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential,
-	imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool,
-) (string, error) {
+func (self *SDatastoreImageCache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
 	return "", cloudprovider.ErrNotImplemented
 }

pkg/util/huawei/storagecache.go

@@ -142,26 +142,26 @@ func (self *SStoragecache) downloadImage(userCred mcclient.TokenCredential, imag
 	return nil, cloudprovider.ErrNotImplemented
 }
 
-func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool) (string, error) {
-	if len(extId) > 0 {
-		log.Debugf("UploadImage: Image external ID exists %s", extId)
+func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
+	if len(image.ExternalId) > 0 {
+		log.Debugf("UploadImage: Image external ID exists %s", image.ExternalId)
 
-		image, err := self.region.GetImage(extId)
+		img, err := self.region.GetImage(image.ExternalId)
 		if err != nil {
 			log.Errorf("GetImageStatus error %s", err)
 		}
-		if image.Status == ImageStatusActive && !isForce {
-			return extId, nil
+		if img.Status == ImageStatusActive && !isForce {
+			return image.ExternalId, nil
 		}
 	} else {
 		log.Debugf("UploadImage: no external ID")
 	}
 
-	return self.uploadImage(ctx, userCred, imageId, osArch, osType, osDist, osVersion, isForce)
+	return self.uploadImage(ctx, userCred, image, isForce)
 }
 
-func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist string, osVersion string, isForce bool) (string, error) {
-	bucketName := GetBucketName(self.region.GetId(), imageId)
+func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
+	bucketName := GetBucketName(self.region.GetId(), image.ImageId)
 	obsClient, err := self.region.getOBSClient()
 	if err != nil {
 		return "", err
@@ -179,12 +179,12 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 
 	// upload to huawei cloud
 	s := auth.GetAdminSession(ctx, options.Options.Region, "")
-	meta, reader, err := modules.Images.Download(s, imageId, string(qemuimg.VMDK), false)
+	meta, reader, err := modules.Images.Download(s, image.ImageId, string(qemuimg.VMDK), false)
 	if err != nil {
 		return "", err
 	}
 	log.Debugf("Images meta data %s", meta)
-	_image, err := modules.Images.Get(s, imageId, nil)
+	_image, err := modules.Images.Get(s, image.ImageId, nil)
 	if err != nil {
 		return "", err
 	}
@@ -201,7 +201,7 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 	// upload to huawei cloud
 	obj := &obs.PutObjectInput{}
 	obj.Bucket = bucketName
-	obj.Key = imageId
+	obj.Key = image.ImageId
 	obj.Body = reader
 
 	_, err = obsClient.PutObject(obj)
@@ -211,13 +211,13 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 
 	objDelete := &obs.DeleteObjectInput{}
 	objDelete.Bucket = bucketName
-	objDelete.Key = imageId
+	objDelete.Key = image.ImageId
 	defer obsClient.DeleteObject(objDelete) // remove object
 
 	// check image name, avoid name conflict
-	imageBaseName := imageId
+	imageBaseName := image.ImageId
 	if imageBaseName[0] >= '0' && imageBaseName[0] <= '9' {
-		imageBaseName = fmt.Sprintf("img%s", imageId)
+		imageBaseName = fmt.Sprintf("img%s", image.ImageId)
 	}
 	imageName := imageBaseName
 	nameIdx := 1
@@ -237,10 +237,10 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		log.Debugf("uploadImage Match remote name %s", imageName)
 	}
 
-	jobId, err := self.region.ImportImageJob(imageName, osDist, osVersion, osArch, bucketName, imageId, int64(minDiskGB))
+	jobId, err := self.region.ImportImageJob(imageName, image.OsDistribution, image.OsVersion, image.OsArch, bucketName, image.ImageId, int64(minDiskGB))
 
 	if err != nil {
-		log.Errorf("ImportImage error %s %s %s %s", jobId, imageId, bucketName, err)
+		log.Errorf("ImportImage error %s %s %s %s", jobId, image.ImageId, bucketName, err)
 		return "", err
 	}
 

pkg/util/openstack/storagecache.go

@@ -100,35 +100,32 @@ func (cache *SStoragecache) GetPath() string {
 	return ""
 }
 
-func (cache *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool) (string, error) {
-	if len(extId) > 0 {
-		log.Debugf("UploadImage: Image external ID exists %s", extId)
+func (cache *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
+	if len(image.ExternalId) > 0 {
+		log.Debugf("UploadImage: Image external ID exists %s", image.ExternalId)
 
-		statsu, err := cache.region.GetImageStatus(extId)
+		statsu, err := cache.region.GetImageStatus(image.ExternalId)
 		if err != nil {
 			log.Errorf("GetImageStatus error %s", err)
 		}
 		if statsu == ACTIVE && !isForce {
-			return extId, nil
+			return image.ExternalId, nil
 		}
 	}
 	log.Debugf("UploadImage: no external ID")
-	return cache.uploadImage(ctx, userCred, imageId, osArch, osType, osDist, osVersion, isForce)
+	return cache.uploadImage(ctx, userCred, image, isForce)
 }
 
-func (cache *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, isForce bool) (string, error) {
+func (cache *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
 	s := auth.GetAdminSession(ctx, options.Options.Region, "")
 
-	meta, reader, err := modules.Images.Download(s, imageId, string(qemuimg.VMDK), false)
+	meta, reader, err := modules.Images.Download(s, image.ImageId, string(qemuimg.VMDK), false)
 	if err != nil {
 		return "", err
 	}
 	log.Infof("meta data %s", meta)
 
-	imageBaseName := imageId
-	if imageBaseName[0] >= '0' && imageBaseName[0] <= '9' {
-		imageBaseName = fmt.Sprintf("img%s", imageId)
-	}
+	imageBaseName := image.ImageName
 	imageName := imageBaseName
 	nameIdx := 1
 
@@ -145,18 +142,18 @@ func (cache *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.T
 		nameIdx++
 	}
 
-	image, err := cache.region.CreateImage(imageName)
+	img, err := cache.region.CreateImage(imageName)
 	if err != nil {
 		return "", err
 	}
 
-	image.storageCache = cache
+	img.storageCache = cache
 
-	_, err = cache.region.client.StreamRequest(cache.region.Name, "image", "PUT", fmt.Sprintf("/v2/images/%s/file", image.ID), "", reader)
+	_, err = cache.region.client.StreamRequest(cache.region.Name, "image", "PUT", fmt.Sprintf("/v2/images/%s/file", img.ID), "", reader)
 	if err != nil {
 		return "", err
 	}
-	return image.ID, cloudprovider.WaitStatus(image, api.CACHED_IMAGE_STATUS_READY, 15*time.Second, 3600*time.Second)
+	return img.ID, cloudprovider.WaitStatus(img, api.CACHED_IMAGE_STATUS_READY, 15*time.Second, 3600*time.Second)
 }
 
 func (cache *SStoragecache) CreateIImage(snapshoutId, imageName, osType, imageDesc string) (cloudprovider.ICloudImage, error) {

pkg/util/qcloud/storagecache.go

@@ -138,22 +138,22 @@ func (self *SStoragecache) GetPath() string {
 	return ""
 }
 
-func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool) (string, error) {
-	if len(extId) > 0 {
-		log.Debugf("UploadImage: Image external ID exists %s", extId)
+func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
+	if len(image.ExternalId) > 0 {
+		log.Debugf("UploadImage: Image external ID exists %s", image.ExternalId)
 
-		status, err := self.region.GetImageStatus(extId)
+		status, err := self.region.GetImageStatus(image.ExternalId)
 		if err != nil {
 			log.Errorf("GetImageStatus error %s", err)
 		}
 		if (status == ImageStatusNormal || status == ImageStatusUsing) && !isForce {
-			return extId, nil
+			return image.ExternalId, nil
 		}
 		log.Debugf("image status: %s isForce: %v", status, isForce)
 	} else {
 		log.Debugf("UploadImage: no external ID")
 	}
-	return self.uploadImage(ctx, userCred, imageId, osArch, osType, osDist, osVersion, isForce)
+	return self.uploadImage(ctx, userCred, image, isForce)
 }
 
 func (self *SRegion) getCosUrl(bucket, object string) string {
@@ -161,16 +161,16 @@ func (self *SRegion) getCosUrl(bucket, object string) string {
 	return fmt.Sprintf("http://%s-%s.cos.%s.myqcloud.com/%s", bucket, self.client.AppID, self.Region, object)
 }
 
-func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, isForce bool) (string, error) {
+func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
 	// first upload image to oss
 	s := auth.GetAdminSession(ctx, options.Options.Region, "")
 
-	meta, reader, err := modules.Images.Download(s, imageId, string(qemuimg.VMDK), false)
+	meta, reader, err := modules.Images.Download(s, image.ImageId, string(qemuimg.VMDK), false)
 	if err != nil {
 		return "", err
 	}
 
-	tmpFile := fmt.Sprintf("%s/%s", options.Options.TempPath, imageId)
+	tmpFile := fmt.Sprintf("%s/%s", options.Options.TempPath, image.ImageId)
 	defer os.Remove(tmpFile)
 	f, err := os.Create(tmpFile)
 	if err != nil {
@@ -200,18 +200,18 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		log.Debugf("Bucket %s exists", bucketName)
 	}
 	log.Debugf("To upload image to bucket %s ...", bucketName)
-	err = cos.Bucket(bucketName).UploadObjectBySlice(context.Background(), imageId, tmpFile, 3, map[string]string{})
+	err = cos.Bucket(bucketName).UploadObjectBySlice(context.Background(), image.ImageId, tmpFile, 3, map[string]string{})
 	if err != nil {
-		log.Errorf("UploadObject error %s %s", imageId, err)
+		log.Errorf("UploadObject error %s %s", image.ImageId, err)
 		return "", err
 	}
 
-	defer cos.Bucket(bucketName).DeleteObject(context.Background(), imageId)
+	defer cos.Bucket(bucketName).DeleteObject(context.Background(), image.ImageId)
 
 	// 腾讯云镜像名称需要小于20个字符
-	imageBaseName := imageId[:10]
+	imageBaseName := image.ImageId[:10]
 	if imageBaseName[0] >= '0' && imageBaseName[0] <= '9' {
-		imageBaseName = fmt.Sprintf("img%s", imageId[:10])
+		imageBaseName = fmt.Sprintf("img%s", image.ImageId[:10])
 	}
 	imageName := imageBaseName
 	nameIdx := 1
@@ -231,11 +231,13 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 	}
 
 	log.Debugf("Import image %s", imageName)
-	if image, err := self.region.ImportImage(imageName, osArch, osDist, osVersion, self.region.getCosUrl(bucketName, imageId)); err != nil {
+	img, err := self.region.ImportImage(imageName, image.OsArch, image.OsDistribution, image.OsVersion, self.region.getCosUrl(bucketName, image.ImageId))
+	if err != nil {
 		return "", err
-	} else if cloudprovider.WaitStatus(image, api.CACHED_IMAGE_STATUS_READY, 15*time.Second, 3600*time.Second); err != nil {
-		return "", err
-	} else {
-		return image.ImageId, nil
 	}
+	err = cloudprovider.WaitStatus(img, api.CACHED_IMAGE_STATUS_READY, 15*time.Second, 3600*time.Second)
+	if err != nil {
+		return "", err
+	}
+	return img.ImageId, nil
 }

pkg/util/ucloud/storagecache.go

@@ -116,30 +116,30 @@ func (self *SStoragecache) DownloadImage(userCred mcclient.TokenCredential, imag
 }
 
 // https://docs.ucloud.cn/api/uhost-api/import_custom_image
-func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool) (string, error) {
-	if len(extId) > 0 {
-		log.Debugf("UploadImage: Image external ID exists %s", extId)
+func (self *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
+	if len(image.ExternalId) > 0 {
+		log.Debugf("UploadImage: Image external ID exists %s", image.ExternalId)
 
-		image, err := self.region.GetImage(extId)
+		img, err := self.region.GetImage(image.ExternalId)
 		if err != nil {
 			log.Errorf("GetImageStatus error %s", err)
 		}
-		if image.GetStatus() == cloudprovider.IMAGE_STATUS_ACTIVE && !isForce {
-			return extId, nil
+		if img.GetStatus() == cloudprovider.IMAGE_STATUS_ACTIVE && !isForce {
+			return image.ExternalId, nil
 		}
 	} else {
 		log.Debugf("UploadImage: no external ID")
 	}
 
-	return self.uploadImage(ctx, userCred, imageId, osArch, osType, osDist, osVersion, isForce)
+	return self.uploadImage(ctx, userCred, image, isForce)
 }
 
-func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist string, osVersion string, isForce bool) (string, error) {
-	if len(osVersion) == 0 {
+func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, image *cloudprovider.SImageCreateOption, isForce bool) (string, error) {
+	if len(image.OsVersion) == 0 {
 		return "", fmt.Errorf("uploadImage os version is empty")
 	}
 
-	bucketName := GetBucketName(self.region.GetId(), imageId)
+	bucketName := GetBucketName(self.region.GetId(), image.ImageId)
 
 	// create bucket
 	if _, err := self.region.GetBucketDomain(bucketName); err != nil {
@@ -157,7 +157,7 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 
 	// upload to  ucloud
 	s := auth.GetAdminSession(ctx, options.Options.Region, "")
-	meta, reader, err := modules.Images.Download(s, imageId, string(qemuimg.VMDK), false)
+	meta, reader, err := modules.Images.Download(s, image.ImageId, string(qemuimg.VMDK), false)
 	if err != nil {
 		return "", err
 	}
@@ -179,7 +179,7 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		BucketName: bucketName,
 		File:       reader,
 		FileSize:   size,
-		FileName:   imageId,
+		FileName:   image.ImageId,
 		FileMD5:    md5,
 	}
 
@@ -195,9 +195,9 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 	}() // remove object
 
 	// check image name, avoid name conflict
-	imageBaseName := imageId
+	imageBaseName := image.ImageId
 	if imageBaseName[0] >= '0' && imageBaseName[0] <= '9' {
-		imageBaseName = fmt.Sprintf("img%s", imageId)
+		imageBaseName = fmt.Sprintf("img%s", image.ImageId)
 	}
 	imageName := imageBaseName
 	nameIdx := 1
@@ -217,7 +217,7 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 		log.Debugf("uploadImage Match remote name %s", imageName)
 	}
 
-	imgId, err := self.region.ImportImage(imageName, file.FetchFileUrl(), osDist, osVersion, diskFormat)
+	imgId, err := self.region.ImportImage(imageName, file.FetchFileUrl(), image.OsDistribution, image.OsVersion, diskFormat)
 
 	if err != nil {
 		log.Errorf("ImportImage error %s %s", file.FetchFileUrl(), err)