def check_and_update_node_interfaces(node):
"""Ensure that node interfaces (e.g. for creation or updating) are valid.
Updates interfaces with calculated defaults, if they are not provided.
:param node: node object to check and potentially update
:raises: InterfaceNotFoundInEntrypoint on validation failure
:returns: True if any changes were made to the node, otherwise False
"""
# NOTE(dtantsur): objects raise NotImplementedError on accessing fields
# that are known, but missing from an object. Thus, we cannot just use
# getattr(node, 'network_interface', None) here.
if 'network_interface' in node and node.network_interface is not None:
if node.network_interface not in CONF.enabled_network_interfaces:
raise exception.InterfaceNotFoundInEntrypoint(
iface=node.network_interface,
entrypoint=NetworkInterfaceFactory._entrypoint_name,
valid=NetworkInterfaceFactory().names)
else:
node.network_interface = (
CONF.default_network_interface or
('flat' if CONF.dhcp.dhcp_provider == 'neutron' else 'noop'))
return True
return False
def _attach_interfaces_to_driver(driver, node, driver_name=None):
driver_singleton = get_driver(driver_name or node.driver)
for iface in driver_singleton.all_interfaces:
impl = getattr(driver_singleton, iface, None)
setattr(driver, iface, impl)
network_iface = node.network_interface
network_factory = NetworkInterfaceFactory()
try:
net_driver = network_factory.get_driver(network_iface)
except KeyError:
raise exception.InterfaceNotFoundInEntrypoint(
iface=network_iface,
entrypoint=network_factory._entrypoint_name,
valid=network_factory.names)
driver.network = net_driver
def get_interface(driver_or_hw_type, interface_type, interface_name):
"""Get interface implementation instance.
For hardware types also validates compatibility.
:param driver_or_hw_type: a hardware type or classic driver instance.
:param interface_type: name of the interface type (e.g. 'boot').
:param interface_name: name of the interface implementation from an
appropriate entry point
(ironic.hardware.interfaces.<interface type>).
:returns: instance of the requested interface implementation.
:raises: InterfaceNotFoundInEntrypoint if the entry point was not found.
:raises: IncompatibleInterface if driver_or_hw_type is a hardware type and
the requested implementation is not compatible with it.
"""
factory = _INTERFACE_LOADERS[interface_type]()
try:
impl_instance = factory.get_driver(interface_name)
except KeyError:
raise exception.InterfaceNotFoundInEntrypoint(
iface=interface_name,
entrypoint=factory._entrypoint_name,
valid=factory.names)
if not isinstance(driver_or_hw_type, hardware_type.AbstractHardwareType):
# NOTE(dtantsur): classic drivers do not have notion of compatibility
return impl_instance
if isinstance(driver_or_hw_type, fake_hardware.FakeHardware):
# NOTE(dtantsur): special-case fake hardware type to allow testing with
# any combinations of interface implementations.
return impl_instance
supported_impls = getattr(driver_or_hw_type,
'supported_%s_interfaces' % interface_type)
if type(impl_instance) not in supported_impls:
raise exception.IncompatibleInterface(
interface_type=interface_type,
interface_impl=impl_instance,
hardware_type=driver_or_hw_type.__class__.__name__)
return impl_instance