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(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 __init__(self, host_w, adapter, slot_mgr=None, cur_lpar_w=None): """Initialize the converter. :param host_w: The host system wrapper. :param adapter: The pypowervm.adapter.Adapter for the PowerVM REST API. :param slot_mgr: NovaSlotManager for setting/saving the maximum number of virtual slots on the VM. :param cur_lpar_w: The LPAR wrapper of the instance. Passing in this parameter signifies a resize operation. """ self.adapter = adapter self.host_w = host_w kwargs = dict(uncapped_weight=CONF.powervm.uncapped_proc_weight, proc_units_factor=CONF.powervm.proc_units_factor) if cur_lpar_w: # Maintain the existing attributes in DefaultStandardize kwargs['max_slots'] = cur_lpar_w.io_config.max_virtual_slots kwargs['spp'] = cur_lpar_w.proc_config.shared_proc_cfg.pool_id kwargs['avail_priority'] = cur_lpar_w.avail_priority kwargs['srr'] = cur_lpar_w.srr_enabled kwargs['proc_compat'] = cur_lpar_w.proc_compat_mode kwargs['enable_lpar_metric'] = ( cur_lpar_w.allow_perf_data_collection) if slot_mgr is not None: # This will already default if not set max_vslots = slot_mgr.build_map.get_max_vslots() if max_vslots > kwargs.get('max_slots', 0): kwargs['max_slots'] = max_vslots self.stdz = lpar_bldr.DefaultStandardize(self.host_w, **kwargs)
def __init__(self, host_w, adapter): """Initialize the converter. :param host_w: The host System wrapper. :param adapter: The pypowervm.adapter.Adapter for the PowerVM REST API. """ self.adapter = adapter self.stdz = lpar_bldr.DefaultStandardize(host_w)
def __init__(self, host_w, adapter): """Initialize the converter. :param host_w: The host system wrapper. """ self.adapter = adapter self.host_w = host_w self.stdz = lpar_bldr.DefaultStandardize( self.host_w, uncapped_weight=CONF.powervm.uncapped_proc_weight, proc_units_factor=CONF.powervm.proc_units_factor)
def __init__(self, host_w, adapter): """Initialize the converter. :param host_w: The host System wrapper. :param adapter: The pypowervm.adapter.Adapter for the PowerVM REST API. """ self.adapter = adapter self.host_w = host_w kwargs = dict(proc_units_factor=CONF.powervm.proc_units_factor) self.stdz = lpar_bldr.DefaultStandardize(host_w, **kwargs)
def __init__(self, host_w, adapter, slot_mgr=None): """Initialize the converter. :param host_w: The host system wrapper. :param adapter: The pypowervm.adapter.Adapter for the PowerVM REST API. :param slot_mgr: NovaSlotManager for setting/saving the maximum number of virtual slots on the VM. """ self.adapter = adapter self.host_w = host_w kwargs = dict(uncapped_weight=CONF.powervm.uncapped_proc_weight, proc_units_factor=CONF.powervm.proc_units_factor) if slot_mgr is not None: # This will already default if not set kwargs['max_slots'] = slot_mgr.build_map.get_max_vslots() self.stdz = lpar_bldr.DefaultStandardize(self.host_w, **kwargs)
def test_builder(self): # Build the minimum attributes, Shared Procs attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertIsNotNone(bldr) new_lpar = bldr.build() self.assertIsNotNone(new_lpar) self.assert_xml(new_lpar, self.sections['shared_lpar']) self.assertEqual('TheName', new_lpar.name) # Rebuild the same lpar with a different name attr['name'] = 'NewName' bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) rbld_lpar = bldr.rebuild(new_lpar) self.assertEqual('NewName', rbld_lpar.name) # Build the minimum attributes, Dedicated Procs attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, dedicated_proc=True) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertIsNotNone(bldr) new_lpar = bldr.build() self.assertIsNotNone(new_lpar) self.assert_xml(new_lpar.entry, self.sections['dedicated_lpar']) # Build the minimum attributes, Dedicated Procs = 'true' attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, dedicated_proc='true') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar.entry, self.sections['dedicated_lpar']) # Leave out memory attr = dict(name=lpar, env=bp.LPARType.AIXLINUX, vcpu=1) self.assertRaises( lpar_bldr.LPARBuilderException, lpar_bldr.LPARBuilder, self.adpt, attr, self.stdz_sys1) # Bad memory lmb multiple attr = dict(name='lpar', memory=3333, env=bp.LPARType.AIXLINUX, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Check the validation of the LPAR type when not specified attr = dict(name='TheName', memory=1024, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['shared_lpar']) # LPAR name too long attr = dict(name='lparlparlparlparlparlparlparlparlparlparlparlpar' 'lparlparlparlparlparlparlparlparlparlparlparlparlparlpar', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(lpar_bldr.LPARBuilderException, bldr.build) # Test setting uuid uuid1 = pvm_uuid.convert_uuid_to_pvm(str(uuid.uuid4())) attr = dict(name='lpar', memory=1024, uuid=uuid1, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) lpar_w = bldr.build() self.assertEqual(uuid1.upper(), lpar_w.uuid) # Test setting id id1 = 1234 attr = dict(name='lpar', memory=1024, uuid=uuid1, vcpu=1, id=id1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) lpar_w = bldr.build() self.assertEqual(id1, lpar_w.id) # Bad LPAR type attr = dict(name='lpar', memory=1024, env='BADLPARType', vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Bad IO Slots attr = dict(name='lpar', memory=1024, max_io_slots=0, env=bp.LPARType.AIXLINUX, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) attr = dict(name='lpar', memory=1024, max_io_slots=(65534+1), env=bp.LPARType.AIXLINUX, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Good non-defaulted IO Slots and SRR attr = dict(name='TheName', memory=1024, max_io_slots=64, env=bp.LPARType.AIXLINUX, vcpu=1, srr_capability=False) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['shared_lpar']) # Bad SRR value. attr = dict(name='lpar', memory=1024, max_io_slots=64, env=bp.LPARType.AIXLINUX, vcpu=1, srr_capability='Frog') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Uncapped / capped shared procs attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, sharing_mode=bp.SharingMode.CAPPED, srr_capability='true') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['capped_lpar']) # Uncapped and no SRR capability attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, sharing_mode=bp.SharingMode.UNCAPPED, uncapped_weight=100, processor_compatibility='POWER6') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys2) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['uncapped_lpar']) # Build dedicated but only via dedicated attributes m = bp.DedicatedSharingMode.SHARE_IDLE_PROCS_ALWAYS attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, sharing_mode=m, processor_compatibility='PoWeR7') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar.entry, self.sections['ded_lpar_sre_idle_procs_always']) # Desired mem outside min attr = dict(name='lpar', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1, min_mem=2048) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Desired mem outside max attr = dict(name='lpar', memory=5000, env=bp.LPARType.AIXLINUX, vcpu=1, max_mem=2048) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Desired vcpu outside min attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=1, min_vcpu=2) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Desired vcpu outside max attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, max_vcpu=2) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Ensure the calculated procs are not below the min attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, min_proc_units=3) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() procs = new_lpar.proc_config.shared_proc_cfg self.assertEqual(3.0, procs.min_units) # Ensure the calculated procs are all 0.5 attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=1, proc_units=0.5) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() procs = new_lpar.proc_config.shared_proc_cfg self.assertEqual(0.5, procs.min_units) self.assertEqual(0.5, procs.max_units) self.assertEqual(0.5, procs.desired_units) # Create a temp standardizer with a smaller proc units factor stdz = lpar_bldr.DefaultStandardize(self.mngd_sys, proc_units_factor=0.1) # Ensure the min, max, and desired proc units works as VCPU is scaled. for x in [1, 5, 10, 17, 20]: attr = dict(name='lpar', memory=2048, vcpu=x) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, stdz) new_lpar = bldr.build() procs = new_lpar.proc_config.shared_proc_cfg self.assertEqual(round(0.1 * x, 2), procs.min_units) self.assertEqual(round(0.1 * x, 2), procs.max_units) self.assertEqual(round(0.1 * x, 2), procs.desired_units) # Ensure the calculated procs are below the max attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, max_proc_units=2.1) stdz = lpar_bldr.DefaultStandardize( self.mngd_sys, proc_units_factor=0.9) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, stdz) new_lpar = bldr.build() procs = new_lpar.proc_config.shared_proc_cfg self.assertEqual(2.1, procs.max_units) # Ensure proc units factor is between 0.1 and 1.0 self.assertRaises( lpar_bldr.LPARBuilderException, lpar_bldr.DefaultStandardize, self.mngd_sys, proc_units_factor=1.01) self.assertRaises( lpar_bldr.LPARBuilderException, lpar_bldr.DefaultStandardize, self.mngd_sys, proc_units_factor=0.01) # Avail priority outside max attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, avail_priority=332) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Avail priority bad parm attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, avail_priority='BADVALUE') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Avail priority at min value attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, avail_priority=0) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assertEqual(new_lpar.avail_priority, 0) # Avail priority at max value attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, avail_priority=255) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assertEqual(new_lpar.avail_priority, 255) # Proc compat for pc in bp.LPARCompat.ALL_VALUES: attr = dict(name='name', memory=1024, vcpu=1, processor_compatibility=pc) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assertEqual(new_lpar.pending_proc_compat_mode, pc) attr = dict(name='name', memory=1024, vcpu=1, processor_compatibility='POWER6') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys2) new_lpar = bldr.build() self.assertEqual(new_lpar.pending_proc_compat_mode, 'POWER6') # Ensure failure occurs on validation after the host supported # proc modes are loaded and not on convert_value which converts # across all acceptable proc modes. # This works because 'POWER8' is in LPARCompat.ALL_VALUES attr = dict(name='name', memory=1024, vcpu=1, processor_compatibility='POWER8') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys2) exp_msg = ("Value 'POWER8' is not valid for field 'Processor " "Compatability Mode' with acceptable choices: ['POWER6']") try: bldr.build() except Exception as e: self.assertEqual(six.text_type(e), exp_msg) # Build a VIOS attr = dict(name='TheName', env=bp.LPARType.VIOS, memory=1024, vcpu=1, dedicated_proc=True) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertIsNotNone(bldr) new_lpar = bldr.build() self.assertIsNotNone(new_lpar) self.assert_xml(new_lpar.entry, self.sections['vios'])
def test_builder(self): # Build the minimum attributes, Shared Procs # shared_lpar test file uses non-default max I/O slots attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, max_io_slots=2000) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertIsNotNone(bldr) new_lpar = bldr.build() self.assertIsNotNone(new_lpar) self.assert_xml(new_lpar, self.sections['shared_lpar']) self.assertEqual('TheName', new_lpar.name) # Rebuild the same lpar with a different name attr['name'] = 'NewName' bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) rbld_lpar = bldr.rebuild(new_lpar) self.assertEqual('NewName', rbld_lpar.name) # Build the minimum attributes, Dedicated Procs attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, dedicated_proc=True) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertIsNotNone(bldr) new_lpar = bldr.build() self.assertIsNotNone(new_lpar) self.assert_xml(new_lpar.entry, self.sections['dedicated_lpar']) # Build the minimum attributes, Dedicated Procs = 'true' attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, dedicated_proc='true') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar.entry, self.sections['dedicated_lpar']) # Leave out memory attr = dict(name=lpar, env=bp.LPARType.AIXLINUX, vcpu=1) self.assertRaises(lpar_bldr.LPARBuilderException, lpar_bldr.LPARBuilder, self.adpt, attr, self.stdz_sys1) # Bad memory lmb multiple attr = dict(name='lpar', memory=3333, env=bp.LPARType.AIXLINUX, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Check the validation of the LPAR type when not specified attr = dict(name='TheName', memory=1024, vcpu=1, max_io_slots=2000) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['shared_lpar']) # Check the PPT ratio element builds correctly attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, ppt_ratio='1:512') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys4) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['ppt_lpar']) # Ensure secure boot is set properly attr = dict(name='SecureBoot', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1, secure_boot=2) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys6) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['secure_boot_lpar']) # Ensure secure boot disabled works for IBMi attr = dict(name='SecureBoot', memory=1024, env=bp.LPARType.OS400, vcpu=1, secure_boot=0) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys6) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['secure_boot_ibmi_lpar']) # LPAR name too long attr = dict(name='lparlparlparlparlparlparlparlparlparlparlparlpar' 'lparlparlparlparlparlparlparlparlparlparlparlparlparlpar', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(lpar_bldr.LPARBuilderException, bldr.build) # Test setting uuid uuid1 = pvm_uuid.convert_uuid_to_pvm(str(uuid.uuid4())) attr = dict(name='lpar', memory=1024, uuid=uuid1, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) lpar_w = bldr.build() self.assertEqual(uuid1.upper(), lpar_w.uuid) # Test setting id id1 = 1234 attr = dict(name='lpar', memory=1024, uuid=uuid1, vcpu=1, id=id1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) lpar_w = bldr.build() self.assertEqual(id1, lpar_w.id) # Bad LPAR type attr = dict(name='lpar', memory=1024, env='BADLPARType', vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Bad IO Slots attr = dict(name='lpar', memory=1024, max_io_slots=0, env=bp.LPARType.AIXLINUX, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) attr = dict(name='lpar', memory=1024, max_io_slots=(65534 + 1), env=bp.LPARType.AIXLINUX, vcpu=1) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Good non-default IO Slots and SRR attr = dict(name='TheName', memory=1024, max_io_slots=2000, env=bp.LPARType.AIXLINUX, vcpu=1, srr_capability=False) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['shared_lpar']) # Bad SRR value. attr = dict(name='lpar', memory=1024, max_io_slots=64, env=bp.LPARType.AIXLINUX, vcpu=1, srr_capability='Frog') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Uncapped / capped shared procs and enabled lpar metrics attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, sharing_mode=bp.SharingMode.CAPPED, srr_capability='true', enable_lpar_metric=True) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['capped_lpar']) # Uncapped and no SRR capability attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, sharing_mode=bp.SharingMode.UNCAPPED, uncapped_weight=100, processor_compatibility='POWER6') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys2) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['uncapped_lpar']) # Build dedicated but only via dedicated attributes m = bp.DedicatedSharingMode.SHARE_IDLE_PROCS_ALWAYS attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, sharing_mode=m, processor_compatibility='PoWeR7') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar.entry, self.sections['ded_lpar_sre_idle_procs_always']) # Desired mem outside min attr = dict(name='lpar', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1, min_mem=2048) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Desired mem outside max attr = dict(name='lpar', memory=5000, env=bp.LPARType.AIXLINUX, vcpu=1, max_mem=2048) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # AME not supported on host attr = dict(name='lpar', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1, ame_factor='1.5') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # AME outside valid range attr = dict(name='lpar', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1, ame_factor='0.5') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys3) self.assertRaises(ValueError, bldr.build) # PPT not supported on host attr = dict(name='lpar', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1, ppt_ratio='1:64') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys3) self.assertRaises(ValueError, bldr.build) # PPT ratio not a valid choice attr = dict(name='lpar', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1, ppt_ratio='1:76') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys3) self.assertRaises(ValueError, bldr.build) # Affinity unsupported host attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, enforce_affinity_check='true') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys4) self.assertRaises(ValueError, bldr.build) # Enforce affinity score check for Lpar with incorrect value attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, enforce_affinity_check='BADVALUE') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys5) self.assertRaises(ValueError, bldr.build) # Secure boot on unsupported host attr = dict(name='SecureBoot', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1, secure_boot=2) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys5) self.assertRaises(ValueError, bldr.build) # Secure boot of IBMi LPAR attr = dict(name='SecureBoot', memory=1024, env=bp.LPARType.OS400, vcpu=1, secure_boot=2) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys6) self.assertRaises(ValueError, bldr.build) # Secure boot bad value attr = dict(name='SecureBoot', memory=1024, env=bp.LPARType.AIXLINUX, vcpu=1, secure_boot=10) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys6) self.assertRaises(ValueError, bldr.build) # Secure boot as 0 on unsupported host # This dictionary should equate to the 'dedicated_lpar' XML on an # unsupported host. attr = dict(name='TheName', env=bp.LPARType.AIXLINUX, memory=1024, vcpu=1, dedicated_proc=True, secure_boot=0) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assert_xml(new_lpar, self.sections['dedicated_lpar']) # Desired vcpu outside min attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=1, min_vcpu=2) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys5) self.assertRaises(ValueError, bldr.build) # Desired vcpu outside max attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, max_vcpu=2) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Ensure the calculated procs are not below the min attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, min_proc_units=3) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() procs = new_lpar.proc_config.shared_proc_cfg self.assertEqual(3.0, procs.min_units) # Ensure the calculated procs are all 0.5 attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=1, proc_units=0.5) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() procs = new_lpar.proc_config.shared_proc_cfg self.assertEqual(0.5, procs.min_units) self.assertEqual(0.5, procs.max_units) self.assertEqual(0.5, procs.desired_units) # Create a temp standardizer with a smaller proc units factor stdz = lpar_bldr.DefaultStandardize(self.mngd_sys, proc_units_factor=0.1) # Ensure the min, max, and desired proc units works as VCPU is scaled. for x in [1, 5, 10, 17, 20]: attr = dict(name='lpar', memory=2048, vcpu=x) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, stdz) new_lpar = bldr.build() procs = new_lpar.proc_config.shared_proc_cfg self.assertEqual(round(0.1 * x, 2), procs.min_units) self.assertEqual(round(0.1 * x, 2), procs.max_units) self.assertEqual(round(0.1 * x, 2), procs.desired_units) # Ensure the calculated procs are below the max attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, max_proc_units=2.1) stdz = lpar_bldr.DefaultStandardize(self.mngd_sys, proc_units_factor=0.9) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, stdz) new_lpar = bldr.build() procs = new_lpar.proc_config.shared_proc_cfg self.assertEqual(2.1, procs.max_units) # Ensure proc units factor is between 0.1 and 1.0 self.assertRaises(lpar_bldr.LPARBuilderException, lpar_bldr.DefaultStandardize, self.mngd_sys, proc_units_factor=1.01) self.assertRaises(lpar_bldr.LPARBuilderException, lpar_bldr.DefaultStandardize, self.mngd_sys, proc_units_factor=0.01) # Avail priority outside max attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, avail_priority=332) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Avail priority bad parm attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, avail_priority='BADVALUE') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Avail priority at min value attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, avail_priority=0) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assertEqual(new_lpar.avail_priority, 0) # Avail priority at max value attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, avail_priority=255) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assertEqual(new_lpar.avail_priority, 255) # Enable Lpar metric with correct value as true attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, enable_lpar_metric='true') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assertEqual(new_lpar.allow_perf_data_collection, True) # Enable Lpar metric with correct value as false attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, enable_lpar_metric='false') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assertEqual(new_lpar.allow_perf_data_collection, False) # Enable Lpar Metric with bad parm other than true or false attr = dict(name='lpar', memory=2048, env=bp.LPARType.AIXLINUX, vcpu=3, enable_lpar_metric='BADVALUE') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertRaises(ValueError, bldr.build) # Proc compat for pc in bp.LPARCompat.ALL_VALUES: attr = dict(name='name', memory=1024, vcpu=1, processor_compatibility=pc) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) new_lpar = bldr.build() self.assertEqual(new_lpar.pending_proc_compat_mode, pc) attr = dict(name='name', memory=1024, vcpu=1, processor_compatibility='POWER6') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys2) new_lpar = bldr.build() self.assertEqual(new_lpar.pending_proc_compat_mode, 'POWER6') # Ensure failure occurs on validation after the host supported # proc modes are loaded and not on convert_value which converts # across all acceptable proc modes. # This works because 'POWER8' is in LPARCompat.ALL_VALUES attr = dict(name='name', memory=1024, vcpu=1, processor_compatibility='POWER8') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys2) exp_msg = ("Value 'POWER8' is not valid for field 'Processor " "Compatability Mode' with acceptable choices: ['POWER6']") try: bldr.build() except Exception as e: self.assertEqual(six.text_type(e), exp_msg) # Build a VIOS with I/O slots slots = [ bp.IOSlot.bld(self.adpt, True, 12345), bp.IOSlot.bld(self.adpt, False, 54321) ] attr = dict(name='TheName', env=bp.LPARType.VIOS, memory=1024, vcpu=1, dedicated_proc=True, phys_io_slots=slots) bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertIsNotNone(bldr) new_lpar = bldr.build() self.assertIsNotNone(new_lpar) self.assert_xml(new_lpar.entry, self.sections['vios'])