| """ |
| SCPFhostLat |
| This test will test the host found latency. |
| Host will arping a ip address, tshark will caputure the package time, then compare with the topology event timestamp. |
| Test will run with 1 node from start, and scale up to 7 nodes. |
| The event timestamp will only greb the latest one, then calculate average and standar dev. |
| |
| yunpeng@onlab.us |
| """ |
| class SCPFhostLat: |
| |
| def __init__( self ): |
| self.default = '' |
| |
| def CASE0( self, main): |
| import sys |
| import json |
| import time |
| import os |
| import imp |
| try: |
| from tests.dependencies.ONOSSetup import ONOSSetup |
| main.testSetUp = ONOSSetup() |
| except ImportError: |
| main.log.error( "ONOSSetup not found. exiting the test" ) |
| main.exit() |
| main.testSetUp.envSetupDescription() |
| stepResult = main.FALSE |
| try: |
| |
| # Test variables |
| main.cellName = main.params[ 'ENV' ][ 'cellName' ] |
| main.apps = main.params[ 'ENV' ][ 'cellApps' ] |
| main.scale = ( main.params[ 'SCALE' ] ).split( "," ) |
| main.ONOSport = main.params[ 'CTRL' ][ 'port' ] |
| main.startUpSleep = int( main.params[ 'SLEEP' ][ 'startup' ] ) |
| main.installSleep = int( main.params[ 'SLEEP' ][ 'install' ] ) |
| main.measurementSleep = int( main.params[ 'SLEEP' ][ 'measurement' ] ) |
| main.timeout = int( main.params[ 'SLEEP' ][ 'timeout' ] ) |
| main.dbFileName = main.params[ 'DATABASE' ][ 'file' ] |
| |
| # Tshark params |
| main.tsharkResultPath = main.params[ 'TSHARK' ][ 'tsharkPath' ] |
| main.tsharkPacketIn = main.params[ 'TSHARK' ][ 'tsharkPacketIn' ] |
| |
| main.numlter = main.params[ 'TEST' ][ 'numIter' ] |
| main.iterIgnore = int( main.params[ 'TEST' ][ 'iterIgnore' ] ) |
| main.hostTimestampKey = main.params[ 'TEST' ][ 'hostTimestamp' ] |
| main.thresholdStr = main.params[ 'TEST' ][ 'singleSwThreshold' ] |
| main.thresholdObj = main.thresholdStr.split( ',' ) |
| main.thresholdMin = int( main.thresholdObj[ 0 ] ) |
| main.thresholdMax = int( main.thresholdObj[ 1 ] ) |
| main.threadID = 0 |
| |
| main.maxNumBatch = 0 |
| main.setupSkipped = False |
| |
| nic = main.params[ 'DATABASE' ][ 'nic' ] |
| node = main.params[ 'DATABASE' ][ 'node' ] |
| nic = main.params[ 'DATABASE' ][ 'nic' ] |
| node = main.params[ 'DATABASE' ][ 'node' ] |
| stepResult = main.TRUE |
| |
| main.log.info( "Cresting DB file" ) |
| with open( main.dbFileName, "w+" ) as dbFile: |
| dbFile.write( "" ) |
| |
| stepResult = main.testSetUp.gitPulling() |
| except Exception as e: |
| main.testSetUp.envSetupException( e ) |
| main.testSetUp.evnSetupConclusion( stepResult ) |
| |
| main.commit = main.commit.split( " " )[ 1 ] |
| |
| with open( main.dbFileName, "a" ) as dbFile: |
| temp = "'" + main.commit + "'," |
| temp += "'" + nic + "'," |
| dbFile.write( temp ) |
| dbFile.close() |
| def CASE1( self ): |
| # main.scale[ 0 ] determines the current number of ONOS controller |
| main.testSetUp.getNumCtrls( True ) |
| main.testSetUp.envSetup( includeGitPull=False, makeMaxNodes=False ) |
| |
| def CASE2( self, main ): |
| """ |
| - Uninstall ONOS cluster |
| - Verify ONOS start up |
| - Install ONOS cluster |
| - Connect to cli |
| """ |
| main.testSetUp.ONOSSetUp( main.Mininet1, True, |
| cellName=main.cellName, killRemoveMax=False, |
| CtrlsSet=False ) |
| |
| def CASE11( self, main ): |
| main.log.info( "set and configure Application" ) |
| import json |
| import time |
| time.sleep(main.startUpSleep) |
| main.step( "Activating org.onosproject.proxyarp" ) |
| appStatus = utilities.retry( main.ONOSrest1.activateApp, |
| main.FALSE, |
| [ 'org.onosproject.proxyarp' ], |
| sleep=3, |
| attempts=3 ) |
| utilities.assert_equals( expect=main.TRUE, |
| actual=appStatus, |
| onpass="Successfully activated proxyarp", |
| onfail="Failed to activated proxyarp") |
| |
| main.step( "Set up Default Topology Provider" ) |
| appStatus = main.TRUE |
| configName = 'org.onosproject.net.topology.impl.DefaultTopologyProvider' |
| configParam = 'maxEvents' |
| appStatus = appStatus and main.CLIs[0].setCfg( configName, configParam,'1' ) |
| configParam = 'maxBatchMs' |
| appStatus = appStatus and main.CLIs[0].setCfg( configName, configParam, '0') |
| configParam = 'maxIdleMs' |
| appStatus = appStatus and main.CLIs[0].setCfg( configName, configParam,'0' ) |
| utilities.assert_equals( expect=main.TRUE, |
| actual=appStatus, |
| onpass="Successfully set DefaultTopologyProvider", |
| onfail="Failed to set DefaultTopologyProvider" ) |
| |
| time.sleep( main.startUpSleep) |
| main.step('Starting mininet topology') |
| mnStatus = main.Mininet1.startNet(args='--topo=linear,1') |
| utilities.assert_equals( expect=main.TRUE, |
| actual=mnStatus, |
| onpass="Successfully started Mininet", |
| onfail="Failed to activate Mininet" ) |
| main.step("Assinging masters to switches") |
| switches = main.Mininet1.getSwitches() |
| swStatus = main.Mininet1.assignSwController( sw=switches.keys(), ip=main.ONOSip[0] ) |
| utilities.assert_equals( expect=main.TRUE, |
| actual=swStatus, |
| onpass="Successfully assigned switches to masters", |
| onfail="Failed assign switches to masters" ) |
| |
| time.sleep( main.startUpSleep) |
| |
| def CASE20(self, main): |
| """ |
| host1 send arping package and measure latency |
| |
| There are only 1 levels of latency measurements to this test: |
| 1 ) ARPING-to-device measurement: Measurement the time from host1 |
| send apring package to onos processing the host event |
| |
| """ |
| import time |
| import subprocess |
| import json |
| import requests |
| import os |
| import numpy |
| try: |
| from tests.dependencies.utils import Utils |
| except ImportError: |
| main.log.error( "Utils not found exiting the test" ) |
| main.exit() |
| try: |
| main.Utils |
| except ( NameError, AttributeError ): |
| main.Utils = Utils() |
| # Host adding measurement |
| assertion = main.TRUE |
| |
| main.log.report('Latency of adding one host to ONOS') |
| main.log.report('First ' + str( main.iterIgnore ) + ' iterations ignored' + ' for jvm warmup time') |
| main.log.report('Total iterations of test: ' + str( main.numlter ) ) |
| |
| addingHostTime = [] |
| metricsResultList = [] |
| for i in range( 0, int( main.numlter ) ): |
| main.log.info( 'Clean up data file' ) |
| with open( main.tsharkResultPath, "w" ) as dbFile: |
| dbFile.write( "" ) |
| |
| main.log.info('Starting tshark capture') |
| main.ONOSbench.tsharkGrep( main.tsharkPacketIn, main.tsharkResultPath ) |
| time.sleep( main.measurementSleep ) |
| |
| main.log.info('host 1 arping...') |
| main.Mininet1.arping(srcHost='h1', dstHost='10.0.0.2') |
| |
| time.sleep( main.measurementSleep ) |
| |
| main.log.info('Stopping all Tshark processes') |
| main.ONOSbench.tsharkStop() |
| |
| time.sleep( main.measurementSleep ) |
| |
| # Get tshark output |
| with open( main.tsharkResultPath, "r" ) as resultFile: |
| resultText = resultFile.readline() |
| main.log.info( 'Capture result:' + resultText ) |
| resultText = resultText.split(' ') |
| if len( resultText ) > 1: |
| tsharkResultTime = float( resultText[ 1 ] ) * 1000.0 |
| else: |
| main.log.error( 'Tshark output file for packet_in' + ' returned unexpected results' ) |
| hostTime = 0 |
| caseResult = main.FALSE |
| resultFile.close() |
| # Compare the timestemps, and get the lowest one. |
| temp = 0; |
| # Get host event timestamps from each nodes |
| for node in range ( 0, main.numCtrls ): |
| metricsResult = json.loads( main.CLIs[ node ].topologyEventsMetrics() ) |
| metricsResult = metricsResult.get( main.hostTimestampKey ).get( "value" ) |
| main.log.info( "ONOS topology event matrics timestemp: {}".format( str( metricsResult ) ) ) |
| |
| if temp < metricsResult: |
| temp = metricsResult |
| metricsResult = temp |
| |
| addingHostTime.append( float( metricsResult ) - tsharkResultTime ) |
| main.log.info( "Result of this iteration: {}".format( str( float( metricsResult ) - tsharkResultTime) ) ) |
| # gethost to remove |
| gethost = main.ONOSrest1.hosts() |
| HosttoRemove = [] |
| HosttoRemove.append( json.loads( gethost[ 1:len( gethost )-1 ] ).get( 'id' ) ) |
| main.CLIs[0].removeHost( HosttoRemove ) |
| |
| main.log.info( "Result List: {}".format( addingHostTime ) ) |
| |
| # calculate average latency from each nodes |
| averageResult = numpy.average( addingHostTime ) |
| main.log.info( "Average Latency: {}".format( averageResult ) ) |
| |
| # calculate std |
| stdResult = numpy.std(addingHostTime) |
| main.log.info("std: {}".format(stdResult)) |
| |
| # write to DB file |
| main.log.info("Writing results to DS file") |
| with open(main.dbFileName, "a") as dbFile: |
| # Scale number |
| temp = str(main.numCtrls) |
| temp += ",'" + "baremetal1" + "'" |
| # average latency |
| temp += "," + str( averageResult ) |
| # std of latency |
| temp += "," + str(stdResult) |
| temp += "\n" |
| dbFile.write( temp ) |
| |
| assertion = main.TRUE |
| |
| utilities.assert_equals(expect=main.TRUE, actual=assertion, |
| onpass='Host latency test successful', |
| onfail='Host latency test failed') |
| |
| main.Utils.mininetCleanup( main.Mininet1 ) |