Python Vm.set_vmHostId方法代码示例

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
    def test_vm_host_get_by_id(self):
        host_id = 'VH1'
        vmhost = VmHost()
        vmhost.id = host_id
        healthnmon_db_api.vm_host_save(get_admin_context(), vmhost)
        vm = Vm()
        vm.id = 'VM11'
        vm.set_vmHostId(host_id)
        healthnmon_db_api.vm_save(get_admin_context(), vm)
        mntPnt = HostMountPoint()
        mntPnt.set_vmHostId(host_id)
        mntPnt.set_path('/path')
        volume = StorageVolume()
        volume.set_id('SV11')
        volume.add_mountPoints(mntPnt)
        healthnmon_db_api.storage_volume_save(get_admin_context(),
                                              volume)

        vmhosts = \
            healthnmon_db_api.vm_host_get_by_ids(get_admin_context(),
                                                 [host_id])
        self.assertFalse(vmhosts is None,
                         'Host get by id returned a none list')
        self.assertTrue(len(vmhosts) > 0,
                        'Host get by id returned invalid number of list'
                        )
        self.assertTrue(vmhosts[0].id == host_id)

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
 def test_vm_host_get_all_for_vm(self):
     host_id = 'VH1'
     vmhost = VmHost()
     vmhost.id = host_id
     healthnmon_db_api.vm_host_save(get_admin_context(), vmhost)
     vm = Vm()
     vm.id = 'VM11'
     vm.set_vmHostId(host_id)
     healthnmon_db_api.vm_save(get_admin_context(), vm)
     vmhosts = \
         healthnmon_db_api.vm_host_get_all(get_admin_context())
     self.assertFalse(vmhosts is None,
                      'Host get by id returned a none list')
     self.assertTrue(len(vmhosts) > 0,
                     'Host get by id returned invalid number of list'
                     )
     self.assertTrue(vmhosts[0].id == host_id)
     vmids = vmhosts[0].get_virtualMachineIds()
     self.assert_(vmids is not None)
     self.assert_(len(vmids) == 1)
     self.assert_(vm.id in vmids)
     healthnmon_db_api.vm_delete_by_ids(get_admin_context(), [vm.id])
     vmhosts = \
         healthnmon_db_api.vm_host_get_all(get_admin_context())
     self.assertTrue(vmhosts[0].id == host_id)
     vmids = vmhosts[0].get_virtualMachineIds()
     self.assert_((vmids is None) or (len(vmids) == 0))

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
 def _createCache(self):
     self.mox.StubOutWithMock(api, "vm_host_get_all")
     vmhost = VmHost()
     vmhost.set_id("vmhost1")
     vmhost1 = VmHost()
     vmhost1.set_id("vmhost2")
     vm = Vm()
     vm.set_id("vm1")
     vm.set_powerState(Constants.VM_POWER_STATES[1])
     vm.set_vmHostId("vmhost1")
     vm1 = Vm()
     vm1.set_id("vm2")
     vm1.set_powerState(Constants.VM_POWER_STATES[1])
     vm1.set_vmHostId("vmhost2")
     vmhost.set_virtualMachineIds(["vm1", "vm2"])
     stPool = StorageVolume()
     stPool.set_id("stpool1")
     subNet = Subnet()
     subNet.set_id("net1")
     api.vm_host_get_all(mox.IgnoreArg()).AndReturn([vmhost, vmhost1])
     self.mox.StubOutWithMock(api, "vm_get_all")
     api.vm_get_all(mox.IgnoreArg()).AndReturn([vm, vm1])
     self.mox.StubOutWithMock(api, "storage_volume_get_all")
     api.storage_volume_get_all(mox.IgnoreArg()).AndReturn([stPool])
     self.mox.StubOutWithMock(api, "subnet_get_all")
     api.subnet_get_all(mox.IgnoreArg()).AndReturn([subNet])

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
    def test_diff_resourcemodel_vm_with_type_changesandupdate(self):
        old_vm = Vm()
        old_vm.set_id(unicode('vm-01'))
        old_vm.set_name(unicode('vm-01'))
        disk1 = VmDisk()
        disk1.set_id(unicode('disk-01'))
        disk1.set_storageVolumeId(unicode("datastore-939"))
        old_vm.add_vmDisks(disk1)
        old_vm.set_vmHostId(unicode('host-329'))

        new_vm = Vm()
        new_vm.set_id('vm-01')
        new_vm.set_name('vm-01')
        disk3 = VmDisk()
        disk3.set_id('disk-01')
        disk3.set_storageVolumeId("datastore-939-999")
        new_vm.add_vmDisks(disk3)
        new_vm.set_vmHostId('host-329')

        diff = ResourceModelDiff(old_vm, new_vm)
        diff_res = diff.diff_resourcemodel()
        self.assertTrue(len(diff_res) > 0)
        self.assertTrue(self.update in diff_res)
        vmDisks = 'vmDisks'
        self.assertTrue(vmDisks in diff_res[self.update])

        self.assertTrue(self.update in diff_res[self.update][vmDisks])
        self.assertTrue('disk-01' in diff_res[self.update][vmDisks][
            self.update])
        self.assertTrue(self.update in diff_res[self.update][vmDisks][
            self.update]['disk-01'])
        self.assertTrue('storageVolumeId' in diff_res[self.update][vmDisks][
            self.update]['disk-01'][self.update])
        self.assertEquals(diff_res[self.update][vmDisks][self.update][
                          'disk-01'][self.update]['storageVolumeId'], 'datastore-939-999')

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
 def get_vm_list(self):
     vm_list = []
     vm = Vm()
     vm.set_id('vm-01')
     vm.set_name('vm-01')
     disk = VmDisk()
     disk.set_storageVolumeId('datastore-999')
     vm.set_vmHostId('host-1234')
     vm.add_vmDisks(disk)
     vm_list.append(vm)
     vm = Vm()
     vm.set_id('vm-02')
     vm.set_name('vm-02')
     vm_list.append(vm)
     return vm_list

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
 def get_single_vm(self):
     vm_list = []
     vm = Vm()
     vm.set_id('vm-01')
     vm.set_name('vm-01')
     disk1 = VmDisk()
     disk1.set_id('disk-01')
     disk1.set_storageVolumeId('datastore-939')
     disk2 = VmDisk()
     disk2.set_id('disk-02')
     disk2.set_storageVolumeId('datastore-439')
     vm.add_vmDisks(disk1)
     vm.add_vmDisks(disk2)
     vm.set_vmHostId('host-329')
     vm_list.append(vm)
     return vm_list

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
 def createInvCache(self, vmrunning, hostconnection='Connected'):
     vmhost = VmHost()
     vmhost.set_id(self.vmhost_id)
     vmhost.set_connectionState(hostconnection)
     vm = Vm()
     vm.set_id(self.vm_id)
     if vmrunning:
         vm.set_powerState(Constants.VM_POWER_STATES[1])
     else:
         vm.set_powerState(Constants.VM_POWER_STATES[0])
     vm.set_vmHostId(self.vmhost_id)
     vmhost.set_virtualMachineIds([self.vm_id
                                   ])
     vmhost.set_processorSpeedMhz(2100)
     vmhost.set_processorCoresCount(4)
     vmhost.set_processorCount('2')
     vmhost.set_memorySize(2097152)
     vmhost.set_memoryConsumed(2097152)
     InventoryCacheManager.update_object_in_cache(self.vmhost_id, vmhost)
     InventoryCacheManager.update_object_in_cache(
         self.vm_id,
         vm)

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
    def test_diff_resourcemodel_vm_with_type_changes(self):
        old_vm = Vm()
        old_vm.set_id(unicode('vm-01'))
        old_vm.set_name(unicode('vm-01'))
        disk1 = VmDisk()
        disk1.set_id(unicode('disk-01'))
        disk1.set_storageVolumeId(unicode("datastore-939"))
        old_vm.add_vmDisks(disk1)
        old_vm.set_vmHostId(unicode('host-329'))

        new_vm = Vm()
        new_vm.set_id('vm-01')
        new_vm.set_name('vm-01')
        disk3 = VmDisk()
        disk3.set_id('disk-01')
        disk3.set_storageVolumeId("datastore-939")
        new_vm.add_vmDisks(disk3)
        new_vm.set_vmHostId('host-329')

        diff = ResourceModelDiff(old_vm, new_vm)
        diff_res = diff.diff_resourcemodel()
        self.assertTrue(len(diff_res) == 0)

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
    def test_vm_host_delete(self):
        vmhost_id = 'VH1'
        vmhost = VmHost()
        vmhost.id = vmhost_id
        vSwitch = VirtualSwitch()
        vSwitch.set_id('vSwitch-01')
        vSwitch.set_name('vSwitch-01')
        vSwitch.set_resourceManagerId('rmId')
        vSwitch.set_switchType('vSwitch')

        cost1 = Cost()
        cost1.set_value(100)
        cost1.set_units('USD')
        vSwitch.set_cost(cost1)

        portGroup = PortGroup()
        portGroup.set_id('pg-01')
        portGroup.set_name('pg-01')
        portGroup.set_resourceManagerId('rmId')
        portGroup.set_type('portgroup_type')
        portGroup.set_cost(cost1)
        vSwitch.add_portGroups(portGroup)
        vmhost.add_virtualSwitches(vSwitch)
        vmhost.add_portGroups(portGroup)
        healthnmon_db_api.vm_host_save(get_admin_context(), vmhost)

        vmhost2 = VmHost()
        vmhost2.set_id('VH2')
        healthnmon_db_api.vm_host_save(get_admin_context(), vmhost2)

        storage = StorageVolume()
        storage.set_id('sv-01')
        storage.set_name('storage-01')
        storage.set_resourceManagerId('rmId')
        storage.set_size(1234)
        storage.set_free(2345)
        storage.set_vmfsVolume(True)
        storage.set_shared(True)
        storage.set_assignedServerCount(1)
        storage.set_volumeType('VMFS')
        storage.set_volumeId('101')

        hostMount1 = HostMountPoint()
        hostMount1.set_path('test_path1')
        hostMount1.set_vmHostId('VH1')
        storage.add_mountPoints(hostMount1)
        hostMount2 = HostMountPoint()
        hostMount2.set_path('test_path2')
        hostMount2.set_vmHostId('VH2')
        storage.add_mountPoints(hostMount2)
        healthnmon_db_api.storage_volume_save(get_admin_context(),
                                              storage)

        vm = Vm()
        vm.set_id('vm-01')
        vm.set_name('vm-01')
        vm.set_vmHostId('VH1')
        healthnmon_db_api.vm_save(get_admin_context(), vm)

        vmhosts = \
            healthnmon_db_api.vm_host_get_by_ids(get_admin_context(),
                                                 [vmhost_id])
        self.assertFalse(vmhosts is None,
                         'host get by id returned a none list')
        self.assertTrue(len(vmhosts) > 0,
                        'host get by id returned invalid number of list'
                        )

        healthnmon_db_api.vm_host_delete_by_ids(get_admin_context(),
                                                [vmhost_id])

        vmhosts = \
            healthnmon_db_api.vm_host_get_by_ids(get_admin_context(),
                                                 [vmhost_id])
        self.assertTrue(vmhosts is None or len(vmhosts) == 0,
                        'host not deleted')

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
    def test_vm_host_get_all(self):
        '''
        Inserts more than one host with vms and storage volumes.
        Also validates the data retrieved from the vmhost, vm, storage volumes.
        '''
        vmhost = VmHost()
        vmhost.id = 'VH1-id'
        healthnmon_db_api.vm_host_save(get_admin_context(), vmhost)
        vmhost = VmHost()
        vmhost.id = 'VH2-id'
        healthnmon_db_api.vm_host_save(get_admin_context(), vmhost)
        vm = Vm()
        vm.id = 'VM1-id'
        vm.set_vmHostId('VH1-id')
        vmGlobalSettings = VmGlobalSettings()
        vmGlobalSettings.set_id(vm.id)
        vmGlobalSettings.set_autoStartAction('autoStartAction')
        vmGlobalSettings.set_autoStopAction('autoStopAction')
        vm.set_vmGlobalSettings(vmGlobalSettings)
        healthnmon_db_api.vm_save(get_admin_context(), vm)
        mntPnt = HostMountPoint()
        mntPnt.set_vmHostId('VH1-id')
        mntPnt.set_path('/path')
        volume = StorageVolume()
        sv_id = 'SV1-id'
        volume.set_id(sv_id)
        volume.add_mountPoints(mntPnt)
        healthnmon_db_api.storage_volume_save(get_admin_context(), volume)

        vmhosts = healthnmon_db_api.vm_host_get_all(get_admin_context())
        self.assertFalse(vmhosts is None,
                         'vm_host_get_all returned a None')
        self.assertTrue(
            len(vmhosts) == 2,
            'vm_host_get_all does not returned expected number of hosts')
        self.assertEqual(vmhosts[0].get_id(),
                         'VH1-id', "VMHost id is not same")
        self.assertEqual(vmhosts[1].get_id(),
                         'VH2-id', "VMHost id is not same")
        vmlist = vmhosts[0].get_virtualMachineIds()
        self.assertFalse(vmlist is None,
                         "virtual machines from the host returned None")
        self.assertTrue(
            len(vmlist) == 1,
            "length of virtual machines list is not returned as expected")
        self.assertTrue(vm.id in vmlist,
                        "VmId is not in host")

        vms = healthnmon_db_api.vm_get_by_ids(get_admin_context(), ['VM1-id'])
        self.assertTrue(vms is not None)
        self.assertTrue(len(vms) == 1)
        vm = vms[0]
        self.assertEqual(vm.get_id(), 'VM1-id', "VM id is not same")
        vmGlobalSets = vm.get_vmGlobalSettings()
        self.assertTrue(vmGlobalSets is not None)
        self.assertEqual(vmGlobalSets.get_id(), 'VM1-id', "VM id is not same")
        self.assertEqual(vmGlobalSets.get_autoStartAction(),
                         'autoStartAction', "autoStartAction is not same")
        self.assertEqual(vmGlobalSets.get_autoStopAction(),
                         'autoStopAction', "autoStopAction is not same")

        svlist = vmhosts[0].get_storageVolumeIds()
        self.assertFalse(svlist is None,
                         "Storage Volumes from the host returned None")
        self.assertTrue(
            len(svlist) >= 1,
            "length of storage volumes list is not returned as expected")
        self.assertTrue(sv_id in svlist,
                        "Storage Volume Id is not host")

        storagevolumes = \
            healthnmon_db_api.storage_volume_get_by_ids(get_admin_context(),
                                                        ['SV1-id'])
        self.assertFalse(storagevolumes is None,
                         'Storage volume get by id returned a none list')
        self.assertTrue(
            len(storagevolumes) > 0,
            'Storage volume get by id returned invalid number of list')
        self.assertEquals(storagevolumes[0].id,
                          'SV1-id', "Storage volume id is not same")
        hostMountPoints = storagevolumes[0].get_mountPoints()
        self.assertEquals(hostMountPoints[0].get_path(),
                          '/path', "Host mount point path is not same")
        self.assertEquals(
            hostMountPoints[0].get_vmHostId(),
            'VH1-id', "VmHost id is not same for storage volumes")

