diff --git a/ironic/common/pxe_utils.py b/ironic/common/pxe_utils.py index 7dd4e00f1b..37e6ffd255 100644 --- a/ironic/common/pxe_utils.py +++ b/ironic/common/pxe_utils.py @@ -33,6 +33,7 @@ from ironic.common import utils from ironic.conf import CONF from ironic.drivers.modules import boot_mode_utils from ironic.drivers.modules import deploy_utils +from ironic.drivers.modules import image_cache from ironic import objects LOG = logging.getLogger(__name__) @@ -857,3 +858,48 @@ def prepare_instance_pxe_config(task, image_info, boot_mode_utils.get_boot_mode_for_deploy(node), False, iscsi_boot=iscsi_boot, ramdisk_boot=ramdisk_boot, ipxe_enabled=ipxe_enabled) + + +@image_cache.cleanup(priority=25) +class TFTPImageCache(image_cache.ImageCache): + def __init__(self): + super(TFTPImageCache, self).__init__( + CONF.pxe.tftp_master_path, + # MiB -> B + cache_size=CONF.pxe.image_cache_size * 1024 * 1024, + # min -> sec + cache_ttl=CONF.pxe.image_cache_ttl * 60) + + +def cache_ramdisk_kernel(task, pxe_info): + """Fetch the necessary kernels and ramdisks for the instance.""" + ctx = task.context + node = task.node + if is_ipxe_enabled(task): + path = os.path.join(get_ipxe_root_dir(), node.uuid) + else: + path = os.path.join(get_root_dir(), node.uuid) + fileutils.ensure_tree(path) + LOG.debug("Fetching necessary kernel and ramdisk for node %s", + node.uuid) + deploy_utils.fetch_images(ctx, TFTPImageCache(), list(pxe_info.values()), + CONF.force_raw_images) + + +def clean_up_pxe_env(task, images_info): + """Cleanup PXE environment of all the images in images_info. + + Cleans up the PXE environment for the mentioned images in + images_info. + + :param task: a TaskManager object + :param images_info: A dictionary of images whose keys are the image names + to be cleaned up (kernel, ramdisk, etc) and values are a tuple of + identifier and absolute path. + """ + for label in images_info: + path = images_info[label][1] + ironic_utils.unlink_without_raise(path) + + clean_up_pxe_config(task) + TFTPImageCache().clean_up() diff --git a/ironic/drivers/modules/ipxe.py b/ironic/drivers/modules/ipxe.py index 160f7275ad..43c4e6ecc0 100644 --- a/ironic/drivers/modules/ipxe.py +++ b/ironic/drivers/modules/ipxe.py @@ -24,7 +24,7 @@ from ironic.common import dhcp_factory from ironic.common import exception from ironic.common.glance_service import service_utils from ironic.common.i18n import _ -from ironic.common import pxe_utils as common_pxe_utils +from ironic.common import pxe_utils as pxe_utils from ironic.common import states from ironic.conductor import utils as manager_utils from ironic.conf import CONF @@ -70,7 +70,7 @@ class iPXEBoot(base.BootInterface): capabilities = ['iscsi_volume_boot', 'ramdisk_boot', 'ipxe_boot'] def __init__(self): - common_pxe_utils.create_ipxe_boot_script() + pxe_utils.create_ipxe_boot_script() def get_properties(self): """Return the properties of the interface. @@ -126,7 +126,7 @@ class iPXEBoot(base.BootInterface): {'node': node.uuid}) pxe.validate_boot_parameters_for_trusted_boot(node) - pxe._parse_driver_info(node) + pxe_utils.parse_driver_info(node) # NOTE(TheJulia): If we're not writing an image, we can skip # the remainder of this method. if (not task.driver.storage.should_write_image(task)): @@ -174,29 +174,29 @@ class iPXEBoot(base.BootInterface): # call the boot script create method here to assert its # existence and handle the unlikely case that it wasn't created # or was deleted. - common_pxe_utils.create_ipxe_boot_script() + pxe_utils.create_ipxe_boot_script() - dhcp_opts = common_pxe_utils.dhcp_options_for_instance(task) + dhcp_opts = pxe_utils.dhcp_options_for_instance(task) provider = dhcp_factory.DHCPFactory() provider.update_dhcp(task, dhcp_opts) - pxe_info = pxe._get_image_info(node, mode=mode) + pxe_info = pxe_utils.get_image_info(node, mode=mode) # NODE: Try to validate and fetch instance images only # if we are in DEPLOYING state. if node.provision_state == states.DEPLOYING: pxe_info.update( - pxe._get_instance_image_info(task, ipxe_enabled=True)) + pxe_utils.get_instance_image_info(task, ipxe_enabled=True)) boot_mode_utils.sync_boot_mode(task) - pxe_options = pxe._build_pxe_config_options(task, pxe_info) + pxe_options = pxe_utils.build_pxe_config_options(task, pxe_info) pxe_options.update(ramdisk_params) pxe_config_template = deploy_utils.get_pxe_config_template(node) - common_pxe_utils.create_pxe_config(task, pxe_options, - pxe_config_template, - ipxe_enabled=True) + pxe_utils.create_pxe_config(task, pxe_options, + pxe_config_template, + ipxe_enabled=True) persistent = strutils.bool_from_string( node.driver_info.get('force_persistent_boot_device', False)) @@ -210,7 +210,7 @@ class iPXEBoot(base.BootInterface): pxe_info.pop(ramdisk_label, None) if pxe_info: - pxe._cache_ramdisk_kernel(task, pxe_info) + pxe_utils.cache_ramdisk_kernel(task, pxe_info) @METRICS.timer('iPXEBoot.clean_up_ramdisk') def clean_up_ramdisk(self, task): @@ -231,13 +231,13 @@ class iPXEBoot(base.BootInterface): node = task.node mode = deploy_utils.rescue_or_deploy_mode(node) try: - images_info = pxe._get_image_info(node, mode=mode) + images_info = pxe_utils.get_image_info(node, mode=mode) except exception.MissingParameterValue as e: LOG.warning('Could not get %(mode)s image info ' 'to clean up images for node %(node)s: %(err)s', {'mode': mode, 'node': node.uuid, 'err': e}) else: - pxe._clean_up_pxe_env(task, images_info) + pxe_utils.clean_up_pxe_env(task, images_info) @METRICS.timer('iPXEBoot.prepare_instance') def prepare_instance(self, task): @@ -259,12 +259,12 @@ class iPXEBoot(base.BootInterface): instance_image_info = {} if boot_option == "ramdisk": - instance_image_info = pxe._get_instance_image_info( + instance_image_info = pxe_utils.get_instance_image_info( task, ipxe_enabled=True) - pxe._cache_ramdisk_kernel(task, instance_image_info) + pxe_utils.cache_ramdisk_kernel(task, instance_image_info) if deploy_utils.is_iscsi_boot(task) or boot_option == "ramdisk": - pxe._prepare_instance_pxe_config( + pxe_utils.prepare_instance_pxe_config( task, instance_image_info, iscsi_boot=deploy_utils.is_iscsi_boot(task), ramdisk_boot=(boot_option == "ramdisk"), @@ -275,12 +275,12 @@ class iPXEBoot(base.BootInterface): if task.driver.storage.should_write_image(task): # Make sure that the instance kernel/ramdisk is cached. # This is for the takeover scenario for active nodes. - instance_image_info = pxe._get_instance_image_info( + instance_image_info = pxe_utils.get_instance_image_info( task, ipxe_enabled=True) - pxe._cache_ramdisk_kernel(task, instance_image_info) + pxe_utils.cache_ramdisk_kernel(task, instance_image_info) # If it's going to PXE boot we need to update the DHCP server - dhcp_opts = common_pxe_utils.dhcp_options_for_instance(task) + dhcp_opts = pxe_utils.dhcp_options_for_instance(task) provider = dhcp_factory.DHCPFactory() provider.update_dhcp(task, dhcp_opts) @@ -303,19 +303,19 @@ class iPXEBoot(base.BootInterface): "from deployment mode to service (boot) mode " "for node %(node)s. Booting the instance " "from disk.", {"node": task.node.uuid}) - common_pxe_utils.clean_up_pxe_config(task) + pxe_utils.clean_up_pxe_config(task) boot_device = boot_devices.DISK else: - pxe._build_service_pxe_config(task, instance_image_info, - root_uuid_or_disk_id, - ipxe_enabled=True) + pxe_utils.build_service_pxe_config(task, instance_image_info, + root_uuid_or_disk_id, + ipxe_enabled=True) boot_device = boot_devices.PXE else: # If it's going to boot from the local disk, we don't need # PXE config files. They still need to be generated as part # of the prepare() because the deployment does PXE boot the # deploy ramdisk - common_pxe_utils.clean_up_pxe_config(task) + pxe_utils.clean_up_pxe_config(task) boot_device = boot_devices.DISK # NOTE(pas-ha) do not re-set boot device on ACTIVE nodes @@ -338,14 +338,14 @@ class iPXEBoot(base.BootInterface): node = task.node try: - images_info = pxe._get_instance_image_info(task, - ipxe_enabled=True) + images_info = pxe_utils.get_instance_image_info(task, + ipxe_enabled=True) except exception.MissingParameterValue as e: LOG.warning('Could not get instance image info ' 'to clean up images for node %(node)s: %(err)s', {'node': node.uuid, 'err': e}) else: - pxe._clean_up_pxe_env(task, images_info) + pxe_utils.clean_up_pxe_env(task, images_info) @METRICS.timer('iPXEBoot.validate_rescue') def validate_rescue(self, task): @@ -355,4 +355,4 @@ class iPXEBoot(base.BootInterface): :raises: MissingParameterValue if node is missing one or more required parameters """ - pxe._parse_driver_info(task.node, mode='rescue') + pxe_utils.parse_driver_info(task.node, mode='rescue') diff --git a/ironic/drivers/modules/pxe.py b/ironic/drivers/modules/pxe.py index ada15727e0..91fe87403d 100644 --- a/ironic/drivers/modules/pxe.py +++ b/ironic/drivers/modules/pxe.py @@ -15,12 +15,8 @@ PXE Boot Interface """ -import os - from ironic_lib import metrics_utils -from ironic_lib import utils as ironic_utils from oslo_log import log as logging -from oslo_utils import fileutils from oslo_utils import strutils from ironic.common import boot_devices @@ -37,7 +33,6 @@ from ironic.drivers import base from ironic.drivers.modules import agent from ironic.drivers.modules import boot_mode_utils from ironic.drivers.modules import deploy_utils -from ironic.drivers.modules import image_cache from ironic.drivers import utils as driver_utils LOG = logging.getLogger(__name__) @@ -65,75 +60,13 @@ RESCUE_PROPERTIES = { COMMON_PROPERTIES = REQUIRED_PROPERTIES.copy() COMMON_PROPERTIES.update(OPTIONAL_PROPERTIES) -# TODO(TheJulia): The lines below are for compatability purposes, -# to enable a phased migration of related code over a series of -# patches instead of attempting to refactor large portions of the -# boot interface code in a single patch. These private method -# mappings should be removed as soon as reasonably possible. - -_parse_driver_info = pxe_utils.parse_driver_info -_get_instance_image_info = pxe_utils.parse_driver_info -_get_instance_image_info = pxe_utils.get_instance_image_info -_get_image_info = pxe_utils.get_image_info -_build_deploy_pxe_options = pxe_utils.build_instance_pxe_options -_build_instance_pxe_options = pxe_utils.build_instance_pxe_options -_build_extra_pxe_options = pxe_utils.build_extra_pxe_options -_build_pxe_config_options = pxe_utils.build_pxe_config_options -_build_service_pxe_config = pxe_utils.build_service_pxe_config -_get_volume_pxe_options = pxe_utils.get_volume_pxe_options -_prepare_instance_pxe_config = pxe_utils.prepare_instance_pxe_config - # NOTE(TheJulia): This was previously a public method to the code being # moved. This mapping should be removed in the T* cycle. validate_boot_parameters_for_trusted_boot = pxe_utils.validate_boot_parameters_for_trusted_boot # noqa +TFTPImageCache = pxe_utils.TFTPImageCache # NOTE(TheJulia): End section of mappings for migrated common pxe code. -@image_cache.cleanup(priority=25) -class TFTPImageCache(image_cache.ImageCache): - def __init__(self): - super(TFTPImageCache, self).__init__( - CONF.pxe.tftp_master_path, - # MiB -> B - cache_size=CONF.pxe.image_cache_size * 1024 * 1024, - # min -> sec - cache_ttl=CONF.pxe.image_cache_ttl * 60) - - -def _cache_ramdisk_kernel(task, pxe_info): - """Fetch the necessary kernels and ramdisks for the instance.""" - ctx = task.context - node = task.node - if CONF.pxe.ipxe_enabled: - path = os.path.join(pxe_utils.get_ipxe_root_dir(), node.uuid) - else: - path = os.path.join(pxe_utils.get_root_dir(), node.uuid) - fileutils.ensure_tree(path) - LOG.debug("Fetching necessary kernel and ramdisk for node %s", - node.uuid) - deploy_utils.fetch_images(ctx, TFTPImageCache(), list(pxe_info.values()), - CONF.force_raw_images) - - -def _clean_up_pxe_env(task, images_info): - """Cleanup PXE environment of all the images in images_info. - - Cleans up the PXE environment for the mentioned images in - images_info. - - :param task: a TaskManager object - :param images_info: A dictionary of images whose keys are the image names - to be cleaned up (kernel, ramdisk, etc) and values are a tuple of - identifier and absolute path. - """ - for label in images_info: - path = images_info[label][1] - ironic_utils.unlink_without_raise(path) - - pxe_utils.clean_up_pxe_config(task) - TFTPImageCache().clean_up() - - class PXEBoot(base.BootInterface): capabilities = ['iscsi_volume_boot', 'ramdisk_boot', 'ipxe_boot', @@ -192,7 +125,7 @@ class PXEBoot(base.BootInterface): # trusted boot. validate_boot_parameters_for_trusted_boot(node) - _parse_driver_info(node) + pxe_utils.parse_driver_info(node) # NOTE(TheJulia): If we're not writing an image, we can skip # the remainder of this method. if (not task.driver.storage.should_write_image(task)): @@ -247,15 +180,15 @@ class PXEBoot(base.BootInterface): provider = dhcp_factory.DHCPFactory() provider.update_dhcp(task, dhcp_opts) - pxe_info = _get_image_info(node, mode=mode) + pxe_info = pxe_utils.get_image_info(node, mode=mode) # NODE: Try to validate and fetch instance images only # if we are in DEPLOYING state. if node.provision_state == states.DEPLOYING: - pxe_info.update(_get_instance_image_info(task)) + pxe_info.update(pxe_utils.get_instance_image_info(task)) boot_mode_utils.sync_boot_mode(task) - pxe_options = _build_pxe_config_options(task, pxe_info) + pxe_options = pxe_utils.build_pxe_config_options(task, pxe_info) pxe_options.update(ramdisk_params) pxe_config_template = deploy_utils.get_pxe_config_template(node) @@ -276,7 +209,7 @@ class PXEBoot(base.BootInterface): pxe_info.pop(ramdisk_label, None) if pxe_info: - _cache_ramdisk_kernel(task, pxe_info) + pxe_utils.cache_ramdisk_kernel(task, pxe_info) @METRICS.timer('PXEBoot.clean_up_ramdisk') def clean_up_ramdisk(self, task): @@ -297,13 +230,13 @@ class PXEBoot(base.BootInterface): node = task.node mode = deploy_utils.rescue_or_deploy_mode(node) try: - images_info = _get_image_info(node, mode=mode) + images_info = pxe_utils.get_image_info(node, mode=mode) except exception.MissingParameterValue as e: LOG.warning('Could not get %(mode)s image info ' 'to clean up images for node %(node)s: %(err)s', {'mode': mode, 'node': node.uuid, 'err': e}) else: - _clean_up_pxe_env(task, images_info) + pxe_utils.clean_up_pxe_env(task, images_info) @METRICS.timer('PXEBoot.prepare_instance') def prepare_instance(self, task): @@ -325,12 +258,11 @@ class PXEBoot(base.BootInterface): boot_device = None instance_image_info = {} if boot_option == "ramdisk": - instance_image_info = _get_instance_image_info(task) - _cache_ramdisk_kernel(task, - instance_image_info) + instance_image_info = pxe_utils.get_instance_image_info(task) + pxe_utils.cache_ramdisk_kernel(task, instance_image_info) if deploy_utils.is_iscsi_boot(task) or boot_option == "ramdisk": - _prepare_instance_pxe_config( + pxe_utils.prepare_instance_pxe_config( task, instance_image_info, iscsi_boot=deploy_utils.is_iscsi_boot(task), ramdisk_boot=(boot_option == "ramdisk"), @@ -341,9 +273,8 @@ class PXEBoot(base.BootInterface): if task.driver.storage.should_write_image(task): # Make sure that the instance kernel/ramdisk is cached. # This is for the takeover scenario for active nodes. - instance_image_info = _get_instance_image_info(task) - _cache_ramdisk_kernel(task, - instance_image_info) + instance_image_info = pxe_utils.get_instance_image_info(task) + pxe_utils.cache_ramdisk_kernel(task, instance_image_info) # If it's going to PXE boot we need to update the DHCP server dhcp_opts = pxe_utils.dhcp_options_for_instance(task) @@ -372,9 +303,9 @@ class PXEBoot(base.BootInterface): pxe_utils.clean_up_pxe_config(task) boot_device = boot_devices.DISK else: - _build_service_pxe_config(task, instance_image_info, - root_uuid_or_disk_id, - ipxe_enabled=ipxe_enabled) + pxe_utils.build_service_pxe_config(task, instance_image_info, + root_uuid_or_disk_id, + ipxe_enabled=ipxe_enabled) boot_device = boot_devices.PXE else: # If it's going to boot from the local disk, we don't need @@ -404,13 +335,13 @@ class PXEBoot(base.BootInterface): node = task.node try: - images_info = _get_instance_image_info(task) + images_info = pxe_utils.get_instance_image_info(task) except exception.MissingParameterValue as e: LOG.warning('Could not get instance image info ' 'to clean up images for node %(node)s: %(err)s', {'node': node.uuid, 'err': e}) else: - _clean_up_pxe_env(task, images_info) + pxe_utils.clean_up_pxe_env(task, images_info) @METRICS.timer('PXEBoot.validate_rescue') def validate_rescue(self, task): @@ -420,7 +351,7 @@ class PXEBoot(base.BootInterface): :raises: MissingParameterValue if node is missing one or more required parameters """ - _parse_driver_info(task.node, mode='rescue') + pxe_utils.parse_driver_info(task.node, mode='rescue') class PXERamdiskDeploy(agent.AgentDeploy): diff --git a/ironic/tests/unit/common/test_pxe_utils.py b/ironic/tests/unit/common/test_pxe_utils.py index 1088775960..498d006150 100644 --- a/ironic/tests/unit/common/test_pxe_utils.py +++ b/ironic/tests/unit/common/test_pxe_utils.py @@ -15,20 +15,32 @@ # under the License. import os +import tempfile +from ironic_lib import utils as ironic_utils import mock from oslo_config import cfg +from oslo_utils import fileutils from oslo_utils import uuidutils import six from ironic.common import exception +from ironic.common.glance_service import base_image_service from ironic.common import pxe_utils +from ironic.common import states from ironic.common import utils from ironic.conductor import task_manager +from ironic.drivers.modules import deploy_utils +from ironic.drivers.modules import ipxe +from ironic.drivers.modules import pxe from ironic.tests.unit.db import base as db_base +from ironic.tests.unit.db import utils as db_utils from ironic.tests.unit.objects import utils as object_utils CONF = cfg.CONF +INST_INFO_DICT = db_utils.get_test_pxe_instance_info() +DRV_INFO_DICT = db_utils.get_test_pxe_driver_info() +DRV_INTERNAL_INFO_DICT = db_utils.get_test_pxe_driver_internal_info() # Prevent /httpboot validation on creating the node @@ -966,3 +978,712 @@ class TestPXEUtils(db_base.DbTestCase): test_file_path = '/tftpboot-path/pxelinux.cfg/test' relpath = pxe_utils.get_path_relative_to_tftp_root(test_file_path) self.assertEqual(relpath, 'pxelinux.cfg/test') + + +@mock.patch.object(ipxe.iPXEBoot, '__init__', lambda self: None) +@mock.patch.object(pxe.PXEBoot, '__init__', lambda self: None) +class PXEInterfacesTestCase(db_base.DbTestCase): + + def setUp(self): + super(PXEInterfacesTestCase, self).setUp() + n = { + 'driver': 'fake-hardware', + 'boot_interface': 'pxe', + 'instance_info': INST_INFO_DICT, + 'driver_info': DRV_INFO_DICT, + 'driver_internal_info': DRV_INTERNAL_INFO_DICT, + } + self.config_temp_dir('http_root', group='deploy') + self.node = object_utils.create_test_node(self.context, **n) + + def _test_parse_driver_info_missing_kernel(self, mode='deploy'): + del self.node.driver_info['%s_kernel' % mode] + if mode == 'rescue': + self.node.provision_state = states.RESCUING + self.assertRaises(exception.MissingParameterValue, + pxe_utils.parse_driver_info, self.node, mode=mode) + + def test_parse_driver_info_missing_deploy_kernel(self): + self._test_parse_driver_info_missing_kernel() + + def test_parse_driver_info_missing_rescue_kernel(self): + self._test_parse_driver_info_missing_kernel(mode='rescue') + + def _test_parse_driver_info_missing_ramdisk(self, mode='deploy'): + del self.node.driver_info['%s_ramdisk' % mode] + if mode == 'rescue': + self.node.provision_state = states.RESCUING + self.assertRaises(exception.MissingParameterValue, + pxe_utils.parse_driver_info, self.node, mode=mode) + + def test_parse_driver_info_missing_deploy_ramdisk(self): + self._test_parse_driver_info_missing_ramdisk() + + def test_parse_driver_info_missing_rescue_ramdisk(self): + self._test_parse_driver_info_missing_ramdisk(mode='rescue') + + def _test_parse_driver_info(self, mode='deploy'): + exp_info = {'%s_ramdisk' % mode: 'glance://%s_ramdisk_uuid' % mode, + '%s_kernel' % mode: 'glance://%s_kernel_uuid' % mode} + image_info = pxe_utils.parse_driver_info(self.node, mode=mode) + self.assertEqual(exp_info, image_info) + + def test_parse_driver_info_deploy(self): + self._test_parse_driver_info() + + def test_parse_driver_info_rescue(self): + self._test_parse_driver_info(mode='rescue') + + def test__get_deploy_image_info(self): + expected_info = {'deploy_ramdisk': + (DRV_INFO_DICT['deploy_ramdisk'], + os.path.join(CONF.pxe.tftp_root, + self.node.uuid, + 'deploy_ramdisk')), + 'deploy_kernel': + (DRV_INFO_DICT['deploy_kernel'], + os.path.join(CONF.pxe.tftp_root, + self.node.uuid, + 'deploy_kernel'))} + image_info = pxe_utils.get_image_info(self.node) + self.assertEqual(expected_info, image_info) + + def test__get_deploy_image_info_missing_deploy_kernel(self): + del self.node.driver_info['deploy_kernel'] + self.assertRaises(exception.MissingParameterValue, + pxe_utils.get_image_info, self.node) + + def test__get_deploy_image_info_deploy_ramdisk(self): + del self.node.driver_info['deploy_ramdisk'] + self.assertRaises(exception.MissingParameterValue, + pxe_utils.get_image_info, self.node) + + @mock.patch.object(base_image_service.BaseImageService, '_show', + autospec=True) + def _test_get_instance_image_info(self, show_mock): + properties = {'properties': {u'kernel_id': u'instance_kernel_uuid', + u'ramdisk_id': u'instance_ramdisk_uuid'}} + + expected_info = {'ramdisk': + ('instance_ramdisk_uuid', + os.path.join(CONF.pxe.tftp_root, + self.node.uuid, + 'ramdisk')), + 'kernel': + ('instance_kernel_uuid', + os.path.join(CONF.pxe.tftp_root, + self.node.uuid, + 'kernel'))} + show_mock.return_value = properties + self.context.auth_token = 'fake' + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + image_info = pxe_utils.get_instance_image_info(task) + show_mock.assert_called_once_with(mock.ANY, 'glance://image_uuid', + method='get') + self.assertEqual(expected_info, image_info) + + # test with saved info + show_mock.reset_mock() + image_info = pxe_utils.get_instance_image_info(task) + self.assertEqual(expected_info, image_info) + self.assertFalse(show_mock.called) + self.assertEqual('instance_kernel_uuid', + task.node.instance_info['kernel']) + self.assertEqual('instance_ramdisk_uuid', + task.node.instance_info['ramdisk']) + + def test_get_instance_image_info(self): + # Tests when 'is_whole_disk_image' exists in driver_internal_info + self._test_get_instance_image_info() + + def test_get_instance_image_info_without_is_whole_disk_image(self): + # Tests when 'is_whole_disk_image' doesn't exists in + # driver_internal_info + del self.node.driver_internal_info['is_whole_disk_image'] + self.node.save() + self._test_get_instance_image_info() + + @mock.patch('ironic.drivers.modules.deploy_utils.get_boot_option', + return_value='local') + def test_get_instance_image_info_localboot(self, boot_opt_mock): + self.node.driver_internal_info['is_whole_disk_image'] = False + self.node.save() + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + image_info = pxe_utils.get_instance_image_info(task) + self.assertEqual({}, image_info) + boot_opt_mock.assert_called_once_with(task.node) + + @mock.patch.object(base_image_service.BaseImageService, '_show', + autospec=True) + def test_get_instance_image_info_whole_disk_image(self, show_mock): + properties = {'properties': None} + show_mock.return_value = properties + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + task.node.driver_internal_info['is_whole_disk_image'] = True + image_info = pxe_utils.get_instance_image_info(task) + self.assertEqual({}, image_info) + + @mock.patch('ironic.common.utils.render_template', autospec=True) + def _test_build_pxe_config_options_pxe(self, render_mock, + whle_dsk_img=False, + debug=False, mode='deploy'): + self.config(debug=debug) + self.config(pxe_append_params='test_param', group='pxe') + # NOTE: right '/' should be removed from url string + self.config(api_url='http://192.168.122.184:6385', group='conductor') + + driver_internal_info = self.node.driver_internal_info + driver_internal_info['is_whole_disk_image'] = whle_dsk_img + self.node.driver_internal_info = driver_internal_info + self.node.save() + + tftp_server = CONF.pxe.tftp_server + + kernel_label = '%s_kernel' % mode + ramdisk_label = '%s_ramdisk' % mode + + pxe_kernel = os.path.join(self.node.uuid, kernel_label) + pxe_ramdisk = os.path.join(self.node.uuid, ramdisk_label) + kernel = os.path.join(self.node.uuid, 'kernel') + ramdisk = os.path.join(self.node.uuid, 'ramdisk') + root_dir = CONF.pxe.tftp_root + + image_info = { + kernel_label: (kernel_label, + os.path.join(root_dir, + self.node.uuid, + kernel_label)), + ramdisk_label: (ramdisk_label, + os.path.join(root_dir, + self.node.uuid, + ramdisk_label)) + } + + if (whle_dsk_img + or deploy_utils.get_boot_option(self.node) == 'local'): + ramdisk = 'no_ramdisk' + kernel = 'no_kernel' + else: + image_info.update({ + 'kernel': ('kernel_id', + os.path.join(root_dir, + self.node.uuid, + 'kernel')), + 'ramdisk': ('ramdisk_id', + os.path.join(root_dir, + self.node.uuid, + 'ramdisk')) + }) + + expected_pxe_params = 'test_param' + if debug: + expected_pxe_params += ' ipa-debug=1' + + expected_options = { + 'deployment_ari_path': pxe_ramdisk, + 'pxe_append_params': expected_pxe_params, + 'deployment_aki_path': pxe_kernel, + 'tftp_server': tftp_server, + 'ipxe_timeout': 0, + 'ari_path': ramdisk, + 'aki_path': kernel, + } + + if mode == 'rescue': + self.node.provision_state = states.RESCUING + self.node.save() + + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + options = pxe_utils.build_pxe_config_options(task, image_info) + self.assertEqual(expected_options, options) + + def test_build_pxe_config_options_pxe(self): + self._test_build_pxe_config_options_pxe(whle_dsk_img=True) + + def test_build_pxe_config_options_pxe_ipa_debug(self): + self._test_build_pxe_config_options_pxe(debug=True) + + def test_build_pxe_config_options_pxe_rescue(self): + del self.node.driver_internal_info['is_whole_disk_image'] + self._test_build_pxe_config_options_pxe(mode='rescue') + + def test_build_pxe_config_options_ipa_debug_rescue(self): + del self.node.driver_internal_info['is_whole_disk_image'] + self._test_build_pxe_config_options_pxe(debug=True, mode='rescue') + + def test_build_pxe_config_options_pxe_local_boot(self): + del self.node.driver_internal_info['is_whole_disk_image'] + i_info = self.node.instance_info + i_info.update({'capabilities': {'boot_option': 'local'}}) + self.node.instance_info = i_info + self.node.save() + self._test_build_pxe_config_options_pxe(whle_dsk_img=False) + + def test_build_pxe_config_options_pxe_without_is_whole_disk_image(self): + del self.node.driver_internal_info['is_whole_disk_image'] + self.node.save() + self._test_build_pxe_config_options_pxe(whle_dsk_img=False) + + def test_build_pxe_config_options_pxe_no_kernel_no_ramdisk(self): + del self.node.driver_internal_info['is_whole_disk_image'] + self.node.save() + pxe_params = 'my-pxe-append-params ipa-debug=0' + self.config(group='pxe', tftp_server='my-tftp-server') + self.config(group='pxe', pxe_append_params=pxe_params) + self.config(group='pxe', tftp_root='/tftp-path/') + image_info = { + 'deploy_kernel': ('deploy_kernel', + os.path.join(CONF.pxe.tftp_root, + 'path-to-deploy_kernel')), + 'deploy_ramdisk': ('deploy_ramdisk', + os.path.join(CONF.pxe.tftp_root, + 'path-to-deploy_ramdisk'))} + + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + options = pxe_utils.build_pxe_config_options(task, image_info) + + expected_options = { + 'deployment_aki_path': 'path-to-deploy_kernel', + 'deployment_ari_path': 'path-to-deploy_ramdisk', + 'pxe_append_params': pxe_params, + 'tftp_server': 'my-tftp-server', + 'aki_path': 'no_kernel', + 'ari_path': 'no_ramdisk', + 'ipxe_timeout': 0} + self.assertEqual(expected_options, options) + + @mock.patch('ironic.common.image_service.GlanceImageService', + autospec=True) + @mock.patch('ironic.common.utils.render_template', autospec=True) + def _test_build_pxe_config_options_ipxe(self, render_mock, glance_mock, + whle_dsk_img=False, + ipxe_timeout=0, + ipxe_use_swift=False, + debug=False, + boot_from_volume=False, + mode='deploy'): + self.config(debug=debug) + self.config(pxe_append_params='test_param', group='pxe') + # NOTE: right '/' should be removed from url string + self.config(api_url='http://192.168.122.184:6385', group='conductor') + self.config(ipxe_timeout=ipxe_timeout, group='pxe') + root_dir = CONF.deploy.http_root + + driver_internal_info = self.node.driver_internal_info + driver_internal_info['is_whole_disk_image'] = whle_dsk_img + self.node.driver_internal_info = driver_internal_info + self.node.save() + + tftp_server = CONF.pxe.tftp_server + + http_url = 'http://192.1.2.3:1234' + self.config(ipxe_enabled=True, group='pxe') + self.config(http_url=http_url, group='deploy') + + kernel_label = '%s_kernel' % mode + ramdisk_label = '%s_ramdisk' % mode + + if ipxe_use_swift: + self.config(ipxe_use_swift=True, group='pxe') + glance = mock.Mock() + glance_mock.return_value = glance + glance.swift_temp_url.side_effect = [ + pxe_kernel, pxe_ramdisk] = [ + 'swift_kernel', 'swift_ramdisk'] + image_info = { + kernel_label: (uuidutils.generate_uuid(), + os.path.join(root_dir, + self.node.uuid, + kernel_label)), + ramdisk_label: (uuidutils.generate_uuid(), + os.path.join(root_dir, + self.node.uuid, + ramdisk_label)) + } + else: + pxe_kernel = os.path.join(http_url, self.node.uuid, + kernel_label) + pxe_ramdisk = os.path.join(http_url, self.node.uuid, + ramdisk_label) + image_info = { + kernel_label: (kernel_label, + os.path.join(root_dir, + self.node.uuid, + kernel_label)), + ramdisk_label: (ramdisk_label, + os.path.join(root_dir, + self.node.uuid, + ramdisk_label)) + } + + kernel = os.path.join(http_url, self.node.uuid, 'kernel') + ramdisk = os.path.join(http_url, self.node.uuid, 'ramdisk') + if (whle_dsk_img + or deploy_utils.get_boot_option(self.node) == 'local'): + ramdisk = 'no_ramdisk' + kernel = 'no_kernel' + else: + image_info.update({ + 'kernel': ('kernel_id', + os.path.join(root_dir, + self.node.uuid, + 'kernel')), + 'ramdisk': ('ramdisk_id', + os.path.join(root_dir, + self.node.uuid, + 'ramdisk')) + }) + + ipxe_timeout_in_ms = ipxe_timeout * 1000 + + expected_pxe_params = 'test_param' + if debug: + expected_pxe_params += ' ipa-debug=1' + + expected_options = { + 'deployment_ari_path': pxe_ramdisk, + 'pxe_append_params': expected_pxe_params, + 'deployment_aki_path': pxe_kernel, + 'tftp_server': tftp_server, + 'ipxe_timeout': ipxe_timeout_in_ms, + 'ari_path': ramdisk, + 'aki_path': kernel, + 'initrd_filename': ramdisk_label, + } + + if mode == 'rescue': + self.node.provision_state = states.RESCUING + self.node.save() + + if boot_from_volume: + expected_options.update({ + 'boot_from_volume': True, + 'iscsi_boot_url': 'iscsi:fake_host::3260:0:fake_iqn', + 'iscsi_initiator_iqn': 'fake_iqn_initiator', + 'iscsi_volumes': [{'url': 'iscsi:fake_host::3260:1:fake_iqn', + 'username': 'fake_username_1', + 'password': 'fake_password_1' + }], + 'username': 'fake_username', + 'password': 'fake_password' + }) + expected_options.pop('deployment_aki_path') + expected_options.pop('deployment_ari_path') + expected_options.pop('initrd_filename') + + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + options = pxe_utils.build_pxe_config_options(task, + image_info, + ipxe_enabled=True) + self.assertEqual(expected_options, options) + + def test_build_pxe_config_options_ipxe(self): + self._test_build_pxe_config_options_ipxe(whle_dsk_img=True) + + def test_build_pxe_config_options_ipxe_ipa_debug(self): + self._test_build_pxe_config_options_ipxe(debug=True) + + def test_build_pxe_config_options_ipxe_local_boot(self): + del self.node.driver_internal_info['is_whole_disk_image'] + i_info = self.node.instance_info + i_info.update({'capabilities': {'boot_option': 'local'}}) + self.node.instance_info = i_info + self.node.save() + self._test_build_pxe_config_options_ipxe(whle_dsk_img=False) + + def test_build_pxe_config_options_ipxe_swift_wdi(self): + self._test_build_pxe_config_options_ipxe(whle_dsk_img=True, + ipxe_use_swift=True) + + def test_build_pxe_config_options_ipxe_swift_partition(self): + self._test_build_pxe_config_options_ipxe(whle_dsk_img=False, + ipxe_use_swift=True) + + def test_build_pxe_config_options_ipxe_and_ipxe_timeout(self): + self._test_build_pxe_config_options_ipxe(whle_dsk_img=True, + ipxe_timeout=120) + + def test_build_pxe_config_options_ipxe_and_iscsi_boot(self): + vol_id = uuidutils.generate_uuid() + vol_id2 = uuidutils.generate_uuid() + object_utils.create_test_volume_connector( + self.context, + uuid=uuidutils.generate_uuid(), + type='iqn', + node_id=self.node.id, + connector_id='fake_iqn_initiator') + object_utils.create_test_volume_target( + self.context, node_id=self.node.id, volume_type='iscsi', + boot_index=0, volume_id='1234', uuid=vol_id, + properties={'target_lun': 0, + 'target_portal': 'fake_host:3260', + 'target_iqn': 'fake_iqn', + 'auth_username': 'fake_username', + 'auth_password': 'fake_password'}) + object_utils.create_test_volume_target( + self.context, node_id=self.node.id, volume_type='iscsi', + boot_index=1, volume_id='1235', uuid=vol_id2, + properties={'target_lun': 1, + 'target_portal': 'fake_host:3260', + 'target_iqn': 'fake_iqn', + 'auth_username': 'fake_username_1', + 'auth_password': 'fake_password_1'}) + self.node.driver_internal_info.update({'boot_from_volume': vol_id}) + self._test_build_pxe_config_options_ipxe(boot_from_volume=True) + + def test_build_pxe_config_options_ipxe_and_iscsi_boot_from_lists(self): + vol_id = uuidutils.generate_uuid() + vol_id2 = uuidutils.generate_uuid() + object_utils.create_test_volume_connector( + self.context, + uuid=uuidutils.generate_uuid(), + type='iqn', + node_id=self.node.id, + connector_id='fake_iqn_initiator') + object_utils.create_test_volume_target( + self.context, node_id=self.node.id, volume_type='iscsi', + boot_index=0, volume_id='1234', uuid=vol_id, + properties={'target_luns': [0, 2], + 'target_portals': ['fake_host:3260', + 'faker_host:3261'], + 'target_iqns': ['fake_iqn', 'faker_iqn'], + 'auth_username': 'fake_username', + 'auth_password': 'fake_password'}) + object_utils.create_test_volume_target( + self.context, node_id=self.node.id, volume_type='iscsi', + boot_index=1, volume_id='1235', uuid=vol_id2, + properties={'target_lun': [1, 3], + 'target_portal': ['fake_host:3260', 'faker_host:3261'], + 'target_iqn': ['fake_iqn', 'faker_iqn'], + 'auth_username': 'fake_username_1', + 'auth_password': 'fake_password_1'}) + self.node.driver_internal_info.update({'boot_from_volume': vol_id}) + self._test_build_pxe_config_options_ipxe(boot_from_volume=True) + + def test_get_volume_pxe_options(self): + vol_id = uuidutils.generate_uuid() + vol_id2 = uuidutils.generate_uuid() + object_utils.create_test_volume_connector( + self.context, + uuid=uuidutils.generate_uuid(), + type='iqn', + node_id=self.node.id, + connector_id='fake_iqn_initiator') + object_utils.create_test_volume_target( + self.context, node_id=self.node.id, volume_type='iscsi', + boot_index=0, volume_id='1234', uuid=vol_id, + properties={'target_lun': [0, 1, 3], + 'target_portal': 'fake_host:3260', + 'target_iqns': 'fake_iqn', + 'auth_username': 'fake_username', + 'auth_password': 'fake_password'}) + object_utils.create_test_volume_target( + self.context, node_id=self.node.id, volume_type='iscsi', + boot_index=1, volume_id='1235', uuid=vol_id2, + properties={'target_lun': 1, + 'target_portal': 'fake_host:3260', + 'target_iqn': 'fake_iqn', + 'auth_username': 'fake_username_1', + 'auth_password': 'fake_password_1'}) + self.node.driver_internal_info.update({'boot_from_volume': vol_id}) + driver_internal_info = self.node.driver_internal_info + driver_internal_info['boot_from_volume'] = vol_id + self.node.driver_internal_info = driver_internal_info + self.node.save() + + expected = {'boot_from_volume': True, + 'username': 'fake_username', 'password': 'fake_password', + 'iscsi_boot_url': 'iscsi:fake_host::3260:0:fake_iqn', + 'iscsi_initiator_iqn': 'fake_iqn_initiator', + 'iscsi_volumes': [{ + 'url': 'iscsi:fake_host::3260:1:fake_iqn', + 'username': 'fake_username_1', + 'password': 'fake_password_1' + }] + } + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + options = pxe_utils.get_volume_pxe_options(task) + self.assertEqual(expected, options) + + def test_get_volume_pxe_options_unsupported_volume_type(self): + vol_id = uuidutils.generate_uuid() + object_utils.create_test_volume_target( + self.context, node_id=self.node.id, volume_type='fake_type', + boot_index=0, volume_id='1234', uuid=vol_id, + properties={'foo': 'bar'}) + + driver_internal_info = self.node.driver_internal_info + driver_internal_info['boot_from_volume'] = vol_id + self.node.driver_internal_info = driver_internal_info + self.node.save() + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + options = pxe_utils.get_volume_pxe_options(task) + self.assertEqual({}, options) + + def test_get_volume_pxe_options_unsupported_additional_volume_type(self): + vol_id = uuidutils.generate_uuid() + vol_id2 = uuidutils.generate_uuid() + object_utils.create_test_volume_target( + self.context, node_id=self.node.id, volume_type='iscsi', + boot_index=0, volume_id='1234', uuid=vol_id, + properties={'target_lun': 0, + 'target_portal': 'fake_host:3260', + 'target_iqn': 'fake_iqn', + 'auth_username': 'fake_username', + 'auth_password': 'fake_password'}) + object_utils.create_test_volume_target( + self.context, node_id=self.node.id, volume_type='fake_type', + boot_index=1, volume_id='1234', uuid=vol_id2, + properties={'foo': 'bar'}) + + driver_internal_info = self.node.driver_internal_info + driver_internal_info['boot_from_volume'] = vol_id + self.node.driver_internal_info = driver_internal_info + self.node.save() + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + options = pxe_utils.get_volume_pxe_options(task) + self.assertEqual([], options['iscsi_volumes']) + + def test_build_pxe_config_options_ipxe_rescue(self): + self._test_build_pxe_config_options_ipxe(mode='rescue') + + def test_build_pxe_config_options_ipxe_rescue_swift(self): + self._test_build_pxe_config_options_ipxe(mode='rescue', + ipxe_use_swift=True) + + def test_build_pxe_config_options_ipxe_rescue_timeout(self): + self._test_build_pxe_config_options_ipxe(mode='rescue', + ipxe_timeout=120) + + @mock.patch.object(deploy_utils, 'fetch_images', autospec=True) + def test__cache_tftp_images_master_path(self, mock_fetch_image): + temp_dir = tempfile.mkdtemp() + self.config(tftp_root=temp_dir, group='pxe') + self.config(tftp_master_path=os.path.join(temp_dir, + 'tftp_master_path'), + group='pxe') + image_path = os.path.join(temp_dir, self.node.uuid, + 'deploy_kernel') + image_info = {'deploy_kernel': ('deploy_kernel', image_path)} + fileutils.ensure_tree(CONF.pxe.tftp_master_path) + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + pxe_utils.cache_ramdisk_kernel(task, image_info) + + mock_fetch_image.assert_called_once_with(self.context, + mock.ANY, + [('deploy_kernel', + image_path)], + True) + + @mock.patch.object(pxe_utils, 'TFTPImageCache', lambda: None) + @mock.patch.object(fileutils, 'ensure_tree', autospec=True) + @mock.patch.object(deploy_utils, 'fetch_images', autospec=True) + def test_cache_ramdisk_kernel(self, mock_fetch_image, mock_ensure_tree): + self.config(ipxe_enabled=False, group='pxe') + fake_pxe_info = {'foo': 'bar'} + expected_path = os.path.join(CONF.pxe.tftp_root, self.node.uuid) + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + pxe_utils.cache_ramdisk_kernel(task, fake_pxe_info) + mock_ensure_tree.assert_called_with(expected_path) + mock_fetch_image.assert_called_once_with( + self.context, mock.ANY, list(fake_pxe_info.values()), True) + + @mock.patch.object(pxe_utils, 'TFTPImageCache', lambda: None) + @mock.patch.object(fileutils, 'ensure_tree', autospec=True) + @mock.patch.object(deploy_utils, 'fetch_images', autospec=True) + def test_cache_ramdisk_kernel_ipxe(self, mock_fetch_image, + mock_ensure_tree): + self.config(ipxe_enabled=True, group='pxe') + fake_pxe_info = {'foo': 'bar'} + expected_path = os.path.join(CONF.deploy.http_root, + self.node.uuid) + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + pxe_utils.cache_ramdisk_kernel(task, fake_pxe_info) + mock_ensure_tree.assert_called_with(expected_path) + mock_fetch_image.assert_called_once_with(self.context, mock.ANY, + list(fake_pxe_info.values()), + True) + + @mock.patch.object(pxe_utils.LOG, 'error', autospec=True) + def test_validate_boot_parameters_for_trusted_boot_one(self, mock_log): + properties = {'capabilities': 'boot_mode:uefi'} + instance_info = {"boot_option": "netboot"} + self.node.properties = properties + self.node.instance_info['capabilities'] = instance_info + self.node.driver_internal_info['is_whole_disk_image'] = False + self.assertRaises(exception.InvalidParameterValue, + pxe.validate_boot_parameters_for_trusted_boot, + self.node) + self.assertTrue(mock_log.called) + + @mock.patch.object(pxe_utils.LOG, 'error', autospec=True) + def test_validate_boot_parameters_for_trusted_boot_two(self, mock_log): + properties = {'capabilities': 'boot_mode:bios'} + instance_info = {"boot_option": "local"} + self.node.properties = properties + self.node.instance_info['capabilities'] = instance_info + self.node.driver_internal_info['is_whole_disk_image'] = False + self.assertRaises(exception.InvalidParameterValue, + pxe.validate_boot_parameters_for_trusted_boot, + self.node) + self.assertTrue(mock_log.called) + + @mock.patch.object(pxe_utils.LOG, 'error', autospec=True) + def test_validate_boot_parameters_for_trusted_boot_three(self, mock_log): + properties = {'capabilities': 'boot_mode:bios'} + instance_info = {"boot_option": "netboot"} + self.node.properties = properties + self.node.instance_info['capabilities'] = instance_info + self.node.driver_internal_info['is_whole_disk_image'] = True + self.assertRaises(exception.InvalidParameterValue, + pxe.validate_boot_parameters_for_trusted_boot, + self.node) + self.assertTrue(mock_log.called) + + @mock.patch.object(pxe_utils.LOG, 'error', autospec=True) + def test_validate_boot_parameters_for_trusted_boot_pass(self, mock_log): + properties = {'capabilities': 'boot_mode:bios'} + instance_info = {"boot_option": "netboot"} + self.node.properties = properties + self.node.instance_info['capabilities'] = instance_info + self.node.driver_internal_info['is_whole_disk_image'] = False + pxe.validate_boot_parameters_for_trusted_boot(self.node) + self.assertFalse(mock_log.called) + + +@mock.patch.object(ironic_utils, 'unlink_without_raise', autospec=True) +@mock.patch.object(pxe_utils, 'clean_up_pxe_config', autospec=True) +@mock.patch.object(pxe_utils, 'TFTPImageCache', autospec=True) +class CleanUpPxeEnvTestCase(db_base.DbTestCase): + def setUp(self): + super(CleanUpPxeEnvTestCase, self).setUp() + instance_info = INST_INFO_DICT + instance_info['deploy_key'] = 'fake-56789' + self.node = object_utils.create_test_node( + self.context, boot_interface='pxe', + instance_info=instance_info, + driver_info=DRV_INFO_DICT, + driver_internal_info=DRV_INTERNAL_INFO_DICT, + ) + + def test__clean_up_pxe_env(self, mock_cache, mock_pxe_clean, + mock_unlink): + image_info = {'label': ['', 'deploy_kernel']} + with task_manager.acquire(self.context, self.node.uuid, + shared=True) as task: + pxe_utils.clean_up_pxe_env(task, image_info) + mock_pxe_clean.assert_called_once_with(task) + mock_unlink.assert_any_call('deploy_kernel') + mock_cache.return_value.clean_up.assert_called_once_with() diff --git a/ironic/tests/unit/drivers/modules/test_ipxe.py b/ironic/tests/unit/drivers/modules/test_ipxe.py index 64108b1e6d..974a5ff5fc 100644 --- a/ironic/tests/unit/drivers/modules/test_ipxe.py +++ b/ironic/tests/unit/drivers/modules/test_ipxe.py @@ -36,7 +36,6 @@ from ironic.drivers import base as drivers_base from ironic.drivers.modules import agent_base_vendor from ironic.drivers.modules import deploy_utils from ironic.drivers.modules import ipxe -from ironic.drivers.modules import pxe from ironic.drivers.modules.storage import noop as noop_storage from ironic.tests.unit.db import base as db_base from ironic.tests.unit.db import utils as db_utils @@ -217,10 +216,10 @@ class iPXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_get_boot_mode', autospec=True) @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory') - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) - @mock.patch.object(pxe, '_get_image_info', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_build_pxe_config_options', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'get_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'build_pxe_config_options', autospec=True) @mock.patch.object(pxe_utils, 'create_pxe_config', autospec=True) def _test_prepare_ramdisk(self, mock_pxe_config, mock_build_pxe, mock_cache_r_k, @@ -500,8 +499,8 @@ class iPXEBootTestCase(db_base.DbTestCase): self._test_prepare_ramdisk(uefi=True, node_boot_mode=boot_modes.UEFI) self.assertEqual(set_boot_mode_mock.call_count, 0) - @mock.patch.object(pxe, '_clean_up_pxe_env', autospec=True) - @mock.patch.object(pxe, '_get_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'clean_up_pxe_env', autospec=True) + @mock.patch.object(pxe_utils, 'get_image_info', autospec=True) def _test_clean_up_ramdisk(self, get_image_info_mock, clean_up_pxe_env_mock, mode='deploy'): with task_manager.acquire(self.context, self.node.uuid) as task: @@ -527,8 +526,8 @@ class iPXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_netboot( self, get_image_info_mock, cache_mock, dhcp_factory_mock, switch_pxe_config_mock, @@ -565,8 +564,8 @@ class iPXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_netboot_active( self, get_image_info_mock, cache_mock, dhcp_factory_mock, switch_pxe_config_mock, @@ -604,8 +603,8 @@ class iPXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory') - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_netboot_missing_root_uuid( self, get_image_info_mock, cache_mock, dhcp_factory_mock, switch_pxe_config_mock, @@ -635,8 +634,8 @@ class iPXEBootTestCase(db_base.DbTestCase): @mock.patch.object(pxe_utils, 'clean_up_pxe_config', autospec=True) @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory') - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_whole_disk_image_missing_root_uuid( self, get_image_info_mock, cache_mock, dhcp_factory_mock, set_boot_device_mock, @@ -666,8 +665,8 @@ class iPXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_netboot_iscsi( self, get_image_info_mock, cache_mock, dhcp_factory_mock, switch_pxe_config_mock, @@ -755,8 +754,8 @@ class iPXEBootTestCase(db_base.DbTestCase): clean_up_pxe_config_mock.assert_called_once_with(task) self.assertFalse(set_boot_device_mock.called) - @mock.patch.object(pxe, '_clean_up_pxe_env', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'clean_up_pxe_env', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_clean_up_instance(self, get_image_info_mock, clean_up_pxe_env_mock): with task_manager.acquire(self.context, self.node.uuid) as task: diff --git a/ironic/tests/unit/drivers/modules/test_iscsi_deploy.py b/ironic/tests/unit/drivers/modules/test_iscsi_deploy.py index 02bfd0e4a1..5aa97777ef 100644 --- a/ironic/tests/unit/drivers/modules/test_iscsi_deploy.py +++ b/ironic/tests/unit/drivers/modules/test_iscsi_deploy.py @@ -1003,8 +1003,8 @@ class CleanUpFullFlowTestCase(db_base.DbTestCase): @mock.patch('ironic.common.dhcp_factory.DHCPFactory._set_dhcp_provider') @mock.patch('ironic.common.dhcp_factory.DHCPFactory.clean_dhcp') - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) - @mock.patch.object(pxe, '_get_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'get_image_info', autospec=True) def test_clean_up_with_master(self, mock_get_deploy_image_info, mock_get_instance_image_info, clean_dhcp_mock, set_dhcp_provider_mock): diff --git a/ironic/tests/unit/drivers/modules/test_pxe.py b/ironic/tests/unit/drivers/modules/test_pxe.py index 44e9a3a05b..63e606728c 100644 --- a/ironic/tests/unit/drivers/modules/test_pxe.py +++ b/ironic/tests/unit/drivers/modules/test_pxe.py @@ -18,11 +18,9 @@ import os import tempfile -from ironic_lib import utils as ironic_utils import mock from oslo_config import cfg from oslo_serialization import jsonutils as json -from oslo_utils import fileutils from oslo_utils import uuidutils from ironic.common import boot_devices @@ -52,718 +50,8 @@ DRV_INFO_DICT = db_utils.get_test_pxe_driver_info() DRV_INTERNAL_INFO_DICT = db_utils.get_test_pxe_driver_internal_info() -# NOTE(TheJulia): This will need to be split until pxe interface code is -# refactored and cleaned up. -@mock.patch.object(ipxe.iPXEBoot, '__init__', lambda self: None) -@mock.patch.object(pxe.PXEBoot, '__init__', lambda self: None) -class PXEPrivateMethodsTestCase(db_base.DbTestCase): - - def setUp(self): - super(PXEPrivateMethodsTestCase, self).setUp() - n = { - 'driver': 'fake-hardware', - 'boot_interface': 'pxe', - 'instance_info': INST_INFO_DICT, - 'driver_info': DRV_INFO_DICT, - 'driver_internal_info': DRV_INTERNAL_INFO_DICT, - } - self.config_temp_dir('http_root', group='deploy') - self.node = obj_utils.create_test_node(self.context, **n) - - def _test__parse_driver_info_missing_kernel(self, mode='deploy'): - del self.node.driver_info['%s_kernel' % mode] - if mode == 'rescue': - self.node.provision_state = states.RESCUING - self.assertRaises(exception.MissingParameterValue, - pxe._parse_driver_info, self.node, mode=mode) - - def test__parse_driver_info_missing_deploy_kernel(self): - self._test__parse_driver_info_missing_kernel() - - def test__parse_driver_info_missing_rescue_kernel(self): - self._test__parse_driver_info_missing_kernel(mode='rescue') - - def _test__parse_driver_info_missing_ramdisk(self, mode='deploy'): - del self.node.driver_info['%s_ramdisk' % mode] - if mode == 'rescue': - self.node.provision_state = states.RESCUING - self.assertRaises(exception.MissingParameterValue, - pxe._parse_driver_info, self.node, mode=mode) - - def test__parse_driver_info_missing_deploy_ramdisk(self): - self._test__parse_driver_info_missing_ramdisk() - - def test__parse_driver_info_missing_rescue_ramdisk(self): - self._test__parse_driver_info_missing_ramdisk(mode='rescue') - - def _test__parse_driver_info(self, mode='deploy'): - exp_info = {'%s_ramdisk' % mode: 'glance://%s_ramdisk_uuid' % mode, - '%s_kernel' % mode: 'glance://%s_kernel_uuid' % mode} - image_info = pxe._parse_driver_info(self.node, mode=mode) - self.assertEqual(exp_info, image_info) - - def test__parse_driver_info_deploy(self): - self._test__parse_driver_info() - - def test__parse_driver_info_rescue(self): - self._test__parse_driver_info(mode='rescue') - - def test__get_deploy_image_info(self): - expected_info = {'deploy_ramdisk': - (DRV_INFO_DICT['deploy_ramdisk'], - os.path.join(CONF.pxe.tftp_root, - self.node.uuid, - 'deploy_ramdisk')), - 'deploy_kernel': - (DRV_INFO_DICT['deploy_kernel'], - os.path.join(CONF.pxe.tftp_root, - self.node.uuid, - 'deploy_kernel'))} - image_info = pxe._get_image_info(self.node) - self.assertEqual(expected_info, image_info) - - def test__get_deploy_image_info_missing_deploy_kernel(self): - del self.node.driver_info['deploy_kernel'] - self.assertRaises(exception.MissingParameterValue, - pxe._get_image_info, self.node) - - def test__get_deploy_image_info_deploy_ramdisk(self): - del self.node.driver_info['deploy_ramdisk'] - self.assertRaises(exception.MissingParameterValue, - pxe._get_image_info, self.node) - - @mock.patch.object(base_image_service.BaseImageService, '_show', - autospec=True) - def _test__get_instance_image_info(self, show_mock): - properties = {'properties': {u'kernel_id': u'instance_kernel_uuid', - u'ramdisk_id': u'instance_ramdisk_uuid'}} - - expected_info = {'ramdisk': - ('instance_ramdisk_uuid', - os.path.join(CONF.pxe.tftp_root, - self.node.uuid, - 'ramdisk')), - 'kernel': - ('instance_kernel_uuid', - os.path.join(CONF.pxe.tftp_root, - self.node.uuid, - 'kernel'))} - show_mock.return_value = properties - self.context.auth_token = 'fake' - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - image_info = pxe._get_instance_image_info(task) - show_mock.assert_called_once_with(mock.ANY, 'glance://image_uuid', - method='get') - self.assertEqual(expected_info, image_info) - - # test with saved info - show_mock.reset_mock() - image_info = pxe._get_instance_image_info(task) - self.assertEqual(expected_info, image_info) - self.assertFalse(show_mock.called) - self.assertEqual('instance_kernel_uuid', - task.node.instance_info['kernel']) - self.assertEqual('instance_ramdisk_uuid', - task.node.instance_info['ramdisk']) - - def test__get_instance_image_info(self): - # Tests when 'is_whole_disk_image' exists in driver_internal_info - self._test__get_instance_image_info() - - def test__get_instance_image_info_without_is_whole_disk_image(self): - # Tests when 'is_whole_disk_image' doesn't exists in - # driver_internal_info - del self.node.driver_internal_info['is_whole_disk_image'] - self.node.save() - self._test__get_instance_image_info() - - @mock.patch('ironic.drivers.modules.deploy_utils.get_boot_option', - return_value='local') - def test__get_instance_image_info_localboot(self, boot_opt_mock): - self.node.driver_internal_info['is_whole_disk_image'] = False - self.node.save() - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - image_info = pxe._get_instance_image_info(task) - self.assertEqual({}, image_info) - boot_opt_mock.assert_called_once_with(task.node) - - @mock.patch.object(base_image_service.BaseImageService, '_show', - autospec=True) - def test__get_instance_image_info_whole_disk_image(self, show_mock): - properties = {'properties': None} - show_mock.return_value = properties - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - task.node.driver_internal_info['is_whole_disk_image'] = True - image_info = pxe._get_instance_image_info(task) - self.assertEqual({}, image_info) - - @mock.patch('ironic.common.utils.render_template', autospec=True) - def _test_build_pxe_config_options_pxe(self, render_mock, - whle_dsk_img=False, - debug=False, mode='deploy'): - self.config(debug=debug) - self.config(pxe_append_params='test_param', group='pxe') - # NOTE: right '/' should be removed from url string - self.config(api_url='http://192.168.122.184:6385', group='conductor') - - driver_internal_info = self.node.driver_internal_info - driver_internal_info['is_whole_disk_image'] = whle_dsk_img - self.node.driver_internal_info = driver_internal_info - self.node.save() - - tftp_server = CONF.pxe.tftp_server - - kernel_label = '%s_kernel' % mode - ramdisk_label = '%s_ramdisk' % mode - - pxe_kernel = os.path.join(self.node.uuid, kernel_label) - pxe_ramdisk = os.path.join(self.node.uuid, ramdisk_label) - kernel = os.path.join(self.node.uuid, 'kernel') - ramdisk = os.path.join(self.node.uuid, 'ramdisk') - root_dir = CONF.pxe.tftp_root - - image_info = { - kernel_label: (kernel_label, - os.path.join(root_dir, - self.node.uuid, - kernel_label)), - ramdisk_label: (ramdisk_label, - os.path.join(root_dir, - self.node.uuid, - ramdisk_label)) - } - - if (whle_dsk_img - or deploy_utils.get_boot_option(self.node) == 'local'): - ramdisk = 'no_ramdisk' - kernel = 'no_kernel' - else: - image_info.update({ - 'kernel': ('kernel_id', - os.path.join(root_dir, - self.node.uuid, - 'kernel')), - 'ramdisk': ('ramdisk_id', - os.path.join(root_dir, - self.node.uuid, - 'ramdisk')) - }) - - expected_pxe_params = 'test_param' - if debug: - expected_pxe_params += ' ipa-debug=1' - - expected_options = { - 'deployment_ari_path': pxe_ramdisk, - 'pxe_append_params': expected_pxe_params, - 'deployment_aki_path': pxe_kernel, - 'tftp_server': tftp_server, - 'ipxe_timeout': 0, - 'ari_path': ramdisk, - 'aki_path': kernel, - } - - if mode == 'rescue': - self.node.provision_state = states.RESCUING - self.node.save() - - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - options = pxe._build_pxe_config_options(task, image_info) - self.assertEqual(expected_options, options) - - def test__build_pxe_config_options_pxe(self): - self._test_build_pxe_config_options_pxe(whle_dsk_img=True) - - def test__build_pxe_config_options_pxe_ipa_debug(self): - self._test_build_pxe_config_options_pxe(debug=True) - - def test__build_pxe_config_options_pxe_rescue(self): - del self.node.driver_internal_info['is_whole_disk_image'] - self._test_build_pxe_config_options_pxe(mode='rescue') - - def test__build_pxe_config_options_ipa_debug_rescue(self): - del self.node.driver_internal_info['is_whole_disk_image'] - self._test_build_pxe_config_options_pxe(debug=True, mode='rescue') - - def test__build_pxe_config_options_pxe_local_boot(self): - del self.node.driver_internal_info['is_whole_disk_image'] - i_info = self.node.instance_info - i_info.update({'capabilities': {'boot_option': 'local'}}) - self.node.instance_info = i_info - self.node.save() - self._test_build_pxe_config_options_pxe(whle_dsk_img=False) - - def test__build_pxe_config_options_pxe_without_is_whole_disk_image(self): - del self.node.driver_internal_info['is_whole_disk_image'] - self.node.save() - self._test_build_pxe_config_options_pxe(whle_dsk_img=False) - - def test__build_pxe_config_options_pxe_no_kernel_no_ramdisk(self): - del self.node.driver_internal_info['is_whole_disk_image'] - self.node.save() - pxe_params = 'my-pxe-append-params ipa-debug=0' - self.config(group='pxe', tftp_server='my-tftp-server') - self.config(group='pxe', pxe_append_params=pxe_params) - self.config(group='pxe', tftp_root='/tftp-path/') - image_info = { - 'deploy_kernel': ('deploy_kernel', - os.path.join(CONF.pxe.tftp_root, - 'path-to-deploy_kernel')), - 'deploy_ramdisk': ('deploy_ramdisk', - os.path.join(CONF.pxe.tftp_root, - 'path-to-deploy_ramdisk'))} - - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - options = pxe._build_pxe_config_options(task, image_info) - - expected_options = { - 'deployment_aki_path': 'path-to-deploy_kernel', - 'deployment_ari_path': 'path-to-deploy_ramdisk', - 'pxe_append_params': pxe_params, - 'tftp_server': 'my-tftp-server', - 'aki_path': 'no_kernel', - 'ari_path': 'no_ramdisk', - 'ipxe_timeout': 0} - self.assertEqual(expected_options, options) - - @mock.patch('ironic.common.image_service.GlanceImageService', - autospec=True) - @mock.patch('ironic.common.utils.render_template', autospec=True) - def _test_build_pxe_config_options_ipxe(self, render_mock, glance_mock, - whle_dsk_img=False, - ipxe_timeout=0, - ipxe_use_swift=False, - debug=False, - boot_from_volume=False, - mode='deploy'): - self.config(debug=debug) - self.config(pxe_append_params='test_param', group='pxe') - # NOTE: right '/' should be removed from url string - self.config(api_url='http://192.168.122.184:6385', group='conductor') - self.config(ipxe_timeout=ipxe_timeout, group='pxe') - root_dir = CONF.deploy.http_root - - driver_internal_info = self.node.driver_internal_info - driver_internal_info['is_whole_disk_image'] = whle_dsk_img - self.node.driver_internal_info = driver_internal_info - self.node.save() - - tftp_server = CONF.pxe.tftp_server - - http_url = 'http://192.1.2.3:1234' - self.config(ipxe_enabled=True, group='pxe') - self.config(http_url=http_url, group='deploy') - - kernel_label = '%s_kernel' % mode - ramdisk_label = '%s_ramdisk' % mode - - if ipxe_use_swift: - self.config(ipxe_use_swift=True, group='pxe') - glance = mock.Mock() - glance_mock.return_value = glance - glance.swift_temp_url.side_effect = [ - pxe_kernel, pxe_ramdisk] = [ - 'swift_kernel', 'swift_ramdisk'] - image_info = { - kernel_label: (uuidutils.generate_uuid(), - os.path.join(root_dir, - self.node.uuid, - kernel_label)), - ramdisk_label: (uuidutils.generate_uuid(), - os.path.join(root_dir, - self.node.uuid, - ramdisk_label)) - } - else: - pxe_kernel = os.path.join(http_url, self.node.uuid, - kernel_label) - pxe_ramdisk = os.path.join(http_url, self.node.uuid, - ramdisk_label) - image_info = { - kernel_label: (kernel_label, - os.path.join(root_dir, - self.node.uuid, - kernel_label)), - ramdisk_label: (ramdisk_label, - os.path.join(root_dir, - self.node.uuid, - ramdisk_label)) - } - - kernel = os.path.join(http_url, self.node.uuid, 'kernel') - ramdisk = os.path.join(http_url, self.node.uuid, 'ramdisk') - if (whle_dsk_img - or deploy_utils.get_boot_option(self.node) == 'local'): - ramdisk = 'no_ramdisk' - kernel = 'no_kernel' - else: - image_info.update({ - 'kernel': ('kernel_id', - os.path.join(root_dir, - self.node.uuid, - 'kernel')), - 'ramdisk': ('ramdisk_id', - os.path.join(root_dir, - self.node.uuid, - 'ramdisk')) - }) - - ipxe_timeout_in_ms = ipxe_timeout * 1000 - - expected_pxe_params = 'test_param' - if debug: - expected_pxe_params += ' ipa-debug=1' - - expected_options = { - 'deployment_ari_path': pxe_ramdisk, - 'pxe_append_params': expected_pxe_params, - 'deployment_aki_path': pxe_kernel, - 'tftp_server': tftp_server, - 'ipxe_timeout': ipxe_timeout_in_ms, - 'ari_path': ramdisk, - 'aki_path': kernel, - 'initrd_filename': ramdisk_label, - } - - if mode == 'rescue': - self.node.provision_state = states.RESCUING - self.node.save() - - if boot_from_volume: - expected_options.update({ - 'boot_from_volume': True, - 'iscsi_boot_url': 'iscsi:fake_host::3260:0:fake_iqn', - 'iscsi_initiator_iqn': 'fake_iqn_initiator', - 'iscsi_volumes': [{'url': 'iscsi:fake_host::3260:1:fake_iqn', - 'username': 'fake_username_1', - 'password': 'fake_password_1' - }], - 'username': 'fake_username', - 'password': 'fake_password' - }) - expected_options.pop('deployment_aki_path') - expected_options.pop('deployment_ari_path') - expected_options.pop('initrd_filename') - - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - options = pxe._build_pxe_config_options( - task, image_info, ipxe_enabled=True) - self.assertEqual(expected_options, options) - - def test__build_pxe_config_options_ipxe(self): - self._test_build_pxe_config_options_ipxe(whle_dsk_img=True) - - def test__build_pxe_config_options_ipxe_ipa_debug(self): - self._test_build_pxe_config_options_ipxe(debug=True) - - def test__build_pxe_config_options_ipxe_local_boot(self): - del self.node.driver_internal_info['is_whole_disk_image'] - i_info = self.node.instance_info - i_info.update({'capabilities': {'boot_option': 'local'}}) - self.node.instance_info = i_info - self.node.save() - self._test_build_pxe_config_options_ipxe(whle_dsk_img=False) - - def test__build_pxe_config_options_ipxe_swift_wdi(self): - self._test_build_pxe_config_options_ipxe(whle_dsk_img=True, - ipxe_use_swift=True) - - def test__build_pxe_config_options_ipxe_swift_partition(self): - self._test_build_pxe_config_options_ipxe(whle_dsk_img=False, - ipxe_use_swift=True) - - def test__build_pxe_config_options_ipxe_and_ipxe_timeout(self): - self._test_build_pxe_config_options_ipxe(whle_dsk_img=True, - ipxe_timeout=120) - - def test__build_pxe_config_options_ipxe_and_iscsi_boot(self): - vol_id = uuidutils.generate_uuid() - vol_id2 = uuidutils.generate_uuid() - obj_utils.create_test_volume_connector( - self.context, - uuid=uuidutils.generate_uuid(), - type='iqn', - node_id=self.node.id, - connector_id='fake_iqn_initiator') - obj_utils.create_test_volume_target( - self.context, node_id=self.node.id, volume_type='iscsi', - boot_index=0, volume_id='1234', uuid=vol_id, - properties={'target_lun': 0, - 'target_portal': 'fake_host:3260', - 'target_iqn': 'fake_iqn', - 'auth_username': 'fake_username', - 'auth_password': 'fake_password'}) - obj_utils.create_test_volume_target( - self.context, node_id=self.node.id, volume_type='iscsi', - boot_index=1, volume_id='1235', uuid=vol_id2, - properties={'target_lun': 1, - 'target_portal': 'fake_host:3260', - 'target_iqn': 'fake_iqn', - 'auth_username': 'fake_username_1', - 'auth_password': 'fake_password_1'}) - self.node.driver_internal_info.update({'boot_from_volume': vol_id}) - self._test_build_pxe_config_options_ipxe(boot_from_volume=True) - - def test__build_pxe_config_options_ipxe_and_iscsi_boot_from_lists(self): - vol_id = uuidutils.generate_uuid() - vol_id2 = uuidutils.generate_uuid() - obj_utils.create_test_volume_connector( - self.context, - uuid=uuidutils.generate_uuid(), - type='iqn', - node_id=self.node.id, - connector_id='fake_iqn_initiator') - obj_utils.create_test_volume_target( - self.context, node_id=self.node.id, volume_type='iscsi', - boot_index=0, volume_id='1234', uuid=vol_id, - properties={'target_luns': [0, 2], - 'target_portals': ['fake_host:3260', - 'faker_host:3261'], - 'target_iqns': ['fake_iqn', 'faker_iqn'], - 'auth_username': 'fake_username', - 'auth_password': 'fake_password'}) - obj_utils.create_test_volume_target( - self.context, node_id=self.node.id, volume_type='iscsi', - boot_index=1, volume_id='1235', uuid=vol_id2, - properties={'target_lun': [1, 3], - 'target_portal': ['fake_host:3260', 'faker_host:3261'], - 'target_iqn': ['fake_iqn', 'faker_iqn'], - 'auth_username': 'fake_username_1', - 'auth_password': 'fake_password_1'}) - self.node.driver_internal_info.update({'boot_from_volume': vol_id}) - self._test_build_pxe_config_options_ipxe(boot_from_volume=True) - - def test__get_volume_pxe_options(self): - vol_id = uuidutils.generate_uuid() - vol_id2 = uuidutils.generate_uuid() - obj_utils.create_test_volume_connector( - self.context, - uuid=uuidutils.generate_uuid(), - type='iqn', - node_id=self.node.id, - connector_id='fake_iqn_initiator') - obj_utils.create_test_volume_target( - self.context, node_id=self.node.id, volume_type='iscsi', - boot_index=0, volume_id='1234', uuid=vol_id, - properties={'target_lun': [0, 1, 3], - 'target_portal': 'fake_host:3260', - 'target_iqns': 'fake_iqn', - 'auth_username': 'fake_username', - 'auth_password': 'fake_password'}) - obj_utils.create_test_volume_target( - self.context, node_id=self.node.id, volume_type='iscsi', - boot_index=1, volume_id='1235', uuid=vol_id2, - properties={'target_lun': 1, - 'target_portal': 'fake_host:3260', - 'target_iqn': 'fake_iqn', - 'auth_username': 'fake_username_1', - 'auth_password': 'fake_password_1'}) - self.node.driver_internal_info.update({'boot_from_volume': vol_id}) - driver_internal_info = self.node.driver_internal_info - driver_internal_info['boot_from_volume'] = vol_id - self.node.driver_internal_info = driver_internal_info - self.node.save() - - expected = {'boot_from_volume': True, - 'username': 'fake_username', 'password': 'fake_password', - 'iscsi_boot_url': 'iscsi:fake_host::3260:0:fake_iqn', - 'iscsi_initiator_iqn': 'fake_iqn_initiator', - 'iscsi_volumes': [{ - 'url': 'iscsi:fake_host::3260:1:fake_iqn', - 'username': 'fake_username_1', - 'password': 'fake_password_1' - }] - } - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - options = pxe._get_volume_pxe_options(task) - self.assertEqual(expected, options) - - def test__get_volume_pxe_options_unsupported_volume_type(self): - vol_id = uuidutils.generate_uuid() - obj_utils.create_test_volume_target( - self.context, node_id=self.node.id, volume_type='fake_type', - boot_index=0, volume_id='1234', uuid=vol_id, - properties={'foo': 'bar'}) - - driver_internal_info = self.node.driver_internal_info - driver_internal_info['boot_from_volume'] = vol_id - self.node.driver_internal_info = driver_internal_info - self.node.save() - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - options = pxe._get_volume_pxe_options(task) - self.assertEqual({}, options) - - def test__get_volume_pxe_options_unsupported_additional_volume_type(self): - vol_id = uuidutils.generate_uuid() - vol_id2 = uuidutils.generate_uuid() - obj_utils.create_test_volume_target( - self.context, node_id=self.node.id, volume_type='iscsi', - boot_index=0, volume_id='1234', uuid=vol_id, - properties={'target_lun': 0, - 'target_portal': 'fake_host:3260', - 'target_iqn': 'fake_iqn', - 'auth_username': 'fake_username', - 'auth_password': 'fake_password'}) - obj_utils.create_test_volume_target( - self.context, node_id=self.node.id, volume_type='fake_type', - boot_index=1, volume_id='1234', uuid=vol_id2, - properties={'foo': 'bar'}) - - driver_internal_info = self.node.driver_internal_info - driver_internal_info['boot_from_volume'] = vol_id - self.node.driver_internal_info = driver_internal_info - self.node.save() - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - options = pxe._get_volume_pxe_options(task) - self.assertEqual([], options['iscsi_volumes']) - - def test__build_pxe_config_options_ipxe_rescue(self): - self._test_build_pxe_config_options_ipxe(mode='rescue') - - def test__build_pxe_config_options_ipxe_rescue_swift(self): - self._test_build_pxe_config_options_ipxe(mode='rescue', - ipxe_use_swift=True) - - def test__build_pxe_config_options_ipxe_rescue_timeout(self): - self._test_build_pxe_config_options_ipxe(mode='rescue', - ipxe_timeout=120) - - @mock.patch.object(deploy_utils, 'fetch_images', autospec=True) - def test__cache_tftp_images_master_path(self, mock_fetch_image): - temp_dir = tempfile.mkdtemp() - self.config(tftp_root=temp_dir, group='pxe') - self.config(tftp_master_path=os.path.join(temp_dir, - 'tftp_master_path'), - group='pxe') - image_path = os.path.join(temp_dir, self.node.uuid, - 'deploy_kernel') - image_info = {'deploy_kernel': ('deploy_kernel', image_path)} - fileutils.ensure_tree(CONF.pxe.tftp_master_path) - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - pxe._cache_ramdisk_kernel(task, image_info) - - mock_fetch_image.assert_called_once_with(self.context, - mock.ANY, - [('deploy_kernel', - image_path)], - True) - - @mock.patch.object(pxe, 'TFTPImageCache', lambda: None) - @mock.patch.object(fileutils, 'ensure_tree', autospec=True) - @mock.patch.object(deploy_utils, 'fetch_images', autospec=True) - def test__cache_ramdisk_kernel(self, mock_fetch_image, mock_ensure_tree): - self.config(ipxe_enabled=False, group='pxe') - fake_pxe_info = {'foo': 'bar'} - expected_path = os.path.join(CONF.pxe.tftp_root, self.node.uuid) - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - pxe._cache_ramdisk_kernel(task, fake_pxe_info) - mock_ensure_tree.assert_called_with(expected_path) - mock_fetch_image.assert_called_once_with( - self.context, mock.ANY, list(fake_pxe_info.values()), True) - - @mock.patch.object(pxe, 'TFTPImageCache', lambda: None) - @mock.patch.object(fileutils, 'ensure_tree', autospec=True) - @mock.patch.object(deploy_utils, 'fetch_images', autospec=True) - def test__cache_ramdisk_kernel_ipxe(self, mock_fetch_image, - mock_ensure_tree): - self.config(ipxe_enabled=True, group='pxe') - fake_pxe_info = {'foo': 'bar'} - expected_path = os.path.join(CONF.deploy.http_root, - self.node.uuid) - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - pxe._cache_ramdisk_kernel(task, fake_pxe_info) - mock_ensure_tree.assert_called_with(expected_path) - mock_fetch_image.assert_called_once_with(self.context, mock.ANY, - list(fake_pxe_info.values()), - True) - - @mock.patch.object(pxe_utils.LOG, 'error', autospec=True) - def test_validate_boot_parameters_for_trusted_boot_one(self, mock_log): - properties = {'capabilities': 'boot_mode:uefi'} - instance_info = {"boot_option": "netboot"} - self.node.properties = properties - self.node.instance_info['capabilities'] = instance_info - self.node.driver_internal_info['is_whole_disk_image'] = False - self.assertRaises(exception.InvalidParameterValue, - pxe.validate_boot_parameters_for_trusted_boot, - self.node) - self.assertTrue(mock_log.called) - - @mock.patch.object(pxe_utils.LOG, 'error', autospec=True) - def test_validate_boot_parameters_for_trusted_boot_two(self, mock_log): - properties = {'capabilities': 'boot_mode:bios'} - instance_info = {"boot_option": "local"} - self.node.properties = properties - self.node.instance_info['capabilities'] = instance_info - self.node.driver_internal_info['is_whole_disk_image'] = False - self.assertRaises(exception.InvalidParameterValue, - pxe.validate_boot_parameters_for_trusted_boot, - self.node) - self.assertTrue(mock_log.called) - - @mock.patch.object(pxe_utils.LOG, 'error', autospec=True) - def test_validate_boot_parameters_for_trusted_boot_three(self, mock_log): - properties = {'capabilities': 'boot_mode:bios'} - instance_info = {"boot_option": "netboot"} - self.node.properties = properties - self.node.instance_info['capabilities'] = instance_info - self.node.driver_internal_info['is_whole_disk_image'] = True - self.assertRaises(exception.InvalidParameterValue, - pxe.validate_boot_parameters_for_trusted_boot, - self.node) - self.assertTrue(mock_log.called) - - @mock.patch.object(pxe_utils.LOG, 'error', autospec=True) - def test_validate_boot_parameters_for_trusted_boot_pass(self, mock_log): - properties = {'capabilities': 'boot_mode:bios'} - instance_info = {"boot_option": "netboot"} - self.node.properties = properties - self.node.instance_info['capabilities'] = instance_info - self.node.driver_internal_info['is_whole_disk_image'] = False - pxe.validate_boot_parameters_for_trusted_boot(self.node) - self.assertFalse(mock_log.called) - - -@mock.patch.object(ironic_utils, 'unlink_without_raise', autospec=True) -@mock.patch.object(pxe_utils, 'clean_up_pxe_config', autospec=True) -@mock.patch.object(pxe, 'TFTPImageCache', autospec=True) -class CleanUpPxeEnvTestCase(db_base.DbTestCase): - def setUp(self): - super(CleanUpPxeEnvTestCase, self).setUp() - instance_info = INST_INFO_DICT - instance_info['deploy_key'] = 'fake-56789' - self.node = obj_utils.create_test_node( - self.context, boot_interface='pxe', - instance_info=instance_info, - driver_info=DRV_INFO_DICT, - driver_internal_info=DRV_INTERNAL_INFO_DICT, - ) - - def test__clean_up_pxe_env(self, mock_cache, mock_pxe_clean, - mock_unlink): - image_info = {'label': ['', 'deploy_kernel']} - with task_manager.acquire(self.context, self.node.uuid, - shared=True) as task: - pxe._clean_up_pxe_env(task, image_info) - mock_pxe_clean.assert_called_once_with(task) - mock_unlink.assert_any_call('deploy_kernel') - mock_cache.return_value.clean_up.assert_called_once_with() - - -# NOTE(TheJulia): cover the ipxe interface's init as well until -# the testing is separated apart. +# NOTE(TheJulia): Mark pxe interface loading as None in order +# to prent false counts for individual method tests. @mock.patch.object(ipxe.iPXEBoot, '__init__', lambda self: None) @mock.patch.object(pxe.PXEBoot, '__init__', lambda self: None) class PXEBootTestCase(db_base.DbTestCase): @@ -926,10 +214,10 @@ class PXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_get_boot_mode', autospec=True) @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory') - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) - @mock.patch.object(pxe, '_get_image_info', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_build_pxe_config_options', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'get_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'build_pxe_config_options', autospec=True) @mock.patch.object(pxe_utils, 'create_pxe_config', autospec=True) def _test_prepare_ramdisk(self, mock_pxe_config, mock_build_pxe, mock_cache_r_k, @@ -1216,8 +504,8 @@ class PXEBootTestCase(db_base.DbTestCase): self._test_prepare_ramdisk(uefi=True, node_boot_mode=boot_modes.UEFI) self.assertEqual(set_boot_mode_mock.call_count, 0) - @mock.patch.object(pxe, '_clean_up_pxe_env', autospec=True) - @mock.patch.object(pxe, '_get_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'clean_up_pxe_env', autospec=True) + @mock.patch.object(pxe_utils, 'get_image_info', autospec=True) def _test_clean_up_ramdisk(self, get_image_info_mock, clean_up_pxe_env_mock, mode='deploy'): with task_manager.acquire(self.context, self.node.uuid) as task: @@ -1243,8 +531,8 @@ class PXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_netboot( self, get_image_info_mock, cache_mock, dhcp_factory_mock, switch_pxe_config_mock, @@ -1281,8 +569,8 @@ class PXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_netboot_active( self, get_image_info_mock, cache_mock, dhcp_factory_mock, switch_pxe_config_mock, @@ -1321,8 +609,8 @@ class PXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory') - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_netboot_missing_root_uuid( self, get_image_info_mock, cache_mock, dhcp_factory_mock, switch_pxe_config_mock, @@ -1349,8 +637,8 @@ class PXEBootTestCase(db_base.DbTestCase): @mock.patch.object(pxe_utils, 'clean_up_pxe_config', autospec=True) @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory') - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_whole_disk_image_missing_root_uuid( self, get_image_info_mock, cache_mock, dhcp_factory_mock, set_boot_device_mock, @@ -1380,8 +668,8 @@ class PXEBootTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_netboot_iscsi( self, get_image_info_mock, cache_mock, dhcp_factory_mock, switch_pxe_config_mock, @@ -1473,8 +761,8 @@ class PXEBootTestCase(db_base.DbTestCase): @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(pxe_utils, 'create_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def _test_prepare_instance_ramdisk( self, get_image_info_mock, cache_mock, dhcp_factory_mock, create_pxe_config_mock, @@ -1522,8 +810,8 @@ class PXEBootTestCase(db_base.DbTestCase): def test_prepare_instance_ramdisk_pxe_conf_exists(self): self._test_prepare_instance_ramdisk(config_file_exits=False) - @mock.patch.object(pxe, '_clean_up_pxe_env', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'clean_up_pxe_env', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_clean_up_instance(self, get_image_info_mock, clean_up_pxe_env_mock): with task_manager.acquire(self.context, self.node.uuid) as task: @@ -1570,8 +858,8 @@ class PXERamdiskDeployTestCase(db_base.DbTestCase): @mock.patch.object(manager_utils, 'node_set_boot_device', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_prepare_instance_ramdisk( self, get_image_info_mock, cache_mock, dhcp_factory_mock, switch_pxe_config_mock, @@ -1606,8 +894,8 @@ class PXERamdiskDeployTestCase(db_base.DbTestCase): @mock.patch.object(pxe.LOG, 'warning', autospec=True) @mock.patch.object(deploy_utils, 'switch_pxe_config', autospec=True) @mock.patch.object(dhcp_factory, 'DHCPFactory', autospec=True) - @mock.patch.object(pxe, '_cache_ramdisk_kernel', autospec=True) - @mock.patch.object(pxe, '_get_instance_image_info', autospec=True) + @mock.patch.object(pxe_utils, 'cache_ramdisk_kernel', autospec=True) + @mock.patch.object(pxe_utils, 'get_instance_image_info', autospec=True) def test_deploy(self, mock_image_info, mock_cache, mock_dhcp_factory, mock_switch_config, mock_warning): image_info = {'kernel': ('', '/path/to/kernel'),