| # CASE1 starts number of nodes specified in param file |
| # |
| # cameron@onlab.us |
| |
| class SCPFportLat: |
| |
| def __init__( self ): |
| self.default = '' |
| |
| def CASE1( self, main ): |
| import sys |
| import re |
| import os |
| import time |
| |
| global init |
| try: |
| if type(init) is not bool: |
| init = Fals |
| except NameError: |
| init = False |
| |
| #Load values from params file |
| main.testOnDirectory = os.path.dirname(os.getcwd()) |
| checkoutBranch = main.params[ 'GIT' ][ 'checkout' ] |
| gitPull = main.params[ 'GIT' ][ 'autopull' ] |
| cellName = main.params[ 'ENV' ][ 'cellName' ] |
| Apps = main.params[ 'ENV' ][ 'cellApps' ] |
| BENCHIp = main.params[ 'BENCH' ][ 'ip' ] |
| MN1Ip = main.params[ 'MN' ][ 'ip1' ] |
| main.maxNodes = int(main.params[ 'max' ]) |
| cellName = main.params[ 'ENV' ][ 'cellName' ] |
| homeDir = os.path.expanduser('~') |
| topoCfgFile = main.params['TEST']['topoConfigFile'] |
| topoCfgName = main.params['TEST']['topoConfigName'] |
| resultPath = main.params['DB']['portEventResultPath'] |
| skipMvn = main.params ['TEST']['mci'] |
| main.topology = main.params['DEPENDENCY']['topology'] |
| main.dependencyPath = main.testOnDirectory + \ |
| main.params['DEPENDENCY']['path'] |
| testONpath = re.sub( "(tests)$", "bin", main.testDir ) # TestON/bin |
| |
| # -- INIT SECTION, ONLY RUNS ONCE -- # |
| if init == False: |
| init = True |
| global clusterCount #number of nodes running |
| global ONOSIp #list of ONOS IP addresses |
| global scale |
| global commit |
| global timeToPost |
| global runNum |
| global jenkinsBuildNumber |
| global CLIs |
| CLIs = [] |
| |
| timeToPost = time.strftime('%Y-%m-%d %H:%M:%S') |
| runNum = time.strftime('%d%H%M%S') |
| ONOSIp = main.ONOSbench.getOnosIps() |
| |
| #Assigning ONOS cli handles to a list |
| for i in range(main.maxNodes): |
| CLIs.append( getattr( main, 'ONOS' + str(i+1) + 'cli')) |
| |
| try: |
| jenkinsBuildNumber = str(os.environ['BUILD_NUMBER']) |
| main.log.report( 'Jenkins build number: ' + jenkinsBuildNumber ) |
| except KeyError: |
| jenkinsBuildNumber = str(0) |
| main.log.info( 'Job is not run by jenkins. ' + 'Build number set to: ' + jenkinsBuildNumber) |
| |
| clusterCount = 0 |
| ONOSIp = main.ONOSbench.getOnosIps() |
| |
| scale = (main.params[ 'SCALE' ]).split(",") |
| clusterCount = int(scale[0]) |
| |
| #mvn clean install, for debugging set param 'skipCleanInstall' to yes to speed up test |
| if skipMvn != "off": |
| mvnResult = main.ONOSbench.cleanInstall() |
| |
| #git |
| main.step( "Git checkout and pull " + checkoutBranch ) |
| if gitPull == 'on': |
| checkoutResult = main.ONOSbench.gitCheckout( checkoutBranch ) |
| pullResult = main.ONOSbench.gitPull() |
| |
| else: |
| checkoutResult = main.TRUE |
| pullResult = main.TRUE |
| main.log.info( "Skipped git checkout and pull" ) |
| |
| main.step("Grabbing commit number") |
| commit = main.ONOSbench.getVersion() |
| commit = (commit.split(" "))[1] |
| |
| main.step("Creating results file") |
| resultsDB = open(resultPath, "w+") |
| resultsDB.close() |
| |
| main.log.report('Commit information - ') |
| main.ONOSbench.getVersion(report=True) |
| |
| # -- END OF INIT SECTION --# |
| |
| main.step("Adjusting scale") |
| clusterCount = int(scale[0]) |
| scale.remove(scale[0]) |
| |
| #kill off all onos processes |
| main.step("Killing all ONOS processes before environmnet setup") |
| for node in range(main.maxNodes): |
| main.ONOSbench.onosDie(ONOSIp[node]) |
| |
| #Uninstall everywhere |
| main.step( "Cleaning Enviornment..." ) |
| for i in range(main.maxNodes): |
| main.log.info(" Uninstalling ONOS " + str(i) ) |
| main.ONOSbench.onosUninstall( ONOSIp[i] ) |
| main.log.info("Sleep 10 second for uninstall to settle...") |
| time.sleep(10) |
| main.ONOSbench.handle.sendline(" ") |
| main.ONOSbench.handle.expect(":~") |
| |
| #construct the cell file |
| main.log.info("Creating cell file") |
| cellIp = [] |
| for node in range (clusterCount): |
| cellIp.append(ONOSIp[node]) |
| |
| main.ONOSbench.createCellFile("localhost",cellName,MN1Ip,str(Apps), cellIp) |
| |
| main.step( "Set Cell" ) |
| main.ONOSbench.setCell(cellName) |
| |
| main.step( "Creating ONOS package" ) |
| packageResult = main.ONOSbench.onosPackage() |
| |
| main.step( "verify cells" ) |
| verifyCellResult = main.ONOSbench.verifyCell() |
| |
| main.step('Starting mininet topology ') |
| copyResult = main.ONOSbench.copyMininetFile(main.topology, |
| main.dependencyPath, |
| main.Mininet1.user_name, |
| main.Mininet1.ip_address) |
| main.Mininet1.startNet() |
| |
| main.log.report( "Initializeing " + str( clusterCount ) + " node cluster." ) |
| for node in range(clusterCount): |
| main.log.info("Starting ONOS " + str(node) + " at IP: " + ONOSIp[node]) |
| main.ONOSbench.onosInstall( ONOSIp[node]) |
| |
| for node in range(clusterCount): |
| for i in range( 2 ): |
| isup = main.ONOSbench.isup( ONOSIp[node] ) |
| if isup: |
| main.log.info("ONOS " + str(node + 1) + " is up\n") |
| break |
| if not isup: |
| main.log.report( "ONOS " + str(node) + " didn't start!" ) |
| main.log.info("Startup sequence complete") |
| |
| main.step('Starting onos CLIs') |
| for i in range(clusterCount): |
| CLIs[i].startOnosCli(ONOSIp[i]) |
| |
| time.sleep(20) |
| |
| main.step( 'activating essential applications' ) |
| CLIs[0].activateApp( 'org.onosproject.metrics' ) |
| CLIs[0].activateApp( 'org.onosproject.openflow' ) |
| |
| main.step( 'Configuring application parameters' ) |
| |
| configName = 'org.onosproject.net.topology.impl.DefaultTopologyProvider' |
| configParam = 'maxEvents 1' |
| main.ONOSbench.onosCfgSet( ONOSIp[0], configName, configParam ) |
| configParam = 'maxBatchMs 0' |
| main.ONOSbench.onosCfgSet( ONOSIp[0], configName, configParam ) |
| configParam = 'maxIdleMs 0' |
| main.ONOSbench.onosCfgSet( ONOSIp[0], configName, configParam ) |
| |
| def CASE2( 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. |
| """ |
| import time |
| import subprocess |
| import os |
| import requests |
| import json |
| import numpy |
| |
| ONOSUser = main.params['CTRL']['user'] |
| numIter = main.params['TEST']['numIter'] |
| iterIgnore = int(main.params['TEST']['iterIgnore']) |
| |
| deviceTimestampKey = main.params['JSON']['deviceTimestamp'] |
| graphTimestampKey = main.params['JSON']['graphTimestamp'] |
| linkTimestampKey = 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'] |
| localTime = time.strftime('%x %X') |
| localTime = localTime.replace('/', '') |
| localTime = localTime.replace(' ', '_') |
| localTime = localTime.replace(':', '') |
| |
| if debugMode == 'on': |
| main.ONOSbench.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='s1', ip=ONOSIp[0]) |
| main.Mininet1.assignSwController(sw='s2', ip=ONOSIp[0]) |
| |
| time.sleep(15) |
| |
| portUpEndToEndNodeIter = numpy.zeros((clusterCount, int(numIter))) |
| portUpOfpToDevNodeIter = numpy.zeros((clusterCount, int(numIter))) |
| portUpDevToLinkNodeIter = numpy.zeros((clusterCount, int(numIter))) |
| portUpLinkToGraphNodeIter = numpy.zeros((clusterCount, int(numIter))) |
| |
| portDownEndToEndNodeIter = numpy.zeros((clusterCount, int(numIter))) |
| portDownOfpToDevNodeIter = numpy.zeros((clusterCount, int(numIter))) |
| portDownDevToLinkNodeIter = numpy.zeros((clusterCount, int(numIter))) |
| portDownLinkToGraphNodeIter = numpy.zeros((clusterCount, int(numIter))) |
| |
| for i in range(0, int(numIter)): |
| main.log.report('Iteration: ' + str(i+1) + ' ClusterCount: ' + str(clusterCount)) |
| main.step('Starting wireshark capture for port status down') |
| main.ONOSbench.tsharkGrep(tsharkPortStatus, tsharkPortDown) |
| |
| time.sleep(2) |
| |
| main.step('Disable port: ' + interfaceConfig) |
| main.Mininet1.handle.sendline('sh ifconfig ' + |
| interfaceConfig + ' down') |
| main.Mininet1.handle.expect('mininet>') |
| |
| time.sleep(2) |
| |
| jsonStrPtDown = [] |
| for node in range (0, clusterCount): |
| metricsPortDown = CLIs[node].topologyEventsMetrics() |
| jsonStrPtDown.append(metricsPortDown) |
| |
| time.sleep(10) |
| |
| main.ONOSbench.tsharkStop() |
| |
| fPortDown = open(tsharkPortDown, 'r') |
| fLine = fPortDown.readline() |
| objDown = fLine.split(' ') |
| if len(fLine) > 0: |
| timestampBeginPtDown = int(float(objDown[1]) * 1000) |
| # At times, tshark reports timestamp at the 3rd |
| # index of the array. If initial readings were |
| # unlike the epoch timestamp, then check the 3rd |
| # index and set that as a timestamp |
| if timestampBeginPtDown < 1400000000000: |
| timestampBeginPtDown = int(float(objDown[2]) * 1000) |
| else: |
| main.log.info('Tshark output file returned unexpected' + |
| ' results: ' + str(objDown)) |
| timestampBeginPtDown = 0 |
| fPortDown.close() |
| |
| for node in range(0, clusterCount): |
| nodeNum = node+1 |
| metricsDown = CLIs[node].topologyEventsMetrics |
| jsonStrPtDown[node] = metricsDown() |
| jsonObj = json.loads(jsonStrPtDown[node]) |
| |
| if jsonObj: |
| graphTimestamp = jsonObj[graphTimestampKey]['value'] |
| deviceTimestamp = jsonObj[deviceTimestampKey]['value'] |
| linkTimestamp = jsonObj[linkTimestampKey]['value'] |
| else: |
| main.log.error( "Unexpected json object" ) |
| graphTimestamp = 0 |
| deviceTimestamp = 0 |
| linkTimestamp = 0 |
| |
| main.log.info('ptDownTimestamp: ' + str(timestampBeginPtDown)) |
| main.log.info("graphTimestamp: " + str(graphTimestamp)) |
| main.log.info("deviceTimestamp: " + str(deviceTimestamp)) |
| main.log.info("linkTimestamp: " + str(linkTimestamp)) |
| |
| ptDownEndToEnd = int(graphTimestamp) - int(timestampBeginPtDown) |
| ptDownOfpToDevice = float(deviceTimestamp) - float(timestampBeginPtDown) |
| ptDownDeviceToLink = float(linkTimestamp) - float(deviceTimestamp) |
| ptDownLinkToGraph = float(graphTimestamp) - float(linkTimestamp) |
| |
| if ptDownEndToEnd < downThresholdMin or ptDownEndToEnd >= downThresholdMax: |
| main.log.info("ONOS " +str(nodeNum) + " surpassed threshold - port down End-to-end: "+ str(ptDownEndToEnd) + " ms") |
| elif i < iterIgnore: |
| main.log.info("ONOS "+str(nodeNum) + " warming up - port down End-to-end: "+ str(ptDownEndToEnd) + " ms") |
| else: |
| portDownEndToEndNodeIter[node][i] = ptDownEndToEnd |
| main.log.info("ONOS "+str(nodeNum) + " port down End-to-end: "+ str(ptDownEndToEnd) + " ms") |
| |
| if ptDownOfpToDevice < downThresholdMin or ptDownOfpToDevice >= downThresholdMax: |
| main.log.info("ONOS " +str(nodeNum) + " surpassed threshold - port down Ofp-to-device: "+ str(ptDownOfpToDevice) + " ms") |
| elif i < iterIgnore: |
| main.log.info("ONOS "+str(nodeNum) + " warming up - port down Ofp-to-device: "+ str(ptDownOfpToDevice) + " ms") |
| else: |
| portDownOfpToDevNodeIter[node][i] = ptDownOfpToDevice |
| main.log.info("ONOS "+str(nodeNum) + " port down Ofp-to-device: "+ str(ptDownOfpToDevice) + " ms") |
| |
| if ptDownDeviceToLink < downThresholdMin or ptDownDeviceToLink >= downThresholdMax: |
| main.log.info("ONOS " +str(nodeNum) + " surpassed threshold - port down Device-to-link: "+ str(ptDownDeviceToLink) + " ms") |
| elif i < iterIgnore: |
| main.log.info("ONOS "+str(nodeNum) + " warming up - port down Device-to-link: "+ str(ptDownDeviceToLink) + " ms") |
| else: |
| portDownDevToLinkNodeIter[node][i] = ptDownDeviceToLink |
| main.log.info("ONOS "+str(nodeNum) + " port down Device-to-link: "+ str(ptDownDeviceToLink) + " ms") |
| |
| if ptDownLinkToGraph < downThresholdMin or ptDownLinkToGraph >= downThresholdMax: |
| main.log.info("ONOS " +str(nodeNum) + " surpassed threshold - port down Link-to-graph: "+ str(ptDownLinkToGraph) + " ms") |
| elif i < iterIgnore: |
| main.log.info("ONOS "+str(nodeNum) + " warming up - port down Link-to-graph: "+ str(ptDownLinkToGraph) + " ms") |
| else: |
| portDownLinkToGraphNodeIter[node][i] = ptDownLinkToGraph |
| main.log.info("ONOS "+str(nodeNum) + " port down Link-to-graph: "+ str(ptDownLinkToGraph) + " ms") |
| |
| time.sleep(3) |
| |
| main.step('Starting wireshark capture for port status up') |
| main.ONOSbench.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) |
| |
| jsonStrPtUp = [] |
| for node in range (0, clusterCount): |
| metricsPortUp = CLIs[node].topologyEventsMetrics() |
| jsonStrPtUp.append(metricsPortUp) |
| |
| time.sleep(5) |
| main.ONOSbench.tsharkStop() |
| |
| time.sleep(3) |
| |
| 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) |
| else: |
| main.log.info('Tshark output file returned unexpected' + ' results.') |
| timestampBeginPtUp = 0 |
| fPortUp.close() |
| |
| for node in range(0, clusterCount): |
| nodeNum = node+1 |
| metricsUp = CLIs[node].topologyEventsMetrics |
| jsonStrUp = metricsUp() |
| jsonObj = json.loads(jsonStrPtUp[node]) |
| |
| if jsonObj: |
| graphTimestamp = jsonObj[graphTimestampKey]['value'] |
| deviceTimestamp = jsonObj[deviceTimestampKey]['value'] |
| linkTimestamp = jsonObj[linkTimestampKey]['value'] |
| else: |
| main.log.error( "Unexpected json object" ) |
| graphTimestamp = 0 |
| deviceTimestamp = 0 |
| linkTimestamp = 0 |
| |
| |
| main.log.info('ptUpTimestamp: ' + str(timestampBeginPtUp)) |
| main.log.info("graphTimestamp: " + str(graphTimestamp)) |
| main.log.info("deviceTimestamp: " + str(deviceTimestamp)) |
| main.log.info("linkTimestamp: " + str(linkTimestamp)) |
| |
| ptUpEndToEnd = int(graphTimestamp) - int(timestampBeginPtUp) |
| ptUpOfpToDevice = float(deviceTimestamp) - float(timestampBeginPtUp) |
| ptUpDeviceToLink = float(linkTimestamp) - float(deviceTimestamp) |
| ptUpLinkToGraph = float(graphTimestamp) - float(linkTimestamp) |
| |
| if ptUpEndToEnd < upThresholdMin or ptUpEndToEnd >= upThresholdMax: |
| main.log.info("ONOS " +str(nodeNum) + " surpassed threshold - port up End-to-end: "+ str(ptUpEndToEnd) + " ms") |
| elif i < iterIgnore: |
| main.log.info("ONOS "+str(nodeNum) + " warming up - port up End-to-end: "+ str(ptUpEndToEnd) + " ms") |
| else: |
| portUpEndToEndNodeIter[node][i] = ptUpEndToEnd |
| main.log.info("ONOS "+str(nodeNum) + " port up End-to-end: "+ str(ptUpEndToEnd) + " ms") |
| |
| if ptUpOfpToDevice < upThresholdMin or ptUpOfpToDevice >= upThresholdMax: |
| main.log.info("ONOS " + str(nodeNum) + " surpassed threshold - port up Ofp-to-device: "+ str(ptUpOfpToDevice) + " ms") |
| elif i < iterIgnore: |
| main.log.info("ONOS "+ str(nodeNum) + " warming up - port up Ofp-to-device: "+ str(ptUpOfpToDevice) + " ms") |
| else: |
| portUpOfpToDevNodeIter[node][i] = ptUpOfpToDevice |
| main.log.info("ONOS "+ str(nodeNum) + " port up Ofp-to-device: "+ str(ptUpOfpToDevice) + " ms") |
| |
| if ptUpDeviceToLink < upThresholdMin or ptUpDeviceToLink >= upThresholdMax: |
| main.log.info("ONOS " +str(nodeNum) + " surpassed threshold - port up Device-to-link: "+ str(ptUpDeviceToLink) + " ms") |
| elif i < iterIgnore: |
| main.log.info("ONOS "+str(nodeNum) + " warming up - port up Device-to-link: "+ str(ptUpDeviceToLink) + " ms") |
| else: |
| portUpDevToLinkNodeIter[node][i] = ptUpDeviceToLink |
| main.log.info("ONOS "+str(nodeNum) + " port up Device-to-link: "+ str(ptUpDeviceToLink) + " ms") |
| |
| if ptUpLinkToGraph < upThresholdMin or ptUpLinkToGraph >= upThresholdMax: |
| main.log.info("ONOS " + str(nodeNum) + " surpassed threshold - port up Link-to-graph: " + str(ptUpLinkToGraph) + " ms") |
| elif i < iterIgnore: |
| main.log.info("ONOS " + str(nodeNum) + " warming up - port up Link-to-graph: " + str(ptUpLinkToGraph) + " ms") |
| else: |
| portUpLinkToGraphNodeIter[node][i] = ptUpLinkToGraph |
| main.log.info("ONOS " + str(nodeNum) + " port up Link-to-graph: " + str(ptUpLinkToGraph) + " ms") |
| |
| dbCmdList = [] |
| for node in range(0, clusterCount): |
| portUpEndToEndList = [] |
| portUpOfpToDevList = [] |
| portUpDevToLinkList = [] |
| portUpLinkToGraphList = [] |
| |
| portDownEndToEndList = [] |
| portDownOfpToDevList = [] |
| portDownDevToLinkList = [] |
| portDownLinkToGraphList = [] |
| |
| portUpEndToEndAvg = 0 |
| portUpOfpToDevAvg = 0 |
| portUpDevToLinkAvg = 0 |
| portUpLinkToGraphAvg = 0 |
| |
| portDownEndToEndAvg = 0 |
| portDownOfpToDevAvg = 0 |
| portDownDevToLinkAvg = 0 |
| portDownLinkToGraphAvg = 0 |
| |
| # TODO: Update for more pythonic way to get list |
| # portUpDevList = [item for item in portUpDevNodeIter[node] |
| # if item > 0.0] |
| for item in portUpEndToEndNodeIter[node]: |
| if item > 0.0: |
| portUpEndToEndList.append(item) |
| |
| for item in portUpOfpToDevNodeIter[node]: |
| if item > 0.0: |
| portUpOfpToDevList.append(item) |
| |
| for item in portUpDevToLinkNodeIter[node]: |
| if item > 0.0: |
| portUpDevToLinkList.append(item) |
| |
| for item in portUpLinkToGraphNodeIter[node]: |
| if item >= 0.0: |
| portUpLinkToGraphList.append(item) |
| |
| for item in portDownEndToEndNodeIter[node]: |
| if item > 0.0: |
| portDownEndToEndList.append(item) |
| |
| for item in portDownOfpToDevNodeIter[node]: |
| if item > 0.0: |
| portDownOfpToDevList.append(item) |
| |
| for item in portDownDevToLinkNodeIter[node]: |
| if item >= 0.0: |
| portDownDevToLinkList.append(item) |
| |
| for item in portDownLinkToGraphNodeIter[node]: |
| if item >= 0.0: |
| portDownLinkToGraphList.append(item) |
| |
| portUpEndToEndAvg = round(numpy.mean(portUpEndToEndList), 2) |
| portUpOfpToDevAvg = round(numpy.mean(portUpOfpToDevList), 2) |
| portUpDevToLinkAvg = round(numpy.mean(portUpDevToLinkList), 2) |
| portUpLinkToGraphAvg = round(numpy.mean(portUpLinkToGraphList), 2) |
| |
| portDownEndToEndAvg = round(numpy.mean(portDownEndToEndList), 2) |
| portDownOfpToDevAvg = round(numpy.mean(portDownOfpToDevList), 2) |
| portDownDevToLinkAvg = round(numpy.mean(portDownDevToLinkList), 2) |
| portDownLinkToGraphAvg = round(numpy.mean(portDownLinkToGraphList), 2) |
| |
| portUpStdDev = round(numpy.std(portUpEndToEndList), 2) |
| portDownStdDev = round(numpy.std(portDownEndToEndList), 2) |
| |
| main.log.report(' - Node ' + str(node + 1) + ' Summary ---------------- ') |
| main.log.report(' Port up End-to-end ' + |
| str(portUpEndToEndAvg) + ' ms') |
| main.log.report(' Port up Ofp-to-device ' + |
| str(portUpOfpToDevAvg) + ' ms') |
| main.log.report(' Port up Device-to-link ' + |
| str(portUpDevToLinkAvg) + ' ms') |
| main.log.report(' Port up Link-to-graph ' + |
| str(portUpLinkToGraphAvg) + ' ms') |
| |
| main.log.report(' Port down End-to-end ' + |
| str(round(portDownEndToEndAvg, 2)) + ' ms') |
| main.log.report(' Port down Ofp-to-device ' + |
| str(portDownOfpToDevAvg) + ' ms') |
| main.log.report(' Port down Device-to-link ' + |
| str(portDownDevToLinkAvg) + ' ms') |
| main.log.report(' Port down Link-to-graph' + |
| str(portDownLinkToGraphAvg) + ' ms') |
| |
| dbCmdList.append( |
| "'" + timeToPost + "','port_latency_results'," + jenkinsBuildNumber + |
| ',' + str(clusterCount) + ",'baremetal" + str(node + 1) + |
| "'," + |
| str(portUpEndToEndAvg) +',' + |
| str(portUpOfpToDevAvg) + ',' + |
| str(portUpDevToLinkAvg) + ',' + |
| str(portUpLinkToGraphAvg) + ',' + |
| str(portDownEndToEndAvg) + ',' + |
| str(portDownOfpToDevAvg) + ',' + |
| str(portDownDevToLinkAvg) + ',' + |
| str(portDownLinkToGraphAvg)) |
| |
| fResult = open(resultPath, 'a') |
| for line in dbCmdList: |
| if line: |
| fResult.write(line + '\n') |
| |
| fResult.close() |
| |
| # Delete switches from controller to prepare for next |
| # set of tests |
| main.Mininet1.deleteSwController('s1') |
| main.Mininet1.deleteSwController('s2') |
| |
| main.log.info("Stopping mininet") |
| main.Mininet1.stopNet() |