# 需要导入模块: from healthnmon.resourcemodel.healthnmonResourceModel import Vm [as 别名]
# 或者: from healthnmon.resourcemodel.healthnmonResourceModel.Vm import set_vmHostId [as 别名]
    def test_diff_resourcemodel_vm_withaddupdtedelete(self):
        vm = Vm()
        vm.set_id('vm-01')
        vm.set_name('vm-01')
        disk1 = VmDisk()
        disk1.set_id('disk-01')
        disk1.set_storageVolumeId('datastore-939')
        disk2 = VmDisk()
        disk2.set_id('disk-02')
        disk2.set_storageVolumeId('datastore-439')
        vm.add_vmDisks(disk1)
        vm.add_vmDisks(disk2)
        vm.set_vmHostId('host-329')

        vm1 = Vm()
        vm1.set_id('vm-01')
        vm1.set_name('vm-01')
        disk11 = VmDisk()
        disk11.set_id('disk-01')
        disk11.set_storageVolumeId('datastore-939-999')
        disk21 = VmDisk()
        disk21.set_id('disk-03')
        disk21.set_storageVolumeId('datastore-439-999')
        vm1.add_vmDisks(disk11)
        vm1.add_vmDisks(disk21)
        vm1.set_vmHostId('host-329-999')

        diff = ResourceModelDiff(vm, vm1)
        diff_res = diff.diff_resourcemodel()
        self.assertTrue(len(diff_res) > 0)
        self.assertTrue(self.update in diff_res)
        vmDisks = 'vmDisks'
        self.assertTrue(vmDisks in diff_res[self.update])

        self.assertTrue(self.add in diff_res[self.update][vmDisks])
        self.assertTrue('disk-03' in diff_res[self.update][vmDisks][self.add])
        self.assertTrue(isinstance(diff_res[self.update][vmDisks][self.add][
            'disk-03'], VmDisk))
        addVmdisk = diff_res[self.update][vmDisks][self.add]['disk-03']
        self.assertEquals(addVmdisk.get_storageVolumeId(), 'datastore-439-999')

        self.assertTrue(self.delete in diff_res[self.update][vmDisks])
        self.assertTrue('disk-02' in diff_res[self.update][vmDisks][
            self.delete])
        self.assertTrue(isinstance(diff_res[self.update][vmDisks][
            self.delete]['disk-02'], VmDisk))
        delVmdisk = diff_res[self.update][vmDisks][self.delete]['disk-02']
        self.assertEquals(delVmdisk.get_storageVolumeId(), 'datastore-439')

        self.assertTrue(self.update in diff_res[self.update][vmDisks])
        self.assertTrue('disk-01' in diff_res[self.update][vmDisks][
            self.update])
        self.assertTrue(self.update in diff_res[self.update][vmDisks][
            self.update]['disk-01'])
        self.assertTrue('storageVolumeId' in diff_res[self.update][vmDisks][
            self.update]['disk-01'][self.update])
        self.assertEquals(diff_res[self.update][vmDisks][self.update][
                          'disk-01'][self.update]['storageVolumeId'],
                          'datastore-939-999')

        self.assertTrue('vmHostId' in diff_res[self.update])
        self.assertEquals(diff_res[self.update]['vmHostId'], 'host-329-999')