From 4058e053239f88379a2a7e45c1e569d135c9d262 Mon Sep 17 00:00:00 2001 From: ioito Date: Fri, 10 May 2019 14:18:48 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=9D=E6=8C=81=E5=85=AC=E6=9C=89=E4=BA=91?= =?UTF-8?q?=E9=95=9C=E5=83=8F=E5=90=8D=E7=A7=B0=E5=92=8C=E6=9C=AC=E5=9C=B0?= =?UTF-8?q?=E9=95=9C=E5=83=8F=E5=90=8D=E7=A7=B0=E7=9B=B8=E5=90=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pkg/cloudprovider/images.go | 11 +++++++ pkg/cloudprovider/resources.go | 2 +- pkg/compute/hostdrivers/managedvirtual.go | 30 ++++++++--------- pkg/compute/models/storagecaches.go | 1 + pkg/util/aliyun/storagecache.go | 36 ++++++++++---------- pkg/util/aws/storagecache.go | 36 ++++++++++---------- pkg/util/azure/storagecache.go | 20 ++++++------ pkg/util/esxi/storagecache.go | 4 +-- pkg/util/huawei/storagecache.go | 34 +++++++++---------- pkg/util/openstack/storagecache.go | 29 ++++++++-------- pkg/util/qcloud/storagecache.go | 40 ++++++++++++----------- pkg/util/ucloud/storagecache.go | 30 ++++++++--------- 12 files changed, 141 insertions(+), 132 deletions(-) diff --git a/pkg/cloudprovider/images.go b/pkg/cloudprovider/images.go index 58e0009d51..56d24aec35 100644 --- a/pkg/cloudprovider/images.go +++ b/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 +} diff --git a/pkg/cloudprovider/resources.go b/pkg/cloudprovider/resources.go index 892e69e9c6..6eafa8e166 100644 --- a/pkg/cloudprovider/resources.go +++ b/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 { diff --git a/pkg/compute/hostdrivers/managedvirtual.go b/pkg/compute/hostdrivers/managedvirtual.go index 571375f39c..2a76cede17 100644 --- a/pkg/compute/hostdrivers/managedvirtual.go +++ b/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 diff --git a/pkg/compute/models/storagecaches.go b/pkg/compute/models/storagecaches.go index da4a9cd331..04341cd2bf 100644 --- a/pkg/compute/models/storagecaches.go +++ b/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 { diff --git a/pkg/util/aliyun/storagecache.go b/pkg/util/aliyun/storagecache.go index b145030159..11dd017378 100644 --- a/pkg/util/aliyun/storagecache.go +++ b/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 } diff --git a/pkg/util/aws/storagecache.go b/pkg/util/aws/storagecache.go index a831578c8d..256eaaa47d 100644 --- a/pkg/util/aws/storagecache.go +++ b/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 } } diff --git a/pkg/util/azure/storagecache.go b/pkg/util/azure/storagecache.go index 6d095998fb..9738070ae6 100644 --- a/pkg/util/azure/storagecache.go +++ b/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) { diff --git a/pkg/util/esxi/storagecache.go b/pkg/util/esxi/storagecache.go index c1f29c086f..fa27a83f94 100644 --- a/pkg/util/esxi/storagecache.go +++ b/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 } diff --git a/pkg/util/huawei/storagecache.go b/pkg/util/huawei/storagecache.go index 03e61d3632..3e6c7b0a50 100644 --- a/pkg/util/huawei/storagecache.go +++ b/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 } diff --git a/pkg/util/openstack/storagecache.go b/pkg/util/openstack/storagecache.go index 30e7ed2009..2527ecc13c 100644 --- a/pkg/util/openstack/storagecache.go +++ b/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) { diff --git a/pkg/util/qcloud/storagecache.go b/pkg/util/qcloud/storagecache.go index 3a4d78edc7..962f57a101 100644 --- a/pkg/util/qcloud/storagecache.go +++ b/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 } diff --git a/pkg/util/ucloud/storagecache.go b/pkg/util/ucloud/storagecache.go index 25bb9e572d..7d660d6e93 100644 --- a/pkg/util/ucloud/storagecache.go +++ b/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)