Get uefi iscsi boot string for the host

        :returns: iscsi boot string for the system
        :raises: IloError, on an error from iLO.
348348
def get_uefi_boot_string(self, mac):
        
        boot_sources = self.boot_sources
        if not boot_sources:
            msg = ('Boot sources are not found')
            LOG.debug(msg)
            raise exception.IloError(msg)

        for boot_source in boot_sources:
            if (mac.upper() in boot_source['UEFIDevicePath'] and
                    'iSCSI' in boot_source['UEFIDevicePath']):
                return boot_source['StructuredBootString']
        else:
            msg = ('MAC provided "%s" is Invalid' % mac)
            raise exception.IloInvalidInputError(msg)
303421
def get_host_cpu_name():
    
    with ffi.OutputString() as out:
        ffi.lib.LLVMPY_GetHostCPUName(out)
        return str(out)
450290
def get_canonical_host(self):
        
        host = self.host.lower()
        if self.port is not None:
            host = "%s:%s" % (host, self.port)
        return host
661807
def get_iface_mode(iface):
    
    p = subprocess.Popen(["iwconfig", iface], stdout=subprocess.PIPE,
                         stderr=subprocess.STDOUT)
    output, err = p.communicate()
    match = re.search(br"mode:([a-zA-Z]*)", output.lower())
    if match:
        return plain_str(match.group(1))
    return "unknown"
141591
def get_pending_boot_mode(self):
        
        headers, uri, bios_settings = self._check_bios_resource(['BootMode'])
        _, _, settings = self._get_bios_settings_resource(bios_settings)
        boot_mode = settings.get('BootMode')
        if boot_mode == 'LegacyBios':
            boot_mode = 'legacy'
        return boot_mode.upper()
9162
def _get_hba_type(hba_type):
    '''
    
    '''
    if hba_type == "parallel":
        return vim.host.ParallelScsiHba
    elif hba_type == "block":
        return vim.host.BlockHba
    elif hba_type == "iscsi":
        return vim.host.InternetScsiHba
    elif hba_type == "fibre":
        return vim.host.FibreChannelHba

    raise ValueError('Unknown Host Bus Adapter Type')
325675
def iscsi_iqn():
    '''
    
    '''
    grains = {}
    grains['iscsi_iqn'] = False
    if salt.utils.platform.is_linux():
        grains['iscsi_iqn'] = _linux_iqn()
    elif salt.utils.platform.is_windows():
        grains['iscsi_iqn'] = _windows_iqn()
    elif salt.utils.platform.is_aix():
        grains['iscsi_iqn'] = _aix_iqn()
    return grains
327419
def _get_interface_name_from_hosting_port(self, port):
        
        try:
            vlan = port['hosting_info']['segmentation_id']
            int_prefix = port['hosting_info']['physical_interface']
            return '%s.%s' % (int_prefix, vlan)
        except KeyError as e:
            params = {'key': e}
            raise cfg_exc.DriverExpectedKeyNotSetException(**params)
866684
def unit_system_id(self):
        
        if self._unit_system_id is None:
            hash_data = bytearray()
            for k, v in sorted(self.lut.items()):
                hash_data.extend(k.encode("utf8"))
                hash_data.extend(repr(v).encode("utf8"))
            m = md5()
            m.update(hash_data)
            self._unit_system_id = str(m.hexdigest())
        return self._unit_system_id
580612
def clear_secure_boot_keys(self):
        
        if self._is_boot_mode_uefi():
            self._change_secure_boot_settings('ResetAllKeys', True)
        else:
            msg = ('System is not in UEFI boot mode. "SecureBoot" related '
                   'resources cannot be changed.')
            raise exception.IloCommandNotSupportedInBiosError(msg)
312849
def unset_iscsi_info(self):
        
        if(self._is_boot_mode_uefi()):
            iscsi_info = {'iSCSIConnection': 'Disabled'}
            self._change_iscsi_target_settings(iscsi_info)
        else:
            msg = 'iSCSI boot is not supported in the BIOS boot mode'
            raise exception.IloCommandNotSupportedInBiosError(msg)
476220
def _get_interfaces(self):
        
        ios_cfg = self._get_running_config()
        parse = HTParser(ios_cfg)
        itfcs_raw = parse.find_lines("^interface GigabitEthernet")
        itfcs = [raw_if.strip().split(' ')[1] for raw_if in itfcs_raw]
        LOG.debug("Interfaces on hosting device: %s", itfcs)
        return itfcs
1023014
def get_IO_reg(bus, addr, bank):
    
    output_map = [0x14, 0x15]
    if (bank != 0) and (bank != 1):
        print()
        raise InvalidIOUsage("An invalid IO bank has been selected")

    output_reg = output_map[bank]
    current_status = bus.read_byte_data(addr, output_reg)
    return current_status
1053592
def getAddr (self, ifname):
        
        if sys.platform == 'darwin':
            return ifconfig_inet(ifname).get('address')
        return self._getaddr(ifname, self.SIOCGIFADDR)
719277
def get_entry_type(hosts_entry=None):
        
        if hosts_entry and isinstance(hosts_entry, str):
            entry = hosts_entry.strip()
            if not entry or not entry[0] or entry[0] == "\n":
                return 'blank'
            if entry[0] == "#":
                return 'comment'
            entry_chunks = entry.split()
            if is_ipv6(entry_chunks[0]):
                return 'ipv6'
            if is_ipv4(entry_chunks[0]):
                return 'ipv4'
1256232
def _get_instance_key(self, host, namespace, wmi_class, other=None):
        
        if other:
            return "{host}:{namespace}:{wmi_class}-{other}".format(
                host=host, namespace=namespace, wmi_class=wmi_class, other=other
            )

        return "{host}:{namespace}:{wmi_class}".format(host=host, namespace=namespace, wmi_class=wmi_class)
754914
def update_boot_system_use(self, boot_sys_use):
        # type: (bytes) -> None
        '''
        
        '''
        if not self._initialized:
            raise pycdlibexception.PyCdlibInternalError('Boot Record not yet initialized')

        self.boot_system_use = boot_sys_use.ljust(197, b'\x00')