Python server端稳定性测试 - Monitor

#!/usr/bin/env python2.6
#encoding=utf-8
import json
import base64
import os
import sys
import time
import string
from datetime import datetime
import unittest
#import  xmlrunner
import ConfigParser

from common_task import CommonTask
from update_tqp_config import UpdateTQPConfig

#from utils import dictutils
#from utils import tmslog

from hosteddb.hosted_taskqueue import HostedTaskQueue
from hosteddb.hosted_device import HostedDevice
from hosteddb.hosted_user import HostedUser
from hosteddb import hosted_info
from airwatch.device import AirwatchDevice

sys.path.append('/opt/mdmi/modules/task_service')
import service_client
import socket

#from vpn_profile import VPNProfile

CFG_DATA = "test_cfg.txt"
TEST_DATA = ConfigParser.ConfigParser()
TEST_DATA.read(CFG_DATA)

#Get Admin user account id from Hosted DB
username = TEST_DATA.get("Connection", "Username")
# The superclass of HostedUser needs accountId to initial object
adminUser = HostedUser(1).get_admin(username)
ACCOUNT_ID = int(adminUser["attributes"]["account"])
#Get Admin user account id from Hosted DB
username2 = TEST_DATA.get("Connection", "Username2")
# The superclass of HostedUser needs accountId to initial object
adminUser = HostedUser(1).get_admin(username2)
ACCOUNT_ID2 = int(adminUser["attributes"]["account"])
#Get Admin user account id from Hosted DB
username3 = TEST_DATA.get("Connection", "Username3")
# The superclass of HostedUser needs accountId to initial object
adminUser = HostedUser(1).get_admin(username3)
ACCOUNT_ID3 = int(adminUser["attributes"]["account"])
#Get Admin user account id from Hosted DB
username4 = TEST_DATA.get("Connection", "Username4")
# The superclass of HostedUser needs accountId to initial object
adminUser = HostedUser(1).get_admin(username4)
ACCOUNT_ID4 = int(adminUser["attributes"]["account"])

NAMESPACES = ["mobile", "email"]
EMAIL_CFG_NAME = ["EmailTasks"]
TQS_CFG_NAME = ["UserGroupTasks", "UserGroupRetryTasks", "EnrollmentTasks", "EnrollmentRetryTasks", "iOSDeployment", "iOSDeployment_retry", "UserGroupPendingTasks", "androidDeployment", "androidDeployment_retry"]
USERGROUP_TQS = ["usergroup", "usergrouppending", "usergroupretry", "usergrouperror"]
ENROLL_TQS = ["enrollment", "enrollmentRetry", "enrollmentError"]
IOS_TQS = ["iosdeploy", "iosdeployretry", "iosdeployerror"]
ARD_TQS = ["androiddeploy", "androiddeployretry", "androiddeployerror"]
EMAIL_TQS = ["email", "error"]
TQS_FOR_CLEAR = ["usergroup", "usergrouppending", "usergroupretry", "usergrouperror", "enrollment", "enrollmentRetry", "enrollmentError", "iosdeploy", "iosdeployretry", "iosdeployerror", "androiddeploy", "androiddeployretry", "androiddeployerror"]

TQP_MONITOR_FILEPATH = "/opt/mdmi/etc/mdmi_monitor/"
TQP_MONITOR_FILES = ["mdmi_monitor_notificationrestservice.ini", "mdmi_monitor_usergroup.ini", "mdmi_monitor_enrollment.ini", "mdmi_monitor_iosdeploy.ini", "mdmi_monitor_androiddeploy.ini"]
TQP_MONITOR_SECTIONS = ["notificationrestservice", "usergroup", "enrollment", "iosdeploy", "androiddeploy"]
TQP_MONITOR_ENTRYS = ["notificationrestservice_receiving_success_counter", "usergroup_receiving_success_counter", "enrollment_receiving_success_counter", "iosdeploy_receiving_success_counter", "androiddeploy_receiving_success_counter"]

