def test_parse_cluster_props(self): """Test the parse_cluster_props_method.""" datacenter = vim.Datacenter('datacenter-1') folder = vim.Folder('group-h1') parents_dict = {} parents_dict[str(datacenter)] = { 'type': 'vim.Datacenter', 'name': 'dc1' } parents_dict[str(folder)] = { 'type': 'vim.Folder', 'parent': str(datacenter) } props = [ vim.DynamicProperty(name='name', val='cluster1'), vim.DynamicProperty(name='parent', val=folder) ] expected_facts = { 'cluster.name': 'cluster1', 'cluster.datacenter': 'dc1' } results = self.runner.parse_cluster_props(props, parents_dict) self.assertEqual(results, expected_facts)
def test_retrieve_properties(self): """Test the retrieve_properties method.""" content = Mock() content.rootFolder = vim.Folder('group-d1') objects_first_page = [ vim.ObjectContent(obj=vim.Folder('group-d1'), ), vim.ObjectContent(obj=vim.ClusterComputeResource('domain-c1'), ), ] objects_second_page = [ vim.ObjectContent(obj=vim.HostSystem('host-1'), ), vim.ObjectContent(obj=vim.VirtualMachine('vm-1'), ), ] content.propertyCollector.RetrievePropertiesEx(ANY).token = '1' content.propertyCollector.RetrievePropertiesEx(ANY).objects = \ objects_first_page content.propertyCollector.ContinueRetrievePropertiesEx(ANY).token = \ None content.propertyCollector.ContinueRetrievePropertiesEx(ANY).objects = \ objects_second_page with patch.object(InspectTaskRunner, 'parse_parent_props') \ as mock_parse_parent_props, patch.object(InspectTaskRunner, 'parse_cluster_props') \ as mock_parse_cluster_props, patch.object(InspectTaskRunner, 'parse_host_props')\ as mock_parse_host_props, patch.object(InspectTaskRunner, 'parse_vm_props') \ as mock_parse_vm_props: self.runner.retrieve_properties(content) mock_parse_parent_props.assert_called_with(ANY, ANY) mock_parse_cluster_props.assert_called_with(ANY, ANY) mock_parse_host_props.assert_called_with(ANY, ANY) mock_parse_vm_props.assert_called_with(ANY, ANY)
def test_parse_parent_props(self): """Test the parse_parent_props_method.""" obj = vim.ClusterComputeResource('domain-c7') folder = vim.Folder('group-h1') props = [ vim.DynamicProperty(name='name', val='cluster1'), vim.DynamicProperty(name='parent', val=folder), ] expected_facts = { 'type': 'vim.ClusterComputeResource', 'name': 'cluster1', 'parent': str(folder) } results = self.runner.parse_parent_props(obj, props) self.assertEqual(results, expected_facts)
def test_get_vm_names(self): """Test the get vm names method.""" objects = [ vim.ObjectContent( obj=vim.VirtualMachine('vm-1'), propSet=[vim.DynamicProperty(name='name', val='vm1')]), vim.ObjectContent( obj=vim.VirtualMachine('vm-2'), propSet=[vim.DynamicProperty(name='name', val='vm2')]), ] content = Mock() content.rootFolder = vim.Folder('group-d1') content.propertyCollector.RetrievePropertiesEx(ANY).token = None content.propertyCollector.RetrievePropertiesEx(ANY).objects = objects vm_names = get_vm_names(content) self.assertTrue(isinstance(vm_names, list)) self.assertEqual(vm_names, ['vm1', 'vm2'])
def setup_cluster_vapi2(context): """Create a cluster from the Folder managed object""" cluster1_name = context.testbed.config['CLUSTER1_NAME'] # Get the host folder for the Datacenter2 using the folder query datacenter_name = context.testbed.config['DATACENTER2_NAME'] datacenter = context.testbed.entities['DATACENTER_IDS'][datacenter_name] folder_summaries = context.client.vcenter.Folder.list( Folder.FilterSpec(type=Folder.Type.HOST, datacenters=set([datacenter]))) folder = folder_summaries[0].folder # Create a managed object from the folder identifier folder_mo = vim.Folder(folder, context.soap_stub) cluster_mo = folder_mo.CreateClusterEx(cluster1_name, vim.cluster.ConfigSpecEx()) print("Created Cluster '{}' ({})".format(cluster_mo._moId, cluster1_name)) context.testbed.entities['CLUSTER_IDS'] = {cluster1_name: cluster_mo._moId}
def run(self, ids=None, names=None, datastores=None, datastore_clusters=None, resource_pools=None, vapps=None, hosts=None, folders=None, clusters=None, datacenters=None, virtual_switches=None, no_recursion=False, vsphere=None): # TODO: food for thought. PowerCli contains additional # parameters that are not present here for the folliwing reason: # <server> - we may need to bring it in if we decide to have # connections to more than 1 VC. # <tag> - Tags in VC are not the same as tags you see in Web # Client for the reason, that those tags are stored # in Inventory Service only. PowerCli somehow can access # it, from vSphere SDK there is no way. self.establish_connection(vsphere) props = ['config.guestFullName', 'name', 'runtime.powerState'] moid_to_vm = {} # getting vms by their ids vms_from_vmids = [] if ids: vms_from_vmids = [ vim.VirtualMachine(moid, stub=self.si._stub) for moid in ids ] GetVMs.__add_vm_properties_to_map_from_vm_array( moid_to_vm, vms_from_vmids) # getting vms by their names vms_from_names = [] if names: container = self.si_content.viewManager.CreateContainerView( self.si_content.rootFolder, [vim.VirtualMachine], True) for vm in container.view: if vm.name in names: vms_from_names.append(vm) GetVMs.__add_vm_properties_to_map_from_vm_array( moid_to_vm, vms_from_names) # getting vms from datastore objects vms_from_datastores = [] if datastores: vim_datastores = [ vim.Datastore(moid, stub=self.si._stub) for moid in datastores ] for ds in vim_datastores: vms_from_datastores.extend(ds.vm) GetVMs.__add_vm_properties_to_map_from_vm_array( moid_to_vm, vms_from_datastores) # getting vms from datastore cluster objects vms_from_datastore_clusters = [] if datastore_clusters: vim_datastore_clusters = [ vim.StoragePod(moid, stub=self.si._stub) for moid in datastore_clusters ] for ds_cl in vim_datastore_clusters: for ds in ds_cl.childEntity: vms_from_datastore_clusters.extend(ds.vm) GetVMs.__add_vm_properties_to_map_from_vm_array( moid_to_vm, vms_from_datastore_clusters) # getting vms from virtual switch objects vms_from_virtual_switches = [] if virtual_switches: vim_virtual_switches = [ vim.DistributedVirtualSwitch(moid, stub=self.si._stub) for moid in virtual_switches ] for vswitch in vim_virtual_switches: for pg in vswitch.portgroup: vms_from_virtual_switches.extend(pg.vm) GetVMs.__add_vm_properties_to_map_from_vm_array( moid_to_vm, vms_from_virtual_switches) # getting vms from containers (location param) vms_from_containers = [] containers = [] if resource_pools: containers += [ vim.ResourcePool(moid, stub=self.si._stub) for moid in resource_pools ] if vapps: containers += [ vim.VirtualApp(moid, stub=self.si._stub) for moid in vapps ] if hosts: containers += [ vim.HostSystem(moid, stub=self.si._stub) for moid in hosts ] if folders: containers += [ vim.Folder(moid, stub=self.si._stub) for moid in folders ] if clusters: containers += [ vim.ComputeResource(moid, stub=self.si._stub) for moid in clusters ] if datacenters: containers += [ vim.Datacenter(moid, stub=self.si._stub) for moid in datacenters ] for cont in containers: objView = self.si_content.viewManager.CreateContainerView( cont, [vim.VirtualMachine], not no_recursion) tSpec = vim.PropertyCollector.TraversalSpec( name='tSpecName', path='view', skip=False, type=vim.view.ContainerView) pSpec = vim.PropertyCollector.PropertySpec(all=False, pathSet=props, type=vim.VirtualMachine) oSpec = vim.PropertyCollector.ObjectSpec(obj=objView, selectSet=[tSpec], skip=False) pfSpec = vim.PropertyCollector.FilterSpec( objectSet=[oSpec], propSet=[pSpec], reportMissingObjectsInResults=False) retOptions = vim.PropertyCollector.RetrieveOptions() retProps = self.si_content.propertyCollector.RetrievePropertiesEx( specSet=[pfSpec], options=retOptions) vms_from_containers += retProps.objects while retProps.token: retProps = self.si_content.propertyCollector.\ ContinueRetrievePropertiesEx( token=retProps.token) vms_from_containers += retProps.objects objView.Destroy() for vm in vms_from_containers: if vm.obj._GetMoId() not in moid_to_vm: moid_to_vm[vm.obj._GetMoId()] = { "moid": vm.obj._GetMoId(), "name": vm.propSet[1].val, "os": vm.propSet[0].val, "runtime.powerState": vm.propSet[2].val } return moid_to_vm.values()
def test_vmware_get_inventory(): content = mock.Mock(spec=vim.ServiceInstanceContent) # Compute case 1 host_1 = mock.Mock(spec=vim.HostSystem) host_1._moId = 'host:1' host_1.name = 'host-1' host_1.summary.config.name = 'host-1.' folder_1 = mock.Mock(spec=vim.ComputeResource) folder_1.host = [host_1] # Computer case 2 host_2 = mock.Mock(spec=vim.HostSystem) host_2._moId = 'host:2' host_2.name = 'host-2' host_2.summary.config.name = 'host-2.' folder_2 = vim.ClusterComputeResource('computer-cluster:1') folder_2.__dict__['name'] = 'compute-cluster-1' folder_2.__dict__['host'] = [host_2] # Folders case host_3 = mock.Mock(spec=vim.HostSystem) host_3._moId = 'host:3' host_3.name = 'host-3' host_3.summary.config.name = 'host-3.' folder_3 = mock.Mock(spec=vim.ComputeResource) folder_3.host = [host_3] folder_4 = vim.Folder('folder:4') folder_4.__dict__['name'] = 'folder-4' folder_4.__dict__['childEntity'] = [folder_3] folder_5 = vim.Folder('folder:5') folder_5.__dict__['name'] = 'folder-5' folder_5.__dict__['childEntity'] = [folder_4] # Datastore case 1 datastore_1 = vim.Datastore('datastore:1') datastore_1.__dict__['name'] = 'datastore-1' # Datastore case 2 datastore_2 = vim.Datastore('datastore:2') datastore_2.__dict__['name'] = 'datastore-2' datastore_2_folder = vim.StoragePod('storagepod:1') datastore_2_folder.__dict__['childEntity'] = [datastore_2] datastore_2_folder.__dict__['name'] = 'datastore2-folder' data_center_1 = mock.Mock(spec=vim.Datacenter) data_center_1.name = 'dc-1' data_center_1_hostfolder = mock.Mock(spec=vim.Folder) data_center_1_hostfolder.childEntity = [folder_1, folder_2, folder_5] data_center_1.hostFolder = data_center_1_hostfolder dc1_datastoreFolder = mock.Mock(spec=vim.Folder) dc1_datastoreFolder.childEntity = [datastore_1, datastore_2_folder] data_center_1.datastoreFolder = dc1_datastoreFolder rootFolder1 = mock.Mock(spec=vim.Folder) rootFolder1.childEntity = [data_center_1] content.rootFolder = rootFolder1 collect_only = { 'vms': True, 'vmguests': True, 'datastores': True, 'hosts': True, 'snapshots': True, } collector = VmwareCollector( '127.0.0.1', 'root', 'password', collect_only, ignore_ssl=True, ) collector.content = content with contextlib.ExitStack() as stack: # We have to disable the LazyObject magic on pyvmomi classes so that we can use them as fakes stack.enter_context(mock.patch.object(vim.Folder, 'name', None)) stack.enter_context(mock.patch.object(vim.Folder, 'childEntity', None)) stack.enter_context(mock.patch.object(vim.ClusterComputeResource, 'name', None)) stack.enter_context(mock.patch.object(vim.ClusterComputeResource, 'host', None)) stack.enter_context(mock.patch.object(vim.Datastore, 'name', None)) stack.enter_context(mock.patch.object(vim.StoragePod, 'childEntity', None)) stack.enter_context(mock.patch.object(vim.StoragePod, 'name', None)) host = yield collector.host_labels ds = yield collector.datastore_labels assert host == { 'host:1': ['host-1', 'dc-1', ''], 'host:2': ['host-2', 'dc-1', 'compute-cluster-1'], 'host:3': ['host-3', 'dc-1', ''], } assert ds == { 'datastore-1': ['datastore-1', 'dc-1', ''], 'datastore-2': ['datastore-2', 'dc-1', 'datastore2-folder'], }