openstack/ironic
Code Issues Proposed changes

Merge "Migrate oneview hardware type to use python-hpOneView"

Browse Source
This commit is contained in:
Zuul 2018-01-24 14:29:13 +00:00 committed by Gerrit Code Review
commit 6a1a8efb5f
15 changed files with 808 additions and 950 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
ironic/drivers/modules/oneview/common.py
View File

@ -21,7 +21,6 @@ from six.moves.urllib import parse
from ironic.common import exception from ironic.common import exception
from ironic.common.i18n import _ from ironic.common.i18n import _
from ironic.common import states
from ironic.conf import CONF from ironic.conf import CONF
from ironic.drivers import utils from ironic.drivers import utils
@ -34,6 +33,7 @@ oneview_exceptions = importutils.try_import('oneview_client.exceptions')
hponeview_client = importutils.try_import('hpOneView.oneview_client') hponeview_client = importutils.try_import('hpOneView.oneview_client')
redfish = importutils.try_import('redfish') redfish = importutils.try_import('redfish')
client_exception = importutils.try_import('hpOneView.exceptions')
REQUIRED_ON_DRIVER_INFO = { REQUIRED_ON_DRIVER_INFO = {
'server_hardware_uri': _("Server Hardware URI. Required in driver_info."), 'server_hardware_uri': _("Server Hardware URI. Required in driver_info."),
@ -281,24 +281,6 @@ def validate_oneview_resources_compatibility(oneview_client, task):
raise exception.OneViewError(error=msg) raise exception.OneViewError(error=msg)
def translate_oneview_power_state(power_state):
"""Translates OneView's power states strings to Ironic's format.
:param: power_state: power state string to be translated
:returns: the power state translated
"""
power_states_map = {
oneview_states.ONEVIEW_POWER_ON: states.POWER_ON,
oneview_states.ONEVIEW_POWERING_OFF: states.POWER_ON,
oneview_states.ONEVIEW_POWER_OFF: states.POWER_OFF,
oneview_states.ONEVIEW_POWERING_ON: states.POWER_OFF,
oneview_states.ONEVIEW_RESETTING: states.REBOOT
}
return power_states_map.get(power_state, states.ERROR)
def _verify_node_info(node_namespace, node_info_dict, info_required): def _verify_node_info(node_namespace, node_info_dict, info_required):
"""Verify if info_required is present in node_namespace of the node info. """Verify if info_required is present in node_namespace of the node info.
@ -334,35 +316,31 @@ def node_has_server_profile(func):
:param func: a given decorated function. :param func: a given decorated function.
""" """
def inner(self, *args, **kwargs): def inner(self, *args, **kwargs):
oneview_client = self.oneview_client
task = args[0] task = args[0]
has_server_profile(task, oneview_client) ensure_server_profile(task)
return func(self, *args, **kwargs) return func(self, *args, **kwargs)
return inner return inner
def has_server_profile(task, oneview_client): def ensure_server_profile(task):
"""Checks if the node's Server Hardware has a Server Profile associated. """Checks if the node's Server Hardware has a Server Profile associated.
Function to check if the Server Profile is applied to the Server Hardware. Function to check if the Server Profile is applied to the Server Hardware.
:param oneview_client: an instance of the OneView client
:param task: a TaskManager instance containing the node to act on. :param task: a TaskManager instance containing the node to act on.
:raises: OneViewError if failed to get server profile from OneView
""" """
oneview_info = get_oneview_info(task.node) oneview_client = get_hponeview_client()
try: try:
node_has_server_profile = ( profile_uri = task.node.driver_info.get('applied_server_profile_uri')
oneview_client.get_server_profile_from_hardware(oneview_info) oneview_client.server_profiles.get(profile_uri)
) except client_exception.HPOneViewException as exc:
except oneview_exceptions.OneViewException as oneview_exc:
LOG.error( LOG.error(
"Failed to get server profile from OneView appliance for" "Failed to get server profile: %(profile)s from OneView appliance "
" node %(node)s. Error: %(message)s", "for node %(node)s. Error: %(message)s", {
{"node": task.node.uuid, "message": oneview_exc} "profile": profile_uri,
) "node": task.node.uuid,
raise exception.OneViewError(error=oneview_exc) "message": exc
if not node_has_server_profile: }
raise exception.OperationNotPermitted(
_("A Server Profile is not associated with node %s.") %
task.node.uuid
) )
raise exception.OneViewError(error=exc)

22
ironic/drivers/modules/oneview/deploy.py
View File

@ -67,9 +67,7 @@ class OneViewPeriodicTasks(object):
node = objects.Node.get(context, node_uuid) node = objects.Node.get(context, node_uuid)
try: try:
oneview_using = deploy_utils.is_node_in_use_by_oneview( oneview_using = deploy_utils.is_node_in_use_by_oneview(node)
self.oneview_client, node
)
except exception.OneViewError as e: except exception.OneViewError as e:
# NOTE(xavierr): Skip this node and process the # NOTE(xavierr): Skip this node and process the
# remaining nodes. This node will be checked in # remaining nodes. This node will be checked in
@ -130,7 +128,7 @@ class OneViewPeriodicTasks(object):
try: try:
oneview_using = deploy_utils.is_node_in_use_by_oneview( oneview_using = deploy_utils.is_node_in_use_by_oneview(
self.oneview_client, node node
) )
except exception.OneViewError as e: except exception.OneViewError as e:
# NOTE(xavierr): Skip this node and process the # NOTE(xavierr): Skip this node and process the
@ -240,23 +238,23 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks):
@METRICS.timer('OneViewIscsiDeploy.prepare') @METRICS.timer('OneViewIscsiDeploy.prepare')
def prepare(self, task): def prepare(self, task):
deploy_utils.prepare(self.oneview_client, task) deploy_utils.prepare(task)
super(OneViewIscsiDeploy, self).prepare(task) super(OneViewIscsiDeploy, self).prepare(task)
@METRICS.timer('OneViewIscsiDeploy.tear_down') @METRICS.timer('OneViewIscsiDeploy.tear_down')
def tear_down(self, task): def tear_down(self, task):
if not CONF.conductor.automated_clean: if not CONF.conductor.automated_clean:
deploy_utils.tear_down(self.oneview_client, task) deploy_utils.tear_down(task)
return super(OneViewIscsiDeploy, self).tear_down(task) return super(OneViewIscsiDeploy, self).tear_down(task)
@METRICS.timer('OneViewIscsiDeploy.prepare_cleaning') @METRICS.timer('OneViewIscsiDeploy.prepare_cleaning')
def prepare_cleaning(self, task): def prepare_cleaning(self, task):
deploy_utils.prepare_cleaning(self.oneview_client, task) deploy_utils.prepare_cleaning(task)
return super(OneViewIscsiDeploy, self).prepare_cleaning(task) return super(OneViewIscsiDeploy, self).prepare_cleaning(task)
@METRICS.timer('OneViewIscsiDeploy.tear_down_cleaning') @METRICS.timer('OneViewIscsiDeploy.tear_down_cleaning')
def tear_down_cleaning(self, task): def tear_down_cleaning(self, task):
deploy_utils.tear_down_cleaning(self.oneview_client, task) deploy_utils.tear_down_cleaning(task)
super(OneViewIscsiDeploy, self).tear_down_cleaning(task) super(OneViewIscsiDeploy, self).tear_down_cleaning(task)
@ -284,21 +282,21 @@ class OneViewAgentDeploy(agent.AgentDeploy, OneViewPeriodicTasks):
@METRICS.timer('OneViewAgentDeploy.prepare') @METRICS.timer('OneViewAgentDeploy.prepare')
def prepare(self, task): def prepare(self, task):
deploy_utils.prepare(self.oneview_client, task) deploy_utils.prepare(task)
super(OneViewAgentDeploy, self).prepare(task) super(OneViewAgentDeploy, self).prepare(task)
@METRICS.timer('OneViewAgentDeploy.tear_down') @METRICS.timer('OneViewAgentDeploy.tear_down')
def tear_down(self, task): def tear_down(self, task):
if not CONF.conductor.automated_clean: if not CONF.conductor.automated_clean:
deploy_utils.tear_down(self.oneview_client, task) deploy_utils.tear_down(task)
return super(OneViewAgentDeploy, self).tear_down(task) return super(OneViewAgentDeploy, self).tear_down(task)
@METRICS.timer('OneViewAgentDeploy.prepare_cleaning') @METRICS.timer('OneViewAgentDeploy.prepare_cleaning')
def prepare_cleaning(self, task): def prepare_cleaning(self, task):
deploy_utils.prepare_cleaning(self.oneview_client, task) deploy_utils.prepare_cleaning(task)
return super(OneViewAgentDeploy, self).prepare_cleaning(task) return super(OneViewAgentDeploy, self).prepare_cleaning(task)
@METRICS.timer('OneViewAgentDeploy.tear_down_cleaning') @METRICS.timer('OneViewAgentDeploy.tear_down_cleaning')
def tear_down_cleaning(self, task): def tear_down_cleaning(self, task):
deploy_utils.tear_down_cleaning(self.oneview_client, task) deploy_utils.tear_down_cleaning(task)
super(OneViewAgentDeploy, self).tear_down_cleaning(task) super(OneViewAgentDeploy, self).tear_down_cleaning(task)

167
ironic/drivers/modules/oneview/deploy_utils.py
View File

@ -27,20 +27,20 @@ LOG = logging.getLogger(__name__)
oneview_exception = importutils.try_import('oneview_client.exceptions') oneview_exception = importutils.try_import('oneview_client.exceptions')
oneview_utils = importutils.try_import('oneview_client.utils') oneview_utils = importutils.try_import('oneview_client.utils')
client_exception = importutils.try_import('hpOneView.exceptions')
def get_properties(): def get_properties():
return common.COMMON_PROPERTIES return common.COMMON_PROPERTIES
def prepare(oneview_client, task): def prepare(task):
"""Applies Server Profile and update the node when preparing. """Applies Server Profile and update the node when preparing.
This method is responsible for applying a Server Profile to the Server This method is responsible for applying a Server Profile to the Server
Hardware and add the uri of the applied Server Profile in the node's Hardware and add the uri of the applied Server Profile in the node's
'applied_server_profile_uri' field on properties/capabilities. 'applied_server_profile_uri' field on properties/capabilities.
:param oneview_client: an instance of the OneView client
:param task: A TaskManager object :param task: A TaskManager object
:raises InstanceDeployFailure: If the node doesn't have the needed OneView :raises InstanceDeployFailure: If the node doesn't have the needed OneView
informations, if Server Hardware is in use by an OneView user, or informations, if Server Hardware is in use by an OneView user, or
@ -56,14 +56,13 @@ def prepare(oneview_client, task):
{"instance_name": instance_display_name, {"instance_name": instance_display_name,
"instance_uuid": instance_uuid} "instance_uuid": instance_uuid}
) )
allocate_server_hardware_to_ironic(oneview_client, task.node, allocate_server_hardware_to_ironic(task.node, server_profile_name)
server_profile_name)
except exception.OneViewError as e: except exception.OneViewError as e:
raise exception.InstanceDeployFailure(node=task.node.uuid, raise exception.InstanceDeployFailure(node=task.node.uuid,
reason=e) reason=e)
def tear_down(oneview_client, task): def tear_down(task):
"""Remove Server profile and update the node when tear down. """Remove Server profile and update the node when tear down.
This method is responsible for power a Server Hardware off, remove a Server This method is responsible for power a Server Hardware off, remove a Server
@ -71,26 +70,24 @@ def tear_down(oneview_client, task):
Profile from the node's 'applied_server_profile_uri' in Profile from the node's 'applied_server_profile_uri' in
properties/capabilities. properties/capabilities.
:param oneview_client: an instance of the OneView client
:param task: A TaskManager object :param task: A TaskManager object
:raises InstanceDeployFailure: If node has no uri of applied Server :raises InstanceDeployFailure: If node has no uri of applied Server
Profile, or if some error occur while deleting Server Profile. Profile, or if some error occur while deleting Server Profile.
""" """
try: try:
deallocate_server_hardware_from_ironic(oneview_client, task.node) deallocate_server_hardware_from_ironic(task)
except exception.OneViewError as e: except exception.OneViewError as e:
raise exception.InstanceDeployFailure(node=task.node.uuid, reason=e) raise exception.InstanceDeployFailure(node=task.node.uuid, reason=e)
def prepare_cleaning(oneview_client, task): def prepare_cleaning(task):
"""Applies Server Profile and update the node when preparing cleaning. """Applies Server Profile and update the node when preparing cleaning.
This method is responsible for applying a Server Profile to the Server This method is responsible for applying a Server Profile to the Server
Hardware and add the uri of the applied Server Profile in the node's Hardware and add the uri of the applied Server Profile in the node's
'applied_server_profile_uri' field on properties/capabilities. 'applied_server_profile_uri' field on properties/capabilities.
:param oneview_client: an instance of the OneView client
:param task: A TaskManager object :param task: A TaskManager object
:raises NodeCleaningFailure: If the node doesn't have the needed OneView :raises NodeCleaningFailure: If the node doesn't have the needed OneView
informations, if Server Hardware is in use by an OneView user, or informations, if Server Hardware is in use by an OneView user, or
@ -99,8 +96,7 @@ def prepare_cleaning(oneview_client, task):
""" """
try: try:
server_profile_name = "Ironic Cleaning [%s]" % task.node.uuid server_profile_name = "Ironic Cleaning [%s]" % task.node.uuid
allocate_server_hardware_to_ironic(oneview_client, task.node, allocate_server_hardware_to_ironic(task.node, server_profile_name)
server_profile_name)
except exception.OneViewError as e: except exception.OneViewError as e:
oneview_error = common.SERVER_HARDWARE_ALLOCATION_ERROR oneview_error = common.SERVER_HARDWARE_ALLOCATION_ERROR
driver_internal_info = task.node.driver_internal_info driver_internal_info = task.node.driver_internal_info
@ -111,7 +107,7 @@ def prepare_cleaning(oneview_client, task):
reason=e) reason=e)
def tear_down_cleaning(oneview_client, task): def tear_down_cleaning(task):
"""Remove Server profile and update the node when tear down cleaning. """Remove Server profile and update the node when tear down cleaning.
This method is responsible for power a Server Hardware off, remove a Server This method is responsible for power a Server Hardware off, remove a Server
@ -119,49 +115,75 @@ def tear_down_cleaning(oneview_client, task):
Profile from the node's 'applied_server_profile_uri' in Profile from the node's 'applied_server_profile_uri' in
properties/capabilities. properties/capabilities.
:param oneview_client: an instance of the OneView client
:param task: A TaskManager object :param task: A TaskManager object
:raises NodeCleaningFailure: If node has no uri of applied Server Profile, :raises NodeCleaningFailure: If node has no uri of applied Server Profile,
or if some error occur while deleting Server Profile. or if some error occur while deleting Server Profile.
""" """
try: try:
deallocate_server_hardware_from_ironic(oneview_client, task.node) deallocate_server_hardware_from_ironic(task)
except exception.OneViewError as e: except exception.OneViewError as e:
raise exception.NodeCleaningFailure(node=task.node.uuid, reason=e) raise exception.NodeCleaningFailure(node=task.node.uuid, reason=e)
def _create_profile_from_template(
oneview_client, server_profile_name,
server_hardware_uri, server_profile_template):
"""Create a server profile from a server profile template.
:param oneview_client: an HPE OneView Client instance
:param server_profile_name: the name of the new server profile
:param server_hardware_uri: the server_hardware assigned to server profile
:param server_profile_template: the server profile template id or uri
:returns: The new server profile generated with the name and server
hardware passed on parameters
:raises OneViewError: if the communication with OneView fails
"""
server_profile = oneview_client.server_profile_templates.get_new_profile(
server_profile_template
)
server_profile['name'] = server_profile_name
server_profile['serverHardwareUri'] = server_hardware_uri
server_profile['serverProfileTemplateUri'] = ""
try:
return oneview_client.server_profiles.create(server_profile)
except client_exception.HPOneViewException as e:
msg = (_("Error while creating a Server Profile for Server Hardware: "
"%(sh_uri)s. Error: %(error)s") %
{'sh_uri': server_hardware_uri, 'error': e})
raise exception.OneViewError(error=msg)
def _is_node_in_use(server_hardware, applied_sp_uri, by_oneview=False): def _is_node_in_use(server_hardware, applied_sp_uri, by_oneview=False):
"""Check if node is in use by ironic or by OneView. """Check if node is in use by ironic or by OneView.
:param server_hardware: Server Hardware object.
:param applied_sp_uri: Server Profile URI applied in the node.
:param by_oneview: Boolean value. True when want to verify if node is in :param by_oneview: Boolean value. True when want to verify if node is in
use by OneView. False to verify if node is in use by use by OneView. False to verify if node is in use by
ironic. ironic.
:param node: an ironic node object
:returns: Boolean value. True if by_oneview param is also True and node is :returns: Boolean value. True if by_oneview param is also True and node is
in use by OneView, False otherwise. True if by_oneview param is in use by OneView, False otherwise. True if by_oneview param is
False and node is in use by ironic, False otherwise. False and node is in use by ironic, False otherwise.
""" """
operation = operator.ne if by_oneview else operator.eq operation = operator.ne if by_oneview else operator.eq
return (server_hardware.server_profile_uri not in (None, '') and server_profile_uri = server_hardware.get('serverProfileUri')
operation(applied_sp_uri, server_hardware.server_profile_uri)) return (server_profile_uri and
operation(applied_sp_uri, server_profile_uri))
def is_node_in_use_by_oneview(oneview_client, node): def is_node_in_use_by_oneview(node):
"""Check if node is in use by OneView user. """Check if node is in use by OneView user.
:param oneview_client: an instance of the OneView client :param node: an ironic node object.
:param node: an ironic node object
:returns: Boolean value. True if node is in use by OneView, :returns: Boolean value. True if node is in use by OneView,
False otherwise. False otherwise.
:raises OneViewError: if not possible to get OneView's informations :raises OneViewError: if not possible to get OneView's informations
for the given node, if not possible to retrieve Server Hardware for the given node, if not possible to retrieve Server Hardware
from OneView. from OneView.
""" """
oneview_client = common.get_hponeview_client()
positive = _("Node '%s' is in use by OneView.") % node.uuid positive = _("Node '%s' is in use by OneView.") % node.uuid
negative = _("Node '%s' is not in use by OneView.") % node.uuid negative = _("Node '%s' is not in use by OneView.") % node.uuid
@ -175,19 +197,17 @@ def is_node_in_use_by_oneview(oneview_client, node):
predicate, positive, negative) predicate, positive, negative)
def is_node_in_use_by_ironic(oneview_client, node): def is_node_in_use_by_ironic(node):
"""Check if node is in use by ironic in OneView. """Check if node is in use by ironic in OneView.
:param oneview_client: an instance of the OneView client :param node: an ironic node object.
:param node: an ironic node object
:returns: Boolean value. True if node is in use by ironic, :returns: Boolean value. True if node is in use by ironic,
False otherwise. False otherwise.
:raises OneViewError: if not possible to get OneView's information :raises OneViewError: if not possible to get OneView's information
for the given node, if not possible to retrieve Server Hardware for the given node, if not possible to retrieve Server Hardware
from OneView. from OneView.
""" """
oneview_client = common.get_hponeview_client()
positive = _("Node '%s' is in use by Ironic.") % node.uuid positive = _("Node '%s' is in use by Ironic.") % node.uuid
negative = _("Node '%s' is not in use by Ironic.") % node.uuid negative = _("Node '%s' is not in use by Ironic.") % node.uuid
@ -215,25 +235,17 @@ def _check_applied_server_profile(oneview_client, node,
""" """
oneview_info = common.get_oneview_info(node) oneview_info = common.get_oneview_info(node)
sh_uuid = oneview_utils.get_uuid_from_uri(
oneview_info.get("server_hardware_uri")
)
try: try:
server_hardware = oneview_client.get_server_hardware_by_uuid( server_hardware = oneview_client.server_hardware.get(
sh_uuid oneview_info.get('server_hardware_uri')
) )
except oneview_exception.OneViewResourceNotFoundError as e: except client_exception.HPOneViewResourceNotFound as e:
msg = (_("Error while obtaining Server Hardware from node " msg = (_("Error while obtaining Server Hardware from node "
"%(node_uuid)s. Error: %(error)s") % "%(node_uuid)s. Error: %(error)s") %
{'node_uuid': node.uuid, 'error': e}) {'node_uuid': node.uuid, 'error': e})
raise exception.OneViewError(error=msg) raise exception.OneViewError(error=msg)
applied_sp_uri = ( applied_sp_uri = node.driver_info.get('applied_server_profile_uri')
node.driver_info.get('applied_server_profile_uri')
)
result = predicate(server_hardware, applied_sp_uri) result = predicate(server_hardware, applied_sp_uri)
if result: if result:
@ -248,10 +260,10 @@ def _add_applied_server_profile_uri_field(node, applied_profile):
"""Adds the applied Server Profile uri to a node. """Adds the applied Server Profile uri to a node.
:param node: an ironic node object :param node: an ironic node object
:param applied_profile: the server_profile that will be applied to node
""" """
driver_info = node.driver_info driver_info = node.driver_info
driver_info['applied_server_profile_uri'] = applied_profile.uri driver_info['applied_server_profile_uri'] = applied_profile.get('uri')
node.driver_info = driver_info node.driver_info = driver_info
node.save() node.save()
@ -268,38 +280,35 @@ def _del_applied_server_profile_uri_field(node):
node.save() node.save()
def allocate_server_hardware_to_ironic(oneview_client, node, def allocate_server_hardware_to_ironic(node, server_profile_name):
server_profile_name):
"""Allocate Server Hardware to ironic. """Allocate Server Hardware to ironic.
:param oneview_client: an instance of the OneView client :param node: an ironic node object.
:param node: an ironic node object
:param server_profile_name: a formatted string with the Server Profile :param server_profile_name: a formatted string with the Server Profile
name name.
:raises OneViewError: if an error occurs while allocating the Server :raises OneViewError: if an error occurs while allocating the Server
Hardware to ironic Hardware to ironic or the node is already in use by OneView.
""" """
node_in_use_by_oneview = is_node_in_use_by_oneview(oneview_client, node) oneview_client = common.get_hponeview_client()
node_in_use_by_oneview = is_node_in_use_by_oneview(node)
if not node_in_use_by_oneview: if not node_in_use_by_oneview:
oneview_info = common.get_oneview_info(node) oneview_info = common.get_oneview_info(node)
applied_sp_uri = node.driver_info.get('applied_server_profile_uri') applied_sp_uri = node.driver_info.get('applied_server_profile_uri')
sh_uri = oneview_info.get("server_hardware_uri")
spt_uri = oneview_info.get("server_profile_template_uri")
server_hardware = oneview_client.server_hardware.get(sh_uri)
sh_uuid = oneview_utils.get_uuid_from_uri( if not server_hardware:
oneview_info.get("server_hardware_uri") msg = _("An error occurred during allocating server hardware to "
) "ironic. Server hardware: %s not found.") % sh_uri
spt_uuid = oneview_utils.get_uuid_from_uri( raise exception.OneViewError(error=msg)
oneview_info.get("server_profile_template_uri")
)
server_hardware = oneview_client.get_server_hardware_by_uuid(sh_uuid)
# Don't have Server Profile on OneView but has # Don't have Server Profile on OneView but has
# `applied_server_profile_uri` on driver_info # `applied_server_profile_uri` on driver_info
if (server_hardware.server_profile_uri in (None, '') and if not server_hardware.get('serverProfileUri') and applied_sp_uri:
applied_sp_uri is not (None, '')):
_del_applied_server_profile_uri_field(node) _del_applied_server_profile_uri_field(node)
LOG.info( LOG.info(
@ -311,8 +320,8 @@ def allocate_server_hardware_to_ironic(oneview_client, node,
# applied_server_profile_uri exists and is equal to Server profile # applied_server_profile_uri exists and is equal to Server profile
# applied on Hardware. Do not apply again. # applied on Hardware. Do not apply again.
if (applied_sp_uri and server_hardware.server_profile_uri and if (applied_sp_uri and server_hardware.get(
server_hardware.server_profile_uri == applied_sp_uri): 'serverProfileUri') == applied_sp_uri):
LOG.info( LOG.info(
"The Server Profile %(applied_sp_uri)s was already applied " "The Server Profile %(applied_sp_uri)s was already applied "
"by ironic on node %(node_uuid)s. Reusing.", "by ironic on node %(node_uuid)s. Reusing.",
@ -321,8 +330,8 @@ def allocate_server_hardware_to_ironic(oneview_client, node,
return return
try: try:
applied_profile = oneview_client.clone_template_and_apply( applied_profile = _create_profile_from_template(
server_profile_name, sh_uuid, spt_uuid oneview_client, server_profile_name, sh_uri, spt_uri
) )
_add_applied_server_profile_uri_field(node, applied_profile) _add_applied_server_profile_uri_field(node, applied_profile)
@ -330,46 +339,42 @@ def allocate_server_hardware_to_ironic(oneview_client, node,
"Server Profile %(server_profile_uuid)s was successfully" "Server Profile %(server_profile_uuid)s was successfully"
" applied to node %(node_uuid)s.", " applied to node %(node_uuid)s.",
{"node_uuid": node.uuid, {"node_uuid": node.uuid,
"server_profile_uuid": applied_profile.uri} "server_profile_uuid": applied_profile.get('uri')}
) )
except oneview_exception.OneViewServerProfileAssignmentError as e: except client_exception.HPOneViewInvalidResource as e:
LOG.error("An error occurred during allocating server " LOG.error("An error occurred during allocating server "
"hardware to ironic during prepare: %s", e) "hardware to ironic during prepare: %s", e)
raise exception.OneViewError(error=e) raise exception.OneViewError(error=e)
else: else:
msg = (_("Node %s is already in use by OneView.") % msg = _("Node %s is already in use by OneView.") % node.uuid
node.uuid)
raise exception.OneViewError(error=msg) raise exception.OneViewError(error=msg)
def deallocate_server_hardware_from_ironic(oneview_client, node): def deallocate_server_hardware_from_ironic(task):
"""Deallocate Server Hardware from ironic. """Deallocate Server Hardware from ironic.
:param oneview_client: an instance of the OneView client :param task: a TaskManager object
:param node: an ironic node object
:raises OneViewError: if an error occurs while deallocating the Server :raises OneViewError: if an error occurs while deallocating the Server
Hardware to ironic Hardware to ironic
""" """
node = task.node
oneview_client = common.get_hponeview_client()
if is_node_in_use_by_ironic(oneview_client, node): if is_node_in_use_by_ironic(node):
oneview_info = common.get_oneview_info(node) oneview_info = common.get_oneview_info(node)
server_profile_uuid = oneview_utils.get_uuid_from_uri( server_profile_uri = oneview_info.get('applied_server_profile_uri')
oneview_info.get('applied_server_profile_uri')
)
try: try:
oneview_client.power_off(oneview_info) task.driver.power.set_power_state(task, states.POWER_OFF)
oneview_client.delete_server_profile(server_profile_uuid) oneview_client.server_profiles.delete(server_profile_uri)
_del_applied_server_profile_uri_field(node) _del_applied_server_profile_uri_field(node)
LOG.info("Server Profile %(server_profile_uuid)s was deleted " LOG.info("Server Profile %(server_profile_uuid)s was deleted "
"from node %(node_uuid)s in OneView.", "from node %(node_uuid)s in OneView.",
{'server_profile_uuid': server_profile_uuid, {'server_profile_uri': server_profile_uri,
'node_uuid': node.uuid}) 'node_uuid': node.uuid})
except (ValueError, oneview_exception.OneViewException) as e: except client_exception.HPOneViewException as e:
msg = (_("Error while deleting applied Server Profile from node " msg = (_("Error while deleting applied Server Profile from node "
"%(node_uuid)s. Error: %(error)s") % "%(node_uuid)s. Error: %(error)s") %
{'node_uuid': node.uuid, 'error': e}) {'node_uuid': node.uuid, 'error': e})

11
ironic/drivers/modules/oneview/inspect.py
View File

@ -68,7 +68,7 @@ class OneViewInspect(inspector.Inspector):
def inspect_hardware(self, task): def inspect_hardware(self, task):
profile_name = 'Ironic Inspecting [%s]' % task.node.uuid profile_name = 'Ironic Inspecting [%s]' % task.node.uuid
deploy_utils.allocate_server_hardware_to_ironic( deploy_utils.allocate_server_hardware_to_ironic(
self.oneview_client, task.node, profile_name task.node, profile_name
) )
return super(OneViewInspect, self).inspect_hardware(task) return super(OneViewInspect, self).inspect_hardware(task)
@ -96,12 +96,9 @@ class OneViewInspect(inspector.Inspector):
state_after = task.node.provision_state state_after = task.node.provision_state
# inspection finished # inspection finished
if ( if state_before == states.INSPECTING and state_after in [
state_before == states.INSPECTING and state_after in [
states.MANAGEABLE, states.INSPECTFAIL states.MANAGEABLE, states.INSPECTFAIL
] ]:
): deploy_utils.deallocate_server_hardware_from_ironic(task.node)
deploy_utils.deallocate_server_hardware_from_ironic(
self.oneview_client, task.node)
return result return result

128
ironic/drivers/modules/oneview/management.py
View File

@ -25,22 +25,68 @@ from ironic.drivers import base
from ironic.drivers.modules.oneview import common from ironic.drivers.modules.oneview import common
from ironic.drivers.modules.oneview import deploy_utils from ironic.drivers.modules.oneview import deploy_utils
LOG = logging.getLogger(__name__) client_exception = importutils.try_import('hpOneView.exceptions')
oneview_exceptions = importutils.try_import('oneview_client.exceptions')
LOG = logging.getLogger(__name__)
METRICS = metrics_utils.get_metrics_logger(__name__) METRICS = metrics_utils.get_metrics_logger(__name__)
BOOT_DEVICE_MAPPING_TO_OV = { BOOT_DEVICE_MAP_ONEVIEW = {
boot_devices.DISK: 'HardDisk',
boot_devices.PXE: 'PXE',
boot_devices.CDROM: 'CD', boot_devices.CDROM: 'CD',
boot_devices.DISK: 'HardDisk',
boot_devices.PXE: 'PXE'
} }
BOOT_DEVICE_OV_TO_GENERIC = { BOOT_DEVICE_MAP_ONEVIEW_REV = {
v: k v: k for k, v in BOOT_DEVICE_MAP_ONEVIEW.items()}
for k, v in BOOT_DEVICE_MAPPING_TO_OV.items()
BOOT_DEVICE_MAP_ILO = {
boot_devices.CDROM: 'Cd',
boot_devices.DISK: 'Hdd',
boot_devices.PXE: 'Pxe'
} }
oneview_exceptions = importutils.try_import('oneview_client.exceptions') BOOT_DEVICE_MAP_ILO_REV = {
v: k for k, v in BOOT_DEVICE_MAP_ILO.items()}
def set_onetime_boot(task):
"""Set onetime boot to server hardware.
Change the onetime boot option of an OneView server hardware.
:param task: a task from TaskManager.
"""
driver_internal_info = task.node.driver_internal_info
next_boot_device = driver_internal_info.get('next_boot_device')
if not next_boot_device:
return
boot_device = next_boot_device.get('boot_device')
persistent = next_boot_device.get('persistent')
if persistent:
return
server_hardware = task.node.driver_info.get('server_hardware_uri')
ilo_client = common.get_ilorest_client(server_hardware)
boot_device = BOOT_DEVICE_MAP_ILO.get(boot_device)
path = '/rest/v1/Systems/1'
body = {
"Boot": {
"BootSourceOverrideTarget": boot_device,
"BootSourceOverrideEnabled": "Once"
}
}
headers = {"Content-Type": "application/json"}
try:
ilo_client.patch(path=path, body=body, headers=headers)
except Exception as e:
msg = (_("Error while trying to set onetime boot on Server Hardware: "
"%(sh_uri)s. Error: %(error)s") %
{'sh_uri': server_hardware, 'error': e})
raise exception.OneViewError(error=msg)
def set_boot_device(task): def set_boot_device(task):
@ -51,12 +97,10 @@ def set_boot_device(task):
:param task: a task from TaskManager. :param task: a task from TaskManager.
:raises: InvalidParameterValue if an invalid boot device is :raises: InvalidParameterValue if an invalid boot device is
specified. specified.
:raises: OperationNotPermitted if the server has no server profile or
if the server is already powered on.
:raises: OneViewError if the communication with OneView fails :raises: OneViewError if the communication with OneView fails
""" """
oneview_client = common.get_oneview_client() oneview_client = common.get_hponeview_client()
common.has_server_profile(task, oneview_client) common.ensure_server_profile(task)
driver_internal_info = task.node.driver_internal_info driver_internal_info = task.node.driver_internal_info
next_boot_device = driver_internal_info.get('next_boot_device') next_boot_device = driver_internal_info.get('next_boot_device')
@ -64,7 +108,7 @@ def set_boot_device(task):
boot_device = next_boot_device.get('boot_device') boot_device = next_boot_device.get('boot_device')
persistent = next_boot_device.get('persistent') persistent = next_boot_device.get('persistent')
if boot_device not in sorted(BOOT_DEVICE_MAPPING_TO_OV): if boot_device not in sorted(BOOT_DEVICE_MAP_ONEVIEW):
raise exception.InvalidParameterValue( raise exception.InvalidParameterValue(
_("Invalid boot device %s specified.") % boot_device) _("Invalid boot device %s specified.") % boot_device)
@ -73,16 +117,24 @@ def set_boot_device(task):
{"boot_device": boot_device, "persistent": persistent, {"boot_device": boot_device, "persistent": persistent,
"node": task.node.uuid}) "node": task.node.uuid})
profile = task.node.driver_info.get('applied_server_profile_uri')
boot_device = BOOT_DEVICE_MAP_ONEVIEW.get(boot_device)
try: try:
oneview_info = common.get_oneview_info(task.node) server_profile = oneview_client.server_profiles.get(profile)
device_to_oneview = BOOT_DEVICE_MAPPING_TO_OV.get(boot_device) boot = server_profile.get('boot', {})
oneview_client.set_boot_device(oneview_info, order = boot.get('order', [])
device_to_oneview, if boot_device in order:
onetime=not persistent) order.remove(boot_device)
order.insert(0, boot_device)
boot['order'] = order
server_profile['boot'] = boot
oneview_client.server_profiles.update(server_profile, profile)
set_onetime_boot(task)
driver_internal_info.pop('next_boot_device', None) driver_internal_info.pop('next_boot_device', None)
task.node.driver_internal_info = driver_internal_info task.node.driver_internal_info = driver_internal_info
task.node.save() task.node.save()
except oneview_exceptions.OneViewException as oneview_exc: except client_exception.HPOneViewException as oneview_exc:
msg = (_( msg = (_(
"Error setting boot device on OneView. Error: %s") "Error setting boot device on OneView. Error: %s")
% oneview_exc % oneview_exc
@ -128,9 +180,7 @@ class OneViewManagement(base.ManagementInterface):
common.validate_oneview_resources_compatibility( common.validate_oneview_resources_compatibility(
self.oneview_client, task) self.oneview_client, task)
if not deploy_utils.is_node_in_use_by_ironic( if not deploy_utils.is_node_in_use_by_ironic(task.node):
self.oneview_client, task.node
):
raise exception.InvalidParameterValue( raise exception.InvalidParameterValue(
_("Node %s is not in use by ironic.") % task.node.uuid) _("Node %s is not in use by ironic.") % task.node.uuid)
except exception.OneViewError as oneview_exc: except exception.OneViewError as oneview_exc:
@ -145,7 +195,7 @@ class OneViewManagement(base.ManagementInterface):
in :mod:`ironic.common.boot_devices`. in :mod:`ironic.common.boot_devices`.
""" """
return sorted(BOOT_DEVICE_MAPPING_TO_OV.keys()) return sorted(BOOT_DEVICE_MAP_ONEVIEW)
@METRICS.timer('OneViewManagement.set_boot_device') @METRICS.timer('OneViewManagement.set_boot_device')
@task_manager.require_exclusive_lock @task_manager.require_exclusive_lock
@ -198,37 +248,43 @@ class OneViewManagement(base.ManagementInterface):
:mod:`ironic.common.boot_devices` [PXE, DISK, CDROM] :mod:`ironic.common.boot_devices` [PXE, DISK, CDROM]
:persistent: Whether the boot device will persist to all :persistent: Whether the boot device will persist to all
future boots or not, None if it is unknown. future boots or not, None if it is unknown.
:raises: OperationNotPermitted if no Server Profile is associated with
the node
:raises: InvalidParameterValue if the boot device is unknown :raises: InvalidParameterValue if the boot device is unknown
:raises: OneViewError if the communication with OneView fails :raises: OneViewError if the communication with OneView fails
""" """
oneview_client = common.get_hponeview_client()
driver_internal_info = task.node.driver_internal_info driver_internal_info = task.node.driver_internal_info
next_boot_device = driver_internal_info.get('next_boot_device') next_boot_device = driver_internal_info.get('next_boot_device')
if next_boot_device: if next_boot_device:
return next_boot_device return next_boot_device
oneview_info = common.get_oneview_info(task.node) driver_info = task.node.driver_info
server_profile = driver_info.get('applied_server_profile_uri')
try: try:
boot_order = self.oneview_client.get_boot_order(oneview_info) profile = oneview_client.server_profiles.get(server_profile)
except oneview_exceptions.OneViewException as oneview_exc: primary_device = None
msg = (_( boot = profile.get('boot', {})
"Error getting boot device from OneView. Error: %s") boot_order = boot.get('order', [])
% oneview_exc if boot_order:
) primary_device = boot_order[0]
except client_exception.HPOneViewException as exc:
msg = _("Error on node: %(node)s while getting Server Profile: "
"%(profile)s of the from OneView. Error: %(error)s.") % {
'profile': server_profile,
'node': task.node.uuid,
'error': exc
}
raise exception.OneViewError(msg) raise exception.OneViewError(msg)
primary_device = boot_order[0] if primary_device not in BOOT_DEVICE_MAP_ONEVIEW_REV:
if primary_device not in BOOT_DEVICE_OV_TO_GENERIC:
raise exception.InvalidParameterValue( raise exception.InvalidParameterValue(
_("Unsupported boot Device %(device)s for Node: %(node)s") _("Unsupported boot device %(device)s for node: %(node)s")
% {"device": primary_device, "node": task.node.uuid} % {"device": primary_device, "node": task.node.uuid}
) )
boot_device = { boot_device = {
'boot_device': BOOT_DEVICE_OV_TO_GENERIC.get(primary_device), 'boot_device': BOOT_DEVICE_MAP_ONEVIEW_REV.get(primary_device),
'persistent': True, 'persistent': True,
} }

98
ironic/drivers/modules/oneview/power.py
View File

@ -26,11 +26,34 @@ from ironic.drivers.modules.oneview import common
from ironic.drivers.modules.oneview import deploy_utils from ironic.drivers.modules.oneview import deploy_utils
from ironic.drivers.modules.oneview import management from ironic.drivers.modules.oneview import management
client_exception = importutils.try_import('hpOneView.exceptions')
oneview_exceptions = importutils.try_import('oneview_client.exceptions')
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
METRICS = metrics_utils.get_metrics_logger(__name__) METRICS = metrics_utils.get_metrics_logger(__name__)
oneview_exceptions = importutils.try_import('oneview_client.exceptions') POWER_ON = {'powerState': 'On'}
POWER_OFF = {'powerState': 'Off', 'powerControl': 'PressAndHold'}
REBOOT = {'powerState': 'On', 'powerControl': 'ColdBoot'}
SOFT_REBOOT = {'powerState': 'On', 'powerControl': 'Reset'}
SOFT_POWER_OFF = {'powerState': 'Off', 'powerControl': 'PressAndHold'}
GET_POWER_STATE_MAP = {
'On': states.POWER_ON,
'Off': states.POWER_OFF,
'Resetting': states.REBOOT,
'PoweringOff': states.POWER_ON,
'PoweringOn': states.POWER_OFF
}
SET_POWER_STATE_MAP = {
states.POWER_ON: POWER_ON,
states.POWER_OFF: POWER_OFF,
states.REBOOT: REBOOT,
states.SOFT_REBOOT: SOFT_REBOOT,
states.SOFT_POWER_OFF: SOFT_POWER_OFF
}
class OneViewPower(base.PowerInterface): class OneViewPower(base.PowerInterface):
@ -68,10 +91,9 @@ class OneViewPower(base.PowerInterface):
try: try:
common.validate_oneview_resources_compatibility( common.validate_oneview_resources_compatibility(
self.oneview_client, task) self.oneview_client, task
)
if deploy_utils.is_node_in_use_by_oneview(self.oneview_client, if deploy_utils.is_node_in_use_by_oneview(task.node):
task.node):
raise exception.InvalidParameterValue( raise exception.InvalidParameterValue(
_("Node %s is in use by OneView.") % task.node.uuid) _("Node %s is in use by OneView.") % task.node.uuid)
except exception.OneViewError as oneview_exc: except exception.OneViewError as oneview_exc:
@ -87,20 +109,21 @@ class OneViewPower(base.PowerInterface):
:raises: OneViewError if fails to retrieve power state of OneView :raises: OneViewError if fails to retrieve power state of OneView
resource resource
""" """
oneview_info = common.get_oneview_info(task.node) oneview_client = common.get_hponeview_client()
server_hardware = task.node.driver_info.get('server_hardware_uri')
try: try:
power_state = self.oneview_client.get_node_power_state( server_hardware = oneview_client.server_hardware.get(
oneview_info server_hardware)
) except client_exception.HPOneViewException as exc:
except oneview_exceptions.OneViewException as oneview_exc:
LOG.error( LOG.error(
"Error getting power state for node %(node)s. Error:" "Error getting power state for node %(node)s. Error:"
"%(error)s", "%(error)s",
{'node': task.node.uuid, 'error': oneview_exc} {'node': task.node.uuid, 'error': exc}
) )
raise exception.OneViewError(error=oneview_exc) raise exception.OneViewError(error=exc)
return common.translate_oneview_power_state(power_state) else:
power_state = server_hardware.get('powerState')
return GET_POWER_STATE_MAP.get(power_state)
@METRICS.timer('OneViewPower.set_power_state') @METRICS.timer('OneViewPower.set_power_state')
@task_manager.require_exclusive_lock @task_manager.require_exclusive_lock
@ -114,38 +137,50 @@ class OneViewPower(base.PowerInterface):
:raises: PowerStateFailure if the power couldn't be set to power_state. :raises: PowerStateFailure if the power couldn't be set to power_state.
:raises: OneViewError if OneView fails setting the power state. :raises: OneViewError if OneView fails setting the power state.
""" """
if deploy_utils.is_node_in_use_by_oneview(self.oneview_client, oneview_client = common.get_hponeview_client()
task.node):
if deploy_utils.is_node_in_use_by_oneview(task.node):
raise exception.PowerStateFailure(_( raise exception.PowerStateFailure(_(
"Cannot set power state '%(power_state)s' to node %(node)s. " "Cannot set power state '%(power_state)s' to node %(node)s. "
"The node is in use by OneView.") % "The node is in use by OneView.") %
{'power_state': power_state, {'power_state': power_state,
'node': task.node.uuid}) 'node': task.node.uuid})
oneview_info = common.get_oneview_info(task.node) if power_state not in SET_POWER_STATE_MAP:
raise exception.InvalidParameterValue(
_("set_power_state called with invalid power state %(state)s "
"on node: %(node)s") % {
'state': power_state,
'node': task.node.uuid
})
LOG.debug('Setting power state of node %(node_uuid)s to ' LOG.debug('Setting power state of node %(node_uuid)s to '
'%(power_state)s', '%(power_state)s',
{'node_uuid': task.node.uuid, 'power_state': power_state}) {'node_uuid': task.node.uuid, 'power_state': power_state})
server_hardware = task.node.driver_info.get('server_hardware_uri')
try: try:
if power_state == states.POWER_ON: if power_state == states.POWER_ON:
management.set_boot_device(task) management.set_boot_device(task)
self.oneview_client.power_on(oneview_info) oneview_client.server_hardware.update_power_state(
elif power_state == states.POWER_OFF: SET_POWER_STATE_MAP.get(power_state), server_hardware)
self.oneview_client.power_off(oneview_info)
elif power_state == states.REBOOT: elif power_state == states.REBOOT:
self.oneview_client.power_off(oneview_info) oneview_client.server_hardware.update_power_state(
SET_POWER_STATE_MAP.get(states.POWER_OFF), server_hardware)
management.set_boot_device(task) management.set_boot_device(task)
self.oneview_client.power_on(oneview_info) oneview_client.server_hardware.update_power_state(
SET_POWER_STATE_MAP.get(states.POWER_ON), server_hardware)
else: else:
raise exception.InvalidParameterValue( oneview_client.server_hardware.update_power_state(
_("set_power_state called with invalid power state %s.") SET_POWER_STATE_MAP.get(power_state), server_hardware)
% power_state) except client_exception.HPOneViewException as exc:
except oneview_exceptions.OneViewException as exc:
raise exception.OneViewError( raise exception.OneViewError(
_("Error setting power state: %s") % exc _("Failed to setting power state on node: %(node)s. "
) "Error: %(error)s.") % {
'node': task.node.uuid,
'error': exc
})
@METRICS.timer('OneViewPower.reboot') @METRICS.timer('OneViewPower.reboot')
@task_manager.require_exclusive_lock @task_manager.require_exclusive_lock
@ -156,5 +191,8 @@ class OneViewPower(base.PowerInterface):
:raises: PowerStateFailure if the final state of the node is not :raises: PowerStateFailure if the final state of the node is not
POWER_ON. POWER_ON.
""" """
current_power_state = self.get_power_state(task)
self.set_power_state(task, states.REBOOT) if current_power_state == states.POWER_ON:
self.set_power_state(task, states.REBOOT)
else:
self.set_power_state(task, states.POWER_ON)

20
ironic/drivers/oneview.py
View File

@ -73,6 +73,16 @@ class AgentPXEOneViewDriver(base.BaseDriver):
driver=self.__class__.__name__, driver=self.__class__.__name__,
reason=_("Unable to import python-oneviewclient library")) reason=_("Unable to import python-oneviewclient library"))
if not importutils.try_import('hpOneView.oneview_client'):
raise exception.DriverLoadError(
driver=self.__class__.__name__,
reason=_("Unable to import hpOneView library"))
if not importutils.try_import('redfish'):
raise exception.DriverLoadError(
driver=self.__class__.__name__,
reason=_("Unable to import python-ilorest-library"))
# Checks connectivity to OneView and version compatibility on driver # Checks connectivity to OneView and version compatibility on driver
# initialization # initialization
oneview_client = common.get_oneview_client() oneview_client = common.get_oneview_client()
@ -101,6 +111,16 @@ class ISCSIPXEOneViewDriver(base.BaseDriver):
driver=self.__class__.__name__, driver=self.__class__.__name__,
reason=_("Unable to import python-oneviewclient library")) reason=_("Unable to import python-oneviewclient library"))
if not importutils.try_import('hpOneView.oneview_client'):
raise exception.DriverLoadError(
driver=self.__class__.__name__,
reason=_("Unable to import hpOneView library"))
if not importutils.try_import('redfish'):
raise exception.DriverLoadError(
driver=self.__class__.__name__,
reason=_("Unable to import python-ilorest-library"))
# Checks connectivity to OneView and version compatibility on driver # Checks connectivity to OneView and version compatibility on driver
# initialization # initialization
oneview_client = common.get_oneview_client() oneview_client = common.get_oneview_client()

20
ironic/tests/unit/drivers/modules/oneview/test_common.py
View File

@ -17,7 +17,6 @@ import mock
from oslo_utils import importutils from oslo_utils import importutils
from ironic.common import exception from ironic.common import exception
from ironic.common import states
from ironic.conductor import task_manager from ironic.conductor import task_manager
from ironic.drivers.modules.oneview import common from ironic.drivers.modules.oneview import common
from ironic.tests.unit.conductor import mgr_utils from ironic.tests.unit.conductor import mgr_utils
@ -26,7 +25,6 @@ from ironic.tests.unit.db import utils as db_utils
from ironic.tests.unit.objects import utils as obj_utils from ironic.tests.unit.objects import utils as obj_utils
hponeview_client = importutils.try_import('hpOneView.oneview_client') hponeview_client = importutils.try_import('hpOneView.oneview_client')
oneview_states = importutils.try_import('oneview_client.states')
class OneViewCommonTestCase(db_base.DbTestCase): class OneViewCommonTestCase(db_base.DbTestCase):
@ -258,24 +256,6 @@ class OneViewCommonTestCase(db_base.DbTestCase):
{"a": '', "b": None, "c": "something"}, {"a": '', "b": None, "c": "something"},
["a", "b", "c"]) ["a", "b", "c"])
def _test_translate_oneview_states(self, power_state_to_translate,
expected_translated_power_state):
translated_power_state = common.translate_oneview_power_state(
power_state_to_translate)
self.assertEqual(translated_power_state,
expected_translated_power_state)
def test_all_scenarios_for_translate_oneview_states(self):
self._test_translate_oneview_states(
oneview_states.ONEVIEW_POWERING_OFF, states.POWER_ON)
self._test_translate_oneview_states(
oneview_states.ONEVIEW_POWER_OFF, states.POWER_OFF)
self._test_translate_oneview_states(
oneview_states.ONEVIEW_POWERING_ON, states.POWER_OFF)
self._test_translate_oneview_states(
oneview_states.ONEVIEW_RESETTING, states.REBOOT)
self._test_translate_oneview_states("anything", states.ERROR)
@mock.patch.object(common, 'get_oneview_client', spec_set=True, @mock.patch.object(common, 'get_oneview_client', spec_set=True,
autospec=True) autospec=True)
def test_validate_oneview_resources_compatibility( def test_validate_oneview_resources_compatibility(

89
ironic/tests/unit/drivers/modules/oneview/test_deploy.py
View File

@ -99,7 +99,6 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.config(password='password', group='oneview') self.config(password='password', group='oneview')
mgr_utils.mock_the_extension_manager(driver='fake_oneview') mgr_utils.mock_the_extension_manager(driver='fake_oneview')
self.driver = driver_factory.get_driver('fake_oneview') self.driver = driver_factory.get_driver('fake_oneview')
self.deploy = OneViewDriverDeploy() self.deploy = OneViewDriverDeploy()
self.os_primary = mock.MagicMock(spec=METHODS) self.os_primary = mock.MagicMock(spec=METHODS)
@ -119,9 +118,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_taken_by_oneview( self.deploy._periodic_check_nodes_taken_by_oneview(
self.os_primary, self.context self.os_primary, self.context
) )
mock_is_node_in_use_by_oneview.assert_called_once_with( mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.deploy.oneview_client, self.node
)
self.assertTrue(self.os_primary.update_node.called) self.assertTrue(self.os_primary.update_node.called)
self.assertTrue(self.os_primary.do_provisioning_action.called) self.assertTrue(self.os_primary.do_provisioning_action.called)
self.assertTrue(self.node.maintenance) self.assertTrue(self.node.maintenance)
@ -139,9 +136,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_taken_by_oneview( self.deploy._periodic_check_nodes_taken_by_oneview(
self.os_primary, self.context self.os_primary, self.context
) )
mock_is_node_in_use_by_oneview.assert_called_once_with( mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.deploy.oneview_client, self.node
)
self.assertFalse(self.os_primary.update_node.called) self.assertFalse(self.os_primary.update_node.called)
self.assertFalse(self.os_primary.do_provisioning_action.called) self.assertFalse(self.os_primary.do_provisioning_action.called)
self.assertFalse(self.node.maintenance) self.assertFalse(self.node.maintenance)
@ -158,9 +153,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_taken_by_oneview( self.deploy._periodic_check_nodes_taken_by_oneview(
self.os_primary, self.context self.os_primary, self.context
) )
mock_is_node_in_use_by_oneview.assert_called_once_with( mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.deploy.oneview_client, self.node
)
self.assertFalse(self.os_primary.update_node.called) self.assertFalse(self.os_primary.update_node.called)
self.assertFalse(self.os_primary.do_provisioning_action.called) self.assertFalse(self.os_primary.do_provisioning_action.called)
self.assertFalse(self.node.maintenance) self.assertFalse(self.node.maintenance)
@ -177,9 +170,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_freed_by_oneview( self.deploy._periodic_check_nodes_freed_by_oneview(
self.os_primary, self.context self.os_primary, self.context
) )
mock_is_node_in_use_by_oneview.assert_called_once_with( mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.deploy.oneview_client, self.node
)
self.assertTrue(self.os_primary.update_node.called) self.assertTrue(self.os_primary.update_node.called)
self.assertTrue(self.os_primary.do_provisioning_action.called) self.assertTrue(self.os_primary.do_provisioning_action.called)
self.assertFalse(self.node.maintenance) self.assertFalse(self.node.maintenance)
@ -195,9 +186,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_freed_by_oneview( self.deploy._periodic_check_nodes_freed_by_oneview(
self.os_primary, self.context self.os_primary, self.context
) )
mock_is_node_in_use_by_oneview.assert_called_once_with( mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.deploy.oneview_client, self.node
)
self.assertFalse(self.os_primary.update_node.called) self.assertFalse(self.os_primary.update_node.called)
self.assertFalse(self.os_primary.do_provisioning_action.called) self.assertFalse(self.os_primary.do_provisioning_action.called)
self.assertTrue(self.node.maintenance) self.assertTrue(self.node.maintenance)
@ -215,9 +204,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_freed_by_oneview( self.deploy._periodic_check_nodes_freed_by_oneview(
self.os_primary, self.context self.os_primary, self.context
) )
mock_is_node_in_use_by_oneview.assert_called_once_with( mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.deploy.oneview_client, self.node
)
self.assertFalse(self.os_primary.update_node.called) self.assertFalse(self.os_primary.update_node.called)
self.assertFalse(self.os_primary.do_provisioning_action.called) self.assertFalse(self.os_primary.do_provisioning_action.called)
self.assertTrue(self.node.maintenance) self.assertTrue(self.node.maintenance)
@ -245,8 +232,8 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
): ):
mock_node_get.get.return_value = self.node mock_node_get.get.return_value = self.node
_setup_node_in_cleanfailed_state_without_oneview_error(self.node) _setup_node_in_cleanfailed_state_without_oneview_error(self.node)
self.os_primary.iter_nodes.return_value = \ self.os_primary.iter_nodes.return_value = (
nodes_taken_on_cleanfail_no_info nodes_taken_on_cleanfail_no_info)
self.deploy._periodic_check_nodes_taken_on_cleanfail( self.deploy._periodic_check_nodes_taken_on_cleanfail(
self.os_primary, self.context self.os_primary, self.context
) )
@ -258,7 +245,6 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.assertNotIn('oneview_error', self.node.driver_internal_info) self.assertNotIn('oneview_error', self.node.driver_internal_info)
@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True)
class OneViewIscsiDeployTestCase(db_base.DbTestCase): class OneViewIscsiDeployTestCase(db_base.DbTestCase):
def setUp(self): def setUp(self):
@ -282,35 +268,32 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
node_id=self.node.id) node_id=self.node.id)
self.info = common.get_oneview_info(self.node) self.info = common.get_oneview_info(self.node)
def test_get_properties(self, mock_get_ov_client): def test_get_properties(self):
expected = common.COMMON_PROPERTIES expected = common.COMMON_PROPERTIES
self.assertEqual(expected, self.driver.deploy.get_properties()) self.assertEqual(expected, self.driver.deploy.get_properties())
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate', @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate',
spec_set=True, autospec=True) spec_set=True, autospec=True)
def test_validate(self, iscsi_deploy_validate_mock, mock_get_ov_client): def test_validate(self, iscsi_deploy_validate):
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
task.driver.deploy.validate(task) task.driver.deploy.validate(task)
iscsi_deploy_validate_mock.assert_called_once_with(mock.ANY, task) iscsi_deploy_validate.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare', @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare', autospec=True)
spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare(self, allocate_server_hardware_mock, def test_prepare(self, allocate_server_hardware_mock,
iscsi_deploy_prepare_mock, mock_get_ov_client): iscsi_deploy_prepare_mock):
self.node.provision_state = states.DEPLOYING self.node.provision_state = states.DEPLOYING
self.node.save() self.node.save()
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid) as task:
shared=False) as task:
task.driver.deploy.prepare(task) task.driver.deploy.prepare(task)
iscsi_deploy_prepare_mock.assert_called_once_with(mock.ANY, task) iscsi_deploy_prepare_mock.assert_called_once_with(mock.ANY, task)
self.assertTrue(allocate_server_hardware_mock.called) self.assertTrue(allocate_server_hardware_mock.called)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare', @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare',
spec_set=True, autospec=True) spec_set=True, autospec=True)
def test_prepare_active_node(self, iscsi_deploy_prepare_mock, def test_prepare_active_node(self, iscsi_deploy_prepare_mock):
mock_get_ov_client):
"""Ensure nodes in running states are not inadvertently changed""" """Ensure nodes in running states are not inadvertently changed"""
test_states = list(states.STABLE_STATES) test_states = list(states.STABLE_STATES)
test_states.extend([states.CLEANING, test_states.extend([states.CLEANING,
@ -328,7 +311,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'deploy', @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'deploy',
spec_set=True, autospec=True) spec_set=True, autospec=True)
def test_deploy(self, iscsi_deploy_mock, mock_get_ov_client): def test_deploy(self, iscsi_deploy_mock):
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
task.driver.deploy.deploy(task) task.driver.deploy.deploy(task)
@ -336,7 +319,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down', spec_set=True, @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down', spec_set=True,
autospec=True) autospec=True)
def test_tear_down(self, iscsi_tear_down_mock, mock_get_ov_client): def test_tear_down(self, iscsi_tear_down_mock):
iscsi_tear_down_mock.return_value = states.DELETED iscsi_tear_down_mock.return_value = states.DELETED
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
@ -348,9 +331,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
autospec=True) autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic') @mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_with_automated_clean_disabled( def test_tear_down_with_automated_clean_disabled(
self, deallocate_server_hardware_mock, self, deallocate_server_hardware_mock, iscsi_tear_down_mock):
iscsi_tear_down_mock, mock_get_ov_client
):
CONF.conductor.automated_clean = False CONF.conductor.automated_clean = False
iscsi_tear_down_mock.return_value = states.DELETED iscsi_tear_down_mock.return_value = states.DELETED
@ -364,8 +345,8 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare_cleaning', @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare_cleaning',
spec_set=True, autospec=True) spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare_cleaning(self, allocate_server_hardware_mock, def test_prepare_cleaning(
iscsi_prep_clean_mock, mock_get_ov_client): self, allocate_server_hardware_mock, iscsi_prep_clean_mock):
iscsi_prep_clean_mock.return_value = states.CLEANWAIT iscsi_prep_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
@ -378,9 +359,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
spec_set=True, autospec=True) spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic') @mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_cleaning( def test_tear_down_cleaning(
self, deallocate_server_hardware_mock, iscsi_tear_down_clean_mock, self, deallocate_server_hardware_mock, iscsi_tear_down_clean_mock):
mock_get_ov_client
):
iscsi_tear_down_clean_mock.return_value = states.CLEANWAIT iscsi_tear_down_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
@ -390,7 +369,6 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
self.assertTrue(deallocate_server_hardware_mock.called) self.assertTrue(deallocate_server_hardware_mock.called)
@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True)
class OneViewAgentDeployTestCase(db_base.DbTestCase): class OneViewAgentDeployTestCase(db_base.DbTestCase):
def setUp(self): def setUp(self):
super(OneViewAgentDeployTestCase, self).setUp() super(OneViewAgentDeployTestCase, self).setUp()
@ -413,13 +391,13 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
node_id=self.node.id) node_id=self.node.id)
self.info = common.get_oneview_info(self.node) self.info = common.get_oneview_info(self.node)
def test_get_properties(self, mock_get_ov_client): def test_get_properties(self):
expected = common.COMMON_PROPERTIES expected = common.COMMON_PROPERTIES
self.assertEqual(expected, self.driver.deploy.get_properties()) self.assertEqual(expected, self.driver.deploy.get_properties())
@mock.patch.object(agent.AgentDeploy, 'validate', @mock.patch.object(agent.AgentDeploy, 'validate',
spec_set=True, autospec=True) spec_set=True, autospec=True)
def test_validate(self, agent_deploy_validate_mock, mock_get_ov_client): def test_validate(self, agent_deploy_validate_mock):
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
task.driver.deploy.validate(task) task.driver.deploy.validate(task)
@ -428,8 +406,8 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
@mock.patch.object(agent.AgentDeploy, 'prepare', @mock.patch.object(agent.AgentDeploy, 'prepare',
spec_set=True, autospec=True) spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare(self, allocate_server_hardware_mock, def test_prepare(
agent_deploy_prepare_mock, mock_get_ov_client): self, allocate_server_hardware_mock, agent_deploy_prepare_mock):
self.node.provision_state = states.DEPLOYING self.node.provision_state = states.DEPLOYING
self.node.save() self.node.save()
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
@ -440,8 +418,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
@mock.patch.object(agent.AgentDeploy, 'prepare', @mock.patch.object(agent.AgentDeploy, 'prepare',
spec_set=True, autospec=True) spec_set=True, autospec=True)
def test_prepare_active_node(self, agent_deploy_prepare_mock, def test_prepare_active_node(self, agent_deploy_prepare_mock):
mock_get_ov_client):
"""Ensure nodes in running states are not inadvertently changed""" """Ensure nodes in running states are not inadvertently changed"""
test_states = list(states.STABLE_STATES) test_states = list(states.STABLE_STATES)
test_states.extend([states.CLEANING, test_states.extend([states.CLEANING,
@ -459,7 +436,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
@mock.patch.object(agent.AgentDeploy, 'deploy', @mock.patch.object(agent.AgentDeploy, 'deploy',
spec_set=True, autospec=True) spec_set=True, autospec=True)
def test_deploy(self, agent_deploy_mock, mock_get_ov_client): def test_deploy(self, agent_deploy_mock):
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
task.driver.deploy.deploy(task) task.driver.deploy.deploy(task)
@ -469,9 +446,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
autospec=True) autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic') @mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_with_automated_clean_disabled( def test_tear_down_with_automated_clean_disabled(
self, deallocate_server_hardware_mock, self, deallocate_server_hardware_mock, agent_tear_down_mock):
agent_tear_down_mock, mock_get_ov_client
):
CONF.conductor.automated_clean = False CONF.conductor.automated_clean = False
agent_tear_down_mock.return_value = states.DELETED agent_tear_down_mock.return_value = states.DELETED
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
@ -484,8 +459,8 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
@mock.patch.object(agent.AgentDeploy, 'prepare_cleaning', @mock.patch.object(agent.AgentDeploy, 'prepare_cleaning',
spec_set=True, autospec=True) spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare_cleaning(self, allocate_server_hardware_mock, def test_prepare_cleaning(
agent_prep_clean_mock, mock_get_ov_client): self, allocate_server_hardware_mock, agent_prep_clean_mock):
agent_prep_clean_mock.return_value = states.CLEANWAIT agent_prep_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
@ -498,9 +473,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
spec_set=True, autospec=True) spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic') @mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_cleaning( def test_tear_down_cleaning(
self, deallocate_server_hardware_mock, agent_tear_down_clean_mock, self, deallocate_server_hardware_mock, agent_tear_down_clean_mock):
mock_get_ov_client
):
agent_tear_down_clean_mock.return_value = states.CLEANWAIT agent_tear_down_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:

