def rpc(self, action, params): """Make a call to the LogicMonitor RPC library and return the response""" self.module.debug("Running LogicMonitor.rpc") param_str = urlencode(params) creds = urlencode({ "c": self.company, "u": self.user, "p": self.password }) if param_str: param_str = param_str + "&" param_str = param_str + creds try: url = ("https://" + self.company + "." + self.lm_url + "/rpc/" + action + "?" + param_str) # Set custom LogicMonitor header with version headers = {"X-LM-User-Agent": self.__version__} # Set headers f = open_url(url, headers=headers) raw = f.read() resp = json.loads(raw) if resp["status"] == 403: self.module.debug("Authentication failed.") self.fail(msg="Error: " + resp["errmsg"]) else: return raw except IOError as ioe: self.fail(msg="Error: Exception making RPC call to " + "https://" + self.company + "." + self.lm_url + "/rpc/" + action + "\nException" + to_native(ioe))
def __init__(self, session): self.session = session self.parameters = {} for url in session._spec.get("paths").keys(): methods = session._spec.get("paths").get(url) for method in methods.keys(): operation_spec = methods.get(method) operation_name = operation_spec.get("operationId", None) parameters = operation_spec.get("parameters") if not operation_name: if method.lower() == "post": operation_name = "Create" elif method.lower() == "get": operation_name = "Get" elif method.lower() == "put": operation_name = "Update" elif method.lower() == "delete": operation_name = "Delete" elif method.lower() == "patch": operation_name = "Patch" else: raise SessionConfigurationException( to_native( "Invalid REST method type {0}".format(method))) # Get the non-parameter parts of the URL and append to the operation name # e.g /application/version -> GetApplicationVersion # e.g. /application/{id} -> GetApplication # This may lead to duplicates, which we must prevent. operation_name += re.sub(r"{(.*)}", "", url).replace( "/", " ").title().replace(" ", "") operation_spec["operationId"] = operation_name op = RestOperation(session, url, method, parameters) setattr(self, operation_name, bind(self, op.restmethod, operation_spec))
def get_destination(self): result = None release_get = netapp_utils.zapi.NaElement( 'snapmirror-get-destination-iter') query = netapp_utils.zapi.NaElement('query') snapmirror_dest_info = netapp_utils.zapi.NaElement( 'snapmirror-destination-info') snapmirror_dest_info.add_new_child('destination-location', self.parameters['destination_path']) query.add_child_elem(snapmirror_dest_info) release_get.add_child_elem(query) try: result = self.source_server.invoke_successfully( release_get, enable_tunneling=True) except netapp_utils.zapi.NaApiError as error: self.module.fail_json( msg='Error fetching snapmirror destinations info: %s' % to_native(error), exception=traceback.format_exc()) if result.get_child_by_name('num-records') and \ int(result.get_child_content('num-records')) > 0: return True return None
def unlock_given_user(self): """ unlocks the user :return: True if user unlocked False if unlock user is not performed :rtype: bool """ user_unlock = netapp_utils.zapi.NaElement.create_node_with_children( 'security-login-unlock', **{'vserver': self.parameters['vserver'], 'user-name': self.parameters['name']}) try: self.server.invoke_successfully(user_unlock, enable_tunneling=False) except netapp_utils.zapi.NaApiError as error: if to_native(error.code) == '13114': return False else: self.module.fail_json(msg='Error unlocking user %s: %s' % (self.parameters['name'], to_native(error)), exception=traceback.format_exc()) return True
def main(): argument_spec = DigitalOceanHelper.digital_ocean_argument_spec() argument_spec.update( snapshot_type=dict(type='str', required=False, choices=['all', 'droplet', 'volume', 'by_id'], default='all'), snapshot_id=dict(type='str', required=False), ) module = AnsibleModule( argument_spec=argument_spec, required_if=[ ['snapshot_type', 'by_id', ['snapshot_id']], ], ) if module._name == 'digital_ocean_snapshot_facts': module.deprecate("The 'digital_ocean_snapshot_facts' module has been renamed to 'digital_ocean_snapshot_info'", version='2.13') try: core(module) except Exception as e: module.fail_json(msg=to_native(e), exception=format_exc())
def get_configuration(self): """Retrieve the existing audit-log configurations. :returns: dictionary containing current audit-log configuration """ try: if self.proxy_used: rc, data = request(self.url + "audit-log/config", timeout=300, headers=self.HEADERS, **self.creds) else: rc, data = request( self.url + "storage-systems/%s/audit-log/config" % self.ssid, timeout=300, headers=self.HEADERS, **self.creds) return data except Exception as err: self.module.fail_json( msg="Failed to retrieve the audit-log configuration! " "Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
def create_vgw(client, module): params = dict() params['Type'] = module.params.get('type') if module.params.get('asn'): params['AmazonSideAsn'] = module.params.get('asn') try: response = client.create_vpn_gateway(**params) get_waiter( client, 'vpn_gateway_exists' ).wait( VpnGatewayIds=[response['VpnGateway']['VpnGatewayId']] ) except botocore.exceptions.WaiterError as e: module.fail_json(msg="Failed to wait for Vpn Gateway {0} to be available".format(response['VpnGateway']['VpnGatewayId']), exception=traceback.format_exc()) except is_boto3_error_code('VpnGatewayLimitExceeded'): module.fail_json(msg="Too many VPN gateways exist in this account.", exception=traceback.format_exc()) except botocore.exceptions.ClientError as e: # pylint: disable=duplicate-except module.fail_json(msg=to_native(e), exception=traceback.format_exc()) result = response return result
def quota_entry_modify(self, modify_attrs): """ Modifies a quota entry """ options = { 'volume': self.parameters['volume'], 'quota-target': self.parameters['quota_target'], 'quota-type': self.parameters['type'], 'qtree': self.parameters['qtree'] } options.update(modify_attrs) if self.parameters.get('policy'): options['policy'] = str(self.parameters['policy']) modify_entry = netapp_utils.zapi.NaElement.create_node_with_children( 'quota-modify-entry', **options) try: self.server.invoke_successfully(modify_entry, enable_tunneling=True) except netapp_utils.zapi.NaApiError as error: self.module.fail_json( msg='Error modifying quota entry %s: %s' % (self.parameters['volume'], to_native(error)), exception=traceback.format_exc())
def remove_compute_environment(module, aws): """ Remove a Batch compute environment :param module: :param aws: :return: """ client = aws.client('batch') changed = False # set API parameters api_params = {'computeEnvironment': module.params['compute_environment_name']} try: if not module.check_mode: client.delete_compute_environment(**api_params) changed = True except (ClientError, ParamValidationError, MissingParametersError) as e: module.fail_json(msg='Error removing compute environment: {0}'.format(to_native(e)), exception=traceback.format_exc()) return changed
def set_acceptance_level(self): change = [] for host in self.hosts: host_changed = False if self.hosts_facts[host.name]['level'] != self.acceptance_level: host_image_config_mgr = host.configManager.imageConfigManager if host_image_config_mgr: try: if self.module.check_mode: self.hosts_facts[ host.name]['level'] = self.acceptance_level else: host_image_config_mgr.UpdateHostImageAcceptanceLevel( newAcceptanceLevel=self.acceptance_level) self.hosts_facts[host.name][ 'level'] = host_image_config_mgr.HostImageConfigGetAcceptance( ) host_changed = True except vim.fault.HostConfigFault as e: self.hosts_facts[host.name]['error'] = to_native(e.msg) change.append(host_changed) self.module.exit_json(changed=any(change), facts=self.hosts_facts)
def create_subsystem(self): """ Create a NVME Subsystem """ if self.parameters.get('ostype') is None: self.module.fail_json( msg= "Error: Missing required parameter 'os_type' for creating subsystem" ) options = { 'subsystem': self.parameters['subsystem'], 'ostype': self.parameters['ostype'] } subsystem_create = netapp_utils.zapi.NaElement('nvme-subsystem-create') subsystem_create.translate_struct(options) try: self.server.invoke_successfully(subsystem_create, enable_tunneling=True) except netapp_utils.zapi.NaApiError as error: self.module.fail_json( msg='Error creating subsystem for %s: %s' % (self.parameters.get('subsystem'), to_native(error)), exception=traceback.format_exc())
def remove_broadcast_domain_ports(self, ports): """ Deletes broadcast domain ports :param: ports to be removed. """ domain_obj = netapp_utils.zapi.NaElement( 'net-port-broadcast-domain-remove-ports') domain_obj.add_new_child("broadcast-domain", self.parameters['resource_name']) if self.parameters.get('ipspace'): domain_obj.add_new_child("ipspace", self.parameters['ipspace']) ports_obj = netapp_utils.zapi.NaElement('ports') domain_obj.add_child_elem(ports_obj) for port in ports: ports_obj.add_new_child('net-qualified-port-name', port) try: self.server.invoke_successfully(domain_obj, True) return True except netapp_utils.zapi.NaApiError as error: self.module.fail_json( msg='Error removing port for broadcast domain %s: %s' % (self.parameters['resource_name'], to_native(error)), exception=traceback.format_exc())
def create_interface(self): ''' calling zapi to create interface ''' required_keys = set(['role', 'home_port']) data_protocols_obj = None if self.parameters.get('subnet_name') is None: required_keys.add('address') required_keys.add('netmask') data_protocols_obj = self.set_protocol_option(required_keys) self.validate_create_parameters(required_keys) options = {'interface-name': self.parameters['interface_name'], 'role': self.parameters['role'], 'home-node': self.parameters.get('home_node'), 'vserver': self.parameters['vserver']} NetAppOntapInterface.set_options(options, self.parameters) interface_create = netapp_utils.zapi.NaElement.create_node_with_children('net-interface-create', **options) if data_protocols_obj is not None: interface_create.add_child_elem(data_protocols_obj) try: self.server.invoke_successfully(interface_create, enable_tunneling=True) except netapp_utils.zapi.NaApiError as exc: self.module.fail_json(msg='Error Creating interface %s: %s' % (self.parameters['interface_name'], to_native(exc)), exception=traceback.format_exc())
def delete_log_messages(self): """Delete all audit-log messages.""" self._logger.info("Deleting audit-log messages...") try: if self.proxy_used: rc, result = request(self.url + "audit-log?clearAll=True", timeout=300, method="DELETE", headers=self.HEADERS, **self.creds) else: rc, result = request( self.url + "storage-systems/%s/audit-log?clearAll=True" % self.ssid, timeout=300, method="DELETE", headers=self.HEADERS, **self.creds) except Exception as err: self.module.fail_json( msg= "Failed to delete audit-log messages! Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
def rename_subnet(self): """ TODO """ options = { 'subnet-name': self.parameters.get('from_name'), 'new-name': self.parameters.get('name') } subnet_rename = netapp_utils.zapi.NaElement.create_node_with_children( 'net-subnet-rename', **options) if self.parameters.get('ipspace'): subnet_rename.add_new_child('ipspace', self.parameters.get('ipspace')) try: self.server.invoke_successfully(subnet_rename, True) except netapp_utils.zapi.NaApiError as error: self.module.fail_json( msg='Error renaming subnet %s: %s' % (self.parameters.get('name'), to_native(error)), exception=traceback.format_exc())
def write_changes(module, b_lines, dest): tmpfd, tmpfile = tempfile.mkstemp() with os.fdopen(tmpfd, 'wb') as f: f.writelines(b_lines) validate = module.params.get('validate', None) valid = not validate if validate: if "%s" not in validate: module.fail_json(msg="validate must contain %%s: %s" % (validate)) (rc, out, err) = module.run_command( to_bytes(validate % tmpfile, errors='surrogate_or_strict')) valid = rc == 0 if rc != 0: module.fail_json(msg='failed to validate: ' 'rc:%s error:%s' % (rc, err)) if valid: module.atomic_move(tmpfile, to_native(os.path.realpath( to_bytes(dest, errors='surrogate_or_strict')), errors='surrogate_or_strict'), unsafe_writes=module.params['unsafe_writes'])
def create_broadcast_domain(self): """ Creates a new broadcast domain """ domain_obj = netapp_utils.zapi.NaElement( 'net-port-broadcast-domain-create') domain_obj.add_new_child("broadcast-domain", self.parameters['name']) if self.parameters.get('ipspace'): domain_obj.add_new_child("ipspace", self.parameters['ipspace']) if self.parameters.get('mtu'): domain_obj.add_new_child("mtu", self.parameters['mtu']) if self.parameters.get('ports'): ports_obj = netapp_utils.zapi.NaElement('ports') domain_obj.add_child_elem(ports_obj) for port in self.parameters['ports']: ports_obj.add_new_child('net-qualified-port-name', port) try: self.server.invoke_successfully(domain_obj, True) except netapp_utils.zapi.NaApiError as error: self.module.fail_json( msg='Error creating broadcast domain %s: %s' % (self.parameters['name'], to_native(error)), exception=traceback.format_exc())
def get_initiators(self): """ Get the existing list of initiators from an igroup :rtype: list() or None """ igroup_info = netapp_utils.zapi.NaElement('igroup-get-iter') attributes = dict(query={'initiator-group-info': {'initiator-group-name': self.parameters['initiator_group'], 'vserver': self.parameters['vserver']}}) igroup_info.translate_struct(attributes) result, current = None, [] try: result = self.server.invoke_successfully(igroup_info, True) except netapp_utils.zapi.NaApiError as error: self.module.fail_json(msg='Error fetching igroup info %s: %s' % (self.parameters['initiator_group'], to_native(error)), exception=traceback.format_exc()) if result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) >= 1: igroup_info = result.get_child_by_name('attributes-list').get_child_by_name('initiator-group-info') if igroup_info.get_child_by_name('initiators') is not None: current = [initiator['initiator-name'] for initiator in igroup_info['initiators'].get_children()] return current
def main(): argument_spec = ipa_argument_spec() argument_spec.update( description=dict(type='str'), state=dict(type='str', default='present', choices=['present', 'absent', 'enabled', 'disabled']), sudocmd=dict(type='str', required=True, aliases=['name'])) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) client = SudoCmdIPAClient(module=module, host=module.params['ipa_host'], port=module.params['ipa_port'], protocol=module.params['ipa_prot']) try: client.login(username=module.params['ipa_user'], password=module.params['ipa_pass']) changed, sudocmd = ensure(module, client) module.exit_json(changed=changed, sudocmd=sudocmd) except Exception as e: module.fail_json(msg=to_native(e), exception=traceback.format_exc())
def update_api_address_interface_match(self, body): """Change network interface address which matches the api_address""" try: try: (rc, data) = request(self.url + 'storage-systems/%s/configuration/ethernet-interfaces' % self.ssid, use_proxy=False, force=True, ignore_errors=True, method='POST', data=json.dumps(body), headers=HEADERS, timeout=10, **self.creds) except Exception: url_parts = list(urlparse.urlparse(self.url)) domain = url_parts[1].split(":") domain[0] = self.address url_parts[1] = ":".join(domain) expected_url = urlparse.urlunparse(url_parts) self._logger.info(pformat(expected_url)) (rc, data) = request(expected_url + 'storage-systems/%s/configuration/ethernet-interfaces' % self.ssid, headers=HEADERS, timeout=300, **self.creds) return except Exception as err: self._logger.info(type(err)) self.module.fail_json( msg="Connection failure: we failed to modify the network settings! Array Id [%s]. Error [%s]." % (self.ssid, to_native(err)))
def main(): argument_spec = dict( ip_address=dict(required=True), key_filename=dict(), password=dict(no_log=True), cert_cn=dict(required=True), cert_friendly_name=dict(required=True), rsa_nbits=dict(default='2048'), signed_by=dict(required=True) ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False, required_one_of=[['key_filename', 'password']]) if paramiko is None: module.fail_json(msg='paramiko is required for this module') ip_address = module.params["ip_address"] key_filename = module.params["key_filename"] password = module.params["password"] cert_cn = module.params["cert_cn"] cert_friendly_name = module.params["cert_friendly_name"] signed_by = module.params["signed_by"] rsa_nbits = module.params["rsa_nbits"] try: stdout = generate_cert(module, ip_address, key_filename, password, cert_cn, cert_friendly_name, signed_by, rsa_nbits) except Exception as exc: module.fail_json(msg=to_native(exc)) module.exit_json(changed=True, msg="okey dokey")
def apply_iscsi_settings(self): """Update the iSCSI target alias and CHAP settings""" update = False target = self.target body = dict() if self.name is not None and self.name != target['alias']: update = True body['alias'] = self.name # If the CHAP secret was provided, we trigger an update. if self.chap_secret: update = True body.update( dict(enableChapAuthentication=True, chapSecret=self.chap_secret)) # If no secret was provided, then we disable chap elif target['chap']: update = True body.update(dict(enableChapAuthentication=False)) if update and not self.check_mode: try: request(self.url + 'storage-systems/%s/iscsi/target-settings' % self.ssid, method='POST', data=json.dumps(body), headers=HEADERS, **self.creds) except Exception as err: self.module.fail_json( msg= "Failed to update the iSCSI target settings. Array Id [%s]. Error [%s]." % (self.ssid, to_native(err))) return update
def main(): module = AnsibleModule( argument_spec=dict( name=dict(), glob=dict(), color=dict(), password=dict(no_log=True), token=dict(no_log=True), url=dict(default="http://localhost:8080"), user=dict(), validate_certs=dict(type='bool', default=True), ), mutually_exclusive=[ ['password', 'token'], ['name', 'glob'], ], required_one_of=[ ['password', 'token'], ], supports_check_mode=True, ) if module._name == 'jenkins_job_facts': module.deprecate( "The 'jenkins_job_facts' module has been renamed to 'jenkins_job_info'", version='2.13') test_dependencies(module) jobs = list() try: jobs = get_jobs(module) except jenkins.JenkinsException as err: module.fail_json(msg='Unable to connect to Jenkins server, %s' % to_native(err), exception=traceback.format_exc()) module.exit_json(changed=False, jobs=jobs)
def _podman(self, cmd, cmd_args=None, in_data=None, use_container_id=True): """ run podman executable :param cmd: podman's command to execute (str) :param cmd_args: list of arguments to pass to the command (list of str/bytes) :param in_data: data passed to podman's stdin :return: return code, stdout, stderr """ podman_exec = self.get_option('podman_executable') podman_cmd = distutils.spawn.find_executable(podman_exec) if not podman_cmd: raise AnsibleError("%s command not found in PATH" % podman_exec) local_cmd = [podman_cmd] if self.get_option('podman_extra_args'): local_cmd += shlex.split( to_native( self.get_option('podman_extra_args'), errors='surrogate_or_strict')) local_cmd.append(cmd) if use_container_id: local_cmd.append(self._container_id) if cmd_args: local_cmd += cmd_args local_cmd = [to_bytes(i, errors='surrogate_or_strict') for i in local_cmd] display.vvv("RUN %s" % (local_cmd,), host=self._container_id) p = subprocess.Popen(local_cmd, shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = p.communicate(input=in_data) display.vvvvv("STDOUT %s" % stdout) display.vvvvv("STDERR %s" % stderr) display.vvvvv("RC CODE %s" % p.returncode) stdout = to_bytes(stdout, errors='surrogate_or_strict') stderr = to_bytes(stderr, errors='surrogate_or_strict') return p.returncode, stdout, stderr
def init_swarm(self): if not self.force and self.client.check_if_swarm_manager(): self.__update_swarm() return if not self.check_mode: init_arguments = { 'advertise_addr': self.parameters.advertise_addr, 'listen_addr': self.parameters.listen_addr, 'force_new_cluster': self.force, 'swarm_spec': self.parameters.spec, } if self.parameters.default_addr_pool is not None: init_arguments[ 'default_addr_pool'] = self.parameters.default_addr_pool if self.parameters.subnet_size is not None: init_arguments['subnet_size'] = self.parameters.subnet_size try: self.client.init_swarm(**init_arguments) except APIError as exc: self.client.fail("Can not create a new Swarm Cluster: %s" % to_native(exc)) if not self.client.check_if_swarm_manager(): if not self.check_mode: self.client.fail("Swarm not created or other error!") self.created = True self.inspect_swarm() self.results['actions'].append("New Swarm cluster created: %s" % (self.swarm_info.get('ID'))) self.differences.add('state', parameter='present', active='absent') self.results['changed'] = True self.results['swarm_facts'] = { 'JoinTokens': self.swarm_info.get('JoinTokens'), 'UnlockKey': self.swarm_info.get('UnlockKey') }
def get_adapter(self): """ Return details about the adapter :param: name : Name of the name of the adapter :return: Details about the adapter. None if not found. :rtype: dict """ adapter_info = netapp_utils.zapi.NaElement('ucm-adapter-get') adapter_info.add_new_child('adapter-name', self.parameters['adapter_name']) adapter_info.add_new_child('node-name', self.parameters['node_name']) try: result = self.server.invoke_successfully(adapter_info, True) except netapp_utils.zapi.NaApiError as error: self.module.fail_json( msg='Error fetching ucadapter details: %s: %s' % (self.parameters['node_name'], to_native(error)), exception=traceback.format_exc()) if result.get_child_by_name('attributes'): adapter_attributes = result.get_child_by_name('attributes').\ get_child_by_name('uc-adapter-info') return_value = { 'mode': adapter_attributes.get_child_content('mode'), 'pending-mode': adapter_attributes.get_child_content('pending-mode'), 'type': adapter_attributes.get_child_content('fc4-type'), 'pending-type': adapter_attributes.get_child_content('pending-fc4-type'), 'status': adapter_attributes.get_child_content('status'), } return return_value return None
def flexcache_get(self): """ Get current FlexCache relations :return: Dictionary of current FlexCache details if query successful, else None """ flexcache_get_iter = self.flexcache_get_iter() flex_info = dict() try: result = self.server.invoke_successfully(flexcache_get_iter, enable_tunneling=True) except netapp_utils.zapi.NaApiError as error: self.module.fail_json(msg='Error fetching FlexCache info: %s' % to_native(error), exception=traceback.format_exc()) if result.get_child_by_name('num-records') and \ int(result.get_child_content('num-records')) == 1: flexcache_info = result.get_child_by_name('attributes-list') \ .get_child_by_name('flexcache-info') flex_info['origin_cluster'] = flexcache_info.get_child_content( 'origin-cluster') flex_info['origin_volume'] = flexcache_info.get_child_content( 'origin-volume') flex_info['origin_vserver'] = flexcache_info.get_child_content( 'origin-vserver') flex_info['size'] = flexcache_info.get_child_content('size') flex_info['volume'] = flexcache_info.get_child_content('volume') flex_info['vserver'] = flexcache_info.get_child_content('vserver') flex_info['auto_provision_as'] = flexcache_info.get_child_content( 'auto-provision-as') return flex_info if result.get_child_by_name('num-records') and \ int(result.get_child_content('num-records')) > 1: msg = 'Multiple records found for %s:' % self.parameters['volume'] self.module.fail_json(msg='Error fetching FlexCache info: %s' % msg) return None
def full_login(self): if self.auto_login is not None: if None in [ self.auto_login.get('subdomain'), self.auto_login.get('username'), self.auto_login.get('secret_key'), self.auto_login.get('master_password') ]: module.fail_json( msg='Unable to perform initial sign in to 1Password. ' 'subdomain, username, secret_key, and master_password are required to perform initial sign in.' ) args = [ 'signin', '{0}.1password.com'.format(self.auto_login['subdomain']), to_bytes(self.auto_login['username']), to_bytes(self.auto_login['secret_key']), '--output=raw', ] try: rc, out, err = self._run( args, command_input=to_bytes(self.auto_login['master_password'])) self.token = out.strip() except AnsibleModuleError as e: module.fail_json( msg="Failed to perform initial sign in to 1Password: %s" % to_native(e)) else: module.fail_json( msg= "Unable to perform an initial sign in to 1Password. Please run '%s sigin' " "or define credentials in 'auto_login'. See the module documentation for details." % self.cli_path)
def modify_dvs_host(self, operation): changed, result = False, None spec = vim.DistributedVirtualSwitch.ConfigSpec() spec.configVersion = self.dv_switch.config.configVersion spec.host = [vim.dvs.HostMember.ConfigSpec()] spec.host[0].operation = operation spec.host[0].host = self.host if self.vendor_specific_config: config = list() for item in self.vendor_specific_config: config.append( vim.dvs.KeyedOpaqueBlob(key=item['key'], opaqueData=item['value'])) spec.host[0].vendorSpecificConfig = config if operation in ("edit", "add"): spec.host[0].backing = vim.dvs.HostMember.PnicBacking() count = 0 for nic in self.vmnics: spec.host[0].backing.pnicSpec.append( vim.dvs.HostMember.PnicSpec()) spec.host[0].backing.pnicSpec[count].pnicDevice = nic spec.host[0].backing.pnicSpec[ count].uplinkPortgroupKey = self.uplink_portgroup.key count += 1 try: task = self.dv_switch.ReconfigureDvs_Task(spec) changed, result = wait_for_task(task) except vmodl.fault.NotSupported as not_supported: self.module.fail_json( msg="Failed to configure DVS host %s as it is not" " compatible with the VDS version." % self.esxi_hostname, details=to_native(not_supported.msg)) return changed, result
def pem_to_der(pem_filename): ''' Load PEM file, and convert to DER. If PEM contains multiple entities, the first entity will be used. ''' certificate_lines = [] try: with open(pem_filename, "rt") as f: header_line_count = 0 for line in f: if line.startswith('-----'): header_line_count += 1 if header_line_count == 2: # If certificate file contains other certs appended # (like intermediate certificates), ignore these. break continue certificate_lines.append(line.strip()) except Exception as err: raise ModuleFailException("cannot load PEM file {0}: {1}".format( pem_filename, to_native(err)), exception=traceback.format_exc()) return base64.b64decode(''.join(certificate_lines))