def main():
"""Main"""
argument_spec = vmware_argument_spec()
argument_spec.update(
ad_domain=dict(type="str",
default="",
aliases=["domain", "domain_name"]),
ad_user=dict(type="str", default=""),
ad_password=dict(type="str", default="", no_log=True),
ad_state=dict(default="absent",
choices=["present", "absent"],
aliases=["state"]),
esxi_hostname=dict(type="str", required=False),
cluster_name=dict(type="str", required=False),
)
module = AnsibleModule(
argument_spec=argument_spec,
required_one_of=[["cluster_name", "esxi_hostname"]],
required_if=[[
"ad_state", "present", ["ad_domain", "ad_user", "ad_password"]
]],
supports_check_mode=True,
)
ad_auth = VmwareHostAdAuthentication(module)
ad_auth.ensure()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
datacenter=dict(type="str", required=True,
aliases=["datacenter_name"]),
folder_name=dict(type="str", required=True),
parent_folder=dict(type="str", required=False),
state=dict(type="str",
choices=["present", "absent"],
default="present"),
folder_type=dict(
type="str",
default="vm",
choices=["datastore", "host", "network", "vm"],
required=False,
),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if len(module.params.get("folder_name")) > 79:
module.fail_json(
msg=
"Failed to manage folder as folder_name can only contain 80 characters."
)
vcenter_folder_mgr = VmwareFolderManager(module)
if not vcenter_folder_mgr.is_vcenter():
module.fail_json(
msg="Module vcenter_folder is meant for vCenter, hostname %s "
"is not vCenter server." % module.params.get("hostname"))
vcenter_folder_mgr.ensure()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type='str'),
uuid=dict(type='str'),
use_instance_uuid=dict(type='bool', default=False),
datacenter=dict(removed_in_version=2.9, type='str')
)
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[['name', 'uuid']],
mutually_exclusive=[['name', 'uuid']],
)
pyv = PyVmomiHelper(module)
# Check if the VM exists before continuing
folders = pyv.getvm_folder_paths()
# VM already exists
if folders:
try:
module.exit_json(folders=folders)
except Exception as exc:
module.fail_json(msg="Folder enumeration failed with exception %s" % to_native(exc))
else:
module.fail_json(msg="Unable to find folders for virtual machine %s" % (module.params.get('name') or
module.params.get('uuid')))
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(vmk_name=dict(required=True, type='str'),
ip_address=dict(required=True, type='str'),
subnet_mask=dict(required=True, type='str')))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
vmk_name = module.params['vmk_name']
ip_address = module.params['ip_address']
subnet_mask = module.params['subnet_mask']
try:
content = connect_to_api(module, False)
host = get_all_objs(content, [vim.HostSystem])
if not host:
module.fail_json(msg="Unable to locate Physical Host.")
host_system = list(host)[0]
changed = configure_vmkernel_ip_address(host_system, vmk_name,
ip_address, subnet_mask)
module.exit_json(changed=changed)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
module.fail_json(msg=method_fault.msg)
except Exception as e:
module.fail_json(msg=str(e))
def main():
"""Main"""
argument_spec = vmware_argument_spec()
argument_spec.update(
state=dict(
type="str",
default="disabled",
choices=["enabled", "disabled", "reset"],
),
snmp_port=dict(type="int", default=161),
community=dict(type="list", default=[]),
trap_targets=dict(type="list", default=list()),
trap_filter=dict(type="list"),
hw_source=dict(
type="str",
default="indications",
choices=["indications", "sensors"],
),
log_level=dict(
type="str",
default="info",
choices=["debug", "info", "warning", "error"],
),
send_trap=dict(type="bool", default=False),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
host_snmp = VmwareHostSnmp(module)
host_snmp.ensure()
def main():
"""Main"""
argument_spec = vmware_argument_spec()
argument_spec.update(
ad_domain=dict(type='str',
default='',
aliases=['domain', 'domain_name']),
ad_user=dict(type='str', default=''),
ad_password=dict(type='str', default='', no_log=True),
ad_state=dict(default='absent',
choices=['present', 'absent'],
aliases=['state']),
esxi_hostname=dict(type='str', required=False),
cluster_name=dict(type='str', required=False),
)
module = AnsibleModule(
argument_spec=argument_spec,
required_one_of=[
['cluster_name', 'esxi_hostname'],
],
required_if=[
['ad_state', 'present', ['ad_domain', 'ad_user', 'ad_password']],
],
supports_check_mode=True)
ad_auth = VmwareHostAdAuthentication(module)
ad_auth.ensure()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type="str"),
uuid=dict(type="str"),
moid=dict(type="str"),
folder=dict(type="str"),
datacenter=dict(type="str"),
esxi_hostname=dict(type="str"),
cluster=dict(type="str"),
local_path=dict(type="path"),
)
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[["name", "uuid", "moid"]])
pyv = PyVmomiHelper(module)
vm = pyv.get_vm()
if not vm:
vm_id = (module.params.get("uuid") or module.params.get("name")
or module.params.get("moid"))
module.fail_json(
msg="Unable to find the specified virtual machine : %s" % vm_id)
result = pyv.take_vm_screenshot()
if result["failed"]:
module.fail_json(**result)
else:
module.exit_json(**result)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type="str"),
uuid=dict(type="str"),
moid=dict(type="str"),
use_instance_uuid=dict(type="bool", default=False),
boot_order=dict(type="list", default=[]),
name_match=dict(choices=["first", "last"], default="first"),
boot_delay=dict(type="int", default=0),
enter_bios_setup=dict(type="bool", default=False),
boot_retry_enabled=dict(type="bool", default=False),
boot_retry_delay=dict(type="int", default=0),
secure_boot_enabled=dict(type="bool", default=False),
boot_firmware=dict(type="str", choices=["efi", "bios"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
required_one_of=[["name", "uuid", "moid"]],
mutually_exclusive=[["name", "uuid", "moid"]],
)
pyv = VmBootManager(module)
pyv.ensure()
def main():
spec = vmware_argument_spec()
spec.update(
dict(esxi_hostname=dict(type='str', required=True),
vsan=dict(
type='str',
choices=[
'ensureObjectAccessibility', 'evacuateAllData', 'noAction'
],
aliases=['vsan_mode'],
),
evacuate=dict(type='bool', default=False),
timeout=dict(default=0, type='int'),
state=dict(required=False,
default='present',
choices=['present', 'absent'])))
module = AnsibleModule(argument_spec=spec)
host_maintenance_mgr = VmwareMaintenanceMgr(module=module)
if module.params['state'] == 'present':
host_maintenance_mgr.EnterMaintenanceMode()
elif module.params['state'] == 'absent':
host_maintenance_mgr.ExitMaintenanceMode()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(name=dict(type='str'),
uuid=dict(type='str'),
moid=dict(type='str'),
folder=dict(type='str'),
datacenter=dict(type='str'),
esxi_hostname=dict(type='str'),
cluster=dict(type='str'),
keys_send=dict(type='list', default=[]),
string_send=dict(type='str'))
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[['name', 'uuid', 'moid']])
pyv = PyVmomiHelper(module)
vm = pyv.get_vm()
if not vm:
vm_id = (module.params.get('uuid') or module.params.get('name')
or module.params.get('moid'))
module.fail_json(
msg='Unable to find the specified virtual machine : %s ' % vm_id)
result = pyv.send_key_to_vm(vm)
if result['failed']:
module.fail_json(**result)
else:
module.exit_json(**result)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
vm_name=dict(aliases=["vm"]),
vm_uuid=dict(aliases=["uuid"]),
moid=dict(type="str"),
use_instance_uuid=dict(type="bool", default=False),
destination_host=dict(aliases=["destination"]),
destination_resourcepool=dict(aliases=["resource_pool"]),
destination_datastore=dict(aliases=["datastore"]),
)
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_one_of=[
["destination_host", "destination_datastore"],
["vm_uuid", "vm_name", "moid"],
],
mutually_exclusive=[["vm_uuid", "vm_name", "moid"]],
)
vmotion_manager = VmotionManager(module)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
cluster_name=dict(type="str", required=False),
esxi_hostname=dict(type="str", required=False),
rules=dict(type="list", default=list(), required=False),
)
module = AnsibleModule(
argument_spec=argument_spec,
required_one_of=[["cluster_name", "esxi_hostname"]],
supports_check_mode=True,
)
for rule_option in module.params.get("rules", []):
if "allowed_hosts" in rule_option:
if isinstance(rule_option["allowed_hosts"], list):
if len(rule_option["allowed_hosts"]) == 1:
allowed_hosts = rule_option["allowed_hosts"][0]
rule_option["allowed_hosts"] = allowed_hosts
module.deprecate(
"allowed_hosts should be a dict, not a list", "2.13"
)
vmware_firewall_manager = VmwareFirewallManager(module)
vmware_firewall_manager.check_params()
vmware_firewall_manager.ensure()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(change_hostname_to=dict(required=True, type='str'),
domainname=dict(required=True, type='str'),
dns_servers=dict(required=True, type='list')))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
change_hostname_to = module.params['change_hostname_to']
domainname = module.params['domainname']
dns_servers = module.params['dns_servers']
try:
content = connect_to_api(module)
host = get_all_objs(content, [vim.HostSystem])
if not host:
module.fail_json(msg="Unable to locate Physical Host.")
host_system = list(host)[0]
changed = configure_dns(host_system, change_hostname_to, domainname,
dns_servers)
module.exit_json(changed=changed)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
module.fail_json(msg=method_fault.msg)
except Exception as e:
module.fail_json(msg=str(e))
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
datacenter=dict(type='str'),
cluster=dict(type='str'),
folder=dict(type='str'),
vm_id=dict(type='str', required=True),
vm_id_type=dict(default='vm_name',
type='str',
choices=[
'inventory_path', 'uuid', 'instance_uuid',
'dns_name', 'vm_name'
]),
vm_username=dict(type='str', required=True),
vm_password=dict(type='str', no_log=True, required=True),
vm_shell=dict(type='str', required=True),
vm_shell_args=dict(default=" ", type='str'),
vm_shell_env=dict(type='list'),
vm_shell_cwd=dict(type='str'),
wait_for_process=dict(type='bool', default=False),
timeout=dict(type='int', default=3600),
))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
required_if=[['vm_id_type', 'inventory_path', ['folder']]],
)
vm_shell_mgr = VMwareShellManager(module)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(datacenter=dict(required=True, type='str'),
cluster=dict(required=True, type='str'),
resource_pool=dict(required=True, type='str'),
mem_shares=dict(type='str',
default="normal",
choices=['high', 'custom', 'normal', 'low']),
mem_limit=dict(type='int', default=-1),
mem_reservation=dict(type='int', default=0),
mem_expandable_reservations=dict(type='bool', default="True"),
cpu_shares=dict(type='str',
default="normal",
choices=['high', 'custom', 'normal', 'low']),
cpu_limit=dict(type='int', default=-1),
cpu_reservation=dict(type='int', default=0),
cpu_expandable_reservations=dict(type='bool', default="True"),
state=dict(default='present',
choices=['present', 'absent'],
type='str')))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
vmware_rp = VMwareResourcePool(module)
vmware_rp.process_state()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
esxi_hostname=dict(required=True, type='str'),
switch_name=dict(required=True, type='str'),
vmnics=dict(required=True, type='list'),
state=dict(default='present',
choices=['present', 'absent'],
type='str'),
vendor_specific_config=dict(
type='list',
elements='dict',
required=False,
options=dict(
key=dict(type='str', required=True),
value=dict(type='str', required=True),
),
),
))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not HAS_COLLECTIONS_COUNTER:
module.fail_json(
msg=
'collections.Counter from Python-2.7 is required for this module')
vmware_dvs_host = VMwareDvsHost(module)
vmware_dvs_host.process_state()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
attribute_key=dict(type="str"),
state=dict(type="str",
default="present",
choices=["absent", "present"]),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
["state", "present", ["attribute_key"]],
["state", "absent", ["attribute_key"]],
],
)
pyv = VmAttributeDefManager(module)
results = dict(changed=False, custom_attribute_defs=list())
if module.params["state"] == "present":
results = pyv.add_custom_def(module.params["attribute_key"])
elif module.params["state"] == "absent":
results = pyv.remove_custom_def(module.params["attribute_key"])
module.exit_json(**results)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
datacenter_name=dict(
type="str", required=False, aliases=["datacenter"]
),
datastore_cluster_name=dict(type="str", required=True),
state=dict(
default="present", choices=["present", "absent"], type="str"
),
folder=dict(type="str", required=False),
enable_sdrs=dict(type="bool", default=False, required=False),
keep_vmdks_together=dict(
type="bool", default=True, required=False
),
automation_level=dict(
type="str", choices=["automated", "manual"], default="manual"
),
enable_io_loadbalance=dict(
type="bool", default=False, required=False
),
loadbalance_interval=dict(type="int", default=480, required=False),
)
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
mutually_exclusive=[["datacenter_name", "folder"]],
required_one_of=[["datacenter_name", "folder"]],
)
datastore_cluster_mgr = VMwareDatastoreClusterManager(module)
datastore_cluster_mgr.ensure()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
cluster_name=dict(type='str', required=False),
esxi_hostname=dict(type='str', required=False),
rules=dict(type='list', default=list(), required=False),
)
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[
['cluster_name', 'esxi_hostname'],
],
supports_check_mode=True)
for rule_option in module.params.get("rules", []):
if 'allowed_hosts' in rule_option:
if isinstance(rule_option['allowed_hosts'], list):
if len(rule_option['allowed_hosts']) == 1:
allowed_hosts = rule_option['allowed_hosts'][0]
rule_option['allowed_hosts'] = allowed_hosts
module.deprecate(
'allowed_hosts should be a dict, not a list', '2.13')
vmware_firewall_manager = VmwareFirewallManager(module)
vmware_firewall_manager.check_params()
vmware_firewall_manager.ensure()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type="str"),
uuid=dict(type="str"),
moid=dict(type="str"),
folder=dict(type="str"),
datacenter=dict(type="str", default="ha-datacenter"),
export_dir=dict(type="path", required=True),
export_with_images=dict(type="bool", default=False),
download_timeout=dict(type="int", default=30),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_one_of=[["name", "uuid", "moid"]],
)
pyv = VMwareExportVmOvf(module)
vm = pyv.get_vm()
if vm:
vm_facts = pyv.gather_facts(vm)
vm_power_state = vm_facts["hw_power_status"].lower()
if vm_power_state != "poweredoff":
module.fail_json(msg="VM state should be poweredoff to export")
results = pyv.export_to_ovf_files(vm_obj=vm)
module.exit_json(**results)
else:
module.fail_json(msg="The specified virtual machine not found")
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(datacenter_name=dict(type='str',
required=False,
aliases=['datacenter']),
datastore_cluster_name=dict(type='str', required=True),
state=dict(default='present',
choices=['present', 'absent'],
type='str'),
folder=dict(type='str', required=False),
enable_sdrs=dict(type='bool', default=False, required=False),
keep_vmdks_together=dict(type='bool',
default=True,
required=False),
automation_level=dict(type='str',
choices=['automated', 'manual'],
default='manual'),
enable_io_loadbalance=dict(type='bool',
default=False,
required=False),
loadbalance_interval=dict(type='int', default=480,
required=False)))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True,
mutually_exclusive=[
['datacenter_name', 'folder'],
],
required_one_of=[
['datacenter_name', 'folder'],
])
datastore_cluster_mgr = VMwareDatastoreClusterManager(module)
datastore_cluster_mgr.ensure()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
datacenter=dict(type='str', required=True,
aliases=['datacenter_name']),
folder_name=dict(type='str', required=True),
parent_folder=dict(type='str', required=False),
state=dict(type='str',
choices=['present', 'absent'],
default='present'),
folder_type=dict(type='str',
default='vm',
choices=['datastore', 'host', 'network', 'vm'],
required=False),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
if len(module.params.get('folder_name')) > 79:
module.fail_json(
msg=
"Failed to manage folder as folder_name can only contain 80 characters."
)
vcenter_folder_mgr = VmwareFolderManager(module)
if not vcenter_folder_mgr.is_vcenter():
module.fail_json(
msg="Module vcenter_folder is meant for vCenter, hostname %s "
"is not vCenter server." % module.params.get('hostname'))
vcenter_folder_mgr.ensure()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type="str"),
uuid=dict(type="str"),
moid=dict(type="str"),
use_instance_uuid=dict(type="bool", default=False),
name_match=dict(choices=["first", "last"], default="first",
type="str"),
folder=dict(type="str"),
datacenter=dict(type="str"),
)
module = AnsibleModule(
argument_spec=argument_spec,
required_one_of=[["name", "uuid", "moid"]],
mutually_exclusive=[["name", "uuid", "moid"]],
supports_check_mode=True,
)
pyv = PyVmomiHelper(module)
vm = pyv.get_vm()
if not vm:
vm_id = (module.params.get("uuid") or module.params.get("name")
or module.params.get("moid"))
module.fail_json(
msg="Unable to find the specified virtual machine using: %s" %
vm_id)
results = pyv.gather_vmtools_info()
module.exit_json(**results)
def main():
argument_spec = vmware_argument_spec()
# add the arguments we're going to use for this module
argument_spec.update(
cluster_name=dict(type='str', required=False),
esxi_hostname=dict(type='str', required=False),
kernel_module_name=dict(type='str', required=True),
kernel_module_option=dict(type='str', required=True),
)
# make sure we have a valid target cluster_name or esxi_hostname (not both)
# and also enable check mode
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_one_of=[
['cluster_name', 'esxi_hostname'],
],
mutually_exclusive=[
['cluster_name', 'esxi_hostname'],
],
)
vmware_host_config = VmwareKernelManager(module)
vmware_host_config.check_host_configuration_state()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(dict(cluster_uuid=dict(required=False, type="str")))
module = AnsibleModule(
argument_spec=argument_spec, supports_check_mode=False
)
if not HAS_PYVMOMI:
module.fail_json(msg="pyvmomi is required for this module")
new_cluster_uuid = module.params["cluster_uuid"]
try:
content = connect_to_api(module, False)
host = get_all_objs(content, [vim.HostSystem])
if not host:
module.fail_json(msg="Unable to locate Physical Host.")
host_system = list(host)[0]
changed, result, cluster_uuid = create_vsan_cluster(
host_system, new_cluster_uuid
)
module.exit_json(
changed=changed, result=result, cluster_uuid=cluster_uuid
)
except vmodl.RuntimeFault as runtime_fault:
module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
module.fail_json(msg=method_fault.msg)
except Exception as e:
module.fail_json(msg=str(e))
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(
cluster_name=dict(type="str", required=True),
datacenter=dict(
type="str", required=True, aliases=["datacenter_name"]
),
# DRS
enable_drs=dict(type="bool", default=False),
drs_enable_vm_behavior_overrides=dict(type="bool", default=True),
drs_default_vm_behavior=dict(
type="str",
choices=["fullyAutomated", "manual", "partiallyAutomated"],
default="fullyAutomated",
),
drs_vmotion_rate=dict(type="int", choices=range(1, 6), default=3),
advanced_settings=dict(
type="dict", default=dict(), required=False
),
)
)
module = AnsibleModule(
argument_spec=argument_spec, supports_check_mode=True
)
vmware_cluster_drs = VMwareCluster(module)
vmware_cluster_drs.configure_drs()
def main():
spec = vmware_argument_spec()
spec.update(
dict(
esxi_hostname=dict(type="str", required=True),
vsan=dict(
type="str",
choices=[
"ensureObjectAccessibility",
"evacuateAllData",
"noAction",
],
aliases=["vsan_mode"],
),
evacuate=dict(type="bool", default=False),
timeout=dict(default=0, type="int"),
state=dict(
required=False,
default="present",
choices=["present", "absent"],
),
))
module = AnsibleModule(argument_spec=spec)
host_maintenance_mgr = VmwareMaintenanceMgr(module=module)
if module.params["state"] == "present":
host_maintenance_mgr.EnterMaintenanceMode()
elif module.params["state"] == "absent":
host_maintenance_mgr.ExitMaintenanceMode()
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
state=dict(
type="str",
default="shutdown-host",
choices=[
"power-down-to-standby",
"power-up-from-standby",
"shutdown-host",
"reboot-host",
],
),
esxi_hostname=dict(type="str", required=False),
cluster_name=dict(type="str", required=False),
force=dict(type="bool", default=False),
timeout=dict(type="int", default=600),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_one_of=[["cluster_name", "esxi_hostname"]],
)
host_power_manager = VmwareHostPowerManager(module)
host_power_manager.ensure()
def main():
""" Main """
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type='str'),
datacenter=dict(type='str', aliases=['datacenter_name']),
cluster=dict(type='str'),
gather_nfs_mount_info=dict(type='bool', default=False),
gather_vmfs_mount_info=dict(type='bool', default=False),
schema=dict(type='str', choices=['summary', 'vsphere'], default='summary'),
properties=dict(type='list')
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True
)
if module._name == 'vmware_datastore_facts':
module.deprecate("The 'vmware_datastore_facts' module has been renamed to 'vmware_datastore_info'", version='2.13')
result = dict(changed=False)
pyv = PyVmomiHelper(module)
if module.params['cluster']:
dxs = pyv.lookup_datastore_by_cluster()
elif module.params['datacenter']:
dxs = pyv.lookup_datastore(confine_to_datacenter=True)
else:
dxs = pyv.lookup_datastore(confine_to_datacenter=False)
vmware_host_datastore = VMwareHostDatastore(module)
datastores = vmware_host_datastore.build_datastore_list(dxs)
result['datastores'] = datastores
module.exit_json(**result)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
name=dict(type="str"),
uuid=dict(type="str"),
use_instance_uuid=dict(type="bool", default=False),
moid=dict(type="str"),
folder=dict(type="str"),
datacenter=dict(type="str", default="ha-datacenter"),
esxi_hostname=dict(type="str"),
cluster=dict(type="str"),
gather_network_info=dict(type="bool",
default=False,
aliases=["gather_network_facts"]),
networks=dict(type="list", default=[]),
)
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=[["name", "uuid", "moid"]])
pyv = PyVmomiHelper(module)
vm = pyv.get_vm()
if not vm:
vm_id = (module.params.get("uuid") or module.params.get("name")
or module.params.get("moid"))
module.fail_json(
msg="Unable to find the specified virtual machine using %s" %
vm_id)
result = pyv.reconfigure_vm_network(vm)
if result["failed"]:
module.fail_json(**result)
else:
module.exit_json(**result)
