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() 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(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), uuid=dict(type='str'), use_instance_uuid=dict(type='bool', default=False), datacenter=dict(removed_in_version=2.9, type='str') ) 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(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() 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(): """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() 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), boot_order=dict(type="list", default=[]), name_match=dict(choices=["first", "last"], default="first"), boot_delay=dict(type="int", default=0), enter_bios_setup=dict(type="bool", default=False), boot_retry_enabled=dict(type="bool", default=False), boot_retry_delay=dict(type="int", default=0), secure_boot_enabled=dict(type="bool", default=False), boot_firmware=dict(type="str", choices=["efi", "bios"]), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[["name", "uuid", "moid"]], mutually_exclusive=[["name", "uuid", "moid"]], ) pyv = VmBootManager(module) pyv.ensure()
def main(): spec = vmware_argument_spec() spec.update( dict(esxi_hostname=dict(type='str', required=True), vsan=dict( type='str', choices=[ 'ensureObjectAccessibility', 'evacuateAllData', 'noAction' ], aliases=['vsan_mode'], ), evacuate=dict(type='bool', default=False), timeout=dict(default=0, type='int'), state=dict(required=False, default='present', choices=['present', 'absent']))) module = AnsibleModule(argument_spec=spec) host_maintenance_mgr = VmwareMaintenanceMgr(module=module) if module.params['state'] == 'present': host_maintenance_mgr.EnterMaintenanceMode() elif module.params['state'] == 'absent': host_maintenance_mgr.ExitMaintenanceMode()
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'), keys_send=dict(type='list', default=[]), string_send=dict(type='str')) 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.send_key_to_vm(vm) if result['failed']: module.fail_json(**result) else: module.exit_json(**result)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( vm_name=dict(aliases=["vm"]), vm_uuid=dict(aliases=["uuid"]), moid=dict(type="str"), use_instance_uuid=dict(type="bool", default=False), destination_host=dict(aliases=["destination"]), destination_resourcepool=dict(aliases=["resource_pool"]), destination_datastore=dict(aliases=["datastore"]), ) ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[ ["destination_host", "destination_datastore"], ["vm_uuid", "vm_name", "moid"], ], mutually_exclusive=[["vm_uuid", "vm_name", "moid"]], ) vmotion_manager = VmotionManager(module)
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( 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(): 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(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( 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( attribute_key=dict(type="str"), state=dict(type="str", default="present", choices=["absent", "present"]), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ["state", "present", ["attribute_key"]], ["state", "absent", ["attribute_key"]], ], ) pyv = VmAttributeDefManager(module) results = dict(changed=False, custom_attribute_defs=list()) if module.params["state"] == "present": results = pyv.add_custom_def(module.params["attribute_key"]) elif module.params["state"] == "absent": results = pyv.remove_custom_def(module.params["attribute_key"]) module.exit_json(**results)
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( 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"), moid=dict(type="str"), folder=dict(type="str"), datacenter=dict(type="str", default="ha-datacenter"), export_dir=dict(type="path", required=True), export_with_images=dict(type="bool", default=False), download_timeout=dict(type="int", default=30), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[["name", "uuid", "moid"]], ) pyv = VMwareExportVmOvf(module) vm = pyv.get_vm() if vm: vm_facts = pyv.gather_facts(vm) vm_power_state = vm_facts["hw_power_status"].lower() if vm_power_state != "poweredoff": module.fail_json(msg="VM state should be poweredoff to export") results = pyv.export_to_ovf_files(vm_obj=vm) module.exit_json(**results) else: module.fail_json(msg="The specified virtual machine not found")
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( 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(): 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", type="str"), folder=dict(type="str"), datacenter=dict(type="str"), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[["name", "uuid", "moid"]], mutually_exclusive=[["name", "uuid", "moid"]], supports_check_mode=True, ) 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) results = pyv.gather_vmtools_info() module.exit_json(**results)
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(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( 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(): spec = vmware_argument_spec() spec.update( dict( esxi_hostname=dict(type="str", required=True), vsan=dict( type="str", choices=[ "ensureObjectAccessibility", "evacuateAllData", "noAction", ], aliases=["vsan_mode"], ), evacuate=dict(type="bool", default=False), timeout=dict(default=0, type="int"), state=dict( required=False, default="present", choices=["present", "absent"], ), )) module = AnsibleModule(argument_spec=spec) host_maintenance_mgr = VmwareMaintenanceMgr(module=module) if module.params["state"] == "present": host_maintenance_mgr.EnterMaintenanceMode() elif module.params["state"] == "absent": host_maintenance_mgr.ExitMaintenanceMode()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( state=dict( type="str", default="shutdown-host", choices=[ "power-down-to-standby", "power-up-from-standby", "shutdown-host", "reboot-host", ], ), esxi_hostname=dict(type="str", required=False), cluster_name=dict(type="str", required=False), force=dict(type="bool", default=False), timeout=dict(type="int", default=600), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[["cluster_name", "esxi_hostname"]], ) host_power_manager = VmwareHostPowerManager(module) host_power_manager.ensure()
def main(): """ Main """ argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), datacenter=dict(type='str', aliases=['datacenter_name']), cluster=dict(type='str'), gather_nfs_mount_info=dict(type='bool', default=False), gather_vmfs_mount_info=dict(type='bool', default=False), schema=dict(type='str', choices=['summary', 'vsphere'], default='summary'), properties=dict(type='list') ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True ) if module._name == 'vmware_datastore_facts': module.deprecate("The 'vmware_datastore_facts' module has been renamed to 'vmware_datastore_info'", version='2.13') result = dict(changed=False) pyv = PyVmomiHelper(module) if module.params['cluster']: dxs = pyv.lookup_datastore_by_cluster() elif module.params['datacenter']: dxs = pyv.lookup_datastore(confine_to_datacenter=True) else: dxs = pyv.lookup_datastore(confine_to_datacenter=False) vmware_host_datastore = VMwareHostDatastore(module) datastores = vmware_host_datastore.build_datastore_list(dxs) result['datastores'] = datastores module.exit_json(**result)
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)