diff --git a/pkg/apis/compute/api.go b/pkg/apis/compute/api.go index 90a67806fc..a753ce43a5 100644 --- a/pkg/apis/compute/api.go +++ b/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"` diff --git a/pkg/apis/compute/guest_const.go b/pkg/apis/compute/guest_const.go new file mode 100644 index 0000000000..e634210f7c --- /dev/null +++ b/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, +} diff --git a/pkg/cloudcommon/cmdline/helper.go b/pkg/cloudcommon/cmdline/helper.go index ee9184c081..fffe148834 100644 --- a/pkg/cloudcommon/cmdline/helper.go +++ b/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 { diff --git a/pkg/cloudcommon/cmdline/helper_test.go b/pkg/cloudcommon/cmdline/helper_test.go index a03e8c62ed..2391633f4d 100644 --- a/pkg/cloudcommon/cmdline/helper_test.go +++ b/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{ diff --git a/pkg/compute/models/guests.go b/pkg/compute/models/guests.go index c5f05155de..7663107220 100644 --- a/pkg/compute/models/guests.go +++ b/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 diff --git a/pkg/compute/models/isolated_devices.go b/pkg/compute/models/isolated_devices.go index c8358842d7..da17dceb94 100644 --- a/pkg/compute/models/isolated_devices.go +++ b/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") diff --git a/pkg/compute/models/networks.go b/pkg/compute/models/networks.go index 1236484d48..c5bc1406f3 100644 --- a/pkg/compute/models/networks.go +++ b/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 { diff --git a/pkg/hostman/guestman/qemu-kvmhelper.go b/pkg/hostman/guestman/qemu-kvmhelper.go index 4f187c06b5..67dccfed97 100644 --- a/pkg/hostman/guestman/qemu-kvmhelper.go +++ b/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) diff --git a/pkg/hostman/isolated_device/isolated_device.go b/pkg/hostman/isolated_device/isolated_device.go index 0bf974df2b..70a9acf55f 100644 --- a/pkg/hostman/isolated_device/isolated_device.go +++ b/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 diff --git a/pkg/mcclient/options/schedulers.go b/pkg/mcclient/options/schedulers.go index f22a37f18c..d4f3785b44 100644 --- a/pkg/mcclient/options/schedulers.go +++ b/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:""` diff --git a/pkg/mcclient/options/servers.go b/pkg/mcclient/options/servers.go index 2e0e9a3934..8c1277947a 100644 --- a/pkg/mcclient/options/servers.go +++ b/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) { diff --git a/pkg/scheduler/cache/candidate/hosts.go b/pkg/scheduler/cache/candidate/hosts.go index 0cad7c9ce1..a77fe42764 100644 --- a/pkg/scheduler/cache/candidate/hosts.go +++ b/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 ':' + 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) } }