openstack/ironic
Code Issues Proposed changes

Reusing oneview_client when possible

Browse Source 
A simple experiment showed that all calls to OneView were calling for
authentication. Reviewing the code, I perceived that every single call to
python-oneviewclient were creating a new instance of the client, which
authenticated again and generated a new session token on OneView.

This patch aims to reuse oneview_client instances when possible, avoiding
to create unecessary new sessions that can be reused.

Co-Authored-By: Hugo Nicodemos <nicodemos@lsd.ufcg.edu.br>
Co-Authored-By: Xavier <marcusrafael@lsd.ufcg.edu.br>

Change-Id: I0c26f0e033ca7f53f648c4ed29c6ef19f6f2e578
Closes-Bug: #1615070
This commit is contained in:
Thiago Paiva 2016-08-19 15:32:28 -03:00 committed by Hugo Nicodemos
parent 51c6d7a6ed
commit 83b2d563a9
13 changed files with 663 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -23,7 +23,6 @@ from ironic.common import states
from ironic.conf import CONF
from ironic.drivers import utils
LOG = logging.getLogger(__name__)
client = importutils.try_import('oneview_client.client')
@ -147,7 +146,7 @@ def get_oneview_info(node):
return oneview_info
def validate_oneview_resources_compatibility(task):
def validate_oneview_resources_compatibility(oneview_client, task):
"""Validates if the node configuration is consistent with OneView.
This method calls python-oneviewclient functions to validate if the node
@ -158,6 +157,7 @@ def validate_oneview_resources_compatibility(task):
represents when in pre-allocation model. If any validation fails,
python-oneviewclient will raise an appropriate OneViewException.
:param oneview_client: an instance of the OneView client
:param: task: a TaskManager instance containing the node to act on.
"""
@ -166,12 +166,9 @@ def validate_oneview_resources_compatibility(task):
oneview_info = get_oneview_info(task.node)
try:
oneview_client = get_oneview_client()
oneview_client.validate_node_server_profile_template(oneview_info)
oneview_client.validate_node_server_hardware_type(oneview_info)
oneview_client.validate_node_enclosure_group(oneview_info)
oneview_client.validate_node_server_hardware(
oneview_info,
task.node.properties.get('memory_mb'),
@ -244,10 +241,10 @@ def node_has_server_profile(func):
"""Checks if the node's Server Hardware has a Server Profile associated.
"""
def inner(*args, **kwargs):
task = args[1]
def inner(self, *args, **kwargs):
oneview_client = self.oneview_client
task = args[0]
oneview_info = get_oneview_info(task.node)
oneview_client = get_oneview_client()
try:
node_has_server_profile = (
oneview_client.get_server_profile_from_hardware(oneview_info)
@ -264,7 +261,7 @@ def node_has_server_profile(func):
_("A Server Profile is not associated with node %s.") %
task.node.uuid
)
return func(*args, **kwargs)
return func(self, *args, **kwargs)
return inner

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

@ -26,6 +26,7 @@ from ironic.common import exception
from ironic.common.i18n import _LE, _LI, _LW
from ironic.common import states
from ironic.conductor import utils as manager_utils
from ironic.conf import CONF
from ironic.drivers.modules import agent
from ironic.drivers.modules import agent_base_vendor
from ironic.drivers.modules import deploy_utils as ironic_deploy_utils
@ -35,11 +36,8 @@ from ironic.drivers.modules.oneview import deploy_utils
from ironic import objects
LOG = logging.getLogger(__name__)
METRICS = metrics_utils.get_metrics_logger(__name__)
CONF = common.CONF
@six.add_metaclass(abc.ABCMeta)
class OneViewPeriodicTasks(object):
@ -75,7 +73,9 @@ class OneViewPeriodicTasks(object):
node = objects.Node.get(context, node_uuid)
try:
oneview_using = deploy_utils.is_node_in_use_by_oneview(node)
oneview_using = deploy_utils.is_node_in_use_by_oneview(
self.oneview_client, node
)
except exception.OneViewError as e:
# NOTE(xavierr): Skip this node and process the
# remaining nodes. This node will be checked in
@ -136,7 +136,7 @@ class OneViewPeriodicTasks(object):
try:
oneview_using = deploy_utils.is_node_in_use_by_oneview(
node
self.oneview_client, node
)
except exception.OneViewError as e:
# NOTE(xavierr): Skip this node and process the
@ -227,6 +227,10 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks):
oneview_driver = common.ISCSI_PXE_ONEVIEW
def __init__(self):
super(OneViewIscsiDeploy, self).__init__()
self.oneview_client = common.get_oneview_client()
def get_properties(self):
deploy_utils.get_properties()
@ -234,7 +238,8 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks):
def validate(self, task):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(task)
common.validate_oneview_resources_compatibility(
self.oneview_client, task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)
super(OneViewIscsiDeploy, self).validate(task)
@ -242,26 +247,26 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks):
@METRICS.timer('OneViewIscsiDeploy.prepare')
def prepare(self, task):
if common.is_dynamic_allocation_enabled(task.node):
deploy_utils.prepare(task)
deploy_utils.prepare(self.oneview_client, task)
super(OneViewIscsiDeploy, self).prepare(task)
@METRICS.timer('OneViewIscsiDeploy.tear_down')
def tear_down(self, task):
if (common.is_dynamic_allocation_enabled(task.node) and
not CONF.conductor.automated_clean):
deploy_utils.tear_down(task)
deploy_utils.tear_down(self.oneview_client, task)
super(OneViewIscsiDeploy, self).tear_down(task)
@METRICS.timer('OneViewIscsiDeploy.prepare_cleaning')
def prepare_cleaning(self, task):
if common.is_dynamic_allocation_enabled(task.node):
deploy_utils.prepare_cleaning(task)
deploy_utils.prepare_cleaning(self.oneview_client, task)
return super(OneViewIscsiDeploy, self).prepare_cleaning(task)
@METRICS.timer('OneViewIscsiDeploy.tear_down_cleaning')
def tear_down_cleaning(self, task):
if common.is_dynamic_allocation_enabled(task.node):
deploy_utils.tear_down_cleaning(task)
deploy_utils.tear_down_cleaning(self.oneview_client, task)
return super(OneViewIscsiDeploy, self).tear_down_cleaning(task)
@ -357,6 +362,10 @@ class OneViewAgentDeploy(OneViewAgentDeployMixin, agent.AgentDeploy,
oneview_driver = common.AGENT_PXE_ONEVIEW
def __init__(self):
super(OneViewAgentDeploy, self).__init__()
self.oneview_client = common.get_oneview_client()
def get_properties(self):
deploy_utils.get_properties()
@ -364,7 +373,8 @@ class OneViewAgentDeploy(OneViewAgentDeployMixin, agent.AgentDeploy,
def validate(self, task):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(task)
common.validate_oneview_resources_compatibility(
self.oneview_client, task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)
super(OneViewAgentDeploy, self).validate(task)
@ -372,24 +382,24 @@ class OneViewAgentDeploy(OneViewAgentDeployMixin, agent.AgentDeploy,
@METRICS.timer('OneViewAgentDeploy.prepare')
def prepare(self, task):
if common.is_dynamic_allocation_enabled(task.node):
deploy_utils.prepare(task)
deploy_utils.prepare(self.oneview_client, task)
super(OneViewAgentDeploy, self).prepare(task)
@METRICS.timer('OneViewAgentDeploy.tear_down')
def tear_down(self, task):
if (common.is_dynamic_allocation_enabled(task.node) and
not CONF.conductor.automated_clean):
deploy_utils.tear_down(task)
deploy_utils.tear_down(self.oneview_client, task)
super(OneViewAgentDeploy, self).tear_down(task)
@METRICS.timer('OneViewAgentDeploy.prepare_cleaning')
def prepare_cleaning(self, task):
if common.is_dynamic_allocation_enabled(task.node):
deploy_utils.prepare_cleaning(task)
deploy_utils.prepare_cleaning(self.oneview_client, task)
return super(OneViewAgentDeploy, self).prepare_cleaning(task)
@METRICS.timer('OneViewAgentDeploy.tear_down_cleaning')
def tear_down_cleaning(self, task):
if common.is_dynamic_allocation_enabled(task.node):
deploy_utils.tear_down_cleaning(task)
deploy_utils.tear_down_cleaning(self.oneview_client, task)
return super(OneViewAgentDeploy, self).tear_down_cleaning(task)

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

@ -34,13 +34,14 @@ def get_properties():
return common.COMMON_PROPERTIES
def prepare(task):
def prepare(oneview_client, task):
"""Applies Server Profile and update the node when preparing.
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
'applied_server_profile_uri' field on properties/capabilities.
:param oneview_client: an instance of the OneView client
:param task: A TaskManager object
:raises InstanceDeployFailure: If the node doesn't have the needed OneView
informations, if Server Hardware is in use by an OneView user, or
@ -56,13 +57,14 @@ def prepare(task):
{"instance_name": instance_display_name,
"instance_uuid": instance_uuid}
)
allocate_server_hardware_to_ironic(task.node, server_profile_name)
allocate_server_hardware_to_ironic(oneview_client, task.node,
server_profile_name)
except exception.OneViewError as e:
raise exception.InstanceDeployFailure(node=task.node.uuid,
reason=e)
def tear_down(task):
def tear_down(oneview_client, task):
"""Remove Server profile and update the node when tear down.
This method is responsible for power a Server Hardware off, remove a Server
@ -70,24 +72,26 @@ def tear_down(task):
Profile from the node's 'applied_server_profile_uri' in
properties/capabilities.
:param oneview_client: an instance of the OneView client
:param task: A TaskManager object
:raises InstanceDeployFailure: If node has no uri of applied Server
Profile, or if some error occur while deleting Server Profile.
"""
try:
deallocate_server_hardware_from_ironic(task.node)
deallocate_server_hardware_from_ironic(oneview_client, task.node)
except exception.OneViewError as e:
raise exception.InstanceDeployFailure(node=task.node.uuid, reason=e)
def prepare_cleaning(task):
def prepare_cleaning(oneview_client, task):
"""Applies Server Profile and update the node when preparing cleaning.
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
'applied_server_profile_uri' field on properties/capabilities.
:param oneview_client: an instance of the OneView client
:param task: A TaskManager object
:raises NodeCleaningFailure: If the node doesn't have the needed OneView
informations, if Server Hardware is in use by an OneView user, or
@ -96,7 +100,8 @@ def prepare_cleaning(task):
"""
try:
server_profile_name = "Ironic Cleaning [%s]" % task.node.uuid
allocate_server_hardware_to_ironic(task.node, server_profile_name)
allocate_server_hardware_to_ironic(oneview_client, task.node,
server_profile_name)
except exception.OneViewError as e:
oneview_error = common.SERVER_HARDWARE_ALLOCATION_ERROR
driver_internal_info = task.node.driver_internal_info
@ -107,7 +112,7 @@ def prepare_cleaning(task):
reason=e)
def tear_down_cleaning(task):
def tear_down_cleaning(oneview_client, task):
"""Remove Server profile and update the node when tear down cleaning.
This method is responsible for power a Server Hardware off, remove a Server
@ -115,13 +120,14 @@ def tear_down_cleaning(task):
Profile from the node's 'applied_server_profile_uri' in
properties/capabilities.
:param oneview_client: an instance of the OneView client
:param task: A TaskManager object
:raises NodeCleaningFailure: If node has no uri of applied Server Profile,
or if some error occur while deleting Server Profile.
"""
try:
deallocate_server_hardware_from_ironic(task.node)
deallocate_server_hardware_from_ironic(oneview_client, task.node)
except exception.OneViewError as e:
raise exception.NodeCleaningFailure(node=task.node.uuid, reason=e)
@ -144,9 +150,10 @@ def _is_node_in_use(server_hardware, applied_sp_uri, by_oneview=False):
operation(applied_sp_uri, server_hardware.server_profile_uri))
def is_node_in_use_by_oneview(node):
def is_node_in_use_by_oneview(oneview_client, node):
"""Check if node is in use by OneView user.
:param oneview_client: an instance of the OneView client
:param node: an ironic node object
:returns: Boolean value. True if node is in use by OneView,
False otherwise.
@ -165,12 +172,14 @@ def is_node_in_use_by_oneview(node):
return _is_node_in_use(server_hardware, applied_sp_uri,
by_oneview=True)
return _check_applied_server_profile(node, predicate, positive, negative)
return _check_applied_server_profile(oneview_client, node,
predicate, positive, negative)
def is_node_in_use_by_ironic(node):
def is_node_in_use_by_ironic(oneview_client, node):
"""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
:returns: Boolean value. True if node is in use by ironic,
False otherwise.
@ -189,12 +198,15 @@ def is_node_in_use_by_ironic(node):
return _is_node_in_use(server_hardware, applied_sp_uri,
by_oneview=False)
return _check_applied_server_profile(node, predicate, positive, negative)
return _check_applied_server_profile(oneview_client, node,
predicate, positive, negative)
def _check_applied_server_profile(node, predicate, positive, negative):
def _check_applied_server_profile(oneview_client, node,
predicate, positive, negative):
"""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
:returns: Boolean value. True if node is in use by ironic,
False otherwise.
@ -205,8 +217,6 @@ def _check_applied_server_profile(node, predicate, positive, negative):
"""
oneview_info = common.get_oneview_info(node)
oneview_client = common.get_oneview_client()
sh_uuid = oneview_utils.get_uuid_from_uri(
oneview_info.get("server_hardware_uri")
)
@ -259,9 +269,11 @@ def _del_applied_server_profile_uri_field(node):
node.save()
def allocate_server_hardware_to_ironic(node, server_profile_name):
def allocate_server_hardware_to_ironic(oneview_client, node,
server_profile_name):
"""Allocate Server Hardware to ironic.
:param oneview_client: an instance of the OneView client
:param node: an ironic node object
:param server_profile_name: a formatted string with the Server Profile
name
@ -269,7 +281,7 @@ def allocate_server_hardware_to_ironic(node, server_profile_name):
Hardware to ironic
"""
node_in_use_by_oneview = is_node_in_use_by_oneview(node)
node_in_use_by_oneview = is_node_in_use_by_oneview(oneview_client, node)
if not node_in_use_by_oneview:
@ -283,7 +295,6 @@ def allocate_server_hardware_to_ironic(node, server_profile_name):
spt_uuid = oneview_utils.get_uuid_from_uri(
oneview_info.get("server_profile_template_uri")
)
oneview_client = common.get_oneview_client()
server_hardware = oneview_client.get_server_hardware_by_uuid(sh_uuid)
# Don't have Server Profile on OneView but has
@ -334,9 +345,10 @@ def allocate_server_hardware_to_ironic(node, server_profile_name):
raise exception.OneViewError(error=msg)
def deallocate_server_hardware_from_ironic(node):
def deallocate_server_hardware_from_ironic(oneview_client, node):
"""Deallocate Server Hardware from ironic.
:param oneview_client: an instance of the OneView client
:param node: an ironic node object
:raises OneViewError: if an error occurs while deallocating the Server
Hardware to ironic
@ -344,7 +356,6 @@ def deallocate_server_hardware_from_ironic(node):
"""
oneview_info = common.get_oneview_info(node)
oneview_client = common.get_oneview_client()
oneview_client.power_off(oneview_info)
applied_sp_uuid = oneview_utils.get_uuid_from_uri(

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

@ -39,8 +39,12 @@ oneview_utils = importutils.try_import('oneview_client.utils')
class OneViewInspect(inspector.Inspector):
"""Interface for in band inspection."""
def __init__(self):
super(OneViewInspect, self).__init__()
self.oneview_client = common.get_oneview_client()
def get_properties(self):
return common.COMMON_PROPERTIES
return deploy_utils.get_properties()
@METRICS.timer('OneViewInspect.validate')
def validate(self, task):
@ -60,7 +64,8 @@ class OneViewInspect(inspector.Inspector):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(task)
common.validate_oneview_resources_compatibility(
self.oneview_client, task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)
@ -68,7 +73,7 @@ class OneViewInspect(inspector.Inspector):
def inspect_hardware(self, task):
profile_name = 'Ironic Inspecting [%s]' % task.node.uuid
deploy_utils.allocate_server_hardware_to_ironic(
task.node, profile_name
self.oneview_client, task.node, profile_name
)
return super(OneViewInspect, self).inspect_hardware(task)
@ -96,8 +101,12 @@ class OneViewInspect(inspector.Inspector):
state_after = task.node.provision_state
# inspection finished
if (state_before == states.INSPECTING and
state_after in [states.MANAGEABLE, states.INSPECTFAIL]):
deploy_utils.deallocate_server_hardware_from_ironic(task.node)
if (
state_before == states.INSPECTING and state_after in [
states.MANAGEABLE, states.INSPECTFAIL
]
):
deploy_utils.deallocate_server_hardware_from_ironic(
self.oneview_client, task.node)
return result

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

@ -46,8 +46,12 @@ oneview_exceptions = importutils.try_import('oneview_client.exceptions')
class OneViewManagement(base.ManagementInterface):
def __init__(self):
super(OneViewManagement, self).__init__()
self.oneview_client = common.get_oneview_client()
def get_properties(self):
return common.COMMON_PROPERTIES
return deploy_utils.get_properties()
@METRICS.timer('OneViewManagement.validate')
def validate(self, task):
@ -69,9 +73,12 @@ class OneViewManagement(base.ManagementInterface):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(task)
common.validate_oneview_resources_compatibility(
self.oneview_client, task)
if not deploy_utils.is_node_in_use_by_ironic(task.node):
if not deploy_utils.is_node_in_use_by_ironic(
self.oneview_client, task.node
):
raise exception.InvalidParameterValue(
_("Node %s is not in use by ironic.") % task.node.uuid)
except exception.OneViewError as oneview_exc:
@ -117,9 +124,9 @@ class OneViewManagement(base.ManagementInterface):
LOG.debug("Setting boot device to %(device)s for node %(node)s",
{"device": device, "node": task.node.uuid})
try:
oneview_client = common.get_oneview_client()
device_to_oneview = BOOT_DEVICE_MAPPING_TO_OV.get(device)
oneview_client.set_boot_device(oneview_info, device_to_oneview)
self.oneview_client.set_boot_device(oneview_info,
device_to_oneview)
except oneview_exceptions.OneViewException as oneview_exc:
msg = (_(
"Error setting boot device on OneView. Error: %s")
@ -148,8 +155,7 @@ class OneViewManagement(base.ManagementInterface):
oneview_info = common.get_oneview_info(task.node)
try:
oneview_client = common.get_oneview_client()
boot_order = oneview_client.get_boot_order(oneview_info)
boot_order = self.oneview_client.get_boot_order(oneview_info)
except oneview_exceptions.OneViewException as oneview_exc:
msg = (_(
"Error getting boot device from OneView. Error: %s")

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

@ -24,6 +24,7 @@ from ironic.common import states
from ironic.conductor import task_manager
from ironic.drivers import base
from ironic.drivers.modules.oneview import common
from ironic.drivers.modules.oneview import deploy_utils
LOG = logging.getLogger(__name__)
@ -34,8 +35,12 @@ oneview_exceptions = importutils.try_import('oneview_client.exceptions')
class OneViewPower(base.PowerInterface):
def __init__(self):
super(OneViewPower, self).__init__()
self.oneview_client = common.get_oneview_client()
def get_properties(self):
return common.COMMON_PROPERTIES
return deploy_utils.get_properties()
@METRICS.timer('OneViewPower.validate')
def validate(self, task):
@ -57,7 +62,8 @@ class OneViewPower(base.PowerInterface):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(task)
common.validate_oneview_resources_compatibility(
self.oneview_client, task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)
@ -74,9 +80,10 @@ class OneViewPower(base.PowerInterface):
"""
oneview_info = common.get_oneview_info(task.node)
oneview_client = common.get_oneview_client()
try:
power_state = oneview_client.get_node_power_state(oneview_info)
power_state = self.oneview_client.get_node_power_state(
oneview_info
)
except oneview_exceptions.OneViewException as oneview_exc:
LOG.error(
_LE("Error getting power state for node %(node)s. Error:"
@ -101,20 +108,18 @@ class OneViewPower(base.PowerInterface):
"""
oneview_info = common.get_oneview_info(task.node)
oneview_client = common.get_oneview_client()
LOG.debug('Setting power state of node %(node_uuid)s to '
'%(power_state)s',
{'node_uuid': task.node.uuid, 'power_state': power_state})
try:
if power_state == states.POWER_ON:
oneview_client.power_on(oneview_info)
self.oneview_client.power_on(oneview_info)
elif power_state == states.POWER_OFF:
oneview_client.power_off(oneview_info)
self.oneview_client.power_off(oneview_info)
elif power_state == states.REBOOT:
oneview_client.power_off(oneview_info)
oneview_client.power_on(oneview_info)
self.oneview_client.power_off(oneview_info)
self.oneview_client.power_on(oneview_info)
else:
raise exception.InvalidParameterValue(
_("set_power_state called with invalid power state %s.")

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

@ -236,7 +236,8 @@ class OneViewCommonTestCase(db_base.DbTestCase):
):
oneview_client = mock_get_ov_client()
with task_manager.acquire(self.context, self.node.uuid) as task:
common.validate_oneview_resources_compatibility(task)
common.validate_oneview_resources_compatibility(oneview_client,
task)
self.assertTrue(
oneview_client.validate_node_server_hardware_type.called)
self.assertTrue(
@ -279,7 +280,8 @@ class OneViewCommonTestCase(db_base.DbTestCase):
driver_info['dynamic_allocation'] = True
task.node.driver_info = driver_info
common.validate_oneview_resources_compatibility(task)
common.validate_oneview_resources_compatibility(oneview_client,
task)
self.assertTrue(
oneview_client.validate_node_server_hardware_type.called)
self.assertTrue(

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

@ -25,7 +25,10 @@ from ironic.common import exception
from ironic.common import states
from ironic.conductor import task_manager
from ironic.conductor import utils as manager_utils
from ironic.conf import CONF
from ironic.drivers.modules import agent
from ironic.drivers.modules import agent_client
from ironic.drivers.modules import iscsi_deploy
from ironic.drivers.modules.oneview import common
from ironic.drivers.modules.oneview import deploy
from ironic.drivers.modules.oneview import deploy_utils
@ -40,6 +43,8 @@ from ironic.tests.unit.objects import utils as obj_utils
oneview_models = importutils.try_import('oneview_client.models')
METHODS = ['iter_nodes', 'update_node', 'do_provisioning_action']
PXE_DRV_INFO_DICT = db_utils.get_test_pxe_driver_info()
PXE_INST_INFO_DICT = db_utils.get_test_pxe_instance_info()
oneview_error = common.SERVER_HARDWARE_ALLOCATION_ERROR
maintenance_reason = common.NODE_IN_USE_BY_ONEVIEW
@ -88,10 +93,12 @@ def _setup_node_in_cleanfailed_state_without_oneview_error(node):
class OneViewDriverDeploy(deploy.OneViewPeriodicTasks):
oneview_driver = 'fake_oneview'
def __init__(self):
self.oneview_client = mock.MagicMock()
@mock.patch('ironic.objects.Node', spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview',
spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview')
class OneViewPeriodicTasks(db_base.DbTestCase):
def setUp(self):
@ -121,7 +128,9 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_taken_by_oneview(
self.manager, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.oneview_client, self.node
)
self.assertTrue(self.manager.update_node.called)
self.assertTrue(self.manager.do_provisioning_action.called)
self.assertTrue(self.node.maintenance)
@ -139,7 +148,9 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_taken_by_oneview(
self.manager, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.oneview_client, self.node
)
self.assertFalse(self.manager.update_node.called)
self.assertFalse(self.manager.do_provisioning_action.called)
self.assertFalse(self.node.maintenance)
@ -156,7 +167,9 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_taken_by_oneview(
self.manager, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.oneview_client, self.node
)
self.assertFalse(self.manager.update_node.called)
self.assertFalse(self.manager.do_provisioning_action.called)
self.assertFalse(self.node.maintenance)
@ -173,7 +186,9 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_freed_by_oneview(
self.manager, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.oneview_client, self.node
)
self.assertTrue(self.manager.update_node.called)
self.assertTrue(self.manager.do_provisioning_action.called)
self.assertFalse(self.node.maintenance)
@ -189,7 +204,9 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_freed_by_oneview(
self.manager, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.oneview_client, self.node
)
self.assertFalse(self.manager.update_node.called)
self.assertFalse(self.manager.do_provisioning_action.called)
self.assertTrue(self.node.maintenance)
@ -207,7 +224,9 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_freed_by_oneview(
self.manager, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.oneview_client, self.node
)
self.assertFalse(self.manager.update_node.called)
self.assertFalse(self.manager.do_provisioning_action.called)
self.assertTrue(self.node.maintenance)
@ -256,7 +275,7 @@ class TestOneViewAgentDeploy(db_base.DbTestCase):
post_deploy_get_power_state_retries=GET_POWER_STATE_RETRIES,
group='agent')
mgr_utils.mock_the_extension_manager(driver="agent_pxe_oneview")
self.driver = driver_factory.get_driver("agent_pxe_oneview")
self.node = obj_utils.create_test_node(
self.context, driver='agent_pxe_oneview',
properties=db_utils.get_test_oneview_properties(),
@ -301,18 +320,24 @@ class TestOneViewAgentDeploy(db_base.DbTestCase):
def test_reboot_and_finish_deploy_soft_poweroff_doesnt_complete(
self, power_off_mock, get_power_state_mock,
node_power_action_mock, mock_get_ov_client):
client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client.return_value
self.driver.management.oneview_client = oneview_client
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
client.get_server_hardware_by_uuid.return_value = fake_server_hardware
mock_get_ov_client.return_value = client
oneview_client.get_server_hardware_by_uuid.return_value = (
fake_server_hardware
)
mock_get_ov_client.return_value = oneview_client
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
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,
shared=False) as task:
get_power_state_mock.return_value = states.POWER_ON
@ -333,19 +358,27 @@ class TestOneViewAgentDeploy(db_base.DbTestCase):
def test_reboot_and_finish_deploy_soft_poweroff_fails(
self, power_off_mock, node_power_action_mock,
mock_get_ov_client):
client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client.return_value
self.driver.management.oneview_client = oneview_client
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
client.get_server_hardware_by_uuid.return_value = fake_server_hardware
mock_get_ov_client.return_value = client
oneview_client.get_server_hardware_by_uuid.return_value = (
fake_server_hardware
)
mock_get_ov_client.return_value = oneview_client
power_off_mock.side_effect = RuntimeError("boom")
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
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,
shared=False) as task:
task.driver.deploy.reboot_and_finish_deploy(task)
@ -366,18 +399,24 @@ class TestOneViewAgentDeploy(db_base.DbTestCase):
def test_reboot_and_finish_deploy_get_power_state_fails(
self, power_off_mock, get_power_state_mock,
node_power_action_mock, mock_get_ov_client):
client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client.return_value
self.driver.management.oneview_client = oneview_client
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
client.get_server_hardware_by_uuid.return_value = fake_server_hardware
mock_get_ov_client.return_value = client
oneview_client.get_server_hardware_by_uuid.return_value = (
fake_server_hardware
)
mock_get_ov_client.return_value = oneview_client
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
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,
shared=False) as task:
get_power_state_mock.side_effect = RuntimeError("boom")
@ -436,18 +475,24 @@ class TestOneViewAgentDeploy(db_base.DbTestCase):
node_power_action_mock, mock_get_ov_client):
check_deploy_mock.return_value = None
client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client.return_value
self.driver.management.oneview_client = oneview_client
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
client.get_server_hardware_by_uuid.return_value = fake_server_hardware
mock_get_ov_client.return_value = client
oneview_client.get_server_hardware_by_uuid.return_value = (
fake_server_hardware
)
mock_get_ov_client.return_value = oneview_client
self.node.provision_state = states.DEPLOYWAIT
self.node.target_provision_state = states.ACTIVE
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,
shared=False) as task:
get_power_state_mock.return_value = states.POWER_OFF
@ -478,20 +523,26 @@ class TestOneViewAgentDeploy(db_base.DbTestCase):
get_power_state_mock,
node_power_action_mock,
mock_get_ov_client):
client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client.return_value
self.driver.management.oneview_client = oneview_client
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
client.get_server_hardware_by_uuid.return_value = fake_server_hardware
mock_get_ov_client.return_value = client
oneview_client.get_server_hardware_by_uuid.return_value = (
fake_server_hardware
)
mock_get_ov_client.return_value = oneview_client
check_deploy_mock.return_value = None
self.node.provision_state = states.DEPLOYWAIT
self.node.target_provision_state = states.ACTIVE
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,
shared=False) as task:
get_power_state_mock.return_value = states.POWER_OFF
@ -508,3 +559,354 @@ class TestOneViewAgentDeploy(db_base.DbTestCase):
task, states.POWER_ON)
self.assertEqual(states.ACTIVE, task.node.provision_state)
self.assertEqual(states.NOSTATE, task.node.target_provision_state)
@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True)
class OneViewIscsiDeployTestCase(db_base.DbTestCase):
def setUp(self):
super(OneViewIscsiDeployTestCase, self).setUp()
self.config(manager_url='https://1.2.3.4', group='oneview')
self.config(username='user', group='oneview')
self.config(password='password', group='oneview')
mgr_utils.mock_the_extension_manager(driver='iscsi_pxe_oneview')
self.driver = driver_factory.get_driver('iscsi_pxe_oneview')
OV_DRV_INFO_DICT = db_utils.get_test_oneview_driver_info()
OV_DRV_INFO_DICT.update(PXE_DRV_INFO_DICT)
self.node = obj_utils.create_test_node(
self.context, driver='iscsi_pxe_oneview',
properties=db_utils.get_test_oneview_properties(),
driver_info=OV_DRV_INFO_DICT,
instance_info=PXE_INST_INFO_DICT,
)
self.port = obj_utils.create_test_port(self.context,
node_id=self.node.id)
self.info = common.get_oneview_info(self.node)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate',
spec_set=True, autospec=True)
def test_validate(self, iscsi_deploy_validate_mock, mock_get_ov_client):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.validate(task)
iscsi_deploy_validate_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare',
spec_set=True, autospec=True)
def test_prepare(self, iscsi_deploy_prepare_mock, mock_get_ov_client):
self.node.provision_state = states.DEPLOYING
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.prepare(task)
iscsi_deploy_prepare_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare',
spec_set=True, autospec=True)
def test_prepare_active_node(self, iscsi_deploy_prepare_mock,
mock_get_ov_client):
"""Ensure nodes in running states are not inadvertently changed"""
test_states = list(states.STABLE_STATES)
test_states.extend([states.CLEANING,
states.CLEANWAIT,
states.INSPECTING])
for state in test_states:
self.node.provision_state = state
self.node.save()
iscsi_deploy_prepare_mock.reset_mock()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.prepare(task)
iscsi_deploy_prepare_mock.assert_called_once_with(
mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare',
spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare_with_dynamic_allocation_enabled(
self, allocate_server_hardware_mock,
iscsi_deploy_prepare_mock, mock_get_ov_client
):
driver_info = self.node.driver_info
driver_info['dynamic_allocation'] = True
self.node.driver_info = driver_info
self.node.provision_state = states.DEPLOYING
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.prepare(task)
iscsi_deploy_prepare_mock.assert_called_once_with(mock.ANY, task)
self.assertTrue(allocate_server_hardware_mock.called)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'deploy',
spec_set=True, autospec=True)
def test_deploy(self, iscsi_deploy_mock, mock_get_ov_client):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.deploy(task)
iscsi_deploy_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down', spec_set=True,
autospec=True)
def test_tear_down(self, iscsi_tear_down_mock, mock_get_ov_client):
iscsi_tear_down_mock.return_value = states.DELETED
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.tear_down(task)
iscsi_tear_down_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down', spec_set=True,
autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_with_dynamic_allocation_enabled(
self, deallocate_server_hardware_mock,
iscsi_tear_down_mock, mock_get_ov_client
):
driver_info = self.node.driver_info
driver_info['dynamic_allocation'] = True
self.node.driver_info = driver_info
self.node.save()
CONF.conductor.automated_clean = False
iscsi_tear_down_mock.return_value = states.DELETED
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.tear_down(task)
iscsi_tear_down_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare_cleaning',
spec_set=True, autospec=True)
def test_prepare_cleaning(self, iscsi_prep_clean_mock, mock_get_ov_client):
iscsi_prep_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
ret = task.driver.deploy.prepare_cleaning(task)
self.assertEqual(states.CLEANWAIT, ret)
iscsi_prep_clean_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare_cleaning',
spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare_cleaning_with_dynamic_allocation_enabled(
self, allocate_server_hardware_mock,
iscsi_prep_clean_mock, mock_get_ov_client
):
driver_info = self.node.driver_info
driver_info['dynamic_allocation'] = True
self.node.driver_info = driver_info
self.node.save()
iscsi_prep_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
ret = task.driver.deploy.prepare_cleaning(task)
self.assertEqual(states.CLEANWAIT, ret)
iscsi_prep_clean_mock.assert_called_once_with(mock.ANY, task)
self.assertTrue(allocate_server_hardware_mock.called)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down_cleaning',
spec_set=True, autospec=True)
def test_tear_down_cleaning(self, iscsi_tear_down_clean_mock,
mock_get_ov_client):
iscsi_tear_down_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.tear_down_cleaning(task)
iscsi_tear_down_clean_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down_cleaning',
spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_cleaning_with_dynamic_allocation_enabled(
self, deallocate_server_hardware_mock,
iscsi_tear_down_clean_mock, mock_get_ov_client
):
driver_info = self.node.driver_info
driver_info['dynamic_allocation'] = True
self.node.driver_info = driver_info
self.node.save()
iscsi_tear_down_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.tear_down_cleaning(task)
iscsi_tear_down_clean_mock.assert_called_once_with(mock.ANY, task)
self.assertTrue(deallocate_server_hardware_mock.called)
@mock.patch.object(common, 'get_oneview_client', spec_set=True, autospec=True)
class OneViewAgentDeployTestCase(db_base.DbTestCase):
def setUp(self):
super(OneViewAgentDeployTestCase, self).setUp()
self.config(manager_url='https://1.2.3.4', group='oneview')
self.config(username='user', group='oneview')
self.config(password='password', group='oneview')
mgr_utils.mock_the_extension_manager(driver='agent_pxe_oneview')
self.driver = driver_factory.get_driver('agent_pxe_oneview')
OV_DRV_INFO_DICT = db_utils.get_test_oneview_driver_info()
OV_DRV_INFO_DICT.update(PXE_DRV_INFO_DICT)
self.node = obj_utils.create_test_node(
self.context, driver='agent_pxe_oneview',
properties=db_utils.get_test_oneview_properties(),
driver_info=OV_DRV_INFO_DICT,
instance_info=PXE_INST_INFO_DICT,
)
self.port = obj_utils.create_test_port(self.context,
node_id=self.node.id)
self.info = common.get_oneview_info(self.node)
@mock.patch.object(agent.AgentDeploy, 'validate',
spec_set=True, autospec=True)
def test_validate(self, agent_deploy_validate_mock, mock_get_ov_client):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.validate(task)
agent_deploy_validate_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'prepare',
spec_set=True, autospec=True)
def test_prepare(self, agent_deploy_prepare_mock, mock_get_ov_client):
self.node.provision_state = states.DEPLOYING
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.prepare(task)
agent_deploy_prepare_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'prepare',
spec_set=True, autospec=True)
def test_prepare_active_node(self, agent_deploy_prepare_mock,
mock_get_ov_client):
"""Ensure nodes in running states are not inadvertently changed"""
test_states = list(states.STABLE_STATES)
test_states.extend([states.CLEANING,
states.CLEANWAIT,
states.INSPECTING])
for state in test_states:
self.node.provision_state = state
self.node.save()
agent_deploy_prepare_mock.reset_mock()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.prepare(task)
agent_deploy_prepare_mock.assert_called_once_with(
mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'prepare',
spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare_with_dynamic_allocation_enabled(
self, allocate_server_hardware_mock,
agent_deploy_prepare_mock, mock_get_ov_client
):
driver_info = self.node.driver_info
driver_info['dynamic_allocation'] = True
self.node.driver_info = driver_info
self.node.provision_state = states.DEPLOYING
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.prepare(task)
agent_deploy_prepare_mock.assert_called_once_with(mock.ANY, task)
self.assertTrue(allocate_server_hardware_mock.called)
@mock.patch.object(agent.AgentDeploy, 'deploy',
spec_set=True, autospec=True)
def test_deploy(self, agent_deploy_mock, mock_get_ov_client):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.deploy(task)
agent_deploy_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'tear_down', spec_set=True,
autospec=True)
def test_tear_down(self, agent_tear_down_mock, mock_get_ov_client):
agent_tear_down_mock.return_value = states.DELETED
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.tear_down(task)
agent_tear_down_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'tear_down', spec_set=True,
autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_with_dynamic_allocation_enabled(
self, deallocate_server_hardware_mock,
agent_tear_down_mock, mock_get_ov_client
):
driver_info = self.node.driver_info
driver_info['dynamic_allocation'] = True
self.node.driver_info = driver_info
self.node.save()
CONF.conductor.automated_clean = False
agent_tear_down_mock.return_value = states.DELETED
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.tear_down(task)
agent_tear_down_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'prepare_cleaning',
spec_set=True, autospec=True)
def test_prepare_cleaning(self, agent_prep_clean_mock, mock_get_ov_client):
agent_prep_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
ret = task.driver.deploy.prepare_cleaning(task)
self.assertEqual(states.CLEANWAIT, ret)
agent_prep_clean_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'prepare_cleaning',
spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare_cleaning_with_dynamic_allocation_enabled(
self, allocate_server_hardware_mock,
agent_prep_clean_mock, mock_get_ov_client
):
driver_info = self.node.driver_info
driver_info['dynamic_allocation'] = True
self.node.driver_info = driver_info
self.node.save()
agent_prep_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
ret = task.driver.deploy.prepare_cleaning(task)
self.assertEqual(states.CLEANWAIT, ret)
agent_prep_clean_mock.assert_called_once_with(mock.ANY, task)
self.assertTrue(allocate_server_hardware_mock.called)
@mock.patch.object(agent.AgentDeploy, 'tear_down_cleaning',
spec_set=True, autospec=True)
def test_tear_down_cleaning(self, agent_tear_down_clean_mock,
mock_get_ov_client):
agent_tear_down_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.tear_down_cleaning(task)
agent_tear_down_clean_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'tear_down_cleaning',
spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_cleaning_with_dynamic_allocation_enabled(
self, deallocate_server_hardware_mock,
agent_tear_down_clean_mock, mock_get_ov_client
):
driver_info = self.node.driver_info
driver_info['dynamic_allocation'] = True
self.node.driver_info = driver_info
self.node.save()
agent_tear_down_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.tear_down_cleaning(task)
agent_tear_down_clean_mock.assert_called_once_with(mock.ANY, task)
self.assertTrue(deallocate_server_hardware_mock.called)

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

@ -58,6 +58,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""
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
@ -70,6 +71,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
self.assertRaises(
exception.InstanceDeployFailure,
deploy_utils.prepare,
oneview_client,
task
)
@ -80,22 +82,24 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""`prepare` behavior when the node is free from OneView standpoint.
"""
ov_client = mock_get_ov_client()
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = None
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task:
task.node.provision_state = states.DEPLOYING
deploy_utils.prepare(task)
self.assertTrue(ov_client.clone_template_and_apply.called)
self.assertTrue(ov_client.get_server_profile_from_hardware)
deploy_utils.prepare(oneview_client, task)
self.assertTrue(oneview_client.clone_template_and_apply.called)
self.assertTrue(oneview_client.get_server_profile_from_hardware)
# Tests for tear_down
def test_tear_down(self, mock_get_ov_client):
"""`tear_down` behavior when node already has Profile applied
"""
ov_client = mock_get_ov_client()
oneview_client = mock_get_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'] = \
@ -105,12 +109,12 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
self.assertTrue(
'applied_server_profile_uri' in task.node.driver_info
)
deploy_utils.tear_down(task)
deploy_utils.tear_down(oneview_client, task)
self.assertFalse(
'applied_server_profile_uri' in task.node.driver_info
)
self.assertTrue(
ov_client.delete_server_profile.called
oneview_client.delete_server_profile.called
)
# Tests for prepare_cleaning
@ -121,13 +125,14 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""`prepare_cleaning` behavior when node is free
"""
ov_client = mock_get_ov_client()
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = None
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task:
deploy_utils.prepare_cleaning(task)
self.assertTrue(ov_client.clone_template_and_apply.called)
deploy_utils.prepare_cleaning(oneview_client, task)
self.assertTrue(oneview_client.clone_template_and_apply.called)
@mock.patch.object(objects.Node, 'save')
def test_prepare_cleaning_when_node_has_sp_applied(
@ -136,18 +141,19 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""`prepare_cleaning` behavior when node already has Profile applied
"""
ov_client = mock_get_ov_client()
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = 'same/sp_applied'
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
driver_info['applied_server_profile_uri'] = 'same/sp_applied'
task.node.driver_info = driver_info
deploy_utils.prepare_cleaning(task)
self.assertFalse(ov_client.clone_template_and_apply.called)
deploy_utils.prepare_cleaning(oneview_client, task)
self.assertFalse(oneview_client.clone_template_and_apply.called)
def test_prepare_cleaning_node_is_in_use_by_oneview(
self, mock_get_ov_client
@ -156,6 +162,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""
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
@ -168,6 +175,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
self.assertRaises(
exception.NodeCleaningFailure,
deploy_utils.prepare_cleaning,
oneview_client,
task
)
@ -176,7 +184,8 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""Checks if Server Profile was deleted and its uri removed
"""
ov_client = mock_get_ov_client()
oneview_client = mock_get_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'] = \
@ -184,16 +193,18 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
task.node.driver_info = driver_info
self.assertIn('applied_server_profile_uri', task.node.driver_info)
deploy_utils.tear_down_cleaning(task)
deploy_utils.tear_down_cleaning(oneview_client, task)
self.assertNotIn('applied_server_profile_uri',
task.node.driver_info)
self.assertTrue(ov_client.delete_server_profile.called)
self.assertTrue(oneview_client.delete_server_profile.called)
# Tests for is_node_in_use_by_oneview
def test_is_node_in_use_by_oneview(self, mock_get_ov_client):
"""Node has a Server Profile applied by a third party user.
"""
oneview_client = mock_get_ov_client()
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = "/any/sp_uri"
@ -202,7 +213,8 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
driver_info['dynamic_allocation'] = True
task.node.driver_info = driver_info
self.assertTrue(
deploy_utils.is_node_in_use_by_oneview(task.node)
deploy_utils.is_node_in_use_by_oneview(oneview_client,
task.node)
)
def test_is_node_in_use_by_oneview_no_server_profile(
@ -211,15 +223,15 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""Node has no Server Profile.
"""
oneview_client = mock_get_ov_client()
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
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertFalse(
deploy_utils.is_node_in_use_by_oneview(task.node)
deploy_utils.is_node_in_use_by_oneview(oneview_client,
task.node)
)
def test_is_node_in_use_by_oneview_same_server_profile_applied(
@ -228,18 +240,19 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""Node's Server Profile uri is the same applied by ironic.
"""
oneview_client = mock_get_ov_client()
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
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
driver_info['applied_server_profile_uri'] = 'same/applied_sp_uri/'
task.node.driver_info = driver_info
self.assertFalse(
deploy_utils.is_node_in_use_by_oneview(task.node)
deploy_utils.is_node_in_use_by_oneview(oneview_client,
task.node)
)
# Tests for is_node_in_use_by_oneview
@ -259,7 +272,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
driver_info['applied_server_profile_uri'] = 'same/applied_sp_uri/'
task.node.driver_info = driver_info
self.assertTrue(
deploy_utils.is_node_in_use_by_ironic(task.node)
deploy_utils.is_node_in_use_by_ironic(ov_client, task.node)
)
def test_is_node_in_use_by_ironic_no_server_profile(
@ -276,7 +289,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertFalse(
deploy_utils.is_node_in_use_by_ironic(task.node)
deploy_utils.is_node_in_use_by_ironic(ov_client, task.node)
)
# Tests for _add_applied_server_profile_uri_field
@ -321,17 +334,17 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""Checks if a Server Profile was created and its uri is in driver_info.
"""
ov_client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = None
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
mock_get_ov_client.return_value = ov_client
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task:
deploy_utils.allocate_server_hardware_to_ironic(
task.node, 'serverProfileName'
oneview_client, task.node, 'serverProfileName'
)
self.assertTrue(ov_client.clone_template_and_apply.called)
self.assertTrue(oneview_client.clone_template_and_apply.called)
self.assertIn('applied_server_profile_uri', task.node.driver_info)
@mock.patch.object(objects.Node, 'save')
@ -347,11 +360,11 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
the conductor should remove the value and apply a new server profile to
use the node.
"""
ov_client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client()
fake_sh = oneview_models.ServerHardware()
fake_sh.server_profile_uri = None
ov_client.get_server_hardware_by_uuid.return_value = fake_sh
mock_get_ov_client.return_value = ov_client
oneview_client.get_server_hardware_by_uuid.return_value = fake_sh
with task_manager.acquire(self.context, self.node.uuid) as task:
driver_info = task.node.driver_info
@ -359,7 +372,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
task.node.driver_info = driver_info
deploy_utils.allocate_server_hardware_to_ironic(
task.node, 'serverProfileName'
oneview_client, task.node, 'serverProfileName'
)
self.assertTrue(mock_delete_applied_sp.called)
@ -368,19 +381,22 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
def test_deallocate_server_hardware_from_ironic(
self, mock_node_save, mock_get_ov_client
):
ov_client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client()
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
mock_get_ov_client.return_value = ov_client
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:
driver_info = task.node.driver_info
driver_info['applied_server_profile_uri'] = 'any/applied_sp_uri/'
task.node.driver_info = driver_info
deploy_utils.deallocate_server_hardware_from_ironic(task.node)
self.assertTrue(ov_client.delete_server_profile.called)
deploy_utils.deallocate_server_hardware_from_ironic(
oneview_client, task.node
)
self.assertTrue(oneview_client.delete_server_profile.called)
self.assertTrue(
'applied_server_profile_uri' not in task.node.driver_info
)

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

@ -25,6 +25,8 @@ from ironic.tests.unit.db import utils as db_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):
def setUp(self):
@ -37,15 +39,15 @@ class AgentPXEOneViewInspectTestCase(db_base.DbTestCase):
driver_info=db_utils.get_test_oneview_driver_info(),
)
def test_get_properties(self):
expected = oneview_common.COMMON_PROPERTIES
def test_get_properties(self, mock_get_ov_client):
expected = deploy_utils.get_properties()
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
self.assertEqual(expected, task.driver.inspect.get_properties())
@mock.patch.object(oneview_common, 'verify_node_info', spec_set=True,
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')
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
@ -53,13 +55,16 @@ class AgentPXEOneViewInspectTestCase(db_base.DbTestCase):
mock_verify_node_info.assert_called_once_with(task.node)
@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,
shared=False) as task:
task.driver.inspect.inspect_hardware(task)
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):
def setUp(self):
@ -72,15 +77,15 @@ class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase):
driver_info=db_utils.get_test_oneview_driver_info(),
)
def test_get_properties(self):
expected = oneview_common.COMMON_PROPERTIES
def test_get_properties(self, mock_get_ov_client):
expected = deploy_utils.get_properties()
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
self.assertEqual(expected, task.driver.inspect.get_properties())
@mock.patch.object(oneview_common, 'verify_node_info', spec_set=True,
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')
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
@ -88,7 +93,8 @@ class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase):
mock_verify_node_info.assert_called_once_with(task.node)
@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,
shared=False) as task:
task.driver.inspect.inspect_hardware(task)

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

@ -57,15 +57,23 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
@mock.patch.object(common, 'validate_oneview_resources_compatibility',
spect_set=True, autospec=True)
def test_validate(self, mock_validate, mock_get_ov_client):
client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client()
self.driver.management.oneview_client = oneview_client
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
client.get_server_hardware_by_uuid.return_value = fake_server_hardware
mock_get_ov_client.return_value = client
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:
task.driver.management.validate(task)
self.assertTrue(mock_validate.called)
@ -75,15 +83,22 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
def test_validate_for_node_not_in_use_by_ironic(self,
mock_validate,
mock_get_ov_client):
client = mock_get_ov_client.return_value
oneview_client = mock_get_ov_client()
fake_server_hardware = oneview_models.ServerHardware()
fake_server_hardware.server_profile_uri = 'any/applied_sp_uri/'
client.get_server_hardware_by_uuid.return_value = fake_server_hardware
mock_get_ov_client.return_value = client
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:
self.assertRaises(exception.InvalidParameterValue,
task.driver.management.validate, task)
@ -113,6 +128,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
def test_set_boot_device(self, mock_get_ov_client):
oneview_client = mock_get_ov_client()
self.driver.management.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.driver.management.set_boot_device(task, boot_devices.PXE)
oneview_client.set_boot_device.assert_called_once_with(
@ -122,6 +139,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
def test_set_boot_device_invalid_device(self, mock_get_ov_client):
oneview_client = mock_get_ov_client()
self.driver.management.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue,
self.driver.management.set_boot_device,
@ -131,9 +149,10 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
def test_set_boot_device_fail_to_get_server_profile(self,
mock_get_ov_client):
oneview_client = mock_get_ov_client()
oneview_client.get_server_profile_from_hardware.side_effect = \
oneview_exceptions.OneViewException()
self.driver.management.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.OneViewError,
self.driver.management.set_boot_device,
@ -143,6 +162,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
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
self.driver.management.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
expected_msg = (
'A Server Profile is not associated with node %s.'
@ -168,6 +189,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
def test_get_boot_device(self, mock_get_ov_client):
device_mapping = management.BOOT_DEVICE_MAPPING_TO_OV
oneview_client = mock_get_ov_client()
self.driver.management.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
# For each known device on OneView, Ironic should return its
@ -186,6 +208,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
oneview_client = mock_get_ov_client()
oneview_client.get_boot_order.side_effect = \
oneview_exceptions.OneViewException()
self.driver.management.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.OneViewError,
self.driver.management.get_boot_device,
@ -196,6 +220,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
oneview_client = mock_get_ov_client()
oneview_client.get_boot_order.return_value = ["spam",
"bacon"]
self.driver.management.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.InvalidParameterValue,

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

@ -89,6 +89,8 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
def test_get_power_state(self, mock_get_ov_client):
oneview_client = mock_get_ov_client()
oneview_client.get_node_power_state.return_value = POWER_ON
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.driver.power.get_power_state(task)
oneview_client.get_node_power_state.assert_called_once_with(self.info)
@ -97,6 +99,8 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
oneview_client = mock_get_ov_client()
oneview_client.get_node_power_state.side_effect = \
oneview_exceptions.OneViewException()
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.OneViewError,
@ -107,6 +111,8 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
def test_set_power_on(self, mock_get_ov_client):
oneview_client = mock_get_ov_client()
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:
self.driver.power.set_power_state(task, states.POWER_ON)
oneview_client.power_on.assert_called_once_with(self.info)
@ -114,6 +120,8 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
def test_set_power_off(self, mock_get_ov_client):
oneview_client = mock_get_ov_client()
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:
self.driver.power.set_power_state(task, states.POWER_OFF)
oneview_client.power_off.assert_called_once_with(self.info)
@ -122,6 +130,8 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
oneview_client = mock_get_ov_client()
oneview_client.power_on.side_effect = \
oneview_exceptions.OneViewException()
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.OneViewError,
self.driver.power.set_power_state, task,
@ -132,6 +142,8 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
oneview_client = mock_get_ov_client()
oneview_client.power_off.side_effect = \
oneview_exceptions.OneViewException()
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.OneViewError,
self.driver.power.set_power_state, task,
@ -148,6 +160,8 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
oneview_client = mock_get_ov_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:
self.driver.power.set_power_state(task, states.REBOOT)
oneview_client.power_off.assert_called_once_with(self.info)
@ -155,9 +169,9 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
def test_reboot(self, mock_get_ov_client):
oneview_client = mock_get_ov_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:
self.driver.power.reboot(task)
@ -169,6 +183,7 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
oneview_client = mock_get_ov_client()
oneview_client.power_off.side_effect = \
oneview_exceptions.OneViewException()
self.driver.power.oneview_client = oneview_client
with task_manager.acquire(self.context,
self.node.uuid) as task:

4
releasenotes/notes/reusing-oneview-client-6a3936fb8f113c10.yaml Normal file
View File

@ -0,0 +1,4 @@
---
fixes:
- Fixes a bug where OneView drivers creates a new instance of the
oneview_client for each request made.