469
ironic/tests/unit/drivers/modules/oneview/test_deploy_utils.py
View File

@ -14,6 +14,7 @@
# under the License. # under the License.
import mock import mock
from oslo_utils import importutils from oslo_utils import importutils
from ironic.common import driver_factory from ironic.common import driver_factory
@ -31,7 +32,7 @@ from ironic.tests.unit.objects import utils as obj_utils
oneview_models = importutils.try_import('oneview_client.models') oneview_models = importutils.try_import('oneview_client.models')
@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True) @mock.patch.object(common, 'get_hponeview_client')
class OneViewDeployUtilsTestCase(db_base.DbTestCase): class OneViewDeployUtilsTestCase(db_base.DbTestCase):
def setUp(self): def setUp(self):
@ -49,394 +50,292 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
driver_info=db_utils.get_test_oneview_driver_info(), driver_info=db_utils.get_test_oneview_driver_info(),
) )
self.info = common.get_oneview_info(self.node) self.info = common.get_oneview_info(self.node)
deploy_utils.is_node_in_use_by_oneview = mock.Mock(return_value=False)
deploy_utils.is_node_in_use_by_ironic = mock.Mock(return_value=True)
# Tests for prepare # Tests for prepare
def test_prepare_node_is_in_use_by_oneview(self, mock_get_ov_client): def test_prepare_node_is_in_use_by_oneview(self, mock_oneview_client):
"""`prepare` behavior when the node already has a Profile on OneView. """`prepare` behavior when the node has a Profile on OneView."""
deploy_utils.is_node_in_use_by_oneview.return_value = True
"""
oneview_client = mock_get_ov_client()
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = "/any/sp_uri"
oneview_client.get_server_hardware.return_value = fake_server_hardware
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
task.node.driver_info = driver_info
task.node.provision_state = states.DEPLOYING task.node.provision_state = states.DEPLOYING
self.assertRaises( self.assertRaises(
exception.InstanceDeployFailure, exception.InstanceDeployFailure,
deploy_utils.prepare, deploy_utils.prepare,
oneview_client,
task task
) )
@mock.patch.object(objects.Node, 'save') @mock.patch.object(objects.Node, 'save')
def test_prepare_node_is_successfuly_allocated_to_ironic( def test_prepare_node_is_successfuly_allocated_to_ironic(
self, mock_node_save, mock_get_ov_client self, mock_save, mock_oneview_client):
): """`prepare` behavior when the node is free from OneView standpoint."""
"""`prepare` behavior when the node is free from OneView standpoint.
"""
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = None
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
task.node.provision_state = states.DEPLOYING task.node.provision_state = states.DEPLOYING
deploy_utils.prepare(oneview_client, task) deploy_utils.prepare(task)
self.assertTrue(oneview_client.clone_template_and_apply.called) self.assertTrue(mock_save.called)
self.assertTrue(oneview_client.get_server_profile_from_hardware)
# Tests for tear_down # Tests for tear_down
def test_tear_down(self, mock_get_ov_client): def test_tear_down(self, mock_oneview_client):
"""`tear_down` behavior when node already has Profile applied """`tear_down` behavior when node already has Profile applied."""
oneview_client = mock_oneview_client()
"""
sp_uri = '/rest/server-profiles/1234556789'
ov_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = sp_uri
ov_client = mock_get_ov_client.return_value
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info['applied_server_profile_uri'] = (
driver_info['applied_server_profile_uri'] = \
'/rest/server-profiles/1234556789' '/rest/server-profiles/1234556789'
task.node.driver_info = driver_info
self.assertIn(
'applied_server_profile_uri', task.node.driver_info
) )
deploy_utils.tear_down(ov_client, task) self.assertTrue(
self.assertNotIn( 'applied_server_profile_uri' in task.node.driver_info
'applied_server_profile_uri', task.node.driver_info
) )
self.assertTrue( deploy_utils.tear_down(task)
ov_client.delete_server_profile.called self.assertFalse(
) 'applied_server_profile_uri' in task.node.driver_info
)
self.assertTrue(oneview_client.server_profiles.delete.called)
# Tests for prepare_cleaning # Tests for prepare_cleaning
@mock.patch.object(objects.Node, 'save') @mock.patch.object(objects.Node, 'save')
def test_prepare_cleaning_when_node_does_not_have_sp_applied( def test_prepare_cleaning_when_node_does_not_have_sp_applied(
self, mock_node_save, mock_get_ov_client self, mock_save, mock_oneview_client):
): """`prepare_cleaning` behavior when node is free."""
"""`prepare_cleaning` behavior when node is free
"""
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = None
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
deploy_utils.prepare_cleaning(oneview_client, task) self.assertFalse(
self.assertTrue(oneview_client.clone_template_and_apply.called) 'applied_server_profile_uri' in task.node.driver_info
)
deploy_utils.prepare_cleaning(task)
self.assertTrue(
'applied_server_profile_uri' in task.node.driver_info
)
@mock.patch.object(objects.Node, 'save') @mock.patch.object(objects.Node, 'save')
def test_prepare_cleaning_when_node_has_sp_applied( def test_prepare_cleaning_when_node_has_sp_applied(
self, mock_node_save, mock_get_ov_client self, mock_node_save, mock_oneview_client):
): """`prepare_cleaning` behavior when node has Profile applied."""
"""`prepare_cleaning` behavior when node already has Profile applied oneview_client = mock_oneview_client()
oneview_client.server_hardware.get.return_value = {
""" 'serverProfileUri': 'same/sp_applied'
oneview_client = mock_get_ov_client() }
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = 'same/sp_applied'
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info['applied_server_profile_uri'] = (
driver_info['applied_server_profile_uri'] = 'same/sp_applied' 'same/sp_applied'
task.node.driver_info = driver_info )
deploy_utils.prepare_cleaning(task)
deploy_utils.prepare_cleaning(oneview_client, task) self.assertFalse(mock_node_save.called)
self.assertFalse(oneview_client.clone_template_and_apply.called)
def test_prepare_cleaning_node_is_in_use_by_oneview( def test_prepare_cleaning_node_is_in_use_by_oneview(
self, mock_get_ov_client self, mock_oneview_client):
): """`prepare_cleaning` behavior when node has Profile on OneView."""
"""`prepare_cleaning` behavior when node has Server Profile on OneView deploy_utils.is_node_in_use_by_oneview.return_value = True
"""
oneview_client = mock_get_ov_client()
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = "/any/sp_uri"
oneview_client.get_server_hardware.return_value = fake_server_hardware
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
task.node.driver_info = driver_info
task.node.provision_state = states.DEPLOYING
self.assertRaises( self.assertRaises(
exception.NodeCleaningFailure, exception.NodeCleaningFailure,
deploy_utils.prepare_cleaning, deploy_utils.prepare_cleaning,
oneview_client,
task task
) )
# Tests for tear_down_cleaning # Tests for tear_down_cleaning
def test_tear_down_cleaning(self, mock_get_ov_client): def test_tear_down_cleaning(self, mock_oneview_client):
"""Checks if Server Profile was deleted and its uri removed """Check if Server Profile was deleted and its uri removed."""
oneview_client = mock_oneview_client()
"""
sp_uri = '/rest/server-profiles/1234556789'
ov_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = sp_uri
ov_client = mock_get_ov_client.return_value
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info['applied_server_profile_uri'] = (
driver_info['applied_server_profile_uri'] = \
'/rest/server-profiles/1234556789' '/rest/server-profiles/1234556789'
task.node.driver_info = driver_info )
self.assertTrue(
self.assertIn('applied_server_profile_uri', task.node.driver_info) 'applied_server_profile_uri' in task.node.driver_info
deploy_utils.tear_down_cleaning(ov_client, task) )
self.assertNotIn('applied_server_profile_uri', deploy_utils.tear_down_cleaning(task)
task.node.driver_info) self.assertFalse(
self.assertTrue(ov_client.delete_server_profile.called) 'applied_server_profile_uri' in task.node.driver_info
)
self.assertTrue(oneview_client.server_profiles.delete.called)
# Tests for is_node_in_use_by_oneview # Tests for is_node_in_use_by_oneview
def test_is_node_in_use_by_oneview(self, mock_get_ov_client): def test_is_node_in_use_by_oneview(self, mock_oneview_client):
"""Node has a Server Profile applied by a third party user. """Node has a Server Profile applied by a third party user."""
server_hardware = {
""" 'serverProfileUri': '/rest/server-profile/123456789'
oneview_client = mock_get_ov_client() }
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = "/any/sp_uri"
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info['applied_server_profile_uri'] = (
task.node.driver_info = driver_info '/rest/server-profile/987654321'
)
self.assertTrue( self.assertTrue(
deploy_utils.is_node_in_use_by_oneview(oneview_client, deploy_utils._is_node_in_use(
task.node) server_hardware,
task.node.driver_info['applied_server_profile_uri'],
by_oneview=True
)
) )
def test_is_node_in_use_by_oneview_no_server_profile( def test_is_node_in_use_by_oneview_no_server_profile(
self, mock_get_ov_client self, mock_oneview_client):
): """Node has no Server Profile."""
"""Node has no Server Profile. server_hardware = {'serverProfileUri': None}
"""
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = None
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
task.node.driver_info['applied_server_profile_uri'] = (
'/rest/server-profile/123456789'
)
self.assertFalse( self.assertFalse(
deploy_utils.is_node_in_use_by_oneview(oneview_client, deploy_utils._is_node_in_use(
task.node) server_hardware,
task.node.driver_info['applied_server_profile_uri'],
by_oneview=True
)
) )
def test_is_node_in_use_by_oneview_same_server_profile_applied( def test_is_node_in_use_by_oneview_same_server_profile_applied(
self, mock_get_ov_client self, mock_oneview_client):
): """Check if node's Server Profile uri is the same applied by ironic."""
"""Node's Server Profile uri is the same applied by ironic. server_hardware = {
'serverProfileUri': '/rest/server-profile/123456789'
""" }
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = 'same/applied_sp_uri/'
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info['applied_server_profile_uri'] = (
driver_info['applied_server_profile_uri'] = 'same/applied_sp_uri/' '/rest/server-profile/123456789'
task.node.driver_info = driver_info )
self.assertFalse( self.assertFalse(
deploy_utils.is_node_in_use_by_oneview(oneview_client, deploy_utils._is_node_in_use(
task.node) server_hardware,
task.node.driver_info['applied_server_profile_uri'],
by_oneview=True
)
) )
# Tests for is_node_in_use_by_ironic # Tests for is_node_in_use_by_ironic
def test_is_node_in_use_by_ironic(self, mock_get_ov_client): def test_is_node_in_use_by_ironic(self, mock_oneview_client):
"""Node has a Server Profile applied by ironic. """Node has a Server Profile applied by ironic."""
server_hardware = {'serverProfileUri': 'same/applied_sp_uri/'}
"""
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = "same/applied_sp_uri/"
ov_client = mock_get_ov_client.return_value
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info['applied_server_profile_uri'] = (
driver_info['applied_server_profile_uri'] = 'same/applied_sp_uri/' 'same/applied_sp_uri/'
task.node.driver_info = driver_info )
self.assertTrue( self.assertTrue(
deploy_utils.is_node_in_use_by_ironic(ov_client, task.node) deploy_utils._is_node_in_use(
server_hardware,
task.node.driver_info['applied_server_profile_uri'],
by_oneview=False
)
) )
def test_is_node_in_use_by_ironic_no_server_profile( def test_is_node_in_use_by_ironic_no_server_profile(
self, mock_get_ov_client self, mock_oneview_client):
): """Node has no Server Profile."""
"""Node has no Server Profile. server_hardware = {'serverProfileUri': None}
"""
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = None
ov_client = mock_get_ov_client.return_value
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
task.node.driver_info['applied_server_profile_uri'] = (
'/applied_sp_uri/'
)
self.assertFalse( self.assertFalse(
deploy_utils.is_node_in_use_by_ironic(ov_client, task.node) deploy_utils._is_node_in_use(
server_hardware,
task.node.driver_info['applied_server_profile_uri'],
by_oneview=False
)
) )
def test__create_profile_from_template(self, mock_oneview_client):
"""Check if the server_profile was created from template."""
server_hardware_uri = "server_hardware/12456789"
sp_template_uri = "server_profile_template_uri/13245798"
oneview_client = mock_oneview_client()
oneview_client.server_profile_templates.\
get_new_profile.return_value = {}
server_profile = {"name": "server_profile_name",
"serverHardwareUri": server_hardware_uri,
"serverProfileTemplateUri": ""}
deploy_utils._create_profile_from_template(
oneview_client,
"server_profile_name",
server_hardware_uri,
sp_template_uri
)
oneview_client.server_profiles.create.assert_called_with(
server_profile)
# Tests for _add_applied_server_profile_uri_field # Tests for _add_applied_server_profile_uri_field
def test__add_applied_server_profile_uri_field(self, mock_get_ov_client): @mock.patch.object(objects.Node, 'save')
"""Checks if applied_server_profile_uri was added to driver_info. def test__add_applied_server_profile_uri_field(
self, save, mock_oneview_client):
""" """Check if applied_server_profile_uri was added to driver_info."""
server_profile = {'uri': 'any/applied_sp_uri/'}
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info.pop('applied_server_profile_uri', None)
task.node.driver_info = driver_info self.assertNotIn(
fake_server_profile = oneview_models.ServerProfile() 'applied_server_profile_uri', task.node.driver_info
fake_server_profile.uri = 'any/applied_sp_uri/' )
self.assertNotIn('applied_server_profile_uri',
task.node.driver_info)
deploy_utils._add_applied_server_profile_uri_field( deploy_utils._add_applied_server_profile_uri_field(
task.node, task.node,
fake_server_profile server_profile
) )
self.assertIn('applied_server_profile_uri', task.node.driver_info) self.assertIn('applied_server_profile_uri', task.node.driver_info)
# Tests for _del_applied_server_profile_uri_field # Tests for _del_applied_server_profile_uri_field
def test__del_applied_server_profile_uri_field(self, mock_get_ov_client): @mock.patch.object(objects.Node, 'save')
"""Checks if applied_server_profile_uri was removed from driver_info. def test__del_applied_server_profile_uri_field(
self, save, mock_oneview_client):
""" """Check if applied_server_profile_uri was removed from driver_info."""
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info['applied_server_profile_uri'] = (
driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/' 'any/applied_sp_uri/'
task.node.driver_info = driver_info )
self.assertIn('applied_server_profile_uri', task.node.driver_info) self.assertIn('applied_server_profile_uri', task.node.driver_info)
deploy_utils._del_applied_server_profile_uri_field(task.node) deploy_utils._del_applied_server_profile_uri_field(task.node)
self.assertNotIn('applied_server_profile_uri', self.assertNotIn(
task.node.driver_info) 'applied_server_profile_uri', task.node.driver_info
)
# Tests for allocate_server_hardware_to_ironic # Tests for allocate_server_hardware_to_ironic
@mock.patch.object(objects.Node, 'save') @mock.patch.object(objects.Node, 'save')
def test_allocate_server_hardware_to_ironic( def test_allocate_server_hardware_to_ironic(
self, mock_node_save, mock_get_ov_client self, mock_node_save, mock_oneview_client):
): """Check if a Profile was created and its uri is in driver_info."""
"""Checks if a Server Profile was created and its uri is in driver_info. oneview_client = mock_oneview_client()
server_hardware = {'serverProfileUri': None}
""" oneview_client.server_hardware.get.return_value = server_hardware
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = None
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
deploy_utils.allocate_server_hardware_to_ironic( deploy_utils.allocate_server_hardware_to_ironic(
oneview_client, task.node, 'serverProfileName' task.node, 'serverProfileName'
) )
self.assertTrue(oneview_client.clone_template_and_apply.called) self.assertTrue(mock_node_save.called)
self.assertIn('applied_server_profile_uri', task.node.driver_info) self.assertIn('applied_server_profile_uri', task.node.driver_info)
@mock.patch.object(objects.Node, 'save') @mock.patch.object(objects.Node, 'save')
@mock.patch.object(deploy_utils,
'_del_applied_server_profile_uri_field')
def test_allocate_server_hardware_to_ironic_node_has_server_profile( def test_allocate_server_hardware_to_ironic_node_has_server_profile(
self, mock_delete_applied_sp, mock_node_save, mock_get_ov_client self, mock_node_save, mock_oneview_client):
): """Test profile allocation when applied_server_profile_uri exists.
"""Tests server profile allocation when applied_server_profile_uri exists.
This test consider that no Server Profile is applied on the Server This test consider that no Server Profile is applied on the Server
Hardware but the applied_server_profile_uri remained on the node. Thus, Hardware but the applied_server_profile_uri remained on the node. Thus,
the conductor should remove the value and apply a new server profile to the conductor should remove the value and apply a new server profile to
use the node. use the node.
""" """
oneview_client = mock_get_ov_client() oneview_client = mock_oneview_client()
server_hardware = {'serverProfileUri': None}
fake_sh = oneview_models.ServerHardware() oneview_client.server_hardware.get.return_value = server_hardware
fake_sh.server_profile_uri = None
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info['applied_server_profile_uri'] = (
driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/' 'any/applied_sp_uri/'
task.node.driver_info = driver_info
deploy_utils.allocate_server_hardware_to_ironic(
oneview_client, task.node, 'serverProfileName'
) )
self.assertTrue(mock_delete_applied_sp.called) deploy_utils.allocate_server_hardware_to_ironic(
task.node, 'serverProfileName'
)
self.assertTrue(mock_node_save.called)
# Tests for deallocate_server_hardware_from_ironic # Tests for deallocate_server_hardware_from_ironic
@mock.patch.object(objects.Node, 'save') @mock.patch.object(objects.Node, 'save')
def test_deallocate_server_hardware_from_ironic( def test_deallocate_server_hardware_from_ironic(
self, mock_node_save, mock_get_ov_client self, mock_node_save, mock_oneview_client):
): oneview_client = mock_oneview_client()
oneview_client = mock_get_ov_client() server_hardware = {'serverProfileUri': 'any/applied_sp_uri/'}
oneview_client.server_hardware.get.return_value = server_hardware
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = 'any/applied_sp_uri/'
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
mock_get_ov_client.return_value = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info task.node.driver_info['applied_server_profile_uri'] = (
driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/' 'any/applied_sp_uri/'
task.node.driver_info = driver_info
deploy_utils.deallocate_server_hardware_from_ironic(
oneview_client, task.node
) )
self.assertTrue(oneview_client.delete_server_profile.called) deploy_utils.deallocate_server_hardware_from_ironic(task)
self.assertNotIn( self.assertTrue(mock_node_save.called)
'applied_server_profile_uri', task.node.driver_info self.assertTrue(
) 'applied_server_profile_uri' not in task.node.driver_info
@mock.patch.object(objects.Node, 'save')
def test_deallocate_server_hardware_from_ironic_missing_profile_uuid(
self, mock_node_save, mock_get_ov_client
):
"""Test for case when server profile application fails.
Due to an error when applying Server Profile in OneView,
the node will have no Server Profile uuid in the
'applied_server_profile_uri' namespace. When the method
tested is called without Server Profile uuid, the client
will raise a ValueError when trying to delete the profile,
this error is converted to an OneViewError.
"""
ov_client = mock_get_ov_client.return_value
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = 'any/applied_sp_uri/'
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
ov_client.delete_server_profile.side_effect = ValueError
mock_get_ov_client.return_value = ov_client
with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/'
task.node.driver_info = driver_info
self.assertRaises(
exception.OneViewError,
deploy_utils.deallocate_server_hardware_from_ironic,
ov_client,
task.node
)
self.assertTrue(ov_client.delete_server_profile.called)
self.assertIn(
'applied_server_profile_uri', task.node.driver_info
) )