class TestPerfREST(unittest.TestCase):
#class TestNotificationServer():
    """
    """
    def setUp(self):
        """The constructor.
            Create a new CommonTask instance.
        """
        self.account_id = ACCOUNT_ID
        self.task = CommonTask()
        self.taskqueue = HostedTaskQueue()
        self.updatetqconfig = UpdateTQPConfig('/etc/sysconfig/tqp/plugins.json')
        #self.ns = NotificationSimu()
        self.vpnprofilename = 'vpn.mobileconfig'
        self.pacfileURL = ''
        self.perflogfilename = 'mdmi_perf_log.txt'
        self.iosspeedlog = 'iosdeploy_process_speed.txt'
        self.nsspeedlog = 'nsrest_process_speed.txt'
        self.ugspeedlog = 'usergroup_process_speed.txt'
        self.enrollspeedlog = 'enroll_process_speed.txt'
        self.ardspeedlog = 'arddeploy_process_speed.txt'
        self.perflongrun = 'mdmi_perf_longrun.txt'
        pass

    def tearDown(self):
        """
            The destructor.
            remove the created CommonTask instance.
        """
        if self.task:
            del self.task
        if self.taskqueue:
            del self.taskqueue
        if self.updatetqconfig:
            del self.updatetqconfig
        #if self.ns:
        #    del self.ns

    def getTQPMonitorCounters(self, filename, section, entry):
        monitor_counter = ConfigParser.ConfigParser()
        monitor_counter.read(filename)
        counter = monitor_counter.get(section, entry)
        return counter

    def updateTQPConfig(self, tqplist=None, flag=1):
        """
        """
        self.updatetqconfig.set_tqp_switch(tqpList=tqplist, flag=flag)
        self.updatetqconfig.restart_service("/etc/init.d/task-processor")
    
    def clearTaskQueues(self, account=1, namespace=NAMESPACES[0]):
        """
        To do:
            clear tqs which name in the tq names list.
        """
        data = {"description" : "", "max_leases" : "30", "max_age" : "0"}    
        tqnames = TQS_FOR_CLEAR
        if self.task:
            del self.task
        self.task = CommonTask()
        for tq in tqnames:
            tq_desc = "%s task queue" % tq
            data['description'] = tq_desc
            self.task.do_clearTaskQueue(account=account, tqname=tq, namespace=namespace, desc=data)
            print "task queue:%s is cleared!" % tq

    def addTask(self, account=None, tqname=None, namespace=None, creator=3, type=1, evt=None, tags=None):
        """
        To do:
            Simulate to add Enrollment task in enrollment decision task queue by User and Group Sync TQP
        Param:
            creator :
                1 - Notification Service
                3 - User and Group Sync TQP
                4 - Enrollment Decision TQP
            type :
                1 - Enrollment task
                2 - De-enrollment task
                3 - Wipe task
            Status :
                1 - Normal task
                2 - Retry task
                3 - Error task
        """
        evt = json.dumps(evt)
        del self.task
        self.task = CommonTask()
        self.task.do_add(account=account, tqname=tqname, namespace=namespace, creator=creator, type=type, evt=evt,tags=tags)
        pass

    def getTaskFromTQ(self, account=None,tqname=None, namespace=None, tags=None):
        del self.task
        self.task = CommonTask()

        tk = self.task.do_getTask(account=account, tqname=tqname, namespace=namespace,tags=tags)
        if tk:
            print 'Got task name is', tk['name']
            print tk
            return tk
        pass

    def getEventFromTask(self, task=None):
        event = self.task.do_getEventFromTask(task=task)
        return event
        pass

    def delTaskQueue(self, account=None,tqname=None, namespace=None):
        if self.task:
            del self.task
        self.task = CommonTask()

        result = self.task.do_delTaskQueue(account=account, tqname=tqname, namespace=namespace)
        print "Del task queue %s is %s" % (tqname, result)
        

    def getEventFromTaskByName(self, account=ACCOUNT_ID, tqname=EMAIL_TQS[1], namespace=NAMESPACES[1], taskname='3678'):
        if self.task:
            del self.task
        self.task = CommonTask()
        
        tk = self.task.do_getTaskByName(tqname=tqname, namespace=namespace, account=account, taskname=taskname)

        if tk:
            print 'Got task name is', tk['name']
            print tk
            event = self.task.do_getEventFromTask(task=tk)
            print event
            return event
        pass

    def getDeviceInfoFromAW(self, device_id):
        """
        To do:
            Get device info. from Airwatch by device id.
        """
        device = AWDevice(self.account_id)
        d = device.get(device_id)
        utils.tmslog.log("test_enrollment decision_tqp.py - device info. from aw is : %s" % d)
        #print d
        return d

    def getDeviceInfoFromRS(self, device_udid):
        """
        To do:
            Get device info. from Hosted RS DB by device udid.
        """
        hosted_device = HostedDevice(device_udid)
        d = hosted_device.do_get()
        #print d
        return d

    def getPacFileUrl(self, accountID, email):
        response = None
        try:
            response = hosted_info.hosted_get_pacfileurl_by_email(accountID, email)
        except Exception, e:
            response = None
            tmslog.log("test_iosdeploy_tqp.py - access hosted os get pac file url error %s" % e)
        return response
    
    def generateVPNFile(self, webpolicy, accountID, eventPayLoad):
        vprofile = None
        try:
            paclist = json.loads(webpolicy, object_hook = dictutils.decode_dict)
            tmslog.log("test_iosdeploy_tqp.py - generate VPN profile start")
            pacfileURL = paclist[0]["attributes"]["policyPacUrl"][0]
            self.pacfileURL = pacfileURL
            tmslog.log("test_iosdeploy_tqp.py - pac file url from account %s is %s" % (accountID, pacfileURL))
            vpnProfile = VPNProfile()
        
            # scanopt default value is 2, TODO need to update the value when Hosted DB ready
            userinfo = "Username:%s;AccountID:%s;DeviceID:%s;DeviceType:%s;DeviceClass:%s;scanopt:2" %(eventPayLoad["EnrollmentEmailAddress"], accountID, eventPayLoad["Udid"], eventPayLoad["Model"], eventPayLoad["Ownership"])
            print 'info sent to vpn profile is : %s' % userinfo
            print '-'*20
            if eventPayLoad.has_key('OperationCallbackURL') and eventPayLoad['OperationCallbackURL']:
                #tmslog.log("test_iosdeployTQP.py - generate VPN profile format is json")
                #vprofile = vpnProfile.dumps(userinfo, pacfileURL, 'json')
                vprofile = vpnProfile.dumps(userinfo, pacfileURL)
            else:      
                vprofile = vpnProfile.dumps(userinfo, pacfileURL)
            tmslog.log("test_iosdeploy_tqp.py - generate VPN profile file end")
            tmslog.log("test_iosdeploy_tqp.py - the VPN profile file is %s " % vprofile)
        except Exception, e:
            vprofile = None
            tmslog.log("test_iosdeploy_tqp.py - generate vpn file error %s " % e)
        return vprofile
    
    def save_file(self, filename, content):
        if filename and content:
            fd = open(filename, 'w')
            fd.write(content)
            fd.close()

    def save_perf_log(self, filename, content):
        if filename and content:
            fd = open(filename, 'a')
            fd.write(content)
            fd.close()

    def check_pac_url(self, filename, pacurl):
        """
        read pac file url
        """
        f = open(filename,'r')
        pac = f.readlines()
        print "pac[0] in vpn profile is %s\npac url got from host db is %s" % (pac[0], pacurl)
        self.assertEqual(pac[0], pacurl)
        f.close()

    def get_letftasksnum(self, tqname, namespace='mobile'):

        account1 = ACCOUNT_ID
        account2 = ACCOUNT_ID2
        account3 = ACCOUNT_ID3
        account4 = ACCOUNT_ID4

        if self.taskqueue:
            del self.taskqueue
        self.taskqueue = HostedTaskQueue()
        lefttasks1 = self.taskqueue.do_get_task_total(account=account1, namespace=namespace, tqname=tqname)
        lefttasks2 = self.taskqueue.do_get_task_total(account=account2, namespace=namespace, tqname=tqname)
        lefttasks3 = self.taskqueue.do_get_task_total(account=account3, namespace=namespace, tqname=tqname)
        lefttasks4 = self.taskqueue.do_get_task_total(account=account4, namespace=namespace, tqname=tqname)
        lefttasks = string.atoi(lefttasks1) + string.atoi(lefttasks2) + string.atoi(lefttasks3) + string.atoi(lefttasks4)
        return lefttasks

    def check_usergroup_taskservice(self):
        try:
            result = service_client.get_service_status()
            #print result
            a = result.split('\n')
            #print a
            print "User and Group task service:"
            print a[6]
        except socket.error as e:
            print "Socket error: User and Group task service is down!"
        except Exception, e:
            print "Error : User and Group task service encounter error %s!" % e

    def test_perf_REST(self):
        """
        To do:
            Performance test for REST service
        """
        #data = {"description" : "ios deployment task queue", "max_leases" : "30", "max_age" : "0"}
        
        sleepsecs = 10

        print 'No need Clear all task queues for long-run stability test...'
        #self.clearTaskQueues(account=1, namespace=NAMESPACES[0])
        print('-'*20)
        print 'Enable all TQPs...'
        self.updateTQPConfig(tqplist=TQS_CFG_NAME, flag=1)
        print('-'*20)

        time_limit = 12000 / 100
        ios_pre_counter = 0
        ns_pre_counter = 0
        ug_pre_counter = 0
        enroll_pre_counter = 0
        ard_pre_counter = 0

        #Get TQPs monitor counters
        ns_counter_file = TQP_MONITOR_FILEPATH + TQP_MONITOR_FILES[0]        
        usergroup_counter_file = TQP_MONITOR_FILEPATH + TQP_MONITOR_FILES[1]        
        enrollment_counter_file = TQP_MONITOR_FILEPATH + TQP_MONITOR_FILES[2]        
        ios_counter_file = TQP_MONITOR_FILEPATH + TQP_MONITOR_FILES[3]        
        ard_counter_file = TQP_MONITOR_FILEPATH + TQP_MONITOR_FILES[4]        

        ns_counter_last = self.getTQPMonitorCounters(ns_counter_file, TQP_MONITOR_SECTIONS[0], TQP_MONITOR_ENTRYS[0])

        usergroup_counter_last = self.getTQPMonitorCounters(usergroup_counter_file, TQP_MONITOR_SECTIONS[1], TQP_MONITOR_ENTRYS[1])
        enrollment_counter_last = self.getTQPMonitorCounters(enrollment_counter_file, TQP_MONITOR_SECTIONS[2], TQP_MONITOR_ENTRYS[2])
        ios_counter_last = self.getTQPMonitorCounters(ios_counter_file, TQP_MONITOR_SECTIONS[3], TQP_MONITOR_ENTRYS[3])
        ard_counter_last = self.getTQPMonitorCounters(ard_counter_file, TQP_MONITOR_SECTIONS[4], TQP_MONITOR_ENTRYS[4])
        
        waitsecs = 10
        print 'Wait for %d seconds for REST Simulator to start up...' %waitsecs
        time.sleep(waitsecs)
        starttime = time.time()
        stime = datetime.now()
        output  =  "mdmi performance test Start time : %s\n" %stime
        print output,
        perf_log_content = output
        ios_speed_content = output
        ns_speed_content = output
        ug_speed_content = output
        enroll_speed_content = output
        ard_speed_content = output
        perf_longrun_content = output
        output = ('-'*20) + '\n'
        print output,
        perf_longrun_content = perf_longrun_content + output
        self.save_perf_log(self.perflongrun, perf_longrun_content)

        index = 0
        while True:
            perf_longrun_content = ""
            endtime = time.time()
            sec_cost = endtime - starttime
            etime = datetime.now()
            #output = "mdmi performance test time cost from beginning: %d seconds.\n" % sec_cost
            output = "current time is: %s\n" % etime
            print output,
            perf_longrun_content = perf_longrun_content + output

            ns_counter = self.getTQPMonitorCounters(ns_counter_file, TQP_MONITOR_SECTIONS[0], TQP_MONITOR_ENTRYS[0])
            ns_counter = string.atoi(ns_counter) - string.atoi(ns_counter_last)
            output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[0], ns_counter)
            print output,
            perf_longrun_content = perf_longrun_content + output

            ns_speed = float(ns_counter - ns_pre_counter) / sleepsecs
            ns_pre_counter = ns_counter
            output = "Speed: %s process task speed is %.1f tasks/Second\n" %(TQP_MONITOR_SECTIONS[0], ns_speed)
            print output,
            perf_longrun_content = perf_longrun_content + output
            ns_speed = str(ns_speed) + '\n'
            ns_speed_content = ns_speed_content + ns_speed            

            tqname = USERGROUP_TQS[0]
            lefttasks1 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks1)
            print output,
            perf_longrun_content = perf_longrun_content + output

            tqname = USERGROUP_TQS[1]
            lefttasks2 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks2)
            print output,
            perf_longrun_content = perf_longrun_content + output
            
            tqname = USERGROUP_TQS[2]
            lefttasks3 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks3)
            print output,
            perf_longrun_content = perf_longrun_content + output

            tqname = USERGROUP_TQS[3]
            lefttasks4 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks4)
            print output,
            perf_longrun_content = perf_longrun_content + output

            #self.check_usergroup_taskservice()

            usergroup_counter = self.getTQPMonitorCounters(usergroup_counter_file, TQP_MONITOR_SECTIONS[1], TQP_MONITOR_ENTRYS[1])
            usergroup_counter = string.atoi(usergroup_counter) - string.atoi(usergroup_counter_last)
            output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[1], usergroup_counter)
            print output,
            perf_longrun_content = perf_longrun_content + output
                
            ug_speed = float(usergroup_counter - ug_pre_counter) / sleepsecs
            ug_pre_counter = usergroup_counter
            output = "Speed: %s process task speed is %.1f tasks/Second\n" %(TQP_MONITOR_SECTIONS[1], ug_speed)
            print output,
            perf_longrun_content = perf_longrun_content + output
            ug_speed = str(ug_speed) + '\n'
            ug_speed_content = ug_speed_content + ug_speed            

            tqname = ENROLL_TQS[0]
            lefttasks5 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks5)
            print output,
            perf_longrun_content = perf_longrun_content + output
                
            tqname = ENROLL_TQS[1]
            lefttasks6 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks6)
            print output,
            perf_longrun_content = perf_longrun_content + output
                
            tqname = ENROLL_TQS[2]
            lefttasks7 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks7)
            print output,
            perf_longrun_content = perf_longrun_content + output
                
            enrollment_counter = self.getTQPMonitorCounters(enrollment_counter_file, TQP_MONITOR_SECTIONS[2], TQP_MONITOR_ENTRYS[2])
            enrollment_counter = string.atoi(enrollment_counter) - string.atoi(enrollment_counter_last)
            output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[2], enrollment_counter)
            print output,
            perf_longrun_content = perf_longrun_content + output

            enroll_speed = float(enrollment_counter - enroll_pre_counter) / sleepsecs
            enroll_pre_counter = enrollment_counter
            output = "Speed: %s process task speed is %.1f tasks/Second\n" %(TQP_MONITOR_SECTIONS[2], enroll_speed)
            print output,
            perf_longrun_content = perf_longrun_content + output
            enroll_speed = str(enroll_speed) + '\n'
            enroll_speed_content = enroll_speed_content + enroll_speed            

            tqname = IOS_TQS[0]
            lefttasks8 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks8)
            print output,
            perf_longrun_content = perf_longrun_content + output

            tqname = IOS_TQS[1]
            lefttasks9 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks9)
            print output,
            perf_longrun_content = perf_longrun_content + output

            tqname = IOS_TQS[2]
            lefttasks10 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks10)
            print output,
            perf_longrun_content = perf_longrun_content + output
        
            ios_counter = self.getTQPMonitorCounters(ios_counter_file, TQP_MONITOR_SECTIONS[3], TQP_MONITOR_ENTRYS[3])
            ios_counter = string.atoi(ios_counter) - string.atoi(ios_counter_last)
            output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[3], ios_counter)
            print output,
            perf_longrun_content = perf_longrun_content + output

            ios_speed = float(ios_counter - ios_pre_counter) / sleepsecs
            ios_pre_counter = ios_counter
            output = "Speed: %s process task speed is %.1f tasks/Second\n" %(TQP_MONITOR_SECTIONS[3], ios_speed)
            print output,
            perf_longrun_content = perf_longrun_content + output
            ios_speed = str(ios_speed) + '\n'
            ios_speed_content = ios_speed_content + ios_speed
    
            tqname = ARD_TQS[0]
            lefttasks11 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks11)
            print output,
            perf_longrun_content = perf_longrun_content + output

            tqname = ARD_TQS[1]
            lefttasks12 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks12)
            print output,
            perf_longrun_content = perf_longrun_content + output

            tqname = ARD_TQS[2]
            lefttasks13 = self.get_letftasksnum(tqname)
            output = "TQ: %s left tasks %d\n" % (tqname, lefttasks13)
            print output,
            perf_longrun_content = perf_longrun_content + output
        
            ard_counter = self.getTQPMonitorCounters(ard_counter_file, TQP_MONITOR_SECTIONS[4], TQP_MONITOR_ENTRYS[4])
            ard_counter = string.atoi(ard_counter) - string.atoi(ard_counter_last)
            output =output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[4], ard_counter)
            print output,
            perf_longrun_content = perf_longrun_content + output

            ard_speed = float(ard_counter - ard_pre_counter) / sleepsecs
            ard_pre_counter = ard_counter
            output = "Speed: %s process task speed is %.1f tasks/Second\n" %(TQP_MONITOR_SECTIONS[4], ard_speed)
            print output,
            perf_longrun_content = perf_longrun_content + output
            ard_speed = str(ard_speed) + '\n'
            ard_speed_content = ard_speed_content + ard_speed
            output = ('-'*20) + '\n'
            print output,
            perf_longrun_content = perf_longrun_content + output

            self.check_usergroup_taskservice()
            output = ('-'*20) + '\n'
            print output,

            #Save the long-run log per 30 seconds
            index = index + 1
            #print index
            if index % 3 == 0:
                self.save_perf_log(self.perflongrun, perf_longrun_content)
                index = 0

            #if lefttasks1 == 0 and lefttasks2 == 0 and lefttasks3 == 0 and lefttasks4 == 0 and lefttasks5== 0 and lefttasks6== 0 and lefttasks7 == 0 and lefttasks8 == 0 and lefttasks9 == 0 and lefttasks10 == 0 and sec_cost >= time_limit:
            if lefttasks1 == 0 and lefttasks2 == 0 and lefttasks3 == 0 and lefttasks5== 0 and lefttasks6== 0 and lefttasks8 == 0 and lefttasks9 == 0 and lefttasks11 == 0 and lefttasks12 == 0 and sec_cost >= time_limit and 1 > 2:
                endtime = time.time()
                etime = datetime.now()
                output = "mdmi performance test End time : %s\n" % etime
                print output,
                perf_log_content = perf_log_content + output
                sec_cost = endtime - starttime
                output = "mdmi performance test time cost: %d seconds.\n" % sec_cost
                print output,
                perf_log_content = perf_log_content + output
                output = '-'*60 + '\n'
                print output,
                perf_log_content = perf_log_content + output
                ns_counter = self.getTQPMonitorCounters(ns_counter_file, TQP_MONITOR_SECTIONS[0], TQP_MONITOR_ENTRYS[0])
                ns_counter = string.atoi(ns_counter) - string.atoi(ns_counter_last)
                output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[0], ns_counter)
                print output,
                perf_log_content = perf_log_content + output                
                ns_speed = float(ns_counter - ns_pre_counter) / sleepsecs
                ns_pre_counter = ns_counter
                print "Speed: %s process task speed is %.1f tasks/Second" %(TQP_MONITOR_SECTIONS[0], ns_speed)
                ns_speed = str(ns_speed) + '\n'
                ns_speed_content = ns_speed_content + ns_speed
                output = "mdmi performance test End time : %s\n" % etime
                ns_speed_content = ns_speed_content + output
                self.save_file(self.nsspeedlog, ns_speed_content)

                usergroup_counter = self.getTQPMonitorCounters(usergroup_counter_file, TQP_MONITOR_SECTIONS[1], TQP_MONITOR_ENTRYS[1])
                usergroup_counter = string.atoi(usergroup_counter) - string.atoi(usergroup_counter_last)
                output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[1], usergroup_counter)
                print output,
                perf_log_content = perf_log_content + output
                ug_speed = float(usergroup_counter - ug_pre_counter) / sleepsecs
                ug_pre_counter = usergroup_counter
                print "Speed: %s process task speed is %.1f tasks/Second" %(TQP_MONITOR_SECTIONS[1], ug_speed)
                ug_speed = str(ug_speed) + '\n'
                ug_speed_content = ug_speed_content + ug_speed
                output = "mdmi performance test End time : %s\n" % etime
                ug_speed_content = ug_speed_content + output
                self.save_file(self.ugspeedlog, ug_speed_content)
                
                enrollment_counter = self.getTQPMonitorCounters(enrollment_counter_file, TQP_MONITOR_SECTIONS[2], TQP_MONITOR_ENTRYS[2])
                enrollment_counter = string.atoi(enrollment_counter) - string.atoi(enrollment_counter_last)
                output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[2], enrollment_counter)                
                print output,
                perf_log_content = perf_log_content + output
                enroll_speed = float(enrollment_counter - enroll_pre_counter) / sleepsecs
                enroll_pre_counter = enrollment_counter
                print "Speed: %s process task speed is %.1f tasks/Second" %(TQP_MONITOR_SECTIONS[2], enroll_speed)
                enroll_speed = str(enroll_speed) + '\n'
                enroll_speed_content = enroll_speed_content + enroll_speed
                output = "mdmi performance test End time : %s\n" % etime
                enroll_speed_content = enroll_speed_content + output
                self.save_file(self.enrollspeedlog, enroll_speed_content)

                ios_counter = self.getTQPMonitorCounters(ios_counter_file, TQP_MONITOR_SECTIONS[3], TQP_MONITOR_ENTRYS[3])
                ios_counter = string.atoi(ios_counter) - string.atoi(ios_counter_last)
                output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[3], ios_counter)
                print output,
                perf_log_content = perf_log_content + output
                #output = '-'*40 + '\n'
                #print output,
                #perf_log_content = perf_log_content + output
                #self.save_perf_log(self.perflogfilename, perf_log_content)

                ios_speed = float(ios_counter - ios_pre_counter) / sleepsecs
                ios_pre_counter = ios_counter
                print "Speed: %s process task speed is %.1f tasks/Second" %(TQP_MONITOR_SECTIONS[3], ios_speed)
                ios_speed = str(ios_speed) + '\n'
                ios_speed_content = ios_speed_content + ios_speed

                output = "mdmi performance test End time : %s\n" % etime
                ios_speed_content = ios_speed_content + output
                self.save_file(self.iosspeedlog, ios_speed_content)    

                ard_counter = self.getTQPMonitorCounters(ard_counter_file, TQP_MONITOR_SECTIONS[4], TQP_MONITOR_ENTRYS[4])
                ard_counter = string.atoi(ard_counter) - string.atoi(ard_counter_last)
                output = "Monitor: %s receiving success counter %d\n" %(TQP_MONITOR_SECTIONS[4], ard_counter)
                print output,
                perf_log_content = perf_log_content + output
                output = '-'*40 + '\n'
                print output,
                perf_log_content = perf_log_content + output
                self.save_perf_log(self.perflogfilename, perf_log_content)

                ard_speed = float(ard_counter - ard_pre_counter) / sleepsecs
                ard_pre_counter = ard_counter
                print "Speed: %s process task speed is %.1f tasks/Second" %(TQP_MONITOR_SECTIONS[4], ard_speed)
                ard_speed = str(ard_speed) + '\n'
                ard_speed_content = ard_speed_content + ard_speed

                output = "mdmi performance test End time : %s\n" % etime
                ard_speed_content = ard_speed_content + output
                self.save_file(self.ardspeedlog, ard_speed_content)    

                break

            #min_cost = float(sec_cost) / float(60)
            #sec_cost = sec_cost % 60
            #print "time cost : %d mins %d secs" % (min_cost, sec_cost)
            #leasedtasks = totalcount - lefttasks
            #process_speed = float(leasedtasks) / float(min_cost)

            #if totalcount >= totaltasks and lefttasks == 0:
            #    output = "total tasks added: %d, leased tasks: %d, left tasks: %d, time cost:%d mins %d secs speed: %d tasks/m " % (totalcount, leasedtasks, lefttasks, min_cost, sec_cost, process_speed)
            #    print output,
            #    break
            #else:
            #    output = "total tasks added: %d, leased tasks: %d, left tasks: %d, time cost:%d mins %d secs speed: %d tasks/m " % (totalcount, leasedtasks, lefttasks, min_cost, sec_cost, process_speed)
            #    print output,            
            time.sleep(sleepsecs)
        pass

