4:21 p.m.
New subject: [PATCH 1 of 4] [TEST] Adding functions to verify the EAFP fields
# HG changeset patch
# User Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
# Date 1215776529 25200
# Node ID 25cd5c474b0797d36d67e200b4f8ed4ffa9cfedc
# Parent 0f8b7f041b91761da40aee3f6574338de6c178fd
[TEST] Adding functions to verify the EAFP fields .
Added functions verify_common_pool_values(), verify_specific_fields() and
verify_disk_mem_proc_pool_values()
to be helpful to verify the EAFP fields returned when queried with Logicaldevices.
Signed-off-by: Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
diff -r 0f8b7f041b91 -r 25cd5c474b07 suites/libvirt-cim/lib/XenKvmLib/logicaldevices.py
--- a/suites/libvirt-cim/lib/XenKvmLib/logicaldevices.py Thu Jul 10 06:07:36 2008 -0700
+++ b/suites/libvirt-cim/lib/XenKvmLib/logicaldevices.py Fri Jul 11 04:42:09 2008 -0700
@@ -123,3 +123,34 @@
return FAIL
return PASS
+def verify_common_pool_values(assoc_info, list_values):
+ if assoc_info['InstanceID'] != list_values['InstanceID']:
+ field_err(assoc_info, list_values, fieldname = 'InstanceID')
+ return FAIL
+ if assoc_info['PoolID'] != list_values['PoolID']:
+ field_err(assoc_info, list_values, fieldname = 'PoolID')
+ return FAIL
+ if assoc_info['ResourceType'] != list_values['ResourceType']:
+ field_err(assoc_info, list_values, fieldname = 'ResourceType')
+ return FAIL
+ return PASS
+
+def verify_specific_fields(assoc_info, list_values):
+ if assoc_info['Capacity'] != list_values['Capacity']:
+ field_err(assoc_info, list_values, fieldname = 'Capacity')
+ return FAIL
+ if assoc_info['Reserved'] != list_values['Reserved']:
+ field_err(assoc_info, list_values, fieldname = 'Reserved')
+ return FAIL
+ if assoc_info['AllocationUnits'] != list_values['AllocationUnits']:
+ field_err(assoc_info, list_values, fieldname = 'AllocationUnits')
+ return FAIL
+ return PASS
+
+def verify_disk_mem_proc_pool_values(assoc_info, list_values):
+ status = verify_common_pool_values(assoc_info, list_values)
+ if status != PASS:
+ return status
+ status = verify_specific_fields(assoc_info, list_values)
+ return status
+
1:04 a.m.
New subject: [PATCH 1 of 4] [TEST] Adding functions to verify the EAFP fields
I'd suggest combining this functionality into the function above.
The only case where you need to ignore these properties is in the
NetworkPool case, so I'd have verify_common_pool_values() take the class
name.
After checking the common values, check to see if the class name is
"NetworkPool" and return from the function if is.
I don't think this function is needed. This function only calls two
other function - it doesn't do any other tasks.
Plus, if you make the changes suggested above, then this function
becomes obsolete.
--
Kaitlin Rupert
IBM Linux Technology Center
kaitlin(a)linux.vnet.ibm.com
4:21 p.m.
New subject: [PATCH 2 of 4] [TEST] Adding functions to common_util.py to support the verifications of EAFP fields
# HG changeset patch
# User Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
# Date 1215777176 25200
# Node ID 65b1865d10a0570ec785e78affc0f69877bc8189
# Parent 25cd5c474b0797d36d67e200b4f8ed4ffa9cfedc
[TEST] Adding functions to common_util.py to support the verifications of EAFP fields.
Added the following functions:
1) eafp_dpool_cap_reserve_val() to get the DiskPool's Capacity and Reserved field
values depending on which libvirt version is present on the machine.
2) eafp_mpool_reserve_val() to get the MemoryPool's Reserved field value.
3) Also, added get_value() function.
Signed-off-by: Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
diff -r 25cd5c474b07 -r 65b1865d10a0 suites/libvirt-cim/lib/XenKvmLib/common_util.py
--- a/suites/libvirt-cim/lib/XenKvmLib/common_util.py Fri Jul 11 04:42:09 2008 -0700
+++ b/suites/libvirt-cim/lib/XenKvmLib/common_util.py Fri Jul 11 04:52:56 2008 -0700
@@ -35,7 +35,9 @@
from XenKvmLib.classes import get_typed_class
from CimTest.Globals import logger, log_param, CIM_ERROR_ENUMERATE
from CimTest.ReturnCodes import PASS, FAIL, XFAIL_RC
-from VirtLib.live import diskpool_list, virsh_version, net_list
+from VirtLib.live import diskpool_list, virsh_version, net_list, \
+active_domain_list, virsh_dominfo_usedmem
+from VirtLib.utils import run_remote
from XenKvmLib.vxml import PoolXML, NetXML
test_dpath = "foo"
@@ -397,3 +399,66 @@
return PASS
+def get_value(server, cmd, log_msg, fieldname):
+ msg = log_msg % fieldname
+ ret, value = run_remote(server, cmd)
+ if ret != 0:
+ logger.error("%s", log_msg, fieldname)
+ return FAIL, value
+ return PASS, value
+
+def eafp_dpool_cap_reserve_val(server, virt, poolname):
+ libvirt_version = virsh_version(server, virt)
+ capacity = reserved = None
+ if libvirt_version >= '0.4.1':
+ # get the value from pool-info
+ log_msg= "Failed to get the '%s' info from pool-info"
+ dp_name, pname = poolname.split("/")
+
+ cmd = "virsh pool-info %s | awk '/Capacity/ { print \$2}'" \
+ % pname
+ status, cap_val = get_value(server, cmd, log_msg, 'Capacity')
+ if status != PASS:
+ return FAIL, capacity, reserved
+ cap_val = float(cap_val)
+ capacity = int(cap_val * 1024 * 1024 * 1024) >> 20
+
+ cmd = "virsh pool-info %s | awk '/Allocation/ { print \$2}'" \
+ % pname
+ status, alloc_val = get_value(server, cmd, log_msg, 'Allocation')
+ if status != PASS:
+ return FAIL, capacity, reserved
+ alloc_val = float(alloc_val)
+ reserved = int(alloc_val * 1024 * 1024 *1024) >> 20
+
+ else:
+ # get info from stat -filesystem
+ log_msg = "Stat on the '%s' file failed"
+
+ cmd = "stat -f %s | awk '/size/ {print \$7}'" % disk_file
+ status, f_bsize = get_value(server, cmd, log_msg, disk_file)
+ if status != PASS:
+ return FAIL, capacity, reserved
+
+ cmd = " stat -f %s | awk '/Blocks/ {print \$3}'" %
disk_file
+ status, b_total = get_value(server, cmd, log_msg, disk_file)
+ if status != PASS:
+ return FAIL, capacity, reserved
+ cap_val = (int(f_bsize) * int(b_total))
+ capacity = (int(f_bsize) * int(b_total)) >> 20
+
+ cmd = "stat -f %s | awk '/Blocks/ {print \$5}'" % disk_file
+ status, b_free = get_value(server, cmd, log_msg, disk_file)
+ if status != PASS:
+ return FAIL, capacity, reserved
+ reserved = (cap_val - (int(f_bsize) * int(b_free))) >> 20
+
+ return PASS, capacity, reserved
+
+def eafp_mpool_reserve_val(server, virt):
+ reserved = 0
+ doms = active_domain_list(server, virt)
+ for dom_name in doms:
+ mem = virsh_dominfo_usedmem(server, dom_name, virt)
+ reserved += mem
+ return reserved
1:57 a.m.
New subject: [PATCH 2 of 4] [TEST] Adding functions to common_util.py to support the verifications of EAFP fields
+def get_value(server, cmd, log_msg, fieldname):
I wouldn't make a separate function out of this. it probably won't be
used except by the eafp_dpool_cap_reserve_val() function.
The capabilities and reserved values are properties of the ResourcePools
- I'd drop eafp from the name since these values aren't related to the
EAFP association.
Also, I'd move these functions to the logicaldevices.py file. Or, you
could create a resourcepool.py file and add the
verify_common_pool_values() function to it.
The common_util.py is becoming quite large - so, it might be a good idea
to try to place more specific functions like these (that deal with a
specific provider's values) into a file specific for that provider.
This calculation is odd. You're converting GB into bytes and then from
bytes into megabytes. You can instead convert straight to megabytes:
capacity = int(cap_val * 1024)
Same here - convert straight to megabytes
If you want to break up the size of this function some, you could do
something like:
dpool_cap_reserve_val():
libvirt_version = virsh_version(server, virt)
capacity = reserved = None
if libvirt_version >= '0.4.1':
libvirt_dpool_cap_res()
else:
fs_dpool_cap_res()
Having sub functions for each of these breaks up the work nicely, and
it's possible (although unlikely) that a test would need to call one of
these functions explicitly.
--
Kaitlin Rupert
IBM Linux Technology Center
kaitlin(a)linux.vnet.ibm.com
4:21 p.m.
New subject: [PATCH 3 of 4] [TEST] Adding functions to live.py
# HG changeset patch
# User Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
# Date 1215777594 25200
# Node ID 9155858d4e5aa69393e652e7fd340ab12a63a153
# Parent 65b1865d10a0570ec785e78affc0f69877bc8189
[TEST] Adding functions to live.py.
Added the following functions:
1) virsh_nodeinfo_cpucount() to get the number of processors on the machine.
2) virsh_nodeinfo_memsize() to get the memory capacity on the machine.
3) virsh_dominfo_usedmem() to get the memory used by the guest.
Signed-off-by: Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
diff -r 65b1865d10a0 -r 9155858d4e5a lib/VirtLib/live.py
--- a/lib/VirtLib/live.py Fri Jul 11 04:52:56 2008 -0700
+++ b/lib/VirtLib/live.py Fri Jul 11 04:59:54 2008 -0700
@@ -347,3 +347,56 @@
return out
return None
+def virsh_nodeinfo_cpucount(server, virt="Xen"):
+ """
+ Returns the number of processors on the machine.
+ """
+
+ cmd = "virsh -c %s nodeinfo | awk '/CPU\(s\)/ { print \$2 }'" \
+ % (utils.virt2uri(virt))
+
+ rc, out = utils.run_remote(server, cmd)
+ if rc != 0:
+ return -1
+
+ try:
+ cpus = int(out)
+ return cpus
+ except ValueError:
+ return -1
+
+def virsh_nodeinfo_memsize(server, virt="Xen"):
+ """
+ Returns the memory capacity on the machine.
+ """
+
+ cmd = "virsh -c %s nodeinfo | awk '/Memory size/ { print \$3 }'"
\
+ % (utils.virt2uri(virt))
+
+ rc, out = utils.run_remote(server, cmd)
+ if rc != 0:
+ return -1
+
+ try:
+ msize = int(out)
+ return msize
+ except ValueError:
+ return -1
+
+def virsh_dominfo_usedmem(server, vs_name, virt="Xen"):
+ """
+ Returns the memory used by the guest.
+ """
+
+ guest_cmd = "virsh -c %s dominfo %s | awk '/Used memory/ { print \$3
}'" \
+ % (utils.virt2uri(virt), vs_name)
+
+ rc, out = utils.run_remote(server, guest_cmd)
+ if rc != 0:
+ return -1
+
+ try:
+ usedmem = int(out)
+ return usedmem
+ except ValueError:
+ return -1
4:21 p.m.
New subject: [PATCH 4 of 4] [TEST] Updating 01_forward.py of EAFP
# HG changeset patch
# User Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
# Date 1215778728 25200
# Node ID 2b57a9423f82420b386775bbdf884302d7338ba8
# Parent 9155858d4e5aa69393e652e7fd340ab12a63a153
[TEST] Updating 01_forward.py of EAFP.
1) Modifying the tc to support XenFV and KVM.
2) Modified get_keys() to use proper SystemCreationClassName.
3) Added functions get_id to get the instances for different logical devices so that the
DeviceID of the instances can be used
in the init_list().
4) Added init_list() function to create a list of inputs for the EAFP association.
5) Added eafp_list() to create a list of pool values that will be used to verify the
return values from the EAFP association.
6) Added the function verify_eafp_values() to call assocation on EAFP and verify the
return values.
7) Included cleanup_restore().
Signed-off-by: Deepti B. Kalakeri <deeptik(a)linux.vnet.ibm.com>
diff -r 9155858d4e5a -r 2b57a9423f82
suites/libvirt-cim/cimtest/ElementAllocatedFromPool/01_forward.py
--- a/suites/libvirt-cim/cimtest/ElementAllocatedFromPool/01_forward.py Fri Jul 11
04:59:54 2008 -0700
+++ b/suites/libvirt-cim/cimtest/ElementAllocatedFromPool/01_forward.py Fri Jul 11
05:18:48 2008 -0700
@@ -44,163 +44,217 @@
import pywbem
from XenKvmLib.test_xml import testxml, testxml_bridge
from VirtLib import utils
-from XenKvmLib import assoc
-from XenKvmLib.test_doms import test_domain_function, destroy_and_undefine_all
+from XenKvmLib.assoc import Associators
+from XenKvmLib.test_doms import destroy_and_undefine_all
from XenKvmLib import devices
-from CimTest import Globals
-from CimTest.Globals import do_main
-from VirtLib.live import network_by_bridge
-from CimTest.ReturnCodes import PASS, FAIL, SKIP
+from CimTest.Globals import CIM_ERROR_ASSOCIATORS, CIM_ERROR_GETINSTANCE
+from XenKvmLib.vxml import get_class
+from XenKvmLib.vsms import RASD_TYPE_DISK, RASD_TYPE_PROC, \
+RASD_TYPE_MEM, RASD_TYPE_NET_ETHER, RASD_TYPE_DISK
+from XenKvmLib.common_util import create_diskpool_conf, cleanup_restore, \
+eafp_dpool_cap_reserve_val, eafp_mpool_reserve_val
+from XenKvmLib.classes import get_typed_class
+from XenKvmLib.logicaldevices import verify_common_pool_values, \
+verify_disk_mem_proc_pool_values
+from CimTest.Globals import do_main, logger
+from VirtLib.live import network_by_bridge, virsh_nodeinfo_cpucount, \
+virsh_nodeinfo_memsize, virsh_dominfo_usedmem
+from CimTest.ReturnCodes import PASS, FAIL
-sup_types = ['Xen']
+sup_types = ['Xen', 'KVM', 'XenFV']
test_dom = "hd_domain"
test_mac = "00:11:22:33:44:aa"
test_vcpus = 1
-test_disk = 'xvda'
def print_error(cn, detail):
- Globals.logger.error(Globals.CIM_ERROR_GETINSTANCE, cn)
- Globals.logger.error("Exception: %s", detail)
+ logger.error(CIM_ERROR_GETINSTANCE, cn)
+ logger.error("Exception: %s", detail)
-def get_keys(cn, device_id):
+def get_keys(virt, cn, device_id):
id = "%s/%s" % (test_dom, device_id)
+ sccn = get_typed_class(virt, "ComputerSystem")
key_list = { 'DeviceID' : id,
'CreationClassName' : cn,
'SystemName' : test_dom,
- 'SystemCreationClassName' : "Xen_ComputerSystem"
+ 'SystemCreationClassName' : sccn
}
return key_list
+def get_id(server, virt, cname, id):
+ dev = None
+ cn = get_typed_class(virt, cname)
+ try:
+ key_list = get_keys(virt, cn, id)
+ dev_class = devices.get_class(cn)
+ dev = dev_class(server, key_list)
+ except Exception,detail:
+ print_error(cn, detail)
+ return FAIL, dev
+ return PASS, dev
+
+def init_list(server, virt, test_disk):
+ lelist = {}
+ status, disk = get_id(server, virt, "LogicalDisk", test_disk)
+ if status != PASS :
+ return status, lelist
+
+ status, mem = get_id(server, virt, "Memory", "mem")
+ if status != PASS :
+ return status, lelist
+
+ status, net = get_id(server, virt, "NetworkPort", test_mac)
+ if status != PASS:
+ return status, lelist
+
+ status, proc = get_id(server, virt, "Processor", "0")
+ if status != PASS:
+ return status, lelist
+
+ lelist = {
+ disk.CreationClassName : disk.DeviceID, \
+ mem.CreationClassName : mem.DeviceID, \
+ net.CreationClassName : net.DeviceID, \
+ proc.CreationClassName : proc.DeviceID
+ }
+ return status, lelist
+
+def eafp_list(server, virt, diskid, d_cap, d_reserve, test_network):
+
+ diskpool = {
+ 'CCName' : get_typed_class(virt,
'DiskPool'),
+ 'InstanceID' : diskid,
+ 'PoolID' : diskid,
+ 'ResourceType' : RASD_TYPE_DISK,
+ 'Capacity' : d_cap,
+ 'Reserved' : d_reserve,
+ 'AllocationUnits' : 'Megabytes'
+ }
+ procpool = {
+ 'CCName' : get_typed_class(virt,
'ProcessorPool'),
+ 'InstanceID' : "%s/%s" %
("ProcessorPool", "0"),
+ 'PoolID' : "%s/%s" %
("ProcessorPool", "0"),
+ 'ResourceType' : RASD_TYPE_PROC,
+ 'Capacity' : virsh_nodeinfo_cpucount(server, virt),
+ 'Reserved' : 0,
+ 'AllocationUnits' : 'Processors'
+ }
+ netpool = {
+ 'CCName' : get_typed_class(virt,
'NetworkPool'),
+ 'InstanceID' : "%s/%s" %
("NetworkPool", test_network),
+ 'PoolID' : "%s/%s" %
("NetworkPool", test_network),
+ 'ResourceType' : RASD_TYPE_NET_ETHER
+ }
+ mempool = {
+ 'CCName' : get_typed_class(virt,
'MemoryPool'),
+ 'InstanceID' : "%s/%s" %
("MemoryPool", "0"),
+ 'PoolID' : "%s/%s" %
("MemoryPool", "0"),
+ 'ResourceType' : RASD_TYPE_MEM,
+ 'Reserved' : eafp_mpool_reserve_val(server, virt),
+ 'Capacity' : virsh_nodeinfo_memsize(server, virt),
+ 'AllocationUnits' :'KiloBytes'
+ }
+ eafp_values = { 'procpool' : procpool,
+ 'diskpool' : diskpool,
+ 'netpool' : netpool,
+ 'mempool' : mempool
+ }
+ return eafp_values
+
+def verify_eafp_values(server, virt, diskid, test_network, in_pllist):
+ # Looping through the in_pllist to get association for devices.
+ an = get_typed_class(virt, "ElementAllocatedFromPool")
+ sccn = get_typed_class(virt, "ComputerSystem")
+ status, d_cap, d_reserve = eafp_dpool_cap_reserve_val(server, virt,
+ diskid)
+ if status != PASS:
+ return FAIL
+
+ eafp_values = eafp_list(server, virt, diskid, d_cap, d_reserve, test_network)
+ for cn, devid in sorted(in_pllist.items()):
+ try:
+ assoc_info = Associators(server, an, cn,
+ DeviceID = devid,
+ CreationClassName = cn,
+ SystemName = test_dom,
+ SystemCreationClassName = sccn,
+ virt=virt)
+ if len(assoc_info) != 1:
+ logger.error("%s returned %i ResourcePool objects for "
+ "domain '%s'", an, len(assoc_info),
+ test_dom)
+ status = FAIL
+ break
+ assoc_eafp_info = assoc_info[0]
+ CCName = assoc_eafp_info.classname
+ if CCName == eafp_values['procpool']['CCName']:
+ list_values = eafp_values['procpool']
+ status = verify_disk_mem_proc_pool_values(assoc_eafp_info,
+ list_values)
+ elif CCName == eafp_values['netpool']['CCName']:
+ list_values = eafp_values['netpool']
+ status = verify_common_pool_values(assoc_eafp_info,
+ list_values)
+ elif CCName == eafp_values['diskpool']['CCName']:
+ list_values = eafp_values['diskpool']
+ status = verify_disk_mem_proc_pool_values(assoc_eafp_info,
+ list_values)
+ elif CCName == eafp_values['mempool']['CCName']:
+ list_values = eafp_values['mempool']
+ status = verify_disk_mem_proc_pool_values(assoc_eafp_info,
+ list_values)
+ else:
+ status = FAIL
+ if status != PASS:
+ break
+ except Exception, detail:
+ logger.error(CIM_ERROR_ASSOCIATORS, an)
+ logger.error("Exception: %s", detail)
+ cleanup_restore(server, virt)
+ status = FAIL
+ return status
+
+
@do_main(sup_types)
def main():
options = main.options
+ server = options.ip
+ virt = options.virt
status = PASS
- idx = 0
+ if virt == 'Xen':
+ test_disk = 'xvda'
+ else:
+ test_disk = 'hda'
+ # Getting the VS list and deleting the test_dom if it already exists.
+ destroy_and_undefine_all(server)
+ virt_type = get_class(virt)
+ vsxml = virt_type(test_dom, vcpus = test_vcpus, mac = test_mac,
+ disk = test_disk)
-# Getting the VS list and deleting the test_dom if it already exists.
- destroy_and_undefine_all(options.ip)
+ # Verify DiskPool on machine
+ status, diskid = create_diskpool_conf(server, virt)
+ if status != PASS:
+ return status
- test_xml, bridge = testxml_bridge(test_dom, 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
-
- if test_xml == None:
- Globals.logger.error("Guest xml not created properly")
- return FAIL
-
- virt_network = network_by_bridge(bridge, options.ip)
- if virt_network == None:
- Globals.logger.error("No virtual network found for bridge %s", bridge)
- return SKIP
-
- ret = test_domain_function(test_xml, options.ip, cmd = "create")
+ ret = vsxml.create(server)
if not ret:
- Globals.logger.error("Failed to Create the dom: %s", test_dom)
+ logger.error("Failed to Create the dom: '%s'", test_dom)
return FAIL
- try:
- cn = "Xen_LogicalDisk"
- key_list = get_keys(cn, test_disk)
- disk = devices.Xen_LogicalDisk(options.ip, key_list)
- except Exception,detail:
- print_error(cn, detail)
- return FAIL
+ status, lelist = init_list(server, virt, test_disk)
+ if status != PASS:
+ cleanup_restore(server, virt)
+ vsxml.destroy(server)
+ return status
- try:
- cn = "Xen_Memory"
- key_list = get_keys(cn, "mem")
- mem = devices.Xen_Memory(options.ip, key_list)
- except Exception,detail:
- print_error(cn, detail)
- return FAIL
-
- try:
- cn = "Xen_NetworkPort"
- key_list = get_keys(cn, test_mac)
- net = devices.Xen_NetworkPort(options.ip, key_list)
- except Exception,detail:
- print_error(cn, detail)
- return FAIL
-
- try:
- cn = "Xen_Processor"
- key_list = get_keys(cn, "0")
- proc = devices.Xen_Processor(options.ip, key_list)
- except Exception,detail:
- print_error(cn, detail)
- return FAIL
-
- netpool_id = "NetworkPool/%s" % virt_network
-
- lelist = {
- "Xen_LogicalDisk" : disk.DeviceID, \
- "Xen_Memory" : mem.DeviceID, \
- "Xen_NetworkPort" : net.DeviceID, \
- "Xen_Processor" : proc.DeviceID
- }
- poollist = [
- "Xen_DiskPool", \
- "Xen_MemoryPool", \
- "Xen_NetworkPool", \
- "Xen_ProcessorPool"
- ]
- poolval = [
- "DiskPool/foo", \
- "MemoryPool/0", \
- netpool_id, \
- "ProcessorPool/0"
- ]
-
- sccn = "Xen_ComputerSystem"
- for cn, devid in sorted(lelist.items()):
- try:
- assoc_info = assoc.Associators(options.ip, \
- "Xen_ElementAllocatedFromPool",
- cn,
- DeviceID = devid,
- CreationClassName = cn,
- SystemName = test_dom,
- SystemCreationClassName = sccn)
- if len(assoc_info) != 1:
- Globals.logger.error("Xen_ElementAllocatedFromPool returned %i\
- ResourcePool objects for domain '%s'", len(assoc_info), test_dom)
- status = FAIL
- break
-
- if assoc_info[0].classname != poollist[idx]:
- Globals.logger.error("Classname Mismatch")
- Globals.logger.error("Returned %s instead of %s", \
- assoc_info[0].classname, \
- poollist[idx])
- status = FAIL
-
- if assoc_info[0]['InstanceID'] != poolval[idx]:
- Globals.logger.error("InstanceID Mismatch")
- Globals.logger.error("Returned %s instead of %s", \
- assoc_info[0]['InstanceID'], \
- poolval[idx])
- status = FAIL
-
- if status != PASS:
- break
- else:
- idx = idx + 1
-
- except Exception, detail:
- Globals.logger.error(Globals.CIM_ERROR_ASSOCIATORS, \
- 'Xen_ElementAllocatedFromPool')
- Globals.logger.error("Exception: %s", detail)
- status = FAIL
-
- ret = test_domain_function(test_dom, options.ip, \
- cmd = "destroy")
+ virt_network = vsxml.xml_get_net_network()
+ status = verify_eafp_values(server, virt, diskid, virt_network, lelist)
+
+ cleanup_restore(server, virt)
+ vsxml.destroy(server)
return status
if __name__ == "__main__":
2:26 a.m.
New subject: [PATCH 4 of 4] [TEST] Updating 01_forward.py of EAFP
I'd suggest condensing the 4 get_id() calls into a loop.
In actuality, you don't need to have this function at all. If you know
the 4 values for the reference (CCN, SCCN, DeviceID, and SystemName),
then you don't really need to get the individual device instances at all.
However, I suspect most CIM clients will do similar step, so this is a
reasonable to do in the test.
+
+def eafp_list(server, virt, diskid, d_cap, d_reserve, test_network):
+
I'd remove this function all together.
Instead of verifying the values of the host pool returned, I'd determine
which pool instances you expect to see (get the instance values by doing
GetInstance() calls).
Then verify that the pool instance returned by the Associators() call is
the same instance your as the pool instance you got using the
GetInstance() call.
I did something similar for this in the ESD patch I recently sent out.
I'd move these resource pool checks to a resource pool specific test.
--
Kaitlin Rupert
IBM Linux Technology Center
kaitlin(a)linux.vnet.ibm.com
1:28 a.m.
Checking the capabilities and reserved of the resource pools is a good
idea, but I think it might be a better approach to put these checks in
ResourcePool/enum_01.py.
EAFP tests should be concerned with verifying that the pool returned by
the association is the pool we expected for the given device.
While the properties of the resource pool instance need to be valid, I
think checking these values clutters this test and makes it difficult to
read.
--
Kaitlin Rupert
IBM Linux Technology Center
kaitlin(a)linux.vnet.ibm.com
6123
days inactive
6123
days old
8 comments
2 participants
participants (2)
-
Deepti B. Kalakeri -
Kaitlin Rupert