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)