24
ironic/tests/unit/drivers/modules/oneview/test_inspect.py
View File

@ -24,8 +24,6 @@ from ironic.tests.unit.db import utils as db_utils
from ironic.tests.unit.objects import utils as obj_utils from ironic.tests.unit.objects import utils as obj_utils
@mock.patch.object(
oneview_common, 'get_oneview_client', spec_set=True, autospec=True)
class AgentPXEOneViewInspectTestCase(db_base.DbTestCase): class AgentPXEOneViewInspectTestCase(db_base.DbTestCase):
def setUp(self): def setUp(self):
@ -39,15 +37,14 @@ class AgentPXEOneViewInspectTestCase(db_base.DbTestCase):
driver_info=db_utils.get_test_oneview_driver_info(), driver_info=db_utils.get_test_oneview_driver_info(),
) )
def test_get_properties(self, mock_get_ov_client): def test_get_properties(self):
expected = deploy_utils.get_properties() expected = deploy_utils.get_properties()
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task: shared=True) as task:
self.assertEqual(expected, task.driver.inspect.get_properties()) self.assertEqual(expected, task.driver.inspect.get_properties())
@mock.patch.object(oneview_common, 'verify_node_info', spec_set=True, @mock.patch.object(oneview_common, 'verify_node_info')
autospec=True) def test_validate(self, mock_verify_node_info):
def test_validate(self, mock_verify_node_info, mock_get_ov_client):
self.config(enabled=False, group='inspector') self.config(enabled=False, group='inspector')
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
@ -55,16 +52,13 @@ class AgentPXEOneViewInspectTestCase(db_base.DbTestCase):
mock_verify_node_info.assert_called_once_with(task.node) mock_verify_node_info.assert_called_once_with(task.node)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic, def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic):
mock_get_ov_client):
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
task.driver.inspect.inspect_hardware(task) task.driver.inspect.inspect_hardware(task)
self.assertTrue(mock_allocate_server_hardware_to_ironic.called) self.assertTrue(mock_allocate_server_hardware_to_ironic.called)
@mock.patch.object(
oneview_common, 'get_oneview_client', spec_set=True, autospec=True)
class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase): class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase):
def setUp(self): def setUp(self):
@ -78,15 +72,14 @@ class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase):
driver_info=db_utils.get_test_oneview_driver_info(), driver_info=db_utils.get_test_oneview_driver_info(),
) )
def test_get_properties(self, mock_get_ov_client): def test_get_properties(self):
expected = deploy_utils.get_properties() expected = deploy_utils.get_properties()
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task: shared=True) as task:
self.assertEqual(expected, task.driver.inspect.get_properties()) self.assertEqual(expected, task.driver.inspect.get_properties())
@mock.patch.object(oneview_common, 'verify_node_info', spec_set=True, @mock.patch.object(oneview_common, 'verify_node_info')
autospec=True) def test_validate(self, mock_verify_node_info):
def test_validate(self, mock_verify_node_info, mock_get_ov_client):
self.config(enabled=False, group='inspector') self.config(enabled=False, group='inspector')
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
@ -94,8 +87,7 @@ class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase):
mock_verify_node_info.assert_called_once_with(task.node) mock_verify_node_info.assert_called_once_with(task.node)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic, def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic):
mock_get_ov_client):
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: shared=False) as task:
task.driver.inspect.inspect_hardware(task) task.driver.inspect.inspect_hardware(task)

