def main(): """Main""" argument_spec = vmware_argument_spec() argument_spec.update( state=dict(type='str', default='disabled', choices=['enabled', 'disabled', 'reset']), snmp_port=dict(type='int', default=161), community=dict(type='list', default=[]), trap_targets=dict(type='list', default=list()), trap_filter=dict(type='list'), hw_source=dict(type='str', default='indications', choices=['indications', 'sensors']), log_level=dict(type='str', default='info', choices=['debug', 'info', 'warning', 'error']), send_trap=dict(type='bool', default=False), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) host_snmp = VmwareHostSnmp(module) host_snmp.ensure()
def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict(datacenter=dict(required=True, type='str'), cluster=dict(required=True, type='str'), resource_pool=dict(required=True, type='str'), mem_shares=dict(type='str', default="normal", choices=[ 'high', 'custom', 'normal', 'low']), mem_limit=dict(type='int', default=-1), mem_reservation=dict(type='int', default=0), mem_expandable_reservations=dict( type='bool', default="True"), cpu_shares=dict(type='str', default="normal", choices=[ 'high', 'custom', 'normal', 'low']), cpu_limit=dict(type='int', default=-1), cpu_reservation=dict(type='int', default=0), cpu_expandable_reservations=dict( type='bool', default="True"), state=dict(default='present', choices=['present', 'absent'], type='str'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') vmware_rp = VMwareResourcePool(module) vmware_rp.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict(cluster_uuid=dict(required=False, type='str'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') new_cluster_uuid = module.params['cluster_uuid'] try: content = connect_to_api(module, False) host = get_all_objs(content, [vim.HostSystem]) if not host: module.fail_json(msg="Unable to locate Physical Host.") host_system = list(host)[0] changed, result, cluster_uuid = create_vsan_cluster( host_system, new_cluster_uuid) module.exit_json(changed=changed, result=result, cluster_uuid=cluster_uuid) except vmodl.RuntimeFault as runtime_fault: module.fail_json(msg=runtime_fault.msg) except vmodl.MethodFault as method_fault: module.fail_json(msg=method_fault.msg) except Exception as e: module.fail_json(msg=str(e))
def main(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), uuid=dict(type='str'), moid=dict(type='str'), folder=dict(type='str'), datacenter=dict(type='str'), esxi_hostname=dict(type='str'), cluster=dict(type='str'), local_path=dict(type='path'), ) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[['name', 'uuid', 'moid']]) pyv = PyVmomiHelper(module) vm = pyv.get_vm() if not vm: vm_id = (module.params.get('uuid') or module.params.get('name') or module.params.get('moid')) module.fail_json( msg='Unable to find the specified virtual machine : %s' % vm_id) result = pyv.take_vm_screenshot() if result['failed']: module.fail_json(**result) else: module.exit_json(**result)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), uuid=dict(type='str'), moid=dict(type='str'), use_instance_uuid=dict(type='bool', default=False), name_match=dict( choices=['first', 'last'], default='first' ), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[ ['name', 'uuid', 'moid'] ], mutually_exclusive=[ ['name', 'uuid', 'moid'] ], supports_check_mode=True, ) pyv = VmBootFactsManager(module) pyv.ensure()
def main(): argument_spec = vmware_argument_spec() # add the arguments we're going to use for this module argument_spec.update( cluster_name=dict(type='str', required=False), esxi_hostname=dict(type='str', required=False), kernel_module_name=dict(type='str', required=True), kernel_module_option=dict(type='str', required=True), ) # make sure we have a valid target cluster_name or esxi_hostname (not both) # and also enable check mode module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[ ['cluster_name', 'esxi_hostname'], ], mutually_exclusive=[ ['cluster_name', 'esxi_hostname'], ], ) vmware_host_config = VmwareKernelManager(module) vmware_host_config.check_host_configuration_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( datacenter=dict(type='str', required=True, aliases=['datacenter_name']), folder_name=dict(type='str', required=True), parent_folder=dict(type='str', required=False), state=dict(type='str', choices=['present', 'absent'], default='present'), folder_type=dict(type='str', default='vm', choices=['datastore', 'host', 'network', 'vm'], required=False), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) if len(module.params.get('folder_name')) > 79: module.fail_json(msg="Failed to manage folder as folder_name can only contain 80 characters.") vcenter_folder_mgr = VmwareFolderManager(module) if not vcenter_folder_mgr.is_vcenter(): module.fail_json(msg="Module vcenter_folder is meant for vCenter, hostname %s " "is not vCenter server." % module.params.get('hostname')) vcenter_folder_mgr.ensure()
def main(): """Main""" argument_spec = vmware_argument_spec() argument_spec.update(type=dict(required=True, type='str', choices=['dhcp', 'static']), device=dict(type='str'), host_name=dict(required=False, type='str'), domain=dict(required=False, type='str'), dns_servers=dict(required=False, type='list'), search_domains=dict(required=False, type='list'), esxi_hostname=dict(required=False, type='str'), cluster_name=dict(required=False, type='str'), verbose=dict(type='bool', default=False, required=False)) module = AnsibleModule(argument_spec=argument_spec, required_if=[ ['type', 'dhcp', ['device']], ], mutually_exclusive=[ ['cluster_name', 'host_name'], ['cluster_name', 'esxi_host_name'], ['static', 'device'], ['dhcp', 'host_name'], ['dhcp', 'domain'], ['dhcp', 'dns_servers'], ['dhcp', 'search_domains'], ], supports_check_mode=True) dns = VmwareHostDNS(module) dns.ensure()
def main(): argument_spec = vmware_argument_spec() argument_spec.update(name=dict(type='str'), uuid=dict(type='str'), use_instance_uuid=dict(type='bool', default=False), moid=dict(type='str'), folder=dict(type='str'), datacenter=dict(type='str', default='ha-datacenter'), esxi_hostname=dict(type='str'), cluster=dict(type='str'), gather_network_info=dict( type='bool', default=False, aliases=['gather_network_facts']), networks=dict(type='list', default=[])) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[['name', 'uuid', 'moid']]) pyv = PyVmomiHelper(module) vm = pyv.get_vm() if not vm: vm_id = (module.params.get('uuid') or module.params.get('name') or module.params.get('moid')) module.fail_json( msg='Unable to find the specified virtual machine using %s' % vm_id) result = pyv.reconfigure_vm_network(vm) if result['failed']: module.fail_json(**result) else: module.exit_json(**result)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict(datacenter_name=dict(type='str', required=False, aliases=['datacenter']), datastore_cluster_name=dict(type='str', required=True), state=dict(default='present', choices=['present', 'absent'], type='str'), folder=dict(type='str', required=False), enable_sdrs=dict(type='bool', default=False, required=False), keep_vmdks_together=dict(type='bool', default=True, required=False), automation_level=dict(type='str', choices=['automated', 'manual'], default='manual'), enable_io_loadbalance=dict(type='bool', default=False, required=False), loadbalance_interval=dict(type='int', default=480, required=False))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True, mutually_exclusive=[ ['datacenter_name', 'folder'], ], required_one_of=[ ['datacenter_name', 'folder'], ]) datastore_cluster_mgr = VMwareDatastoreClusterManager(module) datastore_cluster_mgr.ensure()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( datacenter=dict(type='str'), cluster=dict(type='str'), folder=dict(type='str'), vm_id=dict(type='str', required=True), vm_id_type=dict(default='vm_name', type='str', choices=['inventory_path', 'uuid', 'instance_uuid', 'dns_name', 'vm_name']), vm_username=dict(type='str', required=True), vm_password=dict(type='str', no_log=True, required=True), vm_shell=dict(type='str', required=True), vm_shell_args=dict(default=" ", type='str'), vm_shell_env=dict(type='list'), vm_shell_cwd=dict(type='str'), wait_for_process=dict(type='bool', default=False), timeout=dict(type='int', default=3600), ) ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=False, required_if=[ ['vm_id_type', 'inventory_path', ['folder']] ], ) vm_shell_mgr = VMwareShellManager(module)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict(vmk_name=dict(required=True, type='str'), ip_address=dict(required=True, type='str'), subnet_mask=dict(required=True, type='str'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') vmk_name = module.params['vmk_name'] ip_address = module.params['ip_address'] subnet_mask = module.params['subnet_mask'] try: content = connect_to_api(module, False) host = get_all_objs(content, [vim.HostSystem]) if not host: module.fail_json(msg="Unable to locate Physical Host.") host_system = list(host)[0] changed = configure_vmkernel_ip_address(host_system, vmk_name, ip_address, subnet_mask) module.exit_json(changed=changed) except vmodl.RuntimeFault as runtime_fault: module.fail_json(msg=runtime_fault.msg) except vmodl.MethodFault as method_fault: module.fail_json(msg=method_fault.msg) except Exception as e: module.fail_json(msg=str(e))
def main(): """Main""" argument_spec = vmware_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_local_user_facts = VMwareUserFactsManager(module) vmware_local_user_facts.gather_user_facts()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( cluster_name=dict(type='str', required=False), esxi_hostname=dict(type='str', required=False), rules=dict(type='list', default=list(), required=False), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[ ['cluster_name', 'esxi_hostname'], ], supports_check_mode=True ) for rule_option in module.params.get("rules", []): if 'allowed_hosts' in rule_option: if isinstance(rule_option['allowed_hosts'], list): if len(rule_option['allowed_hosts']) == 1: allowed_hosts = rule_option['allowed_hosts'][0] rule_option['allowed_hosts'] = allowed_hosts module.deprecate('allowed_hosts should be a dict, not a list', '2.13') vmware_firewall_manager = VmwareFirewallManager(module) vmware_firewall_manager.check_params() vmware_firewall_manager.ensure()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), uuid=dict(type='str'), use_instance_uuid=dict(type='bool', default=False), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[['name', 'uuid']], mutually_exclusive=[['name', 'uuid']], ) pyv = PyVmomiHelper(module) # Check if the VM exists before continuing folders = pyv.getvm_folder_paths() # VM already exists if folders: try: module.exit_json(folders=folders) except Exception as exc: module.fail_json( msg="Folder enumeration failed with exception %s" % to_native(exc)) else: module.fail_json( msg="Unable to find folders for virtual machine %s" % (module.params.get('name') or module.params.get('uuid')))
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( esxi_hostname=dict(required=True, type='str'), switch_name=dict(required=True, type='str'), vmnics=dict(required=True, type='list'), state=dict(default='present', choices=['present', 'absent'], type='str'), vendor_specific_config=dict( type='list', elements='dict', required=False, options=dict( key=dict(type='str', required=True), value=dict(type='str', required=True), ), ), )) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) if not HAS_COLLECTIONS_COUNTER: module.fail_json( msg= 'collections.Counter from Python-2.7 is required for this module') vmware_dvs_host = VMwareDvsHost(module) vmware_dvs_host.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( cluster_name=dict(type='str', required=True), datacenter=dict(type='str', required=True, aliases=['datacenter_name']), # DRS enable_drs=dict(type='bool', default=False), drs_enable_vm_behavior_overrides=dict(type='bool', default=True), drs_default_vm_behavior=dict( type='str', choices=['fullyAutomated', 'manual', 'partiallyAutomated'], default='fullyAutomated'), drs_vmotion_rate=dict(type='int', choices=range(1, 6), default=3), advanced_settings=dict(type='dict', default=dict(), required=False), )) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) vmware_cluster_drs = VMwareCluster(module) vmware_cluster_drs.configure_drs()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict(change_hostname_to=dict(required=True, type='str'), domainname=dict(required=True, type='str'), dns_servers=dict(required=True, type='list'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') change_hostname_to = module.params['change_hostname_to'] domainname = module.params['domainname'] dns_servers = module.params['dns_servers'] try: content = connect_to_api(module) host = get_all_objs(content, [vim.HostSystem]) if not host: module.fail_json(msg="Unable to locate Physical Host.") host_system = list(host)[0] changed = configure_dns(host_system, change_hostname_to, domainname, dns_servers) module.exit_json(changed=changed) except vmodl.RuntimeFault as runtime_fault: module.fail_json(msg=runtime_fault.msg) except vmodl.MethodFault as method_fault: module.fail_json(msg=method_fault.msg) except Exception as e: module.fail_json(msg=str(e))
def main(): """Main""" argument_spec = vmware_argument_spec() argument_spec.update( ad_domain=dict(type='str', default='', aliases=['domain', 'domain_name']), ad_user=dict(type='str', default=''), ad_password=dict(type='str', default='', no_log=True), ad_state=dict(default='absent', choices=['present', 'absent'], aliases=['state']), esxi_hostname=dict(type='str', required=False), cluster_name=dict(type='str', required=False), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[ ['cluster_name', 'esxi_hostname'], ], required_if=[ ['ad_state', 'present', ['ad_domain', 'ad_user', 'ad_password']], ], supports_check_mode=True) ad_auth = VmwareHostAdAuthentication(module) ad_auth.ensure()
def main(): argument_spec = vmware_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_rp_mgr = ResourcePoolFactsManager(module) module.exit_json(changed=False, resource_pool_facts=vmware_rp_mgr.gather_rp_facts())
def main(): argument_spec = vmware_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) spbm_client = SPBMClient(module) spbm_client.get_storage_policy_info()
def main(): """Main""" argument_spec = vmware_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_local_user_info = VMwareUserInfoManager(module) vmware_local_user_info.gather_user_info()
def main(): """Main""" argument_spec = vmware_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_local_role_info = VMwareLocalRoleInfo(module) vmware_local_role_info.gather_local_role_info()
def main(): """ Main function """ argument_spec = vmware_argument_spec() argument_spec.update( state=dict(type='str', default='present', choices=['present', 'absent']), datacenter=dict(type='str', required=False, aliases=['datacenter_name']), cluster_name=dict(type='str', required=True), group_name=dict(type='str', required=True), vms=dict(type='list'), hosts=dict(type='list') ) required_if = [ ['state', 'absent', ['group_name']] ] module = AnsibleModule( argument_spec=argument_spec, required_if=required_if, supports_check_mode=True, mutually_exclusive=[['vms', 'hosts']], required_one_of=[['vms', 'hosts']] ) try: # Create instance of VmwareDrsGroupManager vmware_drs_group = VmwareDrsGroupManager(module=module, datacenter_name=module.params.get('datacenter', None), cluster_name=module.params['cluster_name'], group_name=module.params['group_name'], vm_list=module.params['vms'], host_list=module.params['hosts'], state=module.params['state']) if module.params['state'] == 'present': # Add DRS group vmware_drs_group.create_drs_group() elif module.params['state'] == 'absent': # Delete DRS group vmware_drs_group.delete_drs_group() # Set results results = dict(msg=vmware_drs_group.get_msg(), failed=False, changed=vmware_drs_group.get_changed(), result=vmware_drs_group.get_result()) except Exception as error: results = dict(failed=True, msg="Error: %s" % error) if results['failed']: module.fail_json(**results) else: module.exit_json(**results)
def main(): argument_spec = vmware_argument_spec() argument_spec.update(cluster_name=dict(required=True, type='str'), fetch_from_cache=dict(required=False, type='bool')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) if not HAS_PYVMOMI: module.fail_json(msg=missing_required_lib('PyVmomi'), exception=PYVMOMI_IMP_ERR) if not HAS_VSANPYTHONSDK: module.fail_json( msg=missing_required_lib('vSAN Management SDK for Python'), exception=VSANPYTHONSDK_IMP_ERR) if not HAS_PYVMOMIJSON: module.fail_json( msg= 'The installed version of pyvmomi lacks JSON output support; need pyvmomi>6.7.1' ) try: si, content = connect_to_api(module, True, True) except Exception as e: module.fail_json(msg=e.msg) client_stub = si._GetStub() ssl_context = client_stub.schemeArgs.get('context') cluster = find_cluster_by_name(content, module.params['cluster_name']) if not cluster: module.fail_json(msg="Failed to find cluster %s" % module.params['cluster_name']) apiVersion = vsanapiutils.GetLatestVmodlVersion(module.params['hostname']) vcMos = vsanapiutils.GetVsanVcMos(client_stub, context=ssl_context, version=apiVersion) vsanClusterHealthSystem = vcMos['vsan-cluster-health-system'] try: clusterHealth = vsanClusterHealthSystem.VsanQueryVcClusterHealthSummary( cluster=cluster, fetchFromCache=module.params['fetch_from_cache']) except vmodl.fault.NotFound as not_found: module.fail_json(msg=not_found.msg) except vmodl.fault.RuntimeFault as runtime_fault: module.fail_json(msg=runtime_fault.msg) health = json.dumps(clusterHealth, cls=VmomiSupport.VmomiJSONEncoder, sort_keys=True, strip_dynamic=True) module.exit_json(changed=False, vsan_health_info=health)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( state=dict(default='present', choices=['present', 'absent', 'revert', 'remove_all']), name=dict(type='str'), name_match=dict(type='str', choices=['first', 'last'], default='first'), uuid=dict(type='str'), moid=dict(type='str'), use_instance_uuid=dict(type='bool', default=False), folder=dict(type='str'), datacenter=dict(required=True, type='str'), snapshot_name=dict(type='str'), description=dict(type='str', default=''), quiesce=dict(type='bool', default=False), memory_dump=dict(type='bool', default=False), remove_children=dict(type='bool', default=False), new_snapshot_name=dict(type='str'), new_description=dict(type='str'), ) module = AnsibleModule( argument_spec=argument_spec, required_together=[['name', 'folder']], required_one_of=[['name', 'uuid', 'moid']], ) if module.params['folder']: # FindByInventoryPath() does not require an absolute path # so we should leave the input folder path unmodified module.params['folder'] = module.params['folder'].rstrip('/') pyv = PyVmomiHelper(module) # Check if the VM exists before continuing vm = pyv.get_vm() if not vm: vm_id = (module.params.get('uuid') or module.params.get('name') or module.params.get('moid')) module.fail_json( msg="Unable to manage snapshots for non-existing VM %s" % vm_id) if not module.params[ 'snapshot_name'] and module.params['state'] != 'remove_all': module.fail_json( msg="snapshot_name param is required when state is '%(state)s'" % module.params) result = pyv.apply_snapshot_op(vm) if 'failed' not in result: result['failed'] = False if result['failed']: module.fail_json(**result) else: module.exit_json(**result)
def main(): """Main""" argument_spec = vmware_argument_spec() argument_spec.update( dict( switch=dict(required=True, aliases=['dvswitch']), name=dict(type='str'), description=dict(type='str'), advanced=dict( type='dict', options=dict( port_config_reset_at_disconnect=dict(type='bool', default=True), block_override=dict(type='bool', default=True), vendor_config_override=dict(type='bool', default=False), vlan_override=dict(type='bool', default=False), netflow_override=dict(type='bool', default=False), traffic_filter_override=dict(type='bool', default=False), ), default=dict( port_config_reset_at_disconnect=True, block_override=True, vendor_config_override=False, vlan_override=False, netflow_override=False, traffic_filter_override=False, ), aliases=['port_policy'], ), lacp=dict( type='dict', options=dict( status=dict(type='str', choices=['enabled', 'disabled'], default=['disabled']), mode=dict(type='str', choices=['active', 'passive'], default=['passive']), ), default=dict( status='disabled', mode='passive', ), ), vlan_trunk_range=dict(type='list', default=['0-4094']), netflow_enabled=dict(type='bool', default=False), block_all_ports=dict(type='bool', default=False), )) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) vmware_dvswitch_uplink_pg = VMwareDvSwitchUplinkPortgroup(module) vmware_dvswitch_uplink_pg.ensure()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( cluster_name=dict(type='str', required=True), datacenter=dict(type='str', required=True, aliases=['datacenter_name']), state=dict(type='str', default='present', choices=['absent', 'present']), # DRS ignore_drs=dict(type='bool', default=False), enable_drs=dict(type='bool', default=False), drs_enable_vm_behavior_overrides=dict(type='bool', default=True), drs_default_vm_behavior=dict( type='str', choices=['fullyAutomated', 'manual', 'partiallyAutomated'], default='fullyAutomated'), drs_vmotion_rate=dict(type='int', choices=range(1, 6), default=3), # HA ignore_ha=dict(type='bool', default=False), enable_ha=dict(type='bool', default=False), ha_failover_level=dict(type='int', default=2), ha_host_monitoring=dict(type='str', default='enabled', choices=['enabled', 'disabled']), # HA VM Monitoring related parameters ha_vm_monitoring=dict(type='str', choices=[ 'vmAndAppMonitoring', 'vmMonitoringOnly', 'vmMonitoringDisabled' ], default='vmMonitoringDisabled'), ha_vm_failure_interval=dict(type='int', default=30), ha_vm_min_up_time=dict(type='int', default=120), ha_vm_max_failures=dict(type='int', default=3), ha_vm_max_failure_window=dict(type='int', default=-1), ha_restart_priority=dict( type='str', choices=['high', 'low', 'medium', 'disabled'], default='medium'), ha_admission_control_enabled=dict(type='bool', default=True), # VSAN ignore_vsan=dict(type='bool', default=False), enable_vsan=dict(type='bool', default=False), vsan_auto_claim_storage=dict(type='bool', default=False), )) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) vmware_cluster = VMwareCluster(module) vmware_cluster.process_state()
def main(): argument_spec = vmware_argument_spec() module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) vmware_about_facts_mgr = VmwareAboutManager(module) vmware_about_facts_mgr.gather_about_facts()
def main(): argument_spec = vmware_argument_spec() module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) vcenter_extension_facts_mgr = VmwareExtManager(module) vcenter_extension_facts_mgr.gather_plugin_facts()