Add:
* repos/domain/blkstatsflags.py
* repos/domain/block_iotune.py
* repos/domain/block_peek.py
* repos/domain/block_resize.py
* repos/domain/domain_blkio.py
* cases/basic_blockjob.conf
Modify: replace virsh commands to calling api in test function
* repos/domain/blkstats.py
* repos/domain/domain_blkinfo.py
---
cases/basic_blockjob.conf | 87 ++++++++++++++++++++++
repos/domain/blkstats.py | 2 -
repos/domain/blkstatsflags.py | 63 ++++++++++++++++
repos/domain/block_iotune.py | 118 +++++++++++++++++++++++++++++
repos/domain/block_peek.py | 69 +++++++++++++++++
repos/domain/block_resize.py | 88 ++++++++++++++++++++++
repos/domain/domain_blkinfo.py | 87 ++++++++++++----------
repos/domain/domain_blkio.py | 165 +++++++++++++++++++++++++++++++++++++++++
8 files changed, 639 insertions(+), 40 deletions(-)
create mode 100644 cases/basic_blockjob.conf
create mode 100644 repos/domain/blkstatsflags.py
create mode 100644 repos/domain/block_iotune.py
create mode 100644 repos/domain/block_peek.py
create mode 100644 repos/domain/block_resize.py
create mode 100644 repos/domain/domain_blkio.py
diff --git a/cases/basic_blockjob.conf b/cases/basic_blockjob.conf
new file mode 100644
index 0000000..65af2c3
--- /dev/null
+++ b/cases/basic_blockjob.conf
@@ -0,0 +1,87 @@
+domain:install_linux_cdrom
+ guestname
+ $defaultname
+ guestos
+ $defaultos
+ guestarch
+ $defaultarch
+ vcpu
+ $defaultvcpu
+ memory
+ $defaultmem
+ hddriver
+ $defaulthd
+ nicdriver
+ $defaultnic
+ macaddr
+ 54:52:00:45:c3:8a
+
+domain:install_linux_check
+ guestname
+ $defaultname
+ virt_type
+ $defaulthv
+ hddriver
+ $defaulthd
+ nicdriver
+ $defaultnic
+
+domain:block_iotune
+ guestname
+ $defaultname
+ bytes_sec
+ 100000
+ iops_sec
+ 0
+
+domain:block_iotune
+ guestname
+ $defaultname
+ bytes_sec
+ 0
+ iops_sec
+ 1000
+
+domain:block_peek
+ guestname
+ $defaultname
+
+domain:block_peek
+ guestname
+ $defaultname
+
+domain:block_resize
+ guestname
+ $defaultname
+ diskpath
+ /var/lib/libvirt/images/libvirt-test-api
+ disksize
+ 1G
+
+domain:blkstats
+ guestname
+ $defaultname
+
+domain:blkstatsflags
+ guestname
+ $defaultname
+ flags
+ 0
+
+domain:domain_blkinfo
+ guestname
+ $defaultname
+ blockdev
+ /var/lib/libvirt/images/libvirt-test-api
+
+domain:domain_blkio
+ guestname
+ $defaultname
+ weight
+ 500
+
+domain:undefine
+ guestname
+ $defaultname
+
+options cleanup=enable
diff --git a/repos/domain/blkstats.py b/repos/domain/blkstats.py
index 0254922..27c2a46 100644
--- a/repos/domain/blkstats.py
+++ b/repos/domain/blkstats.py
@@ -1,8 +1,6 @@
#!/usr/bin/evn python
# To test domain block device statistics
-import os
-import sys
import time
import libxml2
diff --git a/repos/domain/blkstatsflags.py b/repos/domain/blkstatsflags.py
new file mode 100644
index 0000000..4c84a18
--- /dev/null
+++ b/repos/domain/blkstatsflags.py
@@ -0,0 +1,63 @@
+#!/usr/bin/evn python
+# To test domain block device statistics with flags
+
+import time
+import libxml2
+
+import libvirt
+from libvirt import libvirtError
+
+from src import sharedmod
+
+required_params = ('guestname', 'flags')
+optional_params = {}
+
+def check_guest_status(domobj):
+ """Check guest current status"""
+ state = domobj.info()[0]
+ if state == libvirt.VIR_DOMAIN_SHUTOFF or state == libvirt.VIR_DOMAIN_SHUTDOWN:
+ # add check function
+ return False
+ else:
+ return True
+
+def check_blkstats():
+ """Check block device statistic result"""
+ pass
+
+def blkstatsflags(params):
+ """Domain block device statistic"""
+ logger = params['logger']
+ guestname = params['guestname']
+ flags = int(params['flags'])
+
+ conn = sharedmod.libvirtobj['conn']
+
+ domobj = conn.lookupByName(guestname)
+
+ # Check domain block status
+ if check_guest_status(domobj):
+ pass
+ else:
+ domobj.create()
+ time.sleep(90)
+ try:
+ xml = domobj.XMLDesc(0)
+ doc = libxml2.parseDoc(xml)
+ cont = doc.xpathNewContext()
+ devs = cont.xpathEval("/domain/devices/disk/target/@dev")
+
+ for dev in devs:
+ path = dev.content
+ blkstats = domobj.blockStatsFlags(path, flags)
+ # check_blkstats()
+ logger.debug(blkstats)
+ for entry in blkstats.keys():
+ logger.info("%s %s %s" %(path, entry, blkstats[entry]))
+
+ except libvirtError, e:
+ logger.error("API error message: %s, error code is %s"
+ % (e.message, e.get_error_code()))
+ return 1
+
+ return 0
diff --git a/repos/domain/block_iotune.py b/repos/domain/block_iotune.py
new file mode 100644
index 0000000..f92eaf6
--- /dev/null
+++ b/repos/domain/block_iotune.py
@@ -0,0 +1,118 @@
+#!/usr/bin/evn python
+# To test domain block device iotune
+
+import time
+import libxml2
+import libvirt
+from libvirt import libvirtError
+
+from src import sharedmod
+
+required_params = ('guestname', 'bytes_sec', 'iops_sec')
+optional_params = {}
+
+def check_guest_status(domobj):
+ """Check guest current status"""
+ state = domobj.info()[0]
+ if state == libvirt.VIR_DOMAIN_SHUTOFF or \
+ state == libvirt.VIR_DOMAIN_SHUTDOWN:
+ # add check function
+ return False
+ else:
+ return True
+
+def prepare_block_iotune(param, wbs, rbs, tbs, wis, ris, tis, logger):
+ """prepare the block iotune parameter
+ """
+ logger.info("write_bytes_sec : %s" % wbs)
+ param['write_bytes_sec'] = wbs
+ logger.info("read_bytes_sec : %s" % rbs)
+ param['read_bytes_sec'] = rbs
+ logger.info("total_bytes_sec : %s" % tbs)
+ param['total_bytes_sec'] = tbs
+ logger.info("write_iops_sec : %s" % wis)
+ param['write_iops_sec'] = wis
+ logger.info("read_iops_sec : %s" % ris)
+ param['read_iops_sec'] = ris
+ logger.info("total_iops_sec : %s\n" % tis)
+ param['total_iops_sec'] = tis
+ return 0
+
+def check_iotune(expected_param, result_param):
+ """check block iotune configuration
+ """
+ for k in expected_param.keys():
+ if expected_param[k] != result_param[k]:
+ return 1
+ return 0
+
+def block_iotune(params):
+ """Domain block device iotune"""
+ logger = params['logger']
+ guestname = params['guestname']
+ bytes_sec = int(params['bytes_sec'])
+ iops_sec = int(params['iops_sec'])
+ flag = 0
+
+ conn = sharedmod.libvirtobj['conn']
+
+ domobj = conn.lookupByName(guestname)
+
+ # Check domain block status
+ if check_guest_status(domobj):
+ pass
+ else:
+ domobj.create()
+ time.sleep(90)
+
+ try:
+ xml = domobj.XMLDesc(0)
+ doc = libxml2.parseDoc(xml)
+ cont = doc.xpathNewContext()
+ vdevs = cont.xpathEval("/domain/devices/disk/target/@dev")
+ vdev = vdevs[0].content
+
+ iotune_para = {'write_bytes_sec': 0L,
+ 'total_iops_sec': 0L,
+ 'read_iops_sec': 0L,
+ 'read_bytes_sec': 0L,
+ 'write_iops_sec': 0L,
+ 'total_bytes_sec': 0L
+ }
+
+ logger.info("prepare block iotune:")
+ prepare_block_iotune(iotune_para, bytes_sec, bytes_sec, 0,
+ iops_sec, iops_sec, 0, logger)
+
+ logger.info("start to set block iotune:")
+ domobj.setBlockIoTune(vdev, iotune_para, flag)
+
+ res = domobj.blockIoTune(vdev, flag)
+ ret = check_iotune(iotune_para, res)
+ if not ret:
+ logger.info("set pass")
+ else:
+ logger.error("fails to set")
+ return 1
+
+ logger.info("prepare block iotune:")
+ prepare_block_iotune(iotune_para, 0, 0, bytes_sec,
+ 0, 0, iops_sec, logger)
+
+ logger.info("start to set block iotune:")
+ domobj.setBlockIoTune(vdev, iotune_para, flag)
+
+ res = domobj.blockIoTune(vdev, flag)
+ ret = check_iotune(iotune_para, res)
+ if not ret:
+ logger.info("set pass")
+ else:
+ logger.error("fails to set")
+ return 1
+
+ except libvirtError, e:
+ logger.error("API error message: %s, error code is %s"
+ % (e.message, e.get_error_code()))
+ return 1
+
+ return 0
\ No newline at end of file
diff --git a/repos/domain/block_peek.py b/repos/domain/block_peek.py
new file mode 100644
index 0000000..f159f48
--- /dev/null
+++ b/repos/domain/block_peek.py
@@ -0,0 +1,69 @@
+#!/usr/bin/evn python
+# To test domain block device peek
+
+import time
+import libxml2
+import libvirt
+from libvirt import libvirtError
+
+from src import sharedmod
+
+required_params = ('guestname',)
+optional_params = {}
+
+def check_guest_status(domobj):
+ """Check guest current status"""
+ state = domobj.info()[0]
+ if state == libvirt.VIR_DOMAIN_SHUTOFF or \
+ state == libvirt.VIR_DOMAIN_SHUTDOWN:
+ # add check function
+ return False
+ else:
+ return True
+
+def block_peek(params):
+ """domain block peek test function
+ """
+ logger = params['logger']
+ guestname = params['guestname']
+ flag = 0
+
+ conn = sharedmod.libvirtobj['conn']
+
+ domobj = conn.lookupByName(guestname)
+
+ # Check domain block status
+ if check_guest_status(domobj):
+ pass
+ else:
+ domobj.create()
+ time.sleep(90)
+
+ try:
+ xml = domobj.XMLDesc(0)
+ doc = libxml2.parseDoc(xml)
+ cont = doc.xpathNewContext()
+ vdevs = cont.xpathEval("/domain/devices/disk/target/@dev")
+ vdev = vdevs[0].content
+
+ logger.info("start to test block_peek.")
+ logger.info("get the MBR's last byte of domain %s %s is:"
+ % (guestname, vdev))
+
+ last_byte = domobj.blockPeek(vdev, 511, 1, flag)
+ logger.info(last_byte)
+
+ # compare with '\xaa'
+ if last_byte == '\xaa':
+ logger.info("Pass: the last byte is \\xaa")
+ else:
+ logger.error("Failed: the last byte is not \\xaa")
+ logger.error("please make sure the guest is bootable")
+ return 1
+
+ except libvirtError, e:
+ logger.error("API error message: %s, error code is %s"
+ % (e.message, e.get_error_code()))
+ return 1
+
+ return 0
\ No newline at end of file
diff --git a/repos/domain/block_resize.py b/repos/domain/block_resize.py
new file mode 100644
index 0000000..1dc4b45
--- /dev/null
+++ b/repos/domain/block_resize.py
@@ -0,0 +1,88 @@
+#!/usr/bin/evn python
+# To test domain block device resize
+
+import time
+import libvirt
+from libvirt import libvirtError
+
+from src import sharedmod
+from utils import utils
+
+required_params = ('guestname', 'diskpath', 'disksize',)
+optional_params = {}
+
+def check_guest_status(domobj):
+ """Check guest current status"""
+ state = domobj.info()[0]
+ if state == libvirt.VIR_DOMAIN_SHUTOFF or \
+ state == libvirt.VIR_DOMAIN_SHUTDOWN:
+ # add check function
+ return False
+ else:
+ return True
+
+def block_resize(params):
+ """domain block resize test function
+ """
+ logger = params['logger']
+ guestname = params['guestname']
+ diskpath = params['diskpath']
+ disksize = params['disksize']
+ flag = 0
+
+ out = utils.get_capacity_suffix_size(disksize)
+ if len(out) == 0:
+ logger.error("disksize parse error: \'%s\'" % disksize)
+ logger.error("disksize should be a number with capacity suffix")
+ return 1
+
+ if out['suffix'] == 'K':
+ flag = 0
+ disksize = long(out['capacity'])
+ elif out['suffix'] == 'B':
+ flag = 1
+ disksize = long(out['capacity_byte'])
+ elif out['suffix'] == 'M':
+ flag = 0
+ disksize = long(out['capacity']) * 1024
+ elif out['suffix'] == 'G':
+ flag = 0
+ disksize = long(out['capacity']) * 1024 * 1024
+ else:
+ logger.error("disksize parse error: with a unsupported suffix \'%s\'"
+ % out['suffix'])
+ logger.error("the available disksize suffix of block_resize is: ")
+ logger.error("B, K, M, G, T")
+ return 1
+
+ conn = sharedmod.libvirtobj['conn']
+
+ domobj = conn.lookupByName(guestname)
+
+ # Check domain block status
+ if check_guest_status(domobj):
+ pass
+ else:
+ domobj.create()
+ time.sleep(90)
+
+ try:
+ logger.info("resize domain disk to %s" % disksize)
+ domobj.blockResize(diskpath, disksize, flag)
+
+ # Currently, the units of disksize which get from blockInfo is byte.
+ block_info = domobj.blockInfo(diskpath, 0)
+
+ if block_info[0] == disksize * (1 + 1023 * (1 - flag)):
+ logger.info("domain disk resize success")
+ else:
+ logger.error("error: domain disk change into %s" % block_info[0])
+ return 1
+
+ except libvirtError, e:
+ logger.error("API error message: %s, error code is %s"
+ % (e.message, e.get_error_code()))
+ return 1
+
+ return 0
+
\ No newline at end of file
diff --git a/repos/domain/domain_blkinfo.py b/repos/domain/domain_blkinfo.py
index b6051aa..4978c32 100644
--- a/repos/domain/domain_blkinfo.py
+++ b/repos/domain/domain_blkinfo.py
@@ -1,9 +1,6 @@
#!/usr/bin/env python
-# To test "virsh domblkinfo" command
+# To test domain's blockkinfo API
-import os
-import sys
-import re
import commands
import libvirt
@@ -11,10 +8,8 @@ from libvirt import libvirtError
from src import sharedmod
-GET_DOMBLKINFO_MAC = "virsh domblkinfo %s %s | awk '{print $2}'"
GET_CAPACITY = "du -b %s | awk '{print $1}'"
GET_PHYSICAL_K = " du -B K %s | awk '{print $1}'"
-VIRSH_DOMBLKINFO = "virsh domblkinfo %s %s"
required_params = ('guestname', 'blockdev',)
optional_params = {}
@@ -32,8 +27,8 @@ def check_domain_exists(conn, guestname, logger):
""" check if the domain exists, may or may not be active """
guest_names = []
ids = conn.listDomainsID()
- for id in ids:
- obj = conn.lookupByID(id)
+ for domain_id in ids:
+ obj = conn.lookupByID(domain_id)
guest_names.append(obj.name())
guest_names += conn.listDefinedDomains()
@@ -43,18 +38,28 @@ def check_domain_exists(conn, guestname, logger):
return False
else:
return True
+
+def check_guest_status(domobj):
+ """Check guest current status"""
+ state = domobj.info()[0]
+ if state == libvirt.VIR_DOMAIN_SHUTOFF or \
+ state == libvirt.VIR_DOMAIN_SHUTDOWN:
+ # add check function
+ return False
+ else:
+ return True
def check_block_data(blockdev, blkdata, logger):
""" check data about capacity,allocation,physical """
status, apparent_size = get_output(GET_CAPACITY % blockdev, logger)
if not status:
- if apparent_size == blkdata[0]:
- logger.info("the capacity of '%s' is %s, checking succeeded" % \
- (blockdev, apparent_size))
+ if apparent_size == str(blkdata[0]):
+ logger.info("the capacity of '%s' is %s, checking succeeded"
+ % (blockdev, apparent_size))
else:
- logger.error("apparent-size from 'du' is %s, \n\
- but from 'domblkinfo' is %s, checking failed" % \
- (apparent_size, blkdata[0]))
+ logger.error("apparent-size from 'du' is %s" % apparent_size)
+ logger.error("but from 'domain blockinfo' is %d, checking failed"
+ % blkdata[0])
return 1
else:
return 1
@@ -64,14 +69,15 @@ def check_block_data(blockdev, blkdata, logger):
block_size_b = int(block_size_k[:-1]) * 1024
# Temporarily, we only test the default case, assuming
# Allocation value is equal to Physical value
- if str(block_size_b) == blkdata[1] and str(block_size_b) == blkdata[2]:
- logger.info("the block size of '%s' is %s, same with \n\
- Allocation and Physical value, checking succeeded" % \
- (blockdev, block_size_b))
+ if block_size_b == blkdata[1] and block_size_b == blkdata[2]:
+ logger.info("the block size of '%s' is %s"
+ % (blockdev, block_size_b))
+ logger.info("Allocation and Physical value's checking succeeded")
else:
- logger.error("the block size from 'du' is %s, \n\
- the Allocation value is %s, Physical value is %s, \n\
- checking failed" % (block_size_b, blkdata[1], blkdata[2]))
+ logger.error("the block size from 'du' is %d" % block_size_b)
+ logger.error("the Allocation value is %d, Physical value is %d"
+ % (blkdata[1], blkdata[2]))
+ logger.error("checking failed")
return 1
return 0
@@ -79,7 +85,7 @@ def check_block_data(blockdev, blkdata, logger):
def domain_blkinfo(params):
""" using du command to check the data
- in the output of virsh domblkinfo
+ in the output of API blockinfo
"""
logger = params['logger']
guestname = params.get('guestname')
@@ -93,24 +99,29 @@ def domain_blkinfo(params):
if not check_domain_exists(conn, guestname, logger):
logger.error("need a defined guest")
return 1
-
- logger.info("the output of virsh domblkinfo is:")
- status, output = get_output(VIRSH_DOMBLKINFO % (guestname, blockdev), logger)
- if not status:
- logger.info("\n" + output)
- else:
+
+ domobj = conn.lookupByName(guestname)
+
+ if not check_guest_status(domobj):
+ logger.error("guest is not started.")
return 1
-
- status, data_str = get_output(GET_DOMBLKINFO_MAC % (guestname, blockdev), logger)
- if not status:
- blkdata = data_str.rstrip().split('\n')
- logger.info("capacity,allocation,physical list: %s" % blkdata)
- else:
+
+ try:
+ logger.info("the output of domain blockinfo is:")
+ block_info = domobj.blockInfo(blockdev, 0)
+ logger.info("Capacity : %d " % block_info[0])
+ logger.info("Allocation: %d " % block_info[1])
+ logger.info("Physical : %d " % block_info[2])
+
+ except libvirtError, e:
+ logger.error("API error message: %s, error code is %s"
+ % (e.message, e.get_error_code()))
return 1
-
- if check_block_data(blockdev, blkdata, logger):
- logger.error("checking domblkinfo data FAILED")
+
+ if check_block_data(blockdev, block_info, logger):
+ logger.error("checking domain blockinfo data FAILED")
return 1
else:
- logger.info("checking domblkinfo data SUCCEEDED")
+ logger.info("checking domain blockinfo data SUCCEEDED")
+
return 0
diff --git a/repos/domain/domain_blkio.py b/repos/domain/domain_blkio.py
new file mode 100644
index 0000000..2603113
--- /dev/null
+++ b/repos/domain/domain_blkio.py
@@ -0,0 +1,165 @@
+#!/usr/bin/evn python
+# To test domain blkio parameters
+
+import os
+import time
+import libxml2
+import libvirt
+import commands
+from libvirt import libvirtError
+
+from src import sharedmod
+
+CGROUP_PATH = "/cgroup"
+BLKIO_PATH1 = "%s/blkio/libvirt/qemu/%s"
+BLKIO_PATH2 = "/sys/fs%s/blkio/machine/%s.libvirt-qemu"
+GET_PARTITION = "df -P %s | tail -1 | awk {'print $1'}"
+
+required_params = ('guestname', 'weight',)
+optional_params = {}
+
+def get_output(command, logger):
+ """execute shell command
+ """
+ status, ret = commands.getstatusoutput(command)
+ if status:
+ logger.error("executing "+ "\"" + command + "\"" + " failed")
+ logger.error(ret)
+ return status, ret
+
+def get_device(domobj, logger):
+ """get the disk device which domain image stored in
+ """
+ xml = domobj.XMLDesc(0)
+ doc = libxml2.parseDoc(xml)
+ cont = doc.xpathNewContext()
+ devs = cont.xpathEval("/domain/devices/disk/source/@file")
+ image_file = devs[0].content
+
+ status, output = get_output(GET_PARTITION % image_file, logger)
+ if not status:
+ return output[:-1]
+ else:
+ logger.error("get device error: ")
+ logger.error(GET_PARTITION % image_file)
+ return ""
+
+def check_blkio_paras(domain_blkio_path, domainname, blkio_paras, logger):
+ """check blkio parameters according to cgroup filesystem
+ """
+ logger.info("checking blkio parameters from cgroup")
+ if 'weight' in blkio_paras:
+ expected_weight = blkio_paras['weight']
+ status, output = get_output("cat %s/blkio.weight"
+ % domain_blkio_path, logger)
+ if not status:
+ logger.info("%s/blkio.weight is \"%s\""
+ % (domain_blkio_path, output))
+ else:
+ return 1
+
+ if int(output) == expected_weight:
+ logger.info("the weight matches with cgroup blkio.weight")
+ return 0
+ else:
+ logger.error("the weight mismatches with cgroup blkio.weight")
+ return 1
+
+ if 'device_weight' in blkio_paras:
+ expected_device_weight = blkio_paras['device_weight']
+ status, output = get_output("cat %s/blkio.weight_device"
+ % domain_blkio_path, logger)
+ if not status:
+ logger.info("%s/blkio.weight_device is \"%s\""
+ % (domain_blkio_path, output))
+ else:
+ return 1
+
+ if output.split(' ')[1] == expected_device_weight.split(',')[1]:
+ logger.info("the device_weight matches with cgroup \
+ blkio.weight_device")
+ return 0
+ else:
+ logger.error("the device_weight mismatches with cgroup \
+ blkio.weight_device")
+ return 1
+
+ return 0
+
+def check_guest_status(domobj):
+ """Check guest current status"""
+ state = domobj.info()[0]
+ if state == libvirt.VIR_DOMAIN_SHUTOFF or \
+ state == libvirt.VIR_DOMAIN_SHUTDOWN:
+ # add check function
+ return False
+ else:
+ return True
+
+def domain_blkio(params):
+ """domain blkio parameters test function"""
+ logger = params['logger']
+ guestname = params['guestname']
+ expected_weight = params['weight']
+ flag = 0
+
+ conn = sharedmod.libvirtobj['conn']
+
+ domobj = conn.lookupByName(guestname)
+
+ # Check domain block status
+ if check_guest_status(domobj):
+ pass
+ else:
+ domobj.create()
+ time.sleep(90)
+
+ if os.path.exists(CGROUP_PATH):
+ blkio_path = BLKIO_PATH1 % (CGROUP_PATH, guestname)
+ else:
+ blkio_path = BLKIO_PATH2 % (CGROUP_PATH, guestname)
+
+
+ try:
+ blkio_paras = domobj.blkioParameters(flag)
+
+
+ logger.info("the blkio weight of %s is: %d"
+ % (guestname, blkio_paras['weight']))
+
+ status = check_blkio_paras(blkio_path, guestname, blkio_paras,
+ logger)
+ if status != 0:
+ return 1
+
+ logger.info("start to set param weight to %s" % expected_weight)
+ blkio_paras = {'weight':int(expected_weight)}
+ status = domobj.setBlkioParameters(blkio_paras, flag)
+ if status != 0:
+ return 1
+
+ status = check_blkio_paras(blkio_path, guestname, blkio_paras,
+ logger)
+ if status != 0:
+ return 1
+
+ device = get_device(domobj, logger)
+ device_weight = "%s,%s" % (device, expected_weight)
+ logger.info("start to set param device_weight to %s"
+ % device_weight)
+ blkio_paras = {'device_weight':device_weight}
+ status = domobj.setBlkioParameters(blkio_paras, flag)
+ if status != 0:
+ return 1
+
+ status = check_blkio_paras(blkio_path, guestname, blkio_paras,
+ logger)
+ if status != 0:
+ return 1
+
+ except libvirtError, e:
+ logger.error("API error message: %s, error code is %s"
+ % (e.message, e.get_error_code()))
+ return 1
+
+ return 0
--
1.8.3.1