278
ironic/tests/unit/drivers/modules/oneview/test_management.py
View File

@ -22,6 +22,7 @@ from ironic.common import driver_factory
from ironic.common import exception from ironic.common import exception
from ironic.conductor import task_manager from ironic.conductor import task_manager
from ironic.drivers.modules.oneview import common from ironic.drivers.modules.oneview import common
from ironic.drivers.modules.oneview import deploy_utils
from ironic.drivers.modules.oneview import management from ironic.drivers.modules.oneview import management
from ironic.tests.unit.conductor import mgr_utils from ironic.tests.unit.conductor import mgr_utils
from ironic.tests.unit.db import base as db_base from ironic.tests.unit.db import base as db_base
@ -29,11 +30,12 @@ from ironic.tests.unit.db import utils as db_utils
from ironic.tests.unit.objects import utils as obj_utils from ironic.tests.unit.objects import utils as obj_utils
client_exception = importutils.try_import('hpOneView.exceptions')
oneview_exceptions = importutils.try_import('oneview_client.exceptions') oneview_exceptions = importutils.try_import('oneview_client.exceptions')
oneview_models = importutils.try_import('oneview_client.models') oneview_models = importutils.try_import('oneview_client.models')
@mock.patch.object(common, 'get_oneview_client', spect_set=True, autospec=True) @mock.patch.object(common, 'get_hponeview_client')
class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase): class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
def setUp(self): def setUp(self):
@ -52,26 +54,10 @@ class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
) )
self.info = common.get_oneview_info(self.node) self.info = common.get_oneview_info(self.node)
def test_set_boot_device(self, mock_get_ov_client): @mock.patch.object(common, 'get_ilorest_client')
oneview_client = mock_get_ov_client() def test_set_boot_device(
self, mock_get_ilo_client, mock_get_ov_client):
with task_manager.acquire(self.context, self.node.uuid) as task: ilo_client = mock_get_ilo_client()
driver_internal_info = task.node.driver_internal_info
next_boot_device = {'boot_device': boot_devices.PXE,
'persistent': False}
driver_internal_info['next_boot_device'] = next_boot_device
task.node.driver_internal_info = driver_internal_info
management.set_boot_device(task)
oneview_client.set_boot_device.assert_called_once_with(
self.info,
management.BOOT_DEVICE_MAPPING_TO_OV[boot_devices.PXE],
onetime=True
)
driver_internal_info = task.node.driver_internal_info
self.assertNotIn('next_boot_device', driver_internal_info)
def test_set_boot_device_persistent(self, mock_get_ov_client):
oneview_client = mock_get_ov_client()
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_internal_info = task.node.driver_internal_info driver_internal_info = task.node.driver_internal_info
@ -80,16 +66,49 @@ class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
driver_internal_info['next_boot_device'] = next_boot_device driver_internal_info['next_boot_device'] = next_boot_device
task.node.driver_internal_info = driver_internal_info task.node.driver_internal_info = driver_internal_info
management.set_boot_device(task) management.set_boot_device(task)
oneview_client.set_boot_device.assert_called_once_with( self.assertFalse(ilo_client.called)
self.info, patch = ilo_client.patch
management.BOOT_DEVICE_MAPPING_TO_OV[boot_devices.PXE], self.assertFalse(patch.called)
onetime=False driver_internal_info = task.node.driver_internal_info
) self.assertNotIn('next_boot_device', driver_internal_info)
@mock.patch.object(common, 'get_ilorest_client')
def test_set_boot_device_not_persistent(
self, mock_get_ilo_client, mock_get_ov_client):
ilo_client = mock_get_ilo_client()
client = mock_get_ov_client()
server_profile = {'boot': {'order':
list(management.BOOT_DEVICE_MAP_ONEVIEW_REV)}}
client.server_profiles.get.return_value = server_profile
boot_device_map_ilo = management.BOOT_DEVICE_MAP_ILO
boot_device = boot_device_map_ilo.get(boot_devices.PXE)
path = '/rest/v1/Systems/1'
body = {
"Boot": {
"BootSourceOverrideTarget": boot_device,
"BootSourceOverrideEnabled": "Once"
}
}
headers = {"Content-Type": "application/json"}
with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
profile_uri = driver_info.get('applied_server_profile_uri')
driver_internal_info = task.node.driver_internal_info
next_boot_device = {'boot_device': boot_devices.PXE,
'persistent': False}
driver_internal_info['next_boot_device'] = next_boot_device
task.node.driver_internal_info = driver_internal_info
management.set_boot_device(task)
update = client.server_profiles.update
update.assert_called_once_with(server_profile, profile_uri)
patch = ilo_client.patch
patch.assert_called_once_with(
path=path, body=body, headers=headers)
driver_internal_info = task.node.driver_internal_info driver_internal_info = task.node.driver_internal_info
self.assertNotIn('next_boot_device', driver_internal_info) self.assertNotIn('next_boot_device', driver_internal_info)
def test_set_boot_device_invalid_device(self, mock_get_ov_client): def test_set_boot_device_invalid_device(self, mock_get_ov_client):
oneview_client = mock_get_ov_client() client = mock_get_ov_client()
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_internal_info = task.node.driver_internal_info driver_internal_info = task.node.driver_internal_info
@ -100,30 +119,14 @@ class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
self.assertRaises(exception.InvalidParameterValue, self.assertRaises(exception.InvalidParameterValue,
management.set_boot_device, management.set_boot_device,
task) task)
self.assertFalse(oneview_client.set_boot_device.called) self.assertFalse(client.set_boot_device.called)
self.assertIn('next_boot_device', driver_internal_info) self.assertIn('next_boot_device', driver_internal_info)
def test_set_boot_device_fail_to_get_server_profile( def test_set_boot_device_fail_to_get_server_profile(
self, mock_get_ov_client): self, mock_get_ov_client):
oneview_client = mock_get_ov_client() client = mock_get_ov_client()
oneview_client.get_server_profile_from_hardware.side_effect = \ exc = client_exception.HPOneViewException()
oneview_exceptions.OneViewException() client.server_profiles.get.side_effect = exc
with task_manager.acquire(self.context, self.node.uuid) as task:
driver_internal_info = task.node.driver_internal_info
next_boot_device = {'boot_device': 'disk',
'persistent': True}
driver_internal_info['next_boot_device'] = next_boot_device
task.node.driver_internal_info = driver_internal_info
self.assertRaises(exception.OneViewError,
management.set_boot_device,
task)
self.assertFalse(oneview_client.set_boot_device.called)
self.assertIn('next_boot_device', driver_internal_info)
def test_set_boot_device_without_server_profile(self, mock_get_ov_client):
oneview_client = mock_get_ov_client()
oneview_client.get_server_profile_from_hardware.return_value = False
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_internal_info = task.node.driver_internal_info driver_internal_info = task.node.driver_internal_info
@ -131,20 +134,49 @@ class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
'persistent': True} 'persistent': True}
driver_internal_info['next_boot_device'] = next_boot_device driver_internal_info['next_boot_device'] = next_boot_device
task.node.driver_internal_info = driver_internal_info task.node.driver_internal_info = driver_internal_info
expected_msg = ( self.assertRaises(
'A Server Profile is not associated with node %s.' exception.OneViewError,
% self.node.uuid
)
self.assertRaisesRegex(
exception.OperationNotPermitted,
expected_msg,
management.set_boot_device, management.set_boot_device,
task task
) )
self.assertIn('next_boot_device', driver_internal_info) self.assertIn('next_boot_device', driver_internal_info)
@mock.patch.object(common, 'get_ilorest_client')
def test_set_onetime_boot_persistent(
self, mock_iloclient, mock_get_ov_client):
ilo_client = mock_iloclient()
driver_internal_info = self.node.driver_internal_info
next_boot_device = {'device': 'disk', 'persistent': False}
driver_internal_info['next_boot_device'] = next_boot_device
with task_manager.acquire(self.context, self.node.uuid) as task:
management.set_onetime_boot(task)
self.assertFalse(ilo_client.called)
self.assertFalse(ilo_client.patch.called)
@mock.patch.object(common, 'get_ilorest_client')
def test_set_onetime_boot_not_persistent(
self, mock_iloclient, mock_get_ov_client):
ilo_client = mock_iloclient()
boot_device = management.BOOT_DEVICE_MAP_ILO.get(boot_devices.DISK)
path = '/rest/v1/Systems/1'
body = {
"Boot": {
"BootSourceOverrideTarget": boot_device,
"BootSourceOverrideEnabled": "Once"
}
}
headers = {"Content-Type": "application/json"}
with task_manager.acquire(self.context, self.node.uuid) as task:
driver_internal_info = task.node.driver_internal_info
next_boot_device = {'boot_device': 'disk', 'persistent': False}
driver_internal_info['next_boot_device'] = next_boot_device
task.node.driver_internal_info = driver_internal_info
management.set_onetime_boot(task)
self.assertTrue(mock_iloclient.called)
ilo_client.patch.assert_called_with(
path=path, body=body, headers=headers)
@mock.patch.object(common, 'get_oneview_client', spect_set=True, autospec=True)
class OneViewManagementDriverTestCase(db_base.DbTestCase): class OneViewManagementDriverTestCase(db_base.DbTestCase):
def setUp(self): def setUp(self):
@ -152,6 +184,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
self.config(manager_url='https://1.2.3.4', group='oneview') self.config(manager_url='https://1.2.3.4', group='oneview')
self.config(username='user', group='oneview') self.config(username='user', group='oneview')
self.config(password='password', group='oneview') self.config(password='password', group='oneview')
self.config(tls_cacert_file='ca_file', group='oneview')
self.config(allow_insecure_connections=False, group='oneview')
mgr_utils.mock_the_extension_manager(driver="fake_oneview") mgr_utils.mock_the_extension_manager(driver="fake_oneview")
self.driver = driver_factory.get_driver("fake_oneview") self.driver = driver_factory.get_driver("fake_oneview")
@ -163,79 +197,44 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
) )
self.info = common.get_oneview_info(self.node) self.info = common.get_oneview_info(self.node)
@mock.patch.object(common, 'validate_oneview_resources_compatibility', @mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic')
spect_set=True, autospec=True) @mock.patch.object(common, 'validate_oneview_resources_compatibility')
def test_validate(self, mock_validate, mock_get_ov_client): def test_validate(self, mock_validate, mock_ironic_node):
oneview_client = mock_get_ov_client() mock_ironic_node.return_value = True
self.driver.management.oneview_client = oneview_client
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
oneview_client.get_server_hardware_by_uuid.return_value = (
fake_server_hardware
)
mock_get_ov_client.return_value = oneview_client
driver_info = self.node.driver_info
driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/'
self.node.driver_info = driver_info
self.node.save()
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
task.driver.management.validate(task) task.driver.management.validate(task)
self.assertTrue(mock_validate.called) self.assertTrue(mock_validate.called)
@mock.patch.object(common, 'validate_oneview_resources_compatibility', @mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic')
spect_set=True, autospec=True) def test_validate_for_node_not_in_use_by_ironic(self, mock_ironic_node):
def test_validate_for_node_not_in_use_by_ironic(self, mock_ironic_node.return_value = False
mock_validate,
mock_get_ov_client):
oneview_client = mock_get_ov_client()
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
oneview_client.get_server_hardware_by_uuid.return_value = (
fake_server_hardware
)
mock_get_ov_client.return_value = oneview_client
driver_info = self.node.driver_info
driver_info['applied_server_profile_uri'] = 'other/applied_sp_uri/'
self.node.driver_info = driver_info
self.node.save()
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue, self.assertRaises(exception.InvalidParameterValue,
task.driver.management.validate, task) task.driver.management.validate, task)
def test_validate_fail(self, mock_get_ov_client): def test_validate_fail(self):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(
uuid=uuidutils.generate_uuid(), self.context, uuid=uuidutils.generate_uuid(),
id=999, id=999, driver='fake_oneview'
driver='fake_oneview') )
with task_manager.acquire(self.context, node.uuid) as task: with task_manager.acquire(self.context, node.uuid) as task:
self.assertRaises(exception.MissingParameterValue, self.assertRaises(exception.MissingParameterValue,
task.driver.management.validate, task) task.driver.management.validate, task)
@mock.patch.object(common, 'validate_oneview_resources_compatibility', @mock.patch.object(common, 'validate_oneview_resources_compatibility')
spect_set=True, autospec=True) def test_validate_fail_exception(self, mock_validate):
def test_validate_fail_exception(self, mock_validate, mock_get_ov_client):
mock_validate.side_effect = exception.OneViewError('message') mock_validate.side_effect = exception.OneViewError('message')
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue, self.assertRaises(exception.InvalidParameterValue,
task.driver.management.validate, task.driver.management.validate,
task) task)
def test_get_properties(self, mock_get_ov_client): def test_get_properties(self):
expected = common.COMMON_PROPERTIES expected = common.COMMON_PROPERTIES
self.assertItemsEqual(expected, self.assertItemsEqual(expected,
self.driver.management.get_properties()) self.driver.management.get_properties())
def test_set_boot_device_persistent_true(self, mock_get_ov_client): def test_set_boot_device_persistent_true(self):
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
task.driver.management.set_boot_device( task.driver.management.set_boot_device(
task, boot_devices.PXE, True) task, boot_devices.PXE, True)
@ -246,7 +245,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
next_boot_device.get('boot_device'), boot_devices.PXE) next_boot_device.get('boot_device'), boot_devices.PXE)
self.assertTrue(next_boot_device.get('persistent')) self.assertTrue(next_boot_device.get('persistent'))
def test_set_boot_device_persistent_false(self, mock_get_ov_client): def test_set_boot_device_persistent_false(self):
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
task.driver.management.set_boot_device( task.driver.management.set_boot_device(
task, boot_devices.PXE, False) task, boot_devices.PXE, False)
@ -257,7 +256,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
next_boot_device.get('boot_device'), boot_devices.PXE) next_boot_device.get('boot_device'), boot_devices.PXE)
self.assertFalse(next_boot_device.get('persistent')) self.assertFalse(next_boot_device.get('persistent'))
def test_set_boot_device_invalid_device(self, mock_get_ov_client): def test_set_boot_device_invalid_device(self):
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue, self.assertRaises(exception.InvalidParameterValue,
task.driver.management.set_boot_device, task.driver.management.set_boot_device,
@ -265,38 +264,32 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
driver_internal_info = task.node.driver_internal_info driver_internal_info = task.node.driver_internal_info
self.assertNotIn('next_boot_device', driver_internal_info) self.assertNotIn('next_boot_device', driver_internal_info)
def test_get_supported_boot_devices(self, mock_get_ov_client): def test_get_supported_boot_devices(self):
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
expected = [boot_devices.PXE, boot_devices.DISK, expected = [
boot_devices.CDROM] boot_devices.PXE, boot_devices.DISK, boot_devices.CDROM
]
self.assertItemsEqual( self.assertItemsEqual(
expected, expected,
task.driver.management.get_supported_boot_devices(task), task.driver.management.get_supported_boot_devices(task),
) )
@mock.patch.object(common, 'get_hponeview_client')
def test_get_boot_device(self, mock_get_ov_client): def test_get_boot_device(self, mock_get_ov_client):
device_mapping = management.BOOT_DEVICE_MAPPING_TO_OV client = mock_get_ov_client()
oneview_client = mock_get_ov_client() device_mapping = management.BOOT_DEVICE_MAP_ONEVIEW.items()
self.driver.management.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
# For each known device on OneView, Ironic should return its # For each known device on OneView, Ironic should return its
# counterpart value # counterpart value
for device_ironic, device_ov in device_mapping.items(): for ironic_device, oneview_device in device_mapping:
oneview_client.get_boot_order.return_value = [device_ov] profile = {'boot': {'order': [oneview_device]}}
expected_response = { client.server_profiles.get.return_value = profile
'boot_device': device_ironic, expected = {'boot_device': ironic_device, 'persistent': True}
'persistent': True
}
response = self.driver.management.get_boot_device(task) response = self.driver.management.get_boot_device(task)
self.assertEqual(expected_response, response) self.assertEqual(expected, response)
oneview_client.get_boot_order.assert_called_with(self.info) self.assertTrue(client.server_profiles.get.called)
def test_get_boot_device_from_next_boot_device(
self, mock_get_ov_client):
oneview_client = mock_get_ov_client()
self.driver.management.oneview_client = oneview_client
def test_get_boot_device_from_next_boot_device(self):
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_internal_info = task.node.driver_internal_info driver_internal_info = task.node.driver_internal_info
next_boot_device = {'boot_device': boot_devices.DISK, next_boot_device = {'boot_device': boot_devices.DISK,
@ -309,26 +302,21 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
} }
response = self.driver.management.get_boot_device(task) response = self.driver.management.get_boot_device(task)
self.assertEqual(expected_response, response) self.assertEqual(expected_response, response)
self.assertFalse(oneview_client.get_boot_order.called)
@mock.patch.object(common, 'get_hponeview_client')
def test_get_boot_device_fail(self, mock_get_ov_client): def test_get_boot_device_fail(self, mock_get_ov_client):
oneview_client = mock_get_ov_client() client = mock_get_ov_client()
oneview_client.get_boot_order.side_effect = \ exc = client_exception.HPOneViewException()
oneview_exceptions.OneViewException() client.server_profiles.get.side_effect = exc
self.driver.management.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.OneViewError, self.assertRaises(
self.driver.management.get_boot_device, exception.OneViewError,
task) self.driver.management.get_boot_device,
oneview_client.get_boot_order.assert_called_with(self.info) task
)
def test_get_boot_device_unknown_device(self, mock_get_ov_client): self.assertTrue(client.server_profiles.get.called)
oneview_client = mock_get_ov_client()
oneview_client.get_boot_order.return_value = ["spam",
"bacon"]
self.driver.management.oneview_client = oneview_client
def test_get_boot_device_unknown_device(self):
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises( self.assertRaises(
exception.InvalidParameterValue, exception.InvalidParameterValue,
@ -336,7 +324,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
task task
) )
def test_get_sensors_data_not_implemented(self, mock_get_ov_client): def test_get_sensors_data_not_implemented(self):
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises( self.assertRaises(
NotImplementedError, NotImplementedError,

368
ironic/tests/unit/drivers/modules/oneview/test_power.py
View File

@ -24,20 +24,17 @@ from ironic.conductor import task_manager
from ironic.drivers.modules.oneview import common from ironic.drivers.modules.oneview import common
from ironic.drivers.modules.oneview import deploy_utils from ironic.drivers.modules.oneview import deploy_utils
from ironic.drivers.modules.oneview import management from ironic.drivers.modules.oneview import management
from ironic.drivers.modules.oneview import power
from ironic.tests.unit.conductor import mgr_utils from ironic.tests.unit.conductor import mgr_utils
from ironic.tests.unit.db import base as db_base from ironic.tests.unit.db import base as db_base
from ironic.tests.unit.db import utils as db_utils from ironic.tests.unit.db import utils as db_utils
from ironic.tests.unit.objects import utils as obj_utils from ironic.tests.unit.objects import utils as obj_utils
client_exception = importutils.try_import('hpOneView.exceptions')
oneview_models = importutils.try_import('oneview_client.models') oneview_models = importutils.try_import('oneview_client.models')
oneview_exceptions = importutils.try_import('oneview_client.exceptions') oneview_exceptions = importutils.try_import('oneview_client.exceptions')
POWER_ON = 'On'
POWER_OFF = 'Off'
ERROR = 'error'
@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True)
class OneViewPowerDriverTestCase(db_base.DbTestCase): class OneViewPowerDriverTestCase(db_base.DbTestCase):
def setUp(self): def setUp(self):
@ -45,6 +42,8 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
self.config(manager_url='https://1.2.3.4', group='oneview') self.config(manager_url='https://1.2.3.4', group='oneview')
self.config(username='user', group='oneview') self.config(username='user', group='oneview')
self.config(password='password', group='oneview') self.config(password='password', group='oneview')
self.config(tls_cacert_file='ca_file', group='oneview')
self.config(allow_insecure_connections=False, group='oneview')
mgr_utils.mock_the_extension_manager(driver='fake_oneview') mgr_utils.mock_the_extension_manager(driver='fake_oneview')
self.driver = driver_factory.get_driver('fake_oneview') self.driver = driver_factory.get_driver('fake_oneview')
@ -55,274 +54,197 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
driver_info=db_utils.get_test_oneview_driver_info(), driver_info=db_utils.get_test_oneview_driver_info(),
) )
self.info = common.get_oneview_info(self.node) self.info = common.get_oneview_info(self.node)
deploy_utils.is_node_in_use_by_oneview = mock.Mock(return_value=False)
@mock.patch.object(common, 'validate_oneview_resources_compatibility', @mock.patch.object(common, 'validate_oneview_resources_compatibility')
spect_set=True, autospec=True) def test_validate(self, mock_validate):
@mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview',
spect_set=True, autospec=True)
def test_power_interface_validate(self, mock_is_node_in_use_by_oneview,
mock_validate, mock_get_ov_client):
mock_is_node_in_use_by_oneview.return_value = False
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
task.driver.power.validate(task) task.driver.power.validate(task)
self.assertTrue(mock_validate.called) self.assertTrue(mock_validate.called)
def test_power_interface_validate_fail(self, mock_get_ov_client): def test_validate_missing_parameter(self):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(
uuid=uuidutils.generate_uuid(), self.context, uuid=uuidutils.generate_uuid(),
id=999, id=999, driver='fake_oneview')
driver='fake_oneview')
with task_manager.acquire(self.context, node.uuid) as task: with task_manager.acquire(self.context, node.uuid) as task:
self.assertRaises(exception.MissingParameterValue, self.assertRaises(
task.driver.power.validate, task) exception.MissingParameterValue,
task.driver.power.validate,
task)
@mock.patch.object(common, 'validate_oneview_resources_compatibility', @mock.patch.object(common, 'validate_oneview_resources_compatibility')
spect_set=True, autospec=True) def test_validate_exception(self, mock_validate):
def test_power_interface_validate_fail_exception(self, mock_validate,
mock_get_ov_client):
mock_validate.side_effect = exception.OneViewError('message') mock_validate.side_effect = exception.OneViewError('message')
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue, self.assertRaises(
task.driver.power.validate, exception.InvalidParameterValue,
task) task.driver.power.validate,
task)
@mock.patch.object(common, 'validate_oneview_resources_compatibility', def test_validate_node_in_use_by_oneview(self):
spect_set=True, autospec=True) deploy_utils.is_node_in_use_by_oneview.return_value = True
@mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview',
spect_set=True, autospec=True)
def test_power_validate_fail_node_used_by_oneview(
self, mock_is_node_in_use_by_oneview, mock_validate,
mock_get_ov_client):
mock_validate.return_value = True
mock_is_node_in_use_by_oneview.return_value = True
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue, self.assertRaises(
task.driver.power.validate, exception.InvalidParameterValue,
task) task.driver.power.validate,
task)
@mock.patch.object(common, 'validate_oneview_resources_compatibility', def test_get_properties(self):
spect_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview',
spect_set=True, autospec=True)
def test_validate_fail_node_in_use_by_oneview(
self, mock_is_node_in_use_by_oneview, mock_validate,
mock_get_ov_client):
mock_validate.return_value = True
mock_is_node_in_use_by_oneview.side_effect = (
exception.OneViewError('message'))
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue,
task.driver.power.validate,
task)
def test_power_interface_get_properties(self, mock_get_ov_client):
expected = common.COMMON_PROPERTIES expected = common.COMMON_PROPERTIES
self.assertItemsEqual(expected, self.driver.power.get_properties()) self.assertEqual(expected, self.driver.power.get_properties())
@mock.patch.object(common, 'get_hponeview_client')
def test_get_power_state(self, mock_get_ov_client): def test_get_power_state(self, mock_get_ov_client):
oneview_client = mock_get_ov_client() client = mock_get_ov_client()
oneview_client.get_node_power_state.return_value = POWER_ON server_hardware = {'powerState': 'On'}
self.driver.power.oneview_client = oneview_client client.server_hardware.get.return_value = server_hardware
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.driver.power.get_power_state(task) power_state = self.driver.power.get_power_state(task)
oneview_client.get_node_power_state.assert_called_once_with(self.info) self.assertEqual(states.POWER_ON, power_state)
@mock.patch.object(common, 'get_hponeview_client')
def test_get_power_state_fail(self, mock_get_ov_client): def test_get_power_state_fail(self, mock_get_ov_client):
oneview_client = mock_get_ov_client() client = mock_get_ov_client()
oneview_client.get_node_power_state.side_effect = \ exc = client_exception.HPOneViewException()
oneview_exceptions.OneViewException() client.server_hardware.get.side_effect = exc
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises( self.assertRaises(
exception.OneViewError, exception.OneViewError,
self.driver.power.get_power_state, self.driver.power.get_power_state,
task task)
)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device') @mock.patch.object(management, 'set_boot_device')
def test_set_power_on( def test_set_power_on(self, mock_set_boot_device, mock_get_ov_client):
self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client()
server_hardware = self.node.driver_info.get('server_hardware_uri')
sp_uri = '/any/server-profile'
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = sp_uri
oneview_client = mock_get_ov_client.return_value
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
oneview_client.power_on.return_value = POWER_ON
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
driver_info['applied_server_profile_uri'] = sp_uri
task.node.driver_info = driver_info
self.driver.power.set_power_state(task, states.POWER_ON) self.driver.power.set_power_state(task, states.POWER_ON)
mock_set_boot_device.assert_called_once_with(task) self.assertTrue(mock_set_boot_device.called)
self.info['applied_server_profile_uri'] = sp_uri update = client.server_hardware.update_power_state
oneview_client.power_on.assert_called_once_with(self.info) update.assert_called_once_with(power.POWER_ON, server_hardware)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device') @mock.patch.object(management, 'set_boot_device')
def test_set_power_off( def test_set_power_off(self, mock_set_boot_device, mock_get_ov_client):
self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client()
server_hardware = self.node.driver_info.get('server_hardware_uri')
sp_uri = '/any/server-profile'
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = sp_uri
oneview_client = mock_get_ov_client.return_value
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
oneview_client.power_off.return_value = POWER_OFF
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
driver_info['applied_server_profile_uri'] = sp_uri
task.node.driver_info = driver_info
self.driver.power.set_power_state(task, states.POWER_OFF) self.driver.power.set_power_state(task, states.POWER_OFF)
self.assertFalse(mock_set_boot_device.called) self.assertFalse(mock_set_boot_device.called)
self.info['applied_server_profile_uri'] = sp_uri update = client.server_hardware.update_power_state
oneview_client.power_off.assert_called_once_with(self.info) update.assert_called_once_with(power.POWER_OFF, server_hardware)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device') @mock.patch.object(management, 'set_boot_device')
def test_set_power_on_fail( def test_set_power_reboot(self, mock_set_boot_device, mock_get_ov_client):
self, mock_set_boot_device, mock_get_ov_client): client = mock_get_ov_client()
server_hardware = self.node.driver_info.get('server_hardware_uri')
sp_uri = '/any/server-profile'
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = sp_uri
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
exc = oneview_exceptions.OneViewException()
oneview_client.power_on.side_effect = exc
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info self.driver.power.set_power_state(task, states.REBOOT)
driver_info['applied_server_profile_uri'] = sp_uri calls = [mock.call(power.POWER_OFF, server_hardware),
task.node.driver_info = driver_info mock.call(power.POWER_ON, server_hardware)]
self.assertRaises(exception.OneViewError, update = client.server_hardware.update_power_state
self.driver.power.set_power_state, task, update.assert_has_calls(calls)
states.POWER_ON)
mock_set_boot_device.assert_called_once_with(task)
self.info['applied_server_profile_uri'] = sp_uri
oneview_client.power_on.assert_called_once_with(self.info)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device')
def test_set_power_on_fail(self, mock_set_boot_device, mock_get_ov_client):
client = mock_get_ov_client()
exc = client_exception.HPOneViewException()
client.server_hardware.update_power_state.side_effect = exc
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.OneViewError,
self.driver.power.set_power_state,
task,
states.POWER_ON)
mock_set_boot_device.assert_called_once_with(task)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device') @mock.patch.object(management, 'set_boot_device')
def test_set_power_off_fail( def test_set_power_off_fail(
self, mock_set_boot_device, mock_get_ov_client): self, mock_set_boot_device, mock_get_ov_client):
client = mock_get_ov_client()
sp_uri = '/any/server-profile' exc = client_exception.HPOneViewException()
oneview_client = mock_get_ov_client() client.server_hardware.update_power_state.side_effect = exc
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = sp_uri
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
exc = oneview_exceptions.OneViewException()
oneview_client.power_off.side_effect = exc
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info self.assertRaises(
driver_info['applied_server_profile_uri'] = sp_uri exception.OneViewError,
task.node.driver_info = driver_info self.driver.power.set_power_state,
self.assertRaises(exception.OneViewError, task,
self.driver.power.set_power_state, task, states.POWER_OFF)
states.POWER_OFF)
self.assertFalse(mock_set_boot_device.called)
self.info['applied_server_profile_uri'] = sp_uri
oneview_client.power_off.assert_called_once_with(self.info)
@mock.patch.object(management, 'set_boot_device')
def test_set_power_invalid_state(
self, mock_set_boot_device, mock_get_ov_client):
sp_uri = '/any/server-profile'
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = sp_uri
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
exc = oneview_exceptions.OneViewException()
oneview_client.power_off.side_effect = exc
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
driver_info['applied_server_profile_uri'] = sp_uri
task.node.driver_info = driver_info
self.assertRaises(exception.InvalidParameterValue,
self.driver.power.set_power_state, task,
'fake state')
self.assertFalse(mock_set_boot_device.called) self.assertFalse(mock_set_boot_device.called)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device') @mock.patch.object(management, 'set_boot_device')
def test_set_power_reboot( def test_reboot_fail_with_hardware_on(
self, mock_set_boot_device, mock_get_ov_client): self, mock_set_boot_device, mock_get_ov_client):
client = mock_get_ov_client()
sp_uri = '/any/server-profile' server_hardware = {'powerState': 'On'}
oneview_client = mock_get_ov_client() client.server_hardware.get.return_value = server_hardware
fake_sh = oneview_models.ServerHardware() exc = client_exception.HPOneViewException()
fake_sh.server_profile_uri = sp_uri client.server_hardware.update_power_state.side_effect = exc
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh self.driver.power.client = client
oneview_client.power_off.return_value = POWER_OFF
oneview_client.power_on.return_value = POWER_ON
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info self.assertRaises(
driver_info['applied_server_profile_uri'] = sp_uri exception.OneViewError,
task.node.driver_info = driver_info self.driver.power.reboot,
self.driver.power.set_power_state(task, states.REBOOT) task)
self.assertFalse(mock_set_boot_device.called)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device')
def test_reboot_fail_with_hardware_off(
self, mock_set_boot_device, mock_get_ov_client):
client = mock_get_ov_client()
server_hardware = {'powerState': 'Off'}
client.server_hardware.get.return_value = server_hardware
exc = client_exception.HPOneViewException()
client.server_hardware.update_power_state.side_effect = exc
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.OneViewError,
self.driver.power.reboot,
task)
mock_set_boot_device.assert_called_once_with(task) mock_set_boot_device.assert_called_once_with(task)
self.info['applied_server_profile_uri'] = sp_uri
oneview_client.power_off.assert_called_once_with(self.info)
oneview_client.power_off.assert_called_once_with(self.info)
oneview_client.power_on.assert_called_once_with(self.info)
@mock.patch.object(management, 'set_boot_device') @mock.patch.object(management, 'set_boot_device')
def test_reboot( def test_set_power_invalid_state(self, mock_set_boot_device):
self, mock_set_boot_device, mock_get_ov_client): with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
sp_uri = '/any/server-profile' exception.InvalidParameterValue,
oneview_client = mock_get_ov_client() self.driver.power.set_power_state,
fake_sh = oneview_models.ServerHardware() task,
fake_sh.server_profile_uri = sp_uri 'fake_state')
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh self.assertFalse(mock_set_boot_device.called)
oneview_client.power_off.return_value = POWER_OFF
oneview_client.power_on.return_value = POWER_ON @mock.patch.object(common, 'get_hponeview_client')
self.driver.power.oneview_client = oneview_client @mock.patch.object(management, 'set_boot_device')
def test_set_power_reboot_with_hardware_on(
self, mock_set_boot_device, mock_get_ov_client):
client = mock_get_ov_client()
server_hardware = {'powerState': 'On'}
client.server_hardware.get.return_value = server_hardware
server_hardware = self.node.driver_info.get('server_hardware_uri')
with task_manager.acquire(self.context, self.node.uuid) as task: with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
driver_info['applied_server_profile_uri'] = sp_uri
task.node.driver_info = driver_info
self.driver.power.reboot(task) self.driver.power.reboot(task)
calls = [mock.call(power.POWER_OFF, server_hardware),
mock.call(power.POWER_ON, server_hardware)]
update = client.server_hardware.update_power_state
update.assert_has_calls(calls)
mock_set_boot_device.assert_called_once_with(task) mock_set_boot_device.assert_called_once_with(task)
self.info['applied_server_profile_uri'] = sp_uri
oneview_client.power_off.assert_called_once_with(self.info)
oneview_client.power_on.assert_called_once_with(self.info)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device') @mock.patch.object(management, 'set_boot_device')
def test_reboot_fail( def test_set_power_reboot_with_hardware_off(
self, mock_set_boot_device, mock_get_ov_client): self, mock_set_boot_device, mock_get_ov_client):
client = mock_get_ov_client()
sp_uri = '/any/server-profile' server_hardware = {'powerState': 'Off'}
oneview_client = mock_get_ov_client() client.server_hardware.get.return_value = server_hardware
fake_sh = oneview_models.ServerHardware() server_hardware = self.node.driver_info.get('server_hardware_uri')
fake_sh.server_profile_uri = sp_uri with task_manager.acquire(self.context, self.node.uuid) as task:
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh self.driver.power.reboot(task)
exc = oneview_exceptions.OneViewException() update = client.server_hardware.update_power_state
oneview_client.power_off.side_effect = exc update.assert_called_once_with(power.POWER_ON, server_hardware)
self.driver.power.oneview_client = oneview_client mock_set_boot_device.assert_called_once_with(task)
with task_manager.acquire(self.context,
self.node.uuid) as task:
driver_info = task.node.driver_info
driver_info['applied_server_profile_uri'] = sp_uri
task.node.driver_info = driver_info
self.assertRaises(exception.OneViewError,
self.driver.power.reboot, task)
self.assertFalse(mock_set_boot_device.called)
self.info['applied_server_profile_uri'] = sp_uri
oneview_client.power_off.assert_called_once_with(self.info)
self.assertFalse(oneview_client.power_on.called)

