Merge pull request #1291 in YUNIONIO/onecloud from ~LIZEXI/onecloud:bugfix/lzx-misc-gpu-scheduler to release/2.8.0

* commit '1ed92bd1765144f4114d18646cd804a57ac2737c':
  fix: gpu server not work

pkg/apis/compute/api.go

@@ -142,7 +142,7 @@ type ServerCreateInput struct {
 	Description        string          `json:"description"`
 	BootOrder          string          `json:"boot_order"`
 	ResetPassword      *bool           `json:"reset_password"`
-	DisableDelete      bool            `json:"disable_delete"`
+	DisableDelete      *bool           `json:"disable_delete"`
 	ShutdownBehavior   string          `json:"shutdown_behavior"`
 	AutoStart          bool            `json:"auto_start"`
 	DeployConfigs      []*DeployConfig `json:"deploy_configs"`

pkg/apis/compute/guest_const.go

@@ -0,0 +1,162 @@
+package compute
+
+const (
+	VM_INIT            = "init"
+	VM_UNKNOWN         = "unknown"
+	VM_SCHEDULE        = "schedule"
+	VM_SCHEDULE_FAILED = "sched_fail"
+	VM_CREATE_NETWORK  = "network"
+	VM_NETWORK_FAILED  = "net_fail"
+	VM_DEVICE_FAILED   = "dev_fail"
+	VM_CREATE_FAILED   = "create_fail"
+	VM_CREATE_DISK     = "disk"
+	VM_DISK_FAILED     = "disk_fail"
+	VM_START_DEPLOY    = "start_deploy"
+	VM_DEPLOYING       = "deploying"
+	VM_DEPLOY_FAILED   = "deploy_fail"
+	VM_READY           = "ready"
+	VM_START_START     = "start_start"
+	VM_STARTING        = "starting"
+	VM_START_FAILED    = "start_fail" // # = ready
+	VM_RUNNING         = "running"
+	VM_START_STOP      = "start_stop"
+	VM_STOPPING        = "stopping"
+	VM_STOP_FAILED     = "stop_fail" // # = running
+
+	VM_BACKUP_STARTING         = "backup_starting"
+	VM_BACKUP_CREATING         = "backup_creating"
+	VM_BACKUP_CREATE_FAILED    = "backup_create_fail"
+	VM_DEPLOYING_BACKUP        = "deploying_backup"
+	VM_DEPLOYING_BACKUP_FAILED = "deploging_backup_fail"
+	VM_DELETING_BACKUP         = "deleting_backup"
+	VM_BACKUP_DELETE_FAILED    = "backup_delete_fail"
+	VM_SWITCH_TO_BACKUP        = "switch_to_backup"
+	VM_SWITCH_TO_BACKUP_FAILED = "switch_to_backup_fail"
+
+	VM_ATTACH_DISK_FAILED = "attach_disk_fail"
+	VM_DETACH_DISK_FAILED = "detach_disk_fail"
+
+	VM_START_SUSPEND  = "start_suspend"
+	VM_SUSPENDING     = "suspending"
+	VM_SUSPEND        = "suspend"
+	VM_SUSPEND_FAILED = "suspend_failed"
+
+	VM_START_DELETE = "start_delete"
+	VM_DELETE_FAIL  = "delete_fail"
+	VM_DELETING     = "deleting"
+
+	VM_DEALLOCATED = "deallocated"
+
+	VM_START_MIGRATE  = "start_migrate"
+	VM_MIGRATING      = "migrating"
+	VM_MIGRATE_FAILED = "migrate_failed"
+
+	VM_CHANGE_FLAVOR      = "change_flavor"
+	VM_CHANGE_FLAVOR_FAIL = "change_flavor_fail"
+	VM_REBUILD_ROOT       = "rebuild_root"
+	VM_REBUILD_ROOT_FAIL  = "rebuild_root_fail"
+
+	VM_START_SNAPSHOT  = "snapshot_start"
+	VM_SNAPSHOT        = "snapshot"
+	VM_SNAPSHOT_DELETE = "snapshot_delete"
+	VM_BLOCK_STREAM    = "block_stream"
+	VM_MIRROR_FAIL     = "mirror_failed"
+	VM_SNAPSHOT_SUCC   = "snapshot_succ"
+	VM_SNAPSHOT_FAILED = "snapshot_failed"
+
+	VM_SYNCING_STATUS = "syncing"
+	VM_SYNC_CONFIG    = "sync_config"
+	VM_SYNC_FAIL      = "sync_fail"
+
+	VM_RESIZE_DISK        = "resize_disk"
+	VM_RESIZE_DISK_FAILED = "resize_disk_fail"
+	VM_START_SAVE_DISK    = "start_save_disk"
+	VM_SAVE_DISK          = "save_disk"
+	VM_SAVE_DISK_FAILED   = "save_disk_failed"
+
+	VM_RESTORING_SNAPSHOT = "restoring_snapshot"
+	VM_RESTORE_DISK       = "restore_disk"
+	VM_RESTORE_STATE      = "restore_state"
+	VM_RESTORE_FAILED     = "restore_failed"
+
+	VM_ASSOCIATE_EIP         = "associate_eip"
+	VM_ASSOCIATE_EIP_FAILED  = "associate_eip_failed"
+	VM_DISSOCIATE_EIP        = "dissociate_eip"
+	VM_DISSOCIATE_EIP_FAILED = "dissociate_eip_failed"
+
+	VM_REMOVE_STATEFILE = "remove_state"
+
+	VM_ADMIN = "admin"
+
+	SHUTDOWN_STOP      = "stop"
+	SHUTDOWN_TERMINATE = "terminate"
+
+	HYPERVISOR_KVM       = "kvm"
+	HYPERVISOR_CONTAINER = "container"
+	HYPERVISOR_BAREMETAL = "baremetal"
+	HYPERVISOR_ESXI      = "esxi"
+	HYPERVISOR_HYPERV    = "hyperv"
+	HYPERVISOR_XEN       = "xen"
+
+	HYPERVISOR_ALIYUN    = "aliyun"
+	HYPERVISOR_QCLOUD    = "qcloud"
+	HYPERVISOR_AZURE     = "azure"
+	HYPERVISOR_AWS       = "aws"
+	HYPERVISOR_HUAWEI    = "huawei"
+	HYPERVISOR_OPENSTACK = "openstack"
+
+	//	HYPERVISOR_DEFAULT = HYPERVISOR_KVM
+	HYPERVISOR_DEFAULT = HYPERVISOR_KVM
+)
+
+var VM_RUNNING_STATUS = []string{VM_START_START, VM_STARTING, VM_RUNNING, VM_BLOCK_STREAM}
+var VM_CREATING_STATUS = []string{VM_CREATE_NETWORK, VM_CREATE_DISK, VM_START_DEPLOY, VM_DEPLOYING}
+
+var HYPERVISORS = []string{HYPERVISOR_KVM,
+	HYPERVISOR_BAREMETAL,
+	HYPERVISOR_ESXI,
+	HYPERVISOR_CONTAINER,
+	HYPERVISOR_ALIYUN,
+	HYPERVISOR_AZURE,
+	HYPERVISOR_AWS,
+	HYPERVISOR_QCLOUD,
+	HYPERVISOR_HUAWEI,
+	HYPERVISOR_OPENSTACK,
+}
+
+var PUBLIC_CLOUD_HYPERVISORS = []string{
+	HYPERVISOR_ALIYUN,
+	HYPERVISOR_AWS,
+	HYPERVISOR_AZURE,
+	HYPERVISOR_QCLOUD,
+	HYPERVISOR_HUAWEI,
+	HYPERVISOR_OPENSTACK,
+}
+
+// var HYPERVISORS = []string{HYPERVISOR_ALIYUN}
+
+var HYPERVISOR_HOSTTYPE = map[string]string{
+	HYPERVISOR_KVM:       HOST_TYPE_HYPERVISOR,
+	HYPERVISOR_BAREMETAL: HOST_TYPE_BAREMETAL,
+	HYPERVISOR_ESXI:      HOST_TYPE_ESXI,
+	HYPERVISOR_CONTAINER: HOST_TYPE_KUBELET,
+	HYPERVISOR_ALIYUN:    HOST_TYPE_ALIYUN,
+	HYPERVISOR_AZURE:     HOST_TYPE_AZURE,
+	HYPERVISOR_AWS:       HOST_TYPE_AWS,
+	HYPERVISOR_QCLOUD:    HOST_TYPE_QCLOUD,
+	HYPERVISOR_HUAWEI:    HOST_TYPE_HUAWEI,
+	HYPERVISOR_OPENSTACK: HOST_TYPE_OPENSTACK,
+}
+
+var HOSTTYPE_HYPERVISOR = map[string]string{
+	HOST_TYPE_HYPERVISOR: HYPERVISOR_KVM,
+	HOST_TYPE_BAREMETAL:  HYPERVISOR_BAREMETAL,
+	HOST_TYPE_ESXI:       HYPERVISOR_ESXI,
+	HOST_TYPE_KUBELET:    HYPERVISOR_CONTAINER,
+	HOST_TYPE_ALIYUN:     HYPERVISOR_ALIYUN,
+	HOST_TYPE_AZURE:      HYPERVISOR_AZURE,
+	HOST_TYPE_AWS:        HYPERVISOR_AWS,
+	HOST_TYPE_QCLOUD:     HYPERVISOR_QCLOUD,
+	HOST_TYPE_HUAWEI:     HYPERVISOR_HUAWEI,
+	HOST_TYPE_OPENSTACK:  HYPERVISOR_OPENSTACK,
+}

pkg/cloudcommon/cmdline/helper.go

@@ -310,6 +310,9 @@ func FetchScheduleInputByJSON(obj jsonutils.JSONObject) (*scheduler.ScheduleInpu
 	if err != nil {
 		return nil, err
 	}
+	if obj.Contains("scheduler") {
+		obj, _ = obj.Get("scheduler")
+	}
 	conf := &input.ServerConfig
 	conf.ServerConfigs, err = FetchServerConfigsByJSON(obj)
 	if err != nil {

pkg/cloudcommon/cmdline/helper_test.go

@@ -23,9 +23,10 @@ func TestFetchServerConfigsByJSON(t *testing.T) {
 			args: args{jsonutils.Marshal(map[string]string{
 				"disk.0":                  "1g:centos",
 				"net.0":                   "192.168.222.3:inf0",
+				"net.1":                   "[random]",
 				"schedtag.0":              "ssd:require",
 				"schedtag.1":              "container:exclude",
-				"isolated_device.0":       "vendor=nvidia:p400",
+				"isolated_device.0":       "vendor=NVIDIA:GeForce GTX 1050 Ti",
 				"baremetal_disk_config.0": "raid0:[1,2]",
 			})},
 			want: &compute.ServerConfigs{
@@ -42,6 +43,10 @@ func TestFetchServerConfigsByJSON(t *testing.T) {
 						Network: "inf0",
 						Address: "192.168.222.3",
 					},
+					{
+						Index: 1,
+						Exit:  false,
+					},
 				},
 				Schedtags: []*compute.SchedtagConfig{
 					{
@@ -55,8 +60,8 @@ func TestFetchServerConfigsByJSON(t *testing.T) {
 				},
 				IsolatedDevices: []*compute.IsolatedDeviceConfig{
 					{
-						Vendor: "nvidia",
-						Model:  "p400",
+						Vendor: "NVIDIA",
+						Model:  "GeForce GTX 1050 Ti",
 					},
 				},
 				BaremetalDiskConfigs: []*compute.BaremetalDiskConfig{

pkg/compute/models/guests.go

@@ -41,165 +41,126 @@ import (
 )
 
 const (
-	VM_INIT            = "init"
-	VM_UNKNOWN         = "unknown"
-	VM_SCHEDULE        = "schedule"
-	VM_SCHEDULE_FAILED = "sched_fail"
-	VM_CREATE_NETWORK  = "network"
-	VM_NETWORK_FAILED  = "net_fail"
-	VM_DEVICE_FAILED   = "dev_fail"
-	VM_CREATE_FAILED   = "create_fail"
-	VM_CREATE_DISK     = "disk"
-	VM_DISK_FAILED     = "disk_fail"
-	VM_START_DEPLOY    = "start_deploy"
-	VM_DEPLOYING       = "deploying"
-	VM_DEPLOY_FAILED   = "deploy_fail"
-	VM_READY           = "ready"
-	VM_START_START     = "start_start"
-	VM_STARTING        = "starting"
-	VM_START_FAILED    = "start_fail" // # = ready
-	VM_RUNNING         = "running"
-	VM_START_STOP      = "start_stop"
-	VM_STOPPING        = "stopping"
-	VM_STOP_FAILED     = "stop_fail" // # = running
+	VM_INIT            = api.VM_INIT
+	VM_UNKNOWN         = api.VM_UNKNOWN
+	VM_SCHEDULE        = api.VM_SCHEDULE
+	VM_SCHEDULE_FAILED = api.VM_SCHEDULE_FAILED
+	VM_CREATE_NETWORK  = api.VM_CREATE_NETWORK
+	VM_NETWORK_FAILED  = api.VM_NETWORK_FAILED
+	VM_DEVICE_FAILED   = api.VM_DEVICE_FAILED
+	VM_CREATE_FAILED   = api.VM_CREATE_FAILED
+	VM_CREATE_DISK     = api.VM_CREATE_DISK
+	VM_DISK_FAILED     = api.VM_DISK_FAILED
+	VM_START_DEPLOY    = api.VM_START_DEPLOY
+	VM_DEPLOYING       = api.VM_DEPLOYING
+	VM_DEPLOY_FAILED   = api.VM_DEPLOY_FAILED
+	VM_READY           = api.VM_READY
+	VM_START_START     = api.VM_START_START
+	VM_STARTING        = api.VM_STARTING
+	VM_START_FAILED    = api.VM_START_FAILED // # = ready
+	VM_RUNNING         = api.VM_RUNNING
+	VM_START_STOP      = api.VM_START_STOP
+	VM_STOPPING        = api.VM_STOPPING
+	VM_STOP_FAILED     = api.VM_STOP_FAILED // # = running
 
-	VM_BACKUP_STARTING         = "backup_starting"
-	VM_BACKUP_CREATING         = "backup_creating"
-	VM_BACKUP_CREATE_FAILED    = "backup_create_fail"
-	VM_DEPLOYING_BACKUP        = "deploying_backup"
-	VM_DEPLOYING_BACKUP_FAILED = "deploging_backup_fail"
-	VM_DELETING_BACKUP         = "deleting_backup"
-	VM_BACKUP_DELETE_FAILED    = "backup_delete_fail"
-	VM_SWITCH_TO_BACKUP        = "switch_to_backup"
-	VM_SWITCH_TO_BACKUP_FAILED = "switch_to_backup_fail"
+	VM_BACKUP_STARTING         = api.VM_BACKUP_STARTING
+	VM_BACKUP_CREATING         = api.VM_BACKUP_CREATING
+	VM_BACKUP_CREATE_FAILED    = api.VM_BACKUP_CREATE_FAILED
+	VM_DEPLOYING_BACKUP        = api.VM_DEPLOYING_BACKUP
+	VM_DEPLOYING_BACKUP_FAILED = api.VM_DEPLOYING_BACKUP_FAILED
+	VM_DELETING_BACKUP         = api.VM_DELETING_BACKUP
+	VM_BACKUP_DELETE_FAILED    = api.VM_BACKUP_DELETE_FAILED
+	VM_SWITCH_TO_BACKUP        = api.VM_SWITCH_TO_BACKUP
+	VM_SWITCH_TO_BACKUP_FAILED = api.VM_SWITCH_TO_BACKUP_FAILED
 
-	VM_ATTACH_DISK_FAILED = "attach_disk_fail"
-	VM_DETACH_DISK_FAILED = "detach_disk_fail"
+	VM_ATTACH_DISK_FAILED = api.VM_ATTACH_DISK_FAILED
+	VM_DETACH_DISK_FAILED = api.VM_DETACH_DISK_FAILED
 
-	VM_START_SUSPEND  = "start_suspend"
-	VM_SUSPENDING     = "suspending"
-	VM_SUSPEND        = "suspend"
-	VM_SUSPEND_FAILED = "suspend_failed"
+	VM_START_SUSPEND  = api.VM_START_SUSPEND
+	VM_SUSPENDING     = api.VM_SUSPENDING
+	VM_SUSPEND        = api.VM_SUSPEND
+	VM_SUSPEND_FAILED = api.VM_SUSPEND_FAILED
 
-	VM_START_DELETE = "start_delete"
-	VM_DELETE_FAIL  = "delete_fail"
-	VM_DELETING     = "deleting"
+	VM_START_DELETE = api.VM_START_DELETE
+	VM_DELETE_FAIL  = api.VM_DELETE_FAIL
+	VM_DELETING     = api.VM_DELETING
 
-	VM_DEALLOCATED = "deallocated"
+	VM_DEALLOCATED = api.VM_DEALLOCATED
 
-	VM_START_MIGRATE  = "start_migrate"
-	VM_MIGRATING      = "migrating"
-	VM_MIGRATE_FAILED = "migrate_failed"
+	VM_START_MIGRATE  = api.VM_START_MIGRATE
+	VM_MIGRATING      = api.VM_MIGRATING
+	VM_MIGRATE_FAILED = api.VM_MIGRATE_FAILED
 
-	VM_CHANGE_FLAVOR      = "change_flavor"
-	VM_CHANGE_FLAVOR_FAIL = "change_flavor_fail"
-	VM_REBUILD_ROOT       = "rebuild_root"
-	VM_REBUILD_ROOT_FAIL  = "rebuild_root_fail"
+	VM_CHANGE_FLAVOR      = api.VM_CHANGE_FLAVOR
+	VM_CHANGE_FLAVOR_FAIL = api.VM_CHANGE_FLAVOR_FAIL
+	VM_REBUILD_ROOT       = api.VM_REBUILD_ROOT
+	VM_REBUILD_ROOT_FAIL  = api.VM_REBUILD_ROOT_FAIL
 
-	VM_START_SNAPSHOT  = "snapshot_start"
-	VM_SNAPSHOT        = "snapshot"
-	VM_SNAPSHOT_DELETE = "snapshot_delete"
-	VM_BLOCK_STREAM    = "block_stream"
-	VM_MIRROR_FAIL     = "mirror_failed"
-	VM_SNAPSHOT_SUCC   = "snapshot_succ"
-	VM_SNAPSHOT_FAILED = "snapshot_failed"
+	VM_START_SNAPSHOT  = api.VM_START_SNAPSHOT
+	VM_SNAPSHOT        = api.VM_SNAPSHOT
+	VM_SNAPSHOT_DELETE = api.VM_SNAPSHOT_DELETE
+	VM_BLOCK_STREAM    = api.VM_BLOCK_STREAM
+	VM_MIRROR_FAIL     = api.VM_MIRROR_FAIL
+	VM_SNAPSHOT_SUCC   = api.VM_SNAPSHOT_SUCC
+	VM_SNAPSHOT_FAILED = api.VM_SNAPSHOT_FAILED
 
-	VM_SYNCING_STATUS = "syncing"
-	VM_SYNC_CONFIG    = "sync_config"
-	VM_SYNC_FAIL      = "sync_fail"
+	VM_SYNCING_STATUS = api.VM_SYNCING_STATUS
+	VM_SYNC_CONFIG    = api.VM_SYNC_CONFIG
+	VM_SYNC_FAIL      = api.VM_SYNC_FAIL
 
-	VM_RESIZE_DISK        = "resize_disk"
-	VM_RESIZE_DISK_FAILED = "resize_disk_fail"
-	VM_START_SAVE_DISK    = "start_save_disk"
-	VM_SAVE_DISK          = "save_disk"
-	VM_SAVE_DISK_FAILED   = "save_disk_failed"
+	VM_RESIZE_DISK        = api.VM_RESIZE_DISK
+	VM_RESIZE_DISK_FAILED = api.VM_RESIZE_DISK_FAILED
+	VM_START_SAVE_DISK    = api.VM_START_SAVE_DISK
+	VM_SAVE_DISK          = api.VM_SAVE_DISK
+	VM_SAVE_DISK_FAILED   = api.VM_SAVE_DISK_FAILED
 
-	VM_RESTORING_SNAPSHOT = "restoring_snapshot"
-	VM_RESTORE_DISK       = "restore_disk"
-	VM_RESTORE_STATE      = "restore_state"
-	VM_RESTORE_FAILED     = "restore_failed"
+	VM_RESTORING_SNAPSHOT = api.VM_RESTORING_SNAPSHOT
+	VM_RESTORE_DISK       = api.VM_RESTORE_DISK
+	VM_RESTORE_STATE      = api.VM_RESTORE_STATE
+	VM_RESTORE_FAILED     = api.VM_RESTORE_FAILED
 
-	VM_ASSOCIATE_EIP         = "associate_eip"
-	VM_ASSOCIATE_EIP_FAILED  = "associate_eip_failed"
-	VM_DISSOCIATE_EIP        = "dissociate_eip"
-	VM_DISSOCIATE_EIP_FAILED = "dissociate_eip_failed"
+	VM_ASSOCIATE_EIP         = api.VM_ASSOCIATE_EIP
+	VM_ASSOCIATE_EIP_FAILED  = api.VM_ASSOCIATE_EIP_FAILED
+	VM_DISSOCIATE_EIP        = api.VM_DISSOCIATE_EIP
+	VM_DISSOCIATE_EIP_FAILED = api.VM_DISSOCIATE_EIP_FAILED
 
-	VM_REMOVE_STATEFILE = "remove_state"
+	VM_REMOVE_STATEFILE = api.VM_REMOVE_STATEFILE
 
-	VM_ADMIN = "admin"
+	VM_ADMIN = api.VM_ADMIN
 
-	SHUTDOWN_STOP      = "stop"
-	SHUTDOWN_TERMINATE = "terminate"
+	SHUTDOWN_STOP      = api.SHUTDOWN_STOP
+	SHUTDOWN_TERMINATE = api.SHUTDOWN_TERMINATE
 
-	HYPERVISOR_KVM       = "kvm"
-	HYPERVISOR_CONTAINER = "container"
-	HYPERVISOR_BAREMETAL = "baremetal"
-	HYPERVISOR_ESXI      = "esxi"
-	HYPERVISOR_HYPERV    = "hyperv"
-	HYPERVISOR_XEN       = "xen"
+	HYPERVISOR_KVM       = api.HYPERVISOR_KVM
+	HYPERVISOR_CONTAINER = api.HYPERVISOR_CONTAINER
+	HYPERVISOR_BAREMETAL = api.HYPERVISOR_BAREMETAL
+	HYPERVISOR_ESXI      = api.HYPERVISOR_ESXI
+	HYPERVISOR_HYPERV    = api.HYPERVISOR_HYPERV
+	HYPERVISOR_XEN       = api.HYPERVISOR_XEN
 
-	HYPERVISOR_ALIYUN    = "aliyun"
-	HYPERVISOR_QCLOUD    = "qcloud"
-	HYPERVISOR_AZURE     = "azure"
-	HYPERVISOR_AWS       = "aws"
-	HYPERVISOR_HUAWEI    = "huawei"
-	HYPERVISOR_OPENSTACK = "openstack"
+	HYPERVISOR_ALIYUN    = api.HYPERVISOR_ALIYUN
+	HYPERVISOR_QCLOUD    = api.HYPERVISOR_QCLOUD
+	HYPERVISOR_AZURE     = api.HYPERVISOR_AZURE
+	HYPERVISOR_AWS       = api.HYPERVISOR_AWS
+	HYPERVISOR_HUAWEI    = api.HYPERVISOR_HUAWEI
+	HYPERVISOR_OPENSTACK = api.HYPERVISOR_OPENSTACK
 
 	//	HYPERVISOR_DEFAULT = HYPERVISOR_KVM
 	HYPERVISOR_DEFAULT = HYPERVISOR_KVM
 )
 
-var VM_RUNNING_STATUS = []string{VM_START_START, VM_STARTING, VM_RUNNING, VM_BLOCK_STREAM}
-var VM_CREATING_STATUS = []string{VM_CREATE_NETWORK, VM_CREATE_DISK, VM_START_DEPLOY, VM_DEPLOYING}
+var VM_RUNNING_STATUS = api.VM_RUNNING_STATUS
+var VM_CREATING_STATUS = api.VM_CREATING_STATUS
 
-var HYPERVISORS = []string{HYPERVISOR_KVM,
-	HYPERVISOR_BAREMETAL,
-	HYPERVISOR_ESXI,
-	HYPERVISOR_CONTAINER,
-	HYPERVISOR_ALIYUN,
-	HYPERVISOR_AZURE,
-	HYPERVISOR_AWS,
-	HYPERVISOR_QCLOUD,
-	HYPERVISOR_HUAWEI,
-	HYPERVISOR_OPENSTACK,
-}
+var HYPERVISORS = api.HYPERVISORS
 
-var PUBLIC_CLOUD_HYPERVISORS = []string{
-	HYPERVISOR_ALIYUN,
-	HYPERVISOR_AWS,
-	HYPERVISOR_AZURE,
-	HYPERVISOR_QCLOUD,
-	HYPERVISOR_HUAWEI,
-	HYPERVISOR_OPENSTACK,
-}
+var PUBLIC_CLOUD_HYPERVISORS = api.PUBLIC_CLOUD_HYPERVISORS
 
 // var HYPERVISORS = []string{HYPERVISOR_ALIYUN}
 
-var HYPERVISOR_HOSTTYPE = map[string]string{
-	HYPERVISOR_KVM:       HOST_TYPE_HYPERVISOR,
-	HYPERVISOR_BAREMETAL: HOST_TYPE_BAREMETAL,
-	HYPERVISOR_ESXI:      HOST_TYPE_ESXI,
-	HYPERVISOR_CONTAINER: HOST_TYPE_KUBELET,
-	HYPERVISOR_ALIYUN:    HOST_TYPE_ALIYUN,
-	HYPERVISOR_AZURE:     HOST_TYPE_AZURE,
-	HYPERVISOR_AWS:       HOST_TYPE_AWS,
-	HYPERVISOR_QCLOUD:    HOST_TYPE_QCLOUD,
-	HYPERVISOR_HUAWEI:    HOST_TYPE_HUAWEI,
-	HYPERVISOR_OPENSTACK: HOST_TYPE_OPENSTACK,
-}
+var HYPERVISOR_HOSTTYPE = api.HYPERVISOR_HOSTTYPE
 
-var HOSTTYPE_HYPERVISOR = map[string]string{
-	HOST_TYPE_HYPERVISOR: HYPERVISOR_KVM,
-	HOST_TYPE_BAREMETAL:  HYPERVISOR_BAREMETAL,
-	HOST_TYPE_ESXI:       HYPERVISOR_ESXI,
-	HOST_TYPE_KUBELET:    HYPERVISOR_CONTAINER,
-	HOST_TYPE_ALIYUN:     HYPERVISOR_ALIYUN,
-	HOST_TYPE_AZURE:      HYPERVISOR_AZURE,
-	HOST_TYPE_AWS:        HYPERVISOR_AWS,
-	HOST_TYPE_QCLOUD:     HYPERVISOR_QCLOUD,
-	HOST_TYPE_HUAWEI:     HYPERVISOR_HUAWEI,
-	HOST_TYPE_OPENSTACK:  HYPERVISOR_OPENSTACK,
-}
+var HOSTTYPE_HYPERVISOR = api.HOSTTYPE_HYPERVISOR
 
 type SGuestManager struct {
 	db.SVirtualResourceBaseManager
@@ -747,32 +708,61 @@ func (guest *SGuest) ValidateResizeDisk(disk *SDisk, storage *SStorage) error {
 	return guest.GetDriver().ValidateResizeDisk(guest, disk, storage)
 }
 
+func ValidateMemData(vmemSize int, driver IGuestDriver) (int, error) {
+	if vmemSize > 0 {
+		maxVmemGb := driver.GetMaxVMemSizeGB()
+		if vmemSize < 8 || vmemSize > maxVmemGb*1024 {
+			return 0, httperrors.NewInputParameterError("Memory size must be 8MB ~ %d GB", maxVmemGb)
+		}
+	}
+	return vmemSize, nil
+}
+
+func ValidateCpuData(vcpuCount int, driver IGuestDriver) (int, error) {
+	maxVcpuCount := driver.GetMaxVCpuCount()
+	if vcpuCount < 1 || vcpuCount > maxVcpuCount {
+		return 0, httperrors.NewInputParameterError("CPU core count must be 1 ~ %d", maxVcpuCount)
+	}
+	return vcpuCount, nil
+}
+
 func ValidateMemCpuData(vmemSize, vcpuCount int, hypervisor string) (int, int, error) {
 	if len(hypervisor) == 0 {
 		hypervisor = HYPERVISOR_DEFAULT
 	}
 	driver := GetDriver(hypervisor)
 
-	if vmemSize > 0 {
-		maxVmemGb := driver.GetMaxVMemSizeGB()
-		if vmemSize < 8 || vmemSize > maxVmemGb*1024 {
-			return 0, 0, httperrors.NewInputParameterError("Memory size must be 8MB ~ %d GB", maxVmemGb)
-		}
+	var err error
+	vmemSize, err = ValidateMemData(vmemSize, driver)
+	if err != nil {
+		return 0, 0, err
 	}
 
-	maxVcpuCount := driver.GetMaxVCpuCount()
-	if vcpuCount < 1 || vcpuCount > maxVcpuCount {
-		return 0, 0, httperrors.NewInputParameterError("CPU core count must be 1 ~ %d", maxVcpuCount)
+	vcpuCount, err = ValidateCpuData(vcpuCount, driver)
+	if err != nil {
+		return 0, 0, err
 	}
 	return vmemSize, vcpuCount, nil
 }
 
 func (self *SGuest) ValidateUpdateData(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) {
-	memSize, _ := data.Int("vmem_size")
-	cpuCount, _ := data.Int("vcpu_count")
-	vmemSize, vcpuCount, err := ValidateMemCpuData(int(memSize), int(cpuCount), self.Hypervisor)
-	if err != nil {
-		return nil, err
+	var err error
+	var vmemSize int
+	var vcpuCount int
+
+	driver := GetDriver(self.Hypervisor)
+
+	if memSize, _ := data.Int("vmem_size"); memSize != 0 {
+		vmemSize, err = ValidateMemData(int(memSize), driver)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if cpuCount, _ := data.Int("vcpu_count"); cpuCount != 0 {
+		vcpuCount, err = ValidateCpuData(int(cpuCount), driver)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	if vmemSize > 0 || vcpuCount > 0 {
@@ -2726,8 +2716,7 @@ func (self *SGuest) createDiskOnHost(
 }
 
 func (self *SGuest) CreateIsolatedDeviceOnHost(ctx context.Context, userCred mcclient.TokenCredential, host *SHost, devs []*api.IsolatedDeviceConfig, pendingUsage quotas.IQuota) error {
-	for idx := 0; idx < len(devs); idx += 1 {
-		devConfig := devs[idx]
+	for _, devConfig := range devs {
 		err := self.createIsolatedDeviceOnHost(ctx, userCred, host, devConfig, pendingUsage)
 		if err != nil {
 			return err

pkg/compute/models/isolated_devices.go

@@ -357,7 +357,7 @@ func (manager *SIsolatedDeviceManager) findHostUnusedByModel(model string, hostI
 	devs := make([]SIsolatedDevice, 0)
 	q := manager.findUnusedQuery()
 	q = q.Equals("model", model).Equals("host_id", hostId)
-	err := q.All(&devs)
+	err := db.FetchModelObjects(manager, q, &devs)
 	if err != nil {
 		return nil, err
 	}
@@ -444,7 +444,6 @@ func (self *SIsolatedDevice) GetSpec(statusCheck bool) *jsonutils.JSONDict {
 }
 
 func (man *SIsolatedDeviceManager) GetSpecIdent(spec *jsonutils.JSONDict) []string {
-	log.Errorf("gpu get specIdent: %s", spec)
 	devType, _ := spec.GetString("dev_type")
 	vendor, _ := spec.GetString("vendor")
 	model, _ := spec.GetString("model")

pkg/compute/models/networks.go

@@ -705,19 +705,21 @@ type SNicConfig struct {
 }
 
 func parseNetworkInfo(userCred mcclient.TokenCredential, info *api.NetworkConfig) (*api.NetworkConfig, error) {
-	netObj, err := NetworkManager.FetchByIdOrName(userCred, info.Network)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, httperrors.NewResourceNotFoundError2(NetworkManager.Keyword(), info.Network)
+	if info.Network != "" {
+		netObj, err := NetworkManager.FetchByIdOrName(userCred, info.Network)
+		if err != nil {
+			if err == sql.ErrNoRows {
+				return nil, httperrors.NewResourceNotFoundError2(NetworkManager.Keyword(), info.Network)
+			} else {
+				return nil, err
+			}
+		}
+		net := netObj.(*SNetwork)
+		if net.IsOwner(userCred) || net.IsPublic || db.IsAdminAllowGet(userCred, net) {
+			info.Network = netObj.GetId()
 		} else {
-			return nil, err
+			return nil, httperrors.NewForbiddenError("no allow to access network %s", info.Network)
 		}
-	}
-	net := netObj.(*SNetwork)
-	if net.IsOwner(userCred) || net.IsPublic || db.IsAdminAllowGet(userCred, net) {
-		info.Network = netObj.GetId()
-	} else {
-		return nil, httperrors.NewForbiddenError("no allow to access network %s", info.Network)
 	}
 
 	if info.BwLimit == 0 {

pkg/hostman/guestman/qemu-kvmhelper.go

@@ -291,12 +291,10 @@ func (s *SKVMGuestInstance) generateStartScript(data *jsonutils.JSONDict) (strin
 	}
 
 	var devAddrs = []string{}
-	isolatedParams, err := s.Desc.GetArray("isolated_devices")
-	if err != nil {
-		for _, params := range isolatedParams {
-			devAddr, _ := params.GetString("addr")
-			devAddrs = append(devAddrs, devAddr)
-		}
+	isolatedParams, _ := s.Desc.GetArray("isolated_devices")
+	for _, params := range isolatedParams {
+		devAddr, _ := params.GetString("addr")
+		devAddrs = append(devAddrs, devAddr)
 	}
 	isolatedDevsParams := s.manager.GetHost().GetIsolatedDeviceManager().GetQemuParams(devAddrs)
 

pkg/hostman/isolated_device/isolated_device.go

@@ -104,7 +104,7 @@ func (man *IsolatedDeviceManager) fillPCIDevices() error {
 	}
 	for idx, gpu := range gpus {
 		man.Devices = append(man.Devices, newGPUHPCDevice(gpu))
-		log.Infof("GPU device: %d => %#v", idx, gpu)
+		log.Infof("Add GPU device: %d => %#v", idx, gpu)
 	}
 	return nil
 }
@@ -328,6 +328,7 @@ func (dev *sGPUBaseDevice) CustomProbe() error {
 	if err != nil {
 		return err
 	}
+	grubCmdline = strings.TrimSpace(grubCmdline)
 	params := sets.NewString(strings.Split(grubCmdline, " ")...)
 	if !params.IsSuperset(sets.NewString("intel_iommu=on",
 		"vfio_iommu_type1.allow_unsafe_interrupts=1")) {
@@ -614,7 +615,7 @@ func (d *PCIDevice) getKernelDriver() (string, error) {
 		begin := strings.Index(line, prompt)
 		if begin >= 0 {
 			end := begin + len(prompt)
-			return line[end : len(line)-1], nil
+			return line[end:], nil
 		}
 	}
 	// no driver in use
@@ -729,6 +730,8 @@ func getPassthroughGPUS() ([]*PCIDevice, error) {
 			log.Errorf("Device %#v get kernel driver error: %v", dev, err)
 		} else if drv == VFIO_PCI_KERNEL_DRIVER {
 			ret = append(ret, dev)
+		} else {
+			log.Warningf("GPU %v use kernel driver %q, skip it", dev, drv)
 		}
 	}
 	return ret, nil

pkg/mcclient/options/schedulers.go

@@ -6,7 +6,7 @@ import (
 )
 
 type SchedulerTestBaseOptions struct {
-	*ServerConfigs
+	ServerConfigs
 
 	Mem  int  `help:"Memory size (MB), default 512" metavar:"MEMORY" default:"512"`
 	Ncpu int  `help:"#CPU cores of VM server, default 1" default:"1" metavar:"<SERVER_CPU_COUNT>"`

pkg/mcclient/options/servers.go

@@ -347,7 +347,8 @@ func (opts *ServerCreateOptions) Params() (*computeapi.ServerCreateInput, error)
 	}
 
 	if BoolV(opts.AllowDelete) {
-		params.DisableDelete = false
+		disableDelete := false
+		params.DisableDelete = &disableDelete
 	}
 
 	if BoolV(opts.DryRun) {

pkg/scheduler/cache/candidate/hosts.go

@@ -15,6 +15,7 @@ import (
 	"yunion.io/x/pkg/utils"
 	"yunion.io/x/sqlchemy"
 
+	api "yunion.io/x/onecloud/pkg/apis/compute"
 	computedb "yunion.io/x/onecloud/pkg/cloudcommon/db"
 	computemodels "yunion.io/x/onecloud/pkg/compute/models"
 	"yunion.io/x/onecloud/pkg/scheduler/core"
@@ -121,18 +122,24 @@ func NewGuestReservedResourceUsedByBuilder(b *HostBuilder, host *computemodels.S
 		mem  int64 = 0
 		disk int64 = 0
 	)
-	for _, g := range gst {
-		dSize, err2 := g.DiskSize(true)
-		if err2 != nil {
-			err = err2
-			return
+	guestDiskSize := func(g *computemodels.SGuest, onlyLocal bool) int {
+		size := 0
+		for _, gd := range g.GetDisks() {
+			disk := gd.GetDisk()
+			if !onlyLocal || disk.IsLocal() {
+				size += disk.DiskSize
+			}
 		}
-		disk += dSize
-		if o.GetOptions().IgnoreNonrunningGuests && !g.IsRunning() {
+		return size
+	}
+	for _, g := range gst {
+		dSize := guestDiskSize(&g, true)
+		disk += int64(dSize)
+		if o.GetOptions().IgnoreNonrunningGuests && !utils.IsInStringArray(g.Status, api.VM_RUNNING_STATUS) {
 			continue
 		}
-		cpu += g.VCPUCount
-		mem += g.VMemSize
+		cpu += int64(g.VcpuCount)
+		mem += int64(g.VmemSize)
 	}
 	ret.CPUCount = cpu
 	ret.MemorySize = mem
@@ -464,8 +471,9 @@ func (h *HostDesc) UnusedIsolatedDevicesByType(devType string) []*IsolatedDevice
 
 func (h *HostDesc) UnusedIsolatedDevicesByVendorModel(vendorModel string) []*IsolatedDeviceDesc {
 	ret := make([]*IsolatedDeviceDesc, 0)
+	vm := NewVendorModelByStr(vendorModel)
 	for _, dev := range h.UnusedIsolatedDevices() {
-		if strings.Contains(dev.VendorModel(), vendorModel) {
+		if dev.GetVendorModel().IsMatch(vm) {
 			ret = append(ret, dev)
 		}
 	}
@@ -1192,8 +1200,50 @@ func (i *IsolatedDeviceDesc) VendorID() string {
 	return strings.Split(i.VendorDeviceID, ":")[0]
 }
 
-func (i *IsolatedDeviceDesc) VendorModel() string {
-	return fmt.Sprintf("%s:%s", i.VendorID(), i.Model)
+type VendorModel struct {
+	Vendor string
+	Model  string
+}
+
+func NewVendorModelByStr(desc string) *VendorModel {
+	vm := new(VendorModel)
+	// desc format is '<vendor>:<model>'
+	parts := strings.Split(desc, ":")
+	if len(parts) == 1 {
+		vm.Model = parts[0]
+	} else if len(parts) == 2 {
+		vm.Vendor = parts[0]
+		vm.Model = parts[1]
+	}
+	return vm
+}
+
+func (vm *VendorModel) IsMatch(target *VendorModel) bool {
+	if vm.Model == "" || target.Model == "" {
+		return false
+	}
+	vendorMatch := false
+	modelMatch := false
+	if target.Vendor != "" {
+		if vm.Vendor == target.Vendor {
+			vendorMatch = true
+		} else if api.ID_VENDOR_MAP[vm.Vendor] == target.Vendor {
+			vendorMatch = true
+		}
+	} else {
+		vendorMatch = true
+	}
+	if vm.Model == target.Model {
+		modelMatch = true
+	}
+	return vendorMatch && modelMatch
+}
+
+func (i *IsolatedDeviceDesc) GetVendorModel() *VendorModel {
+	return &VendorModel{
+		Vendor: i.VendorID(),
+		Model:  i.Model,
+	}
 }
 
 func (b *HostBuilder) getIsolatedDevices(hostID string) (devs []*models.IsolatedDevice) {
@@ -1219,8 +1269,8 @@ func (b *HostBuilder) getUsedIsolatedDevices(hostID string) (devs []*models.Isol
 	return
 }
 
-func (b *HostBuilder) getIsolatedDeviceGuests(hostID string) (guests []*models.Guest) {
-	guests = make([]*models.Guest, 0)
+func (b *HostBuilder) getIsolatedDeviceGuests(hostID string) (guests []computemodels.SGuest) {
+	guests = make([]computemodels.SGuest, 0)
 	usedDevs := b.getUsedIsolatedDevices(hostID)
 	if len(usedDevs) == 0 {
 		return
@@ -1231,9 +1281,9 @@ func (b *HostBuilder) getIsolatedDeviceGuests(hostID string) (guests []*models.G
 		if !ok {
 			continue
 		}
-		guest := g.(*models.Guest)
-		if !ids.Has(guest.ID) {
-			ids.Insert(guest.ID)
+		guest := g.(computemodels.SGuest)
+		if !ids.Has(guest.Id) {
+			ids.Insert(guest.Id)
 			guests = append(guests, guest)
 		}
 	}