# HG changeset patch
# User Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
# Date 1216734147 25200
# Node ID 6d1ac5c3497b95a230217f8c5f8b226c07fb1b31
# Parent 3703b7be5a107c67e901546978e974546b3d5562
[TEST] #2 Enabling 02_reverse.py with XenFV, KVM, LXC and modified logicaldevices.py to work for all virt types.
Changes:
-------
Patch 2:
-------
1) Added the missing cleanup_restore() fn in the tc.
In logicaldevices library:
--------------------------
1) Moved the common code from verify_proc_values(), verify_net_values(), verify_disk_values(), verify_mem_values() to verify_device_values().
2) Eliminated verify_proc_values() since it did not require any processor specific checks apart from the ones included in verify_device_values().
Patch 1:
--------
1) Removed unnecessary import statements.
2) Updated verify_proc_values, verify_mem_values, verify_net_values, verify_disk_values function of logicaldevices to work with all virt types.
3) Used verify_proc_values, verify_mem_values, verify_net_values, verify_disk_values fn.
4) Removed conf_file(), clean_up_restore(), get_or_bail(), print_error(), init_list(), get_spec_fields_list(), assoc_values() fns.
5) Removed global status variable.
6) Added verify_eafp_values(), init_pllist(), create_diskpool_conf() fn.
7) Included create_diskpool_conf(), cleanup_restore() fn.
Tested on KVM on rpm, KVM current sources, LXC, XenFV, Xen.
Signed-off-by: Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
diff -r 3703b7be5a10 -r 6d1ac5c3497b suites/libvirt-cim/cimtest/ElementAllocatedFromPool/02_reverse.py
--- a/suites/libvirt-cim/cimtest/ElementAllocatedFromPool/02_reverse.py Wed Jul 16 07:23:32 2008 -0700
+++ b/suites/libvirt-cim/cimtest/ElementAllocatedFromPool/02_reverse.py Tue Jul 22 06:42:27 2008 -0700
@@ -20,9 +20,8 @@
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
-
# This tc is used to verify the classname, InstanceID and certian prop are
-# are appropriately set for the domains when verified using the
+# appropriately set for the domains when verified using the
# Xen_ElementAllocatedFromPool asscoiation.
#
# Example command for LogicalDisk w.r.t to Xen_ElementAllocatedFromPool \
@@ -47,111 +46,79 @@
import sys
import os
-from distutils.file_util import move_file
import pywbem
-from VirtLib import utils
-from VirtLib import live
-from XenKvmLib import assoc
-from XenKvmLib import enumclass
-from CimTest import Globals
-from CimTest.Globals import do_main
-from CimTest.ReturnCodes import PASS, FAIL, SKIP
-from XenKvmLib.test_xml import testxml_bridge
-from XenKvmLib.test_doms import test_domain_function, destroy_and_undefine_all
-from VirtLib.live import network_by_bridge
+from XenKvmLib.assoc import Associators
+from XenKvmLib.vxml import get_class
+from CimTest.Globals import do_main, logger, CIM_ERROR_ASSOCIATORS
+from CimTest.ReturnCodes import PASS, FAIL
+from XenKvmLib.test_doms import destroy_and_undefine_all
+from XenKvmLib.classes import get_typed_class
+from XenKvmLib.common_util import create_diskpool_conf, cleanup_restore
+from XenKvmLib.logicaldevices import verify_device_values
-sup_types = ['Xen']
+sup_types = ['Xen' , 'KVM', 'XenFV', 'LXC']
-status = PASS
-test_dom = "hd_domain"
+test_dom = "eafp_domain"
test_mac = "00:11:22:33:44:aa"
test_mem = 128
test_vcpus = 4
-test_disk = "xvdb"
-test_dpath = "foo"
-disk_file = '/tmp/diskpool.conf'
-back_disk_file = disk_file + "." + "02_reverse"
-diskid = "%s/%s" % ("DiskPool", test_dpath)
-memid = "%s/%s" % ("MemoryPool", 0)
-procid = "%s/%s" % ("ProcessorPool", 0)
-def conf_file():
- """
- Creating diskpool.conf file.
- """
- try:
- f = open(disk_file, 'w')
- f.write('%s %s' % (test_dpath, '/'))
- f.close()
- except Exception,detail:
- Globals.logger.error("Exception: %s", detail)
- status = SKIP
- sys.exit(status)
+def init_pllist(virt, vsxml, diskid):
+ keys = {
+ 'MemoryPool' : 'MemoryPool/0',
+ }
+ if virt != 'LXC':
+ virt_network = vsxml.xml_get_net_network()
+ keys['DiskPool'] = diskid
+ keys['ProcessorPool'] = 'ProcessorPool/0'
+ keys['NetworkPool'] = 'NetworkPool/%s' %virt_network
-def clean_up_restore(ip):
- """
- Restoring back the original diskpool.conf
- file.
- """
- try:
- if os.path.exists(back_disk_file):
- os.remove(disk_file)
- move_file(back_disk_file, disk_file)
- except Exception, detail:
- Globals.logger.error("Exception: %s", detail)
- status = SKIP
- ret = test_domain_function(test_dom, ip, \
- cmd = "destroy")
- sys.exit(status)
-
+ pllist = { }
+ for cn, k in keys.iteritems():
+ cn = get_typed_class(virt, cn)
+ pllist[cn] = k
-def get_or_bail(ip, id, pool_class):
- """
- Getinstance for the CLass and return instance on success, otherwise
- exit after cleanup_restore and destroying the guest.
- """
- key_list = { 'InstanceID' : id }
- try:
- instance = enumclass.getInstance(ip, pool_class, key_list)
- except Exception, detail:
- Globals.logger.error(Globals.CIM_ERROR_GETINSTANCE, '%s', pool_class)
- Globals.logger.error("Exception: %s", detail)
- clean_up_restore(ip)
- status = FAIL
- ret = test_domain_function(test_dom, ip, \
- cmd = "destroy")
- sys.exit(status)
- return instance
+ return pllist
-def print_error(field, ret_val, req_val):
- Globals.logger.error("%s Mismatch", field)
- Globals.logger.error("Returned %s instead of %s", ret_val, req_val)
+def eafp_list(virt, test_disk):
+ mcn = get_typed_class(virt, "Memory")
+ mem = {
+ 'SystemName' : test_dom,
+ 'CreationClassName' : mcn,
+ 'DeviceID' : "%s/%s" % (test_dom, "mem"),
+ 'NumberOfBlocks' : test_mem * 1024
+ }
-def init_list(ip, disk, mem, net, proc):
- """
- Creating the lists that will be used for comparisons.
- """
+ eaf_values = { mcn : mem }
- pllist = {
- "Xen_DiskPool" : disk.InstanceID, \
- "Xen_MemoryPool" : mem.InstanceID, \
- "Xen_NetworkPool" : net.InstanceID, \
- "Xen_ProcessorPool": proc.InstanceID
- }
- cllist = [
- "Xen_LogicalDisk", \
- "Xen_Memory", \
- "Xen_NetworkPort", \
- "Xen_Processor"
- ]
- prop_list = ["%s/%s" % (test_dom, test_disk), test_disk, \
- "%s/%s" % (test_dom, "mem"), test_mem, \
- "%s/%s" % (test_dom, test_mac), test_mac
- ]
- proc_prop = []
- for i in range(test_vcpus):
- proc_prop.append("%s/%s" % (test_dom, i))
- return pllist, cllist, prop_list, proc_prop
+ if virt != 'LXC':
+ dcn = get_typed_class(virt, "LogicalDisk")
+ pcn = get_typed_class(virt, "Processor")
+ ncn = get_typed_class(virt, "NetworkPort")
+
+ disk = {
+ 'SystemName' : test_dom,
+ 'CreationClassName' : dcn,
+ 'DeviceID' : "%s/%s" % (test_dom, test_disk),
+ 'Name' : test_disk
+ }
+ proc = {
+ 'SystemName' : test_dom,
+ 'CreationClassName' : pcn,
+ 'DeviceID' : None
+ }
+ net = {
+ 'SystemName' : test_dom,
+ 'CreationClassName' : ncn,
+ 'DeviceID' : "%s/%s" % (test_dom, test_mac),
+ 'NetworkAddresses' : test_mac
+ }
+
+ eaf_values[pcn] = proc
+ eaf_values[dcn] = disk
+ eaf_values[ncn] = net
+
+ return eaf_values
def get_inst_for_dom(assoc_val):
list = []
@@ -162,196 +129,85 @@ def get_inst_for_dom(assoc_val):
return list
-def get_spec_fields_list(inst_list, field_name):
- global status
- specific_fields = { }
- if (len(inst_list)) != 1:
- Globals.logger.error("Got %s record for Memory/Network/LogicalDisk instead of \
-1", len(inst_list))
- status = FAIL
- return
-# verifying the Name field for LogicalDisk
- try:
- if inst_list[0]['CreationClassName'] != 'Xen_Memory':
- field_value = inst_list[0][field_name]
- if field_name == 'NetworkAddresses':
-# For network we NetworkAddresses is a list of addresses, since we
-# are assigning only one address we are taking field_value[0]
- field_value = field_value[0]
- else:
- field_value = ((int(inst_list[0]['NumberOfBlocks'])*4096)/1024)
- specific_fields = {
- "field_name" : field_name,\
- "field_value" : field_value
- }
- except Exception, detail:
- Globals.logger.error("Exception in get_spec_fields_list(): %s", detail)
- status = FAIL
- return specific_fields
+def verify_eafp_values(server, virt, in_pllist, test_disk):
+ # Looping through the in_pllist to get association for various pools.
+ eafp_values = eafp_list(virt, test_disk)
+ an = get_typed_class(virt, "ElementAllocatedFromPool")
+ for cn, instid in sorted(in_pllist.iteritems()):
+ try:
+ assoc_info = Associators(server, an, cn, virt, InstanceID = instid)
+ assoc_inst_list = get_inst_for_dom(assoc_info)
+ if len(assoc_inst_list) < 1 :
+ logger.error("'%s' with '%s' did not return any records for"
+ " domain: '%s'", an, cn, test_dom)
+ return FAIL
-def assoc_values(assoc_list, field , list, index, specific_fields_list=""):
- """
- Verifying the records retruned by the associations.
- """
- global status
- if field == "CreationClassName":
- for i in range(len(assoc_list)):
- if assoc_list[i][field] != list[index]:
- print_error(field, assoc_list[i][field], list[index])
- status = FAIL
+ assoc_eafp_info = assoc_inst_list[0]
+ CCName = assoc_eafp_info['CreationClassName']
+ if CCName == get_typed_class(virt, 'Processor'):
+ if len(assoc_inst_list) != test_vcpus:
+ logger.error("'%s' should have returned '%i' Processor"
+ " details, got '%i'", an, test_vcpus,
+ len(assoc_inst_list))
+ return FAIL
+
+ for i in range(test_vcpus):
+ eafp_values[CCName]['DeviceID'] = "%s/%s" % (test_dom,i)
+ status = verify_device_values(assoc_inst_list[i],
+ eafp_values, virt)
+ else:
+ status = verify_device_values(assoc_eafp_info,
+ eafp_values, virt)
+
if status != PASS:
- break
- elif field == "DeviceID":
- if assoc_list[0]['CreationClassName'] == 'Xen_Processor':
-# Verifying the list of DeviceId returned by the association
-# against the list created intially .
- for i in range(len(list)):
- if assoc_list[i]['DeviceID'] != list[i]:
- print_error(field, assoc_list[i]['DeviceID'], list[i])
- status = FAIL
- else:
-# Except for Xen_Processor, we get only once record for a domain for
-# other classes.
- if assoc_list[0]['DeviceID'] != list[index]:
- print_error(field, assoc_list[0]['DeviceID'] , list[index])
- status = FAIL
- else:
- # other specific fields verification
- if assoc_list[0]['CreationClassName'] != 'Xen_Processor':
- spec_field_name = specific_fields_list['field_name']
- spec_field_value = specific_fields_list['field_value']
- if spec_field_value != list[index]:
- print_error(field, spec_field_value, list[index])
- status = FAIL
-
+ return status
+ except Exception, detail:
+ logger.error(CIM_ERROR_ASSOCIATORS, an)
+ logger.error("Exception: %s", detail)
+ status = FAIL
+ return status
@do_main(sup_types)
def main():
options = main.options
- global status
loop = 0
server = options.ip
- destroy_and_undefine_all(options.ip)
- test_xml, bridge = testxml_bridge(test_dom, mem = test_mem, vcpus = test_vcpus, \
- mac = test_mac, disk = test_disk, server = options.ip)
- if bridge == None:
- Globals.logger.error("Unable to find virtual bridge")
- return SKIP
+ virt = options.virt
+ if virt == 'Xen':
+ test_disk = 'xvdb'
+ else:
+ test_disk = 'hda'
- if test_xml == None:
- Globals.logger.error("Guest xml was not created properly")
+ # Getting the VS list and deleting the test_dom if it already exists.
+ destroy_and_undefine_all(server)
+ virt_type = get_class(virt)
+ if virt == 'LXC':
+ vsxml = virt_type(test_dom, vcpus = test_vcpus)
+ else:
+ vsxml = virt_type(test_dom, mem = test_mem, vcpus = test_vcpus,
+ mac = test_mac, disk = test_disk)
+
+ # Verify DiskPool on machine
+ status, diskid = create_diskpool_conf(server, virt)
+ if status != PASS:
+ return status
+
+ ret = vsxml.create(server)
+ if not ret:
+ logger.error("Failed to Create the dom: '%s'", test_dom)
+ cleanup_restore(server, virt)
return FAIL
- virt_network = network_by_bridge(bridge, server)
- if virt_network == None:
- Globals.logger.error("No virtual network found for bridge %s", bridge)
- return SKIP
+ # Get pool list against which the EAFP should be queried
+ pllist = init_pllist(virt, vsxml, diskid)
- ret = test_domain_function(test_xml, server, cmd = "create")
- if not ret:
- Globals.logger.error("Failed to Create the dom: %s", test_dom)
- return FAIL
+
+ status = verify_eafp_values(server, virt, pllist, test_disk)
+ vsxml.destroy(server)
+ cleanup_restore(server, virt)
+ return status
- # Taking care of already existing diskconf file
- # Creating diskpool.conf if it does not exist
- # Otherwise backing up the prev file and create new one.
- os.system("rm -f %s" % back_disk_file )
- if not (os.path.exists(disk_file)):
- conf_file()
- else:
- move_file(disk_file, back_disk_file)
- conf_file()
- try :
- disk = get_or_bail(server, id=diskid, \
- pool_class=enumclass.Xen_DiskPool)
- mem = get_or_bail(server, id = memid, \
- pool_class=enumclass.Xen_MemoryPool)
- netid = "%s/%s" % ("NetworkPool", virt_network)
- net = get_or_bail(server, id = netid, \
- pool_class=enumclass.Xen_NetworkPool)
- proc = get_or_bail(server, id = procid, \
- pool_class=enumclass.Xen_ProcessorPool)
-
- except Exception, detail:
- Globals.logger.error("Exception: %s", detail)
- clean_up_restore(server)
- status = FAIL
- ret = test_domain_function(test_dom, server, \
- cmd = "destroy")
- return status
-
- pllist, cllist, prop_list, proc_prop = init_list(server, disk, mem, net, proc)
-
-# Looping through the pllist to get association for various pools.
- for cn, instid in sorted(pllist.items()):
- try:
- assoc_info = assoc.Associators(server, \
- "Xen_ElementAllocatedFromPool", \
- cn, \
- InstanceID = instid)
-# Verifying the Creation Class name for all the records returned for each
-# pool class queried
- inst_list = get_inst_for_dom(assoc_info)
- if (len(inst_list)) == 0:
- Globals.logger.error("Association did not return any records for \
-the specified domain: %s", test_dom)
- status = FAIL
- break
-
- assoc_values(assoc_list=inst_list, field="CreationClassName", \
- list=cllist, \
- index=loop)
-# verifying the DeviceID
- if inst_list[0]['CreationClassName'] == 'Xen_Processor':
-# The DeviceID for the processor varies from 0 to (vcpu - 1 )
- list_index = 0
- assoc_values(assoc_list=inst_list, field="DeviceID", \
- list=proc_prop, \
- index=list_index)
- else:
-# For LogicalDisk, Memory and NetworkPort
- if inst_list[0]['CreationClassName'] == 'Xen_LogicalDisk':
- list_index = 0
- elif inst_list[0]['CreationClassName'] == 'Xen_Memory':
- list_index = 2
- else:
- list_index = 4 # NetworkPort
- assoc_values(assoc_list=inst_list, field="DeviceID", \
- list=prop_list, \
- index=list_index)
- if inst_list[0]['CreationClassName'] == 'Xen_LogicalDisk':
-# verifying the Name field for LogicalDisk
- specific_fields = get_spec_fields_list(inst_list,field_name="Name")
- list_index = 1
- elif inst_list[0]['CreationClassName'] == 'Xen_Memory':
-# verifying the NumberOfBlocks allocated for Memory
- specific_fields = get_spec_fields_list(inst_list,field_name="NumberOfBlocks")
- list_index = 3
- else:
-# verifying the NetworkAddresses for the NetworkPort
- specific_fields = get_spec_fields_list(inst_list,field_name="NetworkAddresses")
- list_index = 5 # NetworkPort
- assoc_values(assoc_list=inst_list, field="Other", \
- list=prop_list, \
- index=list_index, \
- specific_fields_list=specific_fields)
- if status != PASS:
- break
- else:
-# The loop variable is used to index the cllist to verify the creationclassname
- loop = loop + 1
- except Exception, detail:
- Globals.logger.error(Globals.CIM_ERROR_ASSOCIATORS, \
- 'Xen_ElementAllocatedFromPool')
- Globals.logger.error("Exception: %s", detail)
- clean_up_restore(server)
- status = FAIL
-
- ret = test_domain_function(test_dom, server, \
- cmd = "destroy")
- clean_up_restore(server)
- return status
if __name__ == "__main__":
sys.exit(main())
diff -r 3703b7be5a10 -r 6d1ac5c3497b suites/libvirt-cim/lib/XenKvmLib/logicaldevices.py
--- a/suites/libvirt-cim/lib/XenKvmLib/logicaldevices.py Wed Jul 16 07:23:32 2008 -0700
+++ b/suites/libvirt-cim/lib/XenKvmLib/logicaldevices.py Tue Jul 22 06:42:27 2008 -0700
@@ -23,6 +23,7 @@ import os
import os
from CimTest.Globals import logger
from CimTest.ReturnCodes import PASS, FAIL, SKIP
+from XenKvmLib.vxml import get_typed_class
# The list_values that is passed should be of the type ..
# disk = {
@@ -53,70 +54,58 @@ def spec_err(fieldvalue, field_list, fie
logger.error("%s Mismatch", fieldname)
logger.error("Returned %s instead of %s", fieldvalue, field_list[fieldname])
-def verify_proc_values(assoc_info, list_values):
- proc_values = list_values['Xen_Processor']
- if assoc_info['CreationClassName'] != proc_values['CreationClassName']:
- field_err(assoc_info, proc_values, fieldname = 'CreationClassName')
+
+def verify_device_values(assoc_info, list_values, virt='Xen'):
+ dev_cnames = ['LogicalDisk', 'Memory', 'NetworkPort', 'Processor']
+ for i in range(len(dev_cnames)):
+ dev_cnames[i] = get_typed_class(virt, dev_cnames[i])
+
+ CCName = assoc_info['CreationClassName']
+ if not CCName in dev_cnames:
+ logger.error("'%s' seem to be an invalid classname", CCName)
+ return FAIL
+
+ dev_values = list_values[CCName]
+ if assoc_info['CreationClassName'] != dev_values['CreationClassName']:
+ field_err(assoc_info, dev_values, fieldname = 'CreationClassName')
+ return FAIL
+
+ if assoc_info['DeviceID'] != dev_values['DeviceID']:
+ field_err(assoc_info, dev_values, fieldname = 'DeviceID')
+ return FAIL
+
+ sysname = assoc_info['SystemName']
+ if sysname != dev_values['SystemName']:
+ spec_err(sysname, list_values, fieldname = 'SystemName')
return FAIL
- if assoc_info['DeviceID'] != proc_values['DeviceID']:
- field_err(assoc_info, proc_values, fieldname = 'DeviceID')
- return FAIL
- sysname = assoc_info['SystemName']
- if sysname != proc_values['SystemName']:
- spec_err(sysname, proc_values, fieldname = 'SystemName')
- return FAIL
- return PASS
-def verify_mem_values(assoc_info, list_values):
- mem_values = list_values['Xen_Memory']
- if assoc_info['CreationClassName'] != mem_values['CreationClassName']:
- field_err(assoc_info, mem_values, fieldname = 'CreationClassName')
- return FAIL
- if assoc_info['DeviceID'] != mem_values['DeviceID']:
- field_err(assoc_info, mem_values, fieldname = 'DeviceID')
- return FAIL
- sysname = assoc_info['SystemName']
- if sysname != mem_values['SystemName']:
- spec_err(sysname, mem_values, fieldname = 'SystemName')
- return FAIL
+ # Checking Device specific values.
+ if CCName == dev_cnames[0]: # Verifying disk values
+ return verify_disk_values(assoc_info, dev_values, virt)
+ elif CCName == dev_cnames[1]: # Verifying mem values
+ return verify_mem_values(assoc_info, dev_values, virt)
+ elif CCName == dev_cnames[2]: # Verifying net values
+ return verify_net_values(assoc_info, dev_values, virt)
+ elif CCName == dev_cnames[3]: # Verifying processor values
+ return PASS
+
+def verify_mem_values(assoc_info, mem_values, virt='Xen'):
blocks = ((int(assoc_info['NumberOfBlocks'])*4096)/1024)
if blocks != mem_values['NumberOfBlocks']:
spec_err(blocks, mem_values, fieldname = 'NumberOfBlocks')
return FAIL
return PASS
-def verify_net_values(assoc_info, list_values):
- net_values = list_values['Xen_NetworkPort']
- if assoc_info['CreationClassName'] != net_values['CreationClassName']:
- field_err(assoc_info, net_values, fieldname = 'CreationClassName')
- return FAIL
- if assoc_info['DeviceID'] != net_values['DeviceID']:
- field_err(assoc_info, net_values, fieldname = 'DeviceID')
- return FAIL
- sysname = assoc_info['SystemName']
- if sysname != net_values['SystemName']:
- spec_err(sysname, net_values, fieldname = 'SystemName')
- return FAIL
-# We are assinging only one mac address and hence we expect only one
-# address in the list
+def verify_net_values(assoc_info, net_values, virt='Xen'):
+ # We are assinging only one mac address and hence we expect only one
+ # address in the list
netadd = assoc_info['NetworkAddresses'][0]
if netadd != net_values['NetworkAddresses']:
spec_err(netadd, net_values, fieldname = 'NetworkAddresses')
return FAIL
return PASS
-def verify_disk_values(assoc_info, list_values):
- disk_values = list_values['Xen_LogicalDisk']
- if assoc_info['CreationClassName'] != disk_values['CreationClassName']:
- field_err(assoc_info, disk_values, fieldname = 'CreationClassName')
- return FAIL
- if assoc_info['DeviceID'] != disk_values['DeviceID']:
- field_err(assoc_info, disk_values, fieldname = 'DeviceID')
- return FAIL
- sysname = assoc_info['SystemName']
- if sysname != disk_values['SystemName']:
- spec_err(sysname, disk_values, fieldname = 'SystemName')
- return FAIL
+def verify_disk_values(assoc_info, disk_values, virt='Xen'):
devname = assoc_info['Name']
if devname != disk_values['Name']:
spec_err(devname, disk_values, fieldname = 'Name')