4
ironic/tests/unit/drivers/third_party_driver_mock_specs.py
View File

@ -162,6 +162,10 @@ HPE_ONEVIEW_STATES_SPEC = (
'ONEVIEW_ERROR', 'ONEVIEW_ERROR',
) )
REDFISH_SPEC = (
'redfish',
)
SUSHY_CONSTANTS_SPEC = ( SUSHY_CONSTANTS_SPEC = (
'BOOT_SOURCE_TARGET_PXE', 'BOOT_SOURCE_TARGET_PXE',
'BOOT_SOURCE_TARGET_HDD', 'BOOT_SOURCE_TARGET_HDD',

8
ironic/tests/unit/drivers/third_party_driver_mocks.py
View File

@ -116,6 +116,14 @@ if 'ironic.drivers.oneview' in sys.modules:
six.moves.reload_module(sys.modules['ironic.drivers.modules.oneview']) six.moves.reload_module(sys.modules['ironic.drivers.modules.oneview'])
redfish = importutils.try_import('redfish')
if not redfish:
redfish = mock.MagicMock(spec_set=mock_specs.REDFISH_SPEC)
sys.modules['redfish'] = redfish
if 'ironic.drivers.oneview' in sys.modules:
six.moves.reload_module(sys.modules['ironic.drivers.modules.oneview'])
# attempt to load the external 'python-dracclient' library, which is required # attempt to load the external 'python-dracclient' library, which is required
# by the optional drivers.modules.drac module # by the optional drivers.modules.drac module
dracclient = importutils.try_import('dracclient') dracclient = importutils.try_import('dracclient')