blob: 8a9591d6b4073d297b4c2df91e1672c23f7b7a3b [file] [log] [blame]
# 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']
ONOS1Ip = main.params['CTRL']['ip1']
ONOS2Ip = main.params['CTRL']['ip2']
ONOS3Ip = main.params['CTRL']['ip3']
ONOS4Ip = main.params['CTRL']['ip4']
ONOS5Ip = main.params['CTRL']['ip5']
ONOS6Ip = main.params['CTRL']['ip6']
ONOS7Ip = main.params['CTRL']['ip7']
MN1Ip = main.params['MN']['ip1']
BENCHIp = main.params['BENCH']['ip']
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')
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')
main.ONOSbench.onosUninstall(nodeIp=ONOS2Ip)
main.ONOSbench.onosUninstall(nodeIp=ONOS3Ip)
main.ONOSbench.onosUninstall(nodeIp=ONOS4Ip)
main.ONOSbench.onosUninstall(nodeIp=ONOS5Ip)
main.ONOSbench.onosUninstall(nodeIp=ONOS6Ip)
main.ONOSbench.onosUninstall(nodeIp=ONOS7Ip)
main.step('Clearing previous DB log file')
fPortLog = open(portEventResultPath, 'w')
fPortLog.write('')
fPortLog.close()
fSwitchLog = open(switchEventResultPath, 'w')
fSwitchLog.write('')
fSwitchLog.close()
cellStr = 'webconsole,onos-core,onos-api,onos-app-metrics,' +\
'onos-app-gui,onos-cli,onos-openflow'
main.step('Creating cell file')
cellFileResult = main.ONOSbench.createCellFile(
BENCHIp, cellName, MN1Ip, cellStr, ONOS1Ip)
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')
main.ONOS1cli.setCell(cellName)
main.step('Creating ONOS package')
packageResult = main.ONOSbench.onosPackage()
main.step('Installing ONOS package')
install1Result = main.ONOSbench.onosInstall(node=ONOS1Ip)
time.sleep(10)
main.step('Start onos cli')
cli1 = main.ONOS1cli.startOnosCli(ONOS1Ip)
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
ONOS1Ip = main.params['CTRL']['ip1']
ONOS2Ip = main.params['CTRL']['ip2']
ONOS3Ip = main.params['CTRL']['ip3']
ONOS4Ip = main.params['CTRL']['ip4']
ONOS5Ip = main.params['CTRL']['ip5']
ONOS6Ip = main.params['CTRL']['ip6']
ONOS7Ip = main.params['CTRL']['ip7']
ONOSUser = main.params['CTRL']['user']
defaultSwPort = main.params['CTRL']['port1']
numIter = main.params['TEST']['numIter']
iterIgnore = int(main.params['TEST']['iterIgnore'])
deviceTimestamp = main.params['JSON']['deviceTimestamp']
graphTimestamp = 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 = int(thresholdObj[0])
thresholdMax = int(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'
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=ONOS1Ip, 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 + '@' + ONOS1Ip +
':' + tsharkTcpOutput + ' /tmp/')
os.system('scp ' + ONOSUser + '@' + ONOS1Ip +
':' + tsharkRoleOutput + ' /tmp/')
os.system('scp ' + ONOSUser + '@' + ONOS1Ip +
':' + tsharkFeatureOutput + ' /tmp/')
os.system('scp ' + ONOSUser + '@' +
ONOS1Ip + ':' + 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
exec "metricsSwUp = main.ONOS%scli.topologyEventsMetrics"%str(nodeNum)
jsonStr = metricsSwUp()
jsonObj = json.loads(jsonStr)
graphTimestamp = jsonObj[graphTimestamp]['value']
deviceTimestamp = jsonObj[deviceTimestamp]['value']
deltaGraphTcp = int(graphTimestamp) - int(t0Tcp)
deltaDeviceTcp = int(deviceTimestamp) - int(t0Tcp)
deltaGraphOfp = int(graphTimestamp) - int(t0Ofp)
deltaDeviceOfp = int(deviceTimestamp) - int(t0Ofp)
deltaRoleTcp = int(roleTimestamp) - int(t0Tcp)
deltaFeatureTcp = int(featureTimestamp) - int(t0Tcp)
deltaOfpTcp = int(t0Ofp) - int(t0Tcp)
if deltaGraphTcp > thresholdMin and\
deltaGraphTcp < thresholdMax and i >= iterIgnore:
endToEndLatNodeIter[node][i] = deltaGraphTcp
main.log.info("ONOS "+str(nodeNum)+ " tcp-to-graph: "+
str(deltaGraphTcp) + " ms")
else:
main.log.info("ONOS "+str(nodeNum)+ " tcp-to-graph "+
"measurement ignored due to excess in "+
"threshold or premature iteration")
if deltaGraphOfp > thresholdMin and\
deltaGraphOfp < thresholdMax and i >= iterIgnore:
ofpToGraphLatNodeIter[node][i] = deltaGraphOfp
main.log.info("ONOS "+str(nodeNum)+ " ofp-to-graph: "+
str(deltaGraphOfp) + " ms")
else:
main.log.info("ONOS "+str(nodeNum)+ " ofp-to-graph: "+
"measurement ignored due to excess in "+
"threshold or premature iteration")
if deltaDeviceOfp > thresholdMin and\
deltaDeviceOfp < thresholdMax and i >= iterIgnore:
ofpToDeviceLatNodeIter[node][i] = deltaDeviceOfp
main.log.info("ONOS "+str(nodeNum)+ " ofp-to-device: "+
str(deltaDeviceOfp) + " ms")
else:
main.log.info("ONOS "+str(nodeNum)+ " ofp-to-device: "+
"measurement ignored due to excess in "+
"threshold or premature iteration")
# ********************
"""
jsonStr1 = main.ONOS1cli.topologyEventsMetrics()
jsonStr2 = ''
jsonStr3 = ''
jsonStr4 = ''
jsonStr5 = ''
jsonStr6 = ''
jsonStr7 = ''
jsonObj1 = json.loads(jsonStr1)
jsonObj2 = ''
jsonObj3 = ''
jsonObj4 = ''
jsonObj5 = ''
jsonObj6 = ''
jsonObj7 = ''
graphTimestamp1 = jsonObj1[graphTimestamp]['value']
deviceTimestamp1 = jsonObj1[deviceTimestamp]['value']
main.log.info(' GraphTimestamp: ' + str(graphTimestamp1))
main.log.info(' DeviceTimestamp: ' + str(deviceTimestamp1))
deltaDevice1 = int(deviceTimestamp1) - int(t0Tcp)
deltaGraph1 = int(graphTimestamp1) - int(t0Tcp)
deltaOfpGraph1 = int(graphTimestamp1) - int(t0Ofp)
deltaOfpDevice1 = int(deviceTimestamp1) - int(t0Ofp)
# Tshark timestamps
deltaTcpOfp1 = int(t0Ofp) - int(t0Tcp)
deltaRoleTcp1 = int(roleTimestamp) - int(t0Tcp)
deltaFeatureTcp1 = int(featureTimestamp) - int(t0Tcp)
deltaOfpTcp1 = int(t0Ofp) - int(t0Tcp)
if deltaTcpOfp1 > thresholdMin and\
deltaTcpOfp1 < thresholdMax and i >= iterIgnore:
tcpToOfpLatIter.append(deltaTcpOfp1)
main.log.info('ONOS1 iter' + str(i) +
' tcp-to-ofp: ' +
str(deltaTcpOfp1) + ' ms')
if deltaFeatureTcp1 > thresholdMin and\
deltaFeatureTcp1 < thresholdMax and i >= iterIgnore:
tcpToFeatureLatIter.append(deltaFeatureTcp1)
main.log.info('ONOS1 iter' + str(i) +
' tcp-to-feature-reply: ' +
str(deltaFeatureTcp1) + ' ms')
if deltaRoleTcp1 > thresholdMin and\
deltaRoleTcp1 < thresholdMax and i >= iterIgnore:
tcpToRoleLatIter.append(deltaRoleTcp1)
main.log.info('ONOS1 iter' + str(i) +
' tcp-to-role-request: ' +
str(deltaRoleTcp1) + ' ms')
if deltaGraph1 > thresholdMin and\
deltaGraph1 < thresholdMax and i >= iterIgnore:
endToEndLatNodeIter[0][i] = deltaGraph1
main.log.info('ONOS1 iter' + str(i) +
' end-to-end: ' +
str(deltaGraph1) + ' ms')
if deltaOfpGraph1 > thresholdMin and \
deltaOfpGraph1 < thresholdMax and i >= iterIgnore:
ofpToGraphLatNodeIter[0][i] = deltaOfpGraph1
main.log.info('ONOS1 iter' + str(i) +
' ofp-to-graph: ' +
str(deltaOfpGraph1) + ' ms')
if deltaOfpDevice1 > thresholdMin and\
deltaOfpDevice1 < thresholdMax and i >= iterIgnore:
ofpToDeviceLatNodeIter[0][i] = deltaOfpDevice1
main.log.info('ONOS1 iter' + str(i) +
' ofp-to-device: ' +
str(deltaOfpDevice1))
if clusterCount >= 3:
jsonStr2 = main.ONOS2cli.topologyEventsMetrics()
jsonStr3 = main.ONOS3cli.topologyEventsMetrics()
jsonObj2 = json.loads(jsonStr2)
jsonObj3 = json.loads(jsonStr3)
graphTimestamp2 = jsonObj2[graphTimestamp]['value']
graphTimestamp3 = jsonObj3[graphTimestamp]['value']
deviceTimestamp2 = jsonObj2[deviceTimestamp]['value']
deviceTimestamp3 = jsonObj3[deviceTimestamp]['value']
deltaDevice2 = int(deviceTimestamp2) - int(t0Tcp)
deltaDevice3 = int(deviceTimestamp3) - int(t0Tcp)
deltaGraph2 = int(graphTimestamp2) - int(t0Tcp)
deltaGraph3 = int(graphTimestamp3) - int(t0Tcp)
deltaOfpGraph2 = int(graphTimestamp2) - int(t0Ofp)
deltaOfpGraph3 = int(graphTimestamp3) - int(t0Ofp)
deltaOfpDevice2 = int(deviceTimestamp2) - int(t0Ofp)
deltaOfpDevice3 = int(deviceTimestamp3) - int(t0Ofp)
if deltaGraph2 > thresholdMin and\
deltaGraph2 < thresholdMax and i >= iterIgnore:
endToEndLatNodeIter[1][i] = deltaGraph2
main.log.info('ONOS2 iter' + str(i) +
' end-to-end: ' +
str(deltaGraph2) + ' ms')
if deltaOfpGraph2 > thresholdMin and\
deltaOfpGraph2 < thresholdMax and i >= iterIgnore:
ofpToGraphLatNodeIter[1][i] = deltaOfpGraph2
main.log.info('ONOS2 iter' + str(i) +
' ofp-to-graph: ' +
str(deltaOfpGraph2) + ' ms')
if deltaOfpDevice2 > thresholdMin and\
deltaOfpDevice2 < thresholdMax and i >= iterIgnore:
ofpToDeviceLatNodeIter[1][i] = deltaOfpDevice2
main.log.info('ONOS2 iter' + str(i) +
' ofp-to-device: ' +
str(deltaOfpDevice2)+ ' ms')
if deltaGraph3 > thresholdMin and\
deltaGraph3 < thresholdMax and i >= iterIgnore:
endToEndLatNodeIter[2][i] = deltaGraph3
main.log.info('ONOS3 iter' + str(i) +
' end-to-end: ' + str(deltaGraph3) + ' ms')
if deltaOfpGraph3 > thresholdMin and\
deltaOfpGraph3 < thresholdMax and i >= iterIgnore:
ofpToGraphLatNodeIter[2][i] = deltaOfpGraph3
main.log.info('ONOS3 iter' + str(i) +
' ofp-to-graph: ' +
str(deltaOfpGraph3) + ' ms')
if deltaOfpDevice3 > thresholdMin and\
deltaOfpDevice3 < thresholdMax and i >= iterIgnore:
ofpToDeviceLatNodeIter[2][i] = deltaOfpDevice3
main.log.info('ONOS3 iter' + str(i) +
' ofp-to-device: ' + str(deltaOfpDevice3))
if clusterCount >= 5:
jsonStr4 = main.ONOS4cli.topologyEventsMetrics()
jsonStr5 = main.ONOS5cli.topologyEventsMetrics()
jsonObj4 = json.loads(jsonStr4)
jsonObj5 = json.loads(jsonStr5)
graphTimestamp4 = jsonObj4[graphTimestamp]['value']
graphTimestamp5 = jsonObj5[graphTimestamp]['value']
deviceTimestamp4 = jsonObj4[deviceTimestamp]['value']
deviceTimestamp5 = jsonObj5[deviceTimestamp]['value']
deltaDevice4 = int(deviceTimestamp4) - int(t0Tcp)
deltaDevice5 = int(deviceTimestamp5) - int(t0Tcp)
deltaGraph4 = int(graphTimestamp4) - int(t0Tcp)
deltaGraph5 = int(graphTimestamp5) - int(t0Tcp)
deltaOfpGraph4 = int(graphTimestamp4) - int(t0Ofp)
deltaOfpGraph5 = int(graphTimestamp5) - int(t0Ofp)
deltaOfpDevice4 = int(deviceTimestamp4) - int(t0Ofp)
deltaOfpDevice5 = int(deviceTimestamp5) - int(t0Ofp)
if deltaGraph4 > thresholdMin and \
deltaGraph4 < thresholdMax and i >= iterIgnore:
endToEndLatNodeIter[3][i] = deltaGraph4
main.log.info('ONOS4 iter' + str(i) +
' end-to-end: ' + str(deltaGraph4) + ' ms')
if deltaOfpDevice4 > thresholdMin and \
deltaOfpDevice4 < thresholdMax and i >= iterIgnore:
ofpToDeviceLatNodeIter[3][i] = deltaOfpDevice4
main.log.info('ONOS4 iter' + str(i) +
' ofp-to-device: ' + str(deltaOfpDevice4))
if deltaOfpGraph4 > thresholdMin and \
deltaOfpGraph4 < thresholdMax and i >= iterIgnore:
ofpToGraphLatNodeIter[3][i] = deltaOfpGraph4
main.log.info('ONOS4 iter' + str(i) +
' ofp-to-graph: ' + str(deltaOfpGraph4) + ' ms')
if deltaGraph5 > thresholdMin and\
deltaGraph5 < thresholdMax and i >= iterIgnore:
endToEndLatNodeIter[4][i] = deltaGraph5
main.log.info('ONOS5 iter' + str(i) +
' end-to-end: ' + str(deltaGraph5) + ' ms')
if deltaOfpDevice5 > thresholdMin and\
deltaOfpDevice5 < thresholdMax and i >= iterIgnore:
ofpToDeviceLatNodeIter[4][i] = deltaOfpDevice5
main.log.info('ONOS5 iter' + str(i) +
' ofp-to-device: ' + str(deltaOfpDevice5))
if deltaOfpGraph5 > thresholdMin and\
deltaOfpGraph5 < thresholdMax and i >= iterIgnore:
ofpToGraphLatNodeIter[4][i] = deltaOfpGraph5
main.log.info('ONOS5 iter' + str(i) +
' ofp-to-graph: ' +
str(deltaOfpGraph5) + ' ms')
if clusterCount >= 7:
jsonStr6 = main.ONOS6cli.topologyEventsMetrics()
jsonStr7 = main.ONOS7cli.topologyEventsMetrics()
jsonObj6 = json.loads(jsonStr6)
jsonObj7 = json.loads(jsonStr7)
graphTimestamp6 = jsonObj6[graphTimestamp]['value']
graphTimestamp7 = jsonObj7[graphTimestamp]['value']
deviceTimestamp6 = jsonObj6[deviceTimestamp]['value']
deviceTimestamp7 = jsonObj7[deviceTimestamp]['value']
deltaDevice6 = int(deviceTimestamp6) - int(t0Tcp)
deltaDevice7 = int(deviceTimestamp7) - int(t0Tcp)
deltaGraph6 = int(graphTimestamp6) - int(t0Tcp)
deltaGraph7 = int(graphTimestamp7) - int(t0Tcp)
deltaOfpGraph6 = int(graphTimestamp6) - int(t0Ofp)
deltaOfpGraph7 = int(graphTimestamp7) - int(t0Ofp)
deltaOfpDevice6 = int(deviceTimestamp6) - int(t0Ofp)
deltaOfpDevice7 = int(deviceTimestamp7) - int(t0Ofp)
if deltaGraph6 > thresholdMin and \
deltaGraph6 < thresholdMax and i >= iterIgnore:
endToEndLatNodeIter[5][i] = deltaGraph6
main.log.info('ONOS6 iter' + str(i) +
' end-to-end: ' + str(deltaGraph6) + ' ms')
if deltaOfpDevice6 > thresholdMin and\
deltaOfpDevice6 < thresholdMax and i >= iterIgnore:
ofpToDeviceLatNodeIter[5][i] = deltaOfpDevice6
main.log.info('ONOS6 iter' + str(i) +
' ofp-to-device: ' + str(deltaOfpDevice6))
if deltaOfpGraph6 > thresholdMin and\
deltaOfpGraph6 < thresholdMax and i >= iterIgnore:
ofpToGraphLatNodeIter[5][i] = deltaOfpGraph6
main.log.info('ONOS6 iter' + str(i) +
' ofp-to-graph: ' +
str(deltaOfpGraph6) + ' ms')
if deltaGraph7 > thresholdMin and \
deltaGraph7 < thresholdMax and i >= iterIgnore:
endToEndLatNodeIter[6][i] = deltaGraph7
main.log.info('ONOS7 iter' + str(i) +
' end-to-end: ' +
str(deltaGraph7) + ' ms')
if deltaOfpDevice7 > thresholdMin and\
deltaOfpDevice7 < thresholdMax and i >= iterIgnore:
ofpToDeviceLatNodeIter[6][i] = deltaOfpDevice7
main.log.info('ONOS7 iter' + str(i) +
' ofp-to-device: ' +
str(deltaOfpDevice7))
if deltaOfpGraph7 > thresholdMin and \
deltaOfpGraph7 < thresholdMax and i >= iterIgnore:
ofpToGraphLatNodeIter[6][i] = deltaOfpGraph7
main.log.info('ONOS7 iter' + str(i) +
' ofp-to-graph: ' +
str(deltaOfpGraph7) + ' ms')
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'])
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 = []
ofpToGraphList = []
ofpToDeviceList = []
tcpToOfpList = []
tcpToFeatureList = []
tcpToRoleList = []
# LatNodeIter 2d arrays contain all iteration latency
# for each node of the current scale cluster size
for item in endToEndLatNodeIter[node]:
if item > 0.0:
endToEndList.append(item)
for item in ofpToGraphLatNodeIter[node]:
if item > 0.0:
ofpToGraphList.append(item)
for item in ofpToDeviceLatNodeIter[node]:
if item > 0.0:
ofpToDeviceList.append(item)
for item in tcpToOfpLatIter:
if item > 0.0:
tcpToOfpList.append(item)
for item in tcpToFeatureLatIter:
if item > 0.0:
tcpToFeatureList.append(item)
for item in tcpToRoleLatIter:
if item > 0.0:
tcpToRoleList.append(item)
endToEndAvg = round(numpy.mean(endToEndList), 2)
tcpToOfpAvg = round(numpy.mean(tcpToOfpList), 2)
tcpToFeatureAvg = round(numpy.mean(tcpToFeatureList), 2)
tcpToRoleAvg = round(numpy.mean(tcpToRoleList), 2)
ofpToGraphAvg = round(numpy.mean(ofpToGraphList), 2)
endToEndStd = round(numpy.std(endToEndList), 2)
ofpToGraphStd = round(numpy.std(ofpToGraphList), 2)
ofpToDeviceAvg = round(numpy.mean(ofpToDeviceList), 2)
ofpToDeviceStd = round(numpy.std(ofpToDeviceList), 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(endToEndStd) + ' ms')
main.log.report(' Tcp-to-role-reply : ' + str(tcpToOfpAvg) + ' ms')
main.log.report(' Tcp-to-feature-reply : ' + str(tcpToFeatureAvg) + ' ms')
main.log.report(' Tcp-to-role-request : ' + str(tcpToRoleAvg) + ' ms')
main.log.report(' Ofp-to-graph Avg: ' + str(ofpToGraphAvg) +
' ms' + ' Ofp-to-graph Std dev: ' +
str(ofpToGraphStd) + ' ms')
main.log.report(' Ofp-to-device Avg: ' + str(ofpToDeviceAvg) +
' ms' + ' Ofp-to-device Std dev: ' +
str(ofpToDeviceStd) + ' 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) ])