def test_required_params(request, params, msg, fake_ansible_module): """ Test if required params are correct or not""" fake_ansible_module.params = params with pytest.raises(FailJsonException): vmware_module_utils.connect_to_api(fake_ansible_module) assert fake_ansible_module.fail_json.called_once() assert msg in fake_ansible_module.fail_json.call_args[1]['msg']
def main(): argument_spec = vmware_argument_spec() argument_spec.update( dict(vmk_name=dict(required=True, type='str'), ip_address=dict(required=True, type='str'), subnet_mask=dict(required=True, type='str'))) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) if not HAS_PYVMOMI: module.fail_json(msg='pyvmomi is required for this module') vmk_name = module.params['vmk_name'] ip_address = module.params['ip_address'] subnet_mask = module.params['subnet_mask'] try: content = connect_to_api(module, False) host = get_all_objs(content, [vim.HostSystem]) if not host: module.fail_json(msg="Unable to locate Physical Host.") host_system = 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(): 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(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(cluster_name=dict(required=True, type='str'), fetch_from_cache=dict(required=False, type='bool')) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) if not HAS_PYVMOMI: module.fail_json(msg=missing_required_lib('PyVmomi'), exception=PYVMOMI_IMP_ERR) if not HAS_VSANPYTHONSDK: module.fail_json( msg=missing_required_lib('vSAN Management SDK for Python'), exception=VSANPYTHONSDK_IMP_ERR) if not HAS_PYVMOMIJSON: module.fail_json( msg= 'The installed version of pyvmomi lacks JSON output support; need pyvmomi>6.7.1' ) try: si, content = connect_to_api(module, True, True) except Exception as e: module.fail_json(msg=e.msg) client_stub = si._GetStub() ssl_context = client_stub.schemeArgs.get('context') cluster = find_cluster_by_name(content, module.params['cluster_name']) if not cluster: module.fail_json(msg="Failed to find cluster %s" % module.params['cluster_name']) apiVersion = vsanapiutils.GetLatestVmodlVersion(module.params['hostname']) vcMos = vsanapiutils.GetVsanVcMos(client_stub, context=ssl_context, version=apiVersion) vsanClusterHealthSystem = vcMos['vsan-cluster-health-system'] try: clusterHealth = vsanClusterHealthSystem.VsanQueryVcClusterHealthSummary( cluster=cluster, fetchFromCache=module.params['fetch_from_cache']) except vmodl.fault.NotFound as not_found: module.fail_json(msg=not_found.msg) except vmodl.fault.RuntimeFault as runtime_fault: module.fail_json(msg=runtime_fault.msg) health = json.dumps(clusterHealth, cls=VmomiSupport.VmomiJSONEncoder, sort_keys=True, strip_dynamic=True) module.exit_json(changed=False, vsan_health_info=health)
def __init__(self, module): self.module = module self.host_system = None self.migrate_switch_name = self.module.params['migrate_switch_name'] self.migrate_portgroup_name = self.module.params[ 'migrate_portgroup_name'] self.device = self.module.params['device'] self.esxi_hostname = self.module.params['esxi_hostname'] self.current_portgroup_name = self.module.params[ 'current_portgroup_name'] self.current_switch_name = self.module.params['current_switch_name'] self.content = connect_to_api(module)
def sanitize_params(self): ''' this method is used to verify user provided parameters ''' self.vm_obj = self.get_vm() if self.vm_obj is None: vm_id = self.vm_uuid or self.vm_name or self.moid self.module.fail_json( msg="Failed to find the VM/template with %s" % vm_id) # connect to destination VC self.destination_content = connect_to_api( self.module, hostname=self.destination_vcenter, username=self.destination_vcenter_username, password=self.destination_vcenter_password, port=self.destination_vcenter_port, validate_certs=self.destination_vcenter_validate_certs) # Check if vm name already exists in the destination VC vm = find_vm_by_name(content=self.destination_content, vm_name=self.params['destination_vm_name']) if vm: self.module.fail_json( msg="A VM with the given name already exists") datastore_name = self.params['destination_datastore'] datastore_cluster = find_obj(self.destination_content, [vim.StoragePod], datastore_name) if datastore_cluster: # If user specified datastore cluster so get recommended datastore datastore_name = self.get_recommended_datastore( datastore_cluster_obj=datastore_cluster) # Check if get_recommended_datastore or user specified datastore exists or not self.destination_datastore = find_datastore_by_name( content=self.destination_content, datastore_name=datastore_name) if self.destination_datastore is None: self.module.fail_json(msg="Destination datastore not found.") self.destination_host = find_hostsystem_by_name( content=self.destination_content, hostname=self.params['destination_host']) if self.destination_host is None: self.module.fail_json(msg="Destination host not found.") if self.params['destination_resource_pool']: self.destination_resource_pool = find_resource_pool_by_name( content=self.destination_content, resource_pool_name=self.params['destination_resource_pool']) else: self.destination_resource_pool = self.destination_host.parent.resourcePool
def __init__(self, module): self.module = module self.datacenter = module.params['datacenter'] self.cluster = module.params['cluster'] self.resource_pool = module.params['resource_pool'] self.hostname = module.params['hostname'] self.username = module.params['username'] self.password = module.params['password'] self.state = module.params['state'] self.mem_shares = module.params['mem_shares'] self.mem_limit = module.params['mem_limit'] self.mem_reservation = module.params['mem_reservation'] self.mem_expandable_reservations = module.params[ 'cpu_expandable_reservations'] self.cpu_shares = module.params['cpu_shares'] self.cpu_limit = module.params['cpu_limit'] self.cpu_reservation = module.params['cpu_reservation'] self.cpu_expandable_reservations = module.params[ 'cpu_expandable_reservations'] self.dc_obj = None self.cluster_obj = None self.host_obj = None self.resource_pool_obj = None self.content = connect_to_api(module)
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 test_connect_to_api_validate_certs(monkeypatch, fake_ansible_module): monkeypatch.setattr(vmware_module_utils, 'connect', mock.Mock()) def MockSSLContext(proto): ssl_context.proto = proto return ssl_context # New Python with SSLContext + validate_certs=True vmware_module_utils.connect.reset_mock() ssl_context = mock.Mock() monkeypatch.setattr(vmware_module_utils.ssl, 'SSLContext', MockSSLContext) fake_ansible_module.params['validate_certs'] = True vmware_module_utils.connect_to_api(fake_ansible_module) assert ssl_context.proto == ssl.PROTOCOL_SSLv23 assert ssl_context.verify_mode == ssl.CERT_REQUIRED assert ssl_context.check_hostname is True vmware_module_utils.connect.SmartConnect.assert_called_once_with( host='esxi1', port=443, pwd='Esxi@123$%', user='******', sslContext=ssl_context) # New Python with SSLContext + validate_certs=False vmware_module_utils.connect.reset_mock() ssl_context = mock.Mock() monkeypatch.setattr(vmware_module_utils.ssl, 'SSLContext', MockSSLContext) fake_ansible_module.params['validate_certs'] = False vmware_module_utils.connect_to_api(fake_ansible_module) assert ssl_context.proto == ssl.PROTOCOL_SSLv23 assert ssl_context.verify_mode == ssl.CERT_NONE assert ssl_context.check_hostname is False vmware_module_utils.connect.SmartConnect.assert_called_once_with( host='esxi1', port=443, pwd='Esxi@123$%', user='******', sslContext=ssl_context) # Old Python with no SSLContext + validate_certs=True vmware_module_utils.connect.reset_mock() ssl_context = mock.Mock() ssl_context.proto = None monkeypatch.delattr(vmware_module_utils.ssl, 'SSLContext') fake_ansible_module.params['validate_certs'] = True with pytest.raises(FailJsonException): vmware_module_utils.connect_to_api(fake_ansible_module) assert ssl_context.proto is None fake_ansible_module.fail_json.assert_called_once_with( msg=('pyVim does not support changing verification mode with python ' '< 2.7.9. Either update python or use validate_certs=false.')) assert not vmware_module_utils.connect.SmartConnect.called # Old Python with no SSLContext + validate_certs=False vmware_module_utils.connect.reset_mock() ssl_context = mock.Mock() ssl_context.proto = None monkeypatch.delattr(vmware_module_utils.ssl, 'SSLContext', raising=False) fake_ansible_module.params['validate_certs'] = False vmware_module_utils.connect_to_api(fake_ansible_module) assert ssl_context.proto is None vmware_module_utils.connect.SmartConnect.assert_called_once_with( host='esxi1', port=443, pwd='Esxi@123$%', user='******')
def __init__(self, module): self.module = module self.content = connect_to_api(module) self.vm = None self.vm_name = module.params['vm_name'] self.dvportgroup_name = module.params['dvportgroup_name']