"""Get the device info according to device class and field."""

try:

devname = os.path.basename(dev)

with open('/sys/class/%s/%s/device/%s' % (devclass, devname, field),

'r') as f:

return f.read().strip()

except IOError:

LOG.warning(

"Can't find field {} for device {} in device class {}".format(

"""Get a dict representation of the system from lshw

out, _e = utils.execute('lshw', '-quiet', '-json', log_stdout=False)

"""Wait for the udev event queue to settle.

try:

utils.execute('udevadm', 'settle')

except processutils.ProcessExecutionError as e:

LOG.warning('Something went wrong when waiting for udev '

'to settle. Error: %s', e)

"""Connect iSCSI shared connected via iBFT or OF.

try:

utils.execute('iscsistart', '-f')

except (processutils.ProcessExecutionError, EnvironmentError) as e:

LOG.debug("No iscsi connection detected. Skipping iscsi. "

"Error: %s", e)

return

try:

utils.execute('iscsistart', '-b')

except processutils.ProcessExecutionError as e:

LOG.warning("Something went wrong executing 'iscsistart -b' "

"""Get the component devices of a Software RAID device.

if not raid_device:

return []

try:

out, _ = utils.execute('mdadm', '--detail', raid_device,

use_standard_locale=True)

except processutils.ProcessExecutionError as e:

msg = ('Could not get component devices of %(dev)s: %(err)s' %

{'dev': raid_device, 'err': e})

LOG.warning(msg)

return []

component_devices = []

lines = out.splitlines()

# the first line contains the md device itself

for line in lines[1:]:

device = re.findall(r'/dev/\w+', line)

component_devices += device

"""Get the holder disks of a Software RAID device.

if not raid_device:

return []

try:

out, _ = utils.execute('mdadm', '--detail', raid_device,

use_standard_locale=True)

except processutils.ProcessExecutionError as e:

msg = ('Could not get holder disks of %(dev)s: %(err)s' %

{'dev': raid_device, 'err': e})

LOG.warning(msg)

return []

holder_disks = []

lines = out.splitlines()

# the first line contains the md device itself

holder_parts = []

for line in lines[1:]:

device = re.findall(r'/dev/\w+', line)

holder_parts += device

for part in holder_parts:

device = utils.extract_device(part)

if not device:

msg = ('Could not get holder disks of %s: unexpected pattern '

'for partition %s') % (raid_device, part)

raise errors.SoftwareRAIDError(msg)

holder_disks.append(device)

"""Check if a device is an md device

try:

utils.execute('mdadm', '--detail', raid_device)

LOG.debug("%s is an md device", raid_device)

return True

except processutils.ProcessExecutionError:

LOG.debug("%s is not an md device", raid_device)

"""Restart an md device

try:

component_devices = _get_component_devices(raid_device)

utils.execute('mdadm', '--stop', raid_device)

utils.execute('mdadm', '--assemble', raid_device,

*component_devices)

except processutils.ProcessExecutionError as e:

error_msg = ('Could not restart md device %(dev)s: %(err)s' %

{'dev': raid_device, 'err': e})

LOG.error(error_msg)

"""Scan all md devices and assemble RAID arrays from them.

try:

utils.execute('mdadm', '--assemble', '--scan', '--verbose')

except processutils.ProcessExecutionError:

ignore_raid=False,

ignore_floppy=True):

"""List all physical block devices

def _is_known_device(existing, new_device_name):

"""Return true if device name is already known."""

for known_dev in existing:

if os.path.join('/dev', new_device_name) == known_dev.name:

return True

return False

_udev_settle()

# map device names to /dev/disk/by-path symbolic links that points to it

by_path_mapping = {}

disk_by_path_dir = '/dev/disk/by-path'

try:

paths = os.listdir(disk_by_path_dir)

for path in paths:

path = os.path.join(disk_by_path_dir, path)

# Turn possibly relative symbolic link into absolute

devname = os.path.join(disk_by_path_dir, os.readlink(path))

devname = os.path.abspath(devname)

by_path_mapping[devname] = path

except OSError as e:

# NOTE(TheJulia): This is for multipath detection, and will raise

# some warning logs with unrelated tests.

LOG.warning("Path %(path)s is inaccessible, /dev/disk/by-path/* "

"version of block device name is unavailable "

"Cause: %(error)s", {'path': disk_by_path_dir, 'error': e})

columns = ['KNAME', 'MODEL', 'SIZE', 'ROTA', 'TYPE']

report = utils.execute('lsblk', '-Pbia', '-o{}'.format(','.join(columns)),

check_exit_code=[0])[0]

lines = report.splitlines()

context = pyudev.Context()

devices = []

for line in lines:

device = {}

# Split into KEY=VAL pairs

vals = shlex.split(line)

for key, val in (v.split('=', 1) for v in vals):

device[key] = val.strip()

# Ignore block types not specified

devtype = device.get('TYPE')

# We already have devices, we should ensure we don't store duplicates.

if _is_known_device(devices, device.get('KNAME')):

continue

# If we collected the RM column, we could consult it for removable

# media, however USB devices are also flagged as removable media.

# we have to explicitly do this as floppy disks are type disk.

if ignore_floppy and str(device.get('KNAME')).startswith('fd'):

LOG.debug('Ignoring floppy disk device %s', device)

continue

# Search for raid in the reply type, as RAID is a

# disk device, and we should honor it if is present.

# Other possible type values, which we skip recording:

# lvm, part, rom, loop

if devtype != block_type:

if (devtype is not None and

any(x in devtype for x in ['raid', 'md']) and

not ignore_raid):

LOG.debug(

"TYPE detected to contain 'raid' or 'md', signifying a "

"RAID volume. Found: {!r}".format(line))

else:

LOG.debug(

"TYPE did not match. Wanted: {!r} but found: {!r}".format(

block_type, line))

continue

# Ensure all required columns are at least present, even if blank

missing = set(columns) - set(device)

if missing:

raise errors.BlockDeviceError(

'%s must be returned by lsblk.' % ', '.join(sorted(missing)))

# NOTE(dtantsur): RAM disks and zRAM devices appear in the output of

# lsblk as disks, but we cannot do anything useful with them.

if (device['KNAME'].startswith('ram')

or device['KNAME'].startswith('zram')):

LOG.debug('Skipping RAM device %s', device)

continue

name = os.path.join('/dev', device['KNAME'])

try:

udev = pyudev.Devices.from_device_file(context, name)

except pyudev.DeviceNotFoundByFileError as e:

LOG.warning("Device %(dev)s is inaccessible, skipping... "

"Error: %(error)s", {'dev': name, 'error': e})

extra = {}

else:

# TODO(lucasagomes): Since lsblk only supports

# returning the short serial we are using

# ID_SERIAL_SHORT here to keep compatibility with the

# bash deploy ramdisk

extra = {key: udev.get('ID_%s' % udev_key) for key, udev_key in

[('wwn', 'WWN'), ('serial', 'SERIAL_SHORT'),

('wwn_with_extension', 'WWN_WITH_EXTENSION'),

('wwn_vendor_extension', 'WWN_VENDOR_EXTENSION')]}

# NOTE(lucasagomes): Newer versions of the lsblk tool supports

# HCTL as a parameter but let's get it from sysfs to avoid breaking

# old distros.

try:

extra['hctl'] = os.listdir(

'/sys/block/%s/device/scsi_device' % device['KNAME'])[0]

except (OSError, IndexError):

LOG.warning('Could not find the SCSI address (HCTL) for '

'device %s. Skipping', name)

# Not all /dev entries are pointed to from /dev/disk/by-path

by_path_name = by_path_mapping.get(name)

devices.append(BlockDevice(name=name,

model=device['MODEL'],

size=int(device['SIZE'] or 0),

rotational=bool(int(device['ROTA'])),

vendor=_get_device_info(device['KNAME'],

'block', 'vendor'),

by_path=by_path_name,

**extra))

"""Example priorities for hardware managers.

NONE = 0

GENERIC = 1

MAINLINE = 2

serializable_fields = ('name', 'model', 'size', 'rotational',

'wwn', 'serial', 'vendor', 'wwn_with_extension',

'wwn_vendor_extension', 'hctl', 'by_path')

def __init__(self, name, model, size, rotational, wwn=None, serial=None,

vendor=None, wwn_with_extension=None,

wwn_vendor_extension=None, hctl=None, by_path=None):

self.name = name

self.model = model

self.size = size

self.rotational = rotational

self.wwn = wwn

self.serial = serial

self.vendor = vendor

self.wwn_with_extension = wwn_with_extension

self.wwn_vendor_extension = wwn_vendor_extension

self.hctl = hctl

serializable_fields = ('name', 'mac_address', 'ipv4_address',

'ipv6_address', 'has_carrier', 'lldp',

'vendor', 'product', 'client_id',

'biosdevname')

def __init__(self, name, mac_addr, ipv4_address=None, ipv6_address=None,

has_carrier=True, lldp=None, vendor=None, product=None,

client_id=None, biosdevname=None):

self.name = name

self.mac_address = mac_addr

self.ipv4_address = ipv4_address

self.ipv6_address = ipv6_address

self.has_carrier = has_carrier

self.lldp = lldp

self.vendor = vendor

self.product = product

self.biosdevname = biosdevname

# client_id is used for InfiniBand only. we calculate the DHCP

# client identifier Option to allow DHCP to work over InfiniBand.

# see https://tools.ietf.org/html/rfc4390

serializable_fields = ('model_name', 'frequency', 'count', 'architecture',

'flags')

def __init__(self, model_name, frequency, count, architecture,

flags=None):

self.model_name = model_name

self.frequency = frequency

self.count = count

self.architecture = architecture

serializable_fields = ('total', 'physical_mb')

# physical = total + kernel binary + reserved space

def __init__(self, total, physical_mb=None):

self.total = total

serializable_fields = ('product_name', 'serial_number', 'manufacturer')

def __init__(self, product_name, serial_number, manufacturer):

self.product_name = product_name

self.serial_number = serial_number

serializable_fields = ('current_boot_mode', 'pxe_interface')

def __init__(self, current_boot_mode, pxe_interface=None):

self.current_boot_mode = current_boot_mode

@abc.abstractmethod

def evaluate_hardware_support(self):

pass

def list_network_interfaces(self):

raise errors.IncompatibleHardwareMethodError

def get_cpus(self):

raise errors.IncompatibleHardwareMethodError

def list_block_devices(self, include_partitions=False):

"""List physical block devices

raise errors.IncompatibleHardwareMethodError

def get_memory(self):

raise errors.IncompatibleHardwareMethodError

def get_os_install_device(self):

raise errors.IncompatibleHardwareMethodError

def get_bmc_address(self):

raise errors.IncompatibleHardwareMethodError()

def get_bmc_v6address(self):

raise errors.IncompatibleHardwareMethodError()

def get_boot_info(self):

raise errors.IncompatibleHardwareMethodError()

def get_interface_info(self, interface_name):

raise errors.IncompatibleHardwareMethodError()

def erase_block_device(self, node, block_device):

"""Attempt to erase a block device.

raise errors.IncompatibleHardwareMethodError

def erase_devices(self, node, ports):

"""Erase any device that holds user data.

erase_results = {}

block_devices = self.list_block_devices()

if not len(block_devices):

return {}

info = node.get('driver_internal_info', {})

max_pool_size = info.get('disk_erasure_concurrency', 1)

thread_pool = ThreadPool(min(max_pool_size, len(block_devices)))

for block_device in block_devices:

params = {'node': node, 'block_device': block_device}

erase_results[block_device.name] = thread_pool.apply_async(

dispatch_to_managers, ('erase_block_device',), params)

thread_pool.close()

thread_pool.join()

for device_name, result in erase_results.items():

erase_results[device_name] = result.get()

return erase_results

def wait_for_disks(self):

"""Wait for the root disk to appear.

if not CONF.disk_wait_attempts:

return

max_waits = CONF.disk_wait_attempts - 1

for attempt in range(CONF.disk_wait_attempts):

try:

self.get_os_install_device()

except errors.DeviceNotFound:

LOG.debug('Still waiting for the root device to appear, '

'attempt %d of %d', attempt + 1,

CONF.disk_wait_attempts)

if attempt < max_waits:

time.sleep(CONF.disk_wait_delay)

else:

break

else:

if max_waits:

LOG.warning('The root device was not detected in %d seconds',

CONF.disk_wait_delay * max_waits)

else:

LOG.warning('The root device was not detected')

def list_hardware_info(self):

"""Return full hardware inventory as a serializable dict.

# NOTE(dtantsur): don't forget to update docs when extending inventory

hardware_info = {}

hardware_info['interfaces'] = self.list_network_interfaces()

hardware_info['cpu'] = self.get_cpus()

hardware_info['disks'] = self.list_block_devices()

hardware_info['memory'] = self.get_memory()

hardware_info['bmc_address'] = self.get_bmc_address()

hardware_info['bmc_v6address'] = self.get_bmc_v6address()

hardware_info['system_vendor'] = self.get_system_vendor_info()

hardware_info['boot'] = self.get_boot_info()

hardware_info['hostname'] = netutils.get_hostname()

return hardware_info

def get_clean_steps(self, node, ports):

"""Get a list of clean steps with priority.

return []

def get_version(self):

"""Get a name and version for this hardware manager.

return {

'name': getattr(self, 'HARDWARE_MANAGER_NAME',

type(self).__name__),

'version': getattr(self, 'HARDWARE_MANAGER_VERSION', '1.0')

HARDWARE_MANAGER_NAME = 'generic_hardware_manager'

# 1.1 - Added new clean step called erase_devices_metadata

HARDWARE_MANAGER_VERSION = '1.1'

def __init__(self):

self.sys_path = '/sys'

self.lldp_data = {}

def evaluate_hardware_support(self):

# Do some initialization before we declare ourself ready

_check_for_iscsi()

_md_scan_and_assemble()

self.wait_for_disks()

return HardwareSupport.GENERIC

def collect_lldp_data(self, interface_names):

"""Collect and convert LLDP info from the node.

interface_names = [name for name in interface_names if name != 'lo']

lldp_data = {}

try:

raw_lldp_data = netutils.get_lldp_info(interface_names)

except Exception:

# NOTE(sambetts) The get_lldp_info function will log this exception

# and we don't invalidate any existing data in the cache if we fail

# to get data to replace it so just return.

return lldp_data

for ifname, tlvs in raw_lldp_data.items():

# NOTE(sambetts) Convert each type-length-value (TLV) value to hex

# so that it can be serialised safely

processed_tlvs = []

for typ, data in tlvs:

try:

processed_tlvs.append((typ,

binascii.hexlify(data).decode()))

except (binascii.Error, binascii.Incomplete) as e:

LOG.warning('An error occurred while processing TLV type '

'%s for interface %s: %s', (typ, ifname, e))

lldp_data[ifname] = processed_tlvs

return lldp_data

def _get_lldp_data(self, interface_name):

if self.lldp_data:

return self.lldp_data.get(interface_name)

def get_interface_info(self, interface_name):

mac_addr = netutils.get_mac_addr(interface_name)

if mac_addr is None:

raise errors.IncompatibleHardwareMethodError()

return NetworkInterface(

interface_name, mac_addr,

ipv4_address=self.get_ipv4_addr(interface_name),

ipv6_address=self.get_ipv6_addr(interface_name),

has_carrier=netutils.interface_has_carrier(interface_name),

vendor=_get_device_info(interface_name, 'net', 'vendor'),

product=_get_device_info(interface_name, 'net', 'device'),

biosdevname=self.get_bios_given_nic_name(interface_name))

def get_ipv4_addr(self, interface_id):

return netutils.get_ipv4_addr(interface_id)

def get_ipv6_addr(self, interface_id):

"""Get the default IPv6 address assigned to the interface.

return netutils.get_ipv6_addr(interface_id)

def get_bios_given_nic_name(self, interface_name):

"""Collect the BIOS given NICs name.

global WARN_BIOSDEVNAME_NOT_FOUND

try:

stdout, _ = utils.execute('biosdevname', '-i',

interface_name)

return stdout.rstrip('\n')

except OSError:

if not WARN_BIOSDEVNAME_NOT_FOUND:

LOG.warning("Executable 'biosdevname' not found")

WARN_BIOSDEVNAME_NOT_FOUND = True

except processutils.ProcessExecutionError as e:

# NOTE(alezil) biosdevname returns 4 if running in a

# virtual machine.

if e.exit_code == 4:

LOG.info('The system is a virtual machine, so biosdevname '

'utility does not provide names for virtual NICs.')

else:

LOG.warning('Biosdevname returned exit code %s', e.exit_code)

def _is_device(self, interface_name):

device_path = '{}/class/net/{}/device'.format(self.sys_path,

interface_name)

return os.path.exists(device_path)

def list_network_interfaces(self):

network_interfaces_list = []

iface_names = os.listdir('{}/class/net'.format(self.sys_path))

iface_names = [name for name in iface_names if self._is_device(name)]

if CONF.collect_lldp:

self.lldp_data = dispatch_to_managers('collect_lldp_data',

interface_names=iface_names)

for iface_name in iface_names:

result = dispatch_to_managers(

'get_interface_info', interface_name=iface_name)

result.lldp = self._get_lldp_data(iface_name)

network_interfaces_list.append(result)

return network_interfaces_list

def get_cpus(self):

lines = utils.execute('lscpu')[0]

cpu_info = {k.strip().lower(): v.strip() for k, v in

(line.split(':', 1)

for line in lines.split('\n')

if line.strip())}

# Current CPU frequency can be different from maximum one on modern

# processors

freq = cpu_info.get('cpu max mhz', cpu_info.get('cpu mhz'))

flags = []

out = utils.try_execute('grep', '-Em1', '^flags', '/proc/cpuinfo')

if out:

try:

# Example output (much longer for a real system):

# flags : fpu vme de pse

flags = out[0].strip().split(':', 1)[1].strip().split()

except (IndexError, ValueError):

LOG.warning('Malformed CPU flags information: %s', out)

else:

LOG.warning('Failed to get CPU flags')

return CPU(model_name=cpu_info.get('model name'),

frequency=freq,

# this includes hyperthreading cores

count=int(cpu_info.get('cpu(s)')),

architecture=cpu_info.get('architecture'),

flags=flags)

def get_memory(self):

# psutil returns a long, so we force it to an int

try:

total = int(psutil.virtual_memory().total)

except Exception:

# This is explicitly catching all exceptions. We want to catch any

# situation where a newly upgraded psutil would fail, and instead

# print an error instead of blowing up the stack on IPA.

total = None

LOG.exception(("Cannot fetch total memory size using psutil "

"version %s"), psutil.version_info[0])

sys_dict = None

try:

sys_dict = _get_system_lshw_dict()

except (processutils.ProcessExecutionError, OSError, ValueError) as e:

LOG.warning('Could not get real physical RAM from lshw: %s', e)

physical = None

else:

physical = 0

# locate memory information in system_dict

for sys_child in sys_dict['children']:

if sys_child['id'] == 'core':

for core_child in sys_child['children']:

if _MEMORY_ID_RE.match(core_child['id']):

if (not core_child.get("children") and

core_child.get('size')):

value = ("%(size)s %(units)s" % core_child)

physical += int(UNIT_CONVERTER(value).to

('MB').magnitude)

for bank in core_child.get('children', ()):

if bank.get('size'):

value = ("%(size)s %(units)s" % bank)

physical += int(UNIT_CONVERTER(value).to

('MB').magnitude)

if not physical:

LOG.warning('Did not find any physical RAM')

return Memory(total=total, physical_mb=physical)

def list_block_devices(self, include_partitions=False):

block_devices = list_all_block_devices()

if include_partitions:

block_devices.extend(

list_all_block_devices(block_type='part',

ignore_raid=True)

)

return block_devices

def get_os_install_device(self):

cached_node = get_cached_node()

root_device_hints = None

if cached_node is not None:

root_device_hints = cached_node['properties'].get('root_device')

LOG.debug('Looking for a device matching root hints %s',

root_device_hints)

block_devices = self.list_block_devices()

if not root_device_hints:

dev_name = utils.guess_root_disk(block_devices).name

else:

serialized_devs = [dev.serialize() for dev in block_devices]

try:

device = il_utils.match_root_device_hints(serialized_devs,

root_device_hints)

except ValueError as e:

# NOTE(lucasagomes): Just playing on the safe side

# here, this exception should never be raised because

# Ironic should validate the root device hints before the

# deployment starts.

raise errors.DeviceNotFound(

'No devices could be found using the root device hints '

'%(hints)s because they failed to validate. Error: '

'%(error)s' % {'hints': root_device_hints, 'error': e})

if not device:

raise errors.DeviceNotFound(

"No suitable device was found for "

"deployment using these hints %s" % root_device_hints)

dev_name = device['name']

LOG.info('Picked root device %(dev)s for node %(node)s based on '

'root device hints %(hints)s',

{'dev': dev_name, 'hints': root_device_hints,

'node': cached_node['uuid'] if cached_node else None})

return dev_name

def get_system_vendor_info(self):

try:

sys_dict = _get_system_lshw_dict()

except (processutils.ProcessExecutionError, OSError, ValueError) as e:

LOG.warning('Could not retrieve vendor info from lshw: %s', e)

sys_dict = {}

return SystemVendorInfo(product_name=sys_dict.get('product', ''),

serial_number=sys_dict.get('serial', ''),

manufacturer=sys_dict.get('vendor', ''))

def get_boot_info(self):

boot_mode = 'uefi' if os.path.isdir('/sys/firmware/efi') else 'bios'

LOG.debug('The current boot mode is %s', boot_mode)

pxe_interface = utils.get_agent_params().get('BOOTIF')

return BootInfo(current_boot_mode=boot_mode,

pxe_interface=pxe_interface)

def erase_block_device(self, node, block_device):

# Check if the block device is virtual media and skip the device.

if self._is_virtual_media_device(block_device):

LOG.info("Skipping erase of virtual media device %s",

block_device.name)

return

if self._is_linux_raid_member(block_device):

LOG.info("Skipping erase of RAID member device %s",

block_device.name)

return