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=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'), mac_address=dict(type='str'), vlan_id=dict(type='int'), network_name=dict(type='str'), device_type=dict(type='str', default='vmxnet3'), label=dict(type='str'), switch=dict(type='str'), connected=dict(type='bool', default=True), start_connected=dict(type='bool', default=True), wake_onlan=dict(type='bool', default=False), directpath_io=dict(type='bool', default=False), force=dict(type='bool', default=False), gather_network_info=dict( type='bool', default=False, aliases=['gather_network_facts']), networks=dict(type='list', default=[]), guest_control=dict(type='bool', default=True), state=dict(type='str', default='present', choices=['absent', 'present'])) module = AnsibleModule(argument_spec=argument_spec, mutually_exclusive=[['vlan_id', 'network_name']], required_one_of=[['name', 'uuid', 'moid']], supports_check_mode=True) pyv = PyVmomiHelper(module) if module.params['gather_network_info']: nics = pyv._get_nic_info() network_data = {} nics_sorted = sorted(nics.get('network_info'), key=lambda k: k['unit_number']) for n, i in enumerate(nics_sorted): key_name = '{0}'.format(n) network_data[key_name] = i network_data[key_name].update({ 'mac_addr': i['mac_address'], 'name': i['network_name'] }) module.exit_json(network_info=nics.get('network_info'), network_data=network_data, changed=False) if module.params['networks']: network_data = {} module.deprecate( 'The old way of configuring interfaces by supplying an arbitrary list will be removed, loops should be used to handle multiple interfaces', '2.11') diff, changed, network_info = pyv._deprectated_list_config() nd = copy.deepcopy(network_info) nics_sorted = sorted(nd, key=lambda k: k['unit_number']) for n, i in enumerate(nics_sorted): key_name = '{0}'.format(n) network_data[key_name] = i network_data[key_name].update({ 'mac_addr': i['mac_address'], 'name': i['network_name'] }) module.exit_json(changed=changed, network_info=network_info, network_data=network_data, diff=diff) if module.params['state'] == 'present': diff, changed, network_info = pyv._nic_present() if module.params['state'] == 'absent': if not module.params['mac_address']: module.fail_json( msg='parameter mac_address required when removing nics') diff, changed, network_info = pyv._nic_absent() module.exit_json(changed=changed, network_info=network_info, diff=diff)
def main(): """ Main method """ 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), backings=dict( type='list', elements='dict', required=True, options=dict(backing_type=dict(type='str', required=True, aliases=['type']), pipe_name=dict(type='str', default=None), endpoint=dict(type='str', choices=['client', 'server'], default='client'), no_rx_loss=dict(type='bool', default=False), service_uri=dict(type='str', default=None), direction=dict(type='str', choices=['client', 'server'], default='client'), device_name=dict(type='str', default=None), file_path=dict(type='str', default=None), yield_on_poll=dict(type='bool', default=True), state=dict(type='str', choices=['present', 'absent'], default='present')), required_if=[[ 'backing_type', 'pipe', ['pipe_name', 'endpoint', 'no_rx_loss'] ], ['backing_type', 'network', ['service_uri', 'direction']], ['backing_type', 'device', ['device_name']], ['backing_type', 'file', ['file_path']]]), ) module = AnsibleModule( argument_spec=argument_spec, required_one_of=[['name', 'uuid', 'moid']], mutually_exclusive=[['name', 'uuid', 'moid']], ) result = {'failed': False, 'changed': False} pyv = PyVmomiHelper(module) # Check if the VM exists before continuing vm_obj = pyv.get_vm() if vm_obj: proceed = pyv.check_vm_state(vm_obj) if proceed: result = pyv.reconfigure_vm_serial_port(vm_obj) else: # We are unable to find the virtual machine user specified # Bail out vm_id = (module.params.get('name') or module.params.get('uuid') or module.params.get('vm_id')) module.fail_json(msg="Unable to manage serial ports for non-existing" " virtual machine '%s'." % vm_id) if result['failed']: module.fail_json(**result) else: module.exit_json(**result)
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict( extension_key=dict(type='str', required=True), version=dict(type='str', required=True), email=dict(type='str', required=False), description=dict(type='str', required=False), company=dict(type='str', required=False), name=dict(type='str', required=False), url=dict(type='str', required=False), ssl_thumbprint=dict(type='str', required=False), client_type=dict(type='str', default='vsphere-client-serenity', required=False), server_type=dict(type='str', default='vsphere-client-serenity', required=False), visible=dict(type='bool', default='True', required=False), state=dict(type='str', default='present', choices=['absent', 'present']), )) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False, required_if=[[ 'state', 'present', [ 'email', 'description', 'company', 'name', 'url', 'ssl_thumbprint', 'server_type', 'client_type' ] ]]) state = module.params['state'] extension_key = module.params['extension_key'] version = module.params['version'] email = module.params['email'] desc = module.params['description'] name = module.params['name'] company = module.params['company'] client_type = module.params['client_type'] server_type = module.params['server_type'] url = module.params['url'] visible = module.params['visible'] thumbprint = module.params['ssl_thumbprint'] content = connect_to_api(module, False) em = content.extensionManager key_check = em.FindExtension(extension_key) results = dict(changed=False, installed=dict()) if state == 'present' and key_check: results['changed'] = False results['installed'] = "'%s' is already installed" % (extension_key) elif state == 'present' and not key_check: extension = vim.Extension() extension.key = extension_key extension.company = company extension.version = version extension.lastHeartbeatTime = datetime.datetime.now() description = vim.Description() description.label = name description.summary = desc extension.description = description extension.shownInSolutionManager = visible client = vim.Extension.ClientInfo() client.company = company client.version = version client.description = description client.type = client_type client.url = url extension.client = [client] server = vim.Extension.ServerInfo() server.company = company server.description = description server.type = server_type server.adminEmail = email server.serverThumbprint = thumbprint server.url = url extension.server = [server] em.RegisterExtension(extension) results['changed'] = True results['installed'] = "'%s' installed." % (extension_key) elif state == 'absent' and key_check: em.UnregisterExtension(extension_key) results['changed'] = True results['installed'] = "'%s' uninstalled." % (extension_key) elif state == 'absent' and not key_check: results['changed'] = False results['installed'] = "'%s' is not installed." % (extension_key) module.exit_json(**results)
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'), controllers=dict( type='list', elements='dict', required=False, options=dict( state=dict(type='str', choices=['present', 'absent'], required=True), controller_number=dict(type='int', choices=[0, 1, 2, 3], required=False), type=dict( type='str', choices=[ 'sata', 'nvme', 'lsilogic', 'buslogic', 'lsilogicsas', 'paravirtual', 'usb2', 'usb3' ], required=True, ), ), ), use_instance_uuid=dict(type='bool', default=False), gather_disk_controller_facts=dict(type='bool', default=False), sleep_time=dict(type='int', default=10), ) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[['name', 'uuid', 'moid']]) 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 vm_id = (module.params.get('name') or module.params.get('uuid') or module.params.get('moid')) module.fail_json( msg= "Unable to manage disk or USB controllers for non-existing virtual machine '%s'." % vm_id) # VM exists result = pyv.configure_disk_controllers() if result['failed']: module.fail_json(**result) else: module.exit_json(**result)
def main(): argument_spec = vmware_argument_spec() argument_spec.update({ 'name': {}, 'datastore': { 'default': 'datastore1', }, 'datacenter': { 'default': 'ha-datacenter', }, 'cluster': { 'default': None, }, 'deployment_option': { 'default': None, }, 'folder': { 'default': None, }, 'inject_ovf_env': { 'default': False, 'type': 'bool', }, 'resource_pool': { 'default': 'Resources', }, 'networks': { 'default': { 'VM Network': 'VM Network', }, 'type': 'dict', }, 'ovf': { 'type': 'path', '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, ) deploy_ovf = VMwareDeployOvf(module) deploy_ovf.vm_existence_check() deploy_ovf.upload() deploy_ovf.complete() if module.params['inject_ovf_env']: deploy_ovf.inject_ovf_env() facts = deploy_ovf.deploy() facts.update(changed=True) module.exit_json(**facts)
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.0.0', collection_name='community.vmware') if module.params.get('login'): module.deprecate("The 'login' option is being replaced by 'username'", version='2.0.0', collection_name='community.vmware') 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() 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(type='int'), port_binding=dict(required=True, type='str', choices=['static', 'ephemeral']), port_allocation=dict(type='str', choices=['fixed', 'elastic']), state=dict(required=True, choices=['present', 'absent'], type='str'), vlan_trunk=dict(type='bool', default=False), vlan_private=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)), in_traffic_shaping=dict( type='dict', options=dict( enabled=dict(type='bool'), average_bandwidth=dict(type='int'), peak_bandwidth=dict(type='int'), burst_size=dict(type='int'), ), ), out_traffic_shaping=dict( type='dict', options=dict( enabled=dict(type='bool'), average_bandwidth=dict(type='int'), peak_bandwidth=dict(type='int'), burst_size=dict(type='int'), ), ), net_flow=dict(type='bool'), teaming_policy=dict( type='dict', options=dict( inbound_policy=dict(type='bool'), 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', 'loadbalance_loadbased', 'failover_explicit', ], ), active_uplinks=dict(type='list', elements='str'), standby_uplinks=dict(type='list', elements='str'), ), default=dict( 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), ), mac_learning=dict( type='dict', options=dict( allow_unicast_flooding=dict(type='bool'), enabled=dict(type='bool'), limit=dict(type='int'), limit_policy=dict(type='str', choices=['allow', 'drop']), ), ))) module = AnsibleModule(argument_spec=argument_spec, mutually_exclusive=[ ['vlan_trunk', 'vlan_private'], ], 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( labels=dict(type='dict', default=dict(source='ansible')), license=dict(type='str', required=True), state=dict(type='str', default='present', choices=['absent', 'present']), esxi_hostname=dict(type='str'), datacenter=dict(type='str'), cluster_name=dict(type='str'), )) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) license = module.params['license'] state = module.params['state'] # FIXME: This does not seem to work on vCenter v6.0 labels = [] for k in module.params['labels']: kv = vim.KeyValue() kv.key = k kv.value = module.params['labels'][k] labels.append(kv) result = dict( changed=False, diff=dict(), ) pyv = VcenterLicenseMgr(module) if not pyv.is_vcenter(): module.fail_json(msg="vcenter_license is meant for vCenter, hostname %s " "is not vCenter server." % module.params.get('hostname')) lm = pyv.content.licenseManager result['licenses'] = pyv.list_keys(lm.licenses) if module._diff: result['diff']['before'] = '\n'.join(result['licenses']) + '\n' if state == 'present': if license not in result['licenses']: result['changed'] = True if module.check_mode: result['licenses'].append(license) else: lm.AddLicense(license, labels) key = pyv.find_key(lm.licenses, license) if key is not None: lam = lm.licenseAssignmentManager assigned_license = None datacenter = module.params['datacenter'] datacenter_obj = None if datacenter: datacenter_obj = pyv.find_datacenter_by_name(datacenter) if not datacenter_obj: module.fail_json(msg="Unable to find the datacenter %(datacenter)s" % module.params) cluster = module.params['cluster_name'] if cluster: cluster_obj = pyv.find_cluster_by_name(cluster_name=cluster, datacenter_name=datacenter_obj) if not cluster_obj: msg = "Unable to find the cluster %(cluster_name)s" if datacenter: msg += " in datacenter %(datacenter)s" module.fail_json(msg=msg % module.params) entityId = cluster_obj._moId # assign to current vCenter, if esxi_hostname is not specified elif module.params['esxi_hostname'] is None: entityId = pyv.content.about.instanceUuid # if key name not contain "VMware vCenter Server" if pyv.content.about.name not in key.name: module.warn('License key "%s" (%s) is not suitable for "%s"' % (license, key.name, pyv.content.about.name)) # assign to ESXi server else: esxi_host = find_hostsystem_by_name(pyv.content, module.params['esxi_hostname']) if esxi_host is None: module.fail_json(msg='Cannot find the specified ESXi host "%s".' % module.params['esxi_hostname']) entityId = esxi_host._moId # e.g., key.editionKey is "esx.enterprisePlus.cpuPackage", not sure all keys are in this format if 'esx' not in key.editionKey: module.warn('License key "%s" edition "%s" is not suitable for ESXi server' % (license, key.editionKey)) try: assigned_license = lam.QueryAssignedLicenses(entityId=entityId) except Exception as e: module.fail_json(msg='Could not query vCenter "%s" assigned license info due to %s.' % (entityId, to_native(e))) if not assigned_license or (len(assigned_license) != 0 and assigned_license[0].assignedLicense.licenseKey != license): try: lam.UpdateAssignedLicense(entity=entityId, licenseKey=license) except Exception: module.fail_json(msg='Could not assign "%s" (%s) to vCenter.' % (license, key.name)) result['changed'] = True result['licenses'] = pyv.list_keys(lm.licenses) else: module.fail_json(msg='License "%s" is not existing or can not be added' % license) if module._diff: result['diff']['after'] = '\n'.join(result['licenses']) + '\n' elif state == 'absent' and license in result['licenses']: # Check if key is in use key = pyv.find_key(lm.licenses, license) if key.used > 0: module.fail_json(msg='Cannot remove key "%s", still in use %s time(s).' % (license, key.used)) result['changed'] = True if module.check_mode: result['licenses'].remove(license) else: lm.RemoveLicense(license) result['licenses'] = pyv.list_keys(lm.licenses) if module._diff: result['diff']['after'] = '\n'.join(result['licenses']) + '\n' module.exit_json(**result)
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']), state=dict(type='str', default='present', choices=['absent', 'present']), # DRS ignore_drs=dict(type='bool', default=False), enable_drs=dict(type='bool', removed_from_collection='ansible.builtin', removed_in_version='2.12', default=False), drs_enable_vm_behavior_overrides=dict( type='bool', removed_from_collection='ansible.builtin', removed_in_version='2.12', default=True), drs_default_vm_behavior=dict( type='str', removed_from_collection='ansible.builtin', removed_in_version='2.12', choices=['fullyAutomated', 'manual', 'partiallyAutomated'], default='fullyAutomated'), drs_vmotion_rate=dict(type='int', removed_from_collection='ansible.builtin', removed_in_version='2.12', choices=[1, 2, 3, 4, 5], default=3), # HA ignore_ha=dict(type='bool', default=False), enable_ha=dict(type='bool', default=False, removed_from_collection='ansible.builtin', removed_in_version='2.12'), ha_failover_level=dict(type='int', default=2, removed_from_collection='ansible.builtin', removed_in_version='2.12'), ha_host_monitoring=dict(type='str', removed_in_version='2.12', removed_from_collection='ansible.builtin', default='enabled', choices=['enabled', 'disabled']), # HA VM Monitoring related parameters ha_vm_monitoring=dict(type='str', removed_in_version='2.12', removed_from_collection='ansible.builtin', choices=[ 'vmAndAppMonitoring', 'vmMonitoringOnly', 'vmMonitoringDisabled' ], default='vmMonitoringDisabled'), ha_vm_failure_interval=dict( type='int', default=30, removed_from_collection='ansible.builtin', removed_in_version='2.12'), ha_vm_min_up_time=dict(type='int', default=120, removed_from_collection='ansible.builtin', removed_in_version='2.12'), ha_vm_max_failures=dict(type='int', default=3, removed_from_collection='ansible.builtin', removed_in_version='2.12'), ha_vm_max_failure_window=dict( type='int', default=-1, removed_from_collection='ansible.builtin', removed_in_version='2.12'), ha_restart_priority=dict( type='str', removed_in_version='2.12', removed_from_collection='ansible.builtin', choices=['high', 'low', 'medium', 'disabled'], default='medium'), ha_admission_control_enabled=dict( type='bool', default=True, removed_in_version='2.12', removed_from_collection='ansible.builtin'), # VSAN ignore_vsan=dict(type='bool', default=False), enable_vsan=dict(type='bool', default=False, removed_in_version='2.12', removed_from_collection='ansible.builtin'), vsan_auto_claim_storage=dict( type='bool', default=False, removed_in_version='2.12', removed_from_collection='ansible.builtin'), )) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, ) vmware_cluster = VMwareCluster(module) vmware_cluster.process_state()
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']), # HA enable_ha=dict(type='bool', default=False), ha_host_monitoring=dict(type='str', default='enabled', choices=['enabled', 'disabled']), host_isolation_response=dict( type='str', default='none', choices=['none', 'powerOff', 'shutdown']), advanced_settings=dict(type='dict', default=dict(), required=False), # HA VM Monitoring related parameters ha_vm_monitoring=dict(type='str', choices=[ 'vmAndAppMonitoring', 'vmMonitoringOnly', 'vmMonitoringDisabled' ], default='vmMonitoringDisabled'), ha_vm_failure_interval=dict(type='int', default=30), ha_vm_min_up_time=dict(type='int', default=120), ha_vm_max_failures=dict(type='int', default=3), ha_vm_max_failure_window=dict(type='int', default=-1), ha_restart_priority=dict( type='str', choices=['high', 'low', 'medium', 'disabled'], default='medium'), # HA Admission Control related parameters slot_based_admission_control=dict( type='dict', options=dict(failover_level=dict(type='int', required=True), )), reservation_based_admission_control=dict( type='dict', options=dict( auto_compute_percentages=dict(type='bool', default=True), failover_level=dict(type='int', required=True), cpu_failover_resources_percent=dict(type='int', default=50), memory_failover_resources_percent=dict(type='int', default=50), )), failover_host_admission_control=dict( type='dict', options=dict(failover_hosts=dict(type='list', elements='str', required=True), )), )) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True, mutually_exclusive=[[ 'slot_based_admission_control', 'reservation_based_admission_control', 'failover_host_admission_control' ]]) vmware_cluster_ha = VMwareCluster(module) vmware_cluster_ha.configure_ha()
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'), use_instance_uuid=dict(type='bool', default=False), moid=dict(type='str'), folder=dict(type='str'), datacenter=dict(type='str', required=True), tags=dict(type='bool', default=False), schema=dict(type='str', choices=['summary', 'vsphere'], default='summary'), properties=dict(type='list')) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[['name', 'uuid', 'moid']], supports_check_mode=True) if module._name == 'vmware_guest_facts': module.deprecate( "The 'vmware_guest_facts' module has been renamed to 'vmware_guest_info'", version='2.13') if module.params.get('folder'): # FindByInventoryPath() does not require an absolute path # so we should leave the input folder path unmodified module.params['folder'] = module.params['folder'].rstrip('/') if module.params['schema'] != 'vsphere' and module.params.get( 'properties'): module.fail_json( msg= "The option 'properties' is only valid when the schema is 'vsphere'" ) pyv = PyVmomi(module) # Check if the VM exists before continuing vm = pyv.get_vm() # VM already exists if vm: try: if module.params['schema'] == 'summary': instance = pyv.gather_facts(vm) else: instance = pyv.to_json(vm, module.params['properties']) if module.params.get('tags'): if not HAS_VSPHERE: module.fail_json( msg= "Unable to find 'vCloud Suite SDK' Python library which is required." " Please refer this URL for installation steps" " - https://code.vmware.com/web/sdk/60/vcloudsuite-python" ) vm_rest_client = VmwareTag(module) instance.update(tags=vm_rest_client.get_vm_tags( vm_rest_client.tag_service, vm_rest_client.tag_association_svc, vm_mid=vm._moId)) module.exit_json(instance=instance) except Exception as exc: module.fail_json( msg="Information gathering failed with exception %s" % to_text(exc)) else: vm_id = (module.params.get('uuid') or module.params.get('name') or module.params.get('moid')) module.fail_json( msg="Unable to gather information for non-existing VM %s" % vm_id)
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(): """Main""" argument_spec = vmware_argument_spec() argument_spec.update( dict( portgroup=dict(type='str', required=True, aliases=['portgroup_name']), switch=dict(type='str', required=True, aliases=['switch_name', 'vswitch']), vlan_id=dict(type='int', required=False, default=0, aliases=['vlan']), hosts=dict(type='list', aliases=['esxi_hostname'], elements='str'), cluster_name=dict(type='str', aliases=['cluster']), state=dict(type='str', choices=['present', 'absent'], default='present'), security=dict(type='dict', options=dict( promiscuous_mode=dict(type='bool'), forged_transmits=dict(type='bool'), mac_changes=dict(type='bool'), ), aliases=['security_policy', 'network_policy']), traffic_shaping=dict( type='dict', options=dict( enabled=dict(type='bool'), average_bandwidth=dict(type='int'), peak_bandwidth=dict(type='int'), burst_size=dict(type='int'), ), ), teaming=dict( type='dict', options=dict( load_balancing=dict( type='str', choices=[ None, 'loadbalance_ip', 'loadbalance_srcmac', 'loadbalance_srcid', 'failover_explicit', ], aliases=['load_balance_policy'], ), network_failure_detection=dict( type='str', choices=['link_status_only', 'beacon_probing']), notify_switches=dict(type='bool'), failback=dict(type='bool'), active_adapters=dict(type='list', elements='str'), standby_adapters=dict(type='list', elements='str'), ), aliases=['teaming_policy']), )) module = AnsibleModule(argument_spec=argument_spec, required_one_of=[ ['cluster_name', 'hosts'], ], supports_check_mode=True) try: host_portgroup = VMwareHostPortGroup(module) host_portgroup.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( datacenter=dict(type='str', default='ha-datacenter'), 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'), moid=dict(type='str'), use_instance_uuid=dict(type='bool', default=False), folder=dict(type='str'), force=dict(type='bool', default=False), scheduled_at=dict(type='str'), schedule_task_name=dict(), schedule_task_description=dict(), schedule_task_enabled=dict(type='bool', default=True), state_change_timeout=dict(type='int', default=0), answer=dict(type='list', elements='dict', options=dict(question=dict(type='str', required=True), response=dict(type='str', required=True)))) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=False, mutually_exclusive=[['name', 'uuid', 'moid'], ['scheduled_at', 'answer']], ) 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 = { 'present': vim.VirtualMachine.PowerOn, '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_name = module.params[ 'schedule_task_name'] or 'task_%s' % str(randint(10000, 99999)) schedule_task_desc = module.params['schedule_task_description'] if schedule_task_desc is None: schedule_task_desc = 'Schedule task for vm %s for ' \ 'operation %s at %s' % (vm.name, module.params['state'], scheduled_at) schedule_task_spec.name = schedule_task_name 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['state']] schedule_task_spec.enabled = module.params['schedule_task_enabled'] 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(changed=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: # Check if a virtual machine is locked by a question if check_answer_question_status(vm) and module.params['answer']: try: responses = make_answer_response(vm, module.params['answer']) answer_question(vm, responses) except Exception as e: module.fail_json(msg="%s" % e) # Wait until a virtual machine is unlocked while True: if check_answer_question_status(vm) is False: break result['changed'] = True result['instance'] = gather_vm_facts(pyv.content, vm) else: result = set_vm_power_state( pyv.content, vm, module.params['state'], module.params['force'], module.params['state_change_timeout'], module.params['answer']) result['answer'] = module.params['answer'] else: id = module.params.get('uuid') or module.params.get( 'moid') or module.params.get('name') module.fail_json( msg= "Unable to set power state for non-existing virtual machine : '%s'" % id) 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(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), vlan_private=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', 'loadbalance_loadbased', '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, mutually_exclusive=[['vlan_trunk', 'vlan_private']], supports_check_mode=True) vmware_dvs_portgroup = VMwareDvsPortgroup(module) vmware_dvs_portgroup.process_state()
def main(): """ Main method """ 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), destination_vm_name=dict(type='str', required=True), destination_datastore=dict(type='str', required=True), destination_host=dict(type='str', required=True), destination_vcenter=dict(type='str', required=True), destination_vcenter_username=dict(type='str', required=True), destination_vcenter_password=dict(type='str', required=True, no_log=True), destination_vcenter_port=dict(type='int', default=443), destination_vcenter_validate_certs=dict(type='bool', default=False), destination_vm_folder=dict(type='str', required=True), destination_resource_pool=dict(type='str', default=None), state=dict(type='str', default='present', choices=['present', 'poweredon'])) module = AnsibleModule( argument_spec=argument_spec, supports_check_mode=True, required_one_of=[ ['uuid', 'name', 'moid'], ], mutually_exclusive=[ ['uuid', 'name', 'moid'], ], ) result = {'failed': False, 'changed': False} if module.check_mode: if module.params['state'] in ['present']: result.update(vm_name=module.params['destination_vm_name'], vcenter=module.params['destination_vcenter'], host=module.params['destination_host'], datastore=module.params['destination_datastore'], vm_folder=module.params['destination_vm_folder'], state=module.params['state'], changed=True, desired_operation='Create VM with PowerOff State') if module.params['state'] == 'poweredon': result.update(vm_name=module.params['destination_vm_name'], vcenter=module.params['destination_vcenter'], host=module.params['destination_host'], datastore=module.params['destination_datastore'], vm_folder=module.params['destination_vm_folder'], state=module.params['state'], changed=True, desired_operation='Create VM with PowerON State') module.exit_json(**result) clone_manager = CrossVCCloneManager(module) clone_manager.sanitize_params() clone_manager.populate_specs() result = clone_manager.clone() if result['failed']: module.fail_json(**result) else: module.exit_json(**result)
def main(): """Main""" argument_spec = vmware_argument_spec() argument_spec.update( dict( datacenter_name=dict(aliases=['datacenter']), folder=dict(), switch_name=dict(required=True, aliases=['switch', 'dvswitch']), mtu=dict(type='int', default=1500), multicast_filtering_mode=dict(type='str', default='basic', choices=['basic', 'snooping']), switch_version=dict( choices=['5.0.0', '5.1.0', '5.5.0', '6.0.0', '6.5.0', '6.6.0'], aliases=['version'], default=None), uplink_quantity=dict(type='int'), uplink_prefix=dict(type='str', default='Uplink '), discovery_proto=dict(type='str', choices=['cdp', 'lldp', 'disabled'], default='cdp', aliases=['discovery_protocol']), discovery_operation=dict(type='str', choices=['both', 'advertise', 'listen'], default='listen'), health_check=dict( type='dict', options=dict( vlan_mtu=dict(type='bool', default=False), teaming_failover=dict(type='bool', default=False), vlan_mtu_interval=dict(type='int', default=0), teaming_failover_interval=dict(type='int', default=0), ), default=dict( vlan_mtu=False, teaming_failover=False, vlan_mtu_interval=0, teaming_failover_interval=0, ), ), contact=dict( type='dict', options=dict( name=dict(type='str'), description=dict(type='str'), ), ), description=dict(type='str'), state=dict(default='present', choices=['present', 'absent']), )) module = AnsibleModule( argument_spec=argument_spec, required_if=[ ('state', 'present', ['uplink_quantity']), ], required_one_of=[ ['folder', 'datacenter_name'], ], mutually_exclusive=[ ['folder', 'datacenter_name'], ], supports_check_mode=True, ) vmware_dvswitch = VMwareDvSwitch(module) vmware_dvswitch.process_state()
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), 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' ) VmwareGuestFileManager(module)
def main(): argument_spec = vmware_argument_spec() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) vmware_rp_mgr = ResourcePoolInfoManager(module) module.exit_json(changed=False, resource_pool_info=vmware_rp_mgr.gather_rp_info())