def test_IBMi(self): attr = dict(name='TheName', env=bp.LPARType.OS400, 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.assertTrue(new_lpar.restrictedio) tag_io = new_lpar.io_config.tagged_io self.assertEqual('HMC', tag_io.console) self.assertEqual('0', tag_io.load_src) self.assertEqual('NONE', tag_io.alt_load_src) attr = dict(name='OS400LPAR', env=bp.LPARType.OS400, memory=1024, vcpu=1, console='CONSOLE', load_src='9', alt_load_src='9') bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertIsNotNone(bldr) new_lpar = bldr.build() self.assertIsNotNone(new_lpar) self.assertTrue(new_lpar.restrictedio) tag_io = new_lpar.io_config.tagged_io self.assertEqual('CONSOLE', tag_io.console) self.assertEqual('9', tag_io.load_src) self.assertEqual('9', tag_io.alt_load_src)
def lpar_builder(self, inst): """Returns the pypowervm LPARBuilder for a given Nova flavor. :param inst: the VM instance """ attrs = self._format_flavor(inst) # TODO(thorst, efried) Add in IBMi attributes return lpar_bldr.LPARBuilder(self.adapter, attrs, self.stdz)
def lpar_builder(self, instance): """Returns the pypowervm LPARBuilder for a given Nova flavor. :param instance: the VM instance """ attrs = self._format_flavor(instance) self._add_IBMi_attrs(instance, attrs) return lpar_bldr.LPARBuilder(self.adapter, attrs, self.stdz)
def test_io_slots(self): attr = dict(name='TheName', memory=1024, vcpu=1) nlpar = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1).build() self.assertEqual([], nlpar.io_config.io_slots) attr = dict(name='TheName', memory=1024, vcpu=1, phys_io_slots=[]) nlpar = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1).build() self.assertEqual([], nlpar.io_config.io_slots) slots = [ bp.IOSlot.bld(self.adpt, True, 12345), bp.IOSlot.bld(self.adpt, False, 54321) ] attr = dict(name='TheName', memory=1024, vcpu=1, phys_io_slots=slots) nlpar = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1).build() self.assertEqual(len(slots), len(nlpar.io_config.io_slots)) for exp, act in zip(slots, nlpar.io_config.io_slots): self.assertEqual(exp.drc_index, act.drc_index) self.assertEqual(exp.bus_grp_required, act.bus_grp_required)
def lpar_builder(self, inst): """Returns the pypowervm LPARBuilder for a given Nova flavor. :param inst: the VM instance """ attrs = { lpar_bldr.NAME: pvm_u.sanitize_partition_name_for_api(inst.name), lpar_bldr.UUID: get_pvm_uuid(inst), lpar_bldr.MEM: inst.flavor.memory_mb, lpar_bldr.VCPU: inst.flavor.vcpus } # TODO(efried): Loop through the extra specs and process powervm keys # TODO(thorst, efried) Add in IBMi attributes return lpar_bldr.LPARBuilder(self.adapter, attrs, self.stdz)
def test_proc_modes(self): # Base minimum attrs attr = dict(name='TheName', memory=1024, vcpu=1) # No proc keys specified bldr = lpar_bldr.LPARBuilder(self.adpt, attr, self.stdz_sys1) self.assertFalse(bldr._shared_proc_keys_specified()) self.assertFalse(bldr._dedicated_proc_keys_specified()) # Default is shared self.assertTrue(bldr._shared_procs_specified()) # Shared proc keys specified for key in ('proc_units', 'max_proc_units', 'min_proc_units', 'uncapped_weight'): bldr = lpar_bldr.LPARBuilder(self.adpt, dict(attr, **{key: 1}), self.stdz_sys1) self.assertTrue(bldr._shared_proc_keys_specified()) self.assertFalse(bldr._dedicated_proc_keys_specified()) self.assertTrue(bldr._shared_procs_specified()) # Shared modes specified for mode in ('capped', 'uncapped'): bldr = lpar_bldr.LPARBuilder(self.adpt, dict(attr, sharing_mode=mode), self.stdz_sys1) self.assertTrue(bldr._shared_proc_keys_specified()) self.assertFalse(bldr._dedicated_proc_keys_specified()) self.assertTrue(bldr._shared_procs_specified()) # Dedicated modes specified for mode in ('sre idle proces', 'sre idle procs active', 'sre idle procs always', 'keep idle procs'): bldr = lpar_bldr.LPARBuilder(self.adpt, dict(attr, sharing_mode=mode), self.stdz_sys1) self.assertFalse(bldr._shared_proc_keys_specified()) self.assertTrue(bldr._dedicated_proc_keys_specified()) self.assertFalse(bldr._shared_procs_specified()) # Dedicated proc explicitly true bldr = lpar_bldr.LPARBuilder(self.adpt, dict(attr, dedicated_proc='TRUE'), self.stdz_sys1) self.assertFalse(bldr._shared_proc_keys_specified()) self.assertFalse(bldr._dedicated_proc_keys_specified()) self.assertFalse(bldr._shared_procs_specified()) # Dedicated proc explicitly false bldr = lpar_bldr.LPARBuilder(self.adpt, dict(attr, dedicated_proc='NO'), self.stdz_sys1) self.assertFalse(bldr._shared_proc_keys_specified()) self.assertFalse(bldr._dedicated_proc_keys_specified()) self.assertTrue(bldr._shared_procs_specified())
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'])