blob: e6f62ef956d46dd219cc2eeafb0e3fc7675c2c61 [file] [log] [blame]
# 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()