def _typed_randrange(lo, hi, type): if type == 'sint8': return pywbem.Sint8( random.randrange(pywbem.Sint8(lo), pywbem.Sint8(hi))) elif type == 'sint16': return pywbem.Sint16( random.randrange(pywbem.Sint16(lo), pywbem.Sint16(hi))) elif type == 'sint32': return pywbem.Sint32( random.randrange(pywbem.Sint32(lo), pywbem.Sint32(hi))) elif type == 'sint64': return pywbem.Sint64( random.randrange(pywbem.Sint64(lo), pywbem.Sint64(hi))) elif type == 'uint8': return pywbem.Uint8( random.randrange(pywbem.Uint8(lo), pywbem.Uint8(hi))) elif type == 'uint16': return pywbem.Uint16( random.randrange(pywbem.Uint16(lo), pywbem.Uint16(hi))) elif type == 'uint32': return pywbem.Uint32( random.randrange(pywbem.Uint32(lo), pywbem.Uint32(hi))) elif type == 'uint64': return pywbem.Uint64( random.randrange(pywbem.Uint64(lo), pywbem.Uint64(hi))) elif type == 'real32': return pywbem.Real32( random.randrange(pywbem.Real32(lo), pywbem.Real32(hi))) elif type == 'real64': return pywbem.Real64( random.randrange(pywbem.Real64(lo), pywbem.Real64(hi)))
def get_instance(self, env, model): """Return an instance. Keyword arguments: env -- Provider Environment (pycimmb.ProviderEnvironment) model -- A template of the pywbem.CIMInstance to be returned. The key properties are set on this instance to correspond to the instanceName that was requested. The properties of the model are already filtered according to the PropertyList from the request. Only properties present in the model need to be given values. If you prefer, you can set all of the values, and the instance will be filtered for you. Possible Errors: CIM_ERR_ACCESS_DENIED CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters) CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM Instance does not exist in the specified namespace) CIM_ERR_FAILED (some other unspecified error occurred) """ logger = env.get_logger() logger.log_debug('Entering %s.get_instance()' \ % self.__class__.__name__) key = self.fromInstanceID(model['InstanceID']) concreteJob = concrete_job.AnyJob.load(key) logEntriesLen = len(list(concreteJob.logs.enumerate())) #model['AvailableRequestedStates'] = [self.Values.AvailableRequestedStates.<VAL>,] # TODO #model['Caption'] = '' # TODO #model['CommunicationStatus'] = self.Values.CommunicationStatus.<VAL> # TODO model['CurrentNumberOfRecords'] = pywbem.Uint64(logEntriesLen) #model['Description'] = '' # TODO #model['DetailedStatus'] = self.Values.DetailedStatus.<VAL> # TODO #model['ElementName'] = '' # TODO #model['EnabledDefault'] = self.Values.EnabledDefault.Enabled # TODO #model['EnabledState'] = self.Values.EnabledState.Not_Applicable # TODO #model['Generation'] = pywbem.Uint64() # TODO #model['HealthState'] = self.Values.HealthState.<VAL> # TODO #model['InstallDate'] = pywbem.CIMDateTime() # TODO model['LogState'] = self.Values.LogState.Normal model['MaxNumberOfRecords'] = pywbem.Uint64(0) #model['Name'] = '' # TODO #model['OperatingStatus'] = self.Values.OperatingStatus.<VAL> # TODO #model['OperationalStatus'] = [self.Values.OperationalStatus.<VAL>,] # TODO #model['OtherEnabledState'] = '' # TODO model['OverwritePolicy'] = self.Values.OverwritePolicy.Never_Overwrites #model['PrimaryStatus'] = self.Values.PrimaryStatus.<VAL> # TODO #model['RequestedState'] = self.Values.RequestedState.Not_Applicable # TODO #model['Status'] = self.Values.Status.<VAL> # TODO #model['StatusDescriptions'] = ['',] # TODO #model['TimeOfLastStateChange'] = pywbem.CIMDateTime() # TODO #model['TransitioningToState'] = self.Values.TransitioningToState.Not_Applicable # TODO return model
def _create_test_instance(self, name_of_atom, number): """ Create a TestAtom instance. """ weight = _atomic_weights[name_of_atom] #new_instance['char16Prop'] = #new_instance['char16Propa'] = Null new_instance = pywbem.CIMInstance('TestAtom') new_instance['Name'] = name_of_atom new_instance['boolProp'] = False new_instance['dateProp'] = self.time new_instance['real32Prop'] = pywbem.Real32(weight) new_instance['real32Propa'] = [pywbem.Real32(weight), \ pywbem.Real32(weight), \ pywbem.Real32(weight)] new_instance['real64Prop'] = pywbem.Real64(weight) new_instance['real64Propa'] = [pywbem.Real64(weight), \ pywbem.Real64(weight), \ pywbem.Real64(weight)] new_instance['sint16Prop'] = pywbem.Sint16(number) new_instance['sint16Propa'] = [pywbem.Sint16(number), \ pywbem.Sint16(number), \ pywbem.Sint16(number)] new_instance['sint32Prop'] = pywbem.Sint32(number) new_instance['sint32Propa'] = [pywbem.Sint32(number), \ pywbem.Sint32(number), \ pywbem.Sint32(number)] new_instance['sint64Prop'] = pywbem.Sint64(number) new_instance['sint64Propa'] = [pywbem.Sint64(number), \ pywbem.Sint64(number), \ pywbem.Sint64(number)] new_instance['sint8prop'] = pywbem.Sint8(number) new_instance['sint8Propa'] = [pywbem.Sint8(number), \ pywbem.Sint8(number), \ pywbem.Sint8(number)] new_instance['stringProp'] = name_of_atom new_instance['stringPropa'] = ['proton', 'electron', 'neutron'] new_instance['uint16Prop'] = pywbem.Uint16(number) new_instance['uint16Propa'] = [pywbem.Uint16(number), \ pywbem.Uint16(number), \ pywbem.Uint16(number)] new_instance['uint32Prop'] = pywbem.Uint32(number) new_instance['uint32Propa'] = [pywbem.Uint32(number), \ pywbem.Uint32(number), \ pywbem.Uint32(number)] new_instance['uint64Prop'] = pywbem.Uint64(number) new_instance['uint64Propa'] = [pywbem.Uint64(number), \ pywbem.Uint64(number), \ pywbem.Uint64(number)] new_instance['uint8Prop'] = pywbem.Uint64(number) new_instance['uint8Propa'] = [pywbem.Uint64(number), \ pywbem.Uint64(number), \ pywbem.Uint64(number)] try: cipath = self.conn.CreateInstance(new_instance) new_instance.path = cipath self.inst_paths.append(cipath) except pywbem.CIMError, arg: return None, arg
def test_6_modify_instance(self): """Test modify instance""" rinst, msg = self._create_test_instance('Boron', 5) if not rinst: self.fail('%s: CreateInstance Failed.' % str(msg)) return propertylist = ['uint64Prop', 'dateProp', 'stringProp', 'real32Prop', \ 'sint64Propa', 'sint64prop', 'boolProp'] keybindings = {'Name': 'Boron'} mod_instance = get_instance(self.conn, keybindings, propertylist) weight = _atomic_weights['Boron'] new_time = pywbem.CIMDateTime.now() if mod_instance['boolProp']: mod_instance['boolProp'] = False else: mod_instance['boolProp'] = True mod_instance['uint64Prop'] = pywbem.Uint64(2) mod_instance['dateProp'] = new_time mod_instance['stringProp'] = "Helium" mod_instance['real32Prop'] = pywbem.Real32(weight) mod_instance['sint64Propa'] = pywbem.CIMProperty('sint64Propa', \ value=[pywbem.Sint64(2), \ pywbem.Sint64(2), pywbem.Sint64(2)]) mod_instance['sint64prop'] = pywbem.Sint64(2) mod_instance['Name'] = 'Boron' try: self.conn.ModifyInstance(mod_instance) except pywbem.CIMError, arg: self.fail(arg)
def __AttachNicToNetwork(self, switch, nics): result = 0 if switch != None: try: rasd = CIMInstance('Xen_HostNetworkPortSettingData') rasd['ResourceType'] = pywbem.Uint16(33) rasd['VlanTag'] = pywbem.Uint64(23) rasd['Connection'] = nics print 'adding resources %s' % rasd.items() vssd = CIMInstanceName('Xen_VirtualSwitchSettingData') vssd['InstanceID'] = 'Xen:' + switch['Name'] nic_rasds = [rasd] in_params = { 'AffectedConfiguration': vssd, 'ResourceSettings': nic_rasds } (rval, out_params) = self.conn.InvokeMethod('AddResourceSettings', self.vsms, **in_params) if rval == 0: result = 1 try: nics = self.__FindNicsAssociatedWithSwitch(switch) if len(nics) == 0: result = 0 except Exception, e: print 'exception %s was received' % str(e) result = 0 else: print 'Method returned error %d' % rval
def CreateBondedNetwork(self): self.TestBegin() # eth1 and eth2 PIFs are bonded and a network is created out of them rasd1 = CIMInstance('Xen_HostNetworkPortSettingData') rasd1['ResourceType'] = pywbem.Uint16(33) rasd1['Connection'] = ["eth1"] rasd1['VlanTag'] = pywbem.Uint64(2) rasd2 = CIMInstance('Xen_NetworkPortSettingData') rasd2['ResourceType'] = pywbem.Uint16(33) rasd2['Connection'] = ["eth2"] rasd2['VlanTag'] = pywbem.Uint64(2) rasds = [rasd1, rasd2] result = 0 bonded_network = self.__CreateNetwork(rasds) if bonded_network != None: result = 1 self.TestEnd(result) return bonded_network
def createCIMXMLVM(password = None, hostIPAddr = None, vmName = None): cimxmlConn = cimxmlConnection(password,hostIPAddr) # Virtual System setting data for an HVM type hvmVssd = CIMInstance("Xen_ComputerSystemSettingData") hvmVssd['Description'] = vmName hvmVssd['ElementName'] = vmName hvmVssd['VirtualSystemType'] = 'DMTF:xen:HVM' hvmVssd['HVM_Boot_Params'] = ['order=dc'] hvmVssd['HVM_Boot_Policy'] = 'BIOS order' hvmVssd['Platform'] = ['acpi=true','apic=true','pae=true'] # RASD to specify processor allocation for the VM # Processor RASD procRasd = CIMInstance('CIM_ResourceAllocationSettingData') procRasd['ResourceType'] = pywbem.Uint16(3) procRasd['VirtualQuantity'] = pywbem.Uint64(1) procRasd['AllocationUnits'] = 'count' # memory RASD to specify memory allocation settings for a VM memRasd = CIMInstance('Xen_MemorySettingData') memRasd['ResourceType'] = pywbem.Uint16(4) memRasd['VirtualQuantity'] = pywbem.Uint64(512) memRasd['AllocationUnits'] = 'byte*2^20' vsms = cimxmlConn.EnumerateInstanceNames("Xen_VirtualSystemManagementService") rasds = [procRasd, memRasd] hvmParams = {'SystemSettings': hvmVssd, 'ResourceSettings': rasds} newVM = None try: (rval, outParams) = cimxmlConn.InvokeMethod('DefineSystem', vsms[0], **hvmParams) if((rval != 4096) and (rval != 0)): raise xenrt.XRTError("Following error occured while invoking DefineSystem %s" % (rval)) newVM = outParams['ResultingSystem'] xenrt.sleep(10) except Exception, e: raise xenrt.XRTError("Caught exception while invoking DefineSystem")
def get_instance(self, env, model, cim_class, stat=None): """Return an instance. Keyword arguments: env -- Provider Environment model -- A template of the CIMInstance to be returned. The key properties are set on this instance to correspond to the instanceName that was requested. The properties of the model are already filtered according to the PropertyList from the request. cim_class -- The CIMClass Possible Errors: CIM_ERR_ACCESS_DENIED CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters) CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM Instance does not exist in the specified namespace) CIM_ERR_FAILED (some other unspecified error occurred) """ logger = env.get_logger() logger.log_debug('Entering %s.get_instance()' % self.__class__.__name__) if stat is None: stat = os.lstat(model['name']) mode = stat[ST_MODE] model['Writeable'] = bool(mode & S_IWUSR) model['HealthState'] = pywbem.Uint16(5) #model['StatusDescriptions'] = # TODO (type = string[]) model['Executable'] = bool(mode & S_IXUSR) model['Readable'] = bool(mode & S_IRUSR) #model['OperationalStatus'] = # TODO (type = uint16[]) model['FileSize'] = pywbem.Uint64(stat[ST_SIZE]) #model['CompressionMethod'] = # TODO (type = string) #model['Status'] = # TODO (type = string) #model['Description'] = # TODO (type = string) #model['InstallDate'] = # TODO (type = datetime) model['LastModified'] = pywbem.CIMDateTime.fromtimestamp( stat[ST_MTIME]) #model['InUseCount'] = # TODO (type = uint64) #model['EncryptionMethod'] = # TODO (type = string) model['LastAccessed'] = pywbem.CIMDateTime.fromtimestamp( stat[ST_ATIME]) model['ElementName'] = model['name'] == '/' and '/' or \ os.path.basename(model['name']) #model['Caption'] = # TODO (type = string) model['CreationDate'] = pywbem.CIMDateTime.fromtimestamp( stat[ST_CTIME]) return model
def CreateInvalidBondedNetwork(self): self.TestBegin() # 2 invalid pifs (with the wrong interfaces specified) are bonded rasd1 = CIMInstance('Xen_NetworkPortSettingData') rasd1['ResourceType'] = pywbem.Uint16(33) rasd1['Connection'] = ["eth11234", "eth2345"] rasd1['VlanTag'] = pywbem.Uint64(2) rasds = [rasd1] result = 0 bonded_network = self.__CreateNetwork(rasds) if bonded_network == None: result = 1 self.TestEnd(result)
def getnum(num, datatype): try: result = { '8': pywbem.Uint8(num), '16': pywbem.Uint16(num), '32': pywbem.Uint32(num), '64': pywbem.Uint64(num) } result = result.get(datatype, num) except NameError: result = num return result
def CreateInvalidBondedNetwork2(self): self.TestBegin() # one invalid pif is bonded with an valid pif rasd1 = CIMInstance('Xen_HostNetworkPortSettingData') rasd1['ResourceType'] = pywbem.Uint16(33) rasd1['Connection'] = ["eth11234", "eth1"] rasd1['VlanTag'] = pywbem.Uint64(2) rasds = [rasd1] result = 0 bonded_network = self.__CreateNetwork(rasds) if bonded_network == None: result = 1 self.TestEnd(result)
def ConvertExternalVLANNetworkToInternalNetwork(self): self.TestBegin() result = 0 # create an internal network first rasd = CIMInstance('Xen_HostNetworkPortSettingData') rasd['ResourceType'] = pywbem.Uint16(33) rasd['Connection'] = ["eth0"] rasd['VlanTag'] = pywbem.Uint64(256) switch = self.__CreateNetwork(rasd) print switch.items() rasds = self.__FindNicsAssociatedWithSwitch(switch) result = self.__RemoveNicsFromNetwork(switch, rasds) self.TestEnd(result) return switch
def add_vm_resources (conn, vsms, vm_ref): try: print '*** Adding processor and CD resources to VM %s ' % vm_ref['Name'] # AddResourceSettings requires the Xen_ComputerSystemSettingData reference, find it # We'll use the association class for that association_class = 'CIM_SettingsDefineState' # association to traverse via Xen_ComputerSystem result_class = 'CIM_VirtualSystemSettingData' # result class we are looking for in_params = {'ResultClass': result_class, 'AssocClass': association_class } affected_config_arr = conn.AssociatorNames(vm_ref, **in_params) affected_config = affected_config_arr[0] cd_drive = pywbem.CIMInstance('Xen_DiskSettingData') cd_drive['Elementname'] = 'my_cd_drive' cd_drive['ResourceType'] = pywbem.Uint16(15) cd_drive['VirtualQuantity'] = pywbem.Uint64(1) cd_drive['AllocationUnits'] = "count" cd_drive['Access'] = pywbem.Uint8(1) cd_drive['Bootable'] = True more_mem = pywbem.CIMInstance('CIM_ResourceAllocationSettingData') more_mem['ResourceType'] = pywbem.Uint16(4) more_mem['VirtualQuantity'] = pywbem.Uint64(512) more_mem['AllocationUnits'] = 'byte*2^20' rasds = [cd_drive, more_mem] in_params = {'ResourceSettings': rasds, 'AffectedConfiguration':affected_config} [rval, out_params] = conn.InvokeMethod('AddResourceSettings', vsms, **in_params) if rval != 4096: sys.stderr.write('%s returned error: %s\n' % (sys._getframe(0).f_code.co_name, rval)) return 0 job_ref = out_params['Job'] job = wait_for_job_to_complete(conn, job_ref) conn.DeleteInstance(job_ref) except Exception, e: sys.stderr.write('Exception caught in %s: %s\n' % (sys._getframe(0).f_code.co_name, e)) return 0
def CreateExternalNetwork(self): self.TestBegin() result = 0 rasd = CIMInstance('Xen_HostNetworkPortSettingData') rasd['ResourceType'] = pywbem.Uint16(33) rasd['Connection'] = ["eth0"] rasd['VlanTag'] = pywbem.Uint64(3) rasds = [rasd] external_network = self.__CreateNetwork(rasds) if external_network != None: result = 1 # create another VLAN for the same interface with a different VLAN id rasd = CIMInstance('Xen_HostNetworkPortSettingData') rasd['ResourceType'] = pywbem.Uint16(33) rasd['Connection'] = ["eth0"] rasd['VlanTag'] = pywbem.Uint64(4) rasds = [rasd] external_network2 = self.__CreateNetwork(rasds) if external_network2 == None: result = 0 else: self.__DeleteNetwork(external_network2) self.TestEnd(result) return external_network
def CreateBondedNetwork2(self): self.TestBegin() # A second way of specify the two interfaces to bond (in the same RASD) # eth1 and eth2 PIFs are bonded and a network is created out of them rasd1 = CIMInstance('Xen_HostNetworkPortSettingData') rasd1['ResourceType'] = pywbem.Uint16(33) rasd1['Connection'] = ["eth1", "eth2"] rasd1['VlanTag'] = pywbem.Uint64(2) rasds = [rasd1] result = 0 bonded_network = self.__CreateNetwork(rasds) if bonded_network != None: result = 1 self.TestEnd(result) return bonded_network
def CreateNetworkErrorTests(self): self.TestBegin() result = 1 # rasd with wrong resourcetype specified (needs to be 33) print 'Error Test: bad RASD with wrong resourcetype' try: rasd_with_wrong_resource_type = CIMInstance( 'CIM_ResourceAllocationSettingData') rasd_with_wrong_resource_type['ResourceType'] = pywbem.Uint16(19) rasd_with_wrong_resource_type['Connection'] = ["eth0"] rasd_with_wrong_resource_type['VlanTag'] = pywbem.Uint64(2) rasds = [rasd_with_wrong_resource_type] network = self.__CreateNetwork(rasds) if network != None: print 'Virtual Switch was created when it shouldnt have' result = 0 except Exception, e: print 'Exception: %s' % str(e)
def _create_disk_image (self, sr_to_use): print sr_to_use.items() [system_id, sep, pool_id] = sr_to_use['InstanceID'].partition('/') print 'PoolID - %s' % pool_id new_disk_sasd = CIMInstance('Xen_DiskSettingData') new_disk_sasd['ElementName'] = sys._getframe(0).f_code.co_name new_disk_sasd['ResourceType'] = pywbem.Uint16(19) new_disk_sasd['ResourceSubType'] = "Disk" new_disk_sasd['VirtualQuantity'] = pywbem.Uint64(2048) new_disk_sasd['AllocationUnits'] = "MegaBytes" new_disk_sasd['Bootable'] = False new_disk_sasd['Access'] = pywbem.Uint8(3) new_disk_sasd['PoolID'] = pool_id in_params = {"ResourceSetting": new_disk_sasd} [rc, out_params] = self.conn.InvokeMethod("CreateDiskImage", self.spms[0], **in_params) new_disk = out_params["ResultingDiskImage"] print "Created Disk" print new_disk.items() return [rc, new_disk]
def CreateDiskImage(conn, spms, sr_to_use, size_in_bytes, name): print sr_to_use.items() [system_id, sep, pool_id] = sr_to_use['InstanceID'].partition('/') print 'PoolID - %s' % pool_id new_disk_sasd = CIMInstance('Xen_DiskSettingData') new_disk_sasd['ElementName'] = name new_disk_sasd['ResourceType'] = pywbem.Uint16(19) new_disk_sasd['ResourceSubType'] = "Disk" new_disk_sasd['VirtualQuantity'] = pywbem.Uint64(size_in_bytes) new_disk_sasd['AllocationUnits'] = "Bytes" new_disk_sasd['Bootable'] = False new_disk_sasd['Access'] = pywbem.Uint8(3) new_disk_sasd['PoolID'] = pool_id in_params = {"ResourceSetting": new_disk_sasd} [rc, out_params] = conn.InvokeMethod("CreateDiskImage", spms, **in_params) new_disk = out_params["ResultingDiskImage"] print "Created Disk" print new_disk.items() return [rc, new_disk]
def get_num(self, numStr, datatype): """Get the ecom int from the number. :param numStr: the number in string format :param datatype: the type to convert it to :returns: result """ try: result = { '8': pywbem.Uint8(numStr), '16': pywbem.Uint16(numStr), '32': pywbem.Uint32(numStr), '64': pywbem.Uint64(numStr) } result = result.get(datatype, numStr) except NameError: result = numStr return result
def removeNonExistingResources(self): self.TestBegin() local_disk_rasd = CIMInstance('CIM_ResourceAllocationSettingData') local_disk_rasd['PoolID'] = self.DiskPoolID local_disk_rasd['Elementname'] = self.__class__.__name__ + '_Disk1' local_disk_rasd['ResourceType'] = pywbem.Uint16(19) local_disk_rasd['ResourceSubType'] = "Disk" local_disk_rasd['VirtualQuantity'] = pywbem.Uint64(2147483648) local_disk_rasd['AllocationUnits'] = "Bytes" rasds_to_delete = [] rasds_to_delete.append(local_disk_rasd) in_params = {'ResourceSettings': rasds_to_delete} n = DeleteVMResources(self.conn, self.vsms[0], in_params) result = 0 if (n == 1): print "Deleted non existing resource" result = 0 else: result = 1 self.TestEnd(result)
def get_value(string): vtype, value = string.split(',', 1) if vtype == 'str': return str(value) elif vtype == 'uint8': return pywbem.Uint8(value) elif vtype == 'sint8': return pywbem.Sint8(value) elif vtype == 'uint16': return pywbem.Uint16(value) elif vtype == 'sint16': return pywbem.Sint16(value) elif vtype == 'uint32': return pywbem.Uint32(value) elif vtype == 'sint32': return pywbem.Sint32(value) elif vtype == 'uint64': return pywbem.Uint64(value) elif vtype == 'sint64': return pywbem.Sint64(value) else: print "Input value is invalid : %s" % string sys.exit(1)
def _create_test_instance(ch, name_of_atom, number, time): """ Create a TestAtom instance. """ global _inst_paths new_instance = pywbem.CIMInstance('TestAtom') new_instance['Name'] = name_of_atom new_instance['boolProp'] = False #new_instance['char16Prop'] = #new_instance['char16Propa'] = Null new_instance['dateProp'] = time new_instance['real32Prop'] = pywbem.Real32(number) #new_instance['real32Propa'] = pywbem.CIMProperty('Real32Propa', \ type='Real32', is_array=True, value=None) new_instance['real32Propa'] = [pywbem.Real32(number), \ pywbem.Real32(number), \ pywbem.Real32(number)] new_instance['real64Prop'] = pywbem.Real64(number) new_instance['real64Propa'] = [pywbem.Real64(number), \ pywbem.Real64(number), \ pywbem.Real64(number)] new_instance['sint16Prop'] = pywbem.Sint16(number) new_instance['sint16Propa'] = [pywbem.Sint16(number), \ pywbem.Sint16(number), \ pywbem.Sint16(number)] new_instance['sint32Prop'] = pywbem.Sint32(number) new_instance['sint32Propa'] = [pywbem.Sint32(number), \ pywbem.Sint32(number), \ pywbem.Sint32(number)] new_instance['sint64Prop'] = pywbem.Sint64(number) new_instance['sint64Propa'] = [pywbem.Sint64(number), \ pywbem.Sint64(number), \ pywbem.Sint64(number)] new_instance['sint8prop'] = pywbem.Sint8(number) new_instance['sint8Propa'] = [pywbem.Sint8(number), \ pywbem.Sint8(number), \ pywbem.Sint8(number)] new_instance['stringProp'] = name_of_atom new_instance['stringPropa'] = ['proton', 'electron', 'neutron'] new_instance['uint16Prop'] = pywbem.Uint16(number) new_instance['uint16Propa'] = [pywbem.Uint16(number), \ pywbem.Uint16(number), \ pywbem.Uint16(number)] new_instance['uint32Prop'] = pywbem.Uint32(number) new_instance['uint32Propa'] = [pywbem.Uint32(number), \ pywbem.Uint32(number), \ pywbem.Uint32(number)] new_instance['uint64Prop'] = pywbem.Uint64(number) new_instance['uint64Propa'] = [pywbem.Uint64(number), \ pywbem.Uint64(number), \ pywbem.Uint64(number)] new_instance['uint8Prop'] = pywbem.Uint8(number) new_instance['uint8Propa'] = [pywbem.Uint8(number), \ pywbem.Uint8(number), \ pywbem.Uint8(number)] try: msg = '' cipath = ch.CreateInstance(new_instance) new_instance.path = cipath _inst_paths.append(cipath) except pywbem.CIMError, arg: raise
class TestMethods(unittest.TestCase): limits = { 'sint8_min': pywbem.Sint8(-128), 'sint8_max': pywbem.Sint8(127), 'sint16_min': pywbem.Sint16(-32768), 'sint16_max': pywbem.Sint16(32767), 'sint32_min': pywbem.Sint32(-2147483648), 'sint32_max': pywbem.Sint32(2147483647), 'sint64_min': pywbem.Sint64(-92233736854775808L), 'sint64_max': pywbem.Sint64(9223372036854775807L), 'uint8_min': pywbem.Uint8(0), 'uint8_max': pywbem.Uint8(0xFF), 'uint16_min': pywbem.Uint16(0), 'uint16_max': pywbem.Uint16(0xFFFF), 'uint32_min': pywbem.Uint32(0), 'uint32_max': pywbem.Uint32(0xFFFFFFFF), 'uint64_min': pywbem.Uint64(0L), 'uint64_max': pywbem.Uint64(0x7FFFFFFFFFFFFFFFL), 'real32_min': pywbem.Real32(-123456.78), 'real32_max': pywbem.Real32(123456.78), 'real64_min': pywbem.Real64(-12345678987654.32), 'real64_max': pywbem.Real64(12345678987654.32) } # note: the last Uint64 value should be 0xFFFFFFFFFFFFFFFF but there is a bug somewhere... inttypes = [ 'sint8', 'sint16', 'sint32', 'sint64', 'uint8', 'uint16', 'uint32', 'uint64' ] realtypes = ['real32', 'real64'] zeros = { 'sint8': pywbem.Sint8(0), 'sint16': pywbem.Sint16(0), 'sint32': pywbem.Sint32(0), 'sint64': pywbem.Sint64(0), 'uint8': pywbem.Uint8(0), 'uint16': pywbem.Uint16(0), 'uint32': pywbem.Uint32(0), 'uint64': pywbem.Uint64(0), 'real32': pywbem.Real32(0), 'real64': pywbem.Real64(0) } ones = { 'sint8': pywbem.Sint8(1), 'sint16': pywbem.Sint16(1), 'sint32': pywbem.Sint32(1), 'sint64': pywbem.Sint64(1), 'uint8': pywbem.Uint8(1), 'uint16': pywbem.Uint16(1), 'uint32': pywbem.Uint32(1), 'uint64': pywbem.Uint64(1), 'real32': pywbem.Real32(0), 'real64': pywbem.Real64(0) } tens = { 'sint8': pywbem.Sint8(10), 'sint16': pywbem.Sint16(10), 'sint32': pywbem.Sint32(10), 'sint64': pywbem.Sint64(10), 'uint8': pywbem.Uint8(10), 'uint16': pywbem.Uint16(10), 'uint32': pywbem.Uint32(10), 'uint64': pywbem.Uint64(10), 'real32': pywbem.Real32(10), 'real64': pywbem.Real64(10) } twenties = { 'sint8': pywbem.Sint8(20), 'sint16': pywbem.Sint16(20), 'sint32': pywbem.Sint32(20), 'sint64': pywbem.Sint64(20), 'uint8': pywbem.Uint8(20), 'uint16': pywbem.Uint16(20), 'uint32': pywbem.Uint32(20), 'uint64': pywbem.Uint64(20), 'real32': pywbem.Real32(20), 'real64': pywbem.Real64(20) } numlists = { 'sint8': [ pywbem.Sint8(8), pywbem.Sint8(2), pywbem.Sint8(5), pywbem.Sint8(6), pywbem.Sint8(3), pywbem.Sint8(9), pywbem.Sint8(7), pywbem.Sint8(1), pywbem.Sint8(4) ], 'sint16': [ pywbem.Sint16(8), pywbem.Sint16(2), pywbem.Sint16(5), pywbem.Sint16(6), pywbem.Sint16(3), pywbem.Sint16(9), pywbem.Sint16(7), pywbem.Sint16(1), pywbem.Sint16(4) ], 'sint32': [ pywbem.Sint32(8), pywbem.Sint32(2), pywbem.Sint32(5), pywbem.Sint32(6), pywbem.Sint32(3), pywbem.Sint32(9), pywbem.Sint32(7), pywbem.Sint32(1), pywbem.Sint32(4) ], 'sint64': [ pywbem.Sint64(8), pywbem.Sint64(2), pywbem.Sint64(5), pywbem.Sint64(6), pywbem.Sint64(3), pywbem.Sint64(9), pywbem.Sint64(7), pywbem.Sint64(1), pywbem.Sint64(4) ], 'uint8': [ pywbem.Uint8(8), pywbem.Uint8(2), pywbem.Uint8(5), pywbem.Uint8(6), pywbem.Uint8(3), pywbem.Uint8(9), pywbem.Uint8(7), pywbem.Uint8(1), pywbem.Uint8(4) ], 'uint16': [ pywbem.Uint16(8), pywbem.Uint16(2), pywbem.Uint16(5), pywbem.Uint16(6), pywbem.Uint16(3), pywbem.Uint16(9), pywbem.Uint16(7), pywbem.Uint16(1), pywbem.Uint16(4) ], 'uint32': [ pywbem.Uint32(8), pywbem.Uint32(2), pywbem.Uint32(5), pywbem.Uint32(6), pywbem.Uint32(3), pywbem.Uint32(9), pywbem.Uint32(7), pywbem.Uint32(1), pywbem.Uint32(4) ], 'uint64': [ pywbem.Uint64(8), pywbem.Uint64(2), pywbem.Uint64(5), pywbem.Uint64(6), pywbem.Uint64(3), pywbem.Uint64(9), pywbem.Uint64(7), pywbem.Uint64(1), pywbem.Uint64(4) ], 'real32': [ pywbem.Real32(8), pywbem.Real32(2), pywbem.Real32(5), pywbem.Real32(6), pywbem.Real32(3), pywbem.Real32(9), pywbem.Real32(7), pywbem.Real32(1), pywbem.Real32(4) ], 'real64': [ pywbem.Real64(8), pywbem.Real64(2), pywbem.Real64(5), pywbem.Real64(6), pywbem.Real64(3), pywbem.Real64(9), pywbem.Real64(7), pywbem.Real64(1), pywbem.Real64(4) ] } def _dbgPrint(self, msg=''): if self._verbose: if len(msg): print('\t -- %s --' % msg) else: print('') def setUp(self): unittest.TestCase.setUp(self) wconn = wbem_connection.wbem_connection() self.conn = wconn._WBEMConnFromOptions(_g_opts) for iname in self.conn.EnumerateInstanceNames('TestMethod'): self.conn.DeleteInstance(iname) self._verbose = _g_opts.verbose self._dbgPrint() def tearDown(self): unittest.TestCase.tearDown(self) for iname in self.conn.EnumerateInstanceNames('TestMethod'): self.conn.DeleteInstance(iname) def _run_and_validate_getrand(self, type, methodName, min, max, expectedReturnValue=None, minReturnValue=None, maxReturnValue=None): isRealType = False if type.startswith('real'): isRealType = True if isRealType: self._dbgPrint('Testing %s invocation with min=%f, max=%f' % (methodName, min, max)) else: self._dbgPrint('Testing %s invocation with min=%d, max=%d' % (methodName, min, max)) (rv, oparams) = self.conn.InvokeMethod(methodName, 'TestMethod', min=min, max=max) if not oparams['success']: self.fail( '"Success" reported as false for invocation of method %s' % methodName) if expectedReturnValue is not None: if isRealType: self._dbgPrint( 'Verifying return value (%f) equal to expected return value %f...' % (rv, expectedReturnValue)) if abs(expectedReturnValue - rv) > real_tolerance: self.fail( 'Return value not as expected for invocation of method %s' % methodName) else: self._dbgPrint( 'Verifying return value (%d) equal to expected return value %d...' % (rv, expectedReturnValue)) if expectedReturnValue != rv: self.fail( 'Return value not as expected for invocation of method %s' % methodName) self._dbgPrint('Return value is as expected.') if minReturnValue is not None: if isRealType: self._dbgPrint('Verifying return value (%f) >= %f' % (rv, minReturnValue)) else: self._dbgPrint('Verifying return value (%d) >= %d' % (rv, minReturnValue)) if rv < minReturnValue: self.fail( 'Return value less than expected for invocation of method %s' % methodName) self._dbgPrint('Return value is as expected.') if maxReturnValue is not None: if isRealType: self._dbgPrint('Verifying return value (%f) <= %f' % (rv, maxReturnValue)) else: self._dbgPrint('Verifying return value (%d) <= %d' % (rv, maxReturnValue)) if rv > maxReturnValue: self.fail( 'Return value greater than expected for invocation of method %s' % methodName) self._dbgPrint('Return value is as expected.') def _run_and_validate_getrandlist(self, type, methodName, min, max, nelems): isRealType = False if type.startswith('real'): isRealType = True if isRealType: self._dbgPrint('Testing %s invocation with min=%f, max=%f' % (methodName, min, max)) else: self._dbgPrint('Testing %s invocation with min=%d, max=%d' % (methodName, min, max)) (rv, oparams) = self.conn.InvokeMethod(methodName, 'TestMethod', lo=min, hi=max, nelems=nelems) if not rv: self.fail('Invocation of %s returned false success value.' % methodName) self._dbgPrint('Invocation of %s returned successfully.' % methodName) if isRealType: self._dbgPrint('Validating lo (%f) and hi (%f) outparams...' % (min, max)) if abs(oparams['lo'] - min) > real_tolerance: self.fail( 'Returned low range value (%f) not equal to specified value (%f).' % (oparams['lo'], min)) if abs(oparams['hi'] - max) > real_tolerance: self.fail( 'Returned high range value (%f) not equal to specified value (%f).' % (oparams['hi'], max)) else: self._dbgPrint('Validating lo (%d) and hi (%d) outparams...' % (min, max)) if oparams['lo'] != min: self.fail( 'Returned low range value (%d) not equal to specified value (%d).' % (oparams['lo'], min)) if oparams['hi'] != max: self.fail( 'Returned high range value (%d) not equal to specified value (%d).' % (oparams['hi'], max)) self._dbgPrint('Lo and hi outparams validated successfully.') self._dbgPrint('Validating random list values...') if oparams['nlist'] is None: self.fail('Expected a list of values but got none.') if len(oparams['nlist']) != nelems: self.fail('Expected a list of %d items but got %d items instead.' % (nelems, len(oparams['nlist']))) minkey = '%s_min' % type maxkey = '%s_max' % type for num in oparams['nlist']: if num < TestMethods.limits[minkey] or \ num > TestMethods.limits[maxkey]: if isRealType: self.fail( 'List element %f not in expected range for type %s.' % (num, type)) else: self.fail( 'List element %d not in expected range for type %s.' % (num, type)) self._dbgPrint('Random list values validated successfully.') def _run_and_validate_minmedmax(self, type, methodName, numlist): self._dbgPrint('Testing %s invocation' % methodName) (rv, oparams) = self.conn.InvokeMethod(methodName, 'TestMethod', numlist=numlist) if not rv: self.fail('Invocation of %s returned false success value.' % methodName) self._dbgPrint('Invocation of %s returned successfully.' % methodName) self._dbgPrint('Validating min, median, and max outparams...') if oparams['min'] != 1: self.fail('Expected min of 1 but instead got %d' % oparams['min']) if oparams['max'] != 9: self.fail('Expected max of 9 but instead got %d' % oparams['max']) if oparams['med'] != 5: self.fail('Expected median of 5 but instead got %d' % oparams['med']) self._dbgPrint('Min, median, and max values validated successfully.') def _run_numeric_type_tests(self, typelist): gr = self._run_and_validate_getrand grl = self._run_and_validate_getrandlist mmm = self._run_and_validate_minmedmax for type in typelist: method = 'genRand_%s' % type minkey = '%s_min' % type maxkey = '%s_max' % type min = TestMethods.limits[minkey] max = TestMethods.limits[maxkey] gr(type, method, min, max, None, min, max) gr(type, method, min, min, min) gr(type, method, max, max, max) if min != 0: gr(type, method, TestMethods.zeros[type], TestMethods.zeros[type], TestMethods.zeros[type]) gr(type, method, TestMethods.tens[type], TestMethods.twenties[type], None, TestMethods.tens[type], TestMethods.twenties[type]) # the next two should cause exceptions; getting a TypeError exception is not an error in this case. try: gr(type, method, min - 1, min - 1, min - 1) except TypeError: pass try: gr(type, method, max + 1, max + 1, max + 1) except TypeError: pass method = 'genRandList_%s' % type nelems = _typed_randrange(TestMethods.tens[type], TestMethods.twenties[type], type) grl(type, method, min, max, nelems) grl(type, method, min, max, TestMethods.ones[type]) grl(type, method, min, max, TestMethods.zeros[type]) if min != 0: grl(type, method, TestMethods.zeros[type], max, nelems) else: grl(type, method, min, TestMethods.zeros[type], nelems) grl(type, method, TestMethods.tens[type], TestMethods.twenties[type], nelems) grl(type, method, TestMethods.tens[type], TestMethods.twenties[type], TestMethods.ones[type]) grl(type, method, TestMethods.tens[type], TestMethods.twenties[type], TestMethods.zeros[type]) method = 'minmedmax_%s' % type mmm(type, method, TestMethods.numlists[type]) def test_integer_types(self): self._run_numeric_type_tests(TestMethods.inttypes) def test_real_types(self): self._run_numeric_type_tests(TestMethods.realtypes) def test_refs(self): inst = pywbem.CIMInstance('TestMethod', properties={ 'id': 'one', 'p_str': 'One', 'p_sint32': pywbem.Sint32(1) }) self.conn.CreateInstance(inst) iname = pywbem.CIMInstanceName('TestMethod', namespace='root/cimv2', keybindings={'id': 'one'}) rv, outs = self.conn.InvokeMethod('getStrProp', iname) self.assertEquals(rv, 'One') rv, outs = self.conn.InvokeMethod('setStrProp', iname, value='won') self.assertFalse(outs) self.assertEquals(rv, 'One') rv, outs = self.conn.InvokeMethod('getStrProp', iname) self.assertEquals(rv, 'won') inst = self.conn.GetInstance(iname) self.assertEquals(inst['p_str'], 'won') rv, outs = self.conn.InvokeMethod('getIntProp', iname) self.assertEquals(rv, 1) self.assertTrue(isinstance(rv, pywbem.Sint32)) self.assertEquals(inst['p_sint32'], 1) rv, outs = self.conn.InvokeMethod('setIntProp', iname, value=pywbem.Sint32(2)) self.assertTrue(isinstance(rv, pywbem.Sint32)) self.assertEquals(rv, 1) self.assertFalse(outs) rv, outs = self.conn.InvokeMethod('getIntProp', iname) self.assertEquals(rv, 2) self.assertTrue(isinstance(rv, pywbem.Sint32)) inst = self.conn.GetInstance(iname) self.assertEquals(inst['p_sint32'], 2) rv, outs = self.conn.InvokeMethod('getObjectPath', 'TestMethod') self.assertTrue(isinstance(outs['path'], pywbem.CIMInstanceName)) self.assertEquals(outs['path']['id'], 'one') inst = pywbem.CIMInstance('TestMethod', properties={ 'id': 'two', 'p_str': 'Two', 'p_sint32': pywbem.Sint32(2) }) self.conn.CreateInstance(inst) rv, outs = self.conn.InvokeMethod('getObjectPaths', 'TestMethod') self.assertEquals(len(outs['paths']), 2) self.assertTrue(isinstance(outs['paths'][0], pywbem.CIMInstanceName)) to_delete = outs['paths'] inst = pywbem.CIMInstance('TestMethod', properties={ 'id': 'three', 'p_str': 'Three', 'p_sint32': pywbem.Sint32(3) }) self.conn.CreateInstance(inst) iname = pywbem.CIMInstanceName('TestMethod', namespace='root/cimv2', keybindings={'id': 'three'}) inames = self.conn.EnumerateInstanceNames('TestMethod') self.assertEquals(len(inames), 3) rv, outs = self.conn.InvokeMethod('delObject', 'TestMethod', path=iname) inames = self.conn.EnumerateInstanceNames('TestMethod') self.assertEquals(len(inames), 2) self.conn.CreateInstance(inst) ''' # OpenWBEM is broken! uncomment this for Pegasus. ''' rv, outs = self.conn.InvokeMethod('delObjects', 'TestMethod', paths=to_delete) inames = self.conn.EnumerateInstanceNames('TestMethod') self.assertEquals(len(inames), 1) self.assertEquals(inames[0]['id'], 'three') def test_mkUniStr_sint8(self): s = 'Scrum Rocks!' l = [pywbem.Sint8(ord(x)) for x in s] rv, outs = self.conn.InvokeMethod('mkUniStr_sint8', 'TestMethod', cArr=l) self.assertFalse(outs) self.assertEquals(rv, s) rv, outs = self.conn.InvokeMethod('mkUniStr_sint8', 'TestMethod', cArr=[]) self.assertEquals(rv, '') def test_strCat(self): ra = ['one', 'two', 'three', 'four'] rv, outs = self.conn.InvokeMethod('strCat', 'TestMethod', strs=ra, sep=',') self.assertEquals(rv, ','.join(ra)) self.assertFalse(outs) def test_strSplit(self): ra = 'one,two,three,four' rv, outs = self.conn.InvokeMethod('strSplit', 'TestMethod', str=ra, sep=',') self.assertEquals(outs['elems'], ra.split(',')) self.assertTrue(ra) def test_getDate(self): dt = pywbem.CIMDateTime.now() rv, outs = self.conn.InvokeMethod('getDate', 'TestMethod', datestr=str(dt)) self.assertFalse(outs) self.assertEquals(rv, dt) self.assertEquals(str(rv), str(dt)) self.assertTrue(isinstance(rv, pywbem.CIMDateTime)) def test_getDates(self): dt = pywbem.CIMDateTime.now() s1 = str(dt) ra = [s1] dt = pywbem.CIMDateTime(pywbem.datetime.now() + \ pywbem.timedelta(seconds=10)) s2 = str(dt) ra.append(s2) dt = pywbem.CIMDateTime(pywbem.datetime.now() + \ pywbem.timedelta(seconds=10)) s3 = str(dt) ra.append(s3) rv, outs = self.conn.InvokeMethod('getDates', 'TestMethod', datestrs=ra) self.assertTrue(rv) self.assertTrue(isinstance(rv, bool)) self.assertEquals(outs['nelems'], len(ra)) self.assertTrue(isinstance(outs['nelems'], pywbem.Sint32)) for i in range(0, len(ra)): self.assertTrue(isinstance(outs['elems'][i], pywbem.CIMDateTime)) self.assertEquals(str(outs['elems'][i]), ra[i]) def test_minmedmax(self): for tstr in [ 'Sint8', 'Uint8', 'Sint16', 'Uint16', 'Sint32', 'Uint32', 'Sint64', 'Uint64', 'Real32', 'Real64' ]: dt = getattr(pywbem, tstr) method = 'minmedmax_%s' % tstr numlist = [ dt(2), dt(5), dt(8), dt(1), dt(9), dt(6), dt(4), dt(7), dt(3), ] rv, outs = self.conn.InvokeMethod(method, 'TestMethod', numlist=numlist) self.assertTrue(rv) self.assertTrue(isinstance(rv, bool)) self.assertTrue(isinstance(outs['min'], dt)) self.assertTrue(isinstance(outs['med'], dt)) self.assertTrue(isinstance(outs['max'], dt)) self.assertEquals(outs['min'], 1) self.assertEquals(outs['max'], 9) self.assertEquals(outs['med'], 5)
def get_instance(self, env, model, cim_class, stat=None): """Return an instance. Keyword arguments: env -- Provider Environment model -- A template of the CIMInstance to be returned. The key properties are set on this instance to correspond to the instanceName that was requested. The properties of the model are already filtered according to the PropertyList from the request. cim_class -- The CIMClass Possible Errors: CIM_ERR_ACCESS_DENIED CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters) CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM Instance does not exist in the specified namespace) CIM_ERR_FAILED (some other unspecified error occurred) """ if stat is None: stat = os.stat(model['lfname']) statvfs = os.statvfs(model['lfname']) mode = stat[ST_MODE] model['SetUid'] = bool(mode & S_ISUID) model['HealthState'] = self.Values_HealthState.OK #model['PosixSyncIo'] = # TODO (type = uint64) #model['StatusDescriptions'] = # TODO (type = string[]) model['GroupWritable'] = bool(mode & S_IWGRP) #model['PosixChownRestricted'] = # TODO (type = uint64) model['LinkCount'] = pywbem.Uint64(stat[ST_NLINK]) model['UserWritable'] = bool(mode & S_IWUSR) #model['LinkMax'] = # TODO (type = uint64) model['OperationalStatus'] = [self.Values_OperationalStatus.OK] model['SetGid'] = bool(mode & S_ISGID) model['SaveText'] = bool(mode & S_ISVTX) try: gid = grp.getgrgid(stat[ST_GID])[0] except KeyError: gid = str(stat[ST_GID]) model['GroupID'] = gid model['UserExecutable'] = bool(mode & S_IXUSR) #model['Status'] = # TODO (type = string) #model['Description'] = # TODO (type = string) #model['InstallDate'] = # TODO (type = datetime) #model['LastModifiedInode'] = # TODO (type = datetime) model['WorldReadable'] = bool(mode & S_IROTH) #model['PosixPrioIo'] = # TODO (type = uint64) #model['PathMax'] = # TODO (type = uint64) model['WorldExecutable'] = bool(mode & S_IXOTH) model['GroupReadable'] = bool(mode & S_IRGRP) model['NameMax'] = pywbem.Uint64(statvfs[F_NAMEMAX]) model['Name'] = model['lfname'] model['ElementName'] = model['name'] == '/' and '/' or \ os.path.basename(model['name']) try: uid = pwd.getpwuid(stat[ST_UID])[0] except: uid = str(stat[ST_UID]) model['UserID'] = uid model['UserReadable'] = bool(mode & S_IRUSR) model['GroupExecutable'] = bool(mode & S_IXGRP) #model['Caption'] = # TODO (type = string) #model['PosixAsyncIo'] = # TODO (type = uint64) model['WorldWritable'] = bool(mode & S_IWOTH) #model['PosixNoTrunc'] = # TODO (type = uint64) model['FileInodeNumber'] = str(stat[ST_INO]) return model
rasd_with_wrong_resource_type['VlanTag'] = pywbem.Uint64(2) rasds = [rasd_with_wrong_resource_type] network = self.__CreateNetwork(rasds) if network != None: print 'Virtual Switch was created when it shouldnt have' result = 0 except Exception, e: print 'Exception: %s' % str(e) # RASD where Connection property is of invalid type print 'Error Test: bad RASD with bad Connection property' try: rasd_with_wrong_connection = CIMInstance( 'CIM_ResourceAllocationSettingData') rasd_with_wrong_connection['ResourceType'] = pywbem.Uint16(33) rasd_with_wrong_connection['Connection'] = pywbem.Uint32(1234) rasd_with_wrong_connection['VlanTag'] = pywbem.Uint64(2) rasds = [rasd_with_wrong_connection] network = self.__CreateNetwork(rasds) if network != None: print 'Virtual Switch was created when it shouldnt have' result = 0 except Exception, e: print 'Exception: %s' % str(e) self.TestEnd(result) def DeleteNetworkErrorTests(self): self.TestBegin() result = 1 # specify a bad (non-existent) switch reference print 'Error Test: Bad switch reference'
def create_partition(ns, device, size=None, partition_type=None): """ Create new partition on given device. :type device: LMIInstance/CIM_StorageExtent or string :param device: Device which should be partitioned. :type size: int :param size: Size of the device, in blocks. See device's BlockSize to get it. If no size is provided, the largest possible partition is created. :type partition_type: int :param partition_type: Requested partition type. See PARTITION_TYPE_xxx variables. If no type is given, extended partition will be automatically created as 4th partition on MS-DOS style partition table with a logical partition with requested size on it. :rtype: LMIInstance/CIM_GenericDiskPartition. """ device = common.str2device(ns, device) setting = None try: args = {'extent': device} if size: args['Size'] = pywbem.Uint64(size) if partition_type: # create a setting and modify it caps = ns.LMI_DiskPartitionConfigurationCapabilities\ .first_instance() (ret, outparams, err) = caps.CreateSetting() if ret != 0: if err: LmiFailed("Cannot create " \ "LMI_DiskPartitionConfigurationSetting for the " \ "partition: %s." % err) raise LmiFailed("Cannot create " \ "LMI_DiskPartitionConfigurationSetting for the " \ "partition: %d." % ret) setting = outparams['setting'].to_instance() setting.PartitionType = pywbem.Uint16(partition_type) (ret, _outparams, err) = setting.push() if ret != 0: if err: raise LmiFailed("Cannot change " \ "LMI_DiskPartitionConfigurationSetting for the " \ "partition: %s." % err) raise LmiFailed("Cannot change " \ "LMI_DiskPartitionConfigurationSetting for the " \ "partition: %d." % ret) args['Goal'] = setting service = ns.LMI_DiskPartitionConfigurationService.first_instance() (ret, outparams, err) = service.SyncLMI_CreateOrModifyPartition(**args) if ret != 0: if err: raise LmiFailed("Cannot create the partition: %s." % err) values = service.LMI_CreateOrModifyPartition\ .LMI_CreateOrModifyPartitionValues raise LmiFailed("Cannot create the partition: %s." % (values.value_name(ret))) finally: if setting: setting.delete() return outparams['Partition']
def get_instance(self, env, model, withCleanup=True): """Return an instance. Keyword arguments: env -- Provider Environment (pycimmb.ProviderEnvironment) model -- A template of the pywbem.CIMInstance to be returned. The key properties are set on this instance to correspond to the instanceName that was requested. The properties of the model are already filtered according to the PropertyList from the request. Only properties present in the model need to be given values. If you prefer, you can set all of the values, and the instance will be filtered for you. Possible Errors: CIM_ERR_ACCESS_DENIED CIM_ERR_INVALID_PARAMETER (including missing, duplicate, unrecognized or otherwise incorrect parameters) CIM_ERR_NOT_FOUND (the CIM Class does exist, but the requested CIM Instance does not exist in the specified namespace) CIM_ERR_FAILED (some other unspecified error occurred) """ logger = env.get_logger() logger.log_debug('Entering %s.get_instance()' \ % self.__class__.__name__) if withCleanup: self._populateTroveCache() troveId = model['InstanceID'] nvf, isInstalled = self._conarySoftwareMap[troveId] modelName = modelDescription = nvf[0] if isInstalled is self.installationService.SystemModelType: # We use the system model's file mtime as the version timestamp verTimestamp = int(nvf[2]) operatingStatus = self.Values.OperatingStatus.In_Service productLabel = self.installationService.SystemModelElementName versionString = nvf[1] else: # Our timestamps are 32-bit, so we store the 2 MSB as buildNumber # and the 2LSB as the revision number. verTimestamp = int(nvf[1].trailingRevision().getTimestamp()) operatingStatus = ((isInstalled and self.Values.OperatingStatus.In_Service) or self.Values.OperatingStatus.Dormant) productLabel = str(nvf[1].trailingLabel()) versionString = "%s[%s]" % (nvf[1].freeze(), str(nvf[2])) buildNumber = verTimestamp & 0xFFFF revisionNumber = (verTimestamp & 0xFFFF0000) >> 16 vendorURL = 'http://www.rpath.org/rbuilder' model['BuildNumber'] = pywbem.Uint16(buildNumber) #model['Caption'] = '' # TODO #model['ClassificationDescriptions'] = ['',] # TODO #model['Classifications'] = [self.Values.Classifications.<VAL>,] # TODO #model['CommunicationStatus'] = self.Values.CommunicationStatus.<VAL> # TODO model['Description'] = modelDescription #model['DetailedStatus'] = self.Values.DetailedStatus.<VAL> # TODO model['ElementName'] = modelName #model['ExtendedResourceType'] = self.Values.ExtendedResourceType.<VAL> # TODO #model['Generation'] = pywbem.Uint64() # TODO model['HealthState'] = self.Values.HealthState.OK # XXX Some of these have hard-coded values model['IdentityInfoType'] = [ 'VMware-VAMI:VendorUUID', 'VMware-VAMI:ProductRID', 'VMware-VAMI:VendorURL', 'VMware-VAMI:ProductURL', 'VMware-VAMI:SupportURL', 'VMware-VAMI:UpdateInfo' ] model['IdentityInfoValue'] = [ 'com.rpath', productLabel, vendorURL, 'http://www.rpath.org/project/remote-update', vendorURL, '' ] #model['InstallDate'] = pywbem.CIMDateTime() # TODO model['IsEntity'] = True model['IsLargeBuildNumber'] = True #model['Languages'] = ['',] # TODO model['LargeBuildNumber'] = pywbem.Uint64(verTimestamp) model['MajorVersion'] = pywbem.Uint16(0) model['Manufacturer'] = 'rPath, Inc.' #model['MinExtendedResourceTypeBuildNumber'] = pywbem.Uint16() # TODO #model['MinExtendedResourceTypeMajorVersion'] = pywbem.Uint16() # TODO #model['MinExtendedResourceTypeMinorVersion'] = pywbem.Uint16() # TODO #model['MinExtendedResourceTypeRevisionNumber'] = pywbem.Uint16() # TODO model['MinorVersion'] = pywbem.Uint16(0) model['Name'] = modelName model['OperatingStatus'] = operatingStatus #model['OperationalStatus'] = [self.Values.OperationalStatus.<VAL>,] # TODO #model['OtherExtendedResourceTypeDescription'] = '' # TODO model['PrimaryStatus'] = self.Values.PrimaryStatus.OK model['ReleaseDate'] = pywbem.CIMDateTime( utils.Time.format(verTimestamp)) model['RevisionNumber'] = pywbem.Uint16(revisionNumber) #model['SerialNumber'] = '' # TODO #model['Status'] = self.Values.Status.<VAL> # TODO #model['StatusDescriptions'] = ['',] # TODO #model['TargetOperatingSystems'] = ['',] # TODO model['TargetOSTypes'] = [ self.Values.TargetOSTypes.LINUX, ] #model['TargetTypes'] = ['',] # TODO model['VersionString'] = versionString if withCleanup: self._conarySoftwareMap.clear() return model
def __init__(self, Ip, userName, password, need_shared_storage=False, create_vms=True, logfile=None): dir = os.getcwd() if logfile == None: self.logfilename = sys._getframe(2).f_code.co_filename + ".log" else: self.logfilename = logfile print "Location of result log : " + self.logfilename self.oldstdout = sys.stdout self.oldstderr = sys.stderr self.logfile = open(self.logfilename, 'w') sys.stdout = self.logfile sys.stderr = self.logfile print 'TestSetup...' verbose = "false" for arg in sys.argv: if arg == "verbose": verbose = "true" # some useful counters self.TestsPassed = 0 self.TestsFailed = 0 self.TestFailedDescriptions = "" #self.inputMsg = ">" self.IPAddress = Ip self.UserName = userName self.Password = password self.hvmname = 'test-hvm-vm' self.pvname = 'test-pv-vm' self.pv_test_vm = None self.hvm_test_vm = None # create a CIM connection to the server self.conn = pywbem.WBEMConnection('http://' + self.IPAddress, (self.UserName, self.Password)) # Enumerate the Xen Pool my_pool = None pools = self.conn.EnumerateInstances("Xen_HostPool") if len(pools) != 0: my_pool = pools[0] # Enumerate all networks and pick an appropriate network to use network_to_use = None networks = self.conn.EnumerateInstances("Xen_NetworkConnectionPool") for network in networks: network_to_use = network # pick the first one ? this will be what the VM will be connected on break print "Using Network: %s (%s)" % (network_to_use['PoolID'], network_to_use['Name']) # Pick an appropriate SR for use in tests self.sr_to_use = None sr_to_use_local = None if my_pool != None: # Try the default storage of the host pool, if available if my_pool['DefaultStoragePoolID'] != None and my_pool[ 'DefaultStoragePoolID'] != '': print 'default storage pool id %s' % my_pool[ 'DefaultStoragePoolID'] #query_str = "SELECT * FROM Xen_StoragePool WHERE InstanceID = \""+my_pool['DefaultStoragePoolID']+"\"" query_str = "SELECT * FROM Xen_StoragePool WHERE InstanceID LIKE \"%" + my_pool[ 'DefaultStoragePoolID'] + "%\"" print 'Executing query: %s' % query_str defsrs = self.conn.ExecQuery("WQL", query_str, "root/cimv2") sr_to_use_local = defsrs[0] #sr_ref = CIMInstanceName(classname="Xen_StoragePool", keybindings={"InstanceID":'Xen:Shared\\'+my_pool["DefaultStoragePoolID"]}) #sr_to_use_local = self.conn.GetInstance(sr_ref) if sr_to_use_local == None: # No default SR is available srs = self.conn.EnumerateInstances("Xen_StoragePool") for sr in srs: if sr['ResourceSubType'] == 'nfs' or sr[ 'ResourceSubType'] == 'lvmoiscsi': sr_to_use_local = sr break elif need_shared_storage == False and sr[ 'Name'] == 'Local storage': sr_to_use_local = sr break print "Using SR: %s (%s)" % (sr_to_use_local["PoolID"], sr_to_use_local['Name']) # create CIM reference out of CIM instance self.sr_to_use = CIMInstanceName( classname=sr_to_use_local.classname, keybindings={"InstanceID": sr_to_use_local["InstanceID"]}) self.DiskPoolID = sr_to_use_local['PoolID'] # Get instance of Virtual System Management Service self.vsms = self.conn.EnumerateInstanceNames( "Xen_VirtualSystemManagementService") ################ Virtual System Setting Data (VSSD) ################ # VSSD for a PV VM type self.pv_vssd = CIMInstance("Xen_ComputerSystemSettingData") self.pv_vssd['Description'] = 'Test PV VM' self.pv_vssd['ElementName'] = self.__class__.__name__ + '_PV' self.pv_vssd['VirtualSystemType'] = 'DMTF:xen:PV' self.pv_vssd['PV_Bootloader'] = 'pygrub' self.pv_vssd['AutomaticShutdownAction'] = pywbem.Uint8(2) self.pv_vssd['AutomaticStartupAction'] = pywbem.Uint8(3) self.pv_vssd['AutomaticRecoveryAction'] = pywbem.Uint8(3) self.pv_vssd['PV_Args'] = 'Term=xterm' self.pv_vssd['Other_Config'] = ['HideFromXenCenter=false'] # Virtual System setting data for an HVM type self.hvm_vssd = CIMInstance("Xen_ComputerSystemSettingData") self.hvm_vssd['Description'] = 'Test HVM VM' self.hvm_vssd['ElementName'] = self.__class__.__name__ + '_HVM' self.hvm_vssd['VirtualSystemType'] = 'DMTF:xen:HVM' self.hvm_vssd['HVM_Boot_Params'] = ['order=dc'] self.hvm_vssd['HVM_Boot_Policy'] = 'BIOS order' self.hvm_vssd['Platform'] = ['acpi=true', 'apic=true', 'pae=true'] ####################################################################### # define all the Virtual System Resource Allocation Setting Data (RASD) ####################################################################### ####################################################################### # RASD to specify processor allocation for the VM # Processor RASD self.proc_rasd = CIMInstance('CIM_ResourceAllocationSettingData') self.proc_rasd['ResourceType'] = pywbem.Uint16(3) self.proc_rasd['VirtualQuantity'] = pywbem.Uint64(1) self.proc_rasd['AllocationUnits'] = 'count' # Another processor RASD with different limit/weight values self.proc1_rasd = self.proc_rasd.copy() self.proc1_rasd['VirtualQuantity'] = pywbem.Uint64(1) self.proc1_rasd['Limit'] = pywbem.Uint32( 95) # max host CPU it could take up in % self.proc1_rasd['Weight'] = pywbem.Uint32( 512) # relative weight between VCPUs (1-65536) # Processor RASD with wrong resource type self.invalid_proc_rasd = self.proc_rasd.copy() self.invalid_proc_rasd['ResourceType'] = pywbem.Uint32(10000) # processor RASD with no resource type specified, the classname has to be base class self.nort_proc_rasd = CIMInstance('CIM_ResourceAllocationSettingData') self.nort_proc_rasd['VirtualQuantity'] = pywbem.Uint64(1) self.nort_proc_rasd['AllocationUnits'] = 'count' # processor RASD with invalid quantity specified self.invalid_vq_proc_rasd = self.proc_rasd.copy() self.invalid_vq_proc_rasd['VirtualQuantity'] = pywbem.Uint64(10000) # plain old bad processor rasd - mixed types for properties self.bad_proc_rasd = self.proc_rasd.copy() self.bad_proc_rasd['ResourceType'] = '3' # string instead of integer self.bad_proc_rasd['VirtualQuantity'] = '1' self.bad_proc_rasd['AllocationUnits'] = pywbem.Uint8( 1) # integer instead of string self.bad_proc_rasd['Limit'] = '100' # string instead of integer ####################################################################### # memory RASD to specify memory allocation settings for a VM self.mem_rasd = CIMInstance('Xen_MemorySettingData') self.mem_rasd['ResourceType'] = pywbem.Uint16(4) self.mem_rasd['VirtualQuantity'] = pywbem.Uint64(512) self.mem_rasd['AllocationUnits'] = 'byte*2^20' # 2nd RASD to specify more memory self.mem1_rasd = self.mem_rasd.copy() self.mem1_rasd['VirtualQuantity'] = pywbem.Uint64(1024) # mix in wrong types (integers for strings, and strings for integers) self.bad_mem_rasd = self.mem_rasd.copy() self.bad_mem_rasd['AllocationUnits'] = pywbem.Uint32(20) self.bad_mem_rasd['VirtualQuantity'] = "1024" self.bad_mem_rasd['ResourceType'] = "4" ####################################################################### # Resource Allocation Settings to specify Virtual Disk allocation # Start off with a CD drive self.disk0_rasd = CIMInstance('Xen_DiskSettingData') self.disk0_rasd['ElementName'] = self.__class__.__name__ + '_CDRom' self.disk0_rasd['ResourceType'] = pywbem.Uint16(15) # DVD Drive self.disk0_rasd['ResourceSubType'] = 'CD' # self.disk1_rasd['PoolID'] = '<SR ID>' # (No need to specify a SR or VDI, should create an empty DVD # self.disk1_rasd['HostResource'] = '<VDI ID>' # (No need to specify a SR or VDI, should create an empty DVD self.disk0_rasd['Bootable'] = True self.disk0_rasd['Access'] = pywbem.Uint8(1) # A virtual disk of 2 GB size self.disk1_rasd = self.disk0_rasd.copy() self.disk1_rasd['PoolID'] = sr_to_use_local['PoolID'] self.disk1_rasd['ElementName'] = self.__class__.__name__ + '_Disk1' self.disk1_rasd['ResourceType'] = pywbem.Uint16(19) # Storage extent self.disk1_rasd['ResourceSubType'] = 'Disk' self.disk1_rasd['VirtualQuantity'] = pywbem.Uint64(2147483648) # 2GB self.disk1_rasd['AllocationUnits'] = 'byte' # Another virtual disk of 2 GB size self.disk2_rasd = self.disk0_rasd.copy() self.disk2_rasd['PoolID'] = sr_to_use_local['PoolID'] self.disk2_rasd['ResourceType'] = pywbem.Uint16(19) # Storage extent self.disk2_rasd['ResourceSubType'] = 'Disk' self.disk2_rasd['ElementName'] = self.__class__.__name__ + '_Disk2' self.disk2_rasd['VirtualQuantity'] = pywbem.Uint64(2147483648) # 2GB self.disk2_rasd['AllocationUnits'] = 'byte' # mix in wrong types (integers for strings, and strings for integers) self.bad_disk_rasd = self.disk0_rasd.copy() self.bad_disk_rasd['PoolID'] = sr_to_use_local['PoolID'] self.bad_disk_rasd['ElementName'] = pywbem.Uint8(1) self.bad_disk_rasd['ResourceType'] = '15' self.bad_disk_rasd['HostResource'] = pywbem.Uint16(12345) self.bad_disk_rasd['Bootable'] = pywbem.Uint8(1) # create a disk out of a non-existent SR self.invalid_poolId_rasd = self.disk0_rasd.copy() self.invalid_poolId_rasd[ 'PoolId'] = 'ed1bd47e-1ab8-d80a-aecf-06447871211c' # Specify bad allocation units self.invalid_aunits_rasd = self.disk0_rasd.copy() self.invalid_aunits_rasd['PoolID'] = sr_to_use_local['PoolID'] self.invalid_poolId_rasd['AllocationUnits'] = 'KiloMeters' ####################################################################### # Specify the network connection resource allocation setting data # The system will create a virtual NIC for each resource # self.nic_rasd = CIMInstance('Xen_NetworkPortSettingData') self.nic_rasd['ResourceType'] = pywbem.Uint16( 33) # ethernet connection type self.nic_rasd[ 'Address'] = '00:13:72:24:32:f4' # manually generated MAC self.nic_rasd['PoolID'] = network_to_use['PoolID'] # NIC RASD With no mac address - generate one # NIC RASD with no ElementName either - pick next available address self.nic1_rasd = self.nic_rasd.copy() del self.nic1_rasd['Address'] # RASD with no resource type self.nort_nic_rasd = self.nic_rasd.copy() del self.nort_nic_rasd['ResourceType'] # RASD with bad MAC address specified self.invalid_nic_rasd = self.nic_rasd.copy() self.invalid_nic_rasd['Address'] = '00:13:72:24:32:rr' # mixed types for properties (strings for integers and vice versa) self.bad_nic_rasd = self.nic_rasd.copy() self.bad_nic_rasd['ResourceType'] = '33' # supposed to be a int self.bad_nic_rasd['ElementName'] = pywbem.Uint8( 0) # supposed to be a string self.bad_nic_rasd['Address'] = pywbem.Uint64( 001372243245) # supposed to be a string ####################################################################### # Create the test VMs if requested during the test # # Create the PV VM from the Demo Linux VM template (previously the Debian Etch Template) try: pv_template_list = self.conn.ExecQuery( "WQL", "SELECT * FROM Xen_ComputerSystemTemplate WHERE ElementName LIKE \"%XenServer Transfer VM%\"", "root/cimv2") self.pv_template = CIMInstanceName( classname=pv_template_list[0].classname, keybindings={"InstanceID": pv_template_list[0]["InstanceID"]}) self.rasds = [ self.proc_rasd, self.mem_rasd, self.disk0_rasd, self.disk1_rasd, self.nic_rasd ] self.hvm_params = { 'SystemSettings': self.hvm_vssd, 'ResourceSettings': self.rasds } self.pv_params = { 'SystemSettings': self.pv_vssd, 'ResourceSettings': self.rasds, 'ReferenceConfiguration': self.pv_template } self.pv_test_vm = None self.hvm_test_vm = None if create_vms: #print 'using template %s to create PV vm: ' % str(debian_template) print 'Creating PV vm' self.pv_test_vm = CreateVM(self.conn, self.vsms[0], self.pv_params) print 'Creating HVM vm' self.hvm_test_vm = CreateVM(self.conn, self.vsms[0], self.hvm_params) except Exception, e: print "Exception: %s. Has the TVM template been installed?" % e
def create_snapshot_error_tests(self): self.TestBegin() rc = 1 print 'Try with a bad snapshot setting' bad_snapshot_setting = CIMInstance('Xen_ComputerSystemSnapshot') bad_snapshot_setting['ElementName'] = pywbem.Uint64(12345) in_params = { 'AffectedSystem': self.test_vm, 'SnapshotSettings': bad_snapshot_setting } snapshot_ref = CreateVMSnapshot(self.conn, self.vsss[0], in_params) if snapshot_ref != None: print 'Snapshot created unexpectedly' rc = 0 print 'Try with a different bad snapshot setting' bad_snapshot_setting = CIMInstance('Xen_ComputerSystemSnapshot123') bad_snapshot_setting['ElementName'] = '12345' in_params = { 'AffectedSystem': self.test_vm, 'SnapshotSettings': bad_snapshot_setting } snapshot_ref = CreateVMSnapshot(self.conn, self.vsss[0], in_params) if snapshot_ref != None: print 'Snapshot created unexpectedly' rc = 0 print 'Try with an emtpy snapshot setting' bad_snapshot_setting = ''' ''' in_params = { 'AffectedSystem': self.test_vm, 'SnapshotSettings': bad_snapshot_setting } snapshot_ref = CreateVMSnapshot(self.conn, self.vsss[0], in_params) if snapshot_ref != None: print 'Snapshot created unexpectedly' rc = 0 print 'Try with a NULL snapshot setting' in_params = {'AffectedSystem': self.test_vm, 'SnapshotSettings': None} snapshot_ref = CreateVMSnapshot(self.conn, self.vsss[0], in_params) if snapshot_ref != None: print 'Snapshot created unexpectedly' rc = 0 print 'Try with a bad reference to an affected system' bad_test_vm = self.test_vm.copy() bad_test_vm['Name'] = 'bad-reference' in_params = { 'AffectedSystem': bad_test_vm, 'SnapshotSettings': self.snapshot_settings } snapshot_ref = CreateVMSnapshot(self.conn, self.vsss[0], in_params) if snapshot_ref != None: print 'Snapshot created unexpectedly' rc = 0 print 'Try with a NULL affected system' in_params = { 'AffectedSystem': None, 'SnapshotSettings': self.snapshot_settings } snapshot_ref = CreateVMSnapshot(self.conn, self.vsss[0], in_params) if snapshot_ref != None: print 'Snapshot created unexpectedly' rc = 0 print 'Try with no input parameters' in_params = {} snapshot_ref = CreateVMSnapshot(self.conn, self.vsss[0], in_params) if snapshot_ref != None: print 'Snapshot created unexpectedly' rc = 0 self.TestEnd(rc)
def create_new_PV_and_HVM_vms (conn, vsms): # # the metadata for a XenServer Paravirtualized VM we are going to create pv_virtualsystemsettingdata = pywbem.CIMInstance ("Xen_ComputerSystemSettingData") pv_virtualsystemsettingdata['Caption'] = "This is a PV VM" pv_virtualsystemsettingdata['ElementName'] = "test-pv-vm" pv_virtualsystemsettingdata['VirtualSystemType'] = "DMTF:xen:PV" pv_virtualsystemsettingdata['AutomaticShutdownAction'] = pywbem.Uint8(0) pv_virtualsystemsettingdata['AutomaticStarupAction'] = pywbem.Uint8(1) pv_virtualsystemsettingdata['AutomaticRecoveryAction'] = pywbem.Uint8(2) # the following are XenServer specific CIM extensions pv_virtualsystemsettingdata['PV_Bootloader'] = "pygrub" # use pygrub as the bootloader pv_virtualsystemsettingdata['PV_Bootloader_Args'] = "" pv_virtualsystemsettingdata['PV_Args'] = "Term=xterm" # We shall also base the PV VM on an existing XenServer template # This automatically allocates default proc/mem/disk/network resources specified by the template pv_template_list = conn.ExecQuery("WQL", "SELECT * FROM Xen_ComputerSystemTemplate WHERE ElementName LIKE \"%Debian Lenny%\"", "root/cimv2") reference_configuration = pywbem.CIMInstanceName(classname=pv_template_list[0].classname, keybindings={"InstanceID":pv_template_list[0]["InstanceID"]}) # The metadata settings for a XenServer HVM VM (Hardware Virtualized) we will create hvm_virtualsystemsettingdata = pywbem.CIMInstance("Xen_ComputerSystemSettingData") hvm_virtualsystemsettingdata['Caption'] = 'This is an HVM VM' hvm_virtualsystemsettingdata['ElementName'] = 'test-hvm-vm' hvm_virtualsystemsettingdata['VirtualSystemType'] = 'DMTF:xen:HVM' hvm_virtualsystemsettingdata['AutomaticShutdownAction'] = pywbem.Uint8(0) hvm_virtualsystemsettingdata['AutomaticStarupAction'] = pywbem.Uint8(1) hvm_virtualsystemsettingdata['AutomaticRecoveryAction'] = pywbem.Uint8(2) # the following are XenServer specific CIM extensions hvm_virtualsystemsettingdata['HVM_Boot_Params'] = ['order=dc'] # boot order is cd drive and then hard drive hvm_virtualsystemsettingdata['HVM_Boot_Policy'] = 'BIOS order' # boot based on the BIOS boot order specified above hvm_virtualsystemsettingdata['Platform'] = ['acpi=true','apic=true','pae=true'] # use ACPI, APIC, PAE emulation # # define all the resource settings (processor, memory, disk, network) # via ResourceAllocationSettingData instances # # processor proc_resource = pywbem.CIMInstance('CIM_ResourceAllocationSettingData') proc_resource['ResourceType'] = pywbem.Uint16(3) proc_resource['VirtualQuantity'] = pywbem.Uint64(1) proc_resource['AllocationUnits'] = "count" proc_resource['Limit'] = pywbem.Uint32(100) proc_resource['Weight'] = pywbem.Uint32(512) # memory mem_resource = pywbem.CIMInstance('CIM_ResourceAllocationSettingData') mem_resource['ResourceType'] = pywbem.Uint16(4) mem_resource['VirtualQuantity'] = pywbem.Uint64(512) mem_resource['AllocationUnits'] = 'byte*2^20' # DMTF way of specifying MegaBytes # disks sr_to_use = None # find all SRs available to us srs = conn.EnumerateInstances("Xen_StoragePool") for sr in srs: if sr['Name'] == 'Local storage': sr_to_use = sr disk_resource = pywbem.CIMInstance('Xen_DiskSettingData') disk_resource['Elementname'] = 'my_vm_disk' disk_resource['ResourceType'] = pywbem.Uint16(19) disk_resource['ResourceSubType'] = "Disk" # as opposed to "CD" disk_resource['VirtualQuantity'] = pywbem.Uint64(2048) disk_resource['AllocationUnits'] = "byte*2^20" # DMTF way of specifying MegaBytes disk_resource['Access'] = pywbem.Uint8(3) disk_resource['Bootable'] = False disk_resource['PoolID'] = sr_to_use['PoolID']# XenServer SR to allocate the disk out of # nic network_to_use = None # find all network switch connection pools available to us networks = conn.EnumerateInstances("Xen_NetworkConnectionPool") for network in networks: if network['Name'].find('eth0') != -1: network_to_use = network # only RASDs of type NetworkConnection (33) are supported nic_resource = pywbem.CIMInstance('Xen_NetworkPortSettingData') nic_resource['ResourceType'] = pywbem.Uint16(33) nic_resource['ElementName'] = "0" nic_resource['PoolID'] = network_to_use['PoolID']# Virtual Switch to connect to rasds = [proc_resource, mem_resource, disk_resource, nic_resource] hvm_params = {'SystemSettings': hvm_virtualsystemsettingdata, 'ResourceSettings': rasds } pv_params = {'SystemSettings': pv_virtualsystemsettingdata, 'ReferenceConfiguration': reference_configuration} print '*** Creating PV VM %s' % (pv_virtualsystemsettingdata['ElementName']) new_pv_vm_reference = create_vm_helper(conn, vsms, pv_params) print '*** Creating HVM VM %s' % (hvm_virtualsystemsettingdata['ElementName']) new_hvm_vm_reference = create_vm_helper(conn, vsms, hvm_params) if new_pv_vm_reference == None: print 'PV VM was not created' sys.exit(1) if new_hvm_vm_reference == None: print 'HVM VM was not created' sys.exit(1) return [new_pv_vm_reference, new_hvm_vm_reference]