def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
vmware_tag_info = VmTagInfoManager(module)
vmware_tag_info.get_all_tags()
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 main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
tag_names=dict(type='list', required=True, elements='raw'),
state=dict(type='str',
choices=['absent', 'add', 'present', 'remove', 'set'],
default='add'),
moid=dict(type='str'),
object_name=dict(type='str'),
object_type=dict(type='str',
required=True,
choices=[
'VirtualMachine', 'Datacenter',
'ClusterComputeResource', 'HostSystem',
'DistributedVirtualSwitch',
'DistributedVirtualPortgroup', 'Datastore',
'ResourcePool', 'Folder', 'DatastoreCluster'
]),
)
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=[
('moid', 'object_name'),
],
required_one_of=[
['moid', 'object_name'],
])
vmware_tag_manager = VmwareTagManager(module)
vmware_tag_manager.ensure_state()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
library_name=dict(type='str', required=True),
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),
subscription_url=dict(type='str', default='', required=False),
ssl_thumbprint=dict(type='str', default='', required=False),
update_on_demand=dict(type='bool', default=False, required=False),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
('library_type', 'subscribed', ['subscription_url']),
],
)
vmware_contentlib_create = VmwareContentLibCreate(module)
vmware_contentlib_create.process_state()
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(cluster_name=dict(type='str', required=True), )
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False,
)
vmware_namespace_cluster_manage = VmwareNamespaceClusterVdsManage(module)
vmware_namespace_cluster_manage.get_cluster_info()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
encryption_key=dict(type='str', required=False),
description=dict(type='str', required=False),
decryption_key=dict(type='str', required=False),
api=dict(type='str',
required=False,
choices=['list', 'export', 'import', 'validate']),
profiles=dict(type='str', required=False),
config_path=dict(type='str', required=False),
)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
result = {'failed': False, 'changed': False}
vmware_vc_infra_profile = VcenterProfile(module)
vmware_vc_version = VcVersionChecker(module)
vmware_vc_version.check_vc_version()
if module.params['api'].lower() == "list":
if module.check_mode:
result.update(
changed=False,
desired_operation='list_vc_profile_configs',
)
module.exit_json(**result)
vmware_vc_infra_profile.list_vc_infraprofile_configs()
if module.params['api'].lower() == "export":
if module.check_mode:
result.update(
changed=False,
desired_operation='export_vc_profile_configs',
)
module.exit_json(**result)
vmware_vc_infra_profile.vc_export_profile_task()
if module.params['api'].lower() == "import":
if module.check_mode:
result.update(
changed=True,
desired_operation='import_vc_profile_configs',
)
module.exit_json(**result)
vmware_vc_infra_profile.vc_import_profile_task()
if module.params['api'].lower() == "validate":
if module.check_mode:
result.update(
changed=True,
desired_operation='import_vc_profile_configs',
)
module.exit_json(**result)
vmware_vc_infra_profile.vc_validate_profile_task()
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()
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name in ('vmware_tag_facts',
'community.vmware.vmware_tag_facts'):
module.deprecate(
"The 'vmware_tag_facts' module has been renamed to 'vmware_tag_info'",
version='3.0.0',
collection_name='community.vmware') # was Ansible 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(
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(
state=dict(type='str',
default='present',
choices=['present', 'poweredon']),
template=dict(type='str', aliases=['template_src'], required=True),
content_library=dict(type='str',
aliases=['content_library_src'],
required=False),
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(
log_level=dict(type='str',
choices=[
'debug',
'info',
'normal',
],
default='normal'),
template=dict(type='str',
aliases=['ovf', 'ovf_template', 'template_src'],
required=True),
library=dict(type='str',
aliases=['content_library', 'content_library_src'],
required=False),
name=dict(type='str', aliases=['vm_name'], required=True),
datacenter=dict(type='str', required=True),
datastore=dict(type='str', required=False),
datastore_cluster=dict(type='str', required=False),
folder=dict(type='str', default='vm'),
host=dict(type='str', required=False),
resource_pool=dict(type='str', required=False),
cluster=dict(type='str', required=False),
storage_provisioning=dict(
type='str',
choices=['thin', 'thick', 'eagerZeroedThick', 'eagerzeroedthick'],
default='thin',
fallback=(env_fallback, ['VMWARE_STORAGE_PROVISIONING'])),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_one_of=[
['datastore', 'datastore_cluster'],
['host', 'cluster'],
],
)
result = {'failed': False, 'changed': False}
vmware_contentlib_create = VmwareContentDeployOvfTemplate(module)
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_ovf_template()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
object_name=dict(),
object_moid=dict(),
new_name=dict(aliases=['object_new_name'], required=True),
object_type=dict(type='str', required=True),
)
module = AnsibleModule(argument_spec=argument_spec,
mutually_exclusive=[
['object_name', 'object_moid'],
])
vmware_object_rename = VmwareObjectRename(module)
vmware_object_rename.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),
content_library=dict(type='str',
aliases=['content_library_src'],
required=False),
name=dict(type='str', required=True, aliases=['vm_name']),
datacenter=dict(type='str', required=True),
datastore=dict(type='str', required=False),
datastore_cluster=dict(type='str', required=False),
folder=dict(type='str', required=True),
host=dict(type='str', required=False),
resource_pool=dict(type='str', required=False),
cluster=dict(type='str', required=False),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_one_of=[
['datastore', 'datastore_cluster'],
],
)
result = {'failed': False, 'changed': False}
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(
object_name=dict(),
object_moid=dict(),
new_name=dict(aliases=['object_new_name'], required=True),
object_type=dict(type='str', required=True, choices=['ClusterComputeResource', 'Cluster', 'Datacenter',
'Datastore', 'Folder', 'Network', 'ResourcePool', 'VM',
'VirtualMachine'])
)
module = AnsibleModule(
argument_spec=argument_spec,
mutually_exclusive=[
['object_name', 'object_moid'],
]
)
vmware_object_rename = VmwareObjectRename(module)
vmware_object_rename.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',
'Cluster',
'Content Library',
'Datacenter',
'Datastore',
'Datastore Cluster',
'Distributed Port Group',
'Distributed Switch',
'Folder',
'Host',
'Library item',
'Network',
'Host Network',
'Opaque Network',
'Resource Pool',
'vApp',
'Virtual Machine',
],
elements='str',
),
)
module = AnsibleModule(argument_spec=argument_spec)
vmware_category = VmwareCategory(module)
vmware_category.ensure_state()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
ovf_template=dict(type='str',
aliases=['template_src', 'ovf'],
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=True),
cluster=dict(type='str', required=False),
storage_provisioning=dict(
type='str',
required=False,
choices=['thin', 'thick', 'eagerZeroedThick'],
default=None),
)
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 = VmwareContentDeployOvfTemplate(module)
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_ovf_template()
def main():
argument_spec = VmwareRestClient.vmware_client_argument_spec()
argument_spec.update(
cluster_distributed_switch=dict(type='str', required=False),
cluster_name=dict(type='str', required=True),
default_content_library=dict(type='str', required=False),
dns_search_domains=dict(type='list', required=False),
egress_cidrs=dict(type='list', required=False),
ephemeral_storage_policy=dict(type='str', required=False),
haproxy_ca_chain=dict(type='str', required=False),
haproxy_management_ip=dict(type='str', required=False),
haproxy_management_port=dict(type='str',
required=False,
default='5556'),
haproxy_password=dict(type='str', required=False),
haproxy_ip_range_list=dict(type='list', required=False),
haproxy_username=dict(type='str', required=False),
image_storage_policy=dict(type='str', required=False),
ingress_cidrs=dict(type='list', required=False),
management_address_count=dict(type='int', required=False, default=5),
management_dns_servers=dict(type='list', required=False),
management_gateway=dict(type='str', required=False),
management_netmask=dict(type='str', required=False),
management_ntp_servers=dict(type='list', required=False),
management_port_group=dict(type='str', required=False),
management_starting_address=dict(type='str', required=False),
master_storage_policy=dict(type='str', required=False),
network_provider=dict(
type='str',
required=True,
choices=['VSPHERE_NETWORK', 'NSXT_CONTAINER_PLUGIN']),
nsx_edge_cluster=dict(type='str', required=False),
pod_cidrs=dict(type='list', required=False),
workload_dns_servers=dict(type='list', required=False),
workload_gateway=dict(type='str', required=False),
workload_netmask=dict(type='str', required=False),
workload_ntp_servers=dict(type='list', required=False),
workload_portgroup=dict(type='str', required=False),
workload_ip_range_list=dict(type='list', required=False),
services_cidr=dict(type='str', required=False),
supervisor_size=dict(type='str',
choices=['TINY', 'SMALL', 'MEDIUM', 'LARGE'],
required=False),
state=dict(type='str',
choices=['present', 'absent'],
default='present',
required=False),
# storage_policy_name=dict(type='str', required=False),
)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
required_if=[
('state', 'present', [
'ephemeral_storage_policy', 'image_storage_policy',
'management_dns_servers', 'management_gateway',
'management_netmask', 'management_ntp_servers',
'management_port_group', 'management_starting_address',
'master_storage_policy', 'network_provider', 'services_cidr',
'supervisor_size', 'workload_dns_servers',
'workload_ntp_servers'
]),
('network_provider', 'VSPHERE_NETWORK', [
'haproxy_ca_chain',
'haproxy_management_ip',
'haproxy_password',
'haproxy_ip_range_list',
'haproxy_username',
'workload_dns_servers',
'workload_gateway',
'workload_portgroup',
'workload_ip_range_list',
'workload_netmask',
]),
('network_provider', 'NSXT_CONTAINER_PLUGIN', [
'cluster_distributed_switch', 'egress_cidrs', 'ingress_cidrs',
'nsx_edge_cluster', 'pod_cidrs'
]),
])
vmware_namespace_cluster_manage = VmwareNamespaceClusterVdsManage(module)
vmware_namespace_cluster_manage.process_state()
