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
import MySQLdb

from common_task import CommonTask
from update_tqp_config import UpdateTQPConfig

#from utils import dictutils
#from utils import tmslog

from hosteddb.hosted_base import HostedBase
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

#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"]
IOS_TQS_CFG_NAME = ["EnrollmentTasks", "EnrollmentRetryTasks", "iOSDeployment", "iOSDeployment_retry", "androidDeployment", "androidDeployment_retry"]
RETRY_TQS_CFG_NAME = ["EnrollmentRetryTasks", "iOSDeployment_retry", "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 RSUser(HostedBase):
    def __init__(self, account_id):
        super(RSUser, self).__init__(account_id)

    def __del__(self):
        pass

    def count_users(self):
        filter = '{ "filter" : "(&(objectClass=person)(endUserStatus=Active))", "base":"account=%s","count":true,"vlv":{"before":0,"after":1, "offset":1,"force_new_session":true},"sort":["cn"] }' % self.account_id
        count_dict = self._do_get_action(filter)
        if 'total_count' in count_dict:
            return int(count_dict['total_count'])
        return int(count_dict['count'])


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.mysql_connection = MySQLdb.connect(host='cfg',user='webserv',db='blackspider',port=3306)
        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
        #if self.mysql_connection:
        #     try:
        #         self.mysql_connection.close()
        #     except MySQLdb.Error, e:
        #         print 'failed to close myql connection.', e

    def getTQPMonitorCounters(self, filename, section, entry):
        monitor_counter = ConfigParser.ConfigParser()
        monitor_counter.read(filename)
        counter = '0'
        try:
            counter = monitor_counter.get(section, entry)
        except:
            pass
        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 count_db_users(self):
        mysql_connection = MySQLdb.connect(host='cfg',user='webserv',db='blackspider',port=3306)
        cur = mysql_connection.cursor()
        sql = "SELECT count(1) FROM wdEndUsers WHERE Active=1 AND AccountID in %(accounts)s"
        cur.execute(sql, {'accounts': (ACCOUNT_ID, ACCOUNT_ID2, ACCOUNT_ID3, ACCOUNT_ID4)})
        result = cur.fetchone()
        count = 0
        if result:
            count = result[0]
        print '%s: %d users in db' % (time.strftime("%Y/%m/%d %I:%M:%S"), count)
        cur.close()
        mysql_connection.close()
        pass

    def count_rs_users(self):
        accounts = [ACCOUNT_ID, ACCOUNT_ID2, ACCOUNT_ID3, ACCOUNT_ID4]
        count = 0
        for acct in accounts:
            count += RSUser(acct).count_users()
        print '%s: %d users in RS' % (time.strftime("%Y/%m/%d %I:%M:%S"), count)
        pass

    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 'Clear all task queues...'
        self.clearTaskQueues(account=1, namespace=NAMESPACES[0])
        print('-'*20)
        print 'Enable all TQPs...'
        self.updateTQPConfig(tqplist=TQS_CFG_NAME, flag=1)
        #print 'Disable all Rertry TQPs...'
        #self.updateTQPConfig(tqplist=RETRY_TQS_CFG_NAME, flag=0)
        #print('-'*20)

        time_limit = 10
        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 = 20
        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

        while True:
             
            endtime = time.time()
            sec_cost = endtime - starttime
            output = "mdmi performance test time cost from beginning: %d seconds.\n" % sec_cost
            print output

            self.count_db_users()
            self.count_rs_users()

            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)
            print "Monitor: %s receiving success counter %d" %(TQP_MONITOR_SECTIONS[0], ns_counter)

            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          

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

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

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

            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)
            print "Monitor: %s receiving success counter %d" %(TQP_MONITOR_SECTIONS[1], usergroup_counter)
                
            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          

            tqname = ENROLL_TQS[0]
            lefttasks5 = self.get_letftasksnum(tqname)
            print "TQ: %s left tasks %d" % (tqname, lefttasks5)
                
            tqname = ENROLL_TQS[1]
            lefttasks6 = self.get_letftasksnum(tqname)
            print "TQ: %s left tasks %d" % (tqname, lefttasks6)
                
            tqname = ENROLL_TQS[2]
            lefttasks7 = self.get_letftasksnum(tqname)
            print "TQ: %s left tasks %d" % (tqname, lefttasks7)
                
            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)
            print "Monitor: %s receiving success counter %d" %(TQP_MONITOR_SECTIONS[2], enrollment_counter)

            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          

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

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

            tqname = IOS_TQS[2]
            lefttasks10 = self.get_letftasksnum(tqname)
            print "TQ: %s left tasks %d" % (tqname, lefttasks10)
        
            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)
            print "Monitor: %s receiving success counter %d" %(TQP_MONITOR_SECTIONS[3], ios_counter)

            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
    
            tqname = ARD_TQS[0]
            lefttasks11 = self.get_letftasksnum(tqname)
            print "TQ: %s left tasks %d" % (tqname, lefttasks11)

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

            tqname = ARD_TQS[2]
            lefttasks13 = self.get_letftasksnum(tqname)
            print "TQ: %s left tasks %d" % (tqname, lefttasks13)
        
            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)
            print "Monitor: %s receiving success counter %d" %(TQP_MONITOR_SECTIONS[4], ard_counter)

            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
            print('-'*20)

            #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:
                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