# 2015.03.12 10:22:05 PDT
#Embedded file name: ../tests/TopoPerfNextBM/TopoPerfNextBM.py
import time
import sys
import os
import re

class TopoPerfNextBM:

    def __init__(self):
        self.default = ''

    def CASE1(self, main):
        """
        ONOS startup sequence
        """
        global clusterCount
        global timeToPost
        global runNum

        import time
        clusterCount = 1
        timeToPost = time.strftime('%Y-%m-%d %H:%M:%S')
        runNum = time.strftime('%d%H%M%S')
        cellName = main.params['ENV']['cellName']
        gitPull = main.params['GIT']['autoPull']
        checkoutBranch = main.params['GIT']['checkout']
       
        global CLIs
        CLIs = []
        global nodes
        nodes = []
        global nodeIpList
        nodeIpList = []
        for i in range( 1, 8 ):
            CLIs.append( getattr( main, 'ONOS' + str( i ) + 'cli' ) )
            nodes.append( getattr( main, 'ONOS' + str( i ) ) )
            nodeIpList.append( main.params[ 'CTRL' ][ 'ip'+str(i) ] )

        MN1Ip = main.params['MN']['ip1']
        BENCHIp = main.params['BENCH']['ip']
        cellFeatures = main.params['ENV']['cellFeatures']
        topoCfgFile = main.params['TEST']['topoConfigFile']
        topoCfgName = main.params['TEST']['topoConfigName']
        portEventResultPath = main.params['DB']['portEventResultPath']
        switchEventResultPath = main.params['DB']['switchEventResultPath']
        mvnCleanInstall = main.params['TEST']['mci']
        
        main.case('Setting up test environment')

        # NOTE: Below is deprecated after new way to install features
        #main.log.info('Copying topology event accumulator config' +
        #        ' to ONOS /package/etc')
        #main.ONOSbench.handle.sendline('cp ~/' +
        #        topoCfgFile + ' ~/ONOS/tools/package/etc/' +
        #        topoCfgName)
        #main.ONOSbench.handle.expect('\\$')
        
        main.log.report('Setting up test environment')
        
        main.step('Starting mininet topology ')
        main.Mininet1.startNet()
        
        main.step('Cleaning previously installed ONOS if any')
        # Nodes 2 ~ 7
        for i in range( 1, 7 ):
            main.ONOSbench.onosUninstall(nodeIp=nodeIpList[i])
        
        main.step('Clearing previous DB log file')
        
        fPortLog = open(portEventResultPath, 'w')
        fPortLog.write('')
        fPortLog.close()
        fSwitchLog = open(switchEventResultPath, 'w')
        fSwitchLog.write('')
        fSwitchLog.close()
        
        main.step('Creating cell file')
        cellFileResult = main.ONOSbench.createCellFile(
                BENCHIp, cellName, MN1Ip, cellFeatures, nodeIpList[0])
        
        main.step('Applying cell file to environment')
        cellApplyResult = main.ONOSbench.setCell(cellName)
        verifyCellResult = main.ONOSbench.verifyCell()
        
        main.step('Git checkout and pull ' + checkoutBranch)
        if gitPull == 'on':
            checkoutResult = main.TRUE
            pullResult = main.ONOSbench.gitPull()
        else:
            checkoutResult = main.TRUE
            pullResult = main.TRUE
            main.log.info('Skipped git checkout and pull')
        
        main.log.report('Commit information - ')
        main.ONOSbench.getVersion(report=True)
        main.step('Using mvn clean & install')
        if mvnCleanInstall == 'on':
            mvnResult = main.ONOSbench.cleanInstall()
        elif mvnCleanInstall == 'off':
            main.log.info('mci turned off by settings')
            mvnResult = main.TRUE
        main.step('Set cell for ONOS cli env')
        CLIs[0].setCell(cellName)
        
        main.step('Creating ONOS package')
        packageResult = main.ONOSbench.onosPackage()
        
        main.step('Installing ONOS package')
        install1Result = main.ONOSbench.onosInstall(node=nodeIpList[0])
        
        time.sleep(10)
        
        main.step('Start onos cli')
        cli1 = CLIs[0].startOnosCli(nodeIpList[0])
        
        main.step( 'activating essential applications' )
        CLIs[0].activateApp( 'org.onosproject.metrics' )
        CLIs[0].activateApp( 'org.onosproject.openflow' )

        main.step( 'Configuring application parameters' )
        # TODO: Check driver for this functionality
        main.ONOSbench.handle.sendline(
                'onos '+nodeIpList[0]+
                ' cfg set org.onosproject.net.'+
                'topology.impl.DefaultTopologyProvider'+
                ' maxEvents 1')
        main.ONOSbench.handle.expect(":~")
        main.ONOSbench.handle.sendline(
                'onos '+nodeIpList[0]+
                ' cfg set org.onosproject.net.'+
                'topology.impl.DefaultTopologyProvider'+
                ' maxBatchMs 0')
        main.ONOSbench.handle.expect(":~")
        main.ONOSbench.handle.sendline(
                'onos '+nodeIpList[0]+
                ' cfg set org.onosproject.net.'+
                'topology.impl.DefaultTopologyProvider'+
                ' maxIdleMs 0')
        main.ONOSbench.handle.expect(":~")

        utilities.assert_equals(expect=main.TRUE,
                actual=cellFileResult and cellApplyResult and\
                        verifyCellResult and checkoutResult and\
                        pullResult and mvnResult and\
                        install1Result,
                        onpass='Test Environment setup successful',
                        onfail='Failed to setup test environment')

    def CASE2(self, main):
        """
        Assign s1 to ONOS1 and measure latency
        
        There are 4 levels of latency measurements to this test:
        1 ) End-to-end measurement: Complete end-to-end measurement
           from TCP ( SYN/ACK ) handshake to Graph change
        2 ) OFP-to-graph measurement: 'ONOS processing' snippet of
           measurement from OFP Vendor message to Graph change
        3 ) OFP-to-device measurement: 'ONOS processing without
           graph change' snippet of measurement from OFP vendor
           message to Device change timestamp
        4 ) T0-to-device measurement: Measurement that includes
           the switch handshake to devices timestamp without
           the graph view change. ( TCP handshake -> Device
           change )
        """
        import time
        import subprocess
        import json
        import requests
        import os
        import numpy
        
        ONOSUser = main.params['CTRL']['user']
        defaultSwPort = main.params['CTRL']['port1']
        numIter = main.params['TEST']['numIter']
        iterIgnore = int(main.params['TEST']['iterIgnore'])
        
        deviceTimestampKey = main.params['JSON']['deviceTimestamp']
        graphTimestampKey = main.params['JSON']['graphTimestamp']

        debugMode = main.params['TEST']['debugMode']
        onosLog = main.params['TEST']['onosLogFile']
        resultPath = main.params['DB']['switchEventResultPath']
        thresholdStr = main.params['TEST']['singleSwThreshold']
        thresholdObj = thresholdStr.split(',')
        thresholdMin = float(thresholdObj[0])
        thresholdMax = float(thresholdObj[1])
       
        # Look for 'role-request' messages,
        # which replaces the 'vendor' messages previously seen
        # on OVS 2.0.1
        tsharkTcpString = main.params[ 'TSHARK' ][ 'tcpSynAck' ]
        tsharkFeatureReply = main.params[ 'TSHARK' ][ 'featureReply' ]
        tsharkRoleRequest = main.params[ 'TSHARK' ][ 'roleRequest' ]
        tsharkOfString = main.params[ 'TSHARK' ][ 'ofpRoleReply' ]

        tsharkOfOutput = '/tmp/tshark_of_topo.txt'
        tsharkTcpOutput = '/tmp/tshark_tcp_topo.txt'
        tsharkRoleOutput = '/tmp/tshark_role_request.txt'
        tsharkFeatureOutput = '/tmp/tshark_feature_reply.txt'

        # TCP Syn/Ack -> Feature Reply latency collection for each node
        tcpToFeatureLatNodeIter = numpy.zeros((clusterCount, int(numIter)))
        # Feature Reply -> Role Request latency collection for each node
        featureToRoleRequestLatNodeIter = numpy.zeros((clusterCount, 
            int(numIter)))
        # Role Request -> Role Reply latency collection for each node
        roleRequestToRoleReplyLatNodeIter = numpy.zeros((clusterCount,
            int(numIter)))
        # Role Reply -> Device Update latency collection for each node
        roleReplyToDeviceLatNodeIter = numpy.zeros((clusterCount,
            int(numIter)))
        # Device Update -> Graph Update latency collection for each node
        deviceToGraphLatNodeIter = numpy.zeros((clusterCount,
            int(numIter)))

    
        endToEndLatNodeIter = numpy.zeros((clusterCount, int(numIter)))
        ofpToGraphLatNodeIter = numpy.zeros((clusterCount, int(numIter)))
        ofpToDeviceLatNodeIter = numpy.zeros((clusterCount, int(numIter)))
        
        tcpToOfpLatIter = []
        tcpToFeatureLatIter = []
        tcpToRoleLatIter = []
        assertion = main.TRUE
        localTime = time.strftime('%x %X')
        localTime = localTime.replace('/', '')
        localTime = localTime.replace(' ', '_')
        localTime = localTime.replace(':', '')

        if debugMode == 'on':
            main.ONOS1.tsharkPcap('eth0',
                    '/tmp/single_sw_lat_pcap_' + localTime)
            main.log.info('Debug mode is on')
        main.log.report('Latency of adding one switch to controller')
        main.log.report('First ' + str(iterIgnore) +
                ' iterations ignored' + ' for jvm warmup time')
        main.log.report('Total iterations of test: ' + str(numIter))
        
        for i in range(0, int(numIter)):
            main.log.info('Starting tshark capture')
            main.ONOS1.tsharkGrep(tsharkTcpString, tsharkTcpOutput)
            main.ONOS1.tsharkGrep(tsharkOfString, tsharkOfOutput)
            main.ONOS1.tsharkGrep(tsharkRoleRequest, tsharkRoleOutput)
            main.ONOS1.tsharkGrep(tsharkFeatureReply, tsharkFeatureOutput)

            time.sleep(10)
           
            main.log.info('Assigning s3 to controller')
            main.Mininet1.assignSwController(sw='3',
                    ip1=nodeIpList[0], port1=defaultSwPort)
            
            time.sleep(10)
            
            main.log.info('Stopping all Tshark processes')
            main.ONOS1.tsharkStop()
            
            main.log.info('Copying over tshark files')
            os.system('scp ' + ONOSUser + '@' + nodeIpList[0] +
                    ':' + tsharkTcpOutput + ' /tmp/')
            os.system('scp ' + ONOSUser + '@' + nodeIpList[0] +
                    ':' + tsharkRoleOutput + ' /tmp/')
            os.system('scp ' + ONOSUser + '@' + nodeIpList[0] +
                    ':' + tsharkFeatureOutput + ' /tmp/')
            os.system('scp ' + ONOSUser + '@' +
                      nodeIpList[0] + ':' + tsharkOfOutput + ' /tmp/')
           
            # Get tcp syn / ack output
            time.sleep(5)
            tcpFile = open(tsharkTcpOutput, 'r')
            tempText = tcpFile.readline()
            tempText = tempText.split(' ')
            main.log.info('Object read in from TCP capture: ' +
                    str(tempText))
            
            if len(tempText) > 1:
                t0Tcp = float(tempText[1]) * 1000.0
            else:
                main.log.error('Tshark output file for TCP' +
                        ' returned unexpected results')
                t0Tcp = 0
                assertion = main.FALSE
            tcpFile.close()
           
            # Get Role reply output
            time.sleep(5)
            ofFile = open(tsharkOfOutput, 'r')
            lineOfp = ''
            while True:
                tempText = ofFile.readline()
                if tempText != '':
                    lineOfp = tempText
                else:
                    break
            obj = lineOfp.split(' ')
            main.log.info('Object read in from OFP capture: ' +
                    str(lineOfp))
            if len(obj) > 1:
                t0Ofp = float(obj[1]) * 1000.0
            else:
                main.log.error('Tshark output file for OFP' +
                        ' returned unexpected results')
                t0Ofp = 0
                assertion = main.FALSE
            ofFile.close()
           
            # Get role request output
            roleFile = open(tsharkRoleOutput, 'r')
            tempText = roleFile.readline()
            tempText = tempText.split(' ')
            if len(tempText) > 1:
                main.log.info('Object read in from role request capture:' +
                        str(tempText))
                roleTimestamp = float(tempText[1]) * 1000.0
            else:
                main.log.error('Tshark output file for role request' +
                        ' returned unexpected results')
                timeRoleRequest = 0
                assertion = main.FALSE
            roleFile.close()

            # Get feature reply output
            featureFile = open(tsharkFeatureOutput, 'r')
            tempText = featureFile.readline()
            tempText = tempText.split(' ')
            if len(tempText) > 1:
                main.log.info('Object read in from feature reply capture: '+
                        str(tempText))
                featureTimestamp = float(tempText[1]) * 1000.0
            else:
                main.log.error('Tshark output file for feature reply' +
                        ' returned unexpected results')
                timeFeatureReply = 0
                assertion = main.FALSE
            featureFile.close()

            # TODO: calculate feature reply, role request times
            # stack measurements correctly and report

            #TODO: Refactor in progress

            for node in range(0, clusterCount):
                nodeNum = node+1
                metricsSwUp = CLIs[node].topologyEventsMetrics
                jsonStr = metricsSwUp()
                jsonObj = json.loads(jsonStr)
                if jsonObj:
                    graphTimestamp = jsonObj[graphTimestampKey]['value']
                    deviceTimestamp = jsonObj[deviceTimestampKey]['value']
                else:
                    main.log.error( "Unexpected JSON object" )
                    # If we could not obtain the JSON object, 
                    # set the timestamps to 0, which will be
                    # excluded from the measurement later on
                    # (realized as invalid)
                    graphTimestamp = 0
                    deviceTimestamp = 0
                
                endToEnd = int(graphTimestamp) - int(t0Tcp)
                
                # Below are measurement breakdowns of the end-to-end
                # measurement. 
                tcpToFeature = int(featureTimestamp) - int(t0Tcp)
                featureToRole = int(roleTimestamp) - int(featureTimestamp)
                roleToOfp = int(t0Ofp) - int(roleTimestamp)
                ofpToDevice = int(deviceTimestamp) - int(t0Ofp)
                deviceToGraph = float(graphTimestamp) - float(deviceTimestamp)
                
                if endToEnd > thresholdMin and\
                   endToEnd < thresholdMax and i >= iterIgnore:
                    endToEndLatNodeIter[node][i] = endToEnd 
                    main.log.info("ONOS "+str(nodeNum)+ " end-to-end: "+
                            str(endToEnd) + " ms")
                else:
                    main.log.info("ONOS "+str(nodeNum)+ " end-to-end "+
                            "measurement ignored due to excess in "+
                            "threshold or premature iteration")

                if tcpToFeature > thresholdMin and\
                   tcpToFeature < thresholdMax and i >= iterIgnore:
                    tcpToFeatureLatNodeIter[node][i] = tcpToFeature 
                    main.log.info("ONOS "+str(nodeNum)+ " tcp-to-feature: "+
                            str(tcpToFeature) + " ms")
                else:
                    main.log.info("ONOS "+str(nodeNum)+ " tcp-to-feature "+
                            "measurement ignored due to excess in "+
                            "threshold or premature iteration")

                if featureToRole > thresholdMin and\
                   featureToRole < thresholdMax and i >= iterIgnore:
                    featureToRoleRequestLatNodeIter[node][i] = featureToRole 
                    main.log.info("ONOS "+str(nodeNum)+ " feature-to-role: "+
                            str(featureToRole) + " ms")
                else:
                    main.log.info("ONOS "+str(nodeNum)+ " feature-to-role "+
                            "measurement ignored due to excess in "+
                            "threshold or premature iteration")

                if roleToOfp > thresholdMin and\
                   roleToOfp < thresholdMax and i >= iterIgnore:
                    roleRequestToRoleReplyLatNodeIter[node][i] = roleToOfp
                    main.log.info("ONOS "+str(nodeNum)+ " role-to-reply: "+
                            str(roleToOfp) + " ms")
                else:
                    main.log.info("ONOS "+str(nodeNum)+ " role-to-reply "+
                            "measurement ignored due to excess in "+
                            "threshold or premature iteration")
                
                if ofpToDevice > thresholdMin and\
                   ofpToDevice < thresholdMax and i >= iterIgnore:
                    roleReplyToDeviceLatNodeIter[node][i] = ofpToDevice 
                    main.log.info("ONOS "+str(nodeNum)+ " reply-to-device: "+
                            str(ofpToDevice) + " ms")
                else:
                    main.log.info("ONOS "+str(nodeNum)+ " role-to-reply "+
                            "measurement ignored due to excess in "+
                            "threshold or premature iteration")

                if deviceToGraph > thresholdMin and\
                   deviceToGraph < thresholdMax and i >= iterIgnore:
                    deviceToGraphLatNodeIter[node][i] = deviceToGraph
                    main.log.info("ONOS "+str(nodeNum)+ " device-to-graph: "+
                            str(deviceToGraph) + " ms")
                else:
                    main.log.info("ONOS "+str(nodeNum)+ " device=to-graph "+
                            "measurement ignored due to excess in "+
                            "threshold or premature iteration")
                                
            # ********************
            time.sleep(5)
        
            # Get device id to remove
            deviceIdJsonStr = main.ONOS1cli.devices()
            
            main.log.info( "Device obj obtained: " + str(deviceIdJsonStr) )
            deviceId = json.loads(deviceIdJsonStr)

            deviceList = []
            for device in deviceId:
                deviceList.append(device['id'])
           
            # TODO: Measure switch down metrics 
            # TCP FIN/ACK -> TCP FIN
            # TCP FIN -> Device Event
            # Device Event -> Graph Event

            main.step('Remove switch from controller')
            main.Mininet1.deleteSwController('s3')
            
            #firstDevice = deviceList[0] 
            firstDevice = "of:0000000000000003"
            main.log.info( "Removing device " +str(firstDevice)+
                    " from ONOS" )
            #if deviceId:
            main.ONOS1cli.deviceRemove(firstDevice)
            
            time.sleep(5)

        endToEndAvg = 0
        ofpToGraphAvg = 0
        dbCmdList = []
        for node in range(0, clusterCount):
            # List of latency for each node
            endToEndList = []
            
            tcpToFeatureList = []
            featureToRoleList = []
            roleToOfpList = []
            ofpToDeviceList = []
            deviceToGraphList = []

            # LatNodeIter 2d arrays contain all iteration latency
            # for each node of the current scale cluster size
            
            # TODO: Use the new breakdown latency lists

            for item in endToEndLatNodeIter[node]:
                if item > 0.0:
                    endToEndList.append(item)

            for item in tcpToFeatureLatNodeIter[node]:
                if item > 0.0:
                    tcpToFeatureList.append(item)

            for item in featureToRoleRequestLatNodeIter[node]:
                if item > 0.0:
                    featureToRoleList.append(item)

            for item in roleRequestToRoleReplyLatNodeIter[node]:
                if item > 0.0:
                    roleToOfpList.append(item)

            for item in roleReplyToDeviceLatNodeIter[node]:
                if item > 0.0:
                    ofpToDeviceList.append(item)

            for item in deviceToGraphLatNodeIter[node]:
                if item > 0.0:
                    deviceToGraphList.append(item)

            endToEndAvg = round(numpy.mean(endToEndList), 2)
            endToEndStdDev = round(numpy.std(endToEndList), 2)

            tcpToFeatureAvg = round(numpy.mean(tcpToFeatureList), 2)
            tcpToFeatureStdDev = round(numpy.std(tcpToFeatureList), 2)

            featureToRoleAvg = round(numpy.mean(featureToRoleList), 2)
            featureToRoleStdDev = round(numpy.std(featureToRoleList), 2)
            
            roleToOfpAvg = round(numpy.mean(roleToOfpList), 2)
            roleToOfpStdDev = round(numpy.std(roleToOfpList), 2)

            ofpToDeviceAvg = round(numpy.mean(ofpToDeviceList), 2)
            ofpToDeviceStdDev = round(numpy.std(ofpToDeviceList), 2)
            
            deviceToGraphAvg = round(numpy.mean(deviceToGraphList), 2)
            deviceToGraphStdDev = round(numpy.std(deviceToGraphList), 2)

            main.log.report(' - Node ' + str(node + 1) + ' Summary - ')
            main.log.report(' End-to-end Avg: ' + str(endToEndAvg) +
                    ' ms' + ' End-to-end Std dev: ' +
                    str(endToEndStdDev) + ' ms')
            
            main.log.report(' Tcp-to-feature-reply Avg: ' +
                    str(tcpToFeatureAvg) + ' ms')
            main.log.report(' Tcp-to-feature-reply Std dev: '+
                    str(tcpToFeatureStdDev) + ' ms')
            
            main.log.report(' Feature-reply-to-role-request Avg: ' +
                    str(featureToRoleAvg) + ' ms')
            main.log.report(' Feature-reply-to-role-request Std Dev: ' +
                    str(featureToRoleStdDev) + ' ms')
            
            main.log.report(' Role-request-to-role-reply Avg: ' +
                    str(roleToOfpAvg) +' ms')
            main.log.report(' Role-request-to-role-reply Std dev: ' +
                    str(roleToOfpStdDev) + ' ms')
            
            main.log.report(' Role-reply-to-device Avg: ' +
                    str(ofpToDeviceAvg) +' ms')
            main.log.report(' Role-reply-to-device Std dev: ' +
                    str(ofpToDeviceStdDev) + ' ms')
            
            main.log.report(' Device-to-graph Avg: ' +
                    str(deviceToGraphAvg) + ' ms')
            main.log.report( 'Device-to-graph Std dev: ' +
                    str(deviceToGraphStdDev) + ' ms')
            
            dbCmdList.append(
                    "INSERT INTO switch_latency_tests VALUES('" +
                    timeToPost + "','switch_latency_results'," +
                    runNum + ',' + str(clusterCount) + ",'baremetal" + 
                    str(node + 1) + "'," + str(endToEndAvg) + ',' +
                    str(endToEndStd) + ',0,0);')

        if debugMode == 'on':
            main.ONOS1.cpLogsToDir('/opt/onos/log/karaf.log',
                    '/tmp/', copyFileName='sw_lat_karaf')
        fResult = open(resultPath, 'a')
        for line in dbCmdList:
            if line:
                fResult.write(line + '\n')

        fResult.close()
        assertion = main.TRUE
        utilities.assert_equals(expect=main.TRUE, actual=assertion,
                onpass='Switch latency test successful', 
                onfail='Switch latency test failed')

    def CASE3(self, main):
        """
        Bring port up / down and measure latency.
        Port enable / disable is simulated by ifconfig up / down
        
        In ONOS-next, we must ensure that the port we are
        manipulating is connected to another switch with a valid
        connection. Otherwise, graph view will not be updated.
        """
        global timeToPost
        import time
        import subprocess
        import os
        import requests
        import json
        import numpy
        ONOS1Ip = main.params['CTRL']['ip1']
        ONOS2Ip = main.params['CTRL']['ip2']
        ONOS3Ip = main.params['CTRL']['ip3']
        ONOSUser = main.params['CTRL']['user']
        defaultSwPort = main.params['CTRL']['port1']
        assertion = main.TRUE
        numIter = main.params['TEST']['numIter']
        iterIgnore = int(main.params['TEST']['iterIgnore'])
        deviceTimestamp = main.params['JSON']['deviceTimestamp']
        graphTimestamp = main.params['JSON']['graphTimestamp']
        linkTimestamp = main.params['JSON']['linkTimestamp']
        
        tsharkPortUp = '/tmp/tshark_port_up.txt'
        tsharkPortDown = '/tmp/tshark_port_down.txt'
        tsharkPortStatus = main.params[ 'TSHARK' ][ 'ofpPortStatus' ]
        
        debugMode = main.params['TEST']['debugMode']
        postToDB = main.params['DB']['postToDB']
        resultPath = main.params['DB']['portEventResultPath']
        timeToPost = time.strftime('%Y-%m-%d %H:%M:%S')
        localTime = time.strftime('%x %X')
        localTime = localTime.replace('/', '')
        localTime = localTime.replace(' ', '_')
        localTime = localTime.replace(':', '')
        
        if debugMode == 'on':
            main.ONOS1.tsharkPcap('eth0', '/tmp/port_lat_pcap_' + localTime)
        
        upThresholdStr = main.params['TEST']['portUpThreshold']
        downThresholdStr = main.params['TEST']['portDownThreshold']
        upThresholdObj = upThresholdStr.split(',')
        downThresholdObj = downThresholdStr.split(',')
        upThresholdMin = int(upThresholdObj[0])
        upThresholdMax = int(upThresholdObj[1])
        downThresholdMin = int(downThresholdObj[0])
        downThresholdMax = int(downThresholdObj[1])
        
        interfaceConfig = 's1-eth1'
        main.log.report('Port enable / disable latency')
        main.log.report('Simulated by ifconfig up / down')
        main.log.report('Total iterations of test: ' + str(numIter))
        main.step('Assign switches s1 and s2 to controller 1')
        
        main.Mininet1.assignSwController(sw='1',
                ip1=ONOS1Ip, port1=defaultSwPort)
        main.Mininet1.assignSwController(sw='2',
                ip1=ONOS1Ip, port1=defaultSwPort)
        
        time.sleep(15)
        
        portUpDeviceToOfpList = []
        portUpGraphToOfpList = []
        portDownDeviceToOfpList = []
        portDownGraphToOfpList = []
        
        portUpDevNodeIter = numpy.zeros((clusterCount, int(numIter)))
        portUpGraphNodeIter = numpy.zeros((clusterCount, int(numIter)))
        portUpLinkLatNodeIter = numpy.zeros((clusterCount, int(numIter)))
        portDownDevNodeIter = numpy.zeros((clusterCount, int(numIter)))
        portDownGraphNodeIter = numpy.zeros((clusterCount, int(numIter)))
        portDownLinkNodeIter = numpy.zeros((clusterCount, int(numIter)))
        portUpLinkNodeIter = numpy.zeros((clusterCount, int(numIter)))
        
        for i in range(0, int(numIter)):
            main.step('Starting wireshark capture for port status down')
            main.ONOS1.tsharkGrep(tsharkPortStatus, tsharkPortDown)
            time.sleep(5)
            main.step('Disable port: ' + interfaceConfig)
            main.Mininet1.handle.sendline('sh ifconfig ' +
                    interfaceConfig + ' down')
            main.Mininet1.handle.expect('mininet>')
            time.sleep(3)
            main.ONOS1.tsharkStop()
            os.system('scp ' + ONOSUser + '@' + ONOS1Ip + ':' +
                    tsharkPortDown + ' /tmp/')
            fPortDown = open(tsharkPortDown, 'r')
            fLine = fPortDown.readline()
            objDown = fLine.split(' ')
            if len(fLine) > 0:
                timestampBeginPtDown = int(float(objDown[1]) * 1000)
                if timestampBeginPtDown < 1400000000000:
                    timestampBeginPtDown = int(float(objDown[2]) * 1000)
                main.log.info('Port down begin timestamp: ' +
                        str(timestampBeginPtDown))
            else:
                main.log.info('Tshark output file returned unexpected' +
                        ' results: ' + str(objDown))
                timestampBeginPtDown = 0
            fPortDown.close()
          
            """
            # TODO: Refactor in progress

            for node in range(0, clusterCount):
                nodeNum = node+1
                exec "metricsDown = main.ONOS%scli.topologyEventsMetrics"%str(nodeNum) 
                jsonStrDown = metricsDown()
                jsonObj = json.loads(jsonStrDown)
                
                graphTimestamp = jsonObj[graphTimestamp]['value']
                deviceTimestamp = jsonObj[deviceTimestamp]['value']
                linkTimestamp = jsonObj[linkTimestamp]['value']
                
                ptDownGraphToOfp = int(graphTimestamp) - int(timestampBeginPtDown)
                ptDownDeviceToOfp = int(deviceTimestamp) - int(timestampBeginPtDown)
                ptDownLinkToOfp = int(linkTimestamp) - int(timestampBeginPtDown)

                if ptDownGraphToOfp > downThresholdMin and\
                   ptDownGraphToOfp < downThresholdMax and i > iterIgnore:
                    portDownGraphNodeIter[node][i] = ptDownGraphToOfp
                    main.log.info("ONOS "+str(nodeNum)+ 
                            " port down graph-to-ofp: "+
                            str(ptDownGraphToOfp) + " ms") 
                else:
                    main.log.info("ONOS "+str(nodeNum)+
                            " port down graph-to-ofp ignored"+
                            " due to excess in threshold or premature iteration")

                if ptDownDeviceToOfp > downThresholdMin and\
                   ptDownDeviceToOfp < downThresholdMax and i > iterIgnore:
                    portDownDeviceNodeIter[node][i] = ptDownDeviceToOfp
                    main.log.info("ONOS "+str(nodeNum)+ 
                            " port down device-to-ofp: "+
                            str(ptDownDeviceToOfp) + " ms") 
                else:
                    main.log.info("ONOS "+str(nodeNum)+
                            " port down device-to-ofp ignored"+
                            " due to excess in threshold or premature iteration")

                if ptDownLinkToOfp > downThresholdMin and\
                   ptDownLinkToOfp < downThresholdMax and i > iterIgnore:
                    portDownLinkNodeIter[node][i] = ptDownLinkToOfp
                    main.log.info("ONOS "+str(nodeNum)+
                            " port down link-to-ofp: "+
                            str(ptDownLinkToOfp) + " ms")
                else:
                    main.log.info("ONOS "+str(nodeNum)+
                            " port down link-to-ofp ignored"+
                            " due to excess in threshold or premature iteration")
            """
            # *************************

            main.step('Obtain t1 by metrics call')
            
            jsonStrUp1 = main.ONOS1cli.topologyEventsMetrics()
            jsonObj1 = json.loads(jsonStrUp1)
            graphTimestamp1 = jsonObj1[graphTimestamp]['value']
            deviceTimestamp1 = jsonObj1[deviceTimestamp]['value']
            linkTimestamp1 = jsonObj1[linkTimestamp]['value']
            ptDownGraphToOfp1 = int(graphTimestamp1) - int(timestampBeginPtDown)
            ptDownDeviceToOfp1 = int(deviceTimestamp1) - int(timestampBeginPtDown)
            ptDownLinkToOfp1 = int(linkTimestamp1) - int(timestampBeginPtDown)
           
            if ptDownGraphToOfp1 > downThresholdMin and\
               ptDownGraphToOfp1 < downThresholdMax and i > iterIgnore:
                portDownGraphNodeIter[0][i] = ptDownGraphToOfp1
                main.log.info('ONOS1 iter' + str(i) +
                        ' port down graph-to-ofp: ' +
                        str(ptDownGraphToOfp1) + ' ms')
            
            if ptDownDeviceToOfp1 > downThresholdMin and \
               ptDownDeviceToOfp1 < downThresholdMax and i > iterIgnore:
                portDownDevNodeIter[0][i] = ptDownDeviceToOfp1
                main.log.info('ONOS1 iter' + str(i) + 
                        ' port down device-to-ofp: ' +
                        str(ptDownDeviceToOfp1) + ' ms')
            if ptDownLinkToOfp1 > downThresholdMin and\
               ptDownLinkToOfp1 < downThresholdMax and i > iterIgnore:
                portDownLinkNodeIter[0][i] = ptDownLinkToOfp1
                main.log.info('ONOS1 iter' + str(i) +
                        ' port down link-to-ofp: ' +
                        str(ptDownLinkToOfp1) + ' ms')
            
            if clusterCount >= 3:
                jsonStrUp2 = main.ONOS2cli.topologyEventsMetrics()
                jsonStrUp3 = main.ONOS3cli.topologyEventsMetrics()
                jsonObj2 = json.loads(jsonStrUp2)
                jsonObj3 = json.loads(jsonStrUp3)
                graphTimestamp2 = jsonObj2[graphTimestamp]['value']
                graphTimestamp3 = jsonObj3[graphTimestamp]['value']
                deviceTimestamp2 = jsonObj2[deviceTimestamp]['value']
                deviceTimestamp3 = jsonObj3[deviceTimestamp]['value']
                linkTimestamp2 = jsonObj2[linkTimestamp]['value']
                linkTimestamp3 = jsonObj3[linkTimestamp]['value']
                ptDownGraphToOfp2 = int(graphTimestamp2) - int(timestampBeginPtDown)
                ptDownGraphToOfp3 = int(graphTimestamp3) - int(timestampBeginPtDown)
                ptDownDeviceToOfp2 = int(deviceTimestamp2) - int(timestampBeginPtDown)
                ptDownDeviceToOfp3 = int(deviceTimestamp3) - int(timestampBeginPtDown)
                ptDownLinkToOfp2 = int(linkTimestamp2) - int(timestampBeginPtDown)
                ptDownLinkToOfp3 = int(linkTimestamp3) - int(timestampBeginPtDown)
                if ptDownGraphToOfp2 > downThresholdMin and\
                   ptDownGraphToOfp2 < downThresholdMax and i > iterIgnore:
                    portDownGraphNodeIter[1][i] = ptDownGraphToOfp2
                    main.log.info('ONOS2 iter' + str(i) +
                            ' graph-to-ofp: ' +
                            str(ptDownGraphToOfp2) + ' ms')
                if ptDownDeviceToOfp2 > downThresholdMin and \
                   ptDownDeviceToOfp2 < downThresholdMax and i > iterIgnore:
                    portDownDevNodeIter[1][i] = ptDownDeviceToOfp2
                    main.log.info('ONOS2 iter' + str(i) +
                            ' device-to-ofp: ' +
                            str(ptDownDeviceToOfp2) + ' ms')
                if ptDownLinkToOfp2 > downThresholdMin and\
                   ptDownLinkToOfp2 < downThresholdMax and i > iterIgnore:
                    portDownLinkNodeIter[1][i] = ptDownLinkToOfp2
                    main.log.info('ONOS2 iter' + str(i) +
                            ' link-to-ofp: ' +
                            str(ptDownLinkToOfp2) + ' ms')
                if ptDownGraphToOfp3 > downThresholdMin and\
                   ptDownGraphToOfp3 < downThresholdMax and i > iterIgnore:
                    portDownGraphNodeIter[2][i] = ptDownGraphToOfp3
                    main.log.info('ONOS3 iter' + str(i) +
                            ' graph-to-ofp: ' +
                            str(ptDownGraphToOfp3) + ' ms')
                if ptDownDeviceToOfp3 > downThresholdMin and\
                   ptDownDeviceToOfp3 < downThresholdMax and i > iterIgnore:
                    portDownDevNodeIter[2][i] = ptDownDeviceToOfp3
                    main.log.info('ONOS3 iter' + str(i) +
                            ' device-to-ofp: ' +
                            str(ptDownDeviceToOfp3) + ' ms')
                if ptDownLinkToOfp3 > downThresholdMin and\
                   ptDownLinkToOfp3 < downThresholdMax and i > iterIgnore:
                    portDownLinkNodeIter[2][i] = ptDownLinkToOfp3
                    main.log.info('ONOS3 iter' + str(i) +
                            ' link-to-ofp: ' +
                            str(ptDownLinkToOfp3) + ' ms')
            if clusterCount >= 5:
                jsonStrUp4 = main.ONOS4cli.topologyEventsMetrics()
                jsonStrUp5 = main.ONOS5cli.topologyEventsMetrics()
                jsonObj4 = json.loads(jsonStrUp4)
                jsonObj5 = json.loads(jsonStrUp5)
                graphTimestamp4 = jsonObj4[graphTimestamp]['value']
                graphTimestamp5 = jsonObj5[graphTimestamp]['value']
                deviceTimestamp4 = jsonObj4[deviceTimestamp]['value']
                deviceTimestamp5 = jsonObj5[deviceTimestamp]['value']
                linkTimestamp4 = jsonObj4[linkTimestamp]['value']
                linkTimestamp5 = jsonObj5[linkTimestamp]['value']
                ptDownGraphToOfp4 = int(graphTimestamp4) - int(timestampBeginPtDown)
                ptDownGraphToOfp5 = int(graphTimestamp5) - int(timestampBeginPtDown)
                ptDownDeviceToOfp4 = int(deviceTimestamp4) - int(timestampBeginPtDown)
                ptDownDeviceToOfp5 = int(deviceTimestamp5) - int(timestampBeginPtDown)
                ptDownLinkToOfp4 = int(linkTimestamp4) - int(timestampBeginPtDown)
                ptDownLinkToOfp5 = int(linkTimestamp5) - int(timestampBeginPtDown)
                if ptDownGraphToOfp4 > downThresholdMin and \
                   ptDownGraphToOfp4 < downThresholdMax and i > iterIgnore:
                    portDownGraphNodeIter[3][i] = ptDownGraphToOfp4
                    main.log.info('ONOS4 iter' + str(i) +
                            ' graph-to-ofp: ' +
                            str(ptDownGraphToOfp4) + ' ms')
                if ptDownDeviceToOfp4 > downThresholdMin and\
                   ptDownDeviceToOfp4 < downThresholdMax and i > iterIgnore:
                    portDownDevNodeIter[3][i] = ptDownDeviceToOfp4
                    main.log.info('ONOS4 iter' + str(i) +
                            ' device-to-ofp: ' +
                            str(ptDownDeviceToOfp4) + ' ms')
                if ptDownLinkToOfp4 > downThresholdMin and\
                   ptDownLinkToOfp4 < downThresholdMax and i > iterIgnore:
                    portDownLinkNodeIter[3][i] = ptDownLinkToOfp4
                    main.log.info('ONOS4 iter' + str(i) +
                            ' link-to-ofp: ' +
                            str(ptDownLinkToOfp4) + ' ms')
                if ptDownGraphToOfp5 > downThresholdMin and\
                   ptDownGraphToOfp5 < downThresholdMax and i > iterIgnore:
                    portDownGraphNodeIter[4][i] = ptDownGraphToOfp5
                    main.log.info('ONOS5 iter' + str(i) +
                            ' graph-to-ofp: ' +
                            str(ptDownGraphToOfp5) + ' ms')
                if ptDownDeviceToOfp5 > downThresholdMin and\
                   ptDownDeviceToOfp5 < downThresholdMax and i > iterIgnore:
                    portDownDevNodeIter[4][i] = ptDownDeviceToOfp5
                    main.log.info('ONOS5 iter' + str(i) +
                            ' device-to-ofp: ' +
                            str(ptDownDeviceToOfp5) + ' ms')
                if ptDownLinkToOfp5 > downThresholdMin and\
                   ptDownLinkToOfp5 < downThresholdMax and i > iterIgnore:
                    portDownLinkNodeIter[4][i] = ptDownLinkToOfp5
                    main.log.info('ONOS5 iter' + str(i) +
                            ' link-to-ofp: ' +
                            str(ptDownLinkToOfp5) + ' ms')
            if clusterCount >= 7:
                jsonStrUp6 = main.ONOS6cli.topologyEventsMetrics()
                jsonStrUp7 = main.ONOS7cli.topologyEventsMetrics()
                jsonObj6 = json.loads(jsonStrUp6)
                jsonObj7 = json.loads(jsonStrUp7)
                graphTimestamp6 = jsonObj6[graphTimestamp]['value']
                graphTimestamp7 = jsonObj7[graphTimestamp]['value']
                deviceTimestamp6 = jsonObj6[deviceTimestamp]['value']
                deviceTimestamp7 = jsonObj7[deviceTimestamp]['value']
                linkTimestamp6 = jsonObj6[linkTimestamp]['value']
                linkTimestamp7 = jsonObj7[linkTimestamp]['value']
                ptDownGraphToOfp6 = int(graphTimestamp6) - int(timestampBeginPtDown)
                ptDownGraphToOfp7 = int(graphTimestamp7) - int(timestampBeginPtDown)
                ptDownDeviceToOfp6 = int(deviceTimestamp6) - int(timestampBeginPtDown)
                ptDownDeviceToOfp7 = int(deviceTimestamp7) - int(timestampBeginPtDown)
                ptDownLinkToOfp6 = int(linkTimestamp6) - int(timestampBeginPtDown)
                ptDownLinkToOfp7 = int(linkTimestamp7) - int(timestampBeginPtDown)
                if ptDownGraphToOfp6 > downThresholdMin and\
                   ptDownGraphToOfp6 < downThresholdMax and i > iterIgnore:
                    portDownGraphNodeIter[5][i] = ptDownGraphToOfp6
                    main.log.info('ONOS6 iter' + str(i) +
                            ' graph-to-ofp: ' +
                            str(ptDownGraphToOfp6) + ' ms')
                if ptDownDeviceToOfp6 > downThresholdMin and\
                   ptDownDeviceToOfp6 < downThresholdMax and i > iterIgnore:
                    portDownDevNodeIter[5][i] = ptDownDeviceToOfp6
                    main.log.info('ONOS6 iter' + str(i) +
                            ' device-to-ofp: ' +
                            str(ptDownDeviceToOfp6) + ' ms')
                if ptDownLinkToOfp6 > downThresholdMin and\
                   ptDownLinkToOfp6 < downThresholdMax and i > iterIgnore:
                    portDownLinkNodeIter[5][i] = ptDownLinkToOfp6
                    main.log.info('ONOS6 iter' + str(i) +
                            ' link-to-ofp: ' +
                            str(ptDownLinkToOfp6) + ' ms')
                if ptDownGraphToOfp7 > downThresholdMin and\
                   ptDownGraphToOfp7 < downThresholdMax and i > iterIgnore:
                    portDownGraphNodeIter[6][i] = ptDownGraphToOfp7
                    main.log.info('ONOS7 iter' + str(i) +
                            ' graph-to-ofp: ' +
                            str(ptDownGraphToOfp7) + ' ms')
                if ptDownDeviceToOfp7 > downThresholdMin and\
                   ptDownDeviceToOfp7 < downThresholdMax and i > iterIgnore:
                    portDownDevNodeIter[6][i] = ptDownDeviceToOfp7
                    main.log.info('ONOS7 iter' + str(i) +
                            ' device-to-ofp: ' + 
                            str(ptDownDeviceToOfp7) + ' ms')
                if ptDownLinkToOfp7 > downThresholdMin and\
                   ptDownLinkToOfp7 < downThresholdMax and i > iterIgnore:
                    portDownLinkNodeIter[6][i] = ptDownLinkToOfp7
                    main.log.info('ONOS7 iter' + str(i) +
                            ' link-to-ofp: ' +
                            str(ptDownLinkToOfp7) + ' ms')

            time.sleep(3)
            
            main.step('Starting wireshark capture for port status up')
            main.ONOS1.tsharkGrep(tsharkPortStatus, tsharkPortUp)
            
            time.sleep(5)
            main.step('Enable port and obtain timestamp')
            main.Mininet1.handle.sendline('sh ifconfig ' + interfaceConfig + ' up')
            main.Mininet1.handle.expect('mininet>')
            
            time.sleep(5)
            main.ONOS1.tsharkStop()
            
            time.sleep(3)
            os.system('scp ' + ONOSUser + '@' +
                    ONOS1Ip + ':' + tsharkPortUp + ' /tmp/')
            
            fPortUp = open(tsharkPortUp, 'r')
            fLine = fPortUp.readline()
            objUp = fLine.split(' ')
            if len(fLine) > 0:
                timestampBeginPtUp = int(float(objUp[1]) * 1000)
                if timestampBeginPtUp < 1400000000000:
                    timestampBeginPtUp = int(float(objUp[2]) * 1000)
                main.log.info('Port up begin timestamp: ' + str(timestampBeginPtUp))
            else:
                main.log.info('Tshark output file returned unexpected' + ' results.')
                timestampBeginPtUp = 0
            fPortUp.close()
            """ 
            # TODO: Refactoring in progress
            
            for node in range(0, clusterCount):
                nodeNum = node+1
                exec "metricsUp = main.ONOS%scli.topologyEventsMetrics"%str(nodeNum) 
                jsonStrUp = metricsUp()
                jsonObj = json.loads(jsonStrUp)
                
                print jsonObj

                graphTimestamp = jsonObj[graphTimestamp]['value']
                deviceTimestamp = jsonObj[deviceTimestamp]['value']
                linkTimestamp = jsonObj[linkTimestamp]['value']
                
                ptUpGraphToOfp = int(graphTimestamp) - int(timestampBeginPtUp)
                ptUpDeviceToOfp = int(deviceTimestamp) - int(timestampBeginPtUp)
                ptUpLinkToOfp = int(linkTimestamp) - int(timestampBeginPtUp)

                if ptUpGraphToOfp > upThresholdMin and\
                   ptUpGraphToOfp < upThresholdMax and i > iterIgnore:
                    portUpGraphNodeIter[node][i] = ptUpGraphToOfp
                    main.log.info("ONOS "+str(nodeNum)+ 
                            " port up graph-to-ofp: "+
                            str(ptUpGraphToOfp) + " ms") 
                else:
                    main.log.info("ONOS "+str(nodeNum)+
                            " port up graph-to-ofp ignored"+
                            " due to excess in threshold or premature iteration")

                if ptUpDeviceToOfp > upThresholdMin and\
                   ptUpDeviceToOfp < upThresholdMax and i > iterIgnore:
                    portUpDeviceNodeIter[node][i] = ptUpDeviceToOfp
                    main.log.info("ONOS "+str(nodeNum)+ 
                            " port up device-to-ofp: "+
                            str(ptUpDeviceToOfp) + " ms") 
                else:
                    main.log.info("ONOS "+str(nodeNum)+
                            " port up device-to-ofp ignored"+
                            " due to excess in threshold or premature iteration")

                if ptUpLinkToOfp > upThresholdMin and\
                   ptUpLinkToOfp < upThresholdMax and i > iterIgnore:
                    portUpLinkNodeIter[node][i] = ptUpLinkToOfp
                    main.log.info("ONOS "+str(nodeNum)+
                            " port up link-to-ofp: "+
                            str(ptUpLinkToOfp) + " ms")
                else:
                    main.log.info("ONOS "+str(nodeNum)+
                            " port up link-to-ofp ignored"+
                            " due to excess in threshold or premature iteration")

            """

            # *****************************
            
            main.step('Obtain t1 by REST call')
            jsonStrUp1 = main.ONOS1cli.topologyEventsMetrics()
            jsonObj1 = json.loads(jsonStrUp1)
            graphTimestamp1 = jsonObj1[graphTimestamp]['value']
            deviceTimestamp1 = jsonObj1[deviceTimestamp]['value']
            linkTimestamp1 = jsonObj1[linkTimestamp]['value']
            ptUpGraphToOfp1 = int(graphTimestamp1) - int(timestampBeginPtUp)
            ptUpDeviceToOfp1 = int(deviceTimestamp1) - int(timestampBeginPtUp)
            ptUpLinkToOfp1 = int(linkTimestamp1) - int(timestampBeginPtUp)
            if ptUpGraphToOfp1 > upThresholdMin and\
               ptUpGraphToOfp1 < upThresholdMax and i > iterIgnore:
                portUpGraphNodeIter[0][i] = ptUpGraphToOfp1
                main.log.info('ONOS1 iter' + str(i) +
                        ' port up graph-to-ofp: ' +
                        str(ptUpGraphToOfp1) + ' ms')
            if ptUpDeviceToOfp1 > upThresholdMin and \
               ptUpDeviceToOfp1 < upThresholdMax and i > iterIgnore:
                portUpDevNodeIter[0][i] = ptUpDeviceToOfp1
                main.log.info('ONOS1 iter' + str(i) +
                        ' port up device-to-ofp: ' +
                        str(ptUpDeviceToOfp1) + ' ms')
            if ptUpLinkToOfp1 > downThresholdMin and\
               ptUpLinkToOfp1 < downThresholdMax and i > iterIgnore:
                portUpLinkNodeIter[0][i] = ptUpLinkToOfp1
                main.log.info('ONOS1 iter' + str(i) +
                        ' link-to-ofp: ' +
                        str(ptUpLinkToOfp1) + ' ms')
            if clusterCount >= 3:
                jsonStrUp2 = main.ONOS2cli.topologyEventsMetrics()
                jsonStrUp3 = main.ONOS3cli.topologyEventsMetrics()
                jsonObj2 = json.loads(jsonStrUp2)
                jsonObj3 = json.loads(jsonStrUp3)
                graphTimestamp2 = jsonObj2[graphTimestamp]['value']
                graphTimestamp3 = jsonObj3[graphTimestamp]['value']
                deviceTimestamp2 = jsonObj2[deviceTimestamp]['value']
                deviceTimestamp3 = jsonObj3[deviceTimestamp]['value']
                linkTimestamp2 = jsonObj2[linkTimestamp]['value']
                linkTimestamp3 = jsonObj3[linkTimestamp]['value']
                ptUpGraphToOfp2 = int(graphTimestamp2) - int(timestampBeginPtUp)
                ptUpGraphToOfp3 = int(graphTimestamp3) - int(timestampBeginPtUp)
                ptUpDeviceToOfp2 = int(deviceTimestamp2) - int(timestampBeginPtUp)
                ptUpDeviceToOfp3 = int(deviceTimestamp3) - int(timestampBeginPtUp)
                ptUpLinkToOfp2 = int(linkTimestamp2) - int(timestampBeginPtUp)
                ptUpLinkToOfp3 = int(linkTimestamp3) - int(timestampBeginPtUp)
                if ptUpGraphToOfp2 > upThresholdMin and\
                   ptUpGraphToOfp2 < upThresholdMax and i > iterIgnore:
                    portUpGraphNodeIter[1][i] = ptUpGraphToOfp2
                    main.log.info('ONOS2 iter' + str(i) +
                            ' port up graph-to-ofp: ' +
                            str(ptUpGraphToOfp2) + ' ms')
                if ptUpDeviceToOfp2 > upThresholdMin and\
                   ptUpDeviceToOfp2 < upThresholdMax and i > iterIgnore:
                    portUpDevNodeIter[1][i] = ptUpDeviceToOfp2
                    main.log.info('ONOS2 iter' + str(i) +
                            ' port up device-to-ofp: ' +
                            str(ptUpDeviceToOfp2) + ' ms')
                if ptUpLinkToOfp2 > downThresholdMin and\
                   ptUpLinkToOfp2 < downThresholdMax and i > iterIgnore:
                    portUpLinkNodeIter[1][i] = ptUpLinkToOfp2
                    main.log.info('ONOS2 iter' + str(i) +
                            ' port up link-to-ofp: ' +
                            str(ptUpLinkToOfp2) + ' ms')
                if ptUpGraphToOfp3 > upThresholdMin and\
                   ptUpGraphToOfp3 < upThresholdMax and i > iterIgnore:
                    portUpGraphNodeIter[2][i] = ptUpGraphToOfp3
                    main.log.info('ONOS3 iter' + str(i) +
                            ' port up graph-to-ofp: ' +
                            str(ptUpGraphToOfp3) + ' ms')
                if ptUpDeviceToOfp3 > upThresholdMin and\
                   ptUpDeviceToOfp3 < upThresholdMax and i > iterIgnore:
                    portUpDevNodeIter[2][i] = ptUpDeviceToOfp3
                    main.log.info('ONOS3 iter' + str(i) +
                            ' port up device-to-ofp: ' +
                            str(ptUpDeviceToOfp3) + ' ms')
                if ptUpLinkToOfp3 > downThresholdMin and\
                   ptUpLinkToOfp3 < downThresholdMax and i > iterIgnore:
                    portUpLinkNodeIter[2][i] = ptUpLinkToOfp3
                    main.log.info('ONOS3 iter' + str(i) +
                            ' port up link-to-ofp: ' +
                            str(ptUpLinkToOfp3) + ' ms')
            if clusterCount >= 5:
                jsonStrUp4 = main.ONOS4cli.topologyEventsMetrics()
                jsonStrUp5 = main.ONOS5cli.topologyEventsMetrics()
                jsonObj4 = json.loads(jsonStrUp4)
                jsonObj5 = json.loads(jsonStrUp5)
                graphTimestamp4 = jsonObj4[graphTimestamp]['value']
                graphTimestamp5 = jsonObj5[graphTimestamp]['value']
                deviceTimestamp4 = jsonObj4[deviceTimestamp]['value']
                deviceTimestamp5 = jsonObj5[deviceTimestamp]['value']
                linkTimestamp4 = jsonObj4[linkTimestamp]['value']
                linkTimestamp5 = jsonObj5[linkTimestamp]['value']
                ptUpGraphToOfp4 = int(graphTimestamp4) - int(timestampBeginPtUp)
                ptUpGraphToOfp5 = int(graphTimestamp5) - int(timestampBeginPtUp)
                ptUpDeviceToOfp4 = int(deviceTimestamp4) - int(timestampBeginPtUp)
                ptUpDeviceToOfp5 = int(deviceTimestamp5) - int(timestampBeginPtUp)
                ptUpLinkToOfp4 = int(linkTimestamp4) - int(timestampBeginPtUp)
                ptUpLinkToOfp5 = int(linkTimestamp5) - int(timestampBeginPtUp)
                if ptUpGraphToOfp4 > upThresholdMin and\
                   ptUpGraphToOfp4 < upThresholdMax and i > iterIgnore:
                    portUpGraphNodeIter[3][i] = ptUpGraphToOfp4
                    main.log.info('ONOS4 iter' + str(i) +
                            ' port up graph-to-ofp: ' +
                            str(ptUpGraphToOfp4) + ' ms')
                if ptUpDeviceToOfp4 > upThresholdMin and\
                   ptUpDeviceToOfp4 < upThresholdMax and i > iterIgnore:
                    portUpDevNodeIter[3][i] = ptUpDeviceToOfp4
                    main.log.info('ONOS4 iter' + str(i) +
                            ' port up device-to-ofp: ' +
                            str(ptUpDeviceToOfp4) + ' ms')
                if ptUpLinkToOfp4 > downThresholdMin and\
                   ptUpLinkToOfp4 < downThresholdMax and i > iterIgnore:
                    portUpLinkNodeIter[3][i] = ptUpLinkToOfp4
                    main.log.info('ONOS4 iter' + str(i) +
                            ' port up link-to-ofp: ' +
                            str(ptUpLinkToOfp4) + ' ms')
                if ptUpGraphToOfp5 > upThresholdMin and\
                    ptUpGraphToOfp5 < upThresholdMax and i > iterIgnore:
                    portUpGraphNodeIter[4][i] = ptUpGraphToOfp5
                    main.log.info('ONOS5 iter' + str(i) +
                            ' port up graph-to-ofp: ' +
                            str(ptUpGraphToOfp5) + ' ms')
                if ptUpDeviceToOfp5 > upThresholdMin and \
                   ptUpDeviceToOfp5 < upThresholdMax and i > iterIgnore:
                    portUpDevNodeIter[4][i] = ptUpDeviceToOfp5
                    main.log.info('ONOS5 iter' + str(i) +
                            ' port up device-to-ofp: ' +
                            str(ptUpDeviceToOfp5) + ' ms')
                if ptUpLinkToOfp5 > downThresholdMin and\
                   ptUpLinkToOfp5 < downThresholdMax and i > iterIgnore:
                    portUpLinkNodeIter[4][i] = ptUpLinkToOfp5
                    main.log.info('ONOS5 iter' + str(i) +
                            ' port up link-to-ofp: ' +
                            str(ptUpLinkToOfp5) + ' ms')
            
            if clusterCount >= 7:
                jsonStrUp6 = main.ONOS6cli.topologyEventsMetrics()
                jsonStrUp7 = main.ONOS7cli.topologyEventsMetrics()
                jsonObj6 = json.loads(jsonStrUp6)
                jsonObj7 = json.loads(jsonStrUp7)
                graphTimestamp6 = jsonObj6[graphTimestamp]['value']
                graphTimestamp7 = jsonObj7[graphTimestamp]['value']
                deviceTimestamp6 = jsonObj6[deviceTimestamp]['value']
                deviceTimestamp7 = jsonObj7[deviceTimestamp]['value']
                linkTimestamp6 = jsonObj6[linkTimestamp]['value']
                linkTimestamp7 = jsonObj7[linkTimestamp]['value']
                ptUpGraphToOfp6 = int(graphTimestamp6) - int(timestampBeginPtUp)
                ptUpGraphToOfp7 = int(graphTimestamp7) - int(timestampBeginPtUp)
                ptUpDeviceToOfp6 = int(deviceTimestamp6) - int(timestampBeginPtUp)
                ptUpDeviceToOfp7 = int(deviceTimestamp7) - int(timestampBeginPtUp)
                ptUpLinkToOfp6 = int(linkTimestamp6) - int(timestampBeginPtUp)
                ptUpLinkToOfp7 = int(linkTimestamp7) - int(timestampBeginPtUp)
                if ptUpGraphToOfp6 > upThresholdMin and\
                   ptUpGraphToOfp6 < upThresholdMax and i > iterIgnore:
                    portUpGraphNodeIter[5][i] = ptUpGraphToOfp6
                    main.log.info('ONOS6 iter' + str(i) +
                            ' port up graph-to-ofp: ' +
                            str(ptUpGraphToOfp6) + ' ms')
                if ptUpDeviceToOfp6 > upThresholdMin and\
                   ptUpDeviceToOfp6 < upThresholdMax and i > iterIgnore:
                    portUpDevNodeIter[5][i] = ptUpDeviceToOfp6
                    main.log.info('ONOS6 iter' + str(i) +
                            ' port up device-to-ofp: ' + 
                            str(ptUpDeviceToOfp6) + ' ms')
                if ptUpLinkToOfp6 > downThresholdMin and\
                   ptUpLinkToOfp6 < downThresholdMax and i > iterIgnore:
                    portUpLinkNodeIter[5][i] = ptUpLinkToOfp6
                    main.log.info('ONOS6 iter' + str(i) +
                            ' port up link-to-ofp: ' +
                            str(ptUpLinkToOfp6) + ' ms')
                if ptUpGraphToOfp7 > upThresholdMin and \
                   ptUpGraphToOfp7 < upThresholdMax and i > iterIgnore:
                    portUpGraphNodeIter[6][i] = ptUpGraphToOfp7
                    main.log.info('ONOS7 iter' + str(i) +
                            ' port up graph-to-ofp: ' + 
                            str(ptUpGraphToOfp7) + ' ms')
                if ptUpDeviceToOfp7 > upThresholdMin and\
                   ptUpDeviceToOfp7 < upThresholdMax and i > iterIgnore:
                    portUpDevNodeIter[6][i] = ptUpDeviceToOfp7
                    main.log.info('ONOS7 iter' + str(i) +
                            ' port up device-to-ofp: ' +
                            str(ptUpDeviceToOfp7) + ' ms')
                if ptUpLinkToOfp7 > downThresholdMin and\
                   ptUpLinkToOfp7 < downThresholdMax and i > iterIgnore:
                    portUpLinkNodeIter[6][i] = ptUpLinkToOfp7
                    main.log.info('ONOS7 iter' + str(i) +
                            ' port up link-to-ofp: ' +
                            str(ptUpLinkToOfp7) + ' ms')

        dbCmdList = []
        for node in range(0, clusterCount):
            portUpDevList = []
            portUpGraphList = []
            portUpLinkList = []
            portDownDevList = []
            portDownGraphList = []
            portDownLinkList = []

            portUpDevAvg = 0
            portUpGraphAvg = 0
            portUpLinkAvg = 0
            portDownDevAvg = 0
            portDownGraphAvg = 0
            portDownLinkAvg = 0

            for item in portUpDevNodeIter[node]:
                if item > 0.0:
                    portUpDevList.append(item)

            for item in portUpGraphNodeIter[node]:
                if item > 0.0:
                    portUpGraphList.append(item)

            for item in portUpLinkNodeIter[node]:
                if item > 0.0:
                    portUpLinkList.append(item)

            for item in portDownDevNodeIter[node]:
                if item > 0.0:
                    portDownDevList.append(item)

            for item in portDownGraphNodeIter[node]:
                if item > 0.0:
                    portDownGraphList.append(item)

            for item in portDownLinkNodeIter[node]:
                if item > 0.0:
                    portDownLinkList.append(item)

            portUpDevAvg = round(numpy.mean(portUpDevList), 2)
            portUpGraphAvg = round(numpy.mean(portUpGraphList), 2)
            portUpLinkAvg = round(numpy.mean(portUpLinkList), 2)

            portDownDevAvg = round(numpy.mean(portDownDevList), 2)
            portDownGraphAvg = round(numpy.mean(portDownGraphList), 2)
            portDownLinkAvg = round(numpy.mean(portDownLinkList), 2)
            
            portUpStdDev = round(numpy.std(portUpGraphList), 2)
            portDownStdDev = round(numpy.std(portDownGraphList), 2)
           
            main.log.report(' - Node ' + str(node + 1) + ' Summary - ')
            main.log.report(' Port up ofp-to-device ' +
                    str(portUpDevAvg) + ' ms')
            main.log.report(' Port up ofp-to-graph ' +
                    str(portUpGraphAvg) + ' ms')
            main.log.report(' Port up ofp-to-link ' +
                    str(portUpLinkAvg) + ' ms')
            
            main.log.report(' Port down ofp-to-device ' +
                    str(round(portDownDevAvg, 2)) + ' ms')
            main.log.report(' Port down ofp-to-graph ' +
                    str(portDownGraphAvg) + ' ms')
            main.log.report(' Port down ofp-to-link ' +
                    str(portDownLinkAvg) + ' ms')

            dbCmdList.append("INSERT INTO port_latency_tests VALUES('" + 
                    timeToPost + "','port_latency_results'," + runNum +
                    ',' + str(clusterCount) + ",'baremetal" + str(node + 1) +
                    "'," + str(portUpGraphAvg) + ',' + str(portUpStdDev) +
                    '' + str(portDownGraphAvg) + ',' + str(portDownStdDev) + ');')

        fResult = open(resultPath, 'a')
        for line in dbCmdList:
            if line:
                fResult.write(line + '\n')

        fResult.close()
        main.Mininet1.deleteSwController('s1')
        main.Mininet1.deleteSwController('s2')
        utilities.assert_equals(expect=main.TRUE,
                actual=assertion,
                onpass='Port discovery latency calculation successful',
                onfail='Port discovery test failed')

    def CASE4(self, main):
        """
        Increase number of nodes and initiate CLI
        
        With the most recent implementation, we need a method to
        ensure all ONOS nodes are killed, as well as redefine
        the cell files to ensure all nodes that will be used
        is in the cell file. Otherwise, exceptions will
        prohibit test from running successfully.
        
        3/12/15

        """
        global clusterCount
        import time
        import os

        clusterCount += 2

        benchIp = main.params[ 'BENCH' ][ 'ip' ]
        features = main.params[ 'ENV' ][ 'cellFeatures' ]
        cellName = main.params[ 'ENV' ][ 'cellName' ]
        mininetIp = main.params[ 'MN' ][ 'ip1' ]
        
        main.log.report('Increasing cluster size to ' + str(clusterCount))
     
        main.log.step( "Killing all ONOS processes before scale-out" )
        
        for i in range( 1, 8 ):
            main.ONOSbench.onosDie(
                    main.params[ 'CTRL' ][ 'ip'+str(i) ] )
            main.ONOSbench.onosUninstall(
                    main.params[ 'CTRL' ][ 'ip'+str(i) ] )

        main.step( "Creating scale-out cell file" )
        cellIp = []
        for node in range( 1, clusterCount + 1 ):
            cellIp.append( main.params[ 'CTRL' ][ 'ip'+str(node) ] )

        main.log.info( "Cell Ip list: " + str(cellIp) )
        main.ONOSbench.createCellFile( benchIp, cellName, mininetIp,
                                       str(features), *cellIp )
        
        main.step( "Setting cell definition" )
        main.ONOSbench.setCell(cellName)

        main.step( "Packaging cell definition" )
        main.ONOSbench.onosPackage()

        for node in range( 1, clusterCount + 1 ):
            main.ONOSbench.onosInstall(
                    node = main.params[ 'CTRL' ][ 'ip'+str(node) ])
        
        time.sleep( 20 )
        
        for node in range( 1, clusterCount + 1):
            for i in range( 2 ):
                isup = main.ONOSbench.isup( 
                        main.params[ 'CTRL' ][ 'ip'+str(node) ] )
                if isup:
                    main.log.info( "ONOS "+str(node) + " is up\n")
                    break
            if not isup:
                main.log.error( "ONOS "+str(node) + " did not start" )

        for node in range( 1, clusterCount + 1):
            exec "a = main.ONOS%scli.startOnosCli" %str(node)
            a(main.params[ 'CTRL' ][ 'ip'+str(node) ])