Merge "Wrap up PXE private method to pxe_utils move"
This commit is contained in:
Zuul
Gerrit Code Review
commit
f2cb24e0a1
@ -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()
|
||||
|
||||
@ -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')
|
||||
|
||||
@ -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):
|
||||
|
||||
@ -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()
|
||||
|
||||
@ -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:
|
||||
|
||||
@ -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):
|
||||
|
||||
@ -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'),
|
||||
|
||||
Loading…
Reference in New Issue
Block a user