if __name__=='__main__':
    #unittest.main(testRunner=xmlrunner.XMLTestRunner(output='/tmp/output/test-reports'))
    unittest.main()
#if __name__ == "__main__":
#    try:
#        eventpayload = {'Model': 'iPhone', 'DeviceId': 70, 'OperationCallbackURL': 'https://127.0.0.1/cgi-py/installvpn.py', 'Udid': '4B6D5E40DFB22BD57EC4AF54DA1F297A3221388B', 'EnrollmentEmailAddress': 'xwang@websense.com', 'RequestID': '123456789abcdef', 'EnrollmentStatus': 'Unenrolled', 'Ownership': 4, 'EnrollmentUserName': 'test_xwang', 'OperatingSystem': '7.0.2', 'AwProfileId': '123456789'}
#        webpolicy = '[{"href":"https://cog01o:8085/rs/v-1/account-86/mail-enduser3%40ntpr.com","attributes":{"policyPacUrl":["http://webdefence-cn-mobile-it.odd.blackspider.com:8082/proxy.pac?p=22kk6289"],"cn":["Mr EndUser3"],"account":["86"],"objectClass":["hostedUser"],"endUserStatus":["Active"],"mail":["enduser3@ntpr.com"],"accountType":["webdefence"],"o":["Neat&tidy Piano Removers"]},"dn":"mail=enduser3@ntpr.com,account=86,dc=blackspider,dc=com"}]'
#        profile = TestNotificationServer()
#        vpn = profile.generateVPNFile(webpolicy, 86, eventpayload)
#        file = open('corporate.mobilconfig', 'w')
#        file.write(vpn)
#        file.close()
#    except Exception,e:
#        print e