# Copyright 2013 Hewlett-Packard Development Company, L.P. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """Test class for Ironic SSH power driver.""" import fixtures import mock import paramiko from ironic.common import boot_devices from ironic.common import driver_factory from ironic.common import exception from ironic.common import states from ironic.common import utils from ironic.conductor import task_manager from ironic.db import api as dbapi from ironic.drivers.modules import ssh from ironic.drivers import utils as driver_utils from ironic.openstack.common import context from ironic.openstack.common import processutils from ironic.tests import base from ironic.tests.conductor import utils as mgr_utils from ironic.tests.db import base as db_base from ironic.tests.db import utils as db_utils from ironic.tests.objects import utils as obj_utils from oslo.config import cfg CONF = cfg.CONF class SSHValidateParametersTestCase(base.TestCase): def setUp(self): super(SSHValidateParametersTestCase, self).setUp() self.context = context.get_admin_context() def test__parse_driver_info_good_password(self): # make sure we get back the expected things node = obj_utils.get_test_node( self.context, driver='fake_ssh', driver_info=db_utils.get_test_ssh_info('password')) info = ssh._parse_driver_info(node) self.assertIsNotNone(info.get('host')) self.assertIsNotNone(info.get('username')) self.assertIsNotNone(info.get('password')) self.assertIsNotNone(info.get('port')) self.assertIsNotNone(info.get('virt_type')) self.assertIsNotNone(info.get('cmd_set')) self.assertIsNotNone(info.get('uuid')) def test__parse_driver_info_good_key(self): # make sure we get back the expected things node = obj_utils.get_test_node( self.context, driver='fake_ssh', driver_info=db_utils.get_test_ssh_info('key')) info = ssh._parse_driver_info(node) self.assertIsNotNone(info.get('host')) self.assertIsNotNone(info.get('username')) self.assertIsNotNone(info.get('key_contents')) self.assertIsNotNone(info.get('port')) self.assertIsNotNone(info.get('virt_type')) self.assertIsNotNone(info.get('cmd_set')) self.assertIsNotNone(info.get('uuid')) def test__parse_driver_info_good_file(self): # make sure we get back the expected things d_info = db_utils.get_test_ssh_info('file') tempdir = self.useFixture(fixtures.TempDir()) key_path = tempdir.path + '/foo' open(key_path, 'wt').close() d_info['ssh_key_filename'] = key_path node = obj_utils.get_test_node( self.context, driver='fake_ssh', driver_info=d_info) info = ssh._parse_driver_info(node) self.assertIsNotNone(info.get('host')) self.assertIsNotNone(info.get('username')) self.assertIsNotNone(info.get('key_filename')) self.assertIsNotNone(info.get('port')) self.assertIsNotNone(info.get('virt_type')) self.assertIsNotNone(info.get('cmd_set')) self.assertIsNotNone(info.get('uuid')) def test__parse_driver_info_bad_file(self): # A filename that doesn't exist errors. info = db_utils.get_test_ssh_info('file') node = obj_utils.get_test_node( self.context, driver='fake_ssh', driver_info=info) self.assertRaises( exception.InvalidParameterValue, ssh._parse_driver_info, node) def test__parse_driver_info_too_many(self): info = db_utils.get_test_ssh_info('too_many') node = obj_utils.get_test_node( self.context, driver='fake_ssh', driver_info=info) self.assertRaises( exception.InvalidParameterValue, ssh._parse_driver_info, node) def test__parse_driver_info_missing_host(self): # make sure error is raised when info is missing info = db_utils.get_test_ssh_info() del info['ssh_address'] node = obj_utils.get_test_node(self.context, driver_info=info) self.assertRaises(exception.MissingParameterValue, ssh._parse_driver_info, node) def test__parse_driver_info_missing_user(self): # make sure error is raised when info is missing info = db_utils.get_test_ssh_info() del info['ssh_username'] node = obj_utils.get_test_node(self.context, driver_info=info) self.assertRaises(exception.MissingParameterValue, ssh._parse_driver_info, node) def test__parse_driver_info_invalid_creds(self): # make sure error is raised when info is missing info = db_utils.get_test_ssh_info('no-creds') node = obj_utils.get_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, ssh._parse_driver_info, node) def test__parse_driver_info_missing_virt_type(self): # make sure error is raised when info is missing info = db_utils.get_test_ssh_info() del info['ssh_virt_type'] node = obj_utils.get_test_node(self.context, driver_info=info) self.assertRaises(exception.MissingParameterValue, ssh._parse_driver_info, node) def test__parse_driver_info_ssh_port_wrong_type(self): # make sure error is raised when ssh_port is not integer info = db_utils.get_test_ssh_info() info['ssh_port'] = 'wrong_port_value' node = obj_utils.get_test_node(self.context, driver_info=info) self.assertRaises(exception.InvalidParameterValue, ssh._parse_driver_info, node) def test__normalize_mac_string(self): mac_raw = "0A:1B-2C-3D:4F" mac_clean = ssh._normalize_mac(mac_raw) self.assertEqual("0a1b2c3d4f", mac_clean) def test__normalize_mac_unicode(self): mac_raw = u"0A:1B-2C-3D:4F" mac_clean = ssh._normalize_mac(mac_raw) self.assertEqual("0a1b2c3d4f", mac_clean) def test__parse_driver_info_with_custom_libvirt_uri(self): CONF.set_override('libvirt_uri', 'qemu:///foo', 'ssh') expected_base_cmd = "/usr/bin/virsh --connect qemu:///foo" node = obj_utils.get_test_node( self.context, driver='fake_ssh', driver_info=db_utils.get_test_ssh_info()) node['driver_info']['ssh_virt_type'] = 'virsh' info = ssh._parse_driver_info(node) self.assertEqual(expected_base_cmd, info['cmd_set']['base_cmd']) class SSHPrivateMethodsTestCase(base.TestCase): def setUp(self): super(SSHPrivateMethodsTestCase, self).setUp() self.context = context.get_admin_context() self.node = obj_utils.get_test_node( self.context, driver='fake_ssh', driver_info=db_utils.get_test_ssh_info()) self.sshclient = paramiko.SSHClient() @mock.patch.object(utils, 'ssh_connect') def test__get_connection_client(self, ssh_connect_mock): ssh_connect_mock.return_value = self.sshclient client = ssh._get_connection(self.node) self.assertEqual(self.sshclient, client) driver_info = ssh._parse_driver_info(self.node) ssh_connect_mock.assert_called_once_with(driver_info) @mock.patch.object(utils, 'ssh_connect') def test__get_connection_exception(self, ssh_connect_mock): ssh_connect_mock.side_effect = exception.SSHConnectFailed(host='fake') self.assertRaises(exception.SSHConnectFailed, ssh._get_connection, self.node) driver_info = ssh._parse_driver_info(self.node) ssh_connect_mock.assert_called_once_with(driver_info) @mock.patch.object(processutils, 'ssh_execute') def test__ssh_execute(self, exec_ssh_mock): ssh_cmd = "somecmd" expected = ['a', 'b', 'c'] exec_ssh_mock.return_value = ('\n'.join(expected), '') lst = ssh._ssh_execute(self.sshclient, ssh_cmd) exec_ssh_mock.assert_called_once_with(self.sshclient, ssh_cmd) self.assertEqual(expected, lst) @mock.patch.object(processutils, 'ssh_execute') def test__ssh_execute_exception(self, exec_ssh_mock): ssh_cmd = "somecmd" exec_ssh_mock.side_effect = processutils.ProcessExecutionError self.assertRaises(exception.SSHCommandFailed, ssh._ssh_execute, self.sshclient, ssh_cmd) exec_ssh_mock.assert_called_once_with(self.sshclient, ssh_cmd) @mock.patch.object(processutils, 'ssh_execute') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test__get_power_status_on(self, get_hosts_name_mock, exec_ssh_mock): info = ssh._parse_driver_info(self.node) exec_ssh_mock.return_value = ( '"NodeName" {b43c4982-110c-4c29-9325-d5f41b053513}', '') get_hosts_name_mock.return_value = "NodeName" pstate = ssh._get_power_status(self.sshclient, info) ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['list_running']) self.assertEqual(states.POWER_ON, pstate) exec_ssh_mock.assert_called_once_with(self.sshclient, ssh_cmd) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) @mock.patch.object(processutils, 'ssh_execute') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test__get_power_status_off(self, get_hosts_name_mock, exec_ssh_mock): info = ssh._parse_driver_info(self.node) exec_ssh_mock.return_value = ( '"NodeName" {b43c4982-110c-4c29-9325-d5f41b053513}', '') get_hosts_name_mock.return_value = "NotNodeName" pstate = ssh._get_power_status(self.sshclient, info) ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['list_running']) self.assertEqual(states.POWER_OFF, pstate) exec_ssh_mock.assert_called_once_with(self.sshclient, ssh_cmd) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) @mock.patch.object(processutils, 'ssh_execute') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test__get_power_status_error(self, get_hosts_name_mock, exec_ssh_mock): info = ssh._parse_driver_info(self.node) exec_ssh_mock.return_value = ( '"NodeName" {b43c4982-110c-4c29-9325-d5f41b053513}', '') info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_hosts_name_mock.return_value = None self.assertRaises(exception.NodeNotFound, ssh._get_power_status, self.sshclient, info) ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['list_running']) exec_ssh_mock.assert_called_once_with(self.sshclient, ssh_cmd) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) @mock.patch.object(processutils, 'ssh_execute') def test__get_power_status_exception(self, exec_ssh_mock): info = ssh._parse_driver_info(self.node) exec_ssh_mock.side_effect = processutils.ProcessExecutionError self.assertRaises(exception.SSHCommandFailed, ssh._get_power_status, self.sshclient, info) ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['list_running']) exec_ssh_mock.assert_called_once_with( self.sshclient, ssh_cmd) @mock.patch.object(processutils, 'ssh_execute') def test__get_hosts_name_for_node_match(self, exec_ssh_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['list_all']) cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['get_node_macs']) cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') exec_ssh_mock.side_effect = [('NodeName', ''), ('52:54:00:cf:2d:31', '')] expected = [mock.call(self.sshclient, ssh_cmd), mock.call(self.sshclient, cmd_to_exec)] found_name = ssh._get_hosts_name_for_node(self.sshclient, info) self.assertEqual('NodeName', found_name) self.assertEqual(expected, exec_ssh_mock.call_args_list) @mock.patch.object(processutils, 'ssh_execute') def test__get_hosts_name_for_node_no_match(self, exec_ssh_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "22:22:22:22:22:22"] exec_ssh_mock.side_effect = [('NodeName', ''), ('52:54:00:cf:2d:31', '')] ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['list_all']) cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['get_node_macs']) cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') expected = [mock.call(self.sshclient, ssh_cmd), mock.call(self.sshclient, cmd_to_exec)] found_name = ssh._get_hosts_name_for_node(self.sshclient, info) self.assertIsNone(found_name) self.assertEqual(expected, exec_ssh_mock.call_args_list) @mock.patch.object(processutils, 'ssh_execute') def test__get_hosts_name_for_node_exception(self, exec_ssh_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['list_all']) cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['get_node_macs']) cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') exec_ssh_mock.side_effect = [('NodeName', ''), processutils.ProcessExecutionError] expected = [mock.call(self.sshclient, ssh_cmd), mock.call(self.sshclient, cmd_to_exec)] self.assertRaises(exception.SSHCommandFailed, ssh._get_hosts_name_for_node, self.sshclient, info) self.assertEqual(expected, exec_ssh_mock.call_args_list) @mock.patch.object(processutils, 'ssh_execute') @mock.patch.object(ssh, '_get_power_status') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test__power_on_good(self, get_hosts_name_mock, get_power_status_mock, exec_ssh_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_power_status_mock.side_effect = [states.POWER_OFF, states.POWER_ON] get_hosts_name_mock.return_value = "NodeName" expected = [mock.call(self.sshclient, info), mock.call(self.sshclient, info)] cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['start_cmd']) cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') current_state = ssh._power_on(self.sshclient, info) self.assertEqual(states.POWER_ON, current_state) self.assertEqual(expected, get_power_status_mock.call_args_list) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) exec_ssh_mock.assert_called_once_with(self.sshclient, cmd_to_exec) @mock.patch.object(processutils, 'ssh_execute') @mock.patch.object(ssh, '_get_power_status') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test__power_on_fail(self, get_hosts_name_mock, get_power_status_mock, exec_ssh_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_power_status_mock.side_effect = [states.POWER_OFF, states.POWER_OFF] get_hosts_name_mock.return_value = "NodeName" expected = [mock.call(self.sshclient, info), mock.call(self.sshclient, info)] cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['start_cmd']) cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') current_state = ssh._power_on(self.sshclient, info) self.assertEqual(states.ERROR, current_state) self.assertEqual(expected, get_power_status_mock.call_args_list) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) exec_ssh_mock.assert_called_once_with(self.sshclient, cmd_to_exec) @mock.patch.object(processutils, 'ssh_execute') @mock.patch.object(ssh, '_get_power_status') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test__power_on_exception(self, get_hosts_name_mock, get_power_status_mock, exec_ssh_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] exec_ssh_mock.side_effect = processutils.ProcessExecutionError get_power_status_mock.side_effect = [states.POWER_OFF, states.POWER_ON] get_hosts_name_mock.return_value = "NodeName" cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['start_cmd']) cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') self.assertRaises(exception.SSHCommandFailed, ssh._power_on, self.sshclient, info) get_power_status_mock.assert_called_once_with(self.sshclient, info) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) exec_ssh_mock.assert_called_once_with(self.sshclient, cmd_to_exec) @mock.patch.object(processutils, 'ssh_execute') @mock.patch.object(ssh, '_get_power_status') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test__power_off_good(self, get_hosts_name_mock, get_power_status_mock, exec_ssh_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_power_status_mock.side_effect = [states.POWER_ON, states.POWER_OFF] get_hosts_name_mock.return_value = "NodeName" expected = [mock.call(self.sshclient, info), mock.call(self.sshclient, info)] cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['stop_cmd']) cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') current_state = ssh._power_off(self.sshclient, info) self.assertEqual(states.POWER_OFF, current_state) self.assertEqual(expected, get_power_status_mock.call_args_list) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) exec_ssh_mock.assert_called_once_with(self.sshclient, cmd_to_exec) @mock.patch.object(processutils, 'ssh_execute') @mock.patch.object(ssh, '_get_power_status') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test__power_off_fail(self, get_hosts_name_mock, get_power_status_mock, exec_ssh_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_power_status_mock.side_effect = [states.POWER_ON, states.POWER_ON] get_hosts_name_mock.return_value = "NodeName" expected = [mock.call(self.sshclient, info), mock.call(self.sshclient, info)] cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['stop_cmd']) cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') current_state = ssh._power_off(self.sshclient, info) self.assertEqual(states.ERROR, current_state) self.assertEqual(expected, get_power_status_mock.call_args_list) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) exec_ssh_mock.assert_called_once_with(self.sshclient, cmd_to_exec) @mock.patch.object(processutils, 'ssh_execute') @mock.patch.object(ssh, '_get_power_status') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test__power_off_exception(self, get_hosts_name_mock, get_power_status_mock, exec_ssh_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] exec_ssh_mock.side_effect = processutils.ProcessExecutionError get_power_status_mock.side_effect = [states.POWER_ON, states.POWER_OFF] get_hosts_name_mock.return_value = "NodeName" cmd_to_exec = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['stop_cmd']) cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') self.assertRaises(exception.SSHCommandFailed, ssh._power_off, self.sshclient, info) get_power_status_mock.assert_called_once_with(self.sshclient, info) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) exec_ssh_mock.assert_called_once_with(self.sshclient, cmd_to_exec) def test_exec_ssh_command_good(self): class Channel(object): def recv_exit_status(self): return 0 class Stream(object): def __init__(self, buffer=''): self.buffer = buffer self.channel = Channel() def read(self): return self.buffer def close(self): pass with mock.patch.object(self.sshclient, 'exec_command') \ as exec_command_mock: exec_command_mock.return_value = (Stream(), Stream('hello'), Stream()) stdout, stderr = processutils.ssh_execute(self.sshclient, "command") self.assertEqual('hello', stdout) exec_command_mock.assert_called_once_with("command") def test_exec_ssh_command_fail(self): class Channel(object): def recv_exit_status(self): return 127 class Stream(object): def __init__(self, buffer=''): self.buffer = buffer self.channel = Channel() def read(self): return self.buffer def close(self): pass with mock.patch.object(self.sshclient, 'exec_command') \ as exec_command_mock: exec_command_mock.return_value = (Stream(), Stream('hello'), Stream()) self.assertRaises(processutils.ProcessExecutionError, processutils.ssh_execute, self.sshclient, "command") exec_command_mock.assert_called_once_with("command") class SSHDriverTestCase(db_base.DbTestCase): def setUp(self): super(SSHDriverTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_ssh") self.driver = driver_factory.get_driver("fake_ssh") self.node = obj_utils.create_test_node( self.context, driver='fake_ssh', driver_info=db_utils.get_test_ssh_info()) self.dbapi = dbapi.get_instance() self.port = obj_utils.create_test_port(self.context, node_id=self.node.id) self.sshclient = paramiko.SSHClient() @mock.patch.object(utils, 'ssh_connect') def test__validate_info_ssh_connect_failed(self, ssh_connect_mock): info = ssh._parse_driver_info(self.node) ssh_connect_mock.side_effect = exception.SSHConnectFailed(host='fake') with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises(exception.InvalidParameterValue, task.driver.power.validate, task) driver_info = ssh._parse_driver_info(task.node) ssh_connect_mock.assert_called_once_with(driver_info) def test_get_properties(self): expected = ssh.COMMON_PROPERTIES with task_manager.acquire(self.context, self.node.uuid, shared=True) as task: self.assertEqual(expected, task.driver.power.get_properties()) self.assertEqual(expected, task.driver.get_properties()) self.assertEqual(expected, task.driver.management.get_properties()) def test_validate_fail_no_port(self): new_node = obj_utils.create_test_node( self.context, id=321, uuid='aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', driver='fake_ssh', driver_info=db_utils.get_test_ssh_info()) with task_manager.acquire(self.context, new_node.uuid, shared=True) as task: self.assertRaises(exception.InvalidParameterValue, task.driver.power.validate, task) @mock.patch.object(driver_utils, 'get_node_mac_addresses') @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_get_power_status') @mock.patch.object(ssh, '_power_off') @mock.patch.object(ssh, '_power_on') def test_reboot_good(self, power_on_mock, power_off_mock, get_power_stat_mock, get_conn_mock, get_mac_addr_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_mac_addr_mock.return_value = info['macs'] get_conn_mock.return_value = self.sshclient get_power_stat_mock.return_value = states.POWER_ON power_off_mock.return_value = None power_on_mock.return_value = states.POWER_ON with mock.patch.object(ssh, '_parse_driver_info') as parse_drv_info_mock: parse_drv_info_mock.return_value = info with task_manager.acquire(self.context, info['uuid'], shared=False) as task: task.driver.power.reboot(task) parse_drv_info_mock.assert_called_once_with(task.node) get_mac_addr_mock.assert_called_once_with(mock.ANY) get_conn_mock.assert_called_once_with(task.node) get_power_stat_mock.assert_called_once_with(self.sshclient, info) power_off_mock.assert_called_once_with(self.sshclient, info) power_on_mock.assert_called_once_with(self.sshclient, info) @mock.patch.object(driver_utils, 'get_node_mac_addresses') @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_get_power_status') @mock.patch.object(ssh, '_power_off') @mock.patch.object(ssh, '_power_on') def test_reboot_fail(self, power_on_mock, power_off_mock, get_power_stat_mock, get_conn_mock, get_mac_addr_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_mac_addr_mock.return_value = info['macs'] get_conn_mock.return_value = self.sshclient get_power_stat_mock.return_value = states.POWER_ON power_off_mock.return_value = None power_on_mock.return_value = states.POWER_OFF with mock.patch.object(ssh, '_parse_driver_info') as parse_drv_info_mock: parse_drv_info_mock.return_value = info with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises(exception.PowerStateFailure, task.driver.power.reboot, task) parse_drv_info_mock.assert_called_once_with(task.node) get_mac_addr_mock.assert_called_once_with(mock.ANY) get_conn_mock.assert_called_once_with(task.node) get_power_stat_mock.assert_called_once_with(self.sshclient, info) power_off_mock.assert_called_once_with(self.sshclient, info) power_on_mock.assert_called_once_with(self.sshclient, info) @mock.patch.object(driver_utils, 'get_node_mac_addresses') @mock.patch.object(ssh, '_get_connection') def test_set_power_state_bad_state(self, get_conn_mock, get_mac_addr_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_mac_addr_mock.return_value = info['macs'] get_conn_mock.return_value = self.sshclient with mock.patch.object(ssh, '_parse_driver_info') as parse_drv_info_mock: parse_drv_info_mock.return_value = info with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises( exception.InvalidParameterValue, task.driver.power.set_power_state, task, "BAD_PSTATE") parse_drv_info_mock.assert_called_once_with(task.node) get_mac_addr_mock.assert_called_once_with(mock.ANY) get_conn_mock.assert_called_once_with(task.node) @mock.patch.object(driver_utils, 'get_node_mac_addresses') @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_power_on') def test_set_power_state_on_good(self, power_on_mock, get_conn_mock, get_mac_addr_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_mac_addr_mock.return_value = info['macs'] get_conn_mock.return_value = self.sshclient power_on_mock.return_value = states.POWER_ON with mock.patch.object(ssh, '_parse_driver_info') as parse_drv_info_mock: parse_drv_info_mock.return_value = info with task_manager.acquire(self.context, info['uuid'], shared=False) as task: task.driver.power.set_power_state(task, states.POWER_ON) parse_drv_info_mock.assert_called_once_with(task.node) get_mac_addr_mock.assert_called_once_with(mock.ANY) get_conn_mock.assert_called_once_with(task.node) power_on_mock.assert_called_once_with(self.sshclient, info) @mock.patch.object(driver_utils, 'get_node_mac_addresses') @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_power_on') def test_set_power_state_on_fail(self, power_on_mock, get_conn_mock, get_mac_addr_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_mac_addr_mock.return_value = info['macs'] get_conn_mock.return_value = self.sshclient power_on_mock.return_value = states.POWER_OFF with mock.patch.object(ssh, '_parse_driver_info') as parse_drv_info_mock: parse_drv_info_mock.return_value = info with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises( exception.PowerStateFailure, task.driver.power.set_power_state, task, states.POWER_ON) parse_drv_info_mock.assert_called_once_with(task.node) get_mac_addr_mock.assert_called_once_with(mock.ANY) get_conn_mock.assert_called_once_with(task.node) power_on_mock.assert_called_once_with(self.sshclient, info) @mock.patch.object(driver_utils, 'get_node_mac_addresses') @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_power_off') def test_set_power_state_off_good(self, power_off_mock, get_conn_mock, get_mac_addr_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_mac_addr_mock.return_value = info['macs'] get_conn_mock.return_value = self.sshclient power_off_mock.return_value = states.POWER_OFF with mock.patch.object(ssh, '_parse_driver_info') as parse_drv_info_mock: parse_drv_info_mock.return_value = info with task_manager.acquire(self.context, info['uuid'], shared=False) as task: task.driver.power.set_power_state(task, states.POWER_OFF) parse_drv_info_mock.assert_called_once_with(task.node) get_mac_addr_mock.assert_called_once_with(mock.ANY) get_conn_mock.assert_called_once_with(task.node) power_off_mock.assert_called_once_with(self.sshclient, info) @mock.patch.object(driver_utils, 'get_node_mac_addresses') @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_power_off') def test_set_power_state_off_fail(self, power_off_mock, get_conn_mock, get_mac_addr_mock): info = ssh._parse_driver_info(self.node) info['macs'] = ["11:11:11:11:11:11", "52:54:00:cf:2d:31"] get_mac_addr_mock.return_value = info['macs'] get_conn_mock.return_value = self.sshclient power_off_mock.return_value = states.POWER_ON with mock.patch.object(ssh, '_parse_driver_info') as parse_drv_info_mock: parse_drv_info_mock.return_value = info with task_manager.acquire(self.context, info['uuid'], shared=False) as task: self.assertRaises( exception.PowerStateFailure, task.driver.power.set_power_state, task, states.POWER_OFF) parse_drv_info_mock.assert_called_once_with(task.node) get_mac_addr_mock.assert_called_once_with(mock.ANY) get_conn_mock.assert_called_once_with(task.node) power_off_mock.assert_called_once_with(self.sshclient, info) @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_get_hosts_name_for_node') @mock.patch.object(ssh, '_ssh_execute') def test_management_interface_set_boot_device_ok(self, mock_exc, mock_h, mock_get_conn): fake_name = 'fake-name' mock_h.return_value = fake_name mock_get_conn.return_value = self.sshclient with task_manager.acquire(self.context, self.node.uuid) as task: task.node['driver_info']['ssh_virt_type'] = 'virsh' self.driver.management.set_boot_device(task, boot_devices.PXE) expected_cmd = ('EDITOR="sed -i \'/' '/d;/<\\/os>/i\\\'" ' '/usr/bin/virsh --connect qemu:///system ' 'edit %s') % fake_name mock_exc.assert_called_once_with(mock.ANY, expected_cmd) def test_set_boot_device_bad_device(self): with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises(exception.InvalidParameterValue, self.driver.management.set_boot_device, task, 'invalid-device') @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test_set_boot_device_not_supported(self, mock_h, mock_get_conn): mock_h.return_value = 'NodeName' mock_get_conn.return_value = self.sshclient # vmware does not support set_boot_device() self.node['driver_info']['ssh_virt_type'] = 'vmware' with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises(NotImplementedError, self.driver.management.set_boot_device, task, boot_devices.PXE) def test_management_interface_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] self.assertEqual(sorted(expected), sorted(task.driver.management. get_supported_boot_devices())) @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_get_hosts_name_for_node') @mock.patch.object(ssh, '_ssh_execute') def test_management_interface_get_boot_device(self, mock_exc, mock_h, mock_get_conn): fake_name = 'fake-name' mock_h.return_value = fake_name mock_exc.return_value = ('network', '') mock_get_conn.return_value = self.sshclient with task_manager.acquire(self.context, self.node.uuid) as task: task.node['driver_info']['ssh_virt_type'] = 'virsh' result = self.driver.management.get_boot_device(task) self.assertEqual(boot_devices.PXE, result['boot_device']) expected_cmd = ('/usr/bin/virsh --connect qemu:///system dumpxml ' '%s | awk \'/boot dev=/ { gsub( ".*dev=" Q, "" ); ' 'gsub( Q ".*", "" ); print; }\' Q="\'" RS="[<>]" | ' 'head -1') % fake_name mock_exc.assert_called_once_with(mock.ANY, expected_cmd) @mock.patch.object(ssh, '_get_connection') @mock.patch.object(ssh, '_get_hosts_name_for_node') def test_get_boot_device_not_supported(self, mock_h, mock_get_conn): mock_h.return_value = 'NodeName' mock_get_conn.return_value = self.sshclient # vmware does not support get_boot_device() self.node['driver_info']['ssh_virt_type'] = 'vmware' with task_manager.acquire(self.context, self.node.uuid) as task: expected = {'boot_device': None, 'persistent': None} self.assertEqual(expected, self.driver.management.get_boot_device(task)) def test_management_interface_validate_good(self): with task_manager.acquire(self.context, self.node.uuid) as task: task.driver.management.validate(task) def test_management_interface_validate_fail(self): # Missing SSH driver_info information node = obj_utils.create_test_node(self.context, id=2, uuid=utils.generate_uuid(), driver='fake_ssh') with task_manager.acquire(self.context, node.uuid) as task: self.assertRaises(exception.MissingParameterValue, task.driver.management.validate, task)