# Copyright 2014, 2017 IBM Corp. # # 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. import fixtures import mock import testtools import pypowervm.exceptions as pexc from pypowervm.tasks import power import pypowervm.tasks.power_opts as popts import pypowervm.tests.test_fixtures as fx import pypowervm.wrappers.base_partition as pvm_bp import pypowervm.wrappers.logical_partition as pvm_lpar class TestPower(testtools.TestCase): def setUp(self): super(TestPower, self).setUp() self.adpt = self.useFixture(fx.AdapterFx()).adpt # Make it easier to validate job params: create_job_parameter returns a # simple 'name=value' string. mock_crt_jparm = self.useFixture(fixtures.MockPatch( 'pypowervm.wrappers.job.Job.create_job_parameter')).mock mock_crt_jparm.side_effect = ( lambda name, value, cdata=False: '%s=%s' % (name, value)) # Patch Job.wrap to return a mocked Job wrapper mock_job = mock.Mock() self.useFixture(fixtures.MockPatch( 'pypowervm.wrappers.job.Job.wrap')).mock.return_value = mock_job self.run_job = mock_job.run_job def validate_run(self, part, ex_suff="PowerOff", ex_parms=None, ex_timeout=1800, ex_synch=True, result='', nxt=None): """Return side effect method to validate Adapter.read and Job.run_job. :param part: (Mock) partition wrapper. :param ex_suff: Expected Job suffix - "PowerOn" or "PowerOff" :param ex_parms: Set of expected JobParameter 'name=value' strings. :param ex_timeout: Expected timeout (int, seconds). :param ex_synch: Expected value of the 'synchronous' flag. :param result: The desired result of the run_job call. May be None (the run_job call "succeeded") or an instance of an exception to be raised (either JobRequestTimedOut or JobRequestFailed). :param nxt: When chaining side effects, pass the method to be assigned to the run_job side effect after this side effect runs. Typically the return from another validate_run() call. :return: A method suitable for assigning to self.run_job.side_effect. """ def run_job_seff(uuid, job_parms=None, timeout=None, synchronous=None): # We fetched the Job template with the correct bits of the # partition wrapper and the correct suffix self.adpt.read.assert_called_once_with( part.schema_type, part.uuid, suffix_type='do', suffix_parm=ex_suff) # Reset for subsequent runs self.adpt.reset_mock() self.assertEqual(part.uuid, uuid) # JobParameter order doesn't matter self.assertEqual(ex_parms or set(), set(job_parms)) self.assertEqual(ex_timeout, timeout) self.assertEqual(ex_synch, synchronous) if nxt: self.run_job.side_effect = nxt if result: raise result return run_job_seff @staticmethod def etimeout(): """Returns a JobRequestTimedOut exception.""" return pexc.JobRequestTimedOut(operation_name='foo', seconds=1800) @staticmethod def efail(error='error'): """Returns a JobRequestFailed exception.""" return pexc.JobRequestFailed(operation_name='foo', error=error) def mock_partition(self, env=pvm_bp.LPARType.AIXLINUX, rmc_state=pvm_bp.RMCState.ACTIVE, mgmt=False): """Returns a mocked partition with the specified properties.""" return mock.Mock(adapter=self.adpt, env=env, rmc_state=rmc_state, is_mgmt_partition=mgmt) def test_pwrop_start(self): """Test PowerOp.start.""" part = self.mock_partition() # Default params, success self.run_job.side_effect = self.validate_run(part, ex_suff="PowerOn") power.PowerOp.start(part) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Additional params, timeout self.run_job.side_effect = self.validate_run( part, ex_suff="PowerOn", ex_parms={'foo=bar', 'one=two'}, result=self.etimeout()) self.assertRaises( pexc.VMPowerOnTimeout, power.PowerOp.start, part, opts=popts.PowerOnOpts(legacy_add_parms={'foo': 'bar', 'one': 'two'})) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Asynchronous, failure self.run_job.side_effect = self.validate_run( part, ex_suff="PowerOn", ex_synch=False, result=self.efail()) self.assertRaises(pexc.VMPowerOnFailure, power.PowerOp.start, part, synchronous=False) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Specified timeout, already on self.run_job.side_effect = self.validate_run( part, ex_suff="PowerOn", ex_timeout=10, result=self.efail('HSCL3681')) power.PowerOp.start(part, timeout=10) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() def test_pwrop_stop(self): """Test PowerOp.stop.""" # If RMC is down, VSP normal - make sure the 'immediate' flag goes away part = self.mock_partition(rmc_state=pvm_bp.RMCState.INACTIVE) self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown'}) power.PowerOp.stop( part, opts=popts.PowerOffOpts().immediate().soft_detect(part)) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Default parameters - the method figures out whether to do OS shutdown part = self.mock_partition() self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true'}) power.PowerOp.stop( part, opts=popts.PowerOffOpts().immediate().soft_detect(part)) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Non-default optional params ignored, timeout self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true', 'restart=true'}, ex_timeout=100, ex_synch=False, result=self.etimeout()) self.assertRaises( pexc.VMPowerOffTimeout, power.PowerOp.stop, part, opts=popts.PowerOffOpts(legacy_add_parms={ 'one': 1, 'foo': 'bar'}).os_immediate().restart(), timeout=100, synchronous=False) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # VSP normal, fail self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown'}, result=self.efail()) self.assertRaises( pexc.VMPowerOffFailure, power.PowerOp.stop, part, opts=popts.PowerOffOpts().vsp_normal()) self.assertEqual(1, self.run_job.call_count) def test_pwrop_stop_no_rmc(self): """Test PowerOp.stop with bad RMC state.""" part = self.mock_partition(rmc_state=pvm_bp.RMCState.INACTIVE) self.assertRaises(pexc.OSShutdownNoRMC, power.PowerOp.stop, part, opts=popts.PowerOffOpts().os_normal()) self.run_job.assert_not_called() def test_pwron(self): """Test the power_on method.""" lpar = self.mock_partition() self.run_job.side_effect = self.validate_run(lpar, "PowerOn") power.power_on(lpar, None) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Try optional parameters self.run_job.side_effect = self.validate_run( lpar, "PowerOn", ex_parms={ 'bootmode=sms', 'iIPLsource=a', 'remove_optical_name=testVopt', 'remove_optical_time=30'}, ex_synch=False) power.power_on( lpar, None, add_parms={ power.BootMode.KEY: power.BootMode.SMS, pvm_lpar.IPLSrc.KEY: pvm_lpar.IPLSrc.A, power.RemoveOptical.KEY_TIME: 30, power.RemoveOptical.KEY_NAME: 'testVopt'}, synchronous=False) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Job timeout, IBMi, implicit remove_optical_time ibmi = self.mock_partition(env=pvm_bp.LPARType.OS400) self.run_job.side_effect = self.validate_run( ibmi, "PowerOn", ex_parms={'remove_optical_name=test', 'remove_optical_time=0'}, result=self.etimeout()) self.assertRaises(pexc.VMPowerOnTimeout, power.power_on, ibmi, None, add_parms=power.RemoveOptical.bld_map(name="test")) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Job failure, VIOS partition, explicit remove_optical_time vios = self.mock_partition(env=pvm_bp.LPARType.VIOS) self.run_job.side_effect = self.validate_run( vios, "PowerOn", ex_parms={'remove_optical_name=test2', 'remove_optical_time=25'}, result=self.efail()) self.assertRaises( pexc.VMPowerOnFailure, power.power_on, vios, None, add_parms=power.RemoveOptical.bld_map(name="test2", time=25)) self.assertEqual(1, self.run_job.call_count) def test_pwron_already_on(self): """PowerOn when the system is already powered on.""" part = self.mock_partition() for prefix in power._ALREADY_POWERED_ON_ERRS: self.run_job.side_effect = self.validate_run( part, ex_suff="PowerOn", result=self.efail( error="Something %s Something else" % prefix)) power.power_on(part, None) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() def test_pwroff_force_immed(self): """Test power_off with force_immediate=Force.TRUE.""" # PowerOff with force-immediate works the same regardless of partition # type, RMC state, or management partition status. for env in (pvm_bp.LPARType.OS400, pvm_bp.LPARType.AIXLINUX, pvm_bp.LPARType.VIOS): for rmc in (pvm_bp.RMCState.ACTIVE, pvm_bp.RMCState.BUSY, pvm_bp.RMCState.INACTIVE): for mgmt in (True, False): part = self.mock_partition(env=env, rmc_state=rmc, mgmt=mgmt) self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown', 'immediate=true'}) power.power_off(part, None, force_immediate=power.Force.TRUE) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Restart, timeout, additional params ignored part = self.mock_partition() self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown', 'immediate=true', 'restart=true'}, ex_timeout=10, result=self.etimeout()) self.assertRaises(pexc.VMPowerOffTimeout, power.power_off, part, None, force_immediate=power.Force.TRUE, restart=True, timeout=10, add_parms=dict(one=1)) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Failure self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown', 'immediate=true'}, result=self.efail()) self.assertRaises(pexc.VMPowerOffFailure, power.power_off, part, None, force_immediate=power.Force.TRUE) self.assertEqual(1, self.run_job.call_count) def test_pwroff_soft_ibmi_norm(self): """Soft PowerOff flow, IBMi, normal (no immediate).""" part = self.mock_partition(env=pvm_bp.LPARType.OS400) # This works the same whether intervening Job exceptions are Timeout or # Failure. for exc in (self.etimeout(), self.efail()): self.run_job.side_effect = ( # OS normal self.validate_run( part, ex_parms={'operation=osshutdown'}, ex_timeout=100, result=exc, # OS immediate (timeout is defaulted from this point) nxt=self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true'}, result=exc, # VSP normal nxt=self.validate_run( part, ex_parms={'operation=shutdown'}, result=exc, # VSP hard (default timeout) nxt=self.validate_run( part, ex_parms={ 'operation=shutdown', 'immediate=true'})))) ) # Run it power.power_off(part, None, timeout=100) self.assertEqual(4, self.run_job.call_count) self.run_job.reset_mock() # If one of the interim calls succeeds, the operation succeeds. self.run_job.side_effect = ( # OS normal self.validate_run( part, ex_parms={'operation=osshutdown'}, result=self.efail(), # OS immediate (timeout is defaulted from this point) nxt=self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true'}, result=self.etimeout(), # VSP normal - succeeds nxt=self.validate_run( part, ex_parms={'operation=shutdown'}, # Not reached nxt=self.fail)))) power.power_off(part, None) self.assertEqual(3, self.run_job.call_count) def test_pwroff_soft_standard_timeout(self): """Soft PowerOff flow, non-IBMi, with timeout.""" # When OS shutdown times out, go straight to VSP hard. part = self.mock_partition() self.run_job.side_effect = ( # OS normal. Non-IBMi always adds immediate. self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true'}, ex_timeout=100, result=self.etimeout(), # VSP hard nxt=self.validate_run( part, ex_parms={'operation=shutdown', 'immediate=true'})) ) # Run it power.power_off(part, None, timeout=100) self.assertEqual(2, self.run_job.call_count) self.run_job.reset_mock() # Same if invoked with immediate. But since we're running again, add # restart and another param; make sure restart comes through but the # bogus one is ignored. self.run_job.side_effect = ( # OS immediate (non-IBMi always adds immediate). self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true', 'restart=true'}, ex_timeout=200, result=self.etimeout(), # VSP hard nxt=self.validate_run( part, ex_parms={'operation=shutdown', 'immediate=true', 'restart=true'})) ) # Run it power.power_off(part, None, timeout=200, restart=True, add_parms={'foo': 'bar'}) self.assertEqual(2, self.run_job.call_count) def test_pwroff_soft_no_retry(self): """Soft PowerOff, no retry.""" # When OS shutdown fails with NO_RETRY, fail (no soft flow) # IBMi part = self.mock_partition(env=pvm_bp.LPARType.OS400) self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=osshutdown'}, result=self.efail()) self.assertRaises(pexc.VMPowerOffFailure, power.power_off, part, None, force_immediate=power.Force.NO_RETRY) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # non-IBMi part = self.mock_partition() self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true'}, result=self.efail()) self.assertRaises(pexc.VMPowerOffFailure, power.power_off, part, None, force_immediate=power.Force.NO_RETRY) self.assertEqual(1, self.run_job.call_count) def test_pwroff_soft_standard_fail(self): """Soft PowerOff flow, non-IBMi, with Job failure.""" # When OS shutdown fails (non-timeout), we try VSP normal first. part = self.mock_partition() self.run_job.side_effect = ( # OS immediate (non-IBMi always adds immediate). # Make sure restart percolates through, bogus params ignored. self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true', 'restart=true'}, ex_timeout=300, result=self.efail(), # VSP normal, timeout reset to default nxt=self.validate_run( part, ex_parms={ 'operation=shutdown', 'restart=true'}, result=self.efail(), # VSP hard nxt=self.validate_run( part, ex_parms={'operation=shutdown', 'immediate=true', 'restart=true'}))) ) power.power_off(part, None, timeout=300, restart=True, add_parms={'foo': 'bar'}) self.assertEqual(3, self.run_job.call_count) def test_pwroff_soft_standard_no_rmc_no_retry(self): """Non-IBMi soft PowerOff does VSP normal if RMC is down; no retry.""" # Behavior is the same for INACTIVE or BUSY for rmc in (pvm_bp.RMCState.INACTIVE, pvm_bp.RMCState.BUSY): part = self.mock_partition(rmc_state=rmc) self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown'}, result=self.efail()) self.assertRaises( pexc.VMPowerOffFailure, power.power_off, part, None, force_immediate=power.Force.NO_RETRY) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # Job timeout & failure do the same (except for final exception). self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown'}, result=self.etimeout()) self.assertRaises( pexc.VMPowerOffTimeout, power.power_off, part, None, force_immediate=power.Force.NO_RETRY) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() def test_pwroff_already_off(self): """PowerOff when the system is already powered off.""" part = self.mock_partition() for prefix in power._ALREADY_POWERED_OFF_ERRS: self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true'}, result=self.efail(error="Foo %s bar" % prefix)) power.power_off(part, None) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # If restart was specified, this is a failure. (Force, to KISS) self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown', 'immediate=true', 'restart=true'}, result=self.efail(error="Foo %s bar" % prefix)) self.assertRaises(pexc.VMPowerOffFailure, power.power_off, part, None, restart=True, force_immediate=power.Force.TRUE) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() def test_pwroff_new_opts(self): """Test power_off where add_parms is PowerOffOpts (not legacy).""" part = self.mock_partition() # VSP hard self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown', 'immediate=true'}) power.power_off(part, None, add_parms=popts.PowerOffOpts().vsp_hard()) self.assertEqual(1, self.run_job.call_count) self.run_job.reset_mock() # VSP normal self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=shutdown'}) power.power_off(part, None, add_parms=popts.PowerOffOpts().vsp_normal()) self.run_job.reset_mock() # OS immediate self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=osshutdown', 'immediate=true'}) power.power_off(part, None, add_parms=popts.PowerOffOpts().os_immediate()) self.run_job.reset_mock() # OS normal self.run_job.side_effect = self.validate_run( part, ex_parms={'operation=osshutdown'}) power.power_off(part, None, add_parms=popts.PowerOffOpts().os_normal()) @mock.patch('pypowervm.tasks.power._power_off_progressive') def test_pwroff_progressive(self, mock_prog_internal): # The internal _power_off_progressive is exercised via the existing # tests for power_off. This test just ensures the public # power_off_progressive calls it appropriately. # Default kwargs power.power_off_progressive('part') mock_prog_internal.assert_called_once_with( 'part', 1800, False, ibmi_immed=False) mock_prog_internal.reset_mock() # Non-default kwargs power.power_off_progressive('part', restart=True, ibmi_immed=True, timeout=10) mock_prog_internal.assert_called_once_with( 'part', 10, True, ibmi_immed=True)