Merge pull request #3535 from ioito/hotfix/qx-server-sku-sync

fix: remove private cloud server sku brand and provider attribute

cmd/climc/shell/skus.go

@@ -15,6 +15,8 @@
 package shell
 
 import (
+	"yunion.io/x/jsonutils"
+
 	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/mcclient/modules"
 	"yunion.io/x/onecloud/pkg/mcclient/options"
@@ -31,6 +33,7 @@ func init() {
 		Mem         *int    `help:"Memory size in MB" json:"memory_size_mb"`
 		Name        string  `help:"Name of Sku"`
 	}
+
 	R(&ServerSkusListOptions{}, "server-sku-list", "List all avaiable Server SKU", func(s *mcclient.ClientSession, args *ServerSkusListOptions) error {
 		params, err := options.ListStructToParams(args)
 		if err != nil {
@@ -74,6 +77,22 @@ func init() {
 		return nil
 	})
 
+	type ServerSkusCacheOptions struct {
+		REGION string `help:"Private cloud region"`
+		ID     string `help:"ServerSku Id"`
+	}
+
+	R(&ServerSkusCacheOptions{}, "server-sku-cache", "Cache Server SKU for private cloud", func(s *mcclient.ClientSession, args *ServerSkusCacheOptions) error {
+		params := jsonutils.NewDict()
+		params.Add(jsonutils.NewString(args.REGION), "cloudregion")
+		result, err := modules.ServerSkus.PerformAction(s, args.ID, "cache-sku", params)
+		if err != nil {
+			return err
+		}
+		printObject(result)
+		return nil
+	})
+
 	type ServerSkusCreateOptions struct {
 		Name         string `help:"ServerSku name"`
 		CpuCoreCount int    `help:"Cpu Count" required:"true" positional:"true"`
@@ -160,10 +179,15 @@ func init() {
 	})
 
 	type ServerSkusDeleteOptions struct {
-		ID string `help:"Id or name of server sku"`
+		ID    string `help:"Id or name of server sku"`
+		Purge bool   `help:"purge sku"`
 	}
 	R(&ServerSkusDeleteOptions{}, "server-sku-delete", "Delete a server sku", func(s *mcclient.ClientSession, args *ServerSkusDeleteOptions) error {
-		result, err := modules.ServerSkus.Delete(s, args.ID, nil)
+		params := jsonutils.NewDict()
+		if args.Purge {
+			params.Add(jsonutils.JSONTrue, "purge")
+		}
+		result, err := modules.ServerSkus.Delete(s, args.ID, params)
 		if err != nil {
 			return err
 		}

docs/index.yaml

@@ -443,6 +443,8 @@ paths:
     $ref: "./serversku/enable.yaml"
   /serverskus/{serverskuId}/disable:
     $ref: "./serversku/disable.yaml"
+  /serverskus/{serverskuId}/cache-sku:
+    $ref: "./serversku/cache-sku.yaml"
 
   /secgroups:
     $ref: "./secgroup/secgroups.yaml"

docs/parameters/serversku.yaml

@@ -19,4 +19,9 @@ usable:
   in: query
   type: boolean
   description: 过滤所在region底下有ip子网的套餐
-
+purge:
+  name: purge 
+  in: body 
+  type: boolean 
+  default: false
+  description: 删除本地套餐时不同步删除私有云上的套餐

docs/schemas/serversku.yaml

@@ -91,10 +91,6 @@ ServerSku:
           type: string
           example: OpenStack
           description: 套餐平台
-        brand:
-          type: string
-          example: OpenStack
-          description: 品牌信息,用来区分私有云品牌信息
 
 
 ServerSkuListResponse:
@@ -156,4 +152,4 @@ ServerSkuCreate:
       
   required:
     - cpu_core_count
-    - memory_size_mb
+    - memory_size_mb

docs/serversku/cache-sku.yaml

@@ -0,0 +1,12 @@
+post:
+  summary: 缓存本地套餐到私有云上
+  parameters:
+    - $ref: "../parameters/serversku.yaml#/serverskuId"
+  responses:
+    200:
+      description: 缓存的实例套餐信息
+      schema:
+        $ref: "../schemas/serversku.yaml#/ServerSkuResponse"
+
+  tags:
+    - serverskus

docs/serversku/serversku.yaml

@@ -9,3 +9,15 @@ get:
         $ref: "../schemas/serversku.yaml#/ServerSkuResponse"
   tags:
     - serverskus
+
+delete:
+  summary: 删除指定套餐(仅本地套餐可删除)
+  parameters:
+    - $ref: '../parameters/serversku.yaml#/serverskuId'
+    - $ref: '../parameters/serversku.yaml#/purge'
+  responses:
+    200:
+      schema:
+        $ref: "../schemas/serversku.yaml#/ServerSkuResponse"
+  tags:
+    - serverskus

pkg/cloudprovider/resources.go

@@ -108,8 +108,8 @@ type ICloudRegion interface {
 	CreateILoadBalancerAcl(acl *SLoadbalancerAccessControlList) (ICloudLoadbalancerAcl, error)
 	CreateILoadBalancerCertificate(cert *SLoadbalancerCertificate) (ICloudLoadbalancerCertificate, error)
 
-	GetISkus(zoneId string) ([]ICloudSku, error)
-	DeleteISkuByName(name string) error
+	GetISkus() ([]ICloudSku, error)
+	CreateISku(name string, vCpu int, memoryMb int) error
 
 	GetINetworkInterfaces() ([]ICloudNetworkInterface, error)
 

pkg/compute/models/cloudsync.go

@@ -707,20 +707,20 @@ func syncVMSecgroups(ctx context.Context, userCred mcclient.TokenCredential, pro
 	return nil
 }
 
-func syncZoneSkusFromCloud(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localZone *SZone, remoteRegion cloudprovider.ICloudRegion, remoteZone cloudprovider.ICloudZone) {
-	skus, err := remoteRegion.GetISkus(remoteZone.GetId())
+func syncSkusFromPrivateCloud(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, remoteRegion cloudprovider.ICloudRegion) {
+	skus, err := remoteRegion.GetISkus()
 	if err != nil {
-		msg := fmt.Sprintf("GetISkus for zone %s failed %v", localZone.Name, err)
+		msg := fmt.Sprintf("GetISkus for provider %s(%s) failed %v", provider.Name, provider.Id, err)
 		log.Errorf(msg)
 		return
 	}
 
-	result := ServerSkuManager.SyncCloudSkusByZone(ctx, userCred, provider, localZone, skus)
+	result := ServerSkuManager.SyncPrivateCloudSkus(ctx, userCred, provider, skus)
 
 	syncResults.Add(ServerSkuManager, result)
 
 	msg := result.Result()
-	log.Infof("SyncCloudSkusByRegion for zone %s result: %s", localZone.Name, msg)
+	log.Infof("SyncCloudSkusByRegion for provider %s result: %s", provider.Name, msg)
 	if result.IsError() {
 		return
 	}
@@ -991,6 +991,8 @@ func syncPublicCloudProviderInfo(
 
 	if !driver.GetFactory().NeedSyncSkuFromCloud() {
 		syncRegionSkus(ctx, userCred, localRegion)
+	} else {
+		syncSkusFromPrivateCloud(ctx, userCred, syncResults, provider, remoteRegion)
 	}
 
 	// no need to lock public cloud region as cloud region for public cloud is readonly
@@ -1019,10 +1021,6 @@ func syncPublicCloudProviderInfo(
 		if len(newPairs) > 0 {
 			storageCachePairs = append(storageCachePairs, newPairs...)
 		}
-
-		if driver.GetFactory().NeedSyncSkuFromCloud() {
-			syncZoneSkusFromCloud(ctx, userCred, syncResults, provider, &localZones[j], remoteRegion, remoteZones[j])
-		}
 	}
 
 	// sync snapshots after sync disks

pkg/compute/models/skus.go

@@ -115,7 +115,6 @@ type SServerSku struct {
 	GpuMaxCount   int               `nullable:"true" list:"user" create:"admin_optional" update:"admin"`
 
 	Provider string `width:"64" charset:"ascii" nullable:"true" list:"user" default:"OneCloud" create:"admin_optional"`
-	Brand    string `width:"64" charset:"ascii" nullable:"true" list:"user" default:"OneCloud" create:"admin_optional"`
 }
 
 type SInstanceSpecQueryParams struct {
@@ -407,12 +406,9 @@ func (self *SServerSku) PostCreate(ctx context.Context, userCred mcclient.TokenC
 	}
 }
 
-func (self *SServerSku) GetCloudproviders() ([]SCloudprovider, error) {
+func (self *SServerSku) GetPrivateCloudproviders() ([]SCloudprovider, error) {
 	providers := []SCloudprovider{}
-	accounts := CloudaccountManager.Query().SubQuery()
-	q := CloudproviderManager.Query()
-	q = q.Join(accounts, sqlchemy.Equals(accounts.Field("id"), q.Field("cloudaccount_id"))).
-		Filter(sqlchemy.Equals(accounts.Field("brand"), self.Brand))
+	q := CloudproviderManager.Query().In("provider", CloudproviderManager.GetPrivateProviderProvidersQuery())
 	err := db.FetchModelObjects(CloudproviderManager, q, &providers)
 	if err != nil {
 		return nil, err
@@ -664,11 +660,13 @@ func (self *SServerSku) RealDelete(ctx context.Context, userCred mcclient.TokenC
 }
 
 func (self *SServerSku) CustomizeDelete(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) error {
-	return self.StartServerSkuDeleteTask(ctx, userCred, "")
+	return self.StartServerSkuDeleteTask(ctx, userCred, jsonutils.QueryBoolean(data, "purge", false), "")
 }
 
-func (self *SServerSku) StartServerSkuDeleteTask(ctx context.Context, userCred mcclient.TokenCredential, parentTaskId string) error {
-	task, err := taskman.TaskManager.NewTask(ctx, "ServerSkuDeleteTask", self, userCred, nil, parentTaskId, "", nil)
+func (self *SServerSku) StartServerSkuDeleteTask(ctx context.Context, userCred mcclient.TokenCredential, purge bool, parentTaskId string) error {
+	params := jsonutils.NewDict()
+	params.Add(jsonutils.NewBool(purge), "purge")
+	task, err := taskman.TaskManager.NewTask(ctx, "ServerSkuDeleteTask", self, userCred, params, parentTaskId, "", nil)
 	if err != nil {
 		log.Errorf("newTask ServerSkuDeleteTask fail %s", err)
 		return err
@@ -876,23 +874,18 @@ func (manager *SServerSkuManager) GetSkuCountByZone(zoneId string) []SServerSku
 	return skus
 }
 
-func (manager *SServerSkuManager) GetSkuNamesByBrand(brand string) ([]string, error) {
-	skus := []string{}
-	q := manager.Query("name").Equals("brand", brand).Distinct()
-	rows, err := q.Rows()
+func (manager *SServerSkuManager) GetOneCloudSkus() ([]string, error) {
+	skus := []SServerSku{}
+	q := manager.Query().Equals("provider", api.CLOUD_PROVIDER_ONECLOUD)
+	err := db.FetchModelObjects(manager, q, &skus)
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
-	for rows.Next() {
-		var sku string
-		err = rows.Scan(&sku)
-		if err != nil {
-			return nil, errors.Wrap(err, "rows.Scan(&sku)")
-		}
-		skus = append(skus, sku)
+	result := []string{}
+	for _, sku := range skus {
+		result = append(result, fmt.Sprintf("%s/%d/%d", sku.Name, sku.CpuCoreCount, sku.MemorySizeMB))
 	}
-	return skus, nil
+	return result, nil
 }
 
 func (manager *SServerSkuManager) GetSkus(provider string, cpu, memMB int) ([]SServerSku, error) {
@@ -940,27 +933,63 @@ func (manager *SServerSkuManager) PendingDeleteInvalidSku() error {
 	return nil
 }
 
-func (manager *SServerSkuManager) SyncCloudSkusByZone(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, zone *SZone, skus []cloudprovider.ICloudSku) compare.SyncResult {
+func (self *SServerSku) AllowPerformCacheSku(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) bool {
+	return db.IsAdminAllowPerform(userCred, self, "cache-sku")
+}
+
+func (self *SServerSku) PerformCacheSku(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) (jsonutils.JSONObject, error) {
+	cloudregionV := validators.NewModelIdOrNameValidator("cloudregion", "cloudregion", nil)
+	err := cloudregionV.Validate(data.(*jsonutils.JSONDict))
+	if err != nil {
+		return nil, err
+	}
+	cloudregion := cloudregionV.Model.(*SCloudregion)
+	if len(cloudregion.ManagerId) == 0 {
+		return nil, httperrors.NewInputParameterError("Only support cache sku for private cloud")
+	}
+
+	cloudprovider := cloudregion.GetCloudprovider()
+	if cloudprovider == nil {
+		return nil, httperrors.NewInputParameterError("failed to get cloudprovider for region %s(%s)", cloudregion.Name, cloudregion.Id)
+	}
+
+	if !cloudprovider.Enabled {
+		return nil, httperrors.NewInputParameterError("cloudprovider %s(%s) disabled", cloudprovider.Name, cloudprovider.Id)
+	}
+
+	return nil, self.StartServerSkuCacheTask(ctx, userCred, cloudregion.Id, "")
+}
+
+func (self *SServerSku) StartServerSkuCacheTask(ctx context.Context, userCred mcclient.TokenCredential, cloudregionId string, parentTaskId string) error {
+	params := jsonutils.NewDict()
+	params.Add(jsonutils.NewString(cloudregionId), "cloudregion_id")
+	task, err := taskman.TaskManager.NewTask(ctx, "ServerSkuCacheTask", self, userCred, params, parentTaskId, "", nil)
+	if err != nil {
+		return err
+	}
+	task.ScheduleRun(nil)
+	return nil
+}
+
+func (manager *SServerSkuManager) SyncPrivateCloudSkus(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, skus []cloudprovider.ICloudSku) compare.SyncResult {
 	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
 	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
 
 	syncResult := compare.SyncResult{}
-	cloudaccount := provider.GetCloudaccount()
-	names, err := manager.GetSkuNamesByBrand(cloudaccount.Brand)
+	names, err := manager.GetOneCloudSkus()
 	if err != nil {
 		syncResult.Error(err)
 		return syncResult
 	}
 
 	for _, sku := range skus {
-		if !utils.IsInStringArray(sku.GetName(), names) {
-			err := manager.newFromCloudSku(ctx, userCred, sku, cloudaccount.Provider, cloudaccount.Brand)
+		if !utils.IsInStringArray(fmt.Sprintf("%s/%d/%d", sku.GetName(), sku.GetCpuCoreCount(), sku.GetMemorySizeMB()), names) {
+			err := manager.newFromCloudSku(ctx, userCred, sku)
 			if err != nil {
 				syncResult.AddError(err)
 			} else {
 				syncResult.Add()
 			}
-
 		}
 	}
 
@@ -1016,8 +1045,8 @@ func (self *SServerSku) setPrepaidPostpaidStatus(userCred mcclient.TokenCredenti
 	return nil
 }
 
-func (manager *SServerSkuManager) newFromCloudSku(ctx context.Context, userCred mcclient.TokenCredential, extSku cloudprovider.ICloudSku, provider, brand string) error {
-	sku := &SServerSku{Provider: provider, Brand: brand}
+func (manager *SServerSkuManager) newFromCloudSku(ctx context.Context, userCred mcclient.TokenCredential, extSku cloudprovider.ICloudSku) error {
+	sku := &SServerSku{Provider: api.CLOUD_PROVIDER_ONECLOUD}
 	sku.SetModelManager(manager, sku)
 	// 第一次同步新建的套餐是启用状态
 	sku.Enabled = true
@@ -1035,7 +1064,7 @@ func (manager *SServerSkuManager) newFromCloudSku(ctx context.Context, userCred
 		return nil
 	})
 	if err != nil {
-		return errors.Wrapf(err, "Update %s sku %s cloudregion info", sku.Brand, sku.Name)
+		return errors.Wrapf(err, "Update sku %s cloudregion info", sku.Name)
 	}
 
 	db.OpsLog.LogEvent(sku, db.ACT_CREATE, sku.GetShortDesc(ctx), userCred)
@@ -1150,16 +1179,16 @@ func (manager *SServerSkuManager) FetchAllAvailableSkuIdByZoneId(zoneId string)
 	return ids, nil
 }
 
-func (manager *SServerSkuManager) initializeSkuBrand() error {
+func (manager *SServerSkuManager) initializeSkuProvider() error {
 	skus := []SServerSku{}
-	q := manager.Query().IsNullOrEmpty("brand")
+	q := manager.Query().In("provider", CloudproviderManager.GetPrivateProviderProvidersQuery())
 	err := db.FetchModelObjects(manager, q, &skus)
 	if err != nil {
-		return errors.Wrapf(err, "initializeSkuBrand.FetchModelObjects")
+		return errors.Wrapf(err, "initializeSkuProvider.FetchModelObjects")
 	}
 	for _, sku := range skus {
 		_, err = db.Update(&sku, func() error {
-			sku.Brand = sku.Provider
+			sku.Provider = api.CLOUD_PROVIDER_ONECLOUD
 			return nil
 		})
 		if err != nil {
@@ -1306,9 +1335,9 @@ func (manager *SServerSkuManager) InitializeData() error {
 		return errors.Wrap(err, "initializeSkuEnableField")
 	}
 
-	err = manager.initializeSkuBrand()
+	err = manager.initializeSkuProvider()
 	if err != nil {
-		return errors.Wrap(err, "InitializeBrand")
+		return errors.Wrap(err, "InitializeProvider")
 	}
 
 	return manager.initializeSkuStatus()

pkg/compute/tasks/server_sku_cache_task.go

@@ -0,0 +1,99 @@
+// Copyright 2019 Yunion
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package tasks
+
+import (
+	"context"
+	"fmt"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/pkg/errors"
+
+	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
+	"yunion.io/x/onecloud/pkg/compute/models"
+)
+
+type ServerSkuCacheTask struct {
+	taskman.STask
+}
+
+func init() {
+	taskman.RegisterTask(ServerSkuCacheTask{})
+}
+
+func (self *ServerSkuCacheTask) taskFailed(ctx context.Context, sku *models.SServerSku, err error) {
+	self.SetStageFailed(ctx, err.Error())
+}
+
+func (self *ServerSkuCacheTask) getCloudregion() (*models.SCloudregion, error) {
+	cloudregionId, _ := self.GetParams().GetString("cloudregion_id")
+	if len(cloudregionId) == 0 {
+		return nil, fmt.Errorf("Missing cloudregion_id params")
+	}
+	region, err := models.CloudregionManager.FetchById(cloudregionId)
+	if err != nil {
+		return nil, errors.Wrap(err, "CloudregionManager.FetchById")
+	}
+	return region.(*models.SCloudregion), nil
+}
+
+func (self *ServerSkuCacheTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
+	sku := obj.(*models.SServerSku)
+
+	cloudregion, err := self.getCloudregion()
+	if err != nil {
+		self.taskFailed(ctx, sku, errors.Wrap(err, "self.getCloudregion()"))
+		return
+	}
+
+	cloudprovider := cloudregion.GetCloudprovider()
+	if cloudprovider == nil {
+		self.taskFailed(ctx, sku, fmt.Errorf("failed to found cloudprovider for cloudregion %s(%s)", cloudregion.Name, cloudregion.Id))
+		return
+	}
+
+	provider, err := cloudprovider.GetProvider()
+	if err != nil {
+		self.taskFailed(ctx, sku, errors.Wrap(err, "cloudprovider.GetProvider"))
+		return
+	}
+	iRegion, err := provider.GetIRegionById(cloudregion.ExternalId)
+	if err != nil {
+		self.taskFailed(ctx, sku, errors.Wrap(err, "provider.GetIRegionById"))
+		return
+	}
+
+	iskus, err := iRegion.GetISkus()
+	if err != nil {
+		self.taskFailed(ctx, sku, errors.Wrap(err, "provider.GetIRegionById"))
+		return
+	}
+
+	for i := 0; i < len(iskus); i++ {
+		if iskus[i].GetName() == sku.Name && iskus[i].GetMemorySizeMB() == sku.MemorySizeMB && iskus[i].GetCpuCoreCount() == sku.CpuCoreCount {
+			self.SetStageComplete(ctx, nil)
+			return
+		}
+	}
+
+	err = iRegion.CreateISku(sku.Name, sku.CpuCoreCount, sku.MemorySizeMB)
+	if err != nil {
+		self.taskFailed(ctx, sku, errors.Wrap(err, "provider.GetIRegionById"))
+		return
+	}
+	self.SetStageComplete(ctx, nil)
+	return
+}

pkg/compute/tasks/server_sku_delete_task.go

@@ -47,28 +47,40 @@ func (self *ServerSkuDeleteTask) taskFail(ctx context.Context, sku *models.SServ
 
 func (self *ServerSkuDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
 	sku := obj.(*models.SServerSku)
-	cloudproviders, err := sku.GetCloudproviders()
-	if err != nil {
-		self.taskFail(ctx, sku, err.Error())
-		return
-	}
 
-	for _, cloudprovider := range cloudproviders {
-		provider, err := cloudprovider.GetProvider()
+	if !jsonutils.QueryBoolean(self.Params, "purge", false) {
+		cloudproviders, err := sku.GetPrivateCloudproviders()
 		if err != nil {
-			log.Warningf("failed to get provider for cloudprovider %s error: %v", cloudprovider.Name, err)
-			continue
+			self.taskFail(ctx, sku, err.Error())
+			return
 		}
-		regions := provider.GetIRegions()
-		for _, region := range regions {
-			err = region.DeleteISkuByName(sku.Name)
+
+		for _, cloudprovider := range cloudproviders {
+			provider, err := cloudprovider.GetProvider()
 			if err != nil {
-				log.Warningf("failed to delete sku %s for cloudprovider %s error: %v", sku.Name, cloudprovider.Name, err)
+				log.Warningf("failed to get provider for cloudprovider %s error: %v", cloudprovider.Name, err)
+				continue
+			}
+			regions := provider.GetIRegions()
+			for _, region := range regions {
+				iskus, err := region.GetISkus()
+				if err != nil {
+					log.Warningf("failed to get region %s skus", region.GetName())
+					continue
+				}
+				for _, isku := range iskus {
+					if isku.GetName() == sku.Name && isku.GetCpuCoreCount() == sku.CpuCoreCount && isku.GetMemorySizeMB() == sku.MemorySizeMB {
+						err = isku.Delete()
+						if err != nil {
+							log.Warningf("failed to delete sku %s %dC%dM", sku.Name, sku.CpuCoreCount, sku.MemorySizeMB)
+						}
+					}
+				}
 			}
 		}
 	}
 
-	err = sku.RealDelete(ctx, self.UserCred)
+	err := sku.RealDelete(ctx, self.UserCred)
 	if err != nil {
 		err = errors.Wrapf(err, "sku.RealDelete")
 		self.taskFail(ctx, sku, err.Error())

pkg/multicloud/esxi/fakeregion.go

@@ -142,7 +142,7 @@ func (cli *SESXiClient) GetIStoragecacheById(idstr string) (cloudprovider.ICloud
 	return nil, cloudprovider.ErrNotFound
 }
 
-func (cli *SESXiClient) GetISkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+func (cli *SESXiClient) GetISkus() ([]cloudprovider.ICloudSku, error) {
 	return nil, cloudprovider.ErrNotSupported
 }
 

pkg/multicloud/objectstore/objectstore.go

@@ -299,16 +299,12 @@ func (cli *SObjectStoreClient) CreateILoadBalancerCertificate(cert *cloudprovide
 	return nil, cloudprovider.ErrNotSupported
 }
 
-func (cli *SObjectStoreClient) GetISkuById(skuId string) (cloudprovider.ICloudSku, error) {
+func (cli *SObjectStoreClient) GetISkus() ([]cloudprovider.ICloudSku, error) {
 	return nil, cloudprovider.ErrNotSupported
 }
 
-func (cli *SObjectStoreClient) GetISkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
-	return nil, cloudprovider.ErrNotSupported
-}
-
-func (cli *SObjectStoreClient) CreateISku(sku *cloudprovider.SServerSku) (cloudprovider.ICloudSku, error) {
-	return nil, cloudprovider.ErrNotSupported
+func (cli *SObjectStoreClient) CreateISku(name string, vCpu int, memoryMb int) error {
+	return cloudprovider.ErrNotSupported
 }
 
 ////////////////////////////////// S3 API ///////////////////////////////////

pkg/multicloud/openstack/flavor.go

@@ -22,7 +22,6 @@ import (
 	"yunion.io/x/jsonutils"
 
 	api "yunion.io/x/onecloud/pkg/apis/compute"
-	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/onecloud/pkg/multicloud"
 )
 
@@ -117,12 +116,9 @@ func (region *SRegion) syncFlavor(name string, cpu, memoryMb, diskGB int) (strin
 	return "", fmt.Errorf("failed to find right flavor(name: %s cpu: %d memory: %d)", name, cpu, memoryMb)
 }
 
-func (region *SRegion) CreateISku(sku *cloudprovider.SServerSku) (cloudprovider.ICloudSku, error) {
-	isku, err := region.CreateFlavor(sku.Name, sku.CpuCoreCount, sku.MemorySizeMB, 30)
-	if err != nil {
-		return nil, errors.Wrapf(err, "region.CreateFlavor")
-	}
-	return isku, nil
+func (region *SRegion) CreateISku(name string, vCpu int, memoryMb int) error {
+	_, err := region.CreateFlavor(name, vCpu, memoryMb, 30)
+	return err
 }
 
 func (region *SRegion) CreateFlavor(name string, cpu int, memoryMb int, diskGB int) (*SFlavor, error) {

pkg/multicloud/openstack/region.go

@@ -19,8 +19,6 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/pkg/errors"
-
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
 
@@ -472,7 +470,7 @@ func (region *SRegion) CreateILoadBalancerAcl(acl *cloudprovider.SLoadbalancerAc
 	return nil, cloudprovider.ErrNotImplemented
 }
 
-func (region *SRegion) GetISkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+func (region *SRegion) GetISkus() ([]cloudprovider.ICloudSku, error) {
 	flavors, err := region.GetFlavors()
 	if err != nil {
 		return nil, err
@@ -485,26 +483,6 @@ func (region *SRegion) GetISkus(zoneId string) ([]cloudprovider.ICloudSku, error
 	return iskus, nil
 }
 
-func (region *SRegion) DeleteISkuByName(name string) error {
-	skus, err := region.GetISkus("")
-	if err != nil {
-		return errors.Wrap(err, "region.GetISkus()")
-	}
-	for _, sku := range skus {
-		if sku.GetName() == name {
-			err = sku.Delete()
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func (region *SRegion) GetISkuById(skuId string) (cloudprovider.ICloudSku, error) {
-	return region.GetFlavor(skuId)
-}
-
 func (region *SRegion) GetIBuckets() ([]cloudprovider.ICloudBucket, error) {
 	return nil, cloudprovider.ErrNotImplemented
 }

pkg/multicloud/region_base.go

@@ -50,12 +50,12 @@ func (self *SRegion) CancelSnapshotPolicyToDisks(snapshotPolicyId string, diskId
 	return fmt.Errorf("ApplySnapshotPolicyToDisks not implement")
 }
 
-func (self *SRegion) GetISkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+func (self *SRegion) GetISkus() ([]cloudprovider.ICloudSku, error) {
 	return nil, cloudprovider.ErrNotSupported
 }
 
-func (self *SRegion) DeleteISkuByName(name string) error {
-	return fmt.Errorf("Not Support DeleteISkuByName")
+func (self *SRegion) CreateISku(name string, vCpu int, memoryMb int) error {
+	return fmt.Errorf("Not Implement CreateISku")
 }
 
 func (self *SRegion) GetINetworkInterfaces() ([]cloudprovider.ICloudNetworkInterface, error) {

pkg/multicloud/zstack/offering.go

@@ -57,8 +57,9 @@ func (region *SRegion) GetInstanceOfferingByType(instanceType string) (*SInstanc
 	return nil, cloudprovider.ErrNotFound
 }
 
-func (region *SRegion) CreateISku(sku *cloudprovider.SServerSku) (cloudprovider.ICloudSku, error) {
-	return region.CreateInstanceOffering(sku.Name, sku.CpuCoreCount, sku.MemorySizeMB, "UserVm")
+func (region *SRegion) CreateISku(name string, vCpu int, memoryMb int) error {
+	_, err := region.CreateInstanceOffering(name, vCpu, memoryMb, "UserVm")
+	return err
 }
 
 func (region *SRegion) CreateInstanceOffering(name string, cpu int, memoryMb int, offeringType string) (*SInstanceOffering, error) {

pkg/multicloud/zstack/region.go

@@ -328,13 +328,14 @@ func (region *SRegion) GetISnapshotById(snapshotId string) (cloudprovider.ICloud
 	return region.GetSnapshot(snapshotId)
 }
 
-func (region *SRegion) GetISkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+func (region *SRegion) GetISkus() ([]cloudprovider.ICloudSku, error) {
 	offerings, err := region.GetInstanceOfferings("", "", 0, 0)
 	if err != nil {
 		return nil, err
 	}
 	iskus := []cloudprovider.ICloudSku{}
 	for i := 0; i < len(offerings); i++ {
+		offerings[i].region = region
 		iskus = append(iskus, &offerings[i])
 	}
 	return iskus, nil
@@ -354,10 +355,6 @@ func (region *SRegion) DeleteISkuByName(name string) error {
 	return nil
 }
 
-func (region *SRegion) GetISkuById(skuId string) (cloudprovider.ICloudSku, error) {
-	return region.GetInstanceOffering(skuId)
-}
-
 func (region *SRegion) GetISecurityGroupById(secgroupId string) (cloudprovider.ICloudSecurityGroup, error) {
 	return region.GetSecurityGroup(secgroupId)
 }