def reboot(adapter, instance, hard):
"""Reboots a VM.
:param adapter: A pypowervm.adapter.Adapter.
:param instance: The nova instance to reboot.
:param hard: Boolean True if hard reboot, False otherwise.
:raises: InstanceRebootFailure
"""
# Synchronize power-on and power-off ops on a given instance
with lockutils.lock('power_%s' % instance.uuid):
try:
entry = get_instance_wrapper(adapter, instance)
if entry.state != pvm_bp.LPARState.NOT_ACTIVATED:
if hard:
power.PowerOp.stop(
entry, opts=popts.PowerOffOpts().vsp_hard().restart())
else:
power.power_off_progressive(entry, restart=True)
else:
# pypowervm does NOT throw an exception if "already down".
# Any other exception from pypowervm is a legitimate failure;
# let it raise up.
# If we get here, pypowervm thinks the instance is down.
power.power_on(entry, None)
except pvm_exc.Error as e:
LOG.exception("PowerVM error during reboot.", instance=instance)
raise exc.InstanceRebootFailure(reason=six.text_type(e))
def reboot(adapter, instance, hard):
"""Reboots a VM.
:param adapter: A pypowervm.adapter.Adapter.
:param instance: The nova instance to reboot.
:param hard: Boolean True if hard reboot, False otherwise.
:raises: InstanceRebootFailure
"""
# Synchronize power-on and power-off ops on a given instance
with lockutils.lock('power_%s' % instance.uuid):
try:
entry = get_instance_wrapper(adapter, instance)
if entry.state != pvm_bp.LPARState.NOT_ACTIVATED:
if hard:
power.PowerOp.stop(
entry, opts=popts.PowerOffOpts().vsp_hard().restart())
else:
power.power_off_progressive(entry, restart=True)
else:
# pypowervm does NOT throw an exception if "already down".
# Any other exception from pypowervm is a legitimate failure;
# let it raise up.
# If we get here, pypowervm thinks the instance is down.
power.power_on(entry, None)
except pvm_exc.Error as e:
LOG.exception("PowerVM error during reboot.", instance=instance)
raise exc.InstanceRebootFailure(reason=six.text_type(e))
def power_on(adapter, instance, host_uuid, entry=None):
if entry is None:
entry = get_instance_wrapper(adapter, instance, host_uuid)
# Get the current state and see if we can start the VM
if entry.state in POWERVM_STARTABLE_STATE:
# Now start the lpar
power.power_on(entry, host_uuid)
return True
return False
def power_on(adapter, instance, host_uuid, entry=None):
if entry is None:
entry = get_instance_wrapper(adapter, instance, host_uuid)
# Get the current state and see if we can start the VM
if entry.state in POWERVM_STARTABLE_STATE:
# Now start the lpar
power.power_on(entry, host_uuid)
return True
return False
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_power_on_off_vios(self, mock_vios, mock_job_p, mock_run_job):
"""Performs a simple set of Power On/Off Tests."""
mock_vios.adapter = self.adpt
power._power_on_off(mock_vios, 'PowerOn', '1111')
self.assertEqual(1, mock_run_job.call_count)
self.assertEqual(0, mock_job_p.call_count)
mock_run_job.reset_mock()
mock_job_p.reset_mock()
self.adpt.reset_mock()
# Try a power off
power._power_on_off(mock_vios, 'PowerOff', '1111')
self.assertEqual(1, mock_run_job.call_count)
# Only the operation parameter is appended
self.assertEqual(1, mock_job_p.call_count)
mock_run_job.reset_mock()
mock_job_p.reset_mock()
# Try a power off when the RMC state is active
mock_vios.rmc_state = pvm_bp.RMCState.ACTIVE
power._power_on_off(mock_vios, 'PowerOff', '1111')
self.assertEqual(1, mock_run_job.call_count)
# The operation and immediate(no-delay) parameters are appended
self.assertEqual(2, mock_job_p.call_count)
mock_vios.reset_mock()
mock_run_job.reset_mock()
mock_job_p.reset_mock()
# Try a more complex power off
power._power_on_off(mock_vios,
'PowerOff',
'1111',
force_immediate=True,
restart=True,
timeout=100)
self.assertEqual(1, mock_run_job.call_count)
self.assertEqual(3, mock_job_p.call_count)
mock_run_job.reset_mock()
mock_job_p.reset_mock()
# Try optional parameters
power.power_on(mock_vios,
'1111',
add_parms={power.BootMode.KEY: power.BootMode.SMS})
self.assertEqual(1, mock_run_job.call_count)
self.assertEqual(1, mock_job_p.call_count)
mock_job_p.assert_called_with(power.BootMode.KEY, power.BootMode.SMS)
def power_on(adapter, instance):
"""Powers on a VM.
:param adapter: A pypowervm.adapter.Adapter.
:param instance: The nova instance to power on.
:raises: InstancePowerOnFailure
"""
# Synchronize power-on and power-off ops on a given instance
with lockutils.lock('power_%s' % instance.uuid):
entry = get_instance_wrapper(adapter, instance)
# Get the current state and see if we can start the VM
if entry.state in _POWERVM_STARTABLE_STATE:
# Now start the lpar
try:
power.power_on(entry, None)
except pvm_exc.Error as e:
LOG.exception("PowerVM error during power_on.",
instance=instance)
raise exc.InstancePowerOnFailure(reason=six.text_type(e))
def power_on(adapter, instance, opts=None):
"""Powers on a VM.
:param adapter: A pypowervm.adapter.Adapter.
:param instance: The nova instance to power on.
:param opts: (Optional) Additional parameters to the pypowervm power_on
method. See that method's docstring for details.
:return: True if the instance was powered on. False if it was not in a
startable state.
:raises: InstancePowerOnFailure
"""
# Synchronize power-on and power-off ops on a given instance
with lockutils.lock('power_%s' % instance.uuid):
entry = get_instance_wrapper(adapter, instance)
# Get the current state and see if we can start the VM
if entry.state in POWERVM_STARTABLE_STATE:
# Now start the lpar
power.power_on(entry, None, add_parms=opts)
return True
return False
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_power_on_off(self, mock_lpar, mock_job_p, mock_run_job):
"""Performs a simple set of Power On/Off Tests."""
def run_job_mock(**kwargs1):
"""Produce a run_job method that validates the given kwarg values.
E.g. run_job_mock(foo='bar') will produce a mock run_job that
asserts its foo argument is 'bar'.
"""
def run_job(*args, **kwargs2):
for key, val in kwargs1.items():
self.assertEqual(val, kwargs2[key])
return run_job
mock_lpar.adapter = self.adpt
power._power_on_off(mock_lpar, 'PowerOn', '1111')
self.assertEqual(1, mock_run_job.call_count)
self.assertEqual(0, mock_job_p.call_count)
self.assertEqual(1, self.adpt.invalidate_cache_elem.call_count)
mock_run_job.reset_mock()
mock_job_p.reset_mock()
self.adpt.reset_mock()
# Try a power off
power._power_on_off(mock_lpar, 'PowerOff', '1111')
self.assertEqual(1, mock_run_job.call_count)
# Only the operation parameter is appended
self.assertEqual(1, mock_job_p.call_count)
mock_run_job.reset_mock()
mock_job_p.reset_mock()
# Try a power off when the RMC state is active
mock_lpar.rmc_state = pvm_bp.RMCState.ACTIVE
power._power_on_off(mock_lpar, 'PowerOff', '1111')
self.assertEqual(1, mock_run_job.call_count)
# The operation and immediate(no-delay) parameters are appended
self.assertEqual(2, mock_job_p.call_count)
mock_lpar.reset_mock()
mock_run_job.reset_mock()
mock_job_p.reset_mock()
# Try a power off of IBMi
mock_lpar.rmc_state = pvm_bp.RMCState.INACTIVE
mock_lpar.env = pvm_bp.LPARType.OS400
mock_lpar.ref_code = '00000000'
power._power_on_off(mock_lpar, 'PowerOff', '1111')
self.assertEqual(1, mock_run_job.call_count)
# Only the operation parameter is appended
self.assertEqual(1, mock_job_p.call_count)
mock_job_p.assert_called_with('operation', 'osshutdown')
mock_lpar.reset_mock()
mock_run_job.reset_mock()
mock_job_p.reset_mock()
# Try a more complex power off
power._power_on_off(mock_lpar, 'PowerOff', '1111',
force_immediate=True, restart=True, timeout=100)
self.assertEqual(1, mock_run_job.call_count)
self.assertEqual(3, mock_job_p.call_count)
mock_run_job.reset_mock()
mock_job_p.reset_mock()
mock_run_job.side_effect = run_job_mock(synchronous=True)
# Try optional parameters
power.power_on(mock_lpar, '1111',
add_parms={power.BootMode.KEY: power.BootMode.SMS})
self.assertEqual(1, mock_run_job.call_count)
self.assertEqual(1, mock_job_p.call_count)
mock_job_p.assert_called_with(power.BootMode.KEY, power.BootMode.SMS)
mock_run_job.reset_mock()
mock_job_p.reset_mock()
power.power_on(mock_lpar, '1111', add_parms={
pvm_lpar.IPLSrc.KEY: pvm_lpar.IPLSrc.A}, synchronous=True)
self.assertEqual(1, mock_run_job.call_count)
self.assertEqual(1, mock_job_p.call_count)
mock_job_p.assert_called_with(pvm_lpar.IPLSrc.KEY, pvm_lpar.IPLSrc.A)
mock_run_job.reset_mock()
mock_job_p.reset_mock()
mock_run_job.side_effect = run_job_mock(synchronous=False)
power.power_on(mock_lpar, '1111', add_parms={
power.KeylockPos.KEY: power.KeylockPos.MANUAL}, synchronous=False)
self.assertEqual(1, mock_run_job.call_count)
self.assertEqual(1, mock_job_p.call_count)
mock_job_p.assert_called_with(power.KeylockPos.KEY,
power.KeylockPos.MANUAL)
def execute(self, lpar_wrap):
LOG.info(_LI('Powering on instance: %s'), self.instance.name)
power.power_on(lpar_wrap, self.host_uuid, add_parms=self.pwr_opts,
synchronous=self.synchronous)
def execute(self, lpar_wrap):
LOG.info(_LI('Powering on instance: %s'), self.instance.name)
power.power_on(lpar_wrap,
self.host_uuid,
add_parms=self.pwr_opts,
synchronous=self.synchronous)
def execute(self, lpar_wrap):
LOG.info(_LI("Powering on instance: %s"), self.instance.name)
power.power_on(lpar_wrap, self.host_uuid, add_parms=self.pwr_opts)
def execute_impl(self, lpar_wrap):
power.power_on(lpar_wrap, self.host_uuid, add_parms=self.pwr_opts,
synchronous=self.synchronous)
