def _create_property_filter(self, property_collector, config):
connection = self.connection
vim = connection.vim
service_content = vim.service_content
client_factory = vim.client.factory
if not config.cluster_name:
LOG.info("No cluster specified")
container = service_content.rootFolder
else:
container = get_cluster_ref_by_name(connection, config.cluster_name)
if not container:
LOG.error(_LE("Cannot find cluster with name '{}'").format(config.cluster_name))
exit(2)
container_view = connection.invoke_api(vim, 'CreateContainerView', service_content.viewManager,
container=container,
type=['VirtualMachine'],
recursive=True)
traversal_spec = vim_util.build_traversal_spec(client_factory, 'traverseEntities', 'ContainerView', 'view',
False, None)
object_spec = vim_util.build_object_spec(client_factory, container_view, [traversal_spec])
# Only static types work, so we have to get all hardware, still faster than retrieving individual items
vm_properties = ['runtime.powerState', 'config.hardware.device']
property_specs = [vim_util.build_property_spec(client_factory, 'VirtualMachine', vm_properties)]
property_filter_spec = vim_util.build_property_filter_spec(client_factory, property_specs, [object_spec])
return connection.invoke_api(vim, 'CreateFilter', property_collector, spec=property_filter_spec,
partialUpdates=True) # -> PropertyFilter
def _get_properties_for_a_collection_of_objects(self, vim, type, obj_list,
properties):
"""Gets the list of properties for the collection of
objects of the type specified.
"""
client_factory = vim.client.factory
if len(obj_list) == 0:
return []
prop_spec = vim_util.build_property_spec(client_factory,
type,
properties)
lst_obj_specs = []
for obj in obj_list:
lst_obj_specs.append(vim_util.build_object_spec(
client_factory,
obj, []))
prop_filter_spec = vim_util.build_property_filter_spec(client_factory,
[prop_spec],
lst_obj_specs)
options = client_factory.create('ns0:RetrieveOptions')
options.maxObjects = self._max_objects
return vim.RetrievePropertiesEx(
vim.service_content.propertyCollector,
specSet=[prop_filter_spec],
options=options)
def get_inner_objects(vim,
base_obj,
path,
inner_type,
properties_to_collect=None,
all=False):
"""Gets the list of inner objects of the type specified."""
client_factory = vim.client.factory
base_type = base_obj._type
traversal_spec = vutil.build_traversal_spec(client_factory, 'inner',
base_type, path, False, [])
object_spec = vutil.build_object_spec(client_factory, base_obj,
[traversal_spec])
property_spec = vutil.build_property_spec(
client_factory,
type_=inner_type,
properties_to_collect=properties_to_collect,
all_properties=all)
property_filter_spec = vutil.build_property_filter_spec(
client_factory, [property_spec], [object_spec])
options = client_factory.create('ns0:RetrieveOptions')
options.maxObjects = CONF.vmware.maximum_objects
return vim.RetrievePropertiesEx(vim.service_content.propertyCollector,
specSet=[property_filter_spec],
options=options)
def _get_datacenter(vim, entity_ref, max_objects=100):
"""Get the inventory path of a managed entity.
:param vim: Vim object
:param entity_ref: managed entity reference
:return: the datacenter of the entity_ref
"""
client_factory = vim.client.factory
property_collector = vim.service_content.propertyCollector
prop_spec = vim_util.build_property_spec(client_factory, 'Datacenter', ['name'])
select_set = vim_util.build_selection_spec(client_factory, 'ParentTraversalSpec')
select_set = vim_util.build_traversal_spec(
client_factory, 'ParentTraversalSpec', 'ManagedEntity', 'parent',
False, [select_set])
obj_spec = vim_util.build_object_spec(client_factory, entity_ref, select_set)
prop_filter_spec = vim_util.build_property_filter_spec(client_factory,
[prop_spec], [obj_spec])
options = client_factory.create('ns0:RetrieveOptions')
options.maxObjects = max_objects
retrieve_result = vim.RetrievePropertiesEx(
property_collector,
specSet=[prop_filter_spec],
options=options)
with vim_util.WithRetrieval(vim, retrieve_result) as objects:
for obj in objects:
if obj.obj._type == 'Datacenter':
return obj.obj
def test_build_object_spec(self):
client_factory = mock.Mock()
root_folder = mock.Mock()
specs = [mock.Mock()]
obj_spec = vim_util.build_object_spec(client_factory, root_folder,
specs)
self.assertEqual(root_folder, obj_spec.obj)
self.assertEqual(specs, obj_spec.selectSet)
self.assertFalse(obj_spec.skip)
def _get_perf_counters(self):
try:
self.log.info("Loading VmWare performance counters")
perf_counters = []
property_dict = {'perf_counter': ['perfCounter']}
prop_collector = self.session.vim.service_content.propertyCollector
self.client_factory = self.session.vim.client.factory
perf_manager = self.session.vim.service_content.perfManager
options = self.client_factory.create('ns0:RetrieveOptions')
options.maxObjects = 1
prop_spec = vim_util.build_property_spec(
self.client_factory,
PERF_MANAGER_TYPE,
property_dict.get('perf_counter'))
obj_spec = vim_util.build_object_spec(
self.client_factory,
perf_manager,
None)
filter_spec = vim_util.build_property_filter_spec(
self.client_factory, [prop_spec], [obj_spec])
object_contents = self.session.invoke_api(
self.session.vim,
"RetrievePropertiesEx",
prop_collector,
specSet=[filter_spec],
options=options)
if object_contents is not None:
for object_content in object_contents:
dynamic_properties = object_content[1][0].propSet
for dynamic_property in dynamic_properties:
perf_counters = dynamic_property.val.PerfCounterInfo
return perf_counters
except Exception as ex:
self.log.error("Exception in _get_perf_counters: %s"
% str(ex.message))
def _init_perf_counter_id_lookup_map(self):
# Query details of all the performance counters from VC
session = self._api_session
client_factory = session.vim.client.factory
perf_manager = session.vim.service_content.perfManager
prop_spec = vim_util.build_property_spec(client_factory,
PERF_MANAGER_TYPE,
[PERF_COUNTER_PROPERTY])
obj_spec = vim_util.build_object_spec(client_factory, perf_manager,
None)
filter_spec = vim_util.build_property_filter_spec(
client_factory, [prop_spec], [obj_spec])
options = client_factory.create('ns0:RetrieveOptions')
options.maxObjects = 1
prop_collector = session.vim.service_content.propertyCollector
result = session.invoke_api(session.vim,
"RetrievePropertiesEx",
prop_collector,
specSet=[filter_spec],
options=options)
perf_counter_infos = result.objects[0].propSet[0].val.PerfCounterInfo
# Extract the counter Id for each counter and populate the map
self._perf_counter_id_lookup_map = {}
for perf_counter_info in perf_counter_infos:
counter_group = perf_counter_info.groupInfo.key
counter_name = perf_counter_info.nameInfo.key
counter_rollup_type = perf_counter_info.rollupType
counter_id = perf_counter_info.key
counter_full_name = (counter_group + ":" + counter_name + ":" +
counter_rollup_type)
self._perf_counter_id_lookup_map[counter_full_name] = counter_id
def _get_portgroups(self, max_objects=100):
"""Get all portgroups on the switch"""
vim = self.connection.vim
property_collector = vim.service_content.propertyCollector
traversal_spec = vim_util.build_traversal_spec(
vim.client.factory,
"dvs_to_dvpg",
"DistributedVirtualSwitch",
"portgroup",
False,
[])
object_spec = vim_util.build_object_spec(
vim.client.factory,
self._dvs,
[traversal_spec])
property_spec = vim_util.build_property_spec(
vim.client.factory,
"DistributedVirtualPortgroup",
["key", "name", "config.configVersion", "customValue", "vm"])
property_filter_spec = vim_util.build_property_filter_spec(
vim.client.factory,
[property_spec],
[object_spec])
options = vim.client.factory.create('ns0:RetrieveOptions')
options.maxObjects = max_objects
pc_result = vim.RetrievePropertiesEx(property_collector, specSet=[property_filter_spec],
options=options)
result = []
with vim_util.WithRetrieval(vim, pc_result) as pc_objects:
for objContent in pc_objects:
props = {prop.name : prop.val for prop in objContent.propSet}
props["ref"] = objContent.obj
props["configVersion"] = props["config.configVersion"]
result.append(props)
return result
def _get_property_filter_spec(vim, prop_spec_map=None):
if not prop_spec_map:
prop_spec_map = constants.prop_spec_map
client_factory = vim.client.factory
recur_trav_spec = vim_util.build_recursive_traversal_spec(client_factory)
# Build the object spec
object_spec = vim_util.build_object_spec(client_factory,
vim.service_content.rootFolder,
[recur_trav_spec])
# Build property spec
propertySpecList = []
for prop_spec in prop_spec_map:
propertySpec = vim_util.build_property_spec(
client_factory,
type_=prop_spec,
properties_to_collect=prop_spec_map[prop_spec])
propertySpecList.append(propertySpec)
return vim_util.build_property_filter_spec(client_factory,
property_specs=propertySpecList,
object_specs=object_spec)