def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict(target_id=dict(required=True, type='int'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') content = connect_to_api(module) host = find_hostsystem(content) target_lun_uuid = {} scsilun_canonical = {} # Associate the scsiLun key with the canonicalName (NAA) for scsilun in host.config.storageDevice.scsiLun: scsilun_canonical[scsilun.key] = scsilun.canonicalName # Associate target number with LUN uuid for target in host.config.storageDevice.scsiTopology.adapter[0].target: for lun in target.lun: target_lun_uuid[target.target] = lun.scsiLun module.exit_json(changed=False, canonical=scsilun_canonical[target_lun_uuid[module.params['target_id']]])
def main(): argument_spec = vmware_argument_spec() argument_spec.update( cluster_name=dict(type='str', required=False), esxi_hostname=dict(type='str', required=False), acceptance_level=dict(type='str', choices=['community', 'partner', 'vmware_accepted', 'vmware_certified'] ), state=dict(type='str', choices=['list', 'present'], default='list'), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[ ['cluster_name', 'esxi_hostname'], ], required_if=[ ['state', 'present', ['acceptance_level']], ], ) vmware_host_accept_config = VMwareAccpetanceManager(module) vmware_host_accept_config.check_acceptance_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), name_match=dict(type='str', choices=['first', 'last'], default='first'), uuid=dict(type='str'), folder=dict(type='str', default='/vm'), datacenter=dict(type='str', required=True), ) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[['name', 'uuid']]) # 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.getvm(name=module.params['name'], folder=module.params['folder'], uuid=module.params['uuid']) # VM already exists if vm: try: module.exit_json(instance=pyv.gather_facts(vm)) except Exception as exc: module.fail_json(msg="Fact gather failed with exception %s" % to_text(exc)) else: msg = "Unable to gather facts for non-existing VM " if module.params['name']: msg += "%(name)s" % module.params elif module.params['uuid']: msg += "%(uuid)s" % module.params module.fail_json(msg=msg)
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 = host.keys()[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(): 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 = host.keys()[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(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 = host.keys()[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( datacenter_name=dict(type='str', required=True, aliases=['datacenter']), cluster_name=dict(type='str', aliases=['cluster']), esxi_hostname=dict(type='str', required=True), esxi_username=dict(type='str'), esxi_password=dict(type='str', no_log=True), esxi_ssl_thumbprint=dict(type='str', default=''), state=dict(default='present', choices=['present', 'absent', 'add_or_reconnect', 'reconnect'], type='str'), folder=dict(type='str'), add_connected=dict(type='bool', default=True), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ['state', 'present', ['esxi_username', 'esxi_password']], ['state', 'add_or_reconnect', ['esxi_username', 'esxi_password']] ], required_one_of=[ ['cluster_name', 'folder'], ], mutually_exclusive=[ ['cluster_name', 'folder'], ] ) vmware_host = VMwareHost(module) vmware_host.process_state()
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(): spec = vmware_argument_spec() spec.update(dict( esxi_hostname=dict(required=True), vsan=dict(required=False, choices=['ensureObjectAccessibility', 'evacuateAllData', 'noAction']), evacuate=dict(required=False, type='bool', default=False), timeout=dict(required=False, default=0, type='int'), state=dict(required=False, default='present', choices=['present', 'absent']))) module = AnsibleModule(argument_spec=spec) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') content = connect_to_api(module) host = find_hostsystem_by_name(content, module.params['esxi_hostname']) if not host: module.fail_json( msg='Host not found in vCenter') if module.params['state'] == 'present': result = EnterMaintenanceMode(module, host) elif module.params['state'] == 'absent': result = ExitMaintenanceMode(module, host) module.exit_json(**result)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( datacenter=dict(type='str', required=True), 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=False, ) 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) vcenter_folder_mgr.ensure()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), uuid=dict(type='str'), folder=dict(type='str'), datacenter=dict(required=True, type='str'), ) module = AnsibleModule(argument_spec=argument_spec, required_together=[['name', 'folder']], required_one_of=[['name', 'uuid']], ) 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: # If UUID is set, getvm select UUID, show error message accordingly. module.fail_json(msg="Unable to gather facts about snapshots for" " non-existing VM ['%s']" % (module.params.get('uuid') or module.params.get('name'))) results = dict(changed=False, guest_snapshots=pyv.gather_guest_snapshot_facts(vm_obj=vm)) module.exit_json(**results)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), datacenter=dict(type='str'), cluster=dict(type='str') ) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[ ['cluster', 'datacenter'], ], ) result = dict(changed=False) pyv = PyVmomiHelper(module) if module.params['cluster']: dxs = pyv.lookup_datastore_by_cluster() else: dxs = pyv.lookup_datastore() datastores = list() for ds in dxs: summary = ds.summary dds = dict() dds['accessible'] = summary.accessible dds['capacity'] = summary.capacity dds['name'] = summary.name dds['freeSpace'] = summary.freeSpace dds['maintenanceMode'] = summary.maintenanceMode dds['multipleHostAccess'] = summary.multipleHostAccess dds['type'] = summary.type # vcsim does not return uncommitted if not summary.uncommitted: summary.uncommitted = 0 dds['uncommitted'] = summary.uncommitted dds['url'] = summary.url # Calculated values dds['provisioned'] = summary.capacity - summary.freeSpace + summary.uncommitted dds['datastore_cluster'] = 'N/A' if isinstance(ds.parent, vim.StoragePod): dds['datastore_cluster'] = ds.parent.name if module.params['name']: if dds['name'] == module.params['name']: datastores.extend([dds]) else: datastores.extend([dds]) result['datastores'] = datastores # found a datastore if datastores: module.exit_json(**result) else: msg = "Unable to gather datastore facts" if module.params['name']: msg += " for %(name)s" % module.params msg += " in datacenter %(datacenter)s" % module.params module.fail_json(msg=msg)
def main(): argument_spec = vmware_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vm_host_manager = VMwareHostFactManager(module) vm_host_manager.all_facts()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), uuid=dict(type='str'), datacenter=dict(type='str', required=True) ) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[['name', 'uuid']]) pyv = PyVmomiHelper(module) # Check if the VM exists before continuing folders = pyv.getvm_folder_paths( name=module.params['name'], uuid=module.params['uuid'] ) # 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: msg = "Unable to find folders for VM " if module.params['name']: msg += "%(name)s" % module.params elif module.params['uuid']: msg += "%(uuid)s" % module.params module.fail_json(msg=msg)
def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict(datacenter=dict(default=None, type='str'), cluster=dict(default=None, type='str'), folder=dict(type='str', default='/vm'), vm_id=dict(required=True, type='str'), vm_id_type=dict(default='vm_name', type='str', choices=['inventory_path', 'uuid', 'dns_name', 'vm_name']), vm_username=dict(required=False, type='str'), vm_password=dict(required=False, type='str', no_log=True), vm_shell=dict(required=True, type='str'), vm_shell_args=dict(default=" ", type='str'), vm_shell_env=dict(default=None, type='list'), vm_shell_cwd=dict(default=None, type='str'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False, required_if=[['vm_id_type', 'inventory_path', ['folder']]], ) if not HAS_PYVMOMI: module.fail_json(changed=False, msg='pyvmomi is required for this module') try: p = module.params datacenter_name = p['datacenter'] cluster_name = p['cluster'] folder = p['folder'] content = connect_to_api(module) datacenter = None if datacenter_name: datacenter = find_datacenter_by_name(content, datacenter_name) if not datacenter: module.fail_json(changed=False, msg="datacenter not found") cluster = None if cluster_name: cluster = find_cluster_by_name(content, cluster_name, datacenter) if not cluster: module.fail_json(changed=False, msg="cluster not found") if p['vm_id_type'] == 'inventory_path': vm = find_vm_by_id(content, vm_id=p['vm_id'], vm_id_type="inventory_path", folder=folder) else: vm = find_vm_by_id(content, vm_id=p['vm_id'], vm_id_type=p['vm_id_type'], datacenter=datacenter, cluster=cluster) if not vm: module.fail_json(msg='VM not found') msg = execute_command(content, vm, p['vm_username'], p['vm_password'], p['vm_shell'], p['vm_shell_args'], p['vm_shell_env'], p['vm_shell_cwd']) module.exit_json(changed=True, uuid=vm.summary.config.uuid, msg=msg) except vmodl.RuntimeFault as runtime_fault: module.fail_json(changed=False, msg=runtime_fault.msg) except vmodl.MethodFault as method_fault: module.fail_json(changed=False, msg=method_fault.msg) except Exception as e: module.fail_json(changed=False, msg=str(e))
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( vm_name=dict(required=True, aliases=['vm'], type='str'), destination_host=dict(required=True, aliases=['destination'], 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') content = connect_to_api(module=module) vm_object = find_vm_by_name(content=content, vm_name=module.params['vm_name']) host_object = find_hostsystem_by_name(content=content, hostname=module.params['destination_host']) # Setup result result = { 'changed': False } # Check if we could find the VM or Host if not vm_object: module.fail_json(msg='Cannot find virtual machine') if not host_object: module.fail_json(msg='Cannot find host') # Make sure VM isn't already at the destination if vm_object.runtime.host.name == module.params['destination_host']: module.exit_json(**result) if not module.check_mode: # Migrate VM and get Task object back task_object = migrate_vm(vm_object=vm_object, host_object=host_object) # Wait for task to complete wait_for_task(task_object) # If task was a success the VM has moved, update running_host and complete module if task_object.info.state == vim.TaskInfo.State.success: vm_object = find_vm_by_name(content=content, vm_name=module.params['vm_name']) result['running_host'] = vm_object.runtime.host.name result['changed'] = True module.exit_json(**result) else: if task_object.info.error is None: module.fail_json(msg='Unable to migrate VM due to an error, please check vCenter') else: module.fail_json(msg='Unable to migrate VM due to an error: %s' % task_object.info.error) else: # If we are in check mode return a result as if move was performed result['running_host'] = module.params['destination_host'] result['changed'] = True module.exit_json(**result)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( datacenter_name=dict(required=True, type='str'), state=dict(default='present', choices=['present', 'absent'], type='str') ) ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_datacenter_mgr = VmwareDatacenterManager(module) vmware_datacenter_mgr.ensure()
def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict(local_user_name=dict(required=True, type='str'), local_user_password=dict(type='str', no_log=True), local_user_description=dict(type='str'), state=dict(default='present', choices=['present', 'absent'], type='str'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) vmware_local_user_manager = VMwareLocalUserManager(module) vmware_local_user_manager.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict(vm_name=dict(required=True, type='str'), dvportgroup_name=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') vmware_vmnic_migrate = VMwareVmVssDvsMigrate(module) vmware_vmnic_migrate.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict(local_role_name=dict(required=True, type='str'), local_privilege_ids=dict(default=[], type='list'), force_remove=dict(default=False, type='bool'), state=dict(default='present', choices=['present', 'absent'], type='str'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) vmware_local_role_manager = VMwareLocalRoleManager(module) vmware_local_role_manager.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( vm_type=dict(type='str', choices=['vm', 'all', 'template'], default='all'), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) vmware_vm_facts = VmwareVmFacts(module) _virtual_machines = vmware_vm_facts.get_all_virtual_machines() module.exit_json(changed=False, virtual_machines=_virtual_machines)
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', 'dns_name', 'vm_name']), vm_username=dict(type='str', required=True), vm_password=dict(type='str', no_log=True, required=True), directory=dict( type='dict', default=None, options=dict( path=dict(required=True, type='str'), operation=dict(required=True, type='str', choices=['create', 'delete']), recurse=dict(required=False, type='bool', default=False) ) ), copy=dict( type='dict', default=None, options=dict(src=dict(required=True, type='str'), dest=dict(required=True, type='str'), overwrite=dict(required=False, type='bool', default=False) ) ), fetch=dict( type='dict', default=None, options=dict( src=dict(required=True, type='str'), dest=dict(required=True, type='str'), ) ) ) ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False, required_if=[['vm_id_type', 'inventory_path', ['folder']]], mutually_exclusive=[['directory', 'copy', 'fetch']], required_one_of=[['directory', 'copy', 'fetch']], ) if module.params['vm_id_type'] == 'inventory_path' and not module.params['folder']: module.fail_json(msg='Folder is required parameter when vm_id_type is inventory_path') vmware_guest_file_manager = VmwareGuestFileManager(module)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( datacenter=dict(type='str'), cluster_name=dict(type='str') ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[ ['cluster_name', 'datacenter'], ], ) pyv = VmwreClusterFactsManager(module) pyv.gather_cluster_facts()
def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict(dest=dict(required=False, type='path'), esxi_hostname=dict(required=False, type='str'), src=dict(required=False, type='path'), state=dict(required=True, choices=['saved', 'absent', 'loaded'], type='str'))) required_if = [('state', 'saved', ['dest']), ('state', 'loaded', ['src'])] module = AnsibleModule(argument_spec=argument_spec, required_if=required_if, supports_check_mode=False) vmware_cfg_backup = VMwareConfigurationBackup(module) vmware_cfg_backup.process_state()
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'), 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']], ) 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: # If UUID is set, getvm select UUID, show error message accordingly. module.fail_json(msg="Unable to manage snapshots for non-existing VM %s" % (module.params.get('uuid') or module.params.get('name'))) 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(): argument_spec = vmware_argument_spec() argument_spec.update( cluster_name=dict(type='str', required=False), esxi_hostname=dict(type='str', required=False), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[ ['cluster_name', 'esxi_hostname'], ] ) host_vmnic_mgr = HostVmnicMgr(module) module.exit_json(changed=False, hosts_vmnics_facts=host_vmnic_mgr.gather_host_vmnic_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), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[ ['cluster_name', 'esxi_hostname'], ] ) vmware_dns_config = VmwareDnsFactsManager(module) module.exit_json(changed=False, hosts_dns_facts=vmware_dns_config.gather_dns_facts())
def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict(portgroup_name=dict(required=True, type='str'), switch_name=dict(required=True, type='str'), vlan_id=dict(required=True, type='int'), num_ports=dict(required=True, type='int'), portgroup_type=dict(required=True, choices=['earlyBinding', 'lateBinding', 'ephemeral'], type='str'), 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_dvs_portgroup = VMwareDvsPortgroup(module) vmware_dvs_portgroup.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( datacenter=dict(type='str', required=False), cluster_name=dict(type='str', required=False), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[ ['cluster_name', 'datacenter'], ] ) vmware_drs_facts = VmwareDrsFactManager(module) module.exit_json(changed=False, drs_rule_facts=vmware_drs_facts.gather_drs_rule_facts())
def main(): argument_spec = vmware_argument_spec() argument_spec.update(dict( switch=dict(type='str', required=True, aliases=['switch_name']), nics=dict(type='list', aliases=['nic_name'], default=[]), number_of_ports=dict(type='int', default=128), mtu=dict(type='int', default=1500), state=dict(type='str', default='present', choices=['absent', 'present'])), esxi_hostname=dict(type='str', aliases=['host']), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) host_virtual_switch = VMwareHostVirtualSwitch(module) host_virtual_switch.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( datacenter_name=dict(type='str', required=True), cluster_name=dict(type='str', required=True), esxi_hostname=dict(type='str', required=True), esxi_username=dict(type='str', required=False), esxi_password=dict(type='str', required=False, no_log=True), state=dict(default='present', choices=['present', 'absent', 'add_or_reconnect', 'reconnect'], type='str')) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_if=[ ['state', 'present', ['esxi_username', 'esxi_password']], ['state', 'add_or_reconnect', ['esxi_username', 'esxi_password']]]) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') vmware_host = VMwareHost(module) vmware_host.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( cluster_name=dict(type='str', required=False), esxi_hostname=dict(type='str', required=False), acceptance_level=dict(type='str', choices=[ 'community', 'partner', 'vmware_accepted', 'vmware_certified' ]), state=dict(type='str', choices=['list', 'present'], default='list'), ) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[ ['cluster_name', 'esxi_hostname'], ], required_if=[ ['state', 'present', ['acceptance_level']], ], supports_check_mode=True) vmware_host_accept_config = VMwareAccpetanceManager(module) vmware_host_accept_config.check_acceptance_state()
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( 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'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') 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( vm_name=dict(aliases=['vm']), vm_uuid=dict(aliases=['uuid']), destination_host=dict(aliases=['destination']), 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'], ], mutually_exclusive=[ ['vm_uuid', 'vm_name'], ], ) vmotion_manager = VmotionManager(module)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict(datacenter=dict(required=True, type='str'), folder=dict(required=True, type='str'), folder_type=dict(default='vm_folder', choices=['vm_folder', 'host_folder'], type='str'), force=dict(default='no', type='bool'), hostname=dict(required=True, type='str'), username=dict(required=True, type='str'), password=dict(required=True, type='str', no_log=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_folder = VMwareFolder(module) vmware_folder.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( datastore_name=dict(type='str', required=True), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=False, ) pyv = PyVmomiHelper(module) # get list of registered vms vms = pyv.get_vms() facts = [] for vm in vms: try: facts.append(pyv.gather_facts(vm)) except Exception as exc: module.fail_json(msg="Fact gather failed with exception %s" % to_text(exc)) module.exit_json(instance=facts)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), uuid=dict(type='str'), folder=dict(type='str'), datacenter=dict(type='str', required=True), disk=dict(type='list', default=[]), ) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[['name', 'uuid']]) 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: # We unable to find the virtual machine user specified # Bail out module.fail_json( msg="Unable to manage disks for non-existing" " virtual machine '%s'." % (module.params.get('uuid') or module.params.get('name'))) # VM exists try: pyv.ensure_disks(vm_obj=vm) except Exception as exc: module.fail_json(msg="Failed to manage disks for virtual machine" " '%s' with exception : %s" % (vm.name, to_native(exc)))
def main(): argument_spec = vmware_argument_spec() argument_spec.update( datacenter=dict(type='str', required=False, aliases=['datacenter_name']), cluster_name=dict(type='str', required=False), ) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[['cluster_name', 'datacenter']], mutually_exclusive=[['cluster_name', 'datacenter']], ) try: # Create instance of VmwareDrsGroupManager vmware_drs_group_info = VmwareDrsGroupInfoManager( module=module, datacenter_name=module.params.get('datacenter'), cluster_name=module.params.get('cluster_name', None)) vmware_drs_group_info.gather_info() # Set results results = dict(failed=False, drs_group_info=vmware_drs_group_info.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(datacenter_name=dict(type='str', required=True), datastore_name=dict(type='str', required=True), datastore_type=dict(type='str', choices=['nfs', 'vmfs']), nfs_server=dict(type='str'), nfs_path=dict(type='str'), nfs_ro=dict(type='bool', default=False), vmfs_device_name=dict(type='str'), vmfs_version=dict(type='int'), esxi_hostname=dict(type='str', required=True), state=dict(type='str', default='present', choices=['absent', 'present'])) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_together=[['nfs_server', 'nfs_path']], ) # more complex required_if if module.params['state'] == 'present': if module.params[ 'datastore_type'] == 'nfs' and not module.params['nfs_server']: msg = "Missing nfs_server with datastore_type = nfs" module.fail_json(msg=msg) if module.params['datastore_type'] == 'vmfs' and not module.params[ 'vmfs_device_name']: msg = "Missing vmfs_device_name with datastore_type = vmfs" module.fail_json(msg=msg) vmware_host_datastore = VMwareHostDatastore(module) vmware_host_datastore.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( name=dict(type='str'), name_match=dict(type='str', default='first'), uuid=dict(type='str'), folder=dict(type='str', default='/vm'), datacenter=dict(type='str', required=True), ) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[['name', 'uuid']]) # 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.getvm(name=module.params['name'], folder=module.params['folder'], uuid=module.params['uuid']) # VM already exists if vm: try: module.exit_json(instance=pyv.gather_facts(vm)) except Exception as exc: module.fail_json(msg="Fact gather failed with exception %s" % to_text(exc)) else: msg = "Unable to gather facts for non-existing VM " if module.params['name']: msg += "%(name)s" % module.params elif module.params['uuid']: msg += "%(uuid)s" % module.params module.fail_json(msg=msg)
def main(): """Main""" argument_spec = vmware_argument_spec() argument_spec.update( database=dict( type='dict', options=dict( max_connections=dict(type='int', default=50), task_cleanup=dict(type='bool', default=True), task_retention=dict(type='int', default=30), event_cleanup=dict(type='bool', default=True), event_retention=dict(type='int', default=30), ), default=dict( max_connections=50, task_cleanup=True, task_retention=30, event_cleanup=True, event_retention=30, ), ), runtime_settings=dict( type='dict', options=dict( unique_id=dict(type='int'), managed_address=dict(type='str'), vcenter_server_name=dict(type='str'), ), ), user_directory=dict( type='dict', options=dict( timeout=dict(type='int', default=60), query_limit=dict(type='bool', default=True), query_limit_size=dict(type='int', default=5000), validation=dict(type='bool', default=True), validation_period=dict(type='int', default=1440), ), default=dict( timeout=60, query_limit=True, query_limit_size=5000, validation=True, validation_period=1440, ), ), mail=dict( type='dict', options=dict( server=dict(type='str'), sender=dict(type='str'), ), default=dict( server='', sender='', ), ), snmp_receivers=dict( type='dict', options=dict( snmp_receiver_1_url=dict(type='str', default='localhost'), snmp_receiver_1_enabled=dict(type='bool', default=True), snmp_receiver_1_port=dict(type='int', default=162), snmp_receiver_1_community=dict(type='str', default='public'), snmp_receiver_2_url=dict(type='str', default=''), snmp_receiver_2_enabled=dict(type='bool', default=False), snmp_receiver_2_port=dict(type='int', default=162), snmp_receiver_2_community=dict(type='str', default=''), snmp_receiver_3_url=dict(type='str', default=''), snmp_receiver_3_enabled=dict(type='bool', default=False), snmp_receiver_3_port=dict(type='int', default=162), snmp_receiver_3_community=dict(type='str', default=''), snmp_receiver_4_url=dict(type='str', default=''), snmp_receiver_4_enabled=dict(type='bool', default=False), snmp_receiver_4_port=dict(type='int', default=162), snmp_receiver_4_community=dict(type='str', default=''), ), default=dict( snmp_receiver_1_url='localhost', snmp_receiver_1_enabled=True, snmp_receiver_1_port=162, snmp_receiver_1_community='public', snmp_receiver_2_url='', snmp_receiver_2_enabled=False, snmp_receiver_2_port=162, snmp_receiver_2_community='', snmp_receiver_3_url='', snmp_receiver_3_enabled=False, snmp_receiver_3_port=162, snmp_receiver_3_community='', snmp_receiver_4_url='', snmp_receiver_4_enabled=False, snmp_receiver_4_port=162, snmp_receiver_4_community='', ), ), timeout_settings=dict( type='dict', options=dict( normal_operations=dict(type='int', default=30), long_operations=dict(type='int', default=120), ), default=dict( normal_operations=30, long_operations=120, ), ), logging_options=dict( default='info', choices=['none', 'error', 'warning', 'info', 'verbose', 'trivia']), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) host_snmp = VmwareVcenterSettings(module) host_snmp.ensure()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( vm_name=dict(required=True, aliases=['vm'], type='str'), destination_host=dict(required=True, aliases=['destination'], 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') content = connect_to_api(module=module) vm_object = find_vm_by_name(content=content, vm_name=module.params['vm_name']) host_object = find_hostsystem_by_name( content=content, hostname=module.params['destination_host']) # Setup result result = {'changed': False} # Check if we could find the VM or Host if not vm_object: module.fail_json(msg='Cannot find virtual machine') if not host_object: module.fail_json(msg='Cannot find host') # Make sure VM isn't already at the destination if vm_object.runtime.host.name == module.params['destination_host']: module.exit_json(**result) if not module.check_mode: # Migrate VM and get Task object back task_object = migrate_vm(vm_object=vm_object, host_object=host_object) # Wait for task to complete wait_for_task(task_object) # If task was a success the VM has moved, update running_host and complete module if task_object.info.state == vim.TaskInfo.State.success: vm_object = find_vm_by_name(content=content, vm_name=module.params['vm_name']) result['running_host'] = vm_object.runtime.host.name result['changed'] = True module.exit_json(**result) else: if task_object.info.error is None: module.fail_json( msg= 'Unable to migrate VM due to an error, please check vCenter' ) else: module.fail_json( msg='Unable to migrate VM due to an error: %s' % task_object.info.error) else: # If we are in check mode return a result as if move was performed result['running_host'] = module.params['destination_host'] result['changed'] = True module.exit_json(**result)
def main(): argument_spec = vmware_argument_spec() module = AnsibleModule(argument_spec=argument_spec) vmware_local_user_facts = VMwareUserFactsManager(module) vmware_local_user_facts.gather_user_facts()
def main(): argument_spec = vmware_argument_spec() argument_spec.update(display_name=dict(required=True, type='str'), mtu=dict(required=False, type='int'), teaming=dict(required=True, type='dict', name=dict(required=True, type='str'), policy=dict(required=True, type='str'), standby_list=dict(required=False, type='list'), active_list=dict(required=True, type='list')), transport_vlan=dict(required=False, type='int'), named_teamings=dict(required=False, type='list'), lags=dict(required=False, type='list'), resource_type=dict( required=True, type='str', choices=['UplinkHostSwitchProfile']), state=dict(reauired=True, choices=['present', 'absent'])) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) profile_params = get_profile_params(module.params.copy()) state = module.params['state'] mgr_hostname = module.params['hostname'] mgr_username = module.params['username'] mgr_password = module.params['password'] validate_certs = module.params['validate_certs'] display_name = module.params['display_name'] manager_url = 'https://{}/api/v1'.format(mgr_hostname) host_switch_profile_dict = get_uplink_profile_from_display_name( module, manager_url, mgr_username, mgr_password, validate_certs, display_name) host_switch_profile_id, revision = None, None if host_switch_profile_dict: host_switch_profile_id = host_switch_profile_dict['id'] revision = host_switch_profile_dict['_revision'] if state == 'present': headers = dict(Accept="application/json") headers['Content-Type'] = 'application/json' updated = check_for_update(module, manager_url, mgr_username, mgr_password, validate_certs, profile_params) if not updated: # add the block if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(profile_params)), id='12345') request_data = json.dumps(profile_params) try: if host_switch_profile_id: module.exit_json( changed=False, id=host_switch_profile_id, message= "Uplink profile with display_name %s already exist." % module.params['display_name']) (rc, resp) = request(manager_url + '/host-switch-profiles', data=request_data, headers=headers, method='POST', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs, ignore_errors=True) except Exception as err: module.fail_json( msg= "Failed to add host profile. Request body [%s]. Error[%s]." % (request_data, to_native(err))) time.sleep(5) module.exit_json( changed=True, id=resp["id"], body=str(resp), message="host profile with display name %s created." % module.params['display_name']) else: if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(profile_params)), id=host_switch_profile_id) profile_params['_revision'] = revision # update current revision request_data = json.dumps(profile_params) id = host_switch_profile_id try: (rc, resp) = request(manager_url + '/host-switch-profiles/%s' % id, data=request_data, headers=headers, method='PUT', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs, ignore_errors=True) except Exception as err: module.fail_json( msg= "Failed to update host profile with id %s. Request body [%s]. Error[%s]." % (id, request_data, to_native(err))) time.sleep(5) module.exit_json(changed=True, id=resp["id"], body=str(resp), message="host profile with id %s updated." % id) elif state == 'absent': # delete the array id = host_switch_profile_id if id is None: module.exit_json( changed=False, msg='No host switch profile exist with display name %s' % display_name) if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(profile_params)), id=id) try: (rc, resp) = request(manager_url + "/host-switch-profiles/%s" % id, method='DELETE', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs) except Exception as err: module.fail_json( msg="Failed to delete host profile with id %s. Error[%s]." % (id, to_native(err))) time.sleep(5) module.exit_json(changed=True, object_name=id, message="host profile with id %s deleted." % id)
def main(): argument_spec = vmware_argument_spec() argument_spec.update(display_name=dict(required=True, type='str'), description=dict(required=False, type='str'), resource_type=dict(required=False, choices=['TransportNode']), host_switch_spec=dict( required=False, type='dict', host_switches=dict(required=True, type='list'), resource_type=dict(required=True, type='str')), fabric_node_name=dict(required=True, type='str'), host_switches=dict(required=False, type='list'), transport_zone_endpoints=dict(required=False, type='list'), state=dict(reauired=True, choices=['present', 'absent'])) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) transport_node_params = get_transport_node_params(module.params.copy()) state = module.params['state'] mgr_hostname = module.params['hostname'] mgr_username = module.params['username'] mgr_password = module.params['password'] validate_certs = module.params['validate_certs'] display_name = module.params['display_name'] manager_url = 'https://{}/api/v1'.format(mgr_hostname) transport_node_dict = get_tn_from_display_name(module, manager_url, mgr_username, mgr_password, validate_certs, display_name) transport_node_id, revision = None, None if transport_node_dict: transport_node_id = transport_node_dict['id'] revision = transport_node_dict['_revision'] if state == 'present': body = update_params_with_id(module, manager_url, mgr_username, mgr_password, validate_certs, transport_node_params) updated = check_for_update(module, manager_url, mgr_username, mgr_password, validate_certs, body) headers = dict(Accept="application/json") headers['Content-Type'] = 'application/json' if not updated: # add the node if module.check_mode: module.exit_json(changed=True, debug_out=str( json.dumps(logical_switch_params)), id='12345') request_data = json.dumps(body) try: if not transport_node_id: transport_node_id = get_id_from_display_name( module, manager_url, mgr_username, mgr_password, validate_certs, '/transport-nodes', display_name, exit_if_not_found=False) if transport_node_id: module.exit_json( changed=False, id=transport_node_id, message= "Transport node with display_name %s already exist." % module.params['display_name']) (rc, resp) = request(manager_url + '/transport-nodes', data=request_data, headers=headers, method='POST', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs, ignore_errors=True) except Exception as err: module.fail_json( msg= "Failed to add transport node. Request body [%s]. Error[%s]." % (request_data, to_native(err))) wait_till_create(resp['id'], module, manager_url, mgr_username, mgr_password, validate_certs) time.sleep(5) module.exit_json( changed=True, id=resp["id"], body=str(resp), message="Transport node with display name %s created." % module.params['display_name']) else: if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(body)), id=transport_node_id) body['_revision'] = revision # update current revision request_data = json.dumps(body) id = transport_node_id try: (rc, resp) = request(manager_url + '/transport-nodes/%s' % id, data=request_data, headers=headers, method='PUT', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs, ignore_errors=True) except Exception as err: module.fail_json( msg= "Failed to update transport node with id %s. Request body [%s]. Error[%s]." % (id, request_data, to_native(err))) time.sleep(5) module.exit_json( changed=True, id=resp["id"], body=str(resp), message="Transport node with node id %s updated." % id) elif state == 'absent': # delete the array id = transport_node_id if id is None: module.exit_json( changed=False, msg='No transport node exist with display name %s' % display_name) if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(transport_node_params)), id=id) try: (rc, resp) = request(manager_url + "/transport-nodes/%s" % id, method='DELETE', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs) except Exception as err: module.fail_json( msg="Failed to delete transport node with id %s. Error[%s]." % (id, to_native(err))) wait_till_delete(id, module, manager_url, mgr_username, mgr_password, validate_certs) time.sleep(5) module.exit_json(changed=True, object_name=id, message="Transport node with node id %s deleted." % id)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict(hostname=dict(required=False, aliases=['host']), username=dict(required=False, aliases=['login']), src=dict(required=True, aliases=['name']), datacenter=dict(required=False), datastore=dict(required=True), dest=dict(required=True, aliases=['path']), timeout=dict(default=10, type='int'))) module = AnsibleModule( argument_spec=argument_spec, # Implementing check-mode using HEAD is impossible, since size/date is not 100% reliable supports_check_mode=False, ) if module.params.get('host'): module.deprecate("The 'host' option is being replaced by 'hostname'", version='2.12') if module.params.get('login'): module.deprecate("The 'login' option is being replaced by 'username'", version='2.12') hostname = module.params['hostname'] username = module.params['username'] password = module.params.get('password') src = module.params.get('src') datacenter = module.params.get('datacenter') datastore = module.params.get('datastore') dest = module.params.get('dest') validate_certs = module.params.get('validate_certs') timeout = module.params.get('timeout') try: fd = open(src, "rb") atexit.register(fd.close) except Exception as e: module.fail_json(msg="Failed to open src file %s" % to_native(e)) if os.stat(src).st_size == 0: data = '' else: data = mmap.mmap(fd.fileno(), 0, access=mmap.ACCESS_READ) atexit.register(data.close) remote_path = vmware_path(datastore, datacenter, dest) if not all([hostname, username, password]): module.fail_json( msg= "One of following parameter is missing - hostname, username, password" ) url = 'https://%s%s' % (hostname, remote_path) headers = { "Content-Type": "application/octet-stream", "Content-Length": str(len(data)), } try: r = open_url(url, data=data, headers=headers, method='PUT', timeout=timeout, url_username=username, url_password=password, validate_certs=validate_certs, force_basic_auth=True) except socket.error as e: if isinstance(e.args, tuple): if len(e.args) > 0: if e[0] == errno.ECONNRESET: # VSphere resets connection if the file is in use and cannot be replaced module.fail_json( msg='Failed to upload, image probably in use', status=None, errno=e[0], reason=to_native(e), url=url) else: module.fail_json(msg=to_native(e)) else: module.fail_json(msg=str(e), status=None, errno=e[0], reason=str(e), url=url, exception=traceback.format_exc()) except Exception as e: error_code = -1 try: if isinstance(e[0], int): error_code = e[0] except (KeyError, TypeError): pass module.fail_json(msg=to_native(e), status=None, errno=error_code, reason=to_native(e), url=url, exception=traceback.format_exc()) status = r.getcode() if 200 <= status < 300: module.exit_json(changed=True, status=status, reason=r.msg, url=url) else: length = r.headers.get('content-length', None) if r.headers.get('transfer-encoding', '').lower() == 'chunked': chunked = 1 else: chunked = 0 module.fail_json(msg='Failed to upload', errno=None, status=status, reason=r.msg, length=length, headers=dict(r.headers), chunked=chunked, url=url)
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() argument_spec.update(display_name=dict(required=True, type='str'), credential=dict(required=False, type='dict', username=dict(required=False, type='str'), password=dict(required=False, type='str', no_log=True), thumbprint=dict(required=False, type='str', no_log=True), asymmetric_credential=dict(required=False, type='str'), credential_verifier=dict(required=False, type='str'), credential_key=dict(required=False, type='str', no_log=True), credential_type=dict(required=True, type='str')), origin_type=dict(required=True, type='str'), server=dict(required=True, type='str'), state=dict(reauired=True, choices=['present', 'absent'])) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) fabric_compute_manager_params = get_fabric_compute_manager_params(module.params.copy()) state = module.params['state'] mgr_hostname = module.params['hostname'] mgr_username = module.params['username'] mgr_password = module.params['password'] validate_certs = module.params['validate_certs'] display_name = module.params['display_name'] manager_url = 'https://{}/api/v1'.format(mgr_hostname) if not fabric_compute_manager_params['credential'].__contains__('thumbprint'): fabric_compute_manager_params['credential']['thumbprint'] = get_thumb(module) compute_manager_dict = get_compute_manager_from_display_name (module, manager_url, mgr_username, mgr_password, validate_certs, display_name) compute_manager_id, revision = None, None if compute_manager_dict: compute_manager_id = compute_manager_dict['id'] revision = compute_manager_dict['_revision'] if state == 'present': headers = dict(Accept="application/json") headers['Content-Type'] = 'application/json' updated = check_for_update(module, manager_url, mgr_username, mgr_password, validate_certs, fabric_compute_manager_params) if not updated: # add the compute_manager request_data = json.dumps(fabric_compute_manager_params) if module.check_mode: module.exit_json(changed=True, debug_out=str(request_data), id='12345') try: if compute_manager_id: module.exit_json(changed=False, id=compute_manager_id, message="Compute manager with display_name %s already exist."% module.params['display_name']) (rc, resp) = request(manager_url+ '/fabric/compute-managers', data=request_data, headers=headers, method='POST', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs, ignore_errors=True) except Exception as err: module.fail_json(msg="Failed to add compute_manager. Request body [%s]. Error[%s]." % (request_data, to_native(err))) wait_till_create(resp['id'], module, manager_url, mgr_username, mgr_password, validate_certs) module.exit_json(changed=True, id=resp["id"], body= str(resp), message="fabric compute manager with ip %s created." % module.params['server']) else: if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(fabric_compute_manager_params)), id=compute_manager_id) fabric_compute_manager_params['_revision'] = revision # update current revision request_data = json.dumps(fabric_compute_manager_params) id = compute_manager_id try: (rc, resp) = request(manager_url+ '/fabric/compute-managers/%s' % id, data=request_data, headers=headers, method='PUT', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs, ignore_errors=True) except Exception as err: module.fail_json(msg="Failed to update compute_manager with id %s. Request body [%s]. Error[%s]." % (id, request_data, to_native(err))) module.exit_json(changed=True, id=resp["id"], body= str(resp), message="fabric compute manager with compute manager id %s updated." % id) elif state == 'absent': # delete the array id = compute_manager_id if id is None: module.exit_json(changed=False, msg='No compute manager exist with display_name %s' % display_name) if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(fabric_compute_manager_params)), id=id) try: (rc, resp) = request(manager_url + "/fabric/compute-managers/%s" % id, method='DELETE', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs) except Exception as err: module.fail_json(msg="Failed to delete fabric compute manager with id %s. Error[%s]." % (id, to_native(err))) wait_till_delete(id, module, manager_url, mgr_username, mgr_password, validate_certs) module.exit_json(changed=True, id=id, message="fabric compute manager with compute manager id %s deleted." % id)
def main(): argument_spec = vmware_argument_spec() argument_spec.update(display_name=dict(required=True, type='str'), replication_mode=dict(required=False, type='str'), extra_configs=dict(required=False, type='list'), uplink_teaming_policy_name=dict(required=False, type='str'), transport_zone_name=dict(required=True, type='str'), ip_pool_name=dict(required=False, type='str'), vlan=dict(required=False, type='int'), mac_pool_id=dict(required=False, type='str'), vni=dict(required=False, type='int'), vlan_trunk_spec=dict(required=False, type='dict', vlan_ranges=dict(required=True, type='list')), admin_state=dict(required=True, type='str'), address_bindings=dict(required=False, type='list'), switching_profiles=dict(required=False, type='list'), lswitch_id=dict(required=False, type='str'), state=dict(reauired=True, choices=['present', 'absent'])) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) logical_switch_params = get_logical_switch_params(module.params.copy()) state = module.params['state'] mgr_hostname = module.params['hostname'] mgr_username = module.params['username'] mgr_password = module.params['password'] validate_certs = module.params['validate_certs'] display_name = module.params['display_name'] manager_url = 'https://{}/api/v1'.format(mgr_hostname) changed = True lswitch_dict = get_lswitch_from_display_name (module, manager_url, mgr_username, mgr_password, validate_certs, display_name) lswitch_id, revision = None, None if lswitch_dict: lswitch_id = lswitch_dict['id'] revision = lswitch_dict['_revision'] if state == 'present': body = update_params_with_id(module, manager_url, mgr_username, mgr_password, validate_certs, logical_switch_params) updated = check_for_update(module, manager_url, mgr_username, mgr_password, validate_certs, body) headers = dict(Accept="application/json") headers['Content-Type'] = 'application/json' if lswitch_id is None: # add the logical_switch if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(body)), id=lswitch_id) request_data = json.dumps(body) try: if lswitch_id: module.exit_json(changed=False, id=lswitch_id, message="Logical switch with display_name %s already exist."% module.params['display_name']) (rc, resp) = request(manager_url+ '/logical-switches', data=request_data, headers=headers, method='POST', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs, ignore_errors=True) except Exception as err: module.fail_json(msg="Failed to add logical switch. Request body [%s]. Error[%s]." % (request_data, to_native(err))) time.sleep(5) module.exit_json(changed=True, id=resp["id"], body= str(resp), message="Logical switch with display name %s created." % module.params['display_name']) else: if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(body)), id=lswitch_id) body['_revision'] = revision # update current revision request_data = json.dumps(body) id = lswitch_id try: (rc, resp) = request(manager_url+ '/logical-switches/%s' % id, data=request_data, headers=headers, method='PUT', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs, ignore_errors=True) except Exception as err: module.fail_json(msg="Failed to update logical switch with id %s. Request body [%s]. Error[%s]." % (id, request_data, to_native(err))) time.sleep(5) module.exit_json(changed=True, id=resp["id"], body= str(resp), message="logical switch with lswitch id %s updated." % id) elif state == 'absent': # delete the array id = lswitch_id if id is None: module.exit_json(changed=False, msg='No logical switch exist with display name %s' % display_name) if module.check_mode: module.exit_json(changed=True, debug_out=str(json.dumps(logical_switch_params)), id=id) try: (rc, resp) = request(manager_url + "/logical-switches/%s" % id, method='DELETE', url_username=mgr_username, url_password=mgr_password, validate_certs=validate_certs) except Exception as err: module.fail_json(msg="Failed to delete logical switch with id %s. Error[%s]." % (id, to_native(err))) time.sleep(5) module.exit_json(changed=True, object_name=id, message="Logical switch with zone id %s deleted." % id)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( portgroup_name=dict(required=True, type='str'), switch_name=dict(required=True, type='str'), vlan_id=dict(required=True, type='int'), hosts=dict(type='list', aliases=['esxi_hostname']), cluster_name=dict(type='str'), state=dict(type='str', choices=['present', 'absent'], default='present'), network_policy=dict(type='dict', options=dict( promiscuous_mode=dict(type='bool'), forged_transmits=dict(type='bool'), mac_changes=dict(type='bool'), ), default=dict( promiscuous_mode=False, forged_transmits=False, mac_changes=False, )), teaming_policy=dict( type='dict', options=dict(inbound_policy=dict(type='bool', default=False), notify_switches=dict(type='bool', default=True), rolling_order=dict(type='bool', default=False), load_balance_policy=dict( type='str', default='loadbalance_srcid', choices=[ 'loadbalance_ip', 'loadbalance_srcmac', 'loadbalance_srcid', 'failover_explicit', ], )), default=dict( inbound_policy=False, notify_switches=True, rolling_order=False, load_balance_policy='loadbalance_srcid', ), ), )) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False, required_one_of=[ ['cluster_name', 'hosts'], ]) try: pyv = PyVmomiHelper(module) pyv.process_state() except vmodl.RuntimeFault as runtime_fault: module.fail_json(msg=to_native(runtime_fault.msg)) except vmodl.MethodFault as method_fault: module.fail_json(msg=to_native(method_fault.msg)) except Exception as e: module.fail_json(msg=to_native(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', 'dns_name', 'vm_name']), vm_username=dict(type='str', required=True), vm_password=dict(type='str', no_log=True, required=True), directory=dict( type='dict', default=None, options=dict( path=dict(required=True, type='str'), operation=dict(required=True, type='str', choices=['create', 'delete']), recurse=dict(required=False, type='bool', default=False) )), copy=dict( type='dict', default=None, options=dict( src=dict(required=True, type='str'), dest=dict(required=True, type='str'), overwrite=dict(required=False, type='bool', default=False) )), fetch=dict( type='dict', default=None, options=dict(src=dict(required=True, type='str'), dest=dict(required=True, type='str'), )) )) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False, required_if=[['vm_id_type', 'inventory_path', ['folder']]], mutually_exclusive=[['directory', 'copy', 'fetch']], required_one_of=[['directory', 'copy', 'fetch']], ) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') if module.params['vm_id_type'] == 'inventory_path' and not module.params['folder']: module.fail_json(msg='Folder is required parameter when vm_id_type is inventory_path') datacenter_name = module.params['datacenter'] cluster_name = module.params['cluster'] folder = module.params['folder'] content = connect_to_api(module) datacenter = None if datacenter_name: datacenter = find_datacenter_by_name(content, datacenter_name) if not datacenter: module.fail_json(msg="Unable to find %(datacenter)s datacenter" % module.params) cluster = None if cluster_name: cluster = find_cluster_by_name(content, cluster_name, datacenter) if not cluster: module.fail_json(msg="Unable to find %(cluster)s cluster" % module.params) if module.params['vm_id_type'] == 'inventory_path': vm = find_vm_by_id(content, vm_id=module.params['vm_id'], vm_id_type="inventory_path", folder=folder) else: vm = find_vm_by_id(content, vm_id=module.params['vm_id'], vm_id_type=module.params['vm_id_type'], datacenter=datacenter, cluster=cluster) if not vm: module.fail_json(msg='Unable to find virtual machine.') try: if module.params['directory']: result = directory(module, content, vm) if module.params['copy']: result = copy(module, content, vm) if module.params['fetch']: result = fetch(module, content, vm) module.exit_json(**result) 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=to_native(e))
def main(): """Main""" argument_spec = vmware_argument_spec() argument_spec.update(dict( esxi_hostname=dict(required=True, type='str'), portgroup_name=dict(required=True, type='str', aliases=['portgroup']), mtu=dict(required=False, type='int', default=1500), device=dict(type='str'), enable_vsan=dict(required=False, type='bool', default=False), enable_vmotion=dict(required=False, type='bool', default=False), enable_mgmt=dict(required=False, type='bool', default=False), enable_ft=dict(required=False, type='bool', default=False), enable_provisioning=dict(type='bool', default=False), enable_replication=dict(type='bool', default=False), enable_replication_nfc=dict(type='bool', default=False), vswitch_name=dict(required=False, type='str', aliases=['vswitch']), dvswitch_name=dict(required=False, type='str', aliases=['dvswitch']), network=dict( type='dict', options=dict( type=dict(type='str', default='static', choices=['static', 'dhcp']), ip_address=dict(type='str'), subnet_mask=dict(type='str'), default_gateway=dict(type='str'), tcpip_stack=dict(type='str', default='default', choices=['default', 'provisioning', 'vmotion', 'vxlan']), ), default=dict( type='static', tcpip_stack='default', ), ), state=dict( type='str', default='present', choices=['absent', 'present'] ), )) module = AnsibleModule(argument_spec=argument_spec, mutually_exclusive=[ ['vswitch_name', 'dvswitch_name'], ['tcpip_stack', 'enable_vsan'], ['tcpip_stack', 'enable_vmotion'], ['tcpip_stack', 'enable_mgmt'], ['tcpip_stack', 'enable_ft'], ['tcpip_stack', 'enable_provisioning'], ['tcpip_stack', 'enable_replication'], ['tcpip_stack', 'enable_replication_nfc'], ], required_one_of=[ ['vswitch_name', 'dvswitch_name'], ['portgroup_name', 'device'], ], required_if=[ ['state', 'present', ['portgroup_name']], ['state', 'absent', ['device']] ], supports_check_mode=True) pyv = PyVmomiHelper(module) pyv.ensure()
def main(): argument_spec = vmware_argument_spec() argument_spec.update({ 'name': {}, 'datastore': { 'default': 'datastore1', }, 'datacenter': { 'default': 'ha-datacenter', }, 'deployment_option': { 'default': None, }, 'folder': { 'default': None, }, 'resource_pool': { 'default': 'Resources', }, 'networks': { 'default': { 'VM Network': 'VM Network', }, 'type': 'dict', }, 'ovf': { 'type': path_exists, 'aliases': ['ova'], }, 'disk_provisioning': { 'choices': [ 'flat', 'eagerZeroedThick', 'monolithicSparse', 'twoGbMaxExtentSparse', 'twoGbMaxExtentFlat', 'thin', 'sparse', 'thick', 'seSparse', 'monolithicFlat' ], 'default': 'thin', }, 'power_on': { 'type': 'bool', 'default': True, }, 'properties': { 'type': 'dict', }, 'wait': { 'type': 'bool', 'default': True, }, 'wait_for_ip_address': { 'type': 'bool', 'default': False, }, 'allow_duplicates': { 'type': 'bool', 'default': True, }, 'fail_on_spec_warnings': { 'type': 'bool', 'default': False, }, }) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi python library not found') deploy_ovf = VMwareDeployOvf(module) deploy_ovf.upload() deploy_ovf.complete() facts = deploy_ovf.power_on() module.exit_json(instance=facts, changed=True)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( disk_provisioning=dict(type='str', default='thin', choices=[ 'flat', 'eagerZeroedThick', 'monolithicSparse', 'twoGbMaxExtentSparse', 'twoGbMaxExtentFlat', 'thin', 'sparse', 'thick', 'seSparse', 'monolithicFlat' ]), name=dict(type='str', required=True), datacenter=dict(type='str', default='ha-datacenter'), datastore=dict(type='str', default='datastore1'), resource_pool=dict(type='str', default='Resources'), name_match=dict(type='str', choices=['first', 'last'], default='first'), networks=dict(type='list', default=[]), property_map=dict(type='dict', default={}), deployment_option=dict(type='str', default=None), uuid=dict(type='str'), folder=dict(type='str', default='/vm'), ovf_networks=dict(type='dict', default={'VM Network': 'VM Network'}), ovf=dict(type=path_exists), force=dict(type='bool', default=False), power_on=dict(type='bool', default=True), wait=dict(type='bool', default=True), wait_for_ip_address=dict(type='bool', default=True), guest_id=dict(type='str'), customization=dict(type='dict', default={}, no_log=True), ) module = AnsibleModule(argument_spec=argument_spec, ) if not module.params['power_on'] and (module.params['wait_for_ip_address'] or module.params['wait']): module.fail_json(msg='Cannot wait for VM when power_on=False') if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi python library not found') pyv_ovf = PyVmomi(module) pyv_vmomihelper = PyVmomiHelper(module) vm_ovf = pyv_ovf.get_vm() #vm_find = find_vm_by_name() #vm_ovf_helper = pyv_vmomihelper.get_vm() deploy_ovf = VMwareDeployOvf(module) deploy_ovf_PyVmH = PyVmomiHelper(module) vm = deploy_ovf.get_vm_obj() if vm: if vm.runtime.powerState != 'poweredOff': if module.params['force']: set_vm_power_state(deploy_ovf_PyVmH.content, vm, 'poweredoff', module.params['force']) else: module.fail_json( msg= "Virtual Machine is Powered ON. Please Power Off the VM or use force to power it off before doing any customizations." ) if module.params['networks'] or module.params['customization']: deploy_ovf_PyVmH.customize_vm(vm) myspec = deploy_ovf_PyVmH.customspec task = vm.CustomizeVM_Task(spec=myspec) facts = deploy_ovf.vm_power_on(vm) #wait_for_task(task) #task_power=vm.PowerOn() #wait_for_task(task_power) #facts=pyv_vmomihelper.gather_facts(vm) #cust=self.customspec #deploy_ovf_PyVmH.customize_vm(vm_obj=vm) #customspec = vim.vm.customization.Specification() else: module.fail_json( msg= "VM already exists in the vCenter..! Use networks or customization parameters to customize the existing VM" ) else: #deploy_ovf = VMwareDeployOvf(module) deploy_ovf.upload() deploy_ovf.complete() #facts = deploy_ovf.power_on() if module.params['networks'] or module.params['customization']: vm_deploy = deploy_ovf.get_vm_obj() deploy_ovf_PyVmH.customize_vm(vm_deploy) myspec = deploy_ovf_PyVmH.customspec task = vm_deploy.CustomizeVM_Task(spec=myspec) # custom_wait_for_task(task, module) try: wait_for_task(task) except Exception, e: module.fail_json(msg="Error:%s" % e.message.msg) if task.info.state == 'error': module.fail_json(msg="Error occured: %s" % to_native(task.info.error.msg)) try: facts = deploy_ovf.vm_power_on(vm_deploy) except Exception, e: module.fail_json(msg="Error from vCenter: %s" % (e.message))
def main(): """Main""" argument_spec = vmware_argument_spec() argument_spec.update(dict( settings=dict(type='list'), )) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) vcenter = VmwareVcenterSettings(module) option_manager = vcenter.content.setting """Manage settings for a vCenter server""" result = dict(changed=False, msg='') change_option_list = [] changed = False changed_list = [] # Check all general settings, except statistics for desired_setting in module.params.get("settings"): desired_setting_key = next(iter(desired_setting)) settingFound = False for current_setting in option_manager.setting: if desired_setting_key == current_setting.key: settingFound = True if desired_setting[desired_setting_key] != current_setting.value: changed = True changed_list.append(desired_setting_key) result[desired_setting_key] = desired_setting[desired_setting_key] change_option_list.append( vim.option.OptionValue(key=desired_setting_key, value=desired_setting[desired_setting_key]) ) if settingFound == False: module.warn("The setting %s has not been found on this vCenter - skipping." % str(desired_setting)) if changed: if module.check_mode: changed_suffix = ' would be changed' else: changed_suffix = ' changed' if len(changed_list) > 2: message = ', '.join(changed_list[:-1]) + ', and ' + str(changed_list[-1]) elif len(changed_list) == 2: message = ' and '.join(changed_list) elif len(changed_list) == 1: message = changed_list[0] message += changed_suffix if not module.check_mode: try: option_manager.UpdateOptions(changedValue=change_option_list) except (vmodl.fault.SystemError, vmodl.fault.InvalidArgument) as invalid_argument: module.fail_json( msg="Failed to update option(s) as one or more OptionValue contains an invalid value: %s" % to_native(invalid_argument.msg) ) except vim.fault.InvalidName as invalid_name: module.fail_json( msg="Failed to update option(s) as one or more OptionValue objects refers to a " "non-existent option : %s" % to_native(invalid_name.msg) ) else: message = "vCenter settings already configured properly" result['changed'] = changed result['msg'] = message module.exit_json(**result)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict(portgroup_name=dict(required=True, type='str'), switch_name=dict(required=True, type='str'), vlan_id=dict(required=True, type='str'), num_ports=dict(required=True, type='int'), portgroup_type=dict( required=True, choices=['earlyBinding', 'lateBinding', 'ephemeral'], type='str'), state=dict(required=True, choices=['present', 'absent'], type='str'), vlan_trunk=dict(type='bool', default=False), network_policy=dict(type='dict', options=dict(promiscuous=dict(type='bool', default=False), forged_transmits=dict( type='bool', default=False), mac_changes=dict(type='bool', default=False)), default=dict(promiscuous=False, forged_transmits=False, mac_changes=False)), teaming_policy=dict( type='dict', options=dict(inbound_policy=dict(type='bool', default=False), notify_switches=dict(type='bool', default=True), rolling_order=dict(type='bool', default=False), load_balance_policy=dict( type='str', default='loadbalance_srcid', choices=[ 'loadbalance_ip', 'loadbalance_srcmac', 'loadbalance_srcid', 'failover_explicit', ], )), default=dict( inbound_policy=False, notify_switches=True, rolling_order=False, load_balance_policy='loadbalance_srcid', ), ), port_policy=dict( type='dict', options=dict( block_override=dict(type='bool', default=True), ipfix_override=dict(type='bool', default=False), live_port_move=dict(type='bool', default=False), network_rp_override=dict(type='bool', default=False), port_config_reset_at_disconnect=dict(type='bool', default=True), security_override=dict(type='bool', default=False), shaping_override=dict(type='bool', default=False), traffic_filter_override=dict(type='bool', default=False), uplink_teaming_override=dict(type='bool', default=False), vendor_config_override=dict(type='bool', default=False), vlan_override=dict(type='bool', default=False)), default=dict(block_override=True, ipfix_override=False, live_port_move=False, network_rp_override=False, port_config_reset_at_disconnect=True, security_override=False, shaping_override=False, traffic_filter_override=False, uplink_teaming_override=False, vendor_config_override=False, vlan_override=False)))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_dvs_portgroup = VMwareDvsPortgroup(module) vmware_dvs_portgroup.process_state()
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( state=dict(type='str', default='present', choices=['absent', 'present']), vms=dict(type='list'), cluster_name=dict(type='str', required=True), drs_rule_name=dict(type='str', required=True), enabled=dict(type='bool', default=False), mandatory=dict(type='bool', default=False), affinity_rule=dict(type='bool', default=True), )) required_if = [ ['state', 'present', ['vms']], ] module = AnsibleModule(argument_spec=argument_spec, required_if=required_if, supports_check_mode=True) results = dict(failed=False, changed=False) state = module.params['state'] vm_drs = VmwareDrs(module) if state == 'present': # Add Rule if module.check_mode: results['changed'] = True module.exit_json(**results) changed, result = vm_drs.create() if changed: results['changed'] = changed else: results['failed'] = True results['msg'] = "Failed to create DRS rule %s" % vm_drs.rule_name results['result'] = result elif state == 'absent': # Delete Rule if module.check_mode: results['changed'] = True module.exit_json(**results) changed, result = vm_drs.delete() if changed: results['changed'] = changed results[ 'msg'] = "DRS rule %s deleted successfully." % vm_drs.rule_name else: if "No rule named" in result: results['msg'] = result module.exit_json(**results) results['failed'] = True results['msg'] = "Failed to delete DRS rule %s" % vm_drs.rule_name results['result'] = result if results['changed']: module.exit_json(**results) if results['failed']: module.fail_json(**results)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( state=dict(type='str', default='present', choices=['present', 'powered-off', 'powered-on', 'reboot-guest', 'restarted', 'shutdown-guest', 'suspended']), name=dict(type='str'), name_match=dict(type='str', choices=['first', 'last'], default='first'), uuid=dict(type='str'), folder=dict(type='str', default='/vm'), force=dict(type='bool', default=False), scheduled_at=dict(type='str'), ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False, mutually_exclusive=[ ['name', 'uuid'], ], ) result = dict(changed=False,) pyv = PyVmomi(module) # Check if the VM exists before continuing vm = pyv.get_vm() if vm: # VM already exists, so set power state scheduled_at = module.params.get('scheduled_at', None) if scheduled_at: if not pyv.is_vcenter(): module.fail_json(msg="Scheduling task requires vCenter, hostname %s " "is an ESXi server." % module.params.get('hostname')) powerstate = { 'powered-off': vim.VirtualMachine.PowerOff, 'powered-on': vim.VirtualMachine.PowerOn, 'reboot-guest': vim.VirtualMachine.RebootGuest, 'restarted': vim.VirtualMachine.Reset, 'shutdown-guest': vim.VirtualMachine.ShutdownGuest, 'suspended': vim.VirtualMachine.Suspend, } dt = '' try: dt = datetime.strptime(scheduled_at, '%d/%m/%Y %H:%M') except ValueError as e: module.fail_json(msg="Failed to convert given date and time string to Python datetime object," "please specify string in 'dd/mm/yyyy hh:mm' format: %s" % to_native(e)) schedule_task_spec = vim.scheduler.ScheduledTaskSpec() schedule_task_desc = 'Schedule task for vm %s for operation %s at %s' % (vm.name, module.params.get('state'), scheduled_at) schedule_task_spec.name = schedule_task_desc schedule_task_spec.description = schedule_task_desc schedule_task_spec.scheduler = vim.scheduler.OnceTaskScheduler() schedule_task_spec.scheduler.runAt = dt schedule_task_spec.action = vim.action.MethodAction() schedule_task_spec.action.name = powerstate[module.params.get('state')] schedule_task_spec.enabled = True try: pyv.content.scheduledTaskManager.CreateScheduledTask(vm, schedule_task_spec) # As this is async task, we create scheduled task and mark state to changed. module.exit_json(changed=True) except vim.fault.InvalidName as e: module.fail_json(msg="Failed to create scheduled task %s for %s : %s" % (module.params.get('state'), vm.name, to_native(e.msg))) except vim.fault.DuplicateName as e: module.exit_json(chanaged=False, details=to_native(e.msg)) except vmodl.fault.InvalidArgument as e: module.fail_json(msg="Failed to create scheduled task %s as specifications " "given are invalid: %s" % (module.params.get('state'), to_native(e.msg))) else: result = set_vm_power_state(pyv.content, vm, module.params['state'], module.params['force']) else: module.fail_json(msg="Unable to set power state for non-existing virtual machine : '%s'" % (module.params.get('uuid') or module.params.get('name'))) if result.get('failed') is True: module.fail_json(**result) module.exit_json(**result)
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', 'dns_name', 'vm_name']), vm_username=dict(type='str', required=True), vm_password=dict(type='str', no_log=True, required=True), directory=dict(type='dict', default=None, options=dict(operation=dict( required=True, type='str', choices=['create', 'delete', 'mktemp']), path=dict(required=False, type='str'), prefix=dict(required=False, type='str'), suffix=dict(required=False, type='str'), recurse=dict(required=False, type='bool', default=False))), copy=dict(type='dict', default=None, options=dict(src=dict(required=True, type='str'), dest=dict(required=True, type='str'), overwrite=dict(required=False, type='bool', default=False))), fetch=dict(type='dict', default=None, options=dict( src=dict(required=True, type='str'), dest=dict(required=True, type='str'), )))) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=False, required_if=[['vm_id_type', 'inventory_path', ['folder']]], mutually_exclusive=[['directory', 'copy', 'fetch']], required_one_of=[['directory', 'copy', 'fetch']], ) if module.params['directory']: if module.params['directory']['operation'] in ( 'create', 'delete') and not module.params['directory']['path']: module.fail_json( msg= 'directory.path is required when operation is "create" or "delete"' ) if module.params['directory']['operation'] == 'mktemp' and not ( module.params['directory']['prefix'] and module.params['directory']['suffix']): module.fail_json( msg= 'directory.prefix and directory.suffix are required when operation is "mktemp"' ) if module.params[ 'vm_id_type'] == 'inventory_path' and not module.params['folder']: module.fail_json( msg='Folder is required parameter when vm_id_type is inventory_path' ) vmware_guest_file_manager = VmwareGuestFileManager(module)