openstack/ironic
Code Issues Proposed changes

Get a new OneView client when needed

Browse Source 
OneView has the time to expire an active session
defined through an idle time. This idle time is
24 hours by default. The previous client,
python-oneviewclient, used by the hardware type
OneView had a reauthentication mechanism that would
ensure the new session was created when the old
one expired. With the migration to python-hpOneView,
the mechanism to reauthenticate does not exist.

This solution creates a new instance of the client when
it is needed.

Change-Id: Id112e84f7d050d818e3cd9bf02cd9cfe4716ef32
Closes-Bug: 1693788
This commit is contained in:
Stenio Araujo 2017-10-09 14:48:47 -03:00 committed by Dmitry Tantsur
parent aa48dcd8ab
commit faf3f6b210
11 changed files with 131 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -95,15 +95,15 @@ def get_hponeview_client():
return hponeview_client.OneViewClient(config)
def get_ilorest_client(oneview_client, server_hardware):
def get_ilorest_client(server_hardware):
"""Generate an instance of the iLORest library client.
:param oneview_client: an instance of a python-hpOneView
:param: server_hardware: a server hardware uuid or uri
:param server_hardware: a server hardware uuid or uri
:returns: an instance of the iLORest client
:raises: InvalidParameterValue if mandatory information is missing on the
node or on invalid input.
"""
oneview_client = get_hponeview_client()
remote_console = oneview_client.server_hardware.get_remote_console_url(
server_hardware
)
@ -196,7 +196,7 @@ def get_oneview_info(node):
return oneview_info
def validate_oneview_resources_compatibility(oneview_client, task):
def validate_oneview_resources_compatibility(task):
"""Validate if the node configuration is consistent with OneView.
This method calls hpOneView functions to validate if the node
@ -205,11 +205,11 @@ def validate_oneview_resources_compatibility(oneview_client, task):
serverProfileTemplateUri, enclosureGroupUri and node ports. If any
validation fails, the driver will raise an appropriate OneViewError.
:param oneview_client: an instance of the OneView client
:param: task: a TaskManager instance containing the node to act on.
:raises: OneViewError if any validation fails.
"""
ports = task.ports
oneview_client = get_hponeview_client()
oneview_info = get_oneview_info(task.node)
_validate_node_server_profile_template(oneview_client, oneview_info)
@ -254,22 +254,22 @@ def node_has_server_profile(func):
"""
def inner(self, *args, **kwargs):
task = args[0]
has_server_profile(task, self.client)
has_server_profile(task)
return func(self, *args, **kwargs)
return inner
def has_server_profile(task, client):
def has_server_profile(task):
"""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.
:param client: an instance of the OneView client
:param task: a TaskManager instance containing the node to act on.
"""
oneview_client = get_hponeview_client()
try:
profile = task.node.driver_info.get('applied_server_profile_uri')
client.server_profiles.get(profile)
oneview_client.server_profiles.get(profile)
except client_exception.HPOneViewException as exc:
LOG.error(
"Failed to get server profile from OneView appliance for"
@ -279,10 +279,9 @@ def has_server_profile(task, client):
raise exception.OneViewError(error=exc)
def _get_server_hardware_mac_from_ilo(oneview_client, server_hardware):
def _get_server_hardware_mac_from_ilo(server_hardware):
"""Get the MAC of Server Hardware's iLO controller.
:param: oneview_client: an instance of the HPE OneView client
:param: server_hardware: a server hardware uuid or uri
:return: MAC of Server Hardware's iLO controller.
:raises: InvalidParameterValue if required iLO credentials are missing.
@ -290,7 +289,7 @@ def _get_server_hardware_mac_from_ilo(oneview_client, server_hardware):
if fails to get JSON object with the default path.
"""
try:
client = get_ilorest_client(oneview_client, server_hardware)
client = get_ilorest_client(server_hardware)
ilo_path = "/rest/v1/systems/1"
hardware = jsonutils.loads(client.get(ilo_path).text)
hardware_mac = hardware['HostCorrelation']['HostMACAddress'][0]
@ -497,8 +496,7 @@ def _validate_node_port_mac_server_hardware(oneview_client,
try:
mac = _get_server_hardware_mac(server_hardware)
except exception.OneViewError:
mac = _get_server_hardware_mac_from_ilo(
oneview_client, server_hardware)
mac = _get_server_hardware_mac_from_ilo(server_hardware)
incompatible_macs = []
for port in ports:

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

@ -66,9 +66,7 @@ class OneViewPeriodicTasks(object):
node = objects.Node.get(context, node_uuid)
try:
oneview_using = deploy_utils.is_node_in_use_by_oneview(
self.client, node
)
oneview_using = deploy_utils.is_node_in_use_by_oneview(node)
except exception.OneViewError as e:
# NOTE(xavierr): Skip this node and process the
# remaining nodes. This node will be checked in
@ -128,7 +126,7 @@ class OneViewPeriodicTasks(object):
try:
oneview_using = deploy_utils.is_node_in_use_by_oneview(
self.client, node
node
)
except exception.OneViewError as e:
# NOTE(xavierr): Skip this node and process the
@ -218,10 +216,6 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks):
oneview_driver = common.ISCSI_PXE_ONEVIEW
def __init__(self):
super(OneViewIscsiDeploy, self).__init__()
self.client = common.get_hponeview_client()
def get_properties(self):
return deploy_utils.get_properties()
@ -229,30 +223,30 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks):
def validate(self, task):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(self.client, task)
common.validate_oneview_resources_compatibility(task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)
super(OneViewIscsiDeploy, self).validate(task)
@METRICS.timer('OneViewIscsiDeploy.prepare')
def prepare(self, task):
deploy_utils.prepare(self.client, task)
deploy_utils.prepare(task)
super(OneViewIscsiDeploy, self).prepare(task)
@METRICS.timer('OneViewIscsiDeploy.tear_down')
def tear_down(self, task):
if not CONF.conductor.automated_clean:
deploy_utils.tear_down(self.client, task)
deploy_utils.tear_down(task)
return super(OneViewIscsiDeploy, self).tear_down(task)
@METRICS.timer('OneViewIscsiDeploy.prepare_cleaning')
def prepare_cleaning(self, task):
deploy_utils.prepare_cleaning(self.client, task)
deploy_utils.prepare_cleaning(task)
return super(OneViewIscsiDeploy, self).prepare_cleaning(task)
@METRICS.timer('OneViewIscsiDeploy.tear_down_cleaning')
def tear_down_cleaning(self, task):
deploy_utils.tear_down_cleaning(self.client, task)
deploy_utils.tear_down_cleaning(task)
super(OneViewIscsiDeploy, self).tear_down_cleaning(task)
@ -261,10 +255,6 @@ class OneViewAgentDeploy(agent.AgentDeploy, OneViewPeriodicTasks):
oneview_driver = common.AGENT_PXE_ONEVIEW
def __init__(self):
super(OneViewAgentDeploy, self).__init__()
self.client = common.get_hponeview_client()
def get_properties(self):
return deploy_utils.get_properties()
@ -272,28 +262,28 @@ class OneViewAgentDeploy(agent.AgentDeploy, OneViewPeriodicTasks):
def validate(self, task):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(self.client, task)
common.validate_oneview_resources_compatibility(task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)
super(OneViewAgentDeploy, self).validate(task)
@METRICS.timer('OneViewAgentDeploy.prepare')
def prepare(self, task):
deploy_utils.prepare(self.client, task)
deploy_utils.prepare(task)
super(OneViewAgentDeploy, self).prepare(task)
@METRICS.timer('OneViewAgentDeploy.tear_down')
def tear_down(self, task):
if not CONF.conductor.automated_clean:
deploy_utils.tear_down(self.client, task)
deploy_utils.tear_down(task)
return super(OneViewAgentDeploy, self).tear_down(task)
@METRICS.timer('OneViewAgentDeploy.prepare_cleaning')
def prepare_cleaning(self, task):
deploy_utils.prepare_cleaning(self.client, task)
deploy_utils.prepare_cleaning(task)
return super(OneViewAgentDeploy, self).prepare_cleaning(task)
@METRICS.timer('OneViewAgentDeploy.tear_down_cleaning')
def tear_down_cleaning(self, task):
deploy_utils.tear_down_cleaning(self.client, task)
deploy_utils.tear_down_cleaning(task)
super(OneViewAgentDeploy, self).tear_down_cleaning(task)

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

@ -32,14 +32,13 @@ def get_properties():
return common.COMMON_PROPERTIES
def prepare(client, task):
def prepare(task):
"""Apply 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 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
@ -55,14 +54,13 @@ def prepare(client, task):
{"instance_name": instance_display_name,
"instance_uuid": instance_uuid}
)
allocate_server_hardware_to_ironic(client, task.node,
server_profile_name)
allocate_server_hardware_to_ironic(task.node, server_profile_name)
except exception.OneViewError as e:
raise exception.InstanceDeployFailure(node=task.node.uuid,
reason=e)
def tear_down(client, task):
def tear_down(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,26 +68,24 @@ def tear_down(client, task):
Profile from the node's 'applied_server_profile_uri' in
properties/capabilities.
:param 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(client, task)
deallocate_server_hardware_from_ironic(task)
except exception.OneViewError as e:
raise exception.InstanceDeployFailure(node=task.node.uuid, reason=e)
def prepare_cleaning(client, task):
def prepare_cleaning(task):
"""Apply 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 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
@ -98,8 +94,7 @@ def prepare_cleaning(client, task):
"""
try:
server_profile_name = "Ironic Cleaning [%s]" % task.node.uuid
allocate_server_hardware_to_ironic(client, task.node,
server_profile_name)
allocate_server_hardware_to_ironic(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
@ -110,7 +105,7 @@ def prepare_cleaning(client, task):
reason=e)
def tear_down_cleaning(client, task):
def tear_down_cleaning(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
@ -118,14 +113,13 @@ def tear_down_cleaning(client, task):
Profile from the node's 'applied_server_profile_uri' in
properties/capabilities.
:param 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(client, task)
deallocate_server_hardware_from_ironic(task)
except exception.OneViewError as e:
raise exception.NodeCleaningFailure(node=task.node.uuid, reason=e)
@ -171,10 +165,9 @@ def _is_node_in_use(server_hardware, applied_sp_uri, by_oneview=False):
operation(applied_sp_uri, server_profile_uri))
def is_node_in_use_by_oneview(client, node):
def is_node_in_use_by_oneview(node):
"""Check if node is in use by OneView user.
:param 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.
@ -185,6 +178,7 @@ def is_node_in_use_by_oneview(client, node):
"""
positive = _("Node '%s' is in use by OneView.") % node.uuid
negative = _("Node '%s' is not in use by OneView.") % node.uuid
client = common.get_hponeview_client()
def predicate(server_hardware, applied_sp_uri):
# Check if Profile exists in Oneview and it is different of the one
@ -196,10 +190,9 @@ def is_node_in_use_by_oneview(client, node):
predicate, positive, negative)
def is_node_in_use_by_ironic(client, node):
def is_node_in_use_by_ironic(node):
"""Check if node is in use by ironic in OneView.
:param client: an instance of the HPE OneView client
:param node: an ironic node object
:returns: Boolean value. True if node is in use by ironic,
False otherwise.
@ -210,6 +203,7 @@ def is_node_in_use_by_ironic(client, node):
"""
positive = _("Node '%s' is in use by Ironic.") % node.uuid
negative = _("Node '%s' is not in use by Ironic.") % node.uuid
client = common.get_hponeview_client()
def predicate(server_hardware, applied_sp_uri):
# Check if Profile exists in Oneview and it is equals of the one
@ -280,11 +274,9 @@ def _del_applied_server_profile_uri_field(node):
node.save()
def allocate_server_hardware_to_ironic(client, node,
server_profile_name):
def allocate_server_hardware_to_ironic(node, server_profile_name):
"""Allocate Server Hardware to ironic.
:param 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
@ -292,7 +284,8 @@ def allocate_server_hardware_to_ironic(client, node,
Hardware to ironic
"""
node_in_use_by_oneview = is_node_in_use_by_oneview(client, node)
client = common.get_hponeview_client()
node_in_use_by_oneview = is_node_in_use_by_oneview(node)
if not node_in_use_by_oneview:
oneview_info = common.get_oneview_info(node)
@ -347,17 +340,17 @@ def allocate_server_hardware_to_ironic(client, node,
raise exception.OneViewError(error=msg)
def deallocate_server_hardware_from_ironic(client, task):
def deallocate_server_hardware_from_ironic(task):
"""Deallocate Server Hardware from ironic.
:param client: an instance of the OneView client
:param task: a TaskManager object
:raises OneViewError: if an error occurs while deallocating the Server
Hardware to ironic
"""
client = common.get_hponeview_client()
node = task.node
if is_node_in_use_by_ironic(client, node):
if is_node_in_use_by_ironic(node):
oneview_info = common.get_oneview_info(node)
server_profile_uri = oneview_info.get('applied_server_profile_uri')

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

@ -30,10 +30,6 @@ METRICS = metrics_utils.get_metrics_logger(__name__)
class OneViewInspect(inspector.Inspector):
"""Interface for in band inspection."""
def __init__(self):
super(OneViewInspect, self).__init__()
self.client = common.get_hponeview_client()
def get_properties(self):
return deploy_utils.get_properties()
@ -54,7 +50,7 @@ class OneViewInspect(inspector.Inspector):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(self.client, task)
common.validate_oneview_resources_compatibility(task)
except exception.OneViewError as oneview_exc:
raise exception.InvalidParameterValue(oneview_exc)
@ -62,7 +58,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(
self.client, task.node, profile_name
task.node, profile_name
)
return super(OneViewInspect, self).inspect_hardware(task)
@ -93,8 +89,6 @@ class OneViewInspect(inspector.Inspector):
if state_before == states.INSPECTING and state_after in [
states.MANAGEABLE, states.INSPECTFAIL
]:
deploy_utils.deallocate_server_hardware_from_ironic(
self.client, task.node
)
deploy_utils.deallocate_server_hardware_from_ironic(task.node)
return result

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

@ -68,9 +68,8 @@ def set_onetime_boot(task):
persistent = next_boot_device.get('persistent')
if not persistent:
client = common.get_hponeview_client()
server_hardware = task.node.driver_info.get('server_hardware_uri')
ilo_client = common.get_ilorest_client(client, server_hardware)
ilo_client = common.get_ilorest_client(server_hardware)
boot_device = BOOT_DEVICE_MAP_ILO.get(boot_device)
body = {
"Boot": {
@ -93,9 +92,8 @@ def _is_onetime_boot(task):
False otherwise.
"""
client = common.get_hponeview_client()
server_hardware = task.node.driver_info.get('server_hardware_uri')
ilo_client = common.get_ilorest_client(client, server_hardware)
ilo_client = common.get_ilorest_client(server_hardware)
response = ilo_client.get(path=ILO_SYSTEM_PATH,
headers=ILO_REQUEST_HEADERS)
boot = response.dict.get('Boot')
@ -114,7 +112,7 @@ def set_boot_device(task):
:raises: OneViewError if the communication with OneView fails
"""
client = common.get_hponeview_client()
common.has_server_profile(task, client)
common.has_server_profile(task)
driver_internal_info = task.node.driver_internal_info
next_boot_device = driver_internal_info.get('next_boot_device')
@ -163,10 +161,6 @@ def set_boot_device(task):
class OneViewManagement(base.ManagementInterface):
def __init__(self):
super(OneViewManagement, self).__init__()
self.client = common.get_hponeview_client()
def get_properties(self):
return deploy_utils.get_properties()
@ -187,12 +181,9 @@ class OneViewManagement(base.ManagementInterface):
resources in OneView
"""
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(self.client, task)
if not deploy_utils.is_node_in_use_by_ironic(
self.client, task.node
):
common.validate_oneview_resources_compatibility(task)
if not deploy_utils.is_node_in_use_by_ironic(task.node):
raise exception.InvalidParameterValue(
_("Node %s is not in use by ironic.") % task.node.uuid)
except exception.OneViewError as oneview_exc:
@ -264,6 +255,7 @@ class OneViewManagement(base.ManagementInterface):
"""
driver_internal_info = task.node.driver_internal_info
next_boot_device = driver_internal_info.get('next_boot_device')
client = common.get_hponeview_client()
if next_boot_device:
return next_boot_device
@ -272,7 +264,7 @@ class OneViewManagement(base.ManagementInterface):
server_profile = driver_info.get('applied_server_profile_uri')
try:
profile = self.client.server_profiles.get(server_profile)
profile = client.server_profiles.get(server_profile)
except client_exception.HPOneViewException as exc:
msg = _("Error getting boot device from OneView. Error: %s") % exc
raise exception.OneViewError(msg)

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

@ -56,10 +56,6 @@ SET_POWER_STATE_MAP = {
class OneViewPower(base.PowerInterface):
def __init__(self):
super(OneViewPower, self).__init__()
self.client = common.get_hponeview_client()
def get_properties(self):
return deploy_utils.get_properties()
@ -88,9 +84,9 @@ class OneViewPower(base.PowerInterface):
common.verify_node_info(task.node)
try:
common.validate_oneview_resources_compatibility(self.client, task)
common.validate_oneview_resources_compatibility(task)
if deploy_utils.is_node_in_use_by_oneview(self.client, task.node):
if deploy_utils.is_node_in_use_by_oneview(task.node):
raise exception.InvalidParameterValue(
_("Node %s is in use by OneView.") % task.node.uuid)
@ -108,8 +104,9 @@ class OneViewPower(base.PowerInterface):
resource
"""
server_hardware = task.node.driver_info.get('server_hardware_uri')
client = common.get_hponeview_client()
try:
server_hardware = self.client.server_hardware.get(server_hardware)
server_hardware = client.server_hardware.get(server_hardware)
except client_exception.HPOneViewException as exc:
LOG.error(
"Error getting power state for node %(node)s. Error:"
@ -135,7 +132,8 @@ class OneViewPower(base.PowerInterface):
:raises: PowerStateFailure if the power couldn't be set to power_state.
:raises: OneViewError if OneView fails setting the power state.
"""
if deploy_utils.is_node_in_use_by_oneview(self.client, task.node):
client = common.get_hponeview_client()
if deploy_utils.is_node_in_use_by_oneview(task.node):
raise exception.PowerStateFailure(_(
"Cannot set power state '%(power_state)s' to node %(node)s. "
"The node is in use by OneView.") %
@ -157,19 +155,19 @@ class OneViewPower(base.PowerInterface):
try:
if power_state == states.POWER_ON:
management.set_boot_device(task)
self.client.server_hardware.update_power_state(
client.server_hardware.update_power_state(
SET_POWER_STATE_MAP.get(power_state),
server_hardware, timeout=timeout)
elif power_state == states.REBOOT:
self.client.server_hardware.update_power_state(
client.server_hardware.update_power_state(
SET_POWER_STATE_MAP.get(states.POWER_OFF), server_hardware,
timeout=timeout)
management.set_boot_device(task)
self.client.server_hardware.update_power_state(
client.server_hardware.update_power_state(
SET_POWER_STATE_MAP.get(states.POWER_ON), server_hardware,
timeout=timeout)
else:
self.client.server_hardware.update_power_state(
client.server_hardware.update_power_state(
SET_POWER_STATE_MAP.get(power_state), server_hardware,
timeout=timeout)
except client_exception.HPOneViewException as exc:

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

@ -285,8 +285,7 @@ class OneViewCommonTestCase(db_base.DbTestCase):
with task_manager.acquire(self.context, self.node.uuid) as task:
task.ports = [fake_port]
common.validate_oneview_resources_compatibility(oneview_client,
task)
common.validate_oneview_resources_compatibility(task)
self.assertTrue(mock_sp_template.called)
self.assertTrue(mock_sh_type.called)
self.assertTrue(mock_enclosure.called)

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

@ -81,9 +81,6 @@ def _setup_node_in_cleanfailed_state_without_oneview_error(node):
class OneViewDriverDeploy(deploy.OneViewPeriodicTasks):
oneview_driver = 'fake_oneview'
def __init__(self):
self.client = mock.MagicMock()
@mock.patch('ironic.objects.Node', spec_set=True, autospec=True)
@mock.patch.object(deploy_utils, 'is_node_in_use_by_oneview')
@ -114,9 +111,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_taken_by_oneview(
self.os_primary, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.client, self.node
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.assertTrue(self.os_primary.update_node.called)
self.assertTrue(self.os_primary.do_provisioning_action.called)
self.assertTrue(self.node.maintenance)
@ -133,9 +128,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_taken_by_oneview(
self.os_primary, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.client, self.node
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.assertFalse(self.os_primary.update_node.called)
self.assertFalse(self.os_primary.do_provisioning_action.called)
self.assertFalse(self.node.maintenance)
@ -151,9 +144,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_taken_by_oneview(
self.os_primary, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.client, self.node
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.assertFalse(self.os_primary.update_node.called)
self.assertFalse(self.os_primary.do_provisioning_action.called)
self.assertFalse(self.node.maintenance)
@ -169,9 +160,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_freed_by_oneview(
self.os_primary, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.client, self.node
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.assertTrue(self.os_primary.update_node.called)
self.assertTrue(self.os_primary.do_provisioning_action.called)
self.assertFalse(self.node.maintenance)
@ -186,9 +175,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_freed_by_oneview(
self.os_primary, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.client, self.node
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.assertFalse(self.os_primary.update_node.called)
self.assertFalse(self.os_primary.do_provisioning_action.called)
self.assertTrue(self.node.maintenance)
@ -205,9 +192,7 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.deploy._periodic_check_nodes_freed_by_oneview(
self.os_primary, self.context
)
mock_is_node_in_use_by_oneview.assert_called_once_with(
self.deploy.client, self.node
)
mock_is_node_in_use_by_oneview.assert_called_once_with(self.node)
self.assertFalse(self.os_primary.update_node.called)
self.assertFalse(self.os_primary.do_provisioning_action.called)
self.assertTrue(self.node.maintenance)
@ -246,7 +231,6 @@ class OneViewPeriodicTasks(db_base.DbTestCase):
self.assertNotIn('oneview_error', self.node.driver_internal_info)
@mock.patch.object(common, 'get_hponeview_client')
class OneViewIscsiDeployTestCase(db_base.DbTestCase):
def setUp(self):
@ -270,7 +254,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
node_id=self.node.id)
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
self.assertEqual(expected, self.driver.deploy.get_properties())
@ -278,19 +262,17 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
spect_set=True, autospec=True)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate',
spec_set=True, autospec=True)
def test_validate(self, iscsi_deploy_validate_mock,
mock_validate_resources, mock_ov_client):
def test_validate(self, iscsi_deploy_validate_mock, mock_validate):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.validate(task)
self.assertTrue(mock_validate_resources.called)
self.assertTrue(mock_validate.called)
iscsi_deploy_validate_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare', autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare(
self, allocate_server_hardware_mock, iscsi_deploy_prepare_mock,
mock_get_ov_client):
self, allocate_server_hardware_mock, iscsi_deploy_prepare_mock):
self.node.provision_state = states.DEPLOYING
self.node.save()
with task_manager.acquire(self.context, self.node.uuid) as task:
@ -299,8 +281,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
self.assertTrue(allocate_server_hardware_mock.called)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare', autospec=True)
def test_prepare_active_node(
self, iscsi_deploy_prepare_mock, mock_get_ov_client):
def test_prepare_active_node(self, iscsi_deploy_prepare_mock):
"""Ensure nodes in running states are not inadvertently changed."""
test_states = list(states.STABLE_STATES)
test_states.extend([
@ -318,13 +299,13 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
mock.ANY, task)
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'deploy', 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) 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', 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
with task_manager.acquire(self.context, self.node.uuid) as task:
returned_state = task.driver.deploy.tear_down(task)
@ -334,8 +315,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
@mock.patch.object(iscsi_deploy.ISCSIDeploy, 'tear_down', autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_with_automated_clean_disabled(
self, deallocate_server_hardware_mock, iscsi_tear_down_mock,
mock_get_ov_client):
self, deallocate_server_hardware_mock, iscsi_tear_down_mock,):
CONF.conductor.automated_clean = False
iscsi_tear_down_mock.return_value = states.DELETED
@ -349,8 +329,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare_cleaning(
self, allocate_server_hardware_mock, 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
with task_manager.acquire(self.context, self.node.uuid) as task:
ret = task.driver.deploy.prepare_cleaning(task)
@ -362,8 +341,7 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_cleaning(
self, deallocate_server_hardware_mock, iscsi_tear_down_clean_mock,
mock_get_ov_client):
self, deallocate_server_hardware_mock, iscsi_tear_down_clean_mock):
iscsi_tear_down_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid) as task:
@ -372,7 +350,6 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase):
self.assertTrue(deallocate_server_hardware_mock.called)
@mock.patch.object(common, 'get_hponeview_client')
class OneViewAgentDeployTestCase(db_base.DbTestCase):
def setUp(self):
super(OneViewAgentDeployTestCase, self).setUp()
@ -395,7 +372,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
node_id=self.node.id)
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
self.assertEqual(expected, self.driver.deploy.get_properties())
@ -403,19 +380,17 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
spect_set=True, autospec=True)
@mock.patch.object(agent.AgentDeploy, 'validate',
spec_set=True, autospec=True)
def test_validate(self, agent_deploy_validate_mock,
mock_validate_resources, mock_ov_client):
def test_validate(self, agent_deploy_validate_mock, mock_validate):
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
task.driver.deploy.validate(task)
self.assertTrue(mock_validate_resources.called)
self.assertTrue(mock_validate.called)
agent_deploy_validate_mock.assert_called_once_with(mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'prepare', autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare(
self, allocate_server_hardware_mock, 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.save()
with task_manager.acquire(self.context, self.node.uuid) as task:
@ -424,8 +399,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
self.assertTrue(allocate_server_hardware_mock.called)
@mock.patch.object(agent.AgentDeploy, 'prepare', autospec=True)
def test_prepare_active_node(
self, agent_deploy_prepare_mock, mock_get_ov_client):
def test_prepare_active_node(self, agent_deploy_prepare_mock):
"""Ensure nodes in running states are not inadvertently changed."""
test_states = list(states.STABLE_STATES)
test_states.extend([states.CLEANING,
@ -441,7 +415,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
mock.ANY, task)
@mock.patch.object(agent.AgentDeploy, 'deploy', 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) as task:
task.driver.deploy.deploy(task)
agent_deploy_mock.assert_called_once_with(mock.ANY, task)
@ -450,8 +424,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_with_automated_clean_disabled(
self, deallocate_server_hardware_mock, agent_tear_down_mock,
mock_get_ov_client):
self, deallocate_server_hardware_mock, agent_tear_down_mock):
CONF.conductor.automated_clean = False
agent_tear_down_mock.return_value = states.DELETED
with task_manager.acquire(self.context, self.node.uuid) as task:
@ -463,8 +436,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
@mock.patch.object(agent.AgentDeploy, 'prepare_cleaning', autospec=True)
@mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic')
def test_prepare_cleaning(
self, allocate_server_hardware_mock,
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
with task_manager.acquire(self.context, self.node.uuid) as task:
ret = task.driver.deploy.prepare_cleaning(task)
@ -475,8 +447,7 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase):
@mock.patch.object(agent.AgentDeploy, 'tear_down_cleaning', autospec=True)
@mock.patch.object(deploy_utils, 'deallocate_server_hardware_from_ironic')
def test_tear_down_cleaning(
self, deallocate_server_hardware_mock,
agent_tear_down_clean_mock, mock_get_ov_client):
self, deallocate_server_hardware_mock, agent_tear_down_clean_mock):
agent_tear_down_clean_mock.return_value = states.CLEANWAIT
with task_manager.acquire(self.context, self.node.uuid) as task:
task.driver.deploy.tear_down_cleaning(task)

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

@ -55,14 +55,12 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
# Tests for prepare
def test_prepare_node_is_in_use_by_oneview(self, mock_oneview_client):
"""`prepare` behavior when the node has a Profile on OneView."""
client = mock_oneview_client()
deploy_utils.is_node_in_use_by_oneview.return_value = True
with task_manager.acquire(self.context, self.node.uuid) as task:
task.node.provision_state = states.DEPLOYING
self.assertRaises(
exception.InstanceDeployFailure,
deploy_utils.prepare,
client,
task
)
@ -72,7 +70,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
"""`prepare` behavior when the node is free from OneView standpoint."""
with task_manager.acquire(self.context, self.node.uuid) as task:
task.node.provision_state = states.DEPLOYING
deploy_utils.prepare(mock_oneview_client(), task)
deploy_utils.prepare(task)
self.assertTrue(mock_save.called)
# Tests for tear_down
@ -86,7 +84,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
self.assertIn(
'applied_server_profile_uri', task.node.driver_info
)
deploy_utils.tear_down(client, task)
deploy_utils.tear_down(task)
self.assertNotIn(
'applied_server_profile_uri', task.node.driver_info
)
@ -101,7 +99,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
self.assertFalse(
'applied_server_profile_uri' in task.node.driver_info
)
deploy_utils.prepare_cleaning(mock_oneview_client(), task)
deploy_utils.prepare_cleaning(task)
self.assertTrue(
'applied_server_profile_uri' in task.node.driver_info
)
@ -118,7 +116,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
task.node.driver_info['applied_server_profile_uri'] = (
'same/sp_applied'
)
deploy_utils.prepare_cleaning(client, task)
deploy_utils.prepare_cleaning(task)
self.assertFalse(mock_node_save.called)
def test_prepare_cleaning_node_is_in_use_by_oneview(
@ -130,7 +128,6 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
self.assertRaises(
exception.NodeCleaningFailure,
deploy_utils.prepare_cleaning,
mock_oneview_client(),
task
)
@ -145,7 +142,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
self.assertTrue(
'applied_server_profile_uri' in task.node.driver_info
)
deploy_utils.tear_down_cleaning(client, task)
deploy_utils.tear_down_cleaning(task)
self.assertFalse(
'applied_server_profile_uri' in task.node.driver_info
)
@ -296,7 +293,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
with task_manager.acquire(self.context, self.node.uuid) as task:
deploy_utils.allocate_server_hardware_to_ironic(
client, task.node, 'serverProfileName'
task.node, 'serverProfileName'
)
self.assertTrue(mock_node_save.called)
self.assertIn('applied_server_profile_uri', task.node.driver_info)
@ -320,7 +317,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
'any/applied_sp_uri/'
)
deploy_utils.allocate_server_hardware_to_ironic(
client, task.node, 'serverProfileName'
task.node, 'serverProfileName'
)
self.assertTrue(mock_node_save.called)
@ -335,9 +332,7 @@ class OneViewDeployUtilsTestCase(db_base.DbTestCase):
task.node.driver_info['applied_server_profile_uri'] = (
'any/applied_sp_uri/'
)
deploy_utils.deallocate_server_hardware_from_ironic(
client, task
)
deploy_utils.deallocate_server_hardware_from_ironic(task)
self.assertTrue(client.server_profiles.delete.called)
self.assertNotIn(
'applied_server_profile_uri', task.node.driver_info

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

@ -214,7 +214,6 @@ class OneViewManagementDriverFunctionsTestCase(db_base.DbTestCase):
)
@mock.patch.object(common, 'get_hponeview_client')
class OneViewManagementDriverTestCase(db_base.DbTestCase):
def setUp(self):
@ -237,7 +236,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
spect_set=True, autospec=True)
@mock.patch.object(common, 'validate_oneview_resources_compatibility',
spect_set=True, autospec=True)
def test_validate(self, mock_validate, mock_ironic_node, mock_ov_client):
def test_validate(self, mock_validate, mock_ironic_node):
mock_ironic_node.return_value = True
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
@ -246,15 +245,13 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
@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, mock_get_ov_client
):
def test_validate_for_node_not_in_use_by_ironic(self, mock_ironic_node):
mock_ironic_node.return_value = False
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue,
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, uuid=uuidutils.generate_uuid(),
id=999, driver='fake_oneview'
@ -264,19 +261,19 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
task.driver.management.validate, task)
@mock.patch.object(common, 'validate_oneview_resources_compatibility')
def test_validate_fail_exception(self, mock_validate, mock_get_ov_client):
def test_validate_fail_exception(self, mock_validate):
mock_validate.side_effect = exception.OneViewError('message')
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(exception.InvalidParameterValue,
task.driver.management.validate,
task)
def test_get_properties(self, mock_get_ov_client):
def test_get_properties(self):
expected = common.COMMON_PROPERTIES
self.assertItemsEqual(expected,
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:
task.driver.management.set_boot_device(
task, boot_devices.PXE, True)
@ -287,7 +284,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
next_boot_device.get('boot_device'), boot_devices.PXE)
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:
task.driver.management.set_boot_device(
task, boot_devices.PXE, False)
@ -298,7 +295,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
next_boot_device.get('boot_device'), boot_devices.PXE)
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:
self.assertRaises(exception.InvalidParameterValue,
task.driver.management.set_boot_device,
@ -306,7 +303,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
driver_internal_info = task.node.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:
expected = [
boot_devices.PXE, boot_devices.DISK, boot_devices.CDROM
@ -316,10 +313,10 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
task.driver.management.get_supported_boot_devices(task),
)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(common, 'get_ilorest_client')
def test_get_boot_device(
self, mock_ilo_client, mock_get_ov_client):
client = mock_get_ov_client()
def test_get_boot_device(self, mock_ilo_client, mock_ov_client):
client = mock_ov_client()
ilo_client = mock_ilo_client()
self.driver.management.client = client
device_mapping = management.BOOT_DEVICE_MAP_ONEVIEW.items()
@ -337,11 +334,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
self.assertTrue(ilo_client.get.called)
@mock.patch.object(common, 'get_ilorest_client')
def test_get_boot_device_from_next_boot_device(
self, mock_ilo_client, mock_get_ov_client):
client = mock_get_ov_client()
def test_get_boot_device_from_next_boot_device(self, mock_ilo_client):
ilo_client = mock_ilo_client()
self.driver.management.client = client
with task_manager.acquire(self.context, self.node.uuid) as task:
driver_internal_info = task.node.driver_internal_info
@ -355,13 +349,12 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
}
response = self.driver.management.get_boot_device(task)
self.assertEqual(expected_response, response)
self.assertFalse(client.get_boot_order.called)
self.assertFalse(ilo_client.get.called)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(common, 'get_ilorest_client')
def test_get_boot_device_fail(
self, mock_ilo_client, mock_get_ov_client):
client = mock_get_ov_client()
def test_get_boot_device_fail(self, mock_ilo_client, mock_ov_client):
client = mock_ov_client()
ilo_client = mock_ilo_client()
self.driver.management.client = client
exc = client_exception.HPOneViewException()
@ -376,14 +369,8 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
self.assertFalse(ilo_client.get.called)
@mock.patch.object(common, 'get_ilorest_client')
def test_get_boot_device_unknown_device(
self, mock_ilo_client, mock_get_ov_client):
client = mock_get_ov_client()
def test_get_boot_device_unknown_device(self, mock_ilo_client):
ilo_client = mock_ilo_client()
order = ['Eggs', 'Bacon']
profile = {'boot': {'order': order}}
client.server_profiles.get.return_value = profile
self.driver.management.client = client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.InvalidParameterValue,
@ -392,7 +379,7 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase):
)
self.assertFalse(ilo_client.get.called)
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:
self.assertRaises(
NotImplementedError,

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

@ -33,7 +33,6 @@ from ironic.tests.unit.objects import utils as obj_utils
client_exception = importutils.try_import('hpOneView.exceptions')
@mock.patch.object(common, 'get_hponeview_client')
class OneViewPowerDriverTestCase(db_base.DbTestCase):
def setUp(self):
@ -54,12 +53,12 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
deploy_utils.is_node_in_use_by_oneview = mock.Mock(return_value=False)
@mock.patch.object(common, 'validate_oneview_resources_compatibility')
def test_validate(self, mock_validate, mock_get_ov_client):
def test_validate(self, mock_validate):
with task_manager.acquire(self.context, self.node.uuid) as task:
task.driver.power.validate(task)
self.assertTrue(mock_validate.called)
def test_validate_missing_parameter(self, mock_get_ov_client):
def test_validate_missing_parameter(self):
node = obj_utils.create_test_node(
self.context, uuid=uuidutils.generate_uuid(),
id=999, driver='fake_oneview')
@ -70,7 +69,7 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
task)
@mock.patch.object(common, 'validate_oneview_resources_compatibility')
def test_validate_exception(self, mock_validate, mock_get_ov_client):
def test_validate_exception(self, mock_validate):
mock_validate.side_effect = exception.OneViewError('message')
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
@ -78,7 +77,7 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
task.driver.power.validate,
task)
def test_validate_node_in_use_by_oneview(self, mock_get_ov_client):
def test_validate_node_in_use_by_oneview(self):
deploy_utils.is_node_in_use_by_oneview.return_value = True
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
@ -86,34 +85,34 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
task.driver.power.validate,
task)
def test_get_properties(self, mock_get_ov_client):
def test_get_properties(self):
expected = common.COMMON_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):
client = mock_get_ov_client()
server_hardware = {'powerState': 'On'}
client.server_hardware.get.return_value = server_hardware
self.driver.power.client = client
with task_manager.acquire(self.context, self.node.uuid) as task:
power_state = self.driver.power.get_power_state(task)
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):
client = mock_get_ov_client()
exc = client_exception.HPOneViewException()
client.server_hardware.get.side_effect = exc
self.driver.power.client = client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.OneViewError,
self.driver.power.get_power_state,
task)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device')
def test_set_power_on(self, mock_set_boot_device, mock_get_ov_client):
client = mock_get_ov_client()
self.driver.power.client = client
server_hardware = self.node.driver_info.get('server_hardware_uri')
with task_manager.acquire(self.context, self.node.uuid) as task:
self.driver.power.set_power_state(task, states.POWER_ON)
@ -122,10 +121,10 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
update.assert_called_once_with(power.POWER_ON, server_hardware,
timeout=-1)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device')
def test_set_power_off(self, mock_set_boot_device, mock_get_ov_client):
client = mock_get_ov_client()
self.driver.power.client = client
server_hardware = self.node.driver_info.get('server_hardware_uri')
with task_manager.acquire(self.context, self.node.uuid) as task:
self.driver.power.set_power_state(task, states.POWER_OFF)
@ -134,10 +133,10 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
update.assert_called_once_with(power.POWER_OFF, server_hardware,
timeout=-1)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device')
def test_set_power_reboot(self, mock_set_boot_device, mock_get_ov_client):
client = mock_get_ov_client()
self.driver.power.client = client
server_hardware = self.node.driver_info.get('server_hardware_uri')
with task_manager.acquire(self.context, self.node.uuid) as task:
self.driver.power.set_power_state(task, states.REBOOT)
@ -146,12 +145,12 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
update = client.server_hardware.update_power_state
update.assert_has_calls(calls)
@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
self.driver.power.client = client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.OneViewError,
@ -160,13 +159,13 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
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')
def test_set_power_off_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
self.driver.power.client = client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.OneViewError,
@ -175,16 +174,15 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
states.POWER_OFF)
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_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
self.driver.power.client = client
exc = client_exception.HPOneViewException()
client.server_hardware.update_power_state.side_effect = exc
self.driver.power.client = client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.OneViewError,
@ -192,16 +190,15 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
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
self.driver.power.client = client
exc = client_exception.HPOneViewException()
client.server_hardware.update_power_state.side_effect = exc
self.driver.power.client = client
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.OneViewError,
@ -210,8 +207,7 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
mock_set_boot_device.assert_called_once_with(task)
@mock.patch.object(management, 'set_boot_device')
def test_set_power_invalid_state(
self, mock_set_boot_device, mock_get_ov_client):
def test_set_power_invalid_state(self, mock_set_boot_device):
with task_manager.acquire(self.context, self.node.uuid) as task:
self.assertRaises(
exception.InvalidParameterValue,
@ -220,13 +216,13 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
'fake_state')
self.assertFalse(mock_set_boot_device.called)
@mock.patch.object(common, 'get_hponeview_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
self.driver.power.client = client
server_hardware = self.node.driver_info.get('server_hardware_uri')
with task_manager.acquire(self.context, self.node.uuid) as task:
self.driver.power.reboot(task)
@ -236,13 +232,13 @@ class OneViewPowerDriverTestCase(db_base.DbTestCase):
update.assert_has_calls(calls)
mock_set_boot_device.assert_called_once_with(task)
@mock.patch.object(common, 'get_hponeview_client')
@mock.patch.object(management, 'set_boot_device')
def test_set_power_reboot_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
self.driver.power.client = client
server_hardware = self.node.driver_info.get('server_hardware_uri')
with task_manager.acquire(self.context, self.node.uuid) as task:
self.driver.power.reboot(task, timeout=-1)