def properties_facts(self):
ansible_facts = self.to_json(self.host, self.params.get('properties'))
if self.params.get('show_tag'):
vmware_client = VmwareRestClient(self.module)
tag_info = {
'tags':
vmware_client.get_tags_for_hostsystem(
hostsystem_mid=self.host._moId)
}
ansible_facts.update(tag_info)
self.module.exit_json(changed=False, ansible_facts=ansible_facts)
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
vmware_category_facts = VmwareCategoryFactsManager(module)
vmware_category_facts.get_all_tag_categories()
def all_facts(self):
ansible_facts = {}
ansible_facts.update(self.get_cpu_facts())
ansible_facts.update(self.get_memory_facts())
ansible_facts.update(self.get_datastore_facts())
ansible_facts.update(self.get_network_facts())
ansible_facts.update(self.get_system_facts())
ansible_facts.update(self.get_vsan_facts())
ansible_facts.update(self.get_cluster_facts())
if self.params.get('show_tag'):
vmware_client = VmwareRestClient(self.module)
tag_info = {
'tags':
vmware_client.get_tags_for_hostsystem(
hostsystem_mid=self.host._moId)
}
ansible_facts.update(tag_info)
self.module.exit_json(changed=False, ansible_facts=ansible_facts)
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'vmware_tag_facts':
module.deprecate(
"The 'vmware_tag_facts' module has been renamed to 'vmware_tag_info'",
version='2.13')
vmware_tag_info = VmTagInfoManager(module)
vmware_tag_info.get_all_tags()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(library_id=dict(type='str', required=False), )
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
vmware_contentlib_info = VmwareContentLibInfo(module)
if module.params.get('library_id'):
vmware_contentlib_info.get_content_lib_details(
module.params['library_id'])
else:
vmware_contentlib_info.get_all_content_libs()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
tag_name=dict(type='str', required=True),
tag_description=dict(type='str', default='', required=False),
category_id=dict(type='str', required=False),
state=dict(type='str',
choices=['present', 'absent'],
default='present',
required=False),
)
module = AnsibleModule(argument_spec=argument_spec)
vmware_tag = VmwareTag(module)
vmware_tag.ensure_state()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
state=dict(type='str', default='present',
choices=['present', 'poweredon']),
template=dict(type='str', aliases=['template_src'], required=True),
name=dict(type='str', required=True, aliases=['vm_name']),
datacenter=dict(type='str', required=True),
datastore=dict(type='str', required=True),
folder=dict(type='str', required=True),
host=dict(type='str', required=True),
resource_pool=dict(type='str', required=False),
cluster=dict(type='str', required=False),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
result = {'failed': False, 'changed': False}
pyv = PyVmomi(module=module)
vm = pyv.get_vm()
if vm:
module.exit_json(
changed=False,
vm_deploy_info=dict(
msg="Virtual Machine '%s' already Exists." % module.params['name'],
vm_id=vm._moId,
)
)
vmware_contentlib_create = VmwareContentDeployTemplate(module)
if module.params['state'] in ['present']:
if module.check_mode:
result.update(
vm_name=module.params['name'],
changed=True,
desired_operation='Create VM with PowerOff State',
)
module.exit_json(**result)
vmware_contentlib_create.deploy_vm_from_template()
if module.params['state'] == 'poweredon':
if module.check_mode:
result.update(
vm_name=module.params['name'],
changed=True,
desired_operation='Create VM with PowerON State',
)
module.exit_json(**result)
vmware_contentlib_create.deploy_vm_from_template(power_on=True)
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
library_name=dict(type='str', required=False),
library_description=dict(type='str', required=False),
library_type=dict(type='str',
required=False,
choices=['local', 'subscribed'],
default='local'),
datastore_name=dict(type='str', required=False, aliases=['datastore']),
state=dict(type='str',
choices=['present', 'absent'],
default='present',
required=False),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
vmware_contentlib_create = VmwareContentLibCreate(module)
vmware_contentlib_create.process_state()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
tag_names=dict(type='list', required=True),
state=dict(type='str',
choices=['absent', 'add', 'present', 'remove', 'set'],
default='add'),
object_name=dict(type='str', required=True),
object_type=dict(type='str',
required=True,
choices=[
'VirtualMachine', 'Datacenter',
'ClusterComputeResource', 'HostSystem',
'DistributedVirtualSwitch',
'DistributedVirtualPortgroup'
]),
)
module = AnsibleModule(argument_spec=argument_spec)
vmware_tag_manager = VmwareTagManager(module)
vmware_tag_manager.ensure_state()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
category_name=dict(type='str', required=True),
category_description=dict(type='str', default='', required=False),
category_cardinality=dict(type='str',
choices=["multiple", "single"],
default="multiple"),
new_category_name=dict(type='str'),
state=dict(type='str',
choices=['present', 'absent'],
default='present'),
associable_object_types=dict(
type='list',
choices=[
'All objects',
'Folder',
'Cluster',
'Datacenter',
'Datastore',
'Datastore Cluster',
'Distributed Port Group',
'Distributed Switch',
'Host',
'Content Library',
'Library item',
'Network',
'Resource Pool',
'vApp',
'Virtual Machine',
],
elements=str,
),
)
module = AnsibleModule(argument_spec=argument_spec)
vmware_category = VmwareCategory(module)
vmware_category.ensure_state()
def get_tag_info(self, vm_dynamic_obj):
vmware_client = VmwareRestClient(self.module)
return vmware_client.get_tags_for_vm(vm_mid=vm_dynamic_obj._moId)
def gather_cluster_info(self):
"""
Gather information about cluster
"""
results = dict(changed=False, clusters=dict())
for cluster in self.cluster_objs:
# Default values
ha_failover_level = None
ha_restart_priority = None
ha_vm_tools_monitoring = None
ha_vm_min_up_time = None
ha_vm_max_failures = None
ha_vm_max_failure_window = None
ha_vm_failure_interval = None
enabled_vsan = False
vsan_auto_claim_storage = False
hosts = []
# Hosts
for host in cluster.host:
hosts.append({
'name': host.name,
'folder': self.get_vm_path(self.content, host),
})
# HA
das_config = cluster.configurationEx.dasConfig
if das_config.admissionControlPolicy:
ha_failover_level = das_config.admissionControlPolicy.failoverLevel
if das_config.defaultVmSettings:
ha_restart_priority = das_config.defaultVmSettings.restartPriority,
ha_vm_tools_monitoring = das_config.defaultVmSettings.vmToolsMonitoringSettings.vmMonitoring,
ha_vm_min_up_time = das_config.defaultVmSettings.vmToolsMonitoringSettings.minUpTime,
ha_vm_max_failures = das_config.defaultVmSettings.vmToolsMonitoringSettings.maxFailures,
ha_vm_max_failure_window = das_config.defaultVmSettings.vmToolsMonitoringSettings.maxFailureWindow,
ha_vm_failure_interval = das_config.defaultVmSettings.vmToolsMonitoringSettings.failureInterval,
# DRS
drs_config = cluster.configurationEx.drsConfig
# VSAN
if hasattr(cluster.configurationEx, 'vsanConfig'):
vsan_config = cluster.configurationEx.vsanConfig
enabled_vsan = vsan_config.enabled,
vsan_auto_claim_storage = vsan_config.defaultConfig.autoClaimStorage,
tag_info = []
if self.params.get('show_tag'):
vmware_client = VmwareRestClient(self.module)
tag_info = vmware_client.get_tags_for_cluster(
cluster_mid=cluster._moId)
results['clusters'][cluster.name] = dict(
hosts=hosts,
enable_ha=das_config.enabled,
ha_failover_level=ha_failover_level,
ha_vm_monitoring=das_config.vmMonitoring,
ha_host_monitoring=das_config.hostMonitoring,
ha_admission_control_enabled=das_config.
admissionControlEnabled,
ha_restart_priority=ha_restart_priority,
ha_vm_tools_monitoring=ha_vm_tools_monitoring,
ha_vm_min_up_time=ha_vm_min_up_time,
ha_vm_max_failures=ha_vm_max_failures,
ha_vm_max_failure_window=ha_vm_max_failure_window,
ha_vm_failure_interval=ha_vm_failure_interval,
enabled_drs=drs_config.enabled,
drs_enable_vm_behavior_overrides=drs_config.
enableVmBehaviorOverrides,
drs_default_vm_behavior=drs_config.defaultVmBehavior,
drs_vmotion_rate=drs_config.vmotionRate,
enabled_vsan=enabled_vsan,
vsan_auto_claim_storage=vsan_auto_claim_storage,
tags=tag_info,
)
self.module.exit_json(**results)