def test_vios_busy_helper(self, mock_sleep, mock_sess):
# Try with 1 retries
hlp = functools.partial(vios_busy.vios_busy_retry_helper,
max_retries=1)
error = pvmex.Error('yo', response=self.http_error.response)
mock_sess.request.side_effect = error
adpt = adp.Adapter(mock_sess, use_cache=False, helpers=hlp)
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body')
# Test that the request method was called twice and sleep was called
self.assertEqual(mock_sess.request.call_count, 2)
mock_sleep.assert_called_once_with(5 * 1)
# Test with more retries and sleep values
retries = 10
hlp = functools.partial(vios_busy.vios_busy_retry_helper,
max_retries=retries,
delay=15)
mock_sess.reset_mock()
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body',
helpers=hlp)
# Should have tried 'retries' times plus the initial one
self.assertEqual(mock_sess.request.call_count, retries + 1)
# Test with None response
mock_sess.reset_mock()
error = pvmex.Error('yo', response=None)
mock_sess.request.side_effect = error
hlp = functools.partial(vios_busy.vios_busy_retry_helper,
max_retries=1,
delay=15)
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body',
helpers=hlp)
# There should be no retries since the response was None
self.assertEqual(mock_sess.request.call_count, 1)
# Test with a Service Unavailable exception
mock_sess.reset_mock()
hlp = functools.partial(vios_busy.vios_busy_retry_helper,
max_retries=1)
error = pvmex.Error('yo', response=self.http_error_sa.response)
mock_sess.request.side_effect = error
adpt = adp.Adapter(mock_sess, use_cache=False, helpers=hlp)
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body')
self.assertEqual(mock_sess.request.call_count, 2)
def test_get_vm_qp(self, mock_loads):
self.apt.helpers = ['helper1', pvm_log.log_helper, 'helper3']
# Defaults
self.assertEqual(mock_loads.return_value,
vm.get_vm_qp(self.apt, 'lpar_uuid'))
self.apt.read.assert_called_once_with('LogicalPartition',
root_id='lpar_uuid',
suffix_type='quick',
suffix_parm=None)
mock_loads.assert_called_once_with(self.apt.read.return_value.body)
self.apt.read.reset_mock()
mock_loads.reset_mock()
# Specific qprop, no logging errors
self.assertEqual(
mock_loads.return_value,
vm.get_vm_qp(self.apt, 'lpar_uuid', qprop='Prop',
log_errors=False))
self.apt.read.assert_called_once_with('LogicalPartition',
root_id='lpar_uuid',
suffix_type='quick',
suffix_parm='Prop',
helpers=['helper1', 'helper3'])
resp = mock.MagicMock()
resp.status = 404
self.apt.read.side_effect = pvm_exc.HttpError(resp)
self.assertRaises(exception.InstanceNotFound,
vm.get_vm_qp,
self.apt,
'lpar_uuid',
log_errors=False)
self.apt.read.side_effect = pvm_exc.Error("message", response=None)
self.assertRaises(pvm_exc.Error,
vm.get_vm_qp,
self.apt,
'lpar_uuid',
log_errors=False)
resp.status = 500
self.apt.read.side_effect = pvm_exc.Error("message", response=resp)
self.assertRaises(pvm_exc.Error,
vm.get_vm_qp,
self.apt,
'lpar_uuid',
log_errors=False)
def test_upload_new_vdisk_failure(self, mock_create_file):
"""Tests the failure path for uploading of the virtual disks."""
# First need to load in the various test responses.
vg_orig = tju.load_file(UPLOAD_VOL_GRP_ORIG, self.adpt)
vg_post_crt = tju.load_file(UPLOAD_VOL_GRP_NEW_VDISK, self.adpt)
self.adpt.read.return_value = vg_orig
self.adpt.update_by_path.return_value = vg_post_crt
mock_create_file.return_value = self._fake_meta()
self.assertRaises(exc.Error, ts.upload_new_vdisk, self.adpt,
self.v_uuid, self.vg_uuid, None, 'test3', 50)
# Test cleanup failure
self.adpt.delete.side_effect = exc.Error('Something bad')
f_wrap = ts.upload_new_vdisk(self.adpt,
self.v_uuid,
self.vg_uuid,
None,
'test2',
50,
sha_chksum='abc123')
self.adpt.delete.assert_called_once_with(
'File',
service='web',
root_id='6233b070-31cc-4b57-99bd-37f80e845de9')
self.assertIsNotNone(f_wrap)
def test_Error(self):
e = pvmex.Error("test")
self.assertRaises(pvmex.Error, self.raise_helper, e)
try:
raise e
except pvmex.Error as e1:
self.assertEqual(e1.args[0], "test")
def test_get_instance_wrapper(self, mock_get):
resp = mock.Mock(status=404)
mock_get.side_effect = pvm_exc.Error('message', response=resp)
instance = objects.Instance(**powervm.TEST_INSTANCE)
# vm.get_instance_wrapper(self.apt, instance, 'lpar_uuid')
self.assertRaises(exception.InstanceNotFound, vm.get_instance_wrapper,
self.apt, instance, 'lpar_uuid')
def test_create_and_connect_cfg_drive(self):
# With a specified FeedTask
task = tf_stg.CreateAndConnectCfgDrive(
self.adapter, self.instance, 'injected_files',
'network_info', 'stg_ftsk', admin_pass='******')
task.execute('mgmt_cna')
self.mock_cfg_drv.assert_called_once_with(self.adapter)
self.mock_mb.create_cfg_drv_vopt.assert_called_once_with(
self.instance, 'injected_files', 'network_info', 'stg_ftsk',
admin_pass='******', mgmt_cna='mgmt_cna')
# Normal revert
task.revert('mgmt_cna', 'result', 'flow_failures')
self.mock_mb.dlt_vopt.assert_called_once_with(self.instance,
'stg_ftsk')
self.mock_mb.reset_mock()
# Revert when dlt_vopt fails
self.mock_mb.dlt_vopt.side_effect = pvm_exc.Error('fake-exc')
task.revert('mgmt_cna', 'result', 'flow_failures')
self.mock_mb.dlt_vopt.assert_called_once()
self.mock_mb.reset_mock()
# Revert when media builder not created
task.mb = None
task.revert('mgmt_cna', 'result', 'flow_failures')
self.mock_mb.assert_not_called()
def _find_free_vlan(adapter, vswitch_w):
"""Finds a free VLAN on the vswitch specified."""
# A Virtual Network (VNet) will exist for every PowerVM vSwitch / VLAN
# combination in the system. Getting the feed is a quick way to determine
# which VLANs are in use.
vnets = pvm_net.VNet.get(adapter,
parent_type=pvm_ms.System.schema_type,
parent_uuid=adapter.sys_uuid)
# Use that feed to get the VLANs in use, but only get the ones in use for
# the vSwitch passed in.
used_vids = [
x.vlan for x in vnets
if x.associated_switch_uri == vswitch_w.related_href
]
# Walk through the VLAN range, and as soon as one is found that is not in
# use, return it to the user.
for x in range(1, 4094):
if x not in used_vids:
return x
raise exc.Error(
_('Unable to find a valid VLAN for Virtual Switch %s.') %
vswitch_w.name)
def _find_or_create_vswitch(adapter, vs_name, crt_vswitch):
"""Finds (or creates) the appropriate virtual switch.
:param adapter: The pypowervm adapter to perform the update through.
:param vs_name: The name of the virtual switch that this CNA will be
attached to.
:param crt_vswitch: A boolean to indicate that if the vSwitch can not be
found, the system should attempt to create one (with
the default parameters - ex: Veb mode).
"""
vswitch_w = pvm_net.VSwitch.search(adapter,
parent_type=pvm_ms.System,
parent_uuid=adapter.sys_uuid,
one_result=True,
name=vs_name)
if vswitch_w is None:
if crt_vswitch:
vswitch_w = pvm_net.VSwitch.bld(adapter, vs_name)
vswitch_w = vswitch_w.create(parent_type=pvm_ms.System,
parent_uuid=adapter.sys_uuid)
else:
raise exc.Error(
_('Unable to find the Virtual Switch %s on the '
'system.') % vs_name)
return vswitch_w
def test_sample_helper(self, mock_sleep):
helpers = smpl_hlp.sample_retry_helper
fake_resp1 = adp.Response('GET',
'/some/path',
200,
'OK', ['headers'],
body='Some Text HSCL3205 More Text')
self.sess.request.side_effect = pvmex.Error('yo', response=fake_resp1)
adpt = adp.Adapter(self.sess, helpers=helpers)
self.assertRaises(pvmex.Error,
adpt._request,
'method',
'path',
body='the body')
# Test that the request method was called twice and sleep was called
self.assertEqual(self.sess.request.call_count, 2)
mock_sleep.assert_called_once_with(5 * 1)
hlp = functools.partial(smpl_hlp.sample_retry_helper, max_retries=5)
self.sess.reset_mock()
try:
adpt._request('method', 'path', body='the body', helpers=hlp)
except Exception:
# Should have tried 6 times total
self.assertEqual(self.sess.request.call_count, 6)
def test_get_lpars(self):
self.apt.read.return_value = self.resp
lpars = vm.get_lpars(self.apt)
# One of the LPARs is a management partition, so one less than the
# total length should be returned.
self.assertEqual(len(self.resp.feed.entries) - 1, len(lpars))
exc = pvm_exc.Error('Not found', response=FakeAdapterResponse(404))
self.apt.read.side_effect = exc
self.assertRaises(pvm_exc.Error, vm.get_lpars, self.apt)
def test_delete_job(self, mock_status):
wrapper = self._ok_wrapper
mock_status.__get__ = mock.Mock(return_value=jwrap.JobStatus.RUNNING)
with self.assertLogs(jwrap.__name__, 'ERROR'):
self.assertRaises(ex.Error, wrapper.delete_job)
mock_status.__get__.return_value = jwrap.JobStatus.COMPLETED_OK
wrapper.delete_job()
self.adpt.delete.assert_called_with('jobs', wrapper.job_id)
self.adpt.delete.reset_mock()
self.adpt.delete.side_effect = ex.Error('foo')
with self.assertLogs(jwrap.__name__, 'ERROR'):
wrapper.delete_job()
self.adpt.delete.assert_called_with('jobs', wrapper.job_id)
def delete_job(self):
"""Cleans this Job off of the REST server, if it is completed.
:raise JobRequestFailed: if the Job is detected to be running.
"""
if self.job_status == JobStatus.RUNNING:
error = (_("Job %s not deleted. Job is in running state.") %
self.job_id)
LOG.error(error)
raise pvmex.Error(error)
try:
self.adapter.delete(_JOBS, self.job_id)
except pvmex.Error as exc:
LOG.exception(exc)
def test_upload_new_vopt(self, mock_create_file):
"""Tests the uploads of the virtual disks."""
mock_create_file.return_value = self._fake_meta()
v_opt, f_wrap = ts.upload_vopt(self.adpt,
self.v_uuid,
None,
'test2',
f_size=50)
# Test that vopt was 'uploaded'
self.adpt.upload_file.assert_called_with(mock.ANY, None)
self.assertIsNone(f_wrap)
self.assertIsNotNone(v_opt)
self.assertIsInstance(v_opt, stor.VOptMedia)
self.assertEqual('test2', v_opt.media_name)
# Ensure cleanup was called
self.adpt.delete.assert_called_once_with(
'File',
service='web',
root_id='6233b070-31cc-4b57-99bd-37f80e845de9')
# Test cleanup failure
self.adpt.reset_mock()
self.adpt.delete.side_effect = exc.Error('Something bad')
vopt, f_wrap = ts.upload_vopt(self.adpt,
self.v_uuid,
None,
'test2',
f_size=50)
self.adpt.delete.assert_called_once_with(
'File',
service='web',
root_id='6233b070-31cc-4b57-99bd-37f80e845de9')
self.assertIsNotNone(f_wrap)
self.assertIsNotNone(vopt)
self.assertIsInstance(vopt, stor.VOptMedia)
self.assertEqual('test2', v_opt.media_name)
def test_dlt_lpar(self, mock_vterm):
"""Performs a delete LPAR test."""
vm.dlt_lpar(self.apt, '12345')
self.assertEqual(1, self.apt.delete.call_count)
self.assertEqual(1, mock_vterm.call_count)
# Test Failure Path
# build a mock response body with the expected HSCL msg
resp = mock.Mock()
resp.body = 'error msg: HSCL151B more text'
self.apt.delete.side_effect = pvm_exc.Error('Mock Error Message',
response=resp)
# Reset counters
self.apt.reset_mock()
mock_vterm.reset_mock()
self.assertRaises(pvm_exc.Error, vm.dlt_lpar, self.apt, '12345')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(1, self.apt.delete.call_count)
def test_cancel_job(self, mock_monitor, mock_delete, mock_start):
wrapper = self._ok_wrapper
self.adpt.update.side_effect = ex.Error('error')
mock_monitor.return_value = False
wrapper.cancel_job()
self.adpt.update.assert_called_with(None,
None,
root_type='jobs',
root_id=wrapper.job_id,
suffix_type='cancel')
self.assertEqual(0, mock_delete.call_count)
self.adpt.update.reset_mock()
self.adpt.update.side_effect = None
mock_start.reset_mock()
mock_monitor.return_value = False
wrapper.cancel_job()
self.adpt.update.assert_called_with(None,
None,
root_type='jobs',
root_id=wrapper.job_id,
suffix_type='cancel')
self.assertEqual(1, mock_start.call_count)
def test_instance_info(self):
# Test at least one state translation
self.assertEqual(vm._translate_vm_state('running'),
power_state.RUNNING)
inst_info = vm.InstanceInfo(self.apt, 'inst_name', '1234')
# Test the static properties
self.assertEqual(inst_info.id, '1234')
self.assertEqual(inst_info.cpu_time_ns, 0)
# Check that we raise an exception if the instance is gone.
exc = pvm_exc.Error('Not found', response=FakeAdapterResponse(404))
self.apt.read.side_effect = exc
self.assertRaises(exception.InstanceNotFound,
inst_info.__getattribute__, 'state')
# Reset the test inst_info
inst_info = vm.InstanceInfo(self.apt, 'inst_name', '1234')
class FakeResp2(object):
def __init__(self, body):
self.body = '"%s"' % body
resp = FakeResp2('running')
def return_resp(*args, **kwds):
return resp
self.apt.read.side_effect = return_resp
self.assertEqual(inst_info.state, power_state.RUNNING)
# Check the __eq__ method
inst_info1 = vm.InstanceInfo(self.apt, 'inst_name', '1234')
inst_info2 = vm.InstanceInfo(self.apt, 'inst_name', '1234')
self.assertEqual(inst_info1, inst_info2)
inst_info2 = vm.InstanceInfo(self.apt, 'name', '4321')
self.assertNotEqual(inst_info1, inst_info2)
def crt_vdisk(adapter, v_uuid, vol_grp_uuid, d_name, d_size_gb):
"""Creates a new Virtual Disk in the specified volume group.
:param adapter: The pypowervm.adapter.Adapter through which to request the
change.
:param v_uuid: The UUID of the Virtual I/O Server that will host the disk.
:param vol_grp_uuid: The volume group that will host the new Virtual Disk.
:param d_name: The name that should be given to the disk on the Virtual
I/O Server that will contain the file.
:param d_size_gb: The size of the disk in GB.
:return: VDisk ElementWrapper representing the new VirtualDisk from the
server response (i.e. UDID will be populated).
:raise exc.Error: If the server response from attempting to add the VDisk
does not contain the new VDisk.
"""
# Get the existing volume group
vol_grp_data = adapter.read(vios.VIOS.schema_type, v_uuid,
stor.VG.schema_type, vol_grp_uuid)
vol_grp = stor.VG.wrap(vol_grp_data.entry)
new_vdisk = stor.VDisk.bld(adapter, d_name, d_size_gb)
# Append it to the list.
vol_grp.virtual_disks.append(new_vdisk)
# Now perform an update on the adapter.
vol_grp = vol_grp.update()
# The new Virtual Disk should be created. Find the one we created.
for vdisk in vol_grp.virtual_disks:
if vdisk.name == d_name:
return vdisk
# This should never occur since the update went through without error,
# but adding just in case as we don't want to create the file meta
# without a backing disk.
raise exc.Error(_("Unable to locate new vDisk on file upload."))
def test_dlt_lpar(self, mock_vterm):
"""Performs a delete LPAR test."""
vm.dlt_lpar(self.apt, '12345')
self.assertEqual(1, self.apt.delete.call_count)
self.assertEqual(1, mock_vterm.call_count)
# Test Failure Path
# build a mock response body with the expected HSCL msg
resp = mock.Mock()
resp.body = 'error msg: HSCL151B more text'
self.apt.delete.side_effect = pvm_exc.Error(
'Mock Error Message', response=resp)
# Reset counters
self.apt.reset_mock()
mock_vterm.reset_mock()
self.assertRaises(pvm_exc.Error,
vm.dlt_lpar, self.apt, '12345')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(1, self.apt.delete.call_count)
# Test HttpError 404
self.apt.reset_mock()
mock_vterm.reset_mock()
resp.status = 404
self.apt.delete.side_effect = pvm_exc.HttpError(resp=resp)
vm.dlt_lpar(self.apt, '54321')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(1, self.apt.delete.call_count)
# Test Other HttpError
self.apt.reset_mock()
mock_vterm.reset_mock()
resp.status = 111
self.apt.delete.side_effect = pvm_exc.HttpError(resp=resp)
self.assertRaises(pvm_exc.HttpError, vm.dlt_lpar, self.apt, '11111')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(1, self.apt.delete.call_count)
# Test HttpError 404 closing vterm
self.apt.reset_mock()
mock_vterm.reset_mock()
resp.status = 404
mock_vterm.side_effect = pvm_exc.HttpError(resp=resp)
vm.dlt_lpar(self.apt, '55555')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(0, self.apt.delete.call_count)
# Test Other HttpError closing vterm
self.apt.reset_mock()
mock_vterm.reset_mock()
resp.status = 111
mock_vterm.side_effect = pvm_exc.HttpError(resp=resp)
self.assertRaises(pvm_exc.HttpError, vm.dlt_lpar, self.apt, '33333')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(0, self.apt.delete.call_count)
def test_get_instance_wrapper(self, mock_lpar):
resp = mock.Mock(status=404)
mock_lpar.get.side_effect = pvm_exc.Error('message', response=resp)
# vm.get_instance_wrapper(self.apt, instance, 'lpar_uuid')
self.assertRaises(exception.InstanceNotFound, vm.get_instance_wrapper,
self.apt, self.inst)
def test_dlt_lpar(self, mock_vterm):
"""Performs a delete LPAR test."""
vm.delete_lpar(self.apt, 'inst')
self.get_pvm_uuid.assert_called_once_with('inst')
self.apt.delete.assert_called_once_with(
pvm_lpar.LPAR.schema_type, root_id=self.get_pvm_uuid.return_value)
self.assertEqual(1, mock_vterm.call_count)
# Test Failure Path
# build a mock response body with the expected HSCL msg
resp = mock.Mock()
resp.body = 'error msg: HSCL151B more text'
self.apt.delete.side_effect = pvm_exc.Error('Mock Error Message',
response=resp)
# Reset counters
self.apt.reset_mock()
mock_vterm.reset_mock()
self.assertRaises(pvm_exc.Error, vm.delete_lpar, self.apt, 'inst')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(1, self.apt.delete.call_count)
self.apt.reset_mock()
mock_vterm.reset_mock()
# Test HttpError 404
resp.status = 404
self.apt.delete.side_effect = pvm_exc.HttpError(resp=resp)
vm.delete_lpar(self.apt, 'inst')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(1, self.apt.delete.call_count)
self.apt.reset_mock()
mock_vterm.reset_mock()
# Test Other HttpError
resp.status = 111
self.apt.delete.side_effect = pvm_exc.HttpError(resp=resp)
self.assertRaises(pvm_exc.HttpError, vm.delete_lpar, self.apt, 'inst')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(1, self.apt.delete.call_count)
self.apt.reset_mock()
mock_vterm.reset_mock()
# Test HttpError 404 closing vterm
resp.status = 404
mock_vterm.side_effect = pvm_exc.HttpError(resp=resp)
vm.delete_lpar(self.apt, 'inst')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(0, self.apt.delete.call_count)
self.apt.reset_mock()
mock_vterm.reset_mock()
# Test Other HttpError closing vterm
resp.status = 111
mock_vterm.side_effect = pvm_exc.HttpError(resp=resp)
self.assertRaises(pvm_exc.HttpError, vm.delete_lpar, self.apt, 'inst')
self.assertEqual(1, mock_vterm.call_count)
self.assertEqual(0, self.apt.delete.call_count)
def crt_cna(adapter,
host_uuid,
lpar_uuid,
pvid,
vswitch=network.VSW_DEFAULT_VSWITCH,
crt_vswitch=False,
slot_num=None,
mac_addr=None,
addl_vlans=None):
"""Puts a new ClientNetworkAdapter on a given LPAR.
This will update the LPAR and put a new CNA on it. If the LPAR is active
can only perform if there is an active RMC connection. If the LPAR is
powered off, then it will update it offline.
:param adapter: The pypowervm adapter to perform the update through.
:param host_uuid: The host UUID that the CNA will be put on.
:param lpar_uuid: The lpar UUID to update.
:param pvid: The primary VLAN ID.
:param vswitch: The name of the virtual switch that this CNA will be
attached to.
:param crt_vswitch: A boolean to indicate that if the vSwitch can not be
found, the system should attempt to create one (with
the default parameters - ex: Veb mode).
:param slot_num: Optional slot number to use for the CNA. If not
specified, will utilize the next available slot on the
LPAR.
:param mac_addr: The optional mac address. If not specified, one will be
auto generated.
:param addl_vlans: Optional list of (up to 18) additional VLANs. Can be
a list of Ints or Strings (that parse down to ints).
:return: The CNA Wrapper that was created.
"""
# Join the additional VLANs
addl_tagged_vlans = None
if addl_vlans is not None:
addl_tagged_vlans = " ".join(addl_vlans)
# Sanitize the pvid
pvid = str(pvid)
# Find the appropriate virtual switch.
vswitch_w = None
vswitch_resp = adapter.read(ms.System.schema_type,
root_id=host_uuid,
child_type=network.VSwitch.schema_type)
vswitch_wraps = network.VSwitch.wrap(vswitch_resp)
for vs_w in vswitch_wraps:
if vs_w.name == vswitch:
vswitch_w = vs_w
break
if vswitch_w is None:
if crt_vswitch:
vswitch_w = network.VSwitch.bld(adapter, vswitch)
vswitch_w = vswitch_w.create(parent_type=ms.System,
parent_uuid=host_uuid)
else:
raise exc.Error(
_('Unable to find the Virtual Switch %s on the '
'system.') % vswitch)
# Find the virtual network. Ensures that the system is ready for this.
if adapter.traits.vnet_aware:
_find_or_create_vnet(adapter, host_uuid, pvid, vswitch_w)
# Build and create the CNA
net_adpt = network.CNA.bld(adapter,
pvid,
vswitch_w.related_href,
slot_num=slot_num,
mac_addr=mac_addr,
addl_tagged_vlans=addl_tagged_vlans)
return net_adpt.create(parent_type=lpar.LPAR, parent_uuid=lpar_uuid)
def test_dlt_lpar(self, mock_vterm, mock_pvm_uuid):
"""Performs a delete LPAR test."""
mock_pvm_uuid.return_value = 'pvm_uuid'
vm.delete_lpar(self.apt, 'inst')
mock_pvm_uuid.assert_called_once_with('inst')
mock_vterm.assert_called_once_with(self.apt, 'pvm_uuid')
self.apt.delete.assert_called_once_with('LogicalPartition',
root_id='pvm_uuid')
# Test Failure Path
# build a mock response body with the expected HSCL msg
resp = mock.Mock(body='error msg: HSCL151B more text')
self.apt.delete.side_effect = pvm_exc.Error('Mock Error Message',
response=resp)
# Reset counters
mock_pvm_uuid.reset_mock()
self.apt.reset_mock()
mock_vterm.reset_mock()
self.assertRaises(pvm_exc.Error, vm.delete_lpar, self.apt, 'inst')
mock_pvm_uuid.assert_called_once_with('inst')
mock_vterm.assert_called_once_with(self.apt, 'pvm_uuid')
self.apt.delete.assert_called_once_with('LogicalPartition',
root_id='pvm_uuid')
# Test HttpNotFound - exception not raised
mock_pvm_uuid.reset_mock()
self.apt.reset_mock()
mock_vterm.reset_mock()
resp.status = 404
self.apt.delete.side_effect = pvm_exc.HttpNotFound(resp=resp)
vm.delete_lpar(self.apt, 'inst')
mock_pvm_uuid.assert_called_once_with('inst')
mock_vterm.assert_called_once_with(self.apt, 'pvm_uuid')
self.apt.delete.assert_called_once_with('LogicalPartition',
root_id='pvm_uuid')
# Test Other HttpError
mock_pvm_uuid.reset_mock()
self.apt.reset_mock()
mock_vterm.reset_mock()
resp.status = 111
self.apt.delete.side_effect = pvm_exc.HttpError(resp=resp)
self.assertRaises(pvm_exc.HttpError, vm.delete_lpar, self.apt, 'inst')
mock_pvm_uuid.assert_called_once_with('inst')
mock_vterm.assert_called_once_with(self.apt, 'pvm_uuid')
self.apt.delete.assert_called_once_with('LogicalPartition',
root_id='pvm_uuid')
# Test HttpNotFound closing vterm
mock_pvm_uuid.reset_mock()
self.apt.reset_mock()
mock_vterm.reset_mock()
resp.status = 404
mock_vterm.side_effect = pvm_exc.HttpNotFound(resp=resp)
vm.delete_lpar(self.apt, 'inst')
mock_pvm_uuid.assert_called_once_with('inst')
mock_vterm.assert_called_once_with(self.apt, 'pvm_uuid')
self.apt.delete.assert_not_called()
# Test Other HttpError closing vterm
mock_pvm_uuid.reset_mock()
self.apt.reset_mock()
mock_vterm.reset_mock()
resp.status = 111
mock_vterm.side_effect = pvm_exc.HttpError(resp=resp)
self.assertRaises(pvm_exc.HttpError, vm.delete_lpar, self.apt, 'inst')
mock_pvm_uuid.assert_called_once_with('inst')
mock_vterm.assert_called_once_with(self.apt, 'pvm_uuid')
self.apt.delete.assert_not_called()
def test_get_vm_qp(self):
def adapter_read(root_type,
root_id=None,
suffix_type=None,
suffix_parm=None,
helpers=None):
json_str = (u'{"IsVirtualServiceAttentionLEDOn":"false","Migration'
u'State":"Not_Migrating","CurrentProcessingUnits":0.1,'
u'"ProgressState":null,"PartitionType":"AIX/Linux","Pa'
u'rtitionID":1,"AllocatedVirtualProcessors":1,"Partiti'
u'onState":"not activated","RemoteRestartState":"Inval'
u'id","OperatingSystemVersion":"Unknown","AssociatedMa'
u'nagedSystem":"https://9.1.2.3:12443/rest/api/uom/Man'
u'agedSystem/98498bed-c78a-3a4f-b90a-4b715418fcb6","RM'
u'CState":"inactive","PowerManagementMode":null,"Parti'
u'tionName":"lpar-1-06674231-lpar","HasDedicatedProces'
u'sors":"false","ResourceMonitoringIPAddress":null,"Re'
u'ferenceCode":"00000000","CurrentProcessors":null,"Cu'
u'rrentMemory":512,"SharingMode":"uncapped"}')
self.assertEqual('LogicalPartition', root_type)
self.assertEqual('lpar_uuid', root_id)
self.assertEqual('quick', suffix_type)
resp = mock.MagicMock()
if suffix_parm is None:
resp.body = json_str
elif suffix_parm == 'PartitionID':
resp.body = '1'
elif suffix_parm == 'CurrentProcessingUnits':
resp.body = '0.1'
elif suffix_parm == 'AssociatedManagedSystem':
# The double quotes are important
resp.body = ('"https://9.1.2.3:12443/rest/api/uom/ManagedSyste'
'm/98498bed-c78a-3a4f-b90a-4b715418fcb6"')
else:
self.fail('Unhandled quick property key %s' % suffix_parm)
return resp
def adpt_read_no_log(*args, **kwds):
helpers = kwds['helpers']
try:
helpers.index(pvm_log.log_helper)
except ValueError:
# Successful path since the logger shouldn't be there
return adapter_read(*args, **kwds)
self.fail('Log helper was found when it should not be')
ms_href = ('https://9.1.2.3:12443/rest/api/uom/ManagedSystem/98498bed-'
'c78a-3a4f-b90a-4b715418fcb6')
self.apt.read.side_effect = adapter_read
self.assertEqual(1, vm.get_vm_id(self.apt, 'lpar_uuid'))
self.assertEqual(
ms_href,
vm.get_vm_qp(self.apt, 'lpar_uuid', 'AssociatedManagedSystem'))
self.apt.read.side_effect = adpt_read_no_log
self.assertEqual(
0.1,
vm.get_vm_qp(self.apt,
'lpar_uuid',
'CurrentProcessingUnits',
log_errors=False))
qp_dict = vm.get_vm_qp(self.apt, 'lpar_uuid', log_errors=False)
self.assertEqual(ms_href, qp_dict['AssociatedManagedSystem'])
self.assertEqual(1, qp_dict['PartitionID'])
self.assertEqual(0.1, qp_dict['CurrentProcessingUnits'])
resp = mock.MagicMock()
resp.status = 404
self.apt.read.side_effect = pvm_exc.HttpNotFound(resp)
self.assertRaises(exception.InstanceNotFound,
vm.get_vm_qp,
self.apt,
'lpar_uuid',
log_errors=False)
self.apt.read.side_effect = pvm_exc.Error("message", response=None)
self.assertRaises(pvm_exc.Error,
vm.get_vm_qp,
self.apt,
'lpar_uuid',
log_errors=False)
resp.status = 500
self.apt.read.side_effect = pvm_exc.Error("message", response=resp)
self.assertRaises(pvm_exc.Error,
vm.get_vm_qp,
self.apt,
'lpar_uuid',
log_errors=False)
