def setUp(self):
super(TestVSCSIAdapter, self).setUp()
self.adpt = self.useFixture(pvm_fx.AdapterFx()).adpt
self.wtsk = mock.create_autospec(pvm_tx.WrapperTask, instance=True)
self.ftsk = mock.create_autospec(pvm_tx.FeedTask, instance=True)
self.ftsk.configure_mock(wrapper_tasks={'vios_uuid': self.wtsk})
@mock.patch('nova.virt.powervm.vm.get_pvm_uuid')
def init_vol_adpt(mock_pvm_uuid):
con_info = {
'serial': 'id',
'data': {
'initiator_target_map': {
I_WWPN_1: ['t1'],
I_WWPN_2: ['t2', 't3']
},
'target_lun': '1',
'volume_id': 'a_volume_identifier',
},
}
mock_inst = mock.MagicMock()
mock_pvm_uuid.return_value = '1234'
return fcvscsi.FCVscsiVolumeAdapter(
self.adpt, mock_inst, con_info, stg_ftsk=self.ftsk)
self.vol_drv = init_vol_adpt()
def setUp(self):
super(TestNetwork, self).setUp()
self.flags(host='host1')
self.apt = self.useFixture(pvm_fx.AdapterFx()).adpt
self.mock_lpar_wrap = mock.MagicMock()
self.mock_lpar_wrap.can_modify_io.return_value = True, None
def setUp(self):
super(TestLocalDisk, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx()).adpt
# Set up mock for internal VIOS.get()s
self.mock_vios_get = self.useFixture(fixtures.MockPatch(
'pypowervm.wrappers.virtual_io_server.VIOS.get')).mock
# The mock VIOS needs to have scsi_mappings as a list. Internals are
# set by individual test cases as needed.
smaps = [mock.Mock()]
self.vio_to_vg = mock.Mock(spec=pvm_vios.VIOS, scsi_mappings=smaps)
# For our tests, we want find_maps to return the mocked list of scsi
# mappings in our mocked VIOS.
self.mock_find_maps = self.useFixture(fixtures.MockPatch(
'pypowervm.tasks.scsi_mapper.find_maps')).mock
self.mock_find_maps.return_value = smaps
# Set up for the mocks for get_ls
self.mock_vg_uuid = self.useFixture(fixtures.MockPatch(
'pypowervm.tasks.storage.find_vg')).mock
self.vg_uuid = 'd5065c2c-ac43-3fa6-af32-ea84a3960291'
self.mock_vg_uuid.return_value = ('vios_uuid', self.vg_uuid)
# Return the mgmt uuid
self.mgmt_uuid = self.useFixture(fixtures.MockPatch(
'nova_powervm.virt.powervm.mgmt.mgmt_uuid')).mock
self.mgmt_uuid.return_value = 'mp_uuid'
self.flags(volume_group_name='rootvg', group='powervm')
def setUp(self):
super(TestLPARBuilder, self).setUp()
self.sections = xml_sections.load_xml_sections(LPAR_BLDR_DATA)
self.adpt = self.useFixture(fx.AdapterFx()).adpt
def _bld_mgd_sys(proc_units, mem_reg, srr, pcm):
# Build a fake managed system wrapper
mngd_sys = mock.Mock()
type(mngd_sys).proc_units_avail = (
mock.PropertyMock(return_value=proc_units))
type(mngd_sys).memory_region_size = (
mock.PropertyMock(return_value=mem_reg))
capabilities = {
'simplified_remote_restart_capable': srr,
'ibmi_restrictedio_capable': True
}
mngd_sys.get_capabilities.return_value = capabilities
type(mngd_sys).proc_compat_modes = (
mock.PropertyMock(return_value=pcm))
return mngd_sys
self.mngd_sys = _bld_mgd_sys(20.0, 128, True, bp.LPARCompat.ALL_VALUES)
self.mngd_sys_no_srr = _bld_mgd_sys(20.0, 128, False, ['POWER6'])
self.stdz_sys1 = lpar_bldr.DefaultStandardize(self.mngd_sys)
self.stdz_sys2 = lpar_bldr.DefaultStandardize(self.mngd_sys_no_srr)
def setUp(self):
super(TestVNCSocketListener, self).setUp()
self.adpt = self.useFixture(
fx.AdapterFx(traits=fx.LocalPVMTraits)).adpt
self.srv = vterm._VNCSocketListener(self.adpt,
'5901',
'1.2.3.4',
True,
remote_ips=['1.2.3.5'])
self.srv_no_verify = vterm._VNCSocketListener(self.adpt,
'5800',
'1.2.3.4',
False,
remote_ips=['1.2.3.5'])
self.srv_6 = vterm._VNCSocketListener(self.adpt,
'5901',
'fe80:1234',
True,
remote_ips=['fe80:7890'])
self.rptr = vterm._VNCRepeaterServer(self.adpt, 'uuid', '5800')
vterm._VNC_LOCAL_PORT_TO_REPEATER['5800'] = self.rptr
vterm._VNC_PATH_TO_UUID['path'] = 'uuid'
vterm._VNC_PATH_TO_UUID['test'] = 'uuid'
vterm._VNC_UUID_TO_LOCAL_PORT['uuid'] = '5800'
def setUp(self):
super(TestSCSIMapper, self).setUp()
# Common Adapter
self.adpt = self.useFixture(fx.AdapterFx()).adpt
# Don't really sleep
self.useFixture(fx.SleepFx())
# Fake URI
mock_crt_href_p = mock.patch('pypowervm.wrappers.virtual_io_server.'
'VSCSIMapping.crt_related_href')
self.mock_crt_href = mock_crt_href_p.start()
self.addCleanup(mock_crt_href_p.stop)
href = ('https://9.1.2.3:12443/rest/api/uom/ManagedSystem/'
'c5d782c7-44e4-3086-ad15-b16fb039d63b/LogicalPartition/' +
LPAR_UUID)
self.mock_crt_href.return_value = href
# Mock the delay function, by overriding the sleep
mock_delay_p = mock.patch('time.sleep')
self.mock_delay = mock_delay_p.start()
self.addCleanup(mock_delay_p.stop)
self.v1resp = tju.load_file(VIO_MULTI_MAP_FILE, self.adpt)
self.v1wrap = pvm_vios.VIOS.wrap(self.v1resp)
self.v2resp = tju.load_file(VIO_MULTI_MAP_FILE2, self.adpt)
self.v2wrap = pvm_vios.VIOS.wrap(self.v2resp)
def setUp(self):
super(TestVifOvsDriver, self).setUp()
self.adpt = self.useFixture(
pvm_fx.AdapterFx(traits=pvm_fx.LocalPVMTraits)).adpt
self.inst = mock.MagicMock(uuid='inst_uuid')
self.drv = vif.PvmOvsVifDriver(self.adpt, 'host_uuid', self.inst)
def setUp(self):
super(TestScrub3, self).setUp()
self.adpt = self.useFixture(fx.AdapterFx()).adpt
self.vio_feed = [vios.VIOS.wrap(tju.load_file(VIOS_ENTRY2, self.adpt))]
self.txfx = self.useFixture(fx.FeedTaskFx(self.vio_feed))
self.logfx = self.useFixture(fx.LoggingFx())
self.ftsk = tx.FeedTask('scrub', self.vio_feed)
def setUp(self):
super(TestSriov, self).setUp()
self.adpt = self.useFixture(fx.AdapterFx()).adpt
self.fake_sriovs = [
good_sriov(1, [
fake_pport(1, pid, lps, cap)
for pid, lps, cap in ((11, 0, 0.95), (12, 9, 0.0),
(13, 5, 0.03), (14, 20, 0.987))
]), ded_sriov,
good_sriov(2, [fake_pport(2, 21, 19, 0.3)]), down_sriov,
good_sriov(3, []),
good_sriov(4, [
fake_pport(4, pid, 1, cap)
for pid, cap in ((41, 0.02), (42, 0.01))
]),
good_sriov(5, [
fake_pport(5, pid, lps, cap)
for pid, lps, cap in ((51, 17, 0.49), (52, 3, 0.0),
(53, 50, 0.05), (54, 11, 0.0),
(55, 6, 0.4), (56, 13, 0.1),
(57, 0, 0.15), (58, 7, 1.0))
])
]
# Mark link status down on 5/55.
self.fake_sriovs[6].phys_ports[4].link_status = False
def setUp(self):
super(TestLULinkedClone, self).setUp()
self.adpt = self.useFixture(fx.AdapterFx()).adpt
self.adpt.update_by_path = _mock_update_by_path
self.adpt.extend_path = lambda x, xag: x
self.ssp = stor.SSP.bld(self.adpt, 'ssp1', [])
# img_lu1 not cloned
self.img_lu1 = self._mk_img_lu(1)
self.ssp.logical_units.append(self.img_lu1)
# img_lu2 has two clones
self.img_lu2 = self._mk_img_lu(2)
self.ssp.logical_units.append(self.img_lu2)
self.dsk_lu3 = self._mk_dsk_lu(3, 2)
self.ssp.logical_units.append(self.dsk_lu3)
self.dsk_lu4 = self._mk_dsk_lu(4, 2)
self.ssp.logical_units.append(self.dsk_lu4)
# img_lu5 has one clone
self.img_lu5 = self._mk_img_lu(5)
self.ssp.logical_units.append(self.img_lu5)
self.dsk_lu6 = self._mk_dsk_lu(6, 5)
self.ssp.logical_units.append(self.dsk_lu6)
self.dsk_lu_orphan = self._mk_dsk_lu(7, None)
self.ssp.logical_units.append(self.dsk_lu_orphan)
self.ssp.entry.properties = {
'links': {
'SELF': ['/rest/api/uom/SharedStoragePool/123']
}
}
self.ssp._etag = 'before'
def setUp(self):
super(TestRMSTorage, self).setUp()
self.adptfx = self.useFixture(fx.AdapterFx(traits=fx.RemotePVMTraits))
self.adpt = self.adptfx.adpt
self.v_uuid = '14B854F7-42CE-4FF0-BD57-1D117054E701'
self.vg_uuid = 'b6bdbf1f-eddf-3c81-8801-9859eb6fedcb'
self.vg_resp = tju.load_file(UPLOAD_VOL_GRP_NEW_VDISK, self.adpt)
def setUp(self):
super(TestWrapper, self).setUp()
self.adptfx = None
self.adpt = None
adptfx_args = self.mock_adapter_fx_args or {}
self.adptfx = self.useFixture(fx.AdapterFx(**adptfx_args))
self.adpt = self.adptfx.adpt
# Load the file just once...
if self.__class__._pvmfile is None:
self.__class__._pvmfile = pvmhttp.PVMFile(self.file)
# ...but reconstruct the PVMResp every time
self.resp = pvmhttp.PVMResp(pvmfile=self.__class__._pvmfile,
adapter=self.adpt).get_response()
# Some wrappers don't support etag. Subclasses testing those wrappers
# should not be using self.entries, so ignore.
try:
self.entries = self.wrapper_class_to_test.wrap(self.resp)
except TypeError:
pass
if self.resp.feed:
self.dwrap = self.wrapper_class_to_test.wrap(
self.resp.feed.entries[0])
else:
self.dwrap = self.wrapper_class_to_test.wrap(self.resp.entry)
def setUp(self):
super(TestConfigDrivePowerVM, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx()).adpt
self.validate_vopt = self.useFixture(fixtures.MockPatch(
'pypowervm.tasks.vopt.validate_vopt_repo_exists')).mock
self.validate_vopt.return_value = None, None
def setUp(self):
super(TestVios, self).setUp()
self.adpt = self.useFixture(pvm_fx.AdapterFx()).adpt
def resp(file_name):
return pvmhttp.load_pvm_resp(file_name).get_response()
self.vios_feed_resp = resp(VIOS_FEED)
def setUp(self):
super(TestPartition, self).setUp()
self.adpt = self.useFixture(
fx.AdapterFx(traits=fx.RemotePVMTraits)).adpt
self.mgmt_vio = tju.load_file(VIO_FEED_WITH_MGMT, self.adpt)
self.mgmt_lpar = tju.load_file(LPAR_FEED_WITH_MGMT, self.adpt)
self.nomgmt_vio = tju.load_file(VIO_FEED_NO_MGMT, self.adpt)
self.nomgmt_lpar = tju.load_file(LPAR_FEED_NO_MGMT, self.adpt)
def setUp(self):
super(TestVOpt, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx()).adpt
# Wipe out the static variables, so that the re-validate is called
vopt._cur_vios_uuid = None
vopt._cur_vg_uuid = None
def setUp(self, traits_type):
super(TestIBMi, self).setUp()
self.traits = traits_type
self.apt = self.useFixture(pvm_fx.AdapterFx(
traits=self.traits)).adpt
self.vio_feed = pvm_vios.VIOS.wrap(
tju.load_file(VIOS_FEED, self.apt))
self.vioslist = [self.vio_feed[0], self.vio_feed[1]]
def setUp(self):
super(TestNPIVAdapter, self).setUp()
self.adpt = self.useFixture(pvm_fx.AdapterFx()).adpt
def resp(file_name):
return pvmhttp.load_pvm_resp(file_name,
adapter=self.adpt).get_response()
self.vios_feed_resp = resp(VIOS_FEED)
self.wwpn1 = '21000024FF649104'
self.wwpn2 = '21000024FF649107'
self.vios_uuid = '3443DB77-AED1-47ED-9AA5-3DB9C6CF7089'
self.slot_mgr = mock.Mock()
# Set up the transaction manager
feed = pvm_vios.VIOS.wrap(self.vios_feed_resp)
self.ft_fx = pvm_fx.FeedTaskFx(feed)
self.useFixture(self.ft_fx)
# Set up the mocks for the internal volume driver
name = 'nova_powervm.virt.powervm.volume.npiv.NPIVVolumeAdapter.'
self.mock_port_count_p = mock.patch(name + '_ports_per_fabric')
self.mock_port_count = self.mock_port_count_p.start()
self.mock_port_count.return_value = 1
self.mock_fabric_names_p = mock.patch(name + '_fabric_names')
self.mock_fabric_names = self.mock_fabric_names_p.start()
self.mock_fabric_names.return_value = ['A']
self.mock_fabric_ports_p = mock.patch(name + '_fabric_ports')
self.mock_fabric_ports = self.mock_fabric_ports_p.start()
self.mock_fabric_ports.return_value = [self.wwpn1, self.wwpn2]
@mock.patch('pypowervm.wrappers.virtual_io_server.VIOS.getter')
@mock.patch('nova_powervm.virt.powervm.vm.get_pvm_uuid')
def init_vol_adpt(mock_pvm_uuid, mock_getter):
con_info = {
'serial': 'id',
'data': {
'initiator_target_map': {
'i1': ['t1'],
'i2': ['t2', 't3']
},
'target_lun': '1'
}
}
mock_inst = mock.MagicMock()
mock_pvm_uuid.return_value = '1234'
# The getter can just return the VIOS values (to remove a read
# that would otherwise need to be mocked).
mock_getter.return_value = feed
return npiv.NPIVVolumeAdapter(self.adpt, 'host_uuid', mock_inst,
con_info)
self.vol_drv = init_vol_adpt()
def setUp(self):
super(TestMgmt, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx()).adpt
lpar_http = pvmhttp.load_pvm_resp(LPAR_HTTPRESP_FILE, adapter=self.apt)
self.assertNotEqual(lpar_http, None,
"Could not load %s " % LPAR_HTTPRESP_FILE)
self.resp = lpar_http.response
def setUp(self):
super(TestMigration, self).setUp()
self.adpt = self.useFixture(fx.AdapterFx()).adpt
mock_resp = mock.MagicMock()
mock_resp.entry = ent.Entry({}, ent.Element('Dummy', self.adpt),
self.adpt)
self.adpt.read.return_value = mock_resp
self.lpar_w = mock.MagicMock()
self.lpar_w.adapter = self.adpt
self.lpar_w.uuid = '1234'
def setUp(self):
super(TestLPARBuilder, self).setUp()
self.sections = xml_sections.load_xml_sections(LPAR_BLDR_DATA)
self.adpt = self.useFixture(fx.AdapterFx()).adpt
def _bld_mgd_sys(proc_units,
mem_reg,
srr,
pcm,
ame,
ppt,
affinity=False):
# Build a fake managed system wrapper
mngd_sys = mock.Mock()
type(mngd_sys).proc_units_avail = (mock.PropertyMock(
return_value=proc_units))
type(mngd_sys).memory_region_size = (mock.PropertyMock(
return_value=mem_reg))
def get_cap(cap):
capabilities = {
'simplified_remote_restart_capable': srr,
'ibmi_restrictedio_capable': True,
'active_memory_expansion_capable': ame,
'physical_page_table_ratio_capable': ppt,
'affinity_check_capable': affinity
}
return capabilities[cap]
mngd_sys.get_capability.side_effect = get_cap
type(mngd_sys).proc_compat_modes = (mock.PropertyMock(
return_value=pcm))
return mngd_sys
self.mngd_sys = _bld_mgd_sys(20.0, 128, True, bp.LPARCompat.ALL_VALUES,
False, False)
self.mngd_sys_no_srr = _bld_mgd_sys(20.0, 128, False, ['POWER6'],
False, False)
self.mngd_sys_ame = _bld_mgd_sys(20.0, 128, True,
bp.LPARCompat.ALL_VALUES, True, False)
self.mngd_sys_ppt = _bld_mgd_sys(20.0, 128, True,
bp.LPARCompat.ALL_VALUES, False, True)
self.mngd_sys_affinity = _bld_mgd_sys(20.0,
128,
True,
bp.LPARCompat.ALL_VALUES,
False,
True,
affinity=True)
self.stdz_sys1 = lpar_bldr.DefaultStandardize(self.mngd_sys)
self.stdz_sys2 = lpar_bldr.DefaultStandardize(self.mngd_sys_no_srr)
self.stdz_sys3 = lpar_bldr.DefaultStandardize(self.mngd_sys_ame)
self.stdz_sys4 = lpar_bldr.DefaultStandardize(self.mngd_sys_ppt)
self.stdz_sys5 = lpar_bldr.DefaultStandardize(self.mngd_sys_affinity)
def setUp(self):
super(TestVM, self).setUp()
self.apt = self.useFixture(
pvm_fx.AdapterFx(traits=pvm_fx.LocalPVMTraits)).adpt
self.apt.helpers = [pvm_log.log_helper]
lpar_http = pvmhttp.load_pvm_resp(LPAR_HTTPRESP_FILE, adapter=self.apt)
self.assertNotEqual(lpar_http, None,
"Could not load %s " % LPAR_HTTPRESP_FILE)
self.resp = lpar_http.response
def setUp(self):
super(SEAAgentTest, self).setUp()
self.adpt = self.useFixture(
pvm_fx.AdapterFx(traits=pvm_fx.LocalPVMTraits)).adpt
with mock.patch('networking_powervm.plugins.ibm.agent.powervm.utils.'
'get_host_uuid'),\
mock.patch('networking_powervm.plugins.ibm.agent.'
'powervm.utils.parse_sea_mappings'):
self.agent = sea_agent.SharedEthernetNeutronAgent()
self.agent.adapter = self.adpt
def setUp(self):
super(TestISCSIAdapter, self).setUp()
self.adpt = self.useFixture(pvm_fx.AdapterFx()).adpt
self.vios_feed_resp = load_file(VIOS_FEED)
self.feed = pvm_vios.VIOS.wrap(self.vios_feed_resp)
self.ft_fx = pvm_fx.FeedTaskFx(self.feed)
self.useFixture(self.ft_fx)
self.adpt.read.return_value = self.vios_feed_resp
@mock.patch('pypowervm.wrappers.virtual_io_server.VIOS', autospec=True)
@mock.patch('nova_powervm.virt.powervm.vm.get_pvm_uuid')
@mock.patch('pypowervm.tasks.partition.get_mgmt_partition',
autospec=True)
@mock.patch('pypowervm.tasks.hdisk.discover_iscsi_initiator',
autospec=True)
def init_vol_adpt(mock_initiator, mock_mgmt_part, mock_pvm_uuid,
mock_vios):
self.trans_type = 'iscsi'
self.iqn = 'iqn.2016-08.bar.foo:target'
self.lun = '1'
self.host_ip = '10.0.0.1'
self.user = '******'
self.password = '******'
self.serial = 'f042c68a-c5a5-476a-ba34-2f6d43f4226c'
con_info = {
'serial': self.serial,
'driver_volume_type': self.trans_type,
'data': {
'target_iqn': self.iqn,
'target_lun': self.lun,
'target_portal': self.host_ip,
'auth_username': self.user,
'auth_password': self.password
},
}
mock_inst = mock.MagicMock()
mock_pvm_uuid.return_value = '1234'
mock_initiator.return_value = 'initiatior iqn'
# The getter can just return the VIOS values (to remove a read
# that would otherwise need to be mocked).
mock_vios.getter.return_value = self.feed
return iscsi.IscsiVolumeAdapter(self.adpt, 'host_uuid', mock_inst,
con_info)
self.vol_drv = init_vol_adpt()
# setup system_metadata tests
self.devname = "/dev/fake"
self.slot_mgr = mock.Mock()
self.slot_mgr.build_map.get_vscsi_slot.return_value = 62, 'the_lua'
def setUp(self):
super(TestHostCPUStats, self).setUp()
# Fixture for the adapter
self.adpt = self.useFixture(pvm_fx.AdapterFx()).adpt
# Test data
self.cur_json_resp = pvmhttp.PVMFile(PCM_FILE)
self.prev_json_resp = pvmhttp.PVMFile(PCM2_FILE)
# Put in the samples.
self.phyp = pvm_phyp.PhypInfo(self.cur_json_resp.body)
self.prev_phyp = pvm_phyp.PhypInfo(self.prev_json_resp.body)
def setUp(self):
super(PowerVMComputeDriver, self).setUp()
# Set up the mock CPU stats (init_host uses it)
self.useFixture(HostCPUStats())
self.drv = driver.PowerVMDriver(fake.FakeVirtAPI())
self.drv.adapter = self.useFixture(pvm_fx.AdapterFx()).adpt
self._init_host()
self.drv.image_api = mock.Mock()
disk_adpt_fx = self.useFixture(DiskAdapter())
self.drv.disk_dvr = disk_adpt_fx.std_disk_adpt
def setUp(self):
super(TestHostCPUBase, self).setUp()
# Fixture for the adapter
self.adpt = self.useFixture(pvm_fx.AdapterFx()).adpt
ensure_ltm_p = mock.patch(
'pypowervm.tasks.monitor.util.ensure_ltm_monitors')
refresh_p = mock.patch(
'pypowervm.tasks.monitor.util.MetricCache._refresh_if_needed')
self.mock_ensure_ltm_monitors = ensure_ltm_p.start()
self.mock_refresh_if_needed = refresh_p.start()
self.addCleanup(ensure_ltm_p.stop)
self.addCleanup(refresh_p.stop)
def setUp(self):
super(TestVM, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx()).adpt
mock_entries = [mock.Mock(), mock.Mock()]
self.resp = mock.MagicMock()
self.resp.feed = mock.MagicMock(entries=mock_entries)
self.get_pvm_uuid = self.useFixture(fixtures.MockPatch(
'nova.virt.powervm.vm.get_pvm_uuid')).mock
self.inst = powervm.TEST_INSTANCE
def setUp(self):
super(TestFileIOVolumeAdapter, self).setUp()
# Needed for the volume adapter
self.adpt = self.useFixture(pvm_fx.AdapterFx()).adpt
mock_inst = mock.MagicMock(uuid='2BC123')
self.vol_drv = FakeFileIOVolAdapter(self.adpt, 'host_uuid', mock_inst,
None)
self.mock_vio_task = mock.MagicMock()
self.mock_stg_ftsk = mock.MagicMock(
wrapper_tasks={'vios_uuid': self.mock_vio_task})
self.vol_drv.stg_ftsk = self.mock_stg_ftsk
def setUp(self):
super(TestLocalDiskFindVG, self).setUp()
self.apt = self.useFixture(pvm_fx.AdapterFx()).adpt
def resp(file_name):
return pvmhttp.load_pvm_resp(file_name,
adapter=self.apt).get_response()
self.vg_to_vio = resp(VOL_GRP_WITH_VIOS)
self.vio_to_vg = resp(VIOS_WITH_VOL_GRP)
self.mock_vios_feed = [pvm_vios.VIOS.wrap(self.vio_to_vg)]
self.mock_vg_feed = [pvm_stor.VG.wrap(self.vg_to_vio)]
