Merge pull request #1024 in YUNIONIO/onecloud from ~QUXUAN/onecloud:feature/qx-oepnstack-stage2 to release/2.6.0

* commit 'f5f2addfd7ea634e598293a37879c251b9eea006':
  避免部署主机失败后未设置external_id而删除主机失败
  rebase 2.6.0
  快照磁盘支持区分公有云私有云
  openstack 同步flavor
  openstack创建

pkg/cloudprovider/cloudprovider.go

@@ -36,6 +36,7 @@ type ICloudProvider interface {
 	GetSysInfo() (jsonutils.JSONObject, error)
 	GetVersion() string
 	IsOnPremiseInfrastructure() bool
+	SyncSkuFromCloud() bool
 
 	GetIRegions() []ICloudRegion
 	GetIRegionById(id string) (ICloudRegion, error)

pkg/cloudprovider/fakeregion.go

@@ -115,3 +115,7 @@ func (region *SFakeOnPremiseRegion) CreateILoadBalancer(loadbalancer *SLoadbalan
 func (region *SFakeOnPremiseRegion) CreateILoadBalancerAcl(acl *SLoadbalancerAccessControlList) (ICloudLoadbalancerAcl, error) {
 	return nil, ErrNotSupported
 }
+
+func (region *SFakeOnPremiseRegion) GetSkus(zoneId string) ([]ICloudSku, error) {
+	return nil, ErrNotSupported
+}

pkg/cloudprovider/instance.go

@@ -11,6 +11,7 @@ import (
 type SDiskInfo struct {
 	StorageType string
 	SizeGB      int
+	Name        string
 }
 
 type SManagedVMCreateConfig struct {

pkg/cloudprovider/resources.go

@@ -74,6 +74,8 @@ type ICloudRegion interface {
 	CreateILoadBalancerAcl(acl *SLoadbalancerAccessControlList) (ICloudLoadbalancerAcl, error)
 	CreateILoadBalancerCertificate(cert *SLoadbalancerCertificate) (ICloudLoadbalancerCertificate, error)
 
+	GetSkus(zoneId string) ([]ICloudSku, error)
+
 	GetProvider() string
 }
 
@@ -211,7 +213,7 @@ type ICloudVM interface {
 	GetInstanceType() string
 
 	AssignSecurityGroup(secgroupId string) error
-	AssignSecurityGroups(secgroupIds []string) error
+	SetSecurityGroups(secgroupIds []string) error
 
 	GetHypervisor() string
 
@@ -522,3 +524,38 @@ type ICloudLoadbalancerAcl interface {
 	Sync(acl *SLoadbalancerAccessControlList) error
 	Delete() error
 }
+
+type ICloudSku interface {
+	ICloudResource
+
+	GetInstanceTypeFamily() string
+	GetInstanceTypeCategory() string
+
+	GetPrepaidStatus() string
+	GetPostpaidStatus() string
+
+	GetCpuCoreCount() int
+	GetMemorySizeMB() int
+
+	GetOsName() string
+
+	GetSysDiskResizable() bool
+	GetSysDiskType() string
+	GetSysDiskMinSizeGB() int
+	GetSysDiskMaxSizeGB() int
+
+	GetAttachedDiskType() string
+	GetAttachedDiskSizeGB() int
+	GetAttachedDiskCount() int
+
+	GetDataDiskTypes() string
+	GetDataDiskMaxCount() int
+
+	GetNicType() string
+	GetNicMaxCount() int
+
+	GetGpuAttachable() bool
+	GetGpuSpec() string
+	GetGpuCount() int
+	GetGpuMaxCount() int
+}

pkg/compute/guestdrivers/aliyun.go

@@ -162,6 +162,8 @@ func (self *SAliyunGuestDriver) RequestDeployGuestOnHost(ctx context.Context, gu
 			if createErr != nil {
 				return nil, createErr
 			}
+			guest.SetExternalId(iVM.GetGlobalId())
+
 			log.Debugf("VMcreated %s, wait status ready ...", iVM.GetGlobalId())
 			err = cloudprovider.WaitStatus(iVM, models.VM_READY, time.Second*5, time.Second*1800)
 			if err != nil {

pkg/compute/guestdrivers/aws.go

@@ -133,6 +133,8 @@ func (self *SAwsGuestDriver) RequestDeployGuestOnHost(ctx context.Context, guest
 				return nil, createErr
 			}
 
+			guest.SetExternalId(iVM.GetGlobalId())
+
 			log.Debugf("VMcreated %s, wait status running ...", iVM.GetGlobalId())
 			err = cloudprovider.WaitStatus(iVM, models.VM_RUNNING, time.Second*5, time.Second*1800)
 			if err != nil {

pkg/compute/guestdrivers/azure.go

@@ -154,11 +154,12 @@ func (self *SAzureGuestDriver) RequestDeployGuestOnHost(ctx context.Context, gue
 			}
 
 			iVM, createErr := ihost.CreateVM(&desc)
-
 			if createErr != nil {
 				return nil, createErr
 			}
 
+			guest.SetExternalId(iVM.GetGlobalId())
+
 			log.Debugf("VMcreated %s, wait status running ...", iVM.GetGlobalId())
 			if err = cloudprovider.WaitStatus(iVM, models.VM_RUNNING, time.Second*5, time.Second*1800); err != nil {
 				return nil, err

pkg/compute/guestdrivers/huawei.go

@@ -123,6 +123,8 @@ func (self *SHuaweiGuestDriver) RequestDeployGuestOnHost(ctx context.Context, gu
 			if createErr != nil {
 				return nil, createErr
 			}
+			guest.SetExternalId(iVM.GetGlobalId())
+
 			log.Debugf("VMcreated %s, wait status ready ...", iVM.GetGlobalId())
 			err = cloudprovider.WaitStatus(iVM, models.VM_RUNNING, time.Second*5, time.Second*1800)
 			if err != nil {

pkg/compute/guestdrivers/managedvirtual.go

@@ -49,6 +49,7 @@ func (self *SManagedVirtualizedGuestDriver) GetJsonDescAtHost(ctx context.Contex
 		disk := disks[i].GetDisk()
 		storage := disk.GetStorage()
 		if i == 0 {
+			config.SysDisk.Name = disk.Name
 			config.SysDisk.StorageType = storage.StorageType
 			config.SysDisk.SizeGB = disk.DiskSize / 1024
 			cache := storage.GetStoragecache()
@@ -64,6 +65,7 @@ func (self *SManagedVirtualizedGuestDriver) GetJsonDescAtHost(ctx context.Contex
 			dataDisk := cloudprovider.SDiskInfo{
 				SizeGB:      disk.DiskSize / 1024,
 				StorageType: storage.StorageType,
+				Name:        disk.Name,
 			}
 			config.DataDisks = append(config.DataDisks, dataDisk)
 		}
@@ -467,7 +469,7 @@ func (self *SManagedVirtualizedGuestDriver) RequestSyncConfigOnHost(ctx context.
 				}
 				externalIds = append(externalIds, extID)
 			}
-			return nil, iVM.AssignSecurityGroups(externalIds)
+			return nil, iVM.SetSecurityGroups(externalIds)
 		}
 
 		iDisks, err := iVM.GetIDisks()

pkg/compute/guestdrivers/openstack.go

@@ -1,8 +1,21 @@
 package guestdrivers
 
 import (
+	"context"
+	"fmt"
+	"time"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/log"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
+	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/onecloud/pkg/compute/models"
 	"yunion.io/x/onecloud/pkg/compute/options"
+	"yunion.io/x/onecloud/pkg/httperrors"
+	"yunion.io/x/onecloud/pkg/mcclient"
+	"yunion.io/x/onecloud/pkg/util/billing"
+	"yunion.io/x/pkg/util/compare"
 )
 
 type SOpenStackGuestDriver struct {
@@ -29,3 +42,282 @@ func (self *SOpenStackGuestDriver) GetDefaultSysDiskBackend() string {
 func (self *SOpenStackGuestDriver) GetMinimalSysDiskSizeGb() int {
 	return options.Options.DefaultDiskSizeMB / 1024
 }
+
+func (self *SOpenStackGuestDriver) ChooseHostStorage(host *models.SHost, backend string) *models.SStorage {
+	storages := host.GetAttachedStorages("")
+	for i := 0; i < len(storages); i++ {
+		if storages[i].StorageType == backend {
+			return &storages[i]
+		}
+	}
+	for _, stype := range []string{models.STORAGE_OPENSTACK_ISCSI} {
+		for i := 0; i < len(storages); i++ {
+			if storages[i].StorageType == stype {
+				return &storages[i]
+			}
+		}
+	}
+	return nil
+}
+
+func (self *SOpenStackGuestDriver) GetDetachDiskStatus() ([]string, error) {
+	return []string{models.VM_READY, models.VM_RUNNING}, nil
+}
+
+func (self *SOpenStackGuestDriver) GetAttachDiskStatus() ([]string, error) {
+	return []string{models.VM_READY, models.VM_RUNNING}, nil
+}
+
+func (self *SOpenStackGuestDriver) GetRebuildRootStatus() ([]string, error) {
+	return []string{models.VM_READY, models.VM_RUNNING, models.VM_REBUILD_ROOT_FAIL}, nil
+}
+
+func (self *SOpenStackGuestDriver) GetChangeConfigStatus() ([]string, error) {
+	return []string{models.VM_READY, models.VM_RUNNING}, nil
+}
+
+func (self *SOpenStackGuestDriver) GetDeployStatus() ([]string, error) {
+	return []string{models.VM_RUNNING}, nil
+}
+
+func (self *SOpenStackGuestDriver) ValidateCreateData(ctx context.Context, userCred mcclient.TokenCredential, data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) {
+	data, err := self.SManagedVirtualizedGuestDriver.ValidateCreateData(ctx, userCred, data)
+	if err != nil {
+		return nil, err
+	}
+	if data.Contains("net.0") && data.Contains("net.1") {
+		return nil, httperrors.NewInputParameterError("cannot support more than 1 nic")
+	}
+	return data, nil
+}
+
+func (self *SOpenStackGuestDriver) RequestDeployGuestOnHost(ctx context.Context, guest *models.SGuest, host *models.SHost, task taskman.ITask) error {
+	config, err := guest.GetDeployConfigOnHost(ctx, task.GetUserCred(), host, task.GetParams())
+	if err != nil {
+		log.Errorf("GetDeployConfigOnHost error: %v", err)
+		return err
+	}
+	log.Debugf("RequestDeployGuestOnHost: %s", config)
+
+	desc := cloudprovider.SManagedVMCreateConfig{}
+	if err := desc.GetConfig(config); err != nil {
+		return err
+	}
+
+	action, err := config.GetString("action")
+	if err != nil {
+		return err
+	}
+
+	ihost, err := host.GetIHost()
+	if err != nil {
+		return err
+	}
+
+	if action == "create" {
+		taskman.LocalTaskRun(task, func() (jsonutils.JSONObject, error) {
+
+			iVM, createErr := ihost.CreateVM(&desc)
+			if createErr != nil {
+				return nil, createErr
+			}
+
+			// 避免部署失败后，不能删除openstack平台机器
+			guest.SetExternalId(iVM.GetGlobalId())
+
+			log.Debugf("VMcreated %s, wait status running ...", iVM.GetGlobalId())
+			err = cloudprovider.WaitStatus(iVM, models.VM_RUNNING, time.Second*5, time.Second*1800)
+			if err != nil {
+				return nil, err
+			}
+			log.Debugf("VMcreated %s, and status is running", iVM.GetGlobalId())
+
+			iVM, err = ihost.GetIVMById(iVM.GetGlobalId())
+			if err != nil {
+				log.Errorf("cannot find vm %s", err)
+				return nil, err
+			}
+
+			err = cloudprovider.RetryUntil(func() (bool, error) {
+				idisks, err := iVM.GetIDisks()
+				if err != nil {
+					log.Errorf("cannot find vm disks %s", err)
+					return false, err
+				}
+				if len(idisks) == len(desc.DataDisks)+1 {
+					return true, nil
+				} else {
+					return false, nil
+				}
+			}, 10)
+			if err != nil {
+				return nil, err
+			}
+
+			data := fetchIVMinfo(desc, iVM, guest.Id, "root", desc.Password, action)
+			return data, nil
+		})
+	} else if action == "deploy" {
+		iVM, err := ihost.GetIVMById(guest.GetExternalId())
+		if err != nil || iVM == nil {
+			log.Errorf("cannot find vm %s", err)
+			return fmt.Errorf("cannot find vm")
+		}
+
+		params := task.GetParams()
+		log.Debugf("Deploy VM params %s", params.String())
+
+		deleteKeypair := jsonutils.QueryBoolean(params, "__delete_keypair__", false)
+		taskman.LocalTaskRun(task, func() (jsonutils.JSONObject, error) {
+
+			err := iVM.DeployVM(ctx, desc.Name, desc.Password, desc.PublicKey, deleteKeypair, desc.Description)
+			if err != nil {
+				return nil, err
+			}
+
+			data := fetchIVMinfo(desc, iVM, guest.Id, "root", desc.Password, action)
+			return data, nil
+		})
+	} else if action == "rebuild" {
+
+		iVM, err := ihost.GetIVMById(guest.GetExternalId())
+		if err != nil || iVM == nil {
+			log.Errorf("cannot find vm %s", err)
+			return fmt.Errorf("cannot find vm")
+		}
+
+		taskman.LocalTaskRun(task, func() (jsonutils.JSONObject, error) {
+
+			diskId, err := iVM.RebuildRoot(ctx, desc.ExternalImageId, desc.Password, desc.PublicKey, desc.SysDisk.SizeGB)
+			if err != nil {
+				return nil, err
+			}
+
+			log.Debugf("VMrebuildRoot %s new diskID %s, wait status ready ...", iVM.GetGlobalId(), diskId)
+
+			err = cloudprovider.WaitStatus(iVM, models.VM_READY, time.Second*5, time.Second*1800)
+			if err != nil {
+				return nil, err
+			}
+			log.Debugf("VMrebuildRoot %s, and status is ready", iVM.GetGlobalId())
+
+			maxWaitSecs := 300
+			waited := 0
+
+			for {
+				// hack, wait disk number consistent
+				idisks, err := iVM.GetIDisks()
+				if err != nil {
+					log.Errorf("fail to find VM idisks %s", err)
+					return nil, err
+				}
+				if len(idisks) < len(desc.DataDisks)+1 {
+					if waited > maxWaitSecs {
+						log.Errorf("inconsistent disk number, wait timeout, must be something wrong on remote")
+						return nil, cloudprovider.ErrTimeout
+					}
+					log.Debugf("inconsistent disk number???? %d != %d", len(idisks), len(desc.DataDisks)+1)
+					time.Sleep(time.Second * 5)
+					waited += 5
+				} else {
+					if idisks[0].GetGlobalId() != diskId {
+						log.Errorf("system disk id inconsistent %s != %s", idisks[0].GetGlobalId(), diskId)
+						return nil, fmt.Errorf("inconsistent sys disk id after rebuild root")
+					}
+
+					break
+				}
+			}
+
+			data := fetchIVMinfo(desc, iVM, guest.Id, "root", desc.Password, action)
+
+			return data, nil
+		})
+
+	} else {
+		log.Errorf("RequestDeployGuestOnHost: Action %s not supported", action)
+		return fmt.Errorf("Action %s not supported", action)
+	}
+
+	return nil
+}
+
+func (self *SOpenStackGuestDriver) RequestSyncConfigOnHost(ctx context.Context, guest *models.SGuest, host *models.SHost, task taskman.ITask) error {
+	taskman.LocalTaskRun(task, func() (jsonutils.JSONObject, error) {
+		ihost, err := host.GetIHost()
+		if err != nil {
+			return nil, err
+		}
+		iVM, err := ihost.GetIVMById(guest.ExternalId)
+		if err != nil {
+			return nil, err
+		}
+
+		if fwOnly, _ := task.GetParams().Bool("fw_only"); fwOnly {
+			iregion, err := host.GetIRegion()
+			if err != nil {
+				return nil, err
+			}
+			secgroups := guest.GetSecgroups()
+			externalIds := []string{}
+			for _, secgroup := range secgroups {
+
+				lockman.LockRawObject(ctx, "secgroupcache", fmt.Sprintf("%s-normal", guest.SecgrpId))
+				defer lockman.ReleaseRawObject(ctx, "secgroupcache", fmt.Sprintf("%s-normal", guest.SecgrpId))
+
+				secgroupCache := models.SecurityGroupCacheManager.Register(ctx, task.GetUserCred(), secgroup.Id, "normal", host.GetRegion().Id, host.ManagerId)
+				if secgroupCache == nil {
+					return nil, fmt.Errorf("failed to registor secgroupCache for secgroup: %s", secgroup.Id)
+				}
+				extID, err := iregion.SyncSecurityGroup(secgroupCache.ExternalId, "", secgroup.Name, secgroup.Description, secgroup.GetSecRules(""))
+				if err != nil {
+					return nil, err
+				}
+				if err = secgroupCache.SetExternalId(extID); err != nil {
+					return nil, err
+				}
+				externalIds = append(externalIds, extID)
+			}
+			return nil, iVM.SetSecurityGroups(externalIds)
+		}
+
+		iDisks, err := iVM.GetIDisks()
+		if err != nil {
+			return nil, err
+		}
+		disks := make([]models.SDisk, 0)
+		for _, guestdisk := range guest.GetDisks() {
+			disk := guestdisk.GetDisk()
+			disks = append(disks, *disk)
+		}
+
+		added := make([]models.SDisk, 0)
+		commondb := make([]models.SDisk, 0)
+		commonext := make([]cloudprovider.ICloudDisk, 0)
+		removed := make([]cloudprovider.ICloudDisk, 0)
+
+		if err := compare.CompareSets(disks, iDisks, &added, &commondb, &commonext, &removed); err != nil {
+			return nil, err
+		}
+		for _, disk := range removed {
+			if err := iVM.DetachDisk(ctx, disk.GetId()); err != nil {
+				return nil, err
+			}
+		}
+		for _, disk := range added {
+			if err := iVM.AttachDisk(ctx, disk.ExternalId); err != nil {
+				return nil, err
+			}
+		}
+		return nil, nil
+	})
+	return nil
+}
+
+func (self *SOpenStackGuestDriver) AllowReconfigGuest() bool {
+	return true
+}
+
+func (self *SOpenStackGuestDriver) IsSupportedBillingCycle(bc billing.SBillingCycle) bool {
+	return false
+}

pkg/compute/guestdrivers/qcloud.go

@@ -181,6 +181,7 @@ func (self *SQcloudGuestDriver) RequestDeployGuestOnHost(ctx context.Context, gu
 			if createErr != nil {
 				return nil, createErr
 			}
+			guest.SetExternalId(iVM.GetGlobalId())
 
 			log.Debugf("VMcreated %s, wait status running ...", iVM.GetGlobalId())
 			err = cloudprovider.WaitStatus(iVM, models.VM_RUNNING, time.Second*5, time.Second*1800)
@@ -350,7 +351,7 @@ func (self *SQcloudGuestDriver) RequestSyncConfigOnHost(ctx context.Context, gue
 				}
 				externalIds = append(externalIds, extID)
 			}
-			return nil, iVM.AssignSecurityGroups(externalIds)
+			return nil, iVM.SetSecurityGroups(externalIds)
 		}
 
 		iDisks, err := iVM.GetIDisks()

pkg/compute/hostdrivers/openstack.go

@@ -16,3 +16,11 @@ func init() {
 func (self *SOpenStackHostDriver) GetHostType() string {
 	return models.HOST_TYPE_OPENSTACK
 }
+
+func (self *SOpenStackHostDriver) ValidateDiskSize(storage *models.SStorage, sizeGb int) error {
+	return nil
+}
+
+func (driver *SOpenStackHostDriver) GetStoragecacheQuota(host *models.SHost) int {
+	return 100
+}

pkg/compute/models/guests.go

@@ -161,6 +161,7 @@ var PUBLIC_CLOUD_HYPERVISORS = []string{
 	HYPERVISOR_AZURE,
 	HYPERVISOR_QCLOUD,
 	HYPERVISOR_HUAWEI,
+	HYPERVISOR_OPENSTACK,
 }
 
 // var HYPERVISORS = []string{HYPERVISOR_ALIYUN}
@@ -2909,9 +2910,9 @@ func (self *SGuest) GetDeployConfigOnHost(ctx context.Context, userCred mcclient
 		registerVpcId := vpc.ExternalId
 		externalVpcId := vpc.ExternalId
 		switch self.Hypervisor {
-		case HYPERVISOR_ALIYUN, HYPERVISOR_AWS, HYPERVISOR_OPENSTACK, HYPERVISOR_HUAWEI:
+		case HYPERVISOR_ALIYUN, HYPERVISOR_AWS, HYPERVISOR_HUAWEI:
 			break
-		case HYPERVISOR_QCLOUD:
+		case HYPERVISOR_QCLOUD, HYPERVISOR_OPENSTACK:
 			registerVpcId = "normal"
 		case HYPERVISOR_AZURE:
 			registerVpcId, externalVpcId = "normal", "normal"

pkg/compute/models/skus.go

@@ -9,9 +9,11 @@ import (
 
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
+	"yunion.io/x/pkg/util/compare"
 	"yunion.io/x/sqlchemy"
 
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/onecloud/pkg/httperrors"
 	"yunion.io/x/onecloud/pkg/mcclient"
 )
@@ -644,6 +646,15 @@ func (manager *SServerSkuManager) GetSkuCountByRegion(regionId string) int {
 	return q.Count()
 }
 
+func (manager *SServerSkuManager) GetSkuCountByZone(zoneId string) []SServerSku {
+	skus := []SServerSku{}
+	q := manager.Query().Equals("zone_id", zoneId)
+	if err := db.FetchModelObjects(manager, q, &skus); err != nil {
+		log.Errorf("failed to get skus by zoneId %s error: %v", zoneId, err)
+	}
+	return skus
+}
+
 // 删除表中zone not found的记录
 func (manager *SServerSkuManager) PendingDeleteInvalidSku() error {
 	sq := ZoneManager.Query("id").Distinct().SubQuery()
@@ -670,3 +681,99 @@ func (manager *SServerSkuManager) PendingDeleteInvalidSku() error {
 
 	return nil
 }
+
+func (manager *SServerSkuManager) SyncCloudSkusByRegion(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, zone *SZone, skus []cloudprovider.ICloudSku) compare.SyncResult {
+	syncResult := compare.SyncResult{}
+	dbSkus := manager.GetSkuCountByZone(zone.Id)
+
+	removed := []SServerSku{}
+	commondb := []SServerSku{}
+	commonext := []cloudprovider.ICloudSku{}
+	added := []cloudprovider.ICloudSku{}
+
+	if err := compare.CompareSets(dbSkus, skus, &removed, &commondb, &commonext, &added); err != nil {
+		syncResult.Error(err)
+		return syncResult
+	}
+	for i := 0; i < len(removed); i++ {
+		if err := removed[i].ValidateDeleteCondition(ctx); err == nil {
+			removed[i].Delete(ctx, userCred)
+		}
+		syncResult.Delete()
+	}
+
+	for i := 0; i < len(commondb); i++ {
+		err := commondb[i].syncWithCloudSku(ctx, userCred, commonext[i], zone, provider)
+		if err != nil {
+			syncResult.UpdateError(err)
+		} else {
+			syncResult.Update()
+		}
+	}
+
+	for i := 0; i < len(added); i++ {
+		err := manager.newFromCloudSku(ctx, userCred, added[i], zone, provider)
+		if err != nil {
+			syncResult.AddError(err)
+		} else {
+			syncResult.Add()
+		}
+	}
+	return syncResult
+}
+
+func (self *SServerSku) constructSku(extSku cloudprovider.ICloudSku) {
+	self.InstanceTypeFamily = extSku.GetInstanceTypeFamily()
+	self.InstanceTypeCategory = extSku.GetInstanceTypeCategory()
+
+	self.PrepaidStatus = extSku.GetPrepaidStatus()
+	self.PostpaidStatus = extSku.GetPostpaidStatus()
+
+	self.CpuCoreCount = extSku.GetCpuCoreCount()
+	self.MemorySizeMB = extSku.GetMemorySizeMB()
+
+	self.OsName = extSku.GetOsName()
+
+	self.SysDiskResizable = extSku.GetSysDiskResizable()
+	self.SysDiskType = extSku.GetSysDiskType()
+	self.SysDiskMinSizeGB = extSku.GetSysDiskMinSizeGB()
+	self.SysDiskMaxSizeGB = extSku.GetSysDiskMaxSizeGB()
+
+	self.AttachedDiskType = extSku.GetAttachedDiskType()
+	self.AttachedDiskSizeGB = extSku.GetAttachedDiskSizeGB()
+	self.AttachedDiskCount = extSku.GetAttachedDiskCount()
+
+	self.DataDiskTypes = extSku.GetDataDiskTypes()
+	self.DataDiskMaxCount = extSku.GetDataDiskMaxCount()
+
+	self.NicType = extSku.GetNicType()
+	self.NicMaxCount = extSku.GetNicMaxCount()
+
+	self.GpuAttachable = extSku.GetGpuAttachable()
+	self.GpuSpec = extSku.GetGpuSpec()
+	self.GpuCount = extSku.GetGpuCount()
+	self.GpuMaxCount = extSku.GetGpuMaxCount()
+	self.Name = extSku.GetName()
+}
+
+func (self *SServerSku) syncWithCloudSku(ctx context.Context, userCred mcclient.TokenCredential, extSku cloudprovider.ICloudSku, zone *SZone, provider *SCloudprovider) error {
+	_, err := self.GetModelManager().TableSpec().Update(self, func() error {
+		self.constructSku(extSku)
+		return nil
+	})
+	return err
+}
+
+func (manager *SServerSkuManager) newFromCloudSku(ctx context.Context, userCred mcclient.TokenCredential, extSku cloudprovider.ICloudSku, zone *SZone, provider *SCloudprovider) error {
+	region := zone.GetRegion()
+	sku := &SServerSku{
+		CloudregionId: region.Id,
+		ZoneId:        zone.Id,
+		Provider:      provider.Provider,
+	}
+	sku.constructSku(extSku)
+	sku.Name = extSku.GetName()
+	sku.ExternalId = extSku.GetGlobalId()
+	sku.SetModelManager(manager)
+	return manager.TableSpec().Insert(sku)
+}

pkg/compute/models/storages.go

@@ -93,6 +93,7 @@ var (
 		STORAGE_GP2_SSD, STORAGE_IO1_SSD, STORAGE_ST1_HDD, STORAGE_SC1_HDD, STORAGE_STANDARD_HDD,
 		STORAGE_LOCAL_BASIC, STORAGE_LOCAL_SSD, STORAGE_CLOUD_BASIC, STORAGE_CLOUD_PREMIUM,
 		STORAGE_HUAWEI_SSD, STORAGE_HUAWEI_SAS, STORAGE_HUAWEI_SATA,
+		STORAGE_OPENSTACK_ISCSI,
 	}
 
 	STORAGE_LIMITED_TYPES = []string{STORAGE_LOCAL, STORAGE_BAREMETAL, STORAGE_NAS, STORAGE_RBD, STORAGE_NFS}

pkg/compute/tasks/cloud_provider_sync_info_task.go

@@ -159,7 +159,9 @@ func syncPublicCloudProviderInfo(ctx context.Context, provider *models.SCloudpro
 
 		localZones, remoteZones := syncRegionZones(ctx, provider, task, &localRegions[i], remoteRegions[i])
 
-		syncRegionSkus(ctx, provider, task, &localRegions[i])
+		if !driver.SyncSkuFromCloud() {
+			syncRegionSkus(ctx, provider, task, &localRegions[i])
+		}
 
 		syncRegionVPCs(ctx, provider, task, &localRegions[i], remoteRegions[i], syncRange)
 
@@ -177,6 +179,10 @@ func syncPublicCloudProviderInfo(ctx context.Context, provider *models.SCloudpro
 				if len(newPairs) > 0 {
 					storageCachePairs = append(storageCachePairs, newPairs...)
 				}
+
+				if driver.SyncSkuFromCloud() {
+					syncRegionSkusFromCloud(ctx, provider, task, &localZones[i], remoteRegions[i], remoteZones[j])
+				}
 			}
 		}
 		syncRegionSnapshots(ctx, provider, task, &localRegions[i], remoteRegions[i], syncRange)
@@ -329,6 +335,24 @@ func syncLoadbalancerBackends(ctx context.Context, provider *models.SCloudprovid
 	}
 }
 
+func syncRegionSkusFromCloud(ctx context.Context, provider *models.SCloudprovider, task *CloudProviderSyncInfoTask, localZone *models.SZone, remoteRegion cloudprovider.ICloudRegion, remoteZone cloudprovider.ICloudZone) {
+	skus, err := remoteRegion.GetSkus(remoteZone.GetId())
+	if err != nil {
+		msg := fmt.Sprintf("GetSkus for zone %s failed %v", localZone.Name, err)
+		log.Errorf(msg)
+		logSyncFailed(provider, task, msg)
+		return
+	}
+
+	result := models.ServerSkuManager.SyncCloudSkusByRegion(ctx, task.GetUserCred(), provider, localZone, skus)
+	msg := result.Result()
+	log.Infof("SyncCloudSkusByRegion for zone %s result: %s", localZone.Name, msg)
+	if result.IsError() {
+		logSyncFailed(provider, task, msg)
+		return
+	}
+}
+
 func syncRegionSkus(ctx context.Context, provider *models.SCloudprovider, task *CloudProviderSyncInfoTask, localRegion *models.SCloudregion) {
 	if localRegion == nil {
 		log.Debugf("local region is nil skipped.")

pkg/util/aliyun/instance.go

@@ -896,8 +896,8 @@ func (self *SInstance) AssignSecurityGroup(secgroupId string) error {
 	return self.host.zone.region.AssignSecurityGroup(secgroupId, self.InstanceId)
 }
 
-func (self *SInstance) AssignSecurityGroups(secgroupIds []string) error {
-	return self.host.zone.region.AssignSecurityGroups(secgroupIds, self.InstanceId)
+func (self *SInstance) SetSecurityGroups(secgroupIds []string) error {
+	return self.host.zone.region.SetSecurityGroups(secgroupIds, self.InstanceId)
 }
 
 func (self *SInstance) GetBillingType() string {

pkg/util/aliyun/provider/provider.go

@@ -98,6 +98,10 @@ func (self *SAliyunProvider) IsOnPremiseInfrastructure() bool {
 	return false
 }
 
+func (self *SAliyunProvider) SyncSkuFromCloud() bool {
+	return false
+}
+
 func (self *SAliyunProvider) GetId() string {
 	return aliyun.CLOUD_PROVIDER_ALIYUN
 }

pkg/util/aliyun/region.go

@@ -888,3 +888,7 @@ func (region *SRegion) CreateILoadBalancerAcl(acl *cloudprovider.SLoadbalancerAc
 	}
 	return iAcl, region.AddAccessControlListEntry(aclId, acl.Entrys)
 }
+
+func (region *SRegion) GetSkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+	return nil, cloudprovider.ErrNotImplemented
+}

pkg/util/aliyun/securitygroup.go

@@ -501,10 +501,10 @@ func (self *SRegion) syncSecgroupRules(secgroupId string, rules []secrules.Secur
 }
 
 func (self *SRegion) AssignSecurityGroup(secgroupId, instanceId string) error {
-	return self.AssignSecurityGroups([]string{secgroupId}, instanceId)
+	return self.SetSecurityGroups([]string{secgroupId}, instanceId)
 }
 
-func (self *SRegion) AssignSecurityGroups(secgroupIds []string, instanceId string) error {
+func (self *SRegion) SetSecurityGroups(secgroupIds []string, instanceId string) error {
 	params := map[string]string{"InstanceId": instanceId}
 	for _, secgroupId := range secgroupIds {
 		params["SecurityGroupId"] = secgroupId

pkg/util/aws/instance.go

@@ -283,10 +283,10 @@ func (self *SInstance) GetMachine() string {
 }
 
 func (self *SInstance) AssignSecurityGroup(secgroupId string) error {
-	return self.AssignSecurityGroups([]string{secgroupId})
+	return self.SetSecurityGroups([]string{secgroupId})
 }
 
-func (self *SInstance) AssignSecurityGroups(secgroupIds []string) error {
+func (self *SInstance) SetSecurityGroups(secgroupIds []string) error {
 	ids := []*string{}
 	for i := 0; i < len(secgroupIds); i++ {
 		ids = append(ids, &secgroupIds[i])

pkg/util/aws/provider/provider.go

@@ -109,6 +109,10 @@ func (self *SAwsProvider) IsOnPremiseInfrastructure() bool {
 	return false
 }
 
+func (self *SAwsProvider) SyncSkuFromCloud() bool {
+	return false
+}
+
 func (self *SAwsProvider) GetIRegionById(id string) (cloudprovider.ICloudRegion, error) {
 	return self.client.GetIRegionById(id)
 }

pkg/util/aws/region.go

@@ -499,3 +499,7 @@ func (region *SRegion) CreateILoadBalancer(loadbalancer *cloudprovider.SLoadbala
 func (region *SRegion) CreateILoadBalancerAcl(acl *cloudprovider.SLoadbalancerAccessControlList) (cloudprovider.ICloudLoadbalancerAcl, error) {
 	return nil, cloudprovider.ErrNotImplemented
 }
+
+func (region *SRegion) GetSkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+	return nil, cloudprovider.ErrNotImplemented
+}

pkg/util/azure/classic_instance.go

@@ -487,7 +487,7 @@ type assignProperties struct {
 	NetworkSecurityGroup SubResource `json:"networkSecurityGroup,omitempty"`
 }
 
-func (self *SClassicInstance) AssignSecurityGroups(secgroupIds []string) error {
+func (self *SClassicInstance) SetSecurityGroups(secgroupIds []string) error {
 	return cloudprovider.ErrNotSupported
 }
 

pkg/util/azure/instance.go

@@ -1020,7 +1020,7 @@ func (self *SInstance) AssignSecurityGroup(secgroupId string) error {
 	return self.host.zone.region.AssiginSecurityGroup(self.ID, secgroupId)
 }
 
-func (self *SInstance) AssignSecurityGroups(secgroupIds []string) error {
+func (self *SInstance) SetSecurityGroups(secgroupIds []string) error {
 	return cloudprovider.ErrNotSupported
 }
 

pkg/util/azure/provider/provider.go

@@ -87,6 +87,10 @@ func (self *SAzureProvider) IsOnPremiseInfrastructure() bool {
 	return false
 }
 
+func (self *SAzureProvider) SyncSkuFromCloud() bool {
+	return false
+}
+
 func (self *SAzureProvider) GetId() string {
 	return azure.CLOUD_PROVIDER_AZURE
 }

pkg/util/azure/region.go

@@ -551,3 +551,7 @@ func (region *SRegion) CreateILoadBalancer(loadbalancer *cloudprovider.SLoadbala
 func (region *SRegion) CreateILoadBalancerAcl(acl *cloudprovider.SLoadbalancerAccessControlList) (cloudprovider.ICloudLoadbalancerAcl, error) {
 	return nil, cloudprovider.ErrNotImplemented
 }
+
+func (region *SRegion) GetSkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+	return nil, cloudprovider.ErrNotImplemented
+}

pkg/util/esxi/provider/provider.go

@@ -119,6 +119,10 @@ func (self *SESXiProvider) IsOnPremiseInfrastructure() bool {
 	return true
 }
 
+func (self *SESXiProvider) SyncSkuFromCloud() bool {
+	return false
+}
+
 func (self *SESXiProvider) GetId() string {
 	return esxi.CLOUD_PROVIDER_VMWARE
 }

pkg/util/esxi/virtualmachine.go

@@ -528,7 +528,7 @@ func (dc *SVirtualMachine) ChangeConfig2(ctx context.Context, instanceType strin
 	return cloudprovider.ErrNotImplemented
 }
 
-func (self *SVirtualMachine) AssignSecurityGroups(secgroupIds []string) error {
+func (self *SVirtualMachine) SetSecurityGroups(secgroupIds []string) error {
 	return cloudprovider.ErrNotImplemented
 }
 

pkg/util/huawei/instance.go

@@ -9,6 +9,7 @@ import (
 	"strconv"
 
 	"sort"
+
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
 	"yunion.io/x/onecloud/pkg/cloudprovider"
@@ -398,10 +399,10 @@ func (self *SInstance) GetMachine() string {
 }
 
 func (self *SInstance) AssignSecurityGroup(secgroupId string) error {
-	return self.AssignSecurityGroups([]string{secgroupId})
+	return self.SetSecurityGroups([]string{secgroupId})
 }
 
-func (self *SInstance) AssignSecurityGroups(secgroupIds []string) error {
+func (self *SInstance) SetSecurityGroups(secgroupIds []string) error {
 	currentSecgroups, err := self.host.zone.region.GetInstanceSecrityGroupIds(self.GetId())
 	if err != nil {
 		return err

pkg/util/huawei/provider/provider.go

@@ -101,6 +101,10 @@ func (self *SHuaweiProvider) IsOnPremiseInfrastructure() bool {
 	return false
 }
 
+func (self *SHuaweiProvider) SyncSkuFromCloud() bool {
+	return false
+}
+
 func (self *SHuaweiProvider) GetIRegions() []cloudprovider.ICloudRegion {
 	return self.client.GetIRegions()
 }

pkg/util/huawei/region.go

@@ -641,3 +641,7 @@ func (region *SRegion) CreateILoadBalancer(loadbalancer *cloudprovider.SLoadbala
 func (region *SRegion) CreateILoadBalancerAcl(acl *cloudprovider.SLoadbalancerAccessControlList) (cloudprovider.ICloudLoadbalancerAcl, error) {
 	return nil, cloudprovider.ErrNotImplemented
 }
+
+func (region *SRegion) GetSkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+	return nil, cloudprovider.ErrNotImplemented
+}

pkg/util/openstack/disk.go

@@ -2,6 +2,7 @@ package openstack
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"yunion.io/x/jsonutils"
@@ -104,7 +105,7 @@ func (disk *SDisk) GetMetadata() *jsonutils.JSONDict {
 }
 
 func (region *SRegion) GetDisks(category string) ([]SDisk, error) {
-	_, resp, err := region.CinderGet("/volumes/detail", "", nil)
+	_, resp, err := region.CinderList("/volumes/detail", "", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -126,11 +127,11 @@ func (disk *SDisk) GetId() string {
 }
 
 func (disk *SDisk) Delete(ctx context.Context) error {
-	return cloudprovider.ErrNotImplemented
+	return disk.storage.zone.region.DeleteDisk(disk.ID)
 }
 
 func (disk *SDisk) Resize(ctx context.Context, sizeMb int64) error {
-	return cloudprovider.ErrNotImplemented
+	return disk.storage.zone.region.ResizeDisk(disk.ID, sizeMb)
 }
 
 func (disk *SDisk) GetName() string {
@@ -179,8 +180,8 @@ func (disk *SDisk) Refresh() error {
 	return jsonutils.Update(disk, new)
 }
 
-func (disk *SDisk) ResizeDisk(newSize int64) error {
-	return disk.storage.zone.region.ResizeDisk(disk.ID, newSize)
+func (disk *SDisk) ResizeDisk(sizeMb int64) error {
+	return disk.storage.zone.region.ResizeDisk(disk.ID, sizeMb)
 }
 
 func (disk *SDisk) GetDiskFormat() string {
@@ -226,8 +227,22 @@ func (disk *SDisk) GetMountpoint() string {
 	return ""
 }
 
-func (disk *SRegion) CreateDisk(zoneId string, category string, name string, sizeGb int, desc string) (string, error) {
-	return "", cloudprovider.ErrNotImplemented
+func (region *SRegion) CreateDisk(zoneName string, category string, name string, sizeGb int, desc string) (*SDisk, error) {
+	params := map[string]map[string]interface{}{
+		"volume": {
+			"size":              sizeGb,
+			"volume_type":       category,
+			"name":              name,
+			"description":       desc,
+			"availability_zone": zoneName,
+		},
+	}
+	_, resp, err := region.CinderCreate("/volumes", "", jsonutils.Marshal(params))
+	if err != nil {
+		return nil, err
+	}
+	disk := &SDisk{}
+	return disk, resp.Unmarshal(disk, "volume")
 }
 
 func (region *SRegion) GetDisk(diskId string) (*SDisk, error) {
@@ -239,20 +254,39 @@ func (region *SRegion) GetDisk(diskId string) (*SDisk, error) {
 	return disk, resp.Unmarshal(disk, "volume")
 }
 
-func (disk *SRegion) DeleteDisk(diskId string) error {
-	return cloudprovider.ErrNotImplemented
+func (region *SRegion) DeleteDisk(diskId string) error {
+	_, err := region.CinderDelete("/volumes/"+diskId, "")
+	return err
 }
 
-func (disk *SRegion) ResizeDisk(diskId string, sizeMb int64) error {
-	return cloudprovider.ErrNotImplemented
+func (region *SRegion) ResizeDisk(diskId string, sizeMb int64) error {
+	params := map[string]map[string]interface{}{
+		"os-extend": {
+			"new_size": sizeMb / 1024,
+		},
+	}
+	_, _, err := region.CinderAction(fmt.Sprintf("/volumes/%s/action", diskId), "", jsonutils.Marshal(params))
+	return err
 }
 
-func (disk *SRegion) ResetDisk(diskId, snapshotId string) error {
-	return cloudprovider.ErrNotImplemented
+func (region *SRegion) ResetDisk(diskId, snapshotId string) error {
+	//目前测试接口不能使用
+	return cloudprovider.ErrNotSupported
+	// params := map[string]map[string]interface{}{
+	// 	"revert": {
+	// 		"snapshot_id": snapshotId,
+	// 	},
+	// }
+	// _, _, err := region.CinderAction(fmt.Sprintf("/volumes/%s/action", diskId), "3.40", jsonutils.Marshal(params))
+	// return err
 }
 
 func (disk *SDisk) CreateISnapshot(ctx context.Context, name, desc string) (cloudprovider.ICloudSnapshot, error) {
-	return nil, cloudprovider.ErrNotImplemented
+	snapshot, err := disk.storage.zone.region.CreateSnapshot(disk.ID, name, desc)
+	if err != nil {
+		return nil, err
+	}
+	return snapshot, cloudprovider.WaitStatus(snapshot, models.SNAPSHOT_READY, time.Second*5, time.Minute*5)
 }
 
 func (disk *SDisk) GetISnapshot(snapshotId string) (cloudprovider.ICloudSnapshot, error) {
@@ -264,7 +298,7 @@ func (disk *SDisk) GetISnapshots() ([]cloudprovider.ICloudSnapshot, error) {
 }
 
 func (disk *SDisk) Reset(ctx context.Context, snapshotId string) (string, error) {
-	return "", disk.storage.zone.region.ResetDisk(disk.ID, snapshotId)
+	return disk.ID, disk.storage.zone.region.ResetDisk(disk.ID, snapshotId)
 }
 
 func (disk *SDisk) GetBillingType() string {
@@ -280,9 +314,5 @@ func (disk *SDisk) GetAccessPath() string {
 }
 
 func (disk *SDisk) Rebuild(ctx context.Context) error {
-	return disk.storage.zone.region.RebuildDisk(disk.ID)
-}
-
-func (region *SRegion) RebuildDisk(diskId string) error {
-	return cloudprovider.ErrNotImplemented
+	return cloudprovider.ErrNotSupported
 }

pkg/util/openstack/flavor.go

@@ -0,0 +1,244 @@
+package openstack
+
+import (
+	"fmt"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/onecloud/pkg/cloudprovider"
+	"yunion.io/x/onecloud/pkg/compute/models"
+)
+
+type SFlavor struct {
+	region       *SRegion
+	ID           string
+	Disk         int
+	Ephemeral    int
+	ExtraSpecs   ExtraSpecs
+	OriginalName string
+	Name         string
+	RAM          int
+	Swap         string
+	Vcpus        int8
+}
+
+func (region *SRegion) GetFlavors() ([]SFlavor, error) {
+	_, resp, err := region.List("compute", "/flavors/detail", "", nil)
+	if err != nil {
+		return nil, err
+	}
+	flavors := []SFlavor{}
+	return flavors, resp.Unmarshal(&flavors, "flavors")
+}
+
+func (region *SRegion) GetFlavor(flavorId string) (*SFlavor, error) {
+	_, resp, err := region.Get("compute", "/flavors/"+flavorId, "", nil)
+	if err != nil {
+		return nil, err
+	}
+	flavor := &SFlavor{region: region}
+	return flavor, resp.Unmarshal(flavor, "flavor")
+}
+
+func (region *SRegion) syncFlavor(name string, cpu, memoryMb, diskGB int) (string, error) {
+	flavors, err := region.GetFlavors()
+	if err != nil {
+		return "", err
+	}
+	if len(name) > 0 {
+		for _, flavor := range flavors {
+			if flavor.GetName() == name {
+				return flavor.ID, nil
+			}
+		}
+	}
+
+	if cpu == 0 && memoryMb == 0 {
+		return "", fmt.Errorf("failed to find instance type %s", name)
+	}
+
+	for _, flavor := range flavors {
+		if flavor.GetCpuCoreCount() == cpu && flavor.GetMemorySizeMB() == memoryMb {
+			return flavor.ID, nil
+		}
+	}
+
+	if len(name) == 0 {
+		suffix := ""
+		for i := 0; i < 10; i++ {
+			switch cpu {
+			case 1:
+				suffix = "tiny"
+			case 2, 3:
+				suffix = "small"
+			case 4, 6:
+				suffix = "medium"
+			case 8:
+				suffix = "large"
+			default:
+				suffix = "xlarge"
+			}
+		}
+		for i := 0; i < 10; i++ {
+			if _, err := region.GetFlavor(fmt.Sprintf("m%d.%s", i, suffix)); err != nil {
+				if err == cloudprovider.ErrNotFound {
+					name = fmt.Sprintf("m%d.%s", i, suffix)
+					break
+				}
+			}
+		}
+		if len(name) == 0 {
+			return "", fmt.Errorf("failed to find uniq flavor name for cpu %d memory %d", cpu, memoryMb)
+		}
+	}
+
+	flavor, err := region.CreateFlavor(name, cpu, memoryMb, diskGB)
+	if err != nil {
+		return "", err
+	}
+	return flavor.ID, nil
+}
+
+func (region *SRegion) CreateFlavor(name string, cpu int, memoryMb int, diskGB int) (*SFlavor, error) {
+	params := map[string]map[string]interface{}{
+		"flavor": {
+			"name":  name,
+			"ram":   memoryMb,
+			"vcpus": cpu,
+			"disk":  diskGB,
+		},
+	}
+	_, resp, err := region.Post("compute", "/flavors", "", jsonutils.Marshal(params))
+	if err != nil {
+		return nil, err
+	}
+	flavor := &SFlavor{}
+	return flavor, resp.Unmarshal(flavor, "flavor")
+}
+
+func (region *SRegion) DeleteFlavor(flavorId string) error {
+	_, err := region.Delete("compute", "/flavors/"+flavorId, "")
+	return err
+}
+
+func (flavor *SFlavor) GetMetadata() *jsonutils.JSONDict {
+	return nil
+}
+
+func (flavor *SFlavor) IsEmulated() bool {
+	return false
+}
+
+func (flavor *SFlavor) Refresh() error {
+	new, err := flavor.region.GetFlavor(flavor.ID)
+	if err != nil {
+		return err
+	}
+	return jsonutils.Update(flavor, new)
+}
+
+func (flavor *SFlavor) GetName() string {
+	if len(flavor.OriginalName) > 0 {
+		return flavor.OriginalName
+	}
+	return flavor.Name
+}
+
+func (flavor *SFlavor) GetStatus() string {
+	return ""
+}
+
+func (flavor *SFlavor) GetId() string {
+	return flavor.ID
+}
+
+func (flavor *SFlavor) GetGlobalId() string {
+	return flavor.ID
+}
+
+func (flavor *SFlavor) GetInstanceTypeFamily() string {
+	return flavor.GetName()
+}
+
+func (flavor *SFlavor) GetInstanceTypeCategory() string {
+	return flavor.GetName()
+}
+
+func (flavor *SFlavor) GetPrepaidStatus() string {
+	return models.SkuStatusSoldout
+}
+
+func (flavor *SFlavor) GetPostpaidStatus() string {
+	return models.SkuStatusAvailable
+}
+
+func (flavor *SFlavor) GetCpuCoreCount() int {
+	return int(flavor.Vcpus)
+}
+
+func (flavor *SFlavor) GetMemorySizeMB() int {
+	return flavor.RAM
+}
+
+func (flavor *SFlavor) GetOsName() string {
+	return "Any"
+}
+
+func (flavor *SFlavor) GetSysDiskResizable() bool {
+	return true
+}
+
+func (flavor *SFlavor) GetSysDiskType() string {
+	return "iscsi"
+}
+
+func (flavor *SFlavor) GetSysDiskMinSizeGB() int {
+	return 0
+}
+
+func (flavor *SFlavor) GetSysDiskMaxSizeGB() int {
+	return flavor.Disk
+}
+
+func (flavor *SFlavor) GetAttachedDiskType() string {
+	return "iscsi"
+}
+
+func (flavor *SFlavor) GetAttachedDiskSizeGB() int {
+	return 0
+}
+
+func (flavor *SFlavor) GetAttachedDiskCount() int {
+	return 6
+}
+
+func (flavor *SFlavor) GetDataDiskTypes() string {
+	return "iscsi"
+}
+
+func (flavor *SFlavor) GetDataDiskMaxCount() int {
+	return 6
+}
+
+func (flavor *SFlavor) GetNicType() string {
+	return "vpc"
+}
+
+func (flavor *SFlavor) GetNicMaxCount() int {
+	return 1
+}
+
+func (flavor *SFlavor) GetGpuAttachable() bool {
+	return false
+}
+
+func (flavor *SFlavor) GetGpuSpec() string {
+	return ""
+}
+
+func (flavor *SFlavor) GetGpuCount() int {
+	return 0
+}
+
+func (flavor *SFlavor) GetGpuMaxCount() int {
+	return 0
+}

pkg/util/openstack/host.go

@@ -1,9 +1,16 @@
 package openstack
 
 import (
+	"fmt"
+
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/onecloud/pkg/compute/models"
+	"yunion.io/x/onecloud/pkg/util/version"
+)
+
+const (
+	VOLUME_TYPES_API_VERSION = "2.67"
 )
 
 type CpuInfo struct {
@@ -116,7 +123,128 @@ func (host *SHost) GetIVMById(gid string) (cloudprovider.ICloudVM, error) {
 }
 
 func (host *SHost) CreateVM(desc *cloudprovider.SManagedVMCreateConfig) (cloudprovider.ICloudVM, error) {
-	return nil, cloudprovider.ErrNotImplemented
+	network, err := host.zone.region.GetNetwork(desc.ExternalNetworkId)
+	if err != nil {
+		return nil, err
+	}
+
+	secgroups := []map[string]string{}
+
+	for _, secgroupId := range desc.ExternalSecgroupIds {
+		secgroups = append(secgroups, map[string]string{"name": secgroupId})
+	}
+
+	image, err := host.zone.region.GetImage(desc.ExternalImageId)
+	if err != nil {
+		return nil, err
+	}
+
+	storage, err := host.zone.getStorageByCategory(desc.SysDisk.StorageType)
+	if err != nil {
+		return nil, err
+	}
+
+	sysDiskSizeGB := image.Size / 1024 / 1024
+	if desc.SysDisk.SizeGB < sysDiskSizeGB {
+		desc.SysDisk.SizeGB = sysDiskSizeGB
+	}
+
+	_, maxVersion, _ := host.zone.region.GetVersion("compute")
+
+	BlockDeviceMappingV2 := []map[string]interface{}{
+		{
+			"boot_index":            0,
+			"uuid":                  desc.ExternalImageId,
+			"source_type":           "image",
+			"destination_type":      "volume",
+			"volume_size":           desc.SysDisk.SizeGB,
+			"delete_on_termination": true,
+		},
+	}
+
+	if version.GE(maxVersion, VOLUME_TYPES_API_VERSION) {
+		BlockDeviceMappingV2[0]["volume_type"] = storage.Name
+	}
+
+	var _disk *SDisk
+	for _, disk := range desc.DataDisks {
+		storage, err = host.zone.getStorageByCategory(disk.StorageType)
+		if err != nil {
+			break
+		}
+		_disk, err = host.zone.region.CreateDisk(host.zone.ZoneName, storage.Name, "", disk.SizeGB, disk.Name)
+		if err != nil {
+			break
+		}
+
+		mapping := map[string]interface{}{
+			"source_type":           "volume",
+			"destination_type":      "volume",
+			"delete_on_termination": true,
+			"uuid":                  _disk.ID,
+		}
+
+		BlockDeviceMappingV2 = append(BlockDeviceMappingV2, mapping)
+	}
+	if err != nil {
+		for _, blockMap := range BlockDeviceMappingV2 {
+			if blockMap["source_type"] == "volume" {
+				if uuid, ok := blockMap["uuid"].(string); ok {
+					host.zone.region.DeleteDisk(uuid)
+				}
+			}
+		}
+		return nil, err
+	}
+
+	params := map[string]map[string]interface{}{
+		"server": {
+			"name":      desc.Name,
+			"adminPass": desc.Password,
+			//"description":       desc.Description,
+			"accessIPv4":        desc.IpAddr,
+			"availability_zone": fmt.Sprintf("%s:%s", host.zone.ZoneName, host.GetName()),
+			"networks": []map[string]string{
+				{
+					"uuid":     network.NetworkID,
+					"fixed_ip": desc.IpAddr,
+				},
+			},
+			"security_groups":         secgroups,
+			"user_data":               desc.UserData,
+			"imageRef":                desc.ExternalImageId,
+			"block_device_mapping_v2": BlockDeviceMappingV2,
+		},
+	}
+
+	flavorId, err := host.zone.region.syncFlavor(desc.InstanceType, desc.Cpu, desc.MemoryMB, desc.SysDisk.SizeGB)
+	if err != nil {
+		return nil, err
+	}
+	params["server"]["flavorRef"] = flavorId
+
+	if len(desc.PublicKey) > 0 {
+		keypairName, err := host.zone.region.syncKeypair(desc.Name, desc.PublicKey)
+		if err != nil {
+			return nil, err
+		}
+		params["server"]["key_name"] = keypairName
+	}
+
+	_, resp, err := host.zone.region.Post("compute", "/servers", "", jsonutils.Marshal(params))
+	if err != nil {
+		return nil, err
+	}
+	serverId, err := resp.GetString("server", "id")
+	if err != nil {
+		return nil, err
+	}
+	instance, err := host.zone.region.GetInstance(serverId)
+	if err != nil {
+		return nil, err
+	}
+	instance.host = host
+	return instance, nil
 }
 
 func (host *SHost) GetEnabled() bool {

pkg/util/openstack/image.go

@@ -0,0 +1,230 @@
+package openstack
+
+import (
+	"context"
+	"net/url"
+	"strings"
+	"time"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/onecloud/pkg/cloudprovider"
+	"yunion.io/x/onecloud/pkg/compute/models"
+	"yunion.io/x/pkg/utils"
+)
+
+const (
+	QUEUED         = "queued"         //	The Image service reserved an image ID for the image in the catalog but did not yet upload any image data.
+	SAVING         = "saving"         //	The Image service is in the process of saving the raw data for the image into the backing store.
+	ACTIVE         = "active"         //	The image is active and ready for consumption in the Image service.
+	KILLED         = "killed"         // An image data upload error occurred.
+	DELETED        = "deleted"        //	The Image service retains information about the image but the image is no longer available for use.
+	PENDING_DELETE = "pending_delete" // Similar to the deleted status. An image in this state is not recoverable.
+	DEACTIVATED    = "deactivated"    //	The image data is not available for use.
+	UPLOADING      = "uploading"      // Data has been staged as part of the interoperable image import process. It is not yet available for use. (Since Image API 2.6)
+	IMPORTING      = "importing"      //	The image data is being processed as part of the interoperable image import process, but is not yet available for use. (Since Image API 2.6)
+)
+
+type SImage struct {
+	storageCache *SStoragecache
+
+	Status          string
+	Name            string
+	Tags            []string
+	ContainerFormat string
+	CreatedAt       time.Time
+	DiskFormat      string
+	UpdatedAt       time.Time
+	Visibility      string
+	Self            string
+	MinDisk         int
+	Protected       bool
+	ID              string
+	File            string
+	Checksum        string
+	OsHashAlgo      string
+	OsHashValue     string
+	OsHidden        bool
+	Owner           string
+	Size            int
+	MinRAM          int
+	Schema          string
+	VirtualSize     int
+	visibility      string
+}
+
+func (region *SRegion) GetImages(name string, status string, imageIds []string) ([]SImage, error) {
+	params := url.Values{}
+	if utils.IsInStringArray(status, []string{QUEUED, SAVING, ACTIVE, KILLED, DELETED, PENDING_DELETE, DEACTIVATED, UPLOADING, IMPORTING}) {
+		params.Add("status", status)
+	}
+	if len(name) > 0 {
+		params.Add("name", name)
+	}
+	if len(imageIds) > 0 {
+		params.Add("id", "in:"+strings.Join(imageIds, ","))
+	}
+	_, resp, err := region.List("image", "/v2/images?"+params.Encode(), "", nil)
+	if err != nil {
+		return nil, err
+	}
+	images := []SImage{}
+	return images, resp.Unmarshal(&images, "images")
+}
+
+func (image *SImage) GetMetadata() *jsonutils.JSONDict {
+	return nil
+}
+
+func (image *SImage) GetId() string {
+	return image.ID
+}
+
+func (image *SImage) GetName() string {
+	return image.Name
+}
+
+func (image *SImage) IsEmulated() bool {
+	return false
+}
+
+func (image *SImage) GetGlobalId() string {
+	return image.ID
+}
+
+func (image *SImage) Delete(ctx context.Context) error {
+	return image.storageCache.region.DeleteImage(image.ID)
+}
+
+func (image *SImage) GetStatus() string {
+	switch image.Status {
+	case QUEUED, SAVING, UPLOADING, IMPORTING:
+		return models.CACHED_IMAGE_STATUS_CACHING
+	case ACTIVE:
+		return models.CACHED_IMAGE_STATUS_READY
+	case DELETED, DEACTIVATED, PENDING_DELETE, KILLED:
+		return models.CACHED_IMAGE_STATUS_CACHE_FAILED
+	default:
+		return models.CACHED_IMAGE_STATUS_CACHE_FAILED
+	}
+}
+
+func (image *SImage) GetImageStatus() string {
+	switch image.Status {
+	case QUEUED, SAVING, UPLOADING, IMPORTING:
+		return cloudprovider.IMAGE_STATUS_SAVING
+	case ACTIVE:
+		return cloudprovider.IMAGE_STATUS_ACTIVE
+	case DELETED, DEACTIVATED, PENDING_DELETE:
+		return cloudprovider.IMAGE_STATUS_DELETED
+	case KILLED:
+		return cloudprovider.IMAGE_STATUS_KILLED
+	default:
+		return cloudprovider.IMAGE_STATUS_DELETED
+	}
+}
+
+func (image *SImage) Refresh() error {
+	new, err := image.storageCache.region.GetImage(image.ID)
+	if err != nil {
+		return err
+	}
+	return jsonutils.Update(image, new)
+}
+
+func (image *SImage) GetImageType() string {
+	switch image.Visibility {
+	case "public":
+		return cloudprovider.CachedImageTypeSystem
+	default:
+		return cloudprovider.CachedImageTypeCustomized
+	}
+}
+
+func (image *SImage) GetSize() int64 {
+	return int64(image.Size)
+}
+
+func (image *SImage) GetOsType() string {
+	return "Linux"
+}
+
+func (image *SImage) GetOsDist() string {
+	return "Linux"
+}
+
+func (image *SImage) GetOsVersion() string {
+	return ""
+}
+
+func (image *SImage) GetOsArch() string {
+	return "x86_64"
+}
+
+func (image *SImage) GetMinOsDiskSizeGb() int {
+	return 50
+}
+
+func (image *SImage) GetImageFormat() string {
+	return image.DiskFormat
+}
+
+func (image *SImage) GetCreateTime() time.Time {
+	return image.CreatedAt
+}
+
+func (region *SRegion) GetImage(imageId string) (*SImage, error) {
+	images, err := region.GetImages("", "", []string{imageId})
+	if err != nil {
+		return nil, err
+	}
+	if len(images) == 0 {
+		return nil, cloudprovider.ErrNotFound
+	}
+	if len(images) > 1 {
+		return nil, cloudprovider.ErrDuplicateId
+	}
+	return &images[0], nil
+}
+
+func (image *SImage) GetIStoragecache() cloudprovider.ICloudStoragecache {
+	return image.storageCache
+}
+
+func (region *SRegion) DeleteImage(imageId string) error {
+	_, err := region.Delete("image", "/v2/images/"+imageId, "")
+	return err
+}
+
+func (region *SRegion) GetImageStatus(imageId string) (string, error) {
+	image, err := region.GetImage(imageId)
+	if err != nil {
+		return "", err
+	}
+	return image.Status, nil
+}
+
+func (region *SRegion) GetImageByName(name string) (*SImage, error) {
+	images, err := region.GetImages(name, "", []string{})
+	if err != nil {
+		return nil, err
+	}
+	if len(images) == 0 {
+		return nil, cloudprovider.ErrNotFound
+	}
+	return &images[0], nil
+}
+
+func (region *SRegion) CreateImage(imageName string) (*SImage, error) {
+	params := map[string]string{
+		"container_format": "bare",
+		"disk_format":      "vmdk",
+		"name":             imageName,
+	}
+
+	_, resp, err := region.Post("image", "/v2/images", "", jsonutils.Marshal(params))
+	if err != nil {
+		return nil, err
+	}
+	image := &SImage{}
+	return image, resp.Unmarshal(image)
+}

pkg/util/openstack/instance.go

@@ -10,6 +10,7 @@ import (
 	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/onecloud/pkg/compute/models"
 	"yunion.io/x/onecloud/pkg/util/billing"
+	"yunion.io/x/pkg/utils"
 )
 
 const (
@@ -52,17 +53,6 @@ type ExtraSpecs struct {
 	MemPageSize int    `json:"hw:mem_page_size,omitempty"`
 }
 
-type SFlavor struct {
-	ID           string
-	Disk         int
-	Ephemeral    int
-	ExtraSpecs   ExtraSpecs
-	OriginalName string
-	RAM          int
-	Swap         string
-	Vcpus        int8
-}
-
 type Resource struct {
 	ID    string
 	Links []Link
@@ -137,7 +127,7 @@ func (region *SRegion) GetSecurityGroupsByInstance(instanceId string) ([]Securit
 
 func (region *SRegion) GetInstances(zoneName string, hostName string) ([]SInstance, error) {
 	_, maxVersion, _ := region.GetVersion("compute")
-	_, resp, err := region.Get("compute", "/servers/detail", maxVersion, nil)
+	_, resp, err := region.List("compute", "/servers/detail", maxVersion, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -212,19 +202,18 @@ func (instance *SInstance) IsEmulated() bool {
 
 func (instance *SInstance) fetchFlavor() error {
 	if len(instance.Flavor.ID) > 0 && instance.Flavor.Vcpus == 0 {
-		_, resp, err := instance.host.zone.region.Get("compute", "/flavors/"+instance.Flavor.ID, "", nil)
+		flavor, err := instance.host.zone.region.GetFlavor(instance.Flavor.ID)
 		if err != nil {
-			log.Errorf("fetch instance %s flavor error: %v", instance.Name, err)
 			return err
 		}
-		return resp.Unmarshal(&instance.Flavor, "flavor")
+		instance.Flavor = *flavor
 	}
 	return nil
 }
 
 func (instance *SInstance) GetInstanceType() string {
 	instance.fetchFlavor()
-	return instance.Flavor.OriginalName
+	return instance.Flavor.GetName()
 }
 
 func (instance *SInstance) GetIDisks() ([]cloudprovider.ICloudDisk, error) {
@@ -329,7 +318,16 @@ func (instance *SInstance) Refresh() error {
 }
 
 func (instance *SInstance) UpdateVM(ctx context.Context, name string) error {
-	return cloudprovider.ErrNotImplemented
+	if instance.Name != name {
+		params := map[string]map[string]string{
+			"server": {
+				"name": name,
+			},
+		}
+		_, _, err := instance.host.zone.region.Update("compute", "/servers/"+instance.ID, "", jsonutils.Marshal(params))
+		return err
+	}
+	return nil
 }
 
 func (instance *SInstance) GetHypervisor() string {
@@ -337,11 +335,17 @@ func (instance *SInstance) GetHypervisor() string {
 }
 
 func (instance *SInstance) StartVM(ctx context.Context) error {
-	return cloudprovider.ErrNotImplemented
+	if err := instance.host.zone.region.StartVM(instance.ID); err != nil {
+		return err
+	}
+	return cloudprovider.WaitStatus(instance, models.VM_RUNNING, 10*time.Second, 8*time.Minute)
 }
 
 func (instance *SInstance) StopVM(ctx context.Context, isForce bool) error {
-	return cloudprovider.ErrNotImplemented
+	if err := instance.host.zone.region.StopVM(instance.ID, isForce); err != nil {
+		return err
+	}
+	return cloudprovider.WaitStatus(instance, models.VM_RUNNING, 10*time.Second, 8*time.Minute)
 }
 
 func (region *SRegion) GetInstanceVNCUrl(instanceId string) (string, error) {
@@ -372,19 +376,45 @@ func (instance *SInstance) GetVNCInfo() (jsonutils.JSONObject, error) {
 }
 
 func (instance *SInstance) DeployVM(ctx context.Context, name string, password string, publicKey string, deleteKeypair bool, description string) error {
-	return cloudprovider.ErrNotImplemented
+	return instance.host.zone.region.DeployVM(instance.ID, name, password, publicKey, deleteKeypair, description)
 }
 
 func (instance *SInstance) RebuildRoot(ctx context.Context, imageId string, passwd string, publicKey string, sysSizeGB int) (string, error) {
-	return "", cloudprovider.ErrNotImplemented
+	return "", instance.host.zone.region.ReplaceSystemDisk(instance.ID, imageId, passwd, publicKey, sysSizeGB)
+
 }
 
 func (instance *SInstance) ChangeConfig(ctx context.Context, ncpu int, vmem int) error {
-	return cloudprovider.ErrNotImplemented
+	if instance.GetVcpuCount() != int8(ncpu) || instance.GetVmemSizeMB() != vmem {
+		flavorId, err := instance.host.zone.region.syncFlavor("", ncpu, vmem, 40)
+		if err != nil {
+			return err
+		}
+		return instance.host.zone.region.ChangeConfig(instance, flavorId)
+	}
+	return nil
 }
 
 func (instance *SInstance) ChangeConfig2(ctx context.Context, instanceType string) error {
-	return cloudprovider.ErrNotImplemented
+	if instance.GetInstanceType() != instanceType {
+		flavorId, err := instance.host.zone.region.syncFlavor(instanceType, 0, 0, 0)
+		if err != nil {
+			return err
+		}
+		return instance.host.zone.region.ChangeConfig(instance, flavorId)
+	}
+	return nil
+}
+
+func (region *SRegion) ChangeConfig(instance *SInstance, flavorId string) error {
+	params := map[string]map[string]string{
+		"resize": {
+			"flavorRef": flavorId,
+		},
+	}
+	_, maxVersion, _ := region.GetVersion("compute")
+	_, _, err := region.Post("compute", fmt.Sprintf("/servers/%s/action", instance.ID), maxVersion, jsonutils.Marshal(params))
+	return err
 }
 
 func (instance *SInstance) AttachDisk(ctx context.Context, diskId string) error {
@@ -401,40 +431,86 @@ func (region *SRegion) CreateInstance(name string, imageId string, instanceType
 	return "", cloudprovider.ErrNotImplemented
 }
 
-func (region *SRegion) doStartVM(instanceId string) error {
-	return cloudprovider.ErrNotImplemented
+func (region *SRegion) instanceOperation(instanceId, operate string) error {
+	params := jsonutils.Marshal(map[string]string{operate: ""})
+	_, maxVersion, _ := region.GetVersion("compute")
+	_, _, err := region.Post("compute", fmt.Sprintf("/servers/%s/action", instanceId), maxVersion, params)
+	return err
 }
 
 func (region *SRegion) doStopVM(instanceId string, isForce bool) error {
-	return cloudprovider.ErrNotImplemented
+	return region.instanceOperation(instanceId, "os-stop")
 }
 
 func (region *SRegion) doDeleteVM(instanceId string) error {
-	return cloudprovider.ErrNotImplemented
+	return region.instanceOperation(instanceId, "forceDelete")
 }
 
 func (region *SRegion) StartVM(instanceId string) error {
-	return cloudprovider.ErrNotImplemented
+	return region.instanceOperation(instanceId, "os-start")
 }
 
 func (region *SRegion) StopVM(instanceId string, isForce bool) error {
-	return cloudprovider.ErrNotImplemented
+	return region.doStopVM(instanceId, isForce)
 }
 
 func (region *SRegion) DeleteVM(instanceId string) error {
-	return cloudprovider.ErrNotImplemented
+	instance, err := region.GetInstance(instanceId)
+	if err != nil {
+		if err == cloudprovider.ErrNotFound {
+			return nil
+		}
+		log.Errorf("failed to get instance %s %v", instanceId, err)
+		return err
+	}
+	status := instance.GetStatus()
+	log.Debugf("Instance status on delete is %s", status)
+	if status != models.VM_READY {
+		log.Warningf("DeleteVM: vm status is %s expect %s", status, models.VM_READY)
+	}
+	return region.doDeleteVM(instanceId)
 }
 
 func (region *SRegion) DeployVM(instanceId string, name string, password string, keypairName string, deleteKeypair bool, description string) error {
-	return cloudprovider.ErrNotImplemented
+	if len(password) > 0 {
+		params := map[string]map[string]string{
+			"changePassword": {
+				"adminPass": password,
+			},
+		}
+		_, maxVersion, _ := region.GetVersion("compute")
+		_, _, err := region.Post("compute", fmt.Sprintf("/servers/%s/action", instanceId), maxVersion, jsonutils.Marshal(params))
+		return err
+	}
+	return nil
 }
 
 func (instance *SInstance) DeleteVM(ctx context.Context) error {
-	return cloudprovider.ErrNotImplemented
+	return instance.host.zone.region.DeleteVM(instance.ID)
 }
 
-func (region *SRegion) ReplaceSystemDisk(instanceId string, imageId string, passwd string, keypairName string, sysDiskSizeGB int) error {
-	return cloudprovider.ErrNotImplemented
+func (region *SRegion) ReplaceSystemDisk(instanceId string, imageId string, passwd string, publicKey string, sysDiskSizeGB int) error {
+	params := map[string]map[string]string{
+		"rebuild": {
+			"imageRef": imageId,
+		},
+	}
+
+	if len(publicKey) > 0 {
+		keypairName, err := region.syncKeypair(instanceId, publicKey)
+		if err != nil {
+			return err
+		}
+		params["rebuild"]["key_name"] = keypairName
+	}
+
+	if len(passwd) > 0 {
+		params["rebuild"]["adminPass"] = passwd
+	}
+
+	_, maxVersion, _ := region.GetVersion("compute")
+	_, _, err := region.Post("compute", fmt.Sprintf("/servers/%s/action", instanceId), maxVersion, jsonutils.Marshal(params))
+	return err
 }
 
 func (region *SRegion) ChangeVMConfig(zoneId string, instanceId string, ncpu int, vmem int, disks []*SDisk) error {
@@ -446,27 +522,78 @@ func (region *SRegion) ChangeVMConfig2(zoneId string, instanceId string, instanc
 }
 
 func (region *SRegion) DetachDisk(instanceId string, diskId string) error {
-	return cloudprovider.ErrNotImplemented
+	_, err := region.Delete("compute", fmt.Sprintf("/servers/%s/os-volume_attachments/%s", instanceId, diskId), "")
+	return err
 }
 
 func (region *SRegion) AttachDisk(instanceId string, diskId string) error {
-	return cloudprovider.ErrNotImplemented
+	params := map[string]map[string]string{
+		"volumeAttachment": {
+			"volumeId": diskId,
+		},
+	}
+	_, _, err := region.Post("compute", fmt.Sprintf("/servers/%s/os-volume_attachments", instanceId), "", jsonutils.Marshal(params))
+	return err
 }
 
 func (instance *SInstance) AssignSecurityGroup(secgroupId string) error {
-	return cloudprovider.ErrNotImplemented
+	secgroup, err := instance.host.zone.region.GetSecurityGroup(secgroupId)
+	if err != nil {
+		return err
+	}
+	params := map[string]map[string]string{
+		"addSecurityGroup": {
+			"name": secgroup.Name,
+		},
+	}
+	_, _, err = instance.host.zone.region.Post("compute", fmt.Sprintf("/servers/%s/action", instance.ID), "", jsonutils.Marshal(params))
+	return err
 }
 
-func (instance *SInstance) AssignSecurityGroups(secgroupIds []string) error {
-	return cloudprovider.ErrNotImplemented
+func (instance *SInstance) RevokeSecurityGroup(secgroupId string) error {
+	secgroup, err := instance.host.zone.region.GetSecurityGroup(secgroupId)
+	if err != nil {
+		return err
+	}
+	params := map[string]map[string]string{
+		"removeSecurityGroup": {
+			"name": secgroup.Name,
+		},
+	}
+	_, _, err = instance.host.zone.region.Post("compute", fmt.Sprintf("/servers/%s/action", instance.ID), "", jsonutils.Marshal(params))
+	return err
+}
+
+func (instance *SInstance) SetSecurityGroups(secgroupIds []string) error {
+	secgroups, err := instance.host.zone.region.GetSecurityGroupsByInstance(instance.ID)
+	if err != nil {
+		return err
+	}
+	originIds := []string{}
+	for _, secgroup := range secgroups {
+		if !utils.IsInStringArray(secgroup.ID, secgroupIds) {
+			if err := instance.RevokeSecurityGroup(secgroup.ID); err != nil {
+				return err
+			}
+		}
+		originIds = append(originIds, secgroup.ID)
+	}
+	for _, secgroupId := range secgroupIds {
+		if !utils.IsInStringArray(secgroupId, originIds) {
+			if err := instance.AssignSecurityGroup(secgroupId); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
 }
 
 func (instance *SInstance) GetIEIP() (cloudprovider.ICloudEIP, error) {
-	return nil, cloudprovider.ErrNotImplemented
+	return nil, cloudprovider.ErrNotSupported
 }
 
 func (instance *SInstance) GetBillingType() string {
-	return models.BILLING_TYPE_PREPAID
+	return models.BILLING_TYPE_POSTPAID
 }
 
 func (instance *SInstance) GetExpiredAt() time.Time {
@@ -482,9 +609,9 @@ func (instance *SInstance) CreateDisk(ctx context.Context, sizeMb int, uuid stri
 }
 
 func (instance *SInstance) Renew(bc billing.SBillingCycle) error {
-	return cloudprovider.ErrNotImplemented
+	return cloudprovider.ErrNotSupported
 }
 
 func (region *SRegion) RenewInstances(instanceId []string, bc billing.SBillingCycle) error {
-	return cloudprovider.ErrNotImplemented
+	return cloudprovider.ErrNotSupported
 }

pkg/util/openstack/keypaire.go

@@ -0,0 +1,92 @@
+package openstack
+
+import (
+	"fmt"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/onecloud/pkg/cloudprovider"
+	"yunion.io/x/onecloud/pkg/util/version"
+	"yunion.io/x/pkg/utils"
+)
+
+type SKeypair struct {
+	Fingerprint string
+	Name        string
+	Type        string
+	PublicKey   string
+}
+
+type SKeyPair struct {
+	Keypair SKeypair
+}
+
+func (region *SRegion) GetKeypairs() ([]SKeyPair, error) {
+	_, resp, err := region.List("compute", "/os-keypairs", "", nil)
+	if err != nil {
+		return nil, err
+	}
+	keypairs := []SKeyPair{}
+	return keypairs, resp.Unmarshal(&keypairs, "keypairs")
+}
+
+func (region *SRegion) CreateKeypair(name, publicKey, Type string) (*SKeyPair, error) {
+	if len(Type) > 0 && !utils.IsInStringArray(Type, []string{"ssh", "x509"}) {
+		return nil, fmt.Errorf("only support ssh or x509 type")
+	}
+	params := map[string]map[string]string{
+		"keypair": {
+			"name":       name,
+			"public_key": publicKey,
+		},
+	}
+	_, maxVersion, _ := region.GetVersion("compute")
+	if len(Type) > 0 && version.GE(maxVersion, "2.2") {
+		params["keypair"]["type"] = Type
+	}
+	_, resp, err := region.Post("compute", "/os-keypairs", maxVersion, jsonutils.Marshal(params))
+	if err != nil {
+		return nil, err
+	}
+	keypair := &SKeyPair{}
+	return keypair, resp.Unmarshal(keypair)
+}
+
+func (region *SRegion) DeleteKeypair(name string) error {
+	_, err := region.Delete("compute", "/os-keypairs/"+name, "")
+	return err
+}
+
+func (region *SRegion) GetKeypair(name string) (*SKeyPair, error) {
+	_, resp, err := region.Get("compute", "/os-keypairs/"+name, "", nil)
+	if err != nil {
+		return nil, err
+	}
+	keypair := &SKeyPair{}
+	return keypair, resp.Unmarshal(keypair)
+}
+
+func (region *SRegion) syncKeypair(namePrefix, publicKey string) (string, error) {
+	keypairs, err := region.GetKeypairs()
+	if err != nil {
+		return "", err
+	}
+
+	for _, keypair := range keypairs {
+		if keypair.Keypair.PublicKey == publicKey {
+			return keypair.Keypair.Name, nil
+		}
+	}
+	for i := 0; i < 10; i++ {
+		name := fmt.Sprintf("%s-%d", namePrefix, i)
+		if _, err := region.GetKeypair(name); err != nil {
+			if err == cloudprovider.ErrNotFound {
+				keypair, err := region.CreateKeypair(name, publicKey, "ssh")
+				if err != nil {
+					return "", err
+				}
+				return keypair.Keypair.Name, nil
+			}
+		}
+	}
+	return "", fmt.Errorf("failed to find uniq name for keypair")
+}

pkg/util/openstack/network.go

@@ -73,8 +73,9 @@ func (network *SNetwork) Delete() error {
 	return network.wire.zone.region.DeleteNetwork(network.ID)
 }
 
-func (network *SRegion) DeleteNetwork(networkId string) error {
-	return cloudprovider.ErrNotImplemented
+func (region *SRegion) DeleteNetwork(networkId string) error {
+	_, err := region.Delete("network", "/v2.0/subnets/"+networkId, "")
+	return err
 }
 
 func (network *SNetwork) GetIWire() cloudprovider.ICloudWire {
@@ -126,7 +127,7 @@ func (region *SRegion) GetNetwork(networkId string) (*SNetwork, error) {
 }
 
 func (region *SRegion) GetNetworks(vpcId string) ([]SNetwork, error) {
-	_, resp, err := region.Get("network", "/v2.0/subnets", "", nil)
+	_, resp, err := region.List("network", "/v2.0/subnets", "", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -152,6 +153,19 @@ func (network *SNetwork) Refresh() error {
 	return jsonutils.Update(network, new)
 }
 
-func (network *SRegion) CreateNetwork(zoneId string, vpcId string, name string, cidr string, desc string) (string, error) {
-	return "", cloudprovider.ErrNotImplemented
+func (region *SRegion) CreateNetwork(vpcId string, name string, cidr string, desc string) (string, error) {
+	params := map[string]map[string]interface{}{
+		"subnet": {
+			"name":        name,
+			"network_id":  vpcId,
+			"cidr":        cidr,
+			"description": desc,
+			"ip_version":  4,
+		},
+	}
+	_, resp, err := region.Post("network", "/v2.0/subnets", "", jsonutils.Marshal(params))
+	if err != nil {
+		return "", err
+	}
+	return resp.GetString("subnet", "id")
 }

pkg/util/openstack/openstack.go

@@ -3,11 +3,12 @@ package openstack
 import (
 	"context"
 	"fmt"
+	"io"
 	"net/http"
 	"strings"
 
 	"yunion.io/x/jsonutils"
-
+	"yunion.io/x/log"
 	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/onecloud/pkg/compute/models"
 	"yunion.io/x/onecloud/pkg/mcclient"
@@ -68,7 +69,37 @@ func (cli *SOpenStackClient) Request(region, service, method string, url string,
 	}
 	ctx := context.Background()
 	session := cli.client.NewSession(ctx, region, "", "internal", cli.tokenCredential, "")
-	return session.JSONRequest(service, "", httputils.THttpMethod(method), url, header, body)
+	header, resp, err := session.JSONRequest(service, "", httputils.THttpMethod(method), url, header, body)
+	if err != nil && body != nil {
+		uri, _ := session.GetServiceURL(service, "")
+		log.Errorf("microversion %s url: %s, params: %s", microversion, uri+url, body.PrettyString())
+	}
+	return header, resp, err
+}
+
+func (cli *SOpenStackClient) RawRequest(region, service, method string, url string, microversion string, body jsonutils.JSONObject) (*http.Response, error) {
+	header := http.Header{}
+	if len(microversion) > 0 {
+		header.Set("X-Openstack-Nova-API-Version", microversion)
+	}
+	ctx := context.Background()
+	session := cli.client.NewSession(ctx, region, "", "internal", cli.tokenCredential, "")
+	data := strings.NewReader("")
+	if body != nil {
+		data = strings.NewReader(body.String())
+	}
+	return session.RawRequest(service, "", httputils.THttpMethod(method), url, header, data)
+}
+
+func (cli *SOpenStackClient) StreamRequest(region, service, method string, url string, microversion string, body io.Reader) (*http.Response, error) {
+	header := http.Header{}
+	if len(microversion) > 0 {
+		header.Set("X-Openstack-Nova-API-Version", microversion)
+	}
+	header.Set("Content-Type", "application/octet-stream")
+	ctx := context.Background()
+	session := cli.client.NewSession(ctx, region, "", "internal", cli.tokenCredential, "")
+	return session.RawRequest(service, "", httputils.THttpMethod(method), url, header, body)
 }
 
 func (cli *SOpenStackClient) getVersion(region string, service string) (string, string, error) {

pkg/util/openstack/port.go

@@ -60,7 +60,7 @@ func (region *SRegion) GetPorts(macAddress string) ([]SPort, error) {
 		params.Set("mac_address", macAddress)
 	}
 	url := fmt.Sprintf("%s?%s", base, params.Encode())
-	_, resp, err := region.Get("network", url, "", nil)
+	_, resp, err := region.List("network", url, "", nil)
 	if err != nil {
 		return nil, err
 	}

pkg/util/openstack/provider/provider.go

@@ -106,6 +106,10 @@ func (self *SOpenStackProvider) IsOnPremiseInfrastructure() bool {
 	return false
 }
 
+func (self *SOpenStackProvider) SyncSkuFromCloud() bool {
+	return true
+}
+
 func (self *SOpenStackProvider) GetId() string {
 	return openstack.CLOUD_PROVIDER_OPENSTACK
 }

pkg/util/openstack/quota.go

@@ -0,0 +1,61 @@
+package openstack
+
+import (
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/onecloud/pkg/util/version"
+)
+
+type SQuota struct {
+	FixedIps           int
+	Floatingips        int
+	Networks           int
+	Port               int
+	RbacPolicy         int
+	Router             int
+	SecurityGroups     int
+	SecurityGroupRules int
+}
+
+func (region *SRegion) GetQuota() (*SQuota, error) {
+	_, resp, err := region.Get("compute", "/os-quota-sets/"+region.client.tokenCredential.GetTenantId(), "", nil)
+	if err != nil {
+		return nil, err
+	}
+	quota := &SQuota{}
+	return quota, resp.Unmarshal(quota, "quota_set")
+}
+
+func (region *SRegion) SetQuota(quota *SQuota) error {
+	_, maxVersion, _ := region.GetVersion("compute")
+	params := map[string]map[string]interface{}{
+		"quota_set": {
+			"force": "True",
+		},
+	}
+
+	if version.GE(maxVersion, "2.35") {
+		if quota.Floatingips > 0 {
+			params["quota_set"]["floating_ips"] = quota.Floatingips
+		}
+
+		if quota.SecurityGroups > 0 {
+			params["quota_set"]["security_group"] = quota.SecurityGroups
+		}
+
+		if quota.SecurityGroupRules > 0 {
+			params["quota_set"]["security_group_rules"] = quota.SecurityGroupRules
+		}
+
+		if quota.FixedIps > 0 {
+			params["quota_set"]["fixed_ips"] = quota.FixedIps
+		}
+
+		if quota.Networks > 0 {
+			params["quota_set"]["networks"] = quota.Networks
+		}
+
+	}
+
+	_, _, err := region.Update("compute", "/os-quota-sets/"+region.client.tokenCredential.GetTenantId(), maxVersion, jsonutils.Marshal(params))
+	return err
+}

pkg/util/openstack/region.go

@@ -3,11 +3,13 @@ package openstack
 import (
 	"fmt"
 	"net/http"
+	"strings"
 
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
 	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/onecloud/pkg/compute/models"
+	"yunion.io/x/onecloud/pkg/util/httputils"
 )
 
 type SRegion struct {
@@ -63,7 +65,25 @@ func (region *SRegion) Refresh() error {
 }
 
 func (region *SRegion) CreateIVpc(name string, desc string, cidr string) (cloudprovider.ICloudVpc, error) {
-	return nil, cloudprovider.ErrNotImplemented
+	params := map[string]map[string]string{
+		"network": {
+			"name":        name,
+			"description": desc,
+		},
+	}
+	_, resp, err := region.Post("network", "/v2.0/networks", "", jsonutils.Marshal(params))
+	if err != nil {
+		return nil, err
+	}
+	err = region.fetchInfrastructure()
+	if err != nil {
+		return nil, err
+	}
+	vpcId, err := resp.GetString("network", "id")
+	if err != nil {
+		return nil, err
+	}
+	return region.GetIVpcById(vpcId)
 }
 
 func (region *SRegion) GetIHostById(id string) (cloudprovider.ICloudHost, error) {
@@ -173,7 +193,7 @@ func (region *SRegion) GetIZoneById(id string) (cloudprovider.ICloudZone, error)
 }
 
 func (region *SRegion) fetchZones() error {
-	_, resp, err := region.Get("compute", "/os-availability-zone", "", jsonutils.NewDict())
+	_, resp, err := region.List("compute", "/os-availability-zone", "", jsonutils.NewDict())
 	if err != nil {
 		return err
 	}
@@ -227,24 +247,107 @@ func (region *SRegion) fetchInfrastructure() error {
 }
 
 func (region *SRegion) Get(service, url string, microversion string, body jsonutils.JSONObject) (http.Header, jsonutils.JSONObject, error) {
-	return region.client.Request(region.Name, service, "GET", url, microversion, body)
+	if strings.HasSuffix(url, "/") {
+		return nil, nil, cloudprovider.ErrNotFound
+	}
+	header, resp, err := region.client.Request(region.Name, service, "GET", url, microversion, body)
+	if err != nil {
+		if jsonErr, ok := err.(*httputils.JSONClientError); ok {
+			if jsonErr.Code == 404 || strings.HasSuffix(jsonErr.Class, "NotFound") {
+				return nil, nil, cloudprovider.ErrNotFound
+			}
+		}
+		return nil, nil, err
+	}
+	return header, resp, nil
+}
+
+func (region *SRegion) List(service, url string, microversion string, body jsonutils.JSONObject) (http.Header, jsonutils.JSONObject, error) {
+	header, resp, err := region.client.Request(region.Name, service, "GET", url, microversion, body)
+	if err != nil {
+		if jsonErr, ok := err.(*httputils.JSONClientError); ok {
+			if jsonErr.Code == 404 || strings.HasSuffix(jsonErr.Class, "NotFound") {
+				return nil, nil, cloudprovider.ErrNotFound
+			}
+		}
+		return nil, nil, err
+	}
+	return header, resp, nil
 }
 
 func (region *SRegion) Post(service, url string, microversion string, body jsonutils.JSONObject) (http.Header, jsonutils.JSONObject, error) {
 	return region.client.Request(region.Name, service, "POST", url, microversion, body)
 }
 
-func (region *SRegion) CinderGet(url string, microversion string, body jsonutils.JSONObject) (http.Header, jsonutils.JSONObject, error) {
+func (region *SRegion) Update(service, url string, microversion string, body jsonutils.JSONObject) (http.Header, jsonutils.JSONObject, error) {
+	return region.client.Request(region.Name, service, "PUT", url, microversion, body)
+}
+
+func (region *SRegion) Delete(service, url string, microversion string) (*http.Response, error) {
+	return region.client.RawRequest(region.Name, service, "DELETE", url, microversion, nil)
+}
+
+func (region *SRegion) CinderList(url string, microversion string, body jsonutils.JSONObject) (http.Header, jsonutils.JSONObject, error) {
 	for _, service := range []string{"volumev3", "volumev2", "volume"} {
 		header, resp, err := region.Get(service, url, microversion, body)
 		if err == nil {
 			return header, resp, nil
 		}
+		log.Debugf("failed to list %s by service %s error: %v, try another", url, service, err)
+	}
+	return nil, nil, fmt.Errorf("failed to get %s by cinder service", url)
+}
+
+func (region *SRegion) CinderGet(url string, microversion string, body jsonutils.JSONObject) (http.Header, jsonutils.JSONObject, error) {
+	if strings.HasSuffix(url, "/") {
+		return nil, nil, cloudprovider.ErrNotFound
+	}
+	for _, service := range []string{"volumev3", "volumev2", "volume"} {
+		header, resp, err := region.Get(service, url, microversion, body)
+		if err == nil || err == cloudprovider.ErrNotFound {
+			return header, resp, err
+		}
 		log.Debugf("failed to get %s by service %s error: %v, try another", url, service, err)
 	}
 	return nil, nil, fmt.Errorf("failed to get %s by cinder service", url)
 }
 
+func (region *SRegion) CinderCreate(url string, microversion string, body jsonutils.JSONObject) (http.Header, jsonutils.JSONObject, error) {
+	for _, service := range []string{"volumev3", "volumev2", "volume"} {
+		header, resp, err := region.Post(service, url, microversion, body)
+		if err == nil {
+			return header, resp, nil
+		}
+		log.Debugf("failed to create %s by service %s error: %v, try another", url, service, err)
+	}
+	return nil, nil, fmt.Errorf("failed to create %s by cinder service", url)
+}
+
+func (region *SRegion) CinderDelete(url string, microversion string) (*http.Response, error) {
+	if strings.HasSuffix(url, "/") {
+		return nil, cloudprovider.ErrNotFound
+	}
+	for _, service := range []string{"volumev3", "volumev2", "volume"} {
+		resp, err := region.Delete(service, url, microversion)
+		if err == nil {
+			return resp, nil
+		}
+		log.Debugf("failed to delete %s by service %s error: %v, try another", url, service, err)
+	}
+	return nil, fmt.Errorf("failed to delete %s by cinder service", url)
+}
+
+func (region *SRegion) CinderAction(url string, microversion string, body jsonutils.JSONObject) (http.Header, jsonutils.JSONObject, error) {
+	for _, service := range []string{"volumev3", "volumev2", "volume"} {
+		header, resp, err := region.Post(service, url, microversion, body)
+		if err == nil {
+			return header, resp, nil
+		}
+		log.Debugf("failed to operate %s by service %s error: %v, try another", url, service, err)
+	}
+	return nil, nil, fmt.Errorf("failed to operate %s by cinder service", url)
+}
+
 func (region *SRegion) ProjectId() string {
 	return region.client.tokenCredential.GetProjectId()
 }
@@ -270,7 +373,7 @@ func (region *SRegion) GetIVpcs() ([]cloudprovider.ICloudVpc, error) {
 }
 
 func (region *SRegion) GetIEips() ([]cloudprovider.ICloudEIP, error) {
-	return nil, cloudprovider.ErrNotImplemented
+	return nil, cloudprovider.ErrNotSupported
 }
 
 func (region *SRegion) CreateEIP(name string, bwMbps int, chargeType string, bgpType string) (cloudprovider.ICloudEIP, error) {
@@ -316,3 +419,16 @@ func (region *SRegion) CreateILoadBalancer(loadbalancer *cloudprovider.SLoadbala
 func (region *SRegion) CreateILoadBalancerAcl(acl *cloudprovider.SLoadbalancerAccessControlList) (cloudprovider.ICloudLoadbalancerAcl, error) {
 	return nil, cloudprovider.ErrNotImplemented
 }
+
+func (region *SRegion) GetSkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+	flavors, err := region.GetFlavors()
+	if err != nil {
+		return nil, err
+	}
+	iskus := make([]cloudprovider.ICloudSku, len(flavors))
+	for i := 0; i < len(flavors); i++ {
+		flavors[i].region = region
+		iskus[i] = &flavors[i]
+	}
+	return iskus, nil
+}

pkg/util/openstack/securitygroup.go

@@ -1,11 +1,14 @@
 package openstack
 
 import (
+	"fmt"
 	"net"
+	"sort"
 	"strings"
 	"time"
 
 	"yunion.io/x/jsonutils"
+	"yunion.io/x/log"
 	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/pkg/util/secrules"
 	"yunion.io/x/pkg/utils"
@@ -45,6 +48,20 @@ type SSecurityGroup struct {
 	TenantID           string
 }
 
+type SecurigyGroupRuleSet []SSecurityGroupRule
+
+func (v SecurigyGroupRuleSet) Len() int {
+	return len(v)
+}
+
+func (v SecurigyGroupRuleSet) Swap(i, j int) {
+	v[i], v[j] = v[j], v[i]
+}
+
+func (v SecurigyGroupRuleSet) Less(i, j int) bool {
+	return strings.Compare(v[i].String(), v[j].String()) <= 0
+}
+
 func (region *SRegion) GetSecurityGroup(secgroupId string) (*SSecurityGroup, error) {
 	_, resp, err := region.Get("network", "/v2.0/security-groups/"+secgroupId, "", nil)
 	if err != nil {
@@ -55,7 +72,7 @@ func (region *SRegion) GetSecurityGroup(secgroupId string) (*SSecurityGroup, err
 }
 
 func (region *SRegion) GetSecurityGroups() ([]SSecurityGroup, error) {
-	_, resp, err := region.Get("network", "/v2.0/security-groups", "", nil)
+	_, resp, err := region.List("network", "/v2.0/security-groups", "", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -172,14 +189,165 @@ func (secgroup *SSecurityGroup) Refresh() error {
 	return jsonutils.Update(secgroup, new)
 }
 
-func (secgroup *SRegion) SyncSecurityGroup(secgroupId string, vpcId string, name string, desc string, rules []secrules.SecurityRule) (string, error) {
-	return "", cloudprovider.ErrNotImplemented
+func (region *SRegion) SyncSecurityGroup(secgroupId string, vpcId string, name string, desc string, rules []secrules.SecurityRule) (string, error) {
+	if len(secgroupId) > 0 {
+		_, err := region.GetSecurityGroup(secgroupId)
+		if err != nil {
+			if err != cloudprovider.ErrNotFound {
+				return "", err
+			}
+			secgroupId = ""
+		}
+	}
+	if len(secgroupId) == 0 {
+		secgroups, err := region.GetSecurityGroups()
+		if err != nil {
+			return "", err
+		}
+
+		secgroupNames := []string{}
+		for _, secgroup := range secgroups {
+			secgroupNames = append(secgroupNames, strings.ToLower(secgroup.Name))
+		}
+
+		uniqName := strings.ToLower(name)
+		if utils.IsInStringArray(uniqName, secgroupNames) {
+			for i := 0; i < 20; i++ {
+				uniqName = fmt.Sprintf("%s-%d", strings.ToLower(name), i)
+				if !utils.IsInStringArray(uniqName, secgroupNames) {
+					break
+				}
+			}
+		}
+		log.Errorf("create secgroup %s", uniqName)
+		secgroup, err := region.CreateSecurityGroup(uniqName, desc)
+		if err != nil {
+			return "", err
+		}
+		secgroupId = secgroup.ID
+	}
+	return region.syncSecgroupRules(secgroupId, rules)
+}
+
+func (region *SRegion) syncSecgroupRules(secgroupId string, rules []secrules.SecurityRule) (string, error) {
+	secgroup, err := region.GetSecurityGroup(secgroupId)
+	if err != nil {
+		return "", err
+	}
+
+	sort.Sort(secrules.SecurityRuleSet(rules))
+	sort.Sort(SecurigyGroupRuleSet(secgroup.SecurityGroupRules))
+
+	delSecgroupRuleIds := []string{}
+	addSecgroupRules := []secrules.SecurityRule{}
+	addSecgroupRuleStrings := []string{}
+
+	i, j := 0, 0
+	for i < len(rules) || j < len(secgroup.SecurityGroupRules) {
+		if i < len(rules) && j < len(secgroup.SecurityGroupRules) {
+			secruleStr := secgroup.SecurityGroupRules[j].String()
+			ruleStr := rules[i].String()
+			cmp := strings.Compare(secruleStr, ruleStr)
+			if cmp == 0 {
+				i++
+				j++
+			} else if cmp > 0 {
+				delSecgroupRuleIds = append(delSecgroupRuleIds, secgroup.SecurityGroupRules[j].ID)
+				j++
+			} else {
+				if !utils.IsInStringArray(ruleStr, addSecgroupRuleStrings) {
+					addSecgroupRules = append(addSecgroupRules, rules[i])
+					addSecgroupRuleStrings = append(addSecgroupRuleStrings, ruleStr)
+				}
+				i++
+			}
+		} else if i >= len(rules) {
+			delSecgroupRuleIds = append(delSecgroupRuleIds, secgroup.SecurityGroupRules[j].ID)
+			j++
+		} else if j >= len(secgroup.SecurityGroupRules) {
+			ruleStr := rules[i].String()
+			if !utils.IsInStringArray(ruleStr, addSecgroupRuleStrings) {
+				addSecgroupRules = append(addSecgroupRules, rules[i])
+				addSecgroupRuleStrings = append(addSecgroupRuleStrings, ruleStr)
+			}
+			i++
+		}
+	}
+
+	for _, ruleId := range delSecgroupRuleIds {
+		if err := region.delSecurityGroupRule(ruleId); err != nil {
+			log.Errorf("delSecurityGroupRule error %v", err)
+			return "", err
+		}
+	}
+	for i := 0; i < len(addSecgroupRules); i++ {
+		if err := region.addSecurityGroupRules(secgroupId, &addSecgroupRules[i]); err != nil {
+			log.Errorf("addSecurityGroupRule error %v", rules[i])
+			return "", err
+		}
+	}
+
+	return secgroupId, nil
+}
+
+func (region *SRegion) delSecurityGroupRule(ruleId string) error {
+	_, err := region.Delete("network", "/v2.0/security-group-rules/"+ruleId, "")
+	return err
+}
+
+func (region *SRegion) addSecurityGroupRules(secgroupId string, rule *secrules.SecurityRule) error {
+	direction := "ingress"
+	if rule.Direction == secrules.SecurityRuleEgress {
+		direction = "egress"
+	}
+
+	if rule.Protocol == secrules.PROTO_ANY {
+		rule.Protocol = "0"
+	}
+
+	params := map[string]map[string]interface{}{
+		"security_group_rule": {
+			"direction":         direction,
+			"protocol":          rule.Protocol,
+			"security_group_id": secgroupId,
+			"remote_ip_prefix":  rule.IPNet.String(),
+		},
+	}
+	if len(rule.Ports) > 0 {
+		for _, port := range rule.Ports {
+			params["security_group_rule"]["port_range_max"] = port
+			params["security_group_rule"]["port_range_min"] = port
+			_, _, err := region.Post("network", "/v2.0/security-group-rules", "", jsonutils.Marshal(params))
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	if rule.PortEnd > 0 && rule.PortStart > 0 {
+		params["security_group_rule"]["port_range_min"] = rule.PortStart
+		params["security_group_rule"]["port_range_max"] = rule.PortEnd
+	}
+	_, _, err := region.Post("network", "/v2.0/security-group-rules", "", jsonutils.Marshal(params))
+	return err
 }
 
 func (region *SRegion) DeleteSecurityGroup(vpcId, secGroupId string) error {
-	return cloudprovider.ErrNotImplemented
+	_, err := region.Delete("network", "/v2.0/security-groups/"+secGroupId, "")
+	return err
 }
 
 func (region *SRegion) CreateSecurityGroup(name, description string) (*SSecurityGroup, error) {
-	return nil, cloudprovider.ErrNotImplemented
+	params := map[string]map[string]interface{}{
+		"security_group": {
+			"name":        name,
+			"description": description,
+		},
+	}
+	_, resp, err := region.Post("network", "/v2.0/security-groups", "", jsonutils.Marshal(params))
+	if err != nil {
+		return nil, err
+	}
+	secgroup := &SSecurityGroup{}
+	return secgroup, resp.Unmarshal(secgroup, "security_group")
 }

pkg/util/openstack/shell/disk.go

@@ -18,11 +18,11 @@ func init() {
 		return nil
 	})
 
-	type DiskShowOptions struct {
-		ID string `help:"Storage type for disk"`
+	type DiskOptions struct {
+		ID string `help:"ID of disk"`
 	}
 
-	shellutils.R(&DiskShowOptions{}, "disk-show", "Show disk", func(cli *openstack.SRegion, args *DiskShowOptions) error {
+	shellutils.R(&DiskOptions{}, "disk-show", "Show disk", func(cli *openstack.SRegion, args *DiskOptions) error {
 		disk, err := cli.GetDisk(args.ID)
 		if err != nil {
 			return err
@@ -30,4 +30,43 @@ func init() {
 		printObject(disk)
 		return nil
 	})
+
+	shellutils.R(&DiskOptions{}, "disk-delete", "Delete disk", func(cli *openstack.SRegion, args *DiskOptions) error {
+		return cli.DeleteDisk(args.ID)
+	})
+
+	type DiskCreateOptions struct {
+		ZONE     string `help:"Zone name"`
+		CATEGORY string `help:"Disk category"`
+		NAME     string `help:"Disk Name"`
+		SIZE     int    `help:"Disk Size GB"`
+		Desc     string `help:"Description of disk"`
+	}
+	shellutils.R(&DiskCreateOptions{}, "disk-create", "Create disk", func(cli *openstack.SRegion, args *DiskCreateOptions) error {
+		disk, err := cli.CreateDisk(args.ZONE, args.CATEGORY, args.NAME, args.SIZE, args.Desc)
+		if err != nil {
+			return err
+		}
+		printObject(disk)
+		return nil
+	})
+
+	type DiskResetOptions struct {
+		DISK     string `help:"ID of disk"`
+		SNAPSHOT string `help:"ID of snapshot"`
+	}
+
+	shellutils.R(&DiskResetOptions{}, "disk-reset", "Reset disk", func(cli *openstack.SRegion, args *DiskResetOptions) error {
+		return cli.ResetDisk(args.DISK, args.SNAPSHOT)
+	})
+
+	type DiskResizeOptions struct {
+		DISK string `help:"ID of disk"`
+		SIZE int64  `help:"Disk size GB"`
+	}
+
+	shellutils.R(&DiskResizeOptions{}, "disk-resize", "Resize disk", func(cli *openstack.SRegion, args *DiskResizeOptions) error {
+		return cli.ResizeDisk(args.DISK, args.SIZE*1024)
+	})
+
 }

pkg/util/openstack/shell/flavor.go

@@ -0,0 +1,53 @@
+package shell
+
+import (
+	"yunion.io/x/onecloud/pkg/util/openstack"
+	"yunion.io/x/onecloud/pkg/util/shellutils"
+)
+
+func init() {
+	type FlavorkListOptions struct {
+	}
+	shellutils.R(&FlavorkListOptions{}, "flavor-list", "List flavors", func(cli *openstack.SRegion, args *FlavorkListOptions) error {
+		flavors, err := cli.GetFlavors()
+		if err != nil {
+			return err
+		}
+		printList(flavors, 0, 0, 0, []string{})
+		return nil
+	})
+
+	type FlavorOptions struct {
+		ID string `help:"ID of flavor"`
+	}
+
+	shellutils.R(&FlavorOptions{}, "flavor-show", "Show flavor", func(cli *openstack.SRegion, args *FlavorOptions) error {
+		flavor, err := cli.GetFlavor(args.ID)
+		if err != nil {
+			return err
+		}
+		printObject(flavor)
+		return nil
+	})
+
+	shellutils.R(&FlavorOptions{}, "flavor-delete", "Delete flavor", func(cli *openstack.SRegion, args *FlavorOptions) error {
+		return cli.DeleteFlavor(args.ID)
+	})
+
+	type FlavorCreateOptions struct {
+		NAME      string `help:"Name of flavor"`
+		CPU       int    `help:"Core num of cpu"`
+		MEMORY_MB int    `help:"Memory of flavor"`
+		DISK      int    `help:"Disk size of flavor"`
+	}
+
+	shellutils.R(&FlavorCreateOptions{}, "flavor-create", "Create flavor", func(cli *openstack.SRegion, args *FlavorCreateOptions) error {
+		flavor, err := cli.CreateFlavor(args.NAME, args.CPU, args.MEMORY_MB, args.DISK)
+		if err != nil {
+			return err
+		}
+		printObject(flavor)
+		return nil
+	})
+
+}

pkg/util/openstack/shell/image.go

@@ -0,0 +1,53 @@
+package shell
+
+import (
+	"yunion.io/x/onecloud/pkg/util/openstack"
+	"yunion.io/x/onecloud/pkg/util/shellutils"
+)
+
+func init() {
+	type ImageListOptions struct {
+		Name   string
+		Ids    []string
+		Status string
+	}
+	shellutils.R(&ImageListOptions{}, "image-list", "List images", func(cli *openstack.SRegion, args *ImageListOptions) error {
+		images, err := cli.GetImages(args.Name, args.Status, args.Ids)
+		if err != nil {
+			return err
+		}
+		printList(images, 0, 0, 0, []string{})
+		return nil
+	})
+
+	type ImageOptions struct {
+		ID string
+	}
+
+	shellutils.R(&ImageOptions{}, "image-show", "Show image", func(cli *openstack.SRegion, args *ImageOptions) error {
+		image, err := cli.GetImages("", "", []string{args.ID})
+		if err != nil {
+			return err
+		}
+		printObject(image[0])
+		return nil
+	})
+
+	shellutils.R(&ImageOptions{}, "image-delete", "Delete image", func(cli *openstack.SRegion, args *ImageOptions) error {
+		return cli.DeleteImage(args.ID)
+	})
+
+	type ImageCreateOptions struct {
+		NAME string
+	}
+
+	shellutils.R(&ImageCreateOptions{}, "image-create", "Create image", func(cli *openstack.SRegion, args *ImageCreateOptions) error {
+		image, err := cli.CreateImage(args.NAME)
+		if err != nil {
+			return err
+		}
+		printObject(image)
+		return nil
+	})
+
+}

pkg/util/openstack/shell/instance.go

@@ -42,4 +42,23 @@ func init() {
 		return nil
 	})
 
+	type InstanceDeployOptions struct {
+		ID       string `help:"Instance ID"`
+		Password string `help:"Instance password"`
+		Name     string `help:"Instance name"`
+	}
+
+	shellutils.R(&InstanceDeployOptions{}, "instance-deploy", "Deploy instance", func(cli *openstack.SRegion, args *InstanceDeployOptions) error {
+		return cli.DeployVM(args.ID, args.Name, args.Password, "", false, "")
+	})
+
+	type InstanceChangeConfigOptions struct {
+		ID        string `help:"Instance ID"`
+		FLAVOR_ID string `help:"Flavor ID"`
+	}
+
+	shellutils.R(&InstanceChangeConfigOptions{}, "instance-change-config", "Change instance config", func(cli *openstack.SRegion, args *InstanceChangeConfigOptions) error {
+		return cli.ChageConfig(args.ID, args.FLAVOR_ID)
+	})
+
 }

pkg/util/openstack/shell/keypair.go

@@ -0,0 +1,52 @@
+package shell
+
+import (
+	"yunion.io/x/onecloud/pkg/util/openstack"
+	"yunion.io/x/onecloud/pkg/util/shellutils"
+)
+
+func init() {
+	type KeypairListOptions struct {
+	}
+	shellutils.R(&KeypairListOptions{}, "keypair-list", "List keypairs", func(cli *openstack.SRegion, args *KeypairListOptions) error {
+		keypairs, err := cli.GetKeypairs()
+		if err != nil {
+			return err
+		}
+		printList(keypairs, 0, 0, 0, []string{})
+		return nil
+	})
+
+	type KeypairCreateOptions struct {
+		NAME      string
+		PublicKey string
+		Type      string `help:"keypair type" choices:"ssh|x509"`
+	}
+
+	shellutils.R(&KeypairCreateOptions{}, "keypair-create", "Create keypair", func(cli *openstack.SRegion, args *KeypairCreateOptions) error {
+		keypair, err := cli.CreateKeypair(args.NAME, args.PublicKey, args.Type)
+		if err != nil {
+			return err
+		}
+		printObject(keypair)
+		return nil
+	})
+
+	type KeypairOptions struct {
+		NAME string `help:"Keypair name"`
+	}
+
+	shellutils.R(&KeypairOptions{}, "keypair-show", "Show keypair", func(cli *openstack.SRegion, args *KeypairOptions) error {
+		keypair, err := cli.GetKeypair(args.NAME)
+		if err != nil {
+			return err
+		}
+		printObject(keypair)
+		return nil
+	})
+
+	shellutils.R(&KeypairOptions{}, "keypair-delete", "Delete keypair", func(cli *openstack.SRegion, args *KeypairOptions) error {
+		return cli.DeleteKeypair(args.NAME)
+	})
+
+}

pkg/util/openstack/shell/quota.go

@@ -0,0 +1,24 @@
+package shell
+
+import (
+	"yunion.io/x/onecloud/pkg/util/openstack"
+	"yunion.io/x/onecloud/pkg/util/shellutils"
+)
+
+func init() {
+	type QuotaOptions struct {
+	}
+	shellutils.R(&QuotaOptions{}, "quota-show", "Show quota", func(cli *openstack.SRegion, args *QuotaOptions) error {
+		quota, err := cli.GetQuota()
+		if err != nil {
+			return err
+		}
+		printObject(quota)
+		return nil
+	})
+
+	shellutils.R(&openstack.SQuota{}, "quota-set", "Set quota", func(cli *openstack.SRegion, args *openstack.SQuota) error {
+		return cli.SetQuota(args)
+	})
+
+}

pkg/util/openstack/shell/securitygroup.go

@@ -29,4 +29,18 @@ func init() {
 		return nil
 	})
 
+	type SecurityGroupCreateOptions struct {
+		NAME string `help:"Name of security group"`
+		Desc string `help:"Description of security group"`
+	}
+
+	shellutils.R(&SecurityGroupCreateOptions{}, "security-group-create", "Create security group", func(cli *openstack.SRegion, args *SecurityGroupCreateOptions) error {
+		secgroup, err := cli.CreateSecurityGroup(args.NAME, args.Desc)
+		if err != nil {
+			return err
+		}
+		printObject(secgroup)
+		return nil
+	})
+
 }

pkg/util/openstack/shell/snapshot.go

@@ -18,11 +18,11 @@ func init() {
 		return nil
 	})
 
-	type SnapshotShowOptions struct {
+	type SnapshotOptions struct {
 		ID string `help:"ID of snapshot"`
 	}
 
-	shellutils.R(&SnapshotShowOptions{}, "snapshot-show", "Show snapshot", func(cli *openstack.SRegion, args *SnapshotShowOptions) error {
+	shellutils.R(&SnapshotOptions{}, "snapshot-show", "Show snapshot", func(cli *openstack.SRegion, args *SnapshotOptions) error {
 		snapshot, err := cli.GetISnapshotById(args.ID)
 		if err != nil {
 			return err
@@ -31,4 +31,23 @@ func init() {
 		return nil
 	})
 
+	shellutils.R(&SnapshotOptions{}, "snapshot-delete", "Delete snapshot", func(cli *openstack.SRegion, args *SnapshotOptions) error {
+		return cli.DeleteSnapshot(args.ID)
+	})
+
+	type SnapshotCreateOptions struct {
+		DISKID string `help:"Disk ID"`
+		Name   string `help:"Disk Name"`
+		Desc   string `help:"Disk description"`
+	}
+
+	shellutils.R(&SnapshotCreateOptions{}, "snapshot-create", "Create snapshot", func(cli *openstack.SRegion, args *SnapshotCreateOptions) error {
+		snapshot, err := cli.CreateSnapshot(args.DISKID, args.Name, args.Desc)
+		if err != nil {
+			return err
+		}
+		printObject(snapshot)
+		return nil
+	})
+
 }

pkg/util/openstack/snapshot.go

@@ -43,7 +43,7 @@ func (region *SRegion) GetISnapshotById(snapshotId string) (cloudprovider.ICloud
 	if err != nil {
 		return nil, err
 	}
-	snapshot := SSnapshot{}
+	snapshot := SSnapshot{region: region}
 	if err := resp.Unmarshal(&snapshot, "snapshot"); err != nil {
 		return nil, err
 	}
@@ -78,7 +78,7 @@ func (snapshot *SSnapshot) Refresh() error {
 }
 
 func (region *SRegion) GetSnapshots(diskId string) ([]cloudprovider.ICloudSnapshot, error) {
-	_, resp, err := region.CinderGet("/snapshots/detail", "", nil)
+	_, resp, err := region.CinderList("/snapshots/detail", "", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -121,6 +121,9 @@ func (snapshot *SSnapshot) GetGlobalId() string {
 }
 
 func (snapshot *SSnapshot) GetName() string {
+	if len(snapshot.Name) == 0 {
+		return snapshot.ID
+	}
 	return snapshot.Name
 }
 
@@ -139,10 +142,24 @@ func (snapshot *SSnapshot) GetDiskType() string {
 	return models.DISK_TYPE_DATA
 }
 
-func (snapshot *SRegion) DeleteSnapshot(snapshotId string) error {
-	return cloudprovider.ErrNotImplemented
+func (region *SRegion) DeleteSnapshot(snapshotId string) error {
+	_, err := region.CinderDelete("/snapshots/"+snapshotId, "")
+	return err
 }
 
-func (snapshot *SRegion) CreateSnapshot(diskId, name, desc string) (string, error) {
-	return "", cloudprovider.ErrNotImplemented
+func (region *SRegion) CreateSnapshot(diskId, name, desc string) (*SSnapshot, error) {
+	params := map[string]map[string]interface{}{
+		"snapshot": {
+			"volume_id":   diskId,
+			"name":        name,
+			"description": desc,
+			"force":       true,
+		},
+	}
+	_, resp, err := region.CinderCreate("/snapshots", "", jsonutils.Marshal(params))
+	if err != nil {
+		return nil, err
+	}
+	snapshot := &SSnapshot{region: region}
+	return snapshot, resp.Unmarshal(snapshot, "snapshot")
 }

pkg/util/openstack/storage.go

@@ -2,8 +2,10 @@ package openstack
 
 import (
 	"strings"
+	"time"
 
 	"yunion.io/x/jsonutils"
+	"yunion.io/x/log"
 
 	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/onecloud/pkg/compute/models"
@@ -94,7 +96,13 @@ func (storage *SStorage) GetIStoragecache() cloudprovider.ICloudStoragecache {
 }
 
 func (storage *SStorage) CreateIDisk(name string, sizeGb int, desc string) (cloudprovider.ICloudDisk, error) {
-	return nil, cloudprovider.ErrNotImplemented
+	disk, err := storage.zone.region.CreateDisk(storage.zone.ZoneName, storage.Name, name, sizeGb, desc)
+	if err != nil {
+		log.Errorf("createDisk fail %v", err)
+		return nil, err
+	}
+	disk.storage = storage
+	return disk, cloudprovider.WaitStatus(disk, models.DISK_READY, time.Second*5, time.Minute*5)
 }
 
 func (storage *SStorage) GetIDiskById(idStr string) (cloudprovider.ICloudDisk, error) {

pkg/util/openstack/storagecache.go

@@ -3,11 +3,18 @@ package openstack
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"yunion.io/x/jsonutils"
+	"yunion.io/x/log"
 
 	"yunion.io/x/onecloud/pkg/cloudprovider"
+	"yunion.io/x/onecloud/pkg/compute/models"
+	"yunion.io/x/onecloud/pkg/image/options"
 	"yunion.io/x/onecloud/pkg/mcclient"
+	"yunion.io/x/onecloud/pkg/mcclient/auth"
+	"yunion.io/x/onecloud/pkg/mcclient/modules"
+	"yunion.io/x/onecloud/pkg/util/qemuimg"
 )
 
 type SStoragecache struct {
@@ -49,7 +56,16 @@ func (cache *SStoragecache) GetManagerId() string {
 }
 
 func (cache *SStoragecache) fetchImages() error {
-	return cloudprovider.ErrNotImplemented
+	images, err := cache.region.GetImages("", ACTIVE, []string{})
+	if err != nil {
+		return err
+	}
+	cache.iimages = make([]cloudprovider.ICloudImage, len(images))
+	for i := 0; i < len(images); i++ {
+		images[i].storageCache = cache
+		cache.iimages[i] = &images[i]
+	}
+	return nil
 }
 
 func (cache *SStoragecache) GetIImages() ([]cloudprovider.ICloudImage, error) {
@@ -62,7 +78,12 @@ func (cache *SStoragecache) GetIImages() ([]cloudprovider.ICloudImage, error) {
 }
 
 func (cache *SStoragecache) GetIImageById(extId string) (cloudprovider.ICloudImage, error) {
-	return nil, cloudprovider.ErrNotImplemented
+	image, err := cache.region.GetImage(extId)
+	if err != nil {
+		return nil, err
+	}
+	image.storageCache = cache
+	return image, nil
 }
 
 func (cache *SStoragecache) GetPath() string {
@@ -70,11 +91,62 @@ func (cache *SStoragecache) GetPath() string {
 }
 
 func (cache *SStoragecache) UploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, extId string, isForce bool) (string, error) {
-	return "", cloudprovider.ErrNotImplemented
+	if len(extId) > 0 {
+		log.Debugf("UploadImage: Image external ID exists %s", extId)
+
+		statsu, err := cache.region.GetImageStatus(extId)
+		if err != nil {
+			log.Errorf("GetImageStatus error %s", err)
+		}
+		if statsu == ACTIVE && !isForce {
+			return extId, nil
+		}
+	}
+	log.Debugf("UploadImage: no external ID")
+	return cache.uploadImage(ctx, userCred, imageId, osArch, osType, osDist, osVersion, isForce)
 }
 
-func (cache *SStoragecache) uploadImage(userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist string, isForce bool) (string, error) {
-	return "", cloudprovider.ErrNotImplemented
+func (cache *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.TokenCredential, imageId string, osArch, osType, osDist, osVersion string, isForce bool) (string, error) {
+	s := auth.GetAdminSession(ctx, options.Options.Region, "")
+
+	meta, reader, err := modules.Images.Download(s, 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)
+	}
+	imageName := imageBaseName
+	nameIdx := 1
+
+	for {
+		_, err = cache.region.GetImageByName(imageName)
+		if err != nil {
+			if err == cloudprovider.ErrNotFound {
+				break
+			} else {
+				return "", err
+			}
+		}
+		imageName = fmt.Sprintf("%s-%d", imageBaseName, nameIdx)
+		nameIdx++
+	}
+
+	image, err := cache.region.CreateImage(imageName)
+	if err != nil {
+		return "", err
+	}
+
+	image.storageCache = cache
+
+	_, err = cache.region.client.StreamRequest(cache.region.Name, "image", "PUT", fmt.Sprintf("/v2/images/%s/file", image.ID), "", reader)
+	if err != nil {
+		return "", err
+	}
+	return image.ID, cloudprovider.WaitStatus(image, models.CACHED_IMAGE_STATUS_READY, 15*time.Second, 3600*time.Second)
 }
 
 func (cache *SStoragecache) CreateIImage(snapshoutId, imageName, osType, imageDesc string) (cloudprovider.ICloudImage, error) {

pkg/util/openstack/vpc.go

@@ -96,7 +96,8 @@ func (vpc *SVpc) Delete() error {
 }
 
 func (region *SRegion) DeleteVpc(vpcId string) error {
-	return cloudprovider.ErrNotImplemented
+	_, err := region.Delete("network", "/v2.0/networks/"+vpcId, "")
+	return err
 }
 
 func (vpc *SVpc) GetISecurityGroups() ([]cloudprovider.ICloudSecurityGroup, error) {
@@ -191,7 +192,7 @@ func (region *SRegion) GetVpc(vpcId string) (*SVpc, error) {
 }
 
 func (region *SRegion) GetVpcs() ([]SVpc, error) {
-	_, resp, err := region.Get("network", "/v2.0/networks", "", nil)
+	_, resp, err := region.List("network", "/v2.0/networks", "", nil)
 	if err != nil {
 		return nil, err
 	}

pkg/util/openstack/wire.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"yunion.io/x/jsonutils"
+	"yunion.io/x/log"
 
 	"yunion.io/x/onecloud/pkg/cloudprovider"
 )
@@ -56,7 +57,13 @@ func (wire *SWire) GetBandwidth() int {
 }
 
 func (wire *SWire) CreateINetwork(name string, cidr string, desc string) (cloudprovider.ICloudNetwork, error) {
-	return nil, cloudprovider.ErrNotImplemented
+	networkId, err := wire.zone.region.CreateNetwork(wire.vpc.ID, name, cidr, desc)
+	if err != nil {
+		log.Errorf("CreateNetwork error %s", err)
+		return nil, err
+	}
+	wire.inetworks = nil
+	return wire.GetINetworkById(networkId)
 }
 
 func (wire *SWire) GetINetworkById(netid string) (cloudprovider.ICloudNetwork, error) {

pkg/util/openstack/zone.go

@@ -2,6 +2,7 @@ package openstack
 
 import (
 	"fmt"
+	"strings"
 
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
@@ -76,7 +77,7 @@ func (zone *SZone) getStorageByCategory(category string) (*SStorage, error) {
 	}
 	for i := 0; i < len(storages); i++ {
 		storage := storages[i].(*SStorage)
-		if storage.Name == category {
+		if strings.ToLower(storage.Name) == strings.ToLower(category) {
 			return storage, nil
 		}
 	}
@@ -94,7 +95,7 @@ func (zone *SZone) fetchStorages() error {
 	zone.istorages = []cloudprovider.ICloudStorage{}
 
 	for _, service := range []string{"volumev3", "volumev2", "volume"} {
-		_, resp, err := zone.region.Get(service, "/types", "", nil)
+		_, resp, err := zone.region.List(service, "/types", "", nil)
 		if err == nil {
 			storages := []SStorage{}
 			if err := resp.Unmarshal(&storages, "volume_types"); err != nil {
@@ -142,7 +143,7 @@ func (zone *SZone) GetIHosts() ([]cloudprovider.ICloudHost, error) {
 	hosts := []SHost{}
 	_, maxVersion, err := zone.region.GetVersion("compute")
 	if err == nil && version.GE(maxVersion, HYPERVISORS_VERSION) {
-		_, resp, err := zone.region.Get("compute", "/os-hypervisors/detail", maxVersion, nil)
+		_, resp, err := zone.region.List("compute", "/os-hypervisors/detail", maxVersion, nil)
 		if err != nil {
 			return nil, err
 		}
@@ -156,7 +157,7 @@ func (zone *SZone) GetIHosts() ([]cloudprovider.ICloudHost, error) {
 		return ihosts, nil
 	}
 
-	_, resp, err := zone.region.Get("compute", "/os-hosts", "", nil)
+	_, resp, err := zone.region.List("compute", "/os-hosts", "", nil)
 	if err != nil {
 		return nil, err
 	}

pkg/util/qcloud/instance.go

@@ -749,7 +749,7 @@ func (self *SInstance) AssignSecurityGroup(secgroupId string) error {
 	return self.host.zone.region.instanceOperation(self.InstanceId, "ModifyInstancesAttribute", params)
 }
 
-func (self *SInstance) AssignSecurityGroups(secgroupIds []string) error {
+func (self *SInstance) SetSecurityGroups(secgroupIds []string) error {
 	params := map[string]string{}
 	for i := 0; i < len(secgroupIds); i++ {
 		params[fmt.Sprintf("SecurityGroups.%d", i)] = secgroupIds[i]

pkg/util/qcloud/provider/provider.go

@@ -94,6 +94,10 @@ func (self *SQcloudProvider) IsOnPremiseInfrastructure() bool {
 	return false
 }
 
+func (self *SQcloudProvider) SyncSkuFromCloud() bool {
+	return false
+}
+
 func (self *SQcloudProvider) GetId() string {
 	return qcloud.CLOUD_PROVIDER_QCLOUD
 }

pkg/util/qcloud/region.go

@@ -627,3 +627,7 @@ func (region *SRegion) CreateILoadBalancer(loadbalancer *cloudprovider.SLoadbala
 func (region *SRegion) CreateILoadBalancerAcl(acl *cloudprovider.SLoadbalancerAccessControlList) (cloudprovider.ICloudLoadbalancerAcl, error) {
 	return nil, cloudprovider.ErrNotImplemented
 }
+
+func (region *SRegion) GetSkus(zoneId string) ([]cloudprovider.ICloudSku, error) {
+	return nil, cloudprovider.ErrNotImplemented
+}