def test_class_variables(self):
self.assertEqual(['boot', 'deploy', 'management', 'network', 'power'],
driver_base.BareDriver().core_interfaces)
self.assertEqual(
['bios', 'console', 'inspect', 'raid', 'rescue', 'storage'],
driver_base.BareDriver().optional_interfaces
)
def build_driver_for_task(task):
"""Builds a composable driver for a given task.
Starts with a `BareDriver` object, and attaches implementations of the
various driver interfaces to it. They come from separate
driver factories and are configurable via the database.
:param task: The task containing the node to build a driver for.
:returns: A driver object for the task.
:raises: DriverNotFound if node.driver could not be found in the
"ironic.hardware.types" namespaces.
:raises: InterfaceNotFoundInEntrypoint if some node interfaces are set
to invalid or unsupported values.
:raises: IncompatibleInterface the requested implementation is not
compatible with it with the hardware type.
"""
node = task.node
hw_type = get_hardware_type(node.driver)
check_and_update_node_interfaces(node, hw_type=hw_type)
bare_driver = driver_base.BareDriver()
_attach_interfaces_to_driver(bare_driver, node, hw_type)
return bare_driver
def build_driver_for_task(task, driver_name=None):
"""Builds a composable driver for a given task.
Starts with a `BareDriver` object, and attaches implementations of the
various driver interfaces to it. For classic drivers these all come from
the monolithic driver singleton, for hardware types - from separate
driver factories and are configurable via the database.
:param task: The task containing the node to build a driver for.
:param driver_name: The name of the classic driver or hardware type to use
as a base, if different than task.node.driver.
:returns: A driver object for the task.
:raises: DriverNotFound if node.driver could not be found in either
"ironic.drivers" or "ironic.hardware.types" namespaces.
:raises: InterfaceNotFoundInEntrypoint if some node interfaces are set
to invalid or unsupported values.
:raises: IncompatibleInterface if driver is a hardware type and
the requested implementation is not compatible with it.
"""
node = task.node
driver_name = driver_name or node.driver
driver_or_hw_type = get_driver_or_hardware_type(driver_name)
check_and_update_node_interfaces(node, driver_or_hw_type=driver_or_hw_type)
bare_driver = driver_base.BareDriver()
_attach_interfaces_to_driver(bare_driver, node, driver_or_hw_type)
return bare_driver
def test_class_variables_immutable(self):
# Test to make sure that our *_interfaces variables in the class don't
# get modified by a child class
self.assertEqual(('deploy', 'power'),
driver_base.BaseDriver.core_interfaces)
self.assertEqual(('boot', 'console', 'inspect', 'management', 'raid'),
driver_base.BaseDriver.standard_interfaces)
# Ensure that instantiating an instance of a derived class does not
# change our variables.
driver_base.BareDriver()
self.assertEqual(('deploy', 'power'),
driver_base.BaseDriver.core_interfaces)
self.assertEqual(('boot', 'console', 'inspect', 'management', 'raid'),
driver_base.BaseDriver.standard_interfaces)
def build_driver_for_task(task, driver_name=None):
"""Builds a composable driver for a given task.
Starts with a `BareDriver` object, and attaches implementations of the
various driver interfaces to it. Currently these all come from the
monolithic driver singleton, but later will come from separate
driver factories and configurable via the database.
:param task: The task containing the node to build a driver for.
:param driver_name: The name of the monolithic driver to use as a base,
if different than task.node.driver.
:returns: A driver object for the task.
:raises: DriverNotFound if node.driver could not be
found in the "ironic.drivers" namespace.
"""
node = task.node
driver = driver_base.BareDriver()
_attach_interfaces_to_driver(driver, node, driver_name=driver_name)
return driver
def build_driver_for_task(task, driver_name=None):
"""Builds a composable driver for a given task.
Starts with a `BareDriver` object, and attaches implementations of the
various driver interfaces to it. For classic drivers these all come from
the monolithic driver singleton, for hardware types - from separate
driver factories and are configurable via the database.
:param task: The task containing the node to build a driver for.
:param driver_name: The name of the classic driver or hardware type to use
as a base, if different than task.node.driver.
:returns: A driver object for the task.
:raises: DriverNotFound if node.driver could not be found in either
"ironic.drivers" or "ironic.hardware.types" namespaces.
:raises: InterfaceNotFoundInEntrypoint if some node interfaces are set
to invalid or unsupported values.
:raises: IncompatibleInterface if driver is a hardware type and
the requested implementation is not compatible with it.
"""
node = task.node
driver_name = driver_name or node.driver
driver_or_hw_type = get_driver_or_hardware_type(driver_name)
try:
check_and_update_node_interfaces(node,
driver_or_hw_type=driver_or_hw_type)
except exception.MustBeNone as e:
# NOTE(rloo). This was raised because nodes with classic drivers
# cannot have any interfaces (except for network and
# storage) set. However, there was a small window
# where this was possible so instead of breaking those
# users totally, we'll spam them with warnings instead.
LOG.warning(
'%s They will be ignored. To avoid this warning, '
'please set them to None.', e)
bare_driver = driver_base.BareDriver()
_attach_interfaces_to_driver(bare_driver, node, driver_or_hw_type)
return bare_driver
def supported_raid_interfaces(self):
"""List of supported raid interfaces."""
return [fake.FakeRAID]
@property
def supported_rescue_interfaces(self):
"""List of supported rescue interfaces."""
return [fake.FakeRescue]
@property
def supported_vendor_interfaces(self):
"""List of supported rescue interfaces."""
return [fake.FakeVendorB, fake.FakeVendorA]
OPTIONAL_INTERFACES = (set(drivers_base.BareDriver().standard_interfaces) -
{'management', 'boot'}) | {'vendor'}
class HardwareTypeLoadTestCase(db_base.DbTestCase):
def setUp(self):
super(HardwareTypeLoadTestCase, self).setUp()
self.config(dhcp_provider=None, group='dhcp')
self.ifaces = {}
self.node_kwargs = {}
for iface in drivers_base.ALL_INTERFACES:
if iface == 'network':
self.ifaces[iface] = 'noop'
enabled = ['noop']
elif iface == 'storage':
self.ifaces[iface] = 'noop'
"""List of supported raid interfaces."""
return [fake.FakeRAID]
@property
def supported_rescue_interfaces(self):
"""List of supported rescue interfaces."""
return [fake.FakeRescue]
@property
def supported_vendor_interfaces(self):
"""List of supported rescue interfaces."""
return [fake.FakeVendorB, fake.FakeVendorA]
OPTIONAL_INTERFACES = set(
drivers_base.BareDriver().standard_interfaces) - {'management', 'boot'}
class HardwareTypeLoadTestCase(db_base.DbTestCase):
def setUp(self):
super(HardwareTypeLoadTestCase, self).setUp()
self.config(dhcp_provider=None, group='dhcp')
self.ifaces = {}
self.node_kwargs = {}
for iface in drivers_base.ALL_INTERFACES:
if iface == 'network':
self.ifaces[iface] = 'noop'
enabled = ['noop']
elif iface == 'storage':
self.ifaces[iface] = 'noop'
enabled = ['noop']
def supported_raid_interfaces(self):
"""List of supported raid interfaces."""
return [fake.FakeRAID]
@property
def supported_rescue_interfaces(self):
"""List of supported rescue interfaces."""
return [fake.FakeRescue]
@property
def supported_vendor_interfaces(self):
"""List of supported rescue interfaces."""
return [fake.FakeVendorB, fake.FakeVendorA]
OPTIONAL_INTERFACES = (drivers_base.BareDriver().optional_interfaces +
['vendor'])
class HardwareTypeLoadTestCase(db_base.DbTestCase):
def setUp(self):
super(HardwareTypeLoadTestCase, self).setUp()
self.config(dhcp_provider=None, group='dhcp')
self.ifaces = {}
self.node_kwargs = {}
for iface in drivers_base.ALL_INTERFACES:
if iface == 'network':
self.ifaces[iface] = 'noop'
enabled = ['noop']
elif iface == 'storage':
self.ifaces[iface] = 'noop'
