Merge branch 'devl/HA_refactor_threads' of https://github.com/OPENNETWORKINGLAB/ONLabTest into HA_merge
diff --git a/TestON/core/teston.py b/TestON/core/teston.py
index acbc0f1..edb763c 100644
--- a/TestON/core/teston.py
+++ b/TestON/core/teston.py
@@ -247,6 +247,7 @@
#print code[testCaseNumber][step]
self.stepCount = self.stepCount + 1
self.log.exception(e)
+ return main.FALSE
return main.TRUE
if cli.stop:
diff --git a/TestON/drivers/common/cli/onosclidriver.py b/TestON/drivers/common/cli/onosclidriver.py
index be5e425..7adc453 100644
--- a/TestON/drivers/common/cli/onosclidriver.py
+++ b/TestON/drivers/common/cli/onosclidriver.py
@@ -43,7 +43,7 @@
try:
for key in connectargs:
vars( self )[ key ] = connectargs[ key ]
- self.home = "~/ONOS"
+ self.home = "~/onos"
for key in self.options:
if key == "home":
self.home = self.options[ 'home' ]
@@ -160,12 +160,12 @@
# Expect the cellname in the ONOSCELL variable.
# Note that this variable name is subject to change
# and that this driver will have to change accordingly
- self.handle.expect( "ONOS_CELL" )
+ self.handle.expect(str(cellname))
handleBefore = self.handle.before
handleAfter = self.handle.after
# Get the rest of the handle
- self.handle.sendline( "" )
- self.handle.expect( "\$" )
+ self.handle.sendline("")
+ self.handle.expect("\$")
handleMore = self.handle.before
main.log.info( "Cell call returned: " + handleBefore +
@@ -447,14 +447,17 @@
def topology( self ):
"""
- Shows the current state of the topology
- by issuing command: 'onos> onos:topology'
+ Definition:
+ Returns the ouput of topology command.
+ Return:
+ topology = current ONOS topology
"""
+ import json
try:
# either onos:topology or 'topology' will work in CLI
- cmdStr = "onos:topology"
+ cmdStr = "topology -j"
handle = self.sendline( cmdStr )
- main.log.info( "onos:topology returned: " + str( handle ) )
+ main.log.info( "topology -j returned: " + str( handle ) )
return handle
except TypeError:
main.log.exception( self.name + ": Object not as expected" )
@@ -525,6 +528,31 @@
main.cleanup()
main.exit()
+ def deviceRemove( self, deviceId ):
+ """
+ Removes particular device from storage
+
+ TODO: refactor this function
+ """
+ try:
+ cmdStr = "device-remove "+str(deviceId)
+ handle = self.sendline( cmdStr )
+ return main.TRUE
+ except TypeError:
+ main.log.exception( self.name + ": Object not as expected" )
+ return None
+ except pexpect.EOF:
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
+ main.cleanup()
+ main.exit()
+ except Exception:
+ main.log.exception( self.name + ": Uncaught exception!" )
+ main.cleanup()
+ main.exit()
+
+
+
def devices( self, jsonFormat=True ):
"""
Lists all infrastructure devices or switches
@@ -1617,7 +1645,11 @@
else:
cmdStr = "topology-events-metrics"
handle = self.sendline( cmdStr )
- return handle
+ if handle:
+ return handle
+ else:
+ # Return empty json
+ return '{}'
except TypeError:
main.log.exception( self.name + ": Object not as expected" )
return None
diff --git a/TestON/drivers/common/cli/onosdriver.py b/TestON/drivers/common/cli/onosdriver.py
index 1c7d329..261bd03 100644
--- a/TestON/drivers/common/cli/onosdriver.py
+++ b/TestON/drivers/common/cli/onosdriver.py
@@ -42,7 +42,7 @@
try:
for key in connectargs:
vars( self )[ key ] = connectargs[ key ]
- self.home = "~/ONOS"
+ self.home = "~/onos"
for key in self.options:
if key == "home":
self.home = self.options[ 'home' ]
@@ -626,12 +626,12 @@
# Expect the cellname in the ONOSCELL variable.
# Note that this variable name is subject to change
# and that this driver will have to change accordingly
- self.handle.expect( "ONOS_CELL" )
+ self.handle.expect(str(cellname))
handleBefore = self.handle.before
handleAfter = self.handle.after
# Get the rest of the handle
- self.handle.sendline( "" )
- self.handle.expect( "\$" )
+ self.handle.sendline("")
+ self.handle.expect("\$")
handleMore = self.handle.before
main.log.info( "Cell call returned: " + handleBefore +
@@ -1046,18 +1046,18 @@
main.cleanup()
main.exit()
- def isup( self, node="" ):
+ def isup(self, node = "", timeout = 120):
"""
Run's onos-wait-for-start which only returns once ONOS is at run
- level 100( ready for use )
+ level 100(ready for use)
Returns: main.TRUE if ONOS is running and main.FALSE on timeout
"""
try:
- self.handle.sendline( "onos-wait-for-start " + node )
- self.handle.expect( "onos-wait-for-start" )
+ self.handle.sendline("onos-wait-for-start " + node )
+ self.handle.expect("onos-wait-for-start")
# NOTE: this timeout is arbitrary"
- i = self.handle.expect( [ "\$", pexpect.TIMEOUT ], timeout=120 )
+ i = self.handle.expect(["\$", pexpect.TIMEOUT], timeout)
if i == 0:
main.log.info( self.name + ": " + node + " is up" )
return main.TRUE
@@ -1142,39 +1142,16 @@
def getTopology( self, topologyOutput ):
"""
- parses the onos:topology output
- Returns: a topology dict populated by the key values found in
- the cli command.
+ Definition:
+ Loads a json topology output
+ Return:
+ topology = current ONOS topology
"""
+ import json
try:
- # call the cli to get the topology summary
- # cmdstr = "onos:topology"
- # cliResult = self.onosCli( ip, cmdstr )
- # print "cli_result = ", cliResult
-
- # Parse the output
- topology = {}
- # for line in cliResult.split( "\n" ):
- for line in topologyOutput.splitlines():
- if not line.startswith( "time=" ):
- continue
- # else
- # print line
- for var in line.split( "," ):
- # print "'"+var+"'"
- # print "'"+var.strip()+"'"
- key, value = var.strip().split( "=" )
- topology[ key ] = value
- # print "topology = ", topology
- # devices = topology.get( 'devices', False )
- # print "devices = ", devices
- # links = topology.get( 'links', False )
- # print "links = ", links
- # SCCs = topology.get( 'SCC(s)', False )
- # print "SCCs = ", SCCs
- # paths = topology.get( 'paths', False )
- # print "paths = ", paths
-
+ # either onos:topology or 'topology' will work in CLI
+ topology = json.loads(topologyOutput)
+ print topology
return topology
except pexpect.EOF:
main.log.error( self.name + ": EOF exception found" )
@@ -1216,8 +1193,8 @@
return main.ERROR
output = ""
# Is the number of switches is what we expected
- devices = topology.get( 'devices', False )
- links = topology.get( 'links', False )
+ devices = topology.get( 'deviceCount', False )
+ links = topology.get( 'linkCount', False )
if not devices or not links:
return main.ERROR
switchCheck = ( int( devices ) == int( numoswitch ) )
@@ -1507,8 +1484,6 @@
return main.TRUE
elif i == 1:
main.log.info( "ONOS is stopped" )
- return main.FALSE
- else:
main.log.error( "ONOS service failed to check the status" )
main.cleanup()
main.exit()
@@ -1674,3 +1649,173 @@
main.cleanup()
main.exit()
+ def createLinkGraphFile( self, benchIp, ONOSIpList, deviceCount):
+ '''
+ Create/formats the LinkGraph.cfg file based on arguments
+ -only creates a linear topology and connects islands
+ -evenly distributes devices
+ -must be called by ONOSbench
+
+ ONOSIpList - list of all of the node IPs to be used
+
+ deviceCount - number of switches to be assigned
+ '''
+ main.log.step("Creating link graph configuration file." )
+ linkGraphPath = self.home + "/tools/package/etc/linkGraph.cfg"
+ tempFile = "/tmp/linkGraph.cfg"
+
+ linkGraph = open(tempFile, 'w+')
+ linkGraph.write("# NullLinkProvider topology description (config file).\n")
+ linkGraph.write("# The NodeId is only added if the destination is another node's device.\n")
+ linkGraph.write("# Bugs: Comments cannot be appended to a line to be read.\n")
+
+ clusterCount = len(ONOSIpList)
+
+ if type(deviceCount) is int or type(deviceCount) is str:
+ deviceCount = int(deviceCount)
+ switchList = [0]*(clusterCount+1)
+ baselineSwitchCount = deviceCount/clusterCount
+
+ for node in range(1, clusterCount + 1):
+ switchList[node] = baselineSwitchCount
+
+ for node in range(1, (deviceCount%clusterCount)+1):
+ switchList[node] += 1
+
+ if type(deviceCount) is list:
+ main.log.info("Using provided device distribution")
+ switchList = [0]
+ for i in deviceCount:
+ switchList.append(int(i))
+
+ tempList = ['0']
+ tempList.extend(ONOSIpList)
+ ONOSIpList = tempList
+
+ myPort = 6
+ lastSwitch = 0
+ for node in range(1, clusterCount+1):
+ if switchList[node] == 0:
+ continue
+
+ linkGraph.write("graph " + ONOSIpList[node] + " {\n")
+
+ if node > 1:
+ #connect to last device on previous node
+ line = ("\t0:5 -> " + str(lastSwitch) + ":6:" + lastIp + "\n") #ONOSIpList[node-1]
+ linkGraph.write(line)
+
+ lastSwitch = 0
+ for switch in range (0, switchList[node]-1):
+ line = ""
+ line = ("\t" + str(switch) + ":" + str(myPort))
+ line += " -- "
+ line += (str(switch+1) + ":" + str(myPort-1) + "\n")
+ linkGraph.write(line)
+ lastSwitch = switch+1
+ lastIp = ONOSIpList[node]
+
+ #lastSwitch += 1
+ if node < (clusterCount):
+ #connect to first device on the next node
+ line = ("\t" + str(lastSwitch) + ":6 -> 0:5:" + ONOSIpList[node+1] + "\n")
+ linkGraph.write(line)
+
+ linkGraph.write("}\n")
+ linkGraph.close()
+
+ #SCP
+ os.system( "scp " + tempFile + " admin@" + benchIp + ":" + linkGraphPath)
+ main.log.info("linkGraph.cfg creation complete")
+
+ def createNullDevProviderFile( self, benchIp, ONOSIpList, deviceCount, numPorts=10):
+
+ '''
+ benchIp = Ip address of the test bench
+ ONOSIpList = list of Ip addresses of nodes switches will be devided amongst
+ deviceCount = number of switches to distribute
+ numPorts = number of ports per device, when not specified in file it defaults to 10, optional arg
+ '''
+
+ main.log.step("Creating null device provider configuration file." )
+ nullDevicePath = self.home + "/tools/package/etc/org.onosproject.provider.nil.device.impl.NullDeviceProvider.cfg"
+ tempFile = "/tmp/org.onosproject.provider.nil.device.impl.NullDeviceProvider.cfg"
+ configFile = open(tempFile, 'w+')
+ clusterCount = len(ONOSIpList)
+
+ if type(deviceCount) is int or type(deviceCount) is str:
+ main.log.info("Creating device distribution")
+ deviceCount = int(deviceCount)
+ switchList = [0]*(clusterCount+1)
+ baselineSwitchCount = deviceCount/clusterCount
+
+ for node in range(1, clusterCount + 1):
+ switchList[node] = baselineSwitchCount
+
+ for node in range(1, (deviceCount%clusterCount)+1):
+ switchList[node] += 1
+
+ if type(deviceCount) is list:
+ main.log.info("Using provided device distribution")
+ switchList = ['0']
+ switchList.extend(deviceCount)
+
+ ONOSIp = [0]
+ ONOSIp.extend(ONOSIpList)
+
+ devicesString = "devConfigs = "
+ for node in range(1, len(ONOSIp)):
+ devicesString += (ONOSIp[node] + ":" + str(switchList[node] ))
+ if node < clusterCount:
+ devicesString += (",")
+
+ configFile.write(devicesString + "\n")
+ if numPorts == 10:
+ configFile.write("#numPorts = 10")
+ else:
+ configFile.write("numPorts = " + str(numPorts))
+
+ configFile.close()
+ os.system( "scp " + tempFile + " admin@" + benchIp + ":" + nullDevicePath)
+
+ def createNullLinkProviderFile( self, benchIp, neighborIpList=0, eventRate=0, onNode=False):
+ '''
+ neighbor list is an optional list of neighbors to be written directly to the file
+ onNode - bool, if true, alternate file path will be used to scp, inteneded
+ for use on cell
+ '''
+
+ main.log.step("Creating Null Link Provider config file")
+ nullLinkPath = self.home + "/tools/package/etc/org.onosproject.provider.nil.link.impl.NullLinkProvider.cfg"
+ if onNode == True:
+ nullLinkPath = "/opt/onos/apache-karaf-3.0.2/etc/org.onosproject.provider.nil.link.impl.NullLinkProvider.cfg"
+ tempFile = "/tmp/org.onosproject.provider.nil.link.impl.NullLinkProvider.cfg"
+ configFile = open(tempFile, 'w+')
+
+ eventRate = int(eventRate)
+
+ if eventRate == 0:
+ configFile.write("#eventRate = \n")
+ else:
+ configFile.write("eventRate = " + str(eventRate) + "\n")
+
+ configFile.write("#cfgFile = /tmp/foo.cfg #If enabled, points to the full path to the topology file.\n")
+
+ if neighborIpList != 0:
+ configFile.write("neighbors = ")
+ for n in range (0, len(neighborIpList)):
+ configFile.write(neighborIpList[n])
+ if n < (len(neighborIpList) - 1):
+ configFile.write(",")
+ else:
+ configFile.write("#neighbors = ")
+
+ configFile.close()
+ if onNode == False:
+ os.system( "scp " + tempFile + " admin@" + benchIp + ":" + nullLinkPath)
+ if onNode == True:
+ os.system( "scp " + tempFile + " sdn@" + benchIp + ":" + nullLinkPath)
+
+
+
+
diff --git a/TestON/tests/IntentEventTP/IntentEventTP.params b/TestON/tests/IntentEventTP/IntentEventTP.params
new file mode 100644
index 0000000..d5dd65c
--- /dev/null
+++ b/TestON/tests/IntentEventTP/IntentEventTP.params
@@ -0,0 +1,66 @@
+<PARAMS>
+
+ <testcases>1,3,2,3,2,3,2,3</testcases>
+
+ <debugMode></debugMode> #nothing means false
+
+ <ENV>
+ <cellName>intentTP</cellName>
+ <cellFeatures>"webconsole,onos-core,onos-api,onos-cli,onos-null,onos-gui,onos-rest,onos-app-metrics,onos-app-metrics-intent,onos-app-metrics-topology"</cellFeatures>
+ </ENV>
+
+ <SCALE>2</SCALE>
+ <availableNodes>7</availableNodes>
+
+ <GIT>
+ <autopull>off</autopull>
+ <checkout>master</checkout>
+ </GIT>
+
+ <CTRL>
+ <USER>admin</USER>
+
+ <ip1>10.128.5.51</ip1>
+ <port1>6633</port1>
+
+ <ip2>10.128.5.52</ip2>
+ <port2>6633</port2>
+
+ <ip3>10.128.5.53</ip3>
+ <port3>6633</port3>
+
+ <ip4>10.128.5.54</ip4>
+ <port4>6633</port4>
+
+ <ip5>10.128.5.65</ip5>
+ <port5>6633</port5>
+
+ <ip6>10.128.5.66</ip6>
+ <port6>6633</port6>
+
+ <ip7>10.128.5.67</ip7>
+ <port7>6633</port7>
+ </CTRL>
+
+ <MN><ip1>10.128.5.55</ip1></MN>
+
+ <BENCH>
+ <user>admin</user>
+ <ip1>10.128.5.55</ip1>
+ </BENCH>
+
+ <TEST>
+ <loadFrom>1,0,0,0,0,0,0</loadFrom> #generate load on server, 1 = generator on
+ <numSwitches>35</numSwitches>
+ <skipCleanInstall>yes</skipCleanInstall>
+ <duration>60</duration>
+ <log_interval>5</log_interval>
+ </TEST>
+
+ <METRICS>
+ <intents_rate>intents-events-metrics|grep "Intent Installed Events"|cut -d ' ' -f7</intents_rate>
+ <intents_withdrawn>intents-events-metrics|grep "Intent Withdrawn Events"|cut -d ' ' -f7</intents_withdrawn>
+ <intents_failed>intents-events-metrics|grep "Intent Failed Events"|cut -d ' ' -f7</intents_failed>
+ </METRICS>
+
+</PARAMS>
diff --git a/TestON/tests/IntentEventTP/IntentEventTP.py b/TestON/tests/IntentEventTP/IntentEventTP.py
new file mode 100644
index 0000000..b1f0e91
--- /dev/null
+++ b/TestON/tests/IntentEventTP/IntentEventTP.py
@@ -0,0 +1,397 @@
+# ScaleOutTemplate --> IntentEventTP
+#
+# CASE1 starts number of nodes specified in param file
+#
+# cameron@onlab.us
+
+import sys
+import os
+import time
+
+
+class IntentEventTP:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE1( self, main ): #This is the initialization case
+ import os.path #this case will clean up all nodes
+ import time #but only node 1 is started in this case
+
+ global clusterCount #number of nodes running
+ global ONOSIp #list of ONOS IP addresses
+ clusterCount = 1
+ ONOSIp = [ 0 ]
+
+ #Load values from params file
+ checkoutBranch = main.params[ 'GIT' ][ 'checkout' ]
+ gitPull = main.params[ 'GIT' ][ 'autopull' ]
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ Features= main.params[ 'ENV' ][ 'cellFeatures' ]
+ BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
+ BENCHUser = main.params[ 'BENCH' ][ 'user' ]
+ maxNodes = int(main.params[ 'availableNodes' ])
+ MNip = main.params[ 'MN' ][ 'ip1' ]
+ skipMvn = main.params[ 'TEST' ][ 'skipCleanInstall' ]
+ numSwitches = main.params[ 'TEST' ][ 'numSwitches' ]
+
+ homeDir = os.path.expanduser('~')
+
+ main.ONOSbench.handle.sendline("export TERM=vt100")
+ dump = main.ONOSbench.handle.expect(":~")
+
+ #Populate ONOSIp with ips from params
+ for i in range(1, maxNodes + 1):
+ ipString = 'ip' + str(i)
+ ONOSIp.append(main.params[ 'CTRL' ][ ipString ])
+
+ #kill off all onos processes
+ main.log.step("Safety check, killing all ONOS processes")
+ main.log.step("before initiating enviornment setup")
+ for node in range(1, maxNodes + 1):
+ main.log.info("killing node " + str(node))
+ main.ONOSbench.onosDie(ONOSIp[node])
+
+ #construct the cell file
+ main.log.info("Creating cell file")
+ exec "a = main.ONOSbench.createCellFile"
+ cellIp = []
+ for node in range (1, clusterCount + 1):
+ cellIp.append(ONOSIp[node])
+ a(BENCHIp,cellName,MNip,str(Features), *cellIp)
+
+ main.step( "Set Cell" )
+ main.ONOSbench.setCell(cellName)
+
+ #Uninstall everywhere
+ main.log.step( "Cleaning Enviornment..." )
+ for i in range(1, maxNodes + 1):
+ main.log.info(" Uninstalling ONOS " + str(i) )
+ main.ONOSbench.onosUninstall( ONOSIp[i] )
+
+ #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" )
+
+ #mvn clean install, for debugging set param 'skipCleanInstall' to yes to speed up test
+ if skipMvn != "yes":
+ mvnResult = main.ONOSbench.cleanInstall()
+
+ #configure null device provider
+ switchList = [0,int(numSwitches),0,0,0,0,0,0]
+ devicesString = ""
+ for node in range(1, maxNodes + 1):
+ devicesString += (ONOSIp[node] + ":" + str(switchList[node] ))
+ if node < maxNodes:
+ devicesString += (",")
+
+ main.log.info("Configuring device provider: ONOS 1 with " + (numSwitches) + " switches")
+ localPath = "/onos/tools/package/etc/org.onosproject.provider.nil.device.impl.NullDeviceProvider.cfg"
+ filePath = homeDir + localPath
+ main.log.info(filePath)
+
+ configFile = open(filePath, 'w+')
+ configFile.write("devConfigs = " + devicesString + "\n")
+ configFile.write("#numPorts = 8")
+ configFile.close()
+ main.log.info("DevConfig = " + devicesString)
+ main.log.info("Device provider file written and closed")
+
+ ## configuring null link provider
+ main.log.info(" Configuring null provider to disable flicker" )
+ homeDir = os.path.expanduser('~')
+ main.log.info(homeDir)
+ localPath = "/onos/tools/package/etc/org.onosproject.provider.nil.link.impl.NullLinkProvider.cfg"
+ filePath = homeDir + localPath
+ main.log.info(filePath)
+
+ neighborsString = ""
+ for node in range(1, maxNodes + 1):
+ neighborsString += ONOSIp[node]
+ if node < maxNodes:
+ neighborsString += ","
+
+ configFile = open(filePath, 'w+')
+ configFile.write("#eventRate =\n")
+ configFile.write("#cfgFile = /tmp/foo.cfg #If enabled, points to the full path to the topology file.\n")
+ configFile.write("#neighbors = ")
+ configFile.close()
+ main.log.info("Configuration completed")
+
+ main.log.info("Writing link graph configuration file..." )
+ homeDir = os.path.expanduser('~')
+ localPath = "/onos/tools/package/etc/linkGraph.cfg"
+ filePath = homeDir + localPath
+ linkGraph = open(filePath, 'w+')
+ linkGraph.write("# NullLinkProvider topology description (config file).\n")
+ linkGraph.write("# The NodeId is only added if the destination is another node's device.\n")
+ linkGraph.write("# Bugs: Comments cannot be appended to a line to be read.\n")
+
+ myPort = 6
+ for node in range(1, clusterCount+1):
+ linkGraph.write("graph " + ONOSIp[node] + " {\n")
+ for switch in range (0, switchList[node]-1):
+ line = ""
+ line = ("\t" + str(switch) + ":" + str(myPort))
+ line += " -- "
+ line += (str(switch+1) + ":" + str(myPort-1) + "\n")
+ linkGraph.write(line)
+ linkGraph.write("}")
+ linkGraph.close()
+
+ main.step( "Creating ONOS package" )
+ packageResult = main.ONOSbench.onosPackage()
+
+ main.step( "Installing ONOS package" )
+ install1Result = main.ONOSbench.onosInstall( node=ONOSIp[1] )
+
+ main.step( "verify cells" )
+ verifyCellResult = main.ONOSbench.verifyCell()
+
+ main.step( "Checking if ONOS is up yet" )
+ for i in range( 2 ):
+ isup = main.ONOSbench.isup( ONOSIp[1] )
+ if isup:
+ break
+ if not isup:
+ main.log.report( "ONOS1 didn't start!" )
+
+ lastOutput = "--"
+ origin = time.time()
+ clockStarted = False
+ while True:
+ main.ONOSbench.handle.sendline("onos $OC1 summary")
+ main.ONOSbench.handle.expect(":~")
+ clusterCheck = ((main.ONOSbench.handle.before).splitlines())[3]
+ print("\nBefore: " + str(clusterCheck))
+ if "SCC(s)=1," in clusterCheck and ("devices=" + str(numSwitches)) in clusterCheck: #check for links and devices too
+ break
+ if clusterCheck != lastOutput:
+ sameOutput = False
+ elif clusterCheck == lastOutput:
+ if clockStarted == False:
+ start = time.time()
+ clockStarted = True
+ if time.time() > (start + 30):
+ main.log.error("TIMEOUT EXCEEDED: Clusters have not converged, continuing anyway...")
+ break
+ lastOutput = clusterCheck
+ time.sleep(5)
+
+
+
+ def CASE2( self, main ):
+ # This case increases the cluster size by whatever scale is
+ # Note: 'scale' is the size of the step
+ # if scaling is not a part of your test, simply run this case
+ # once after CASE1 to set up your enviornment for your desired
+ # cluster size. If scaling is a part of you test call this case each time
+ # you want to increase cluster size
+
+ ''
+ 'Increase number of nodes and initiate CLI'
+ ''
+ import time
+ import os.path
+ global clusterCount
+
+ Features= main.params[ 'ENV' ][ 'cellFeatures' ]
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ MNip = main.params[ 'MN' ][ 'ip1' ]
+ BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
+ numSwitches = int(main.params[ 'TEST' ][ 'numSwitches' ])
+ scale = int( main.params[ 'SCALE' ] )
+ maxNodes = int(main.params[ 'availableNodes' ])
+ clusterCount += scale
+ homeDir = os.path.expanduser('~')
+
+ #kill off all onos processes
+ main.log.step("Safety check, killing all ONOS processes")
+ main.log.step("before initiating enviornment setup")
+ for node in range(1, maxNodes + 1):
+ main.ONOSbench.onosDie(ONOSIp[node])
+
+ #Uninstall everywhere
+ main.log.step( "Cleaning Enviornment..." )
+ for i in range(1, maxNodes + 1):
+ main.log.info(" Uninstalling ONOS " + str(i) )
+ main.ONOSbench.onosUninstall( ONOSIp[i] )
+
+ #construct the cell file
+ main.log.info("Creating cell file")
+ exec "a = main.ONOSbench.createCellFile"
+ cellIp = []
+ for node in range (1, clusterCount + 1):
+ cellIp.append(ONOSIp[node])
+ a(BENCHIp,cellName,MNip,str(Features), *cellIp)
+
+ main.step( "Set Cell" )
+ main.ONOSbench.setCell(cellName)
+
+ baselineSwitchCount = numSwitches/clusterCount
+ switchList = [0,0,0,0,0,0,0,0]
+
+ for node in range(1, clusterCount + 1):
+ switchList[node] = baselineSwitchCount
+
+ for node in range(1, (numSwitches%clusterCount)+1):
+ switchList[node] += 1
+
+ devicesString = ""
+ for node in range(1, maxNodes + 1):
+ devicesString += (ONOSIp[node] + ":" + str(switchList[node] ))
+ if node < maxNodes:
+ devicesString += (",")
+
+ main.log.info("Configuring device provider")
+ localPath = "/onos/tools/package/etc/org.onosproject.provider.nil.device.impl.NullDeviceProvider.cfg"
+ filePath = homeDir + localPath
+ main.log.info(filePath)
+
+ configFile = open(filePath, 'w+')
+ configFile.write("devConfigs = " + devicesString +"\n")
+ configFile.write("# numPorts = 8")
+ configFile.close()
+ main.log.info("DevConfig = " + devicesString)
+ main.log.info("Device provider file written and closed")
+
+ main.log.info("Writing link graph configuration file..." )
+ homeDir = os.path.expanduser('~')
+ localPath = "/onos/tools/package/etc/linkGraph.cfg"
+ filePath = homeDir + localPath
+ linkGraph = open(filePath, 'w+')
+ linkGraph.write("# NullLinkProvider topology description (config file).\n")
+ linkGraph.write("# The NodeId is only added if the destination is another node's device.\n")
+ linkGraph.write("# Bugs: Comments cannot be appended to a line to be read.\n")
+
+ myPort = 6
+ for node in range(1, clusterCount+1):
+ linkGraph.write("graph " + ONOSIp[node] + " {\n")
+ for switch in range (0, switchList[node]-1):
+ line = ""
+ line = ("\t" + str(switch) + ":" + str(myPort))
+ line += " -- "
+ line += (str(switch+1) + ":" + str(myPort-1) + "\n")
+ linkGraph.write(line)
+ linkGraph.write("}\n")
+ linkGraph.close()
+
+ main.step( "Creating ONOS package, preparing to reinstall" )
+ packageResult = main.ONOSbench.onosPackage()
+
+ main.log.report( "Reinstalling on all nodes and increasing cluster size to " + str( clusterCount ) )
+ for node in range(1, clusterCount + 1):
+ main.log.info("Starting ONOS " + str(node) + " at IP: " + ONOSIp[node])
+ main.ONOSbench.onosInstall( ONOSIp[node])
+
+ for i in range( 2 ):
+ isup = main.ONOSbench.isup( ONOSIp[node] )
+ if isup:
+ main.log.info("ONOS " + str(node) + " is up\n")
+ break
+ if not isup:
+ main.log.report( "ONOS " + str(node) + " didn't start!" )
+
+ lastOutput = "--"
+ origin = time.time()
+ clockStarted = False
+ while True:
+ main.ONOSbench.handle.sendline("onos $OC1 summary")
+ main.ONOSbench.handle.expect(":~")
+ clusterCheck = ((main.ONOSbench.handle.before).splitlines())[3]
+ print("\nBefore: " + str(clusterCheck))
+ if "SCC(s)=1," in clusterCheck and ("nodes=" + str(clusterCount)) in clusterCheck and ("devices=" + str(numSwitches)) in clusterCheck:
+ break
+ if clusterCheck != lastOutput:
+ sameOutput = False
+ elif clusterCheck == lastOutput:
+ if clockStarted == False:
+ start = time.time()
+ clockStarted = True
+ if time.time() > (start + 60):
+ main.log.error("TIMEOUT EXCEEDED: Clusters have not converged, continuing anyway...")
+ break
+ lastOutput = clusterCheck
+ time.sleep(5)
+
+
+ def CASE3( self, main ):
+ import time
+ import json
+ import string
+ import csv
+
+ main.log.info("Cluster Count = " + str(clusterCount))
+
+ intentsRate = main.params['METRICS']['intents_rate']
+ intentsWithdrawn = main.params[ 'METRICS' ][ 'intents_withdrawn' ]
+ intentsFailed = main.params[ 'METRICS' ][ 'intents_failed' ]
+ testDuration = main.params[ 'TEST' ][ 'duration' ]
+ logInterval = main.params[ 'TEST' ][ 'log_interval' ]
+ debug = main.params[ 'debugMode' ]
+
+ metricList = [intentsRate, intentsWithdrawn, intentsFailed]
+
+ tempsleep =40
+ main.log.info("sleeping " + str(tempsleep))
+ time.sleep(tempsleep)
+
+ loadFrom = ['0']
+ loadFrom.extend((main.params[ 'TEST' ][ 'loadFrom' ]).split(","))
+
+ for node in range(1, clusterCount+1):
+ if loadFrom[node] == "1":
+ cmd = "onos $OC" + str(node) + " feature:install onos-app-intent-perf"
+ main.ONOSbench.handle.sendline(cmd)
+ main.ONOSbench.handle.expect(":~")
+ main.log.info("Load initiated on node " + str(node))
+
+ main.log.info( "Starting test loop for " + str(testDuration) + " seconds...\n" )
+ stop = time.time() + float( testDuration )
+
+ while time.time() < stop:
+ time.sleep( float( logInterval ) )
+ for node in range (1, clusterCount + 1):
+ myResults = ['0','0','0']
+ for metric in metricList:
+
+ onosEnv = "onos $OC" + str(node)
+ cmd = onosEnv + " " + metric
+ main.log.info("COMMAND: " + cmd)
+ main.ONOSbench.handle.sendline( cmd )
+ time.sleep(10)
+ main.ONOSbench.handle.expect(":~")
+ rawResult = main.ONOSbench.handle.before
+ rawResult = (rawResult.splitlines())
+
+ tempResult = "--"
+ for word in rawResult:
+ if debug: print("word: " + word)
+ if "m1" in str(word):
+ tempResult = word
+ break
+
+ if tempResult == "--":
+ main.log.error("WRONG pexepct.before data\n" + str(rawResult))
+ main.log.info("retrying command... ")
+ main.ONOSbench.handle.sendline(cmd)
+ main.ONOSbench.handle.expect(":~")
+ test = main.ONOSbench.handle.before
+ print ("\n\n" + str(test))
+
+ tempResult = round(float(tempResult.replace("m1=","")),1)
+ tempResult = str(tempResult) # easy way to clean up number/prep to log
+ resultIndex = metricList.index(metric)
+ myResults[resultIndex] = tempResult
+
+ main.log.info("\tNode " + str(node))
+ main.log.info("Installed\tWithdrawn\tFailed")
+ main.log.info(myResults[0] + "\t\t " + myResults[1] + "\t\t" + myResults[2] + "\n")
+
+
diff --git a/TestON/tests/IntentEventTP/IntentEventTP.topo b/TestON/tests/IntentEventTP/IntentEventTP.topo
new file mode 100644
index 0000000..30a1467
--- /dev/null
+++ b/TestON/tests/IntentEventTP/IntentEventTP.topo
@@ -0,0 +1,146 @@
+<TOPOLOGY>
+
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS><home>~/onos</home></COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1cli>
+
+ <ONOS2cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2cli>
+
+ <ONOS3cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS3cli>
+
+ <ONOS4cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4cli>
+
+ <ONOS5cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>6</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5cli>
+
+ <ONOS6cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>7</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6cli>
+
+ <ONOS7cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>8</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7cli>
+
+ <ONOS1>
+ <host>10.128.5.51</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>9</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.128.5.52</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>10</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <ONOS3>
+ <host>10.128.5.53</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>11</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS3>
+
+ <ONOS4>
+ <host>10.128.5.54</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>12</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4>
+
+
+ <ONOS5>
+ <host>10.128.5.65</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>13</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5>
+
+ <ONOS6>
+ <host>10.128.5.66</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>14</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6>
+
+ <ONOS7>
+ <host>10.128.5.67</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>15</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7>
+
+ </COMPONENT>
+
+</TOPOLOGY>
+
+
+
diff --git a/TestON/tests/IntentsLoad/__init__.py b/TestON/tests/IntentEventTP/__init__.py
similarity index 100%
rename from TestON/tests/IntentsLoad/__init__.py
rename to TestON/tests/IntentEventTP/__init__.py
diff --git a/TestON/tests/IntentPerfNextBM/IntentPerfNextBM.params b/TestON/tests/IntentPerfNextBM/IntentPerfNextBM.params
new file mode 100644
index 0000000..194a783
--- /dev/null
+++ b/TestON/tests/IntentPerfNextBM/IntentPerfNextBM.params
@@ -0,0 +1,66 @@
+<PARAMS>
+ <testcases>1,2,3,4,2,3,4,2,3,4,2,3</testcases>
+
+ <ENV>
+ <cellName>intent_perf_test</cellName>
+ </ENV>
+
+ <GIT>
+ #autoPull 'on' or 'off'
+ <autoPull>off</autoPull>
+ <checkout>master</checkout>
+ </GIT>
+
+ <CTRL>
+ <user>sdn</user>
+ <ip1>10.254.1.201</ip1>
+ <port1>6633</port1>
+ <ip2>10.254.1.202</ip2>
+ <port2>6633</port2>
+ <ip3>10.254.1.203</ip3>
+ <port3>6633</port3>
+ <ip4>10.254.1.204</ip4>
+ <ip5>10.254.1.205</ip5>
+ <ip6>10.254.1.206</ip6>
+ <ip7>10.254.1.207</ip7>
+ </CTRL>
+
+ <TSHARK>
+ <ofpPortStatus>OF 1.3 146</ofpPortStatus>
+ </TSHARK>
+
+ <MN>
+ <ip1>10.254.1.200</ip1>
+ <ip2>10.254.1.200</ip2>
+ </MN>
+
+ <BENCH>
+ <ip>10.254.1.200</ip>
+ </BENCH>
+
+ <TEST>
+ #Number of times to iterate each case
+ <numIter>8</numIter>
+ <numIgnore>2</numIgnore>
+ <numSwitch>8</numSwitch>
+ <batchThresholdMin>0</batchThresholdMin>
+ <batchThresholdMax>1000</batchThresholdMax>
+ <batchIntentSize>1</batchIntentSize>
+ <numMult>1</numMult>
+ #Interface to bring down for intent reroute case
+ <intfs>s3-eth2</intfs>
+ </TEST>
+
+ <DB>
+ <intentFilePath>
+ /home/admin/ONLabTest/TestON/tests/IntentPerfNextBM/intentLatencyResultDb.log
+ </intentFilePath>
+ </DB>
+
+ <JSON>
+ <submittedTime>intentSubmittedTimestamp</submittedTime>
+ <installedTime>intentInstalledTimestamp</installedTime>
+ <wdRequestTime>intentWithdrawRequestedTimestamp</wdRequestTime>
+ <withdrawnTime>intentWithdrawnTimestamp</withdrawnTime>
+ </JSON>
+</PARAMS>
diff --git a/TestON/tests/IntentPerfNextBM/IntentPerfNextBM.py b/TestON/tests/IntentPerfNextBM/IntentPerfNextBM.py
new file mode 100644
index 0000000..8f23b29
--- /dev/null
+++ b/TestON/tests/IntentPerfNextBM/IntentPerfNextBM.py
@@ -0,0 +1,735 @@
+# 2015.03.12 10:28:21 PDT
+#Embedded file name: ../tests/IntentPerfNextBM/IntentPerfNextBM.py
+
+
+class IntentPerfNextBM:
+
+ 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']
+ intentFilePath = main.params['DB']['intentFilePath']
+ ONOSIp = []
+
+ for i in range(1, 8):
+ ONOSIp.append(main.params['CTRL']['ip' + str(i)])
+ main.ONOSbench.onosUninstall(nodeIp=ONOSIp[i - 1])
+
+ MN1Ip = main.params['MN']['ip1']
+ BENCHIp = main.params['BENCH']['ip']
+ main.case('Setting up test environment')
+ main.step('Clearing previous DB log file')
+ fIntentLog = open(intentFilePath, 'w')
+ fIntentLog.write('')
+ fIntentLog.close()
+ main.step('Starting mininet topology')
+ main.Mininet1.startNet()
+ main.step('Creating cell file')
+ cellFileResult = main.TRUE
+ main.step('Applying cell file to environment')
+ cellApplyResult = main.ONOSbench.setCell(cellName)
+ verifyCellResult = main.ONOSbench.verifyCell()
+ main.step('Removing raft logs')
+ main.ONOSbench.onosRemoveRaftLogs()
+ main.step('Git checkout and pull ' + checkoutBranch)
+
+ if gitPull == 'on':
+ checkoutResult = main.ONOSbench.gitCheckout(checkoutBranch)
+ pullResult = main.ONOSbench.gitPull()
+ main.step('Using onos-build to compile ONOS')
+ buildResult = main.ONOSbench.onosBuild()
+ else:
+ checkoutResult = main.TRUE
+ pullResult = main.TRUE
+ buildResult = main.TRUE
+ main.log.info('Git pull skipped by configuration')
+
+ main.log.report('Commit information - ')
+ main.ONOSbench.getVersion(report=True)
+ main.step('Creating ONOS package')
+ packageResult = main.ONOSbench.onosPackage()
+ main.step('Installing ONOS package')
+ install1Result = main.ONOSbench.onosInstall(node=ONOSIp[0])
+ main.step('Set cell for ONOScli env')
+ main.ONOS1cli.setCell(cellName)
+ time.sleep(5)
+ main.step('Start onos cli')
+ cli1 = main.ONOS1cli.startOnosCli(ONOSIp[0])
+ utilities.assert_equals(expect=main.TRUE,
+ actual=cellFileResult and cellApplyResult and\
+ verifyCellResult and checkoutResult and\
+ pullResult and buildResult and install1Result,
+ onpass='ONOS started successfully',
+ onfail='Failed to start ONOS')
+
+ def CASE2(self, main):
+ """
+ Batch intent install
+
+ Supports scale-out scenarios and increasing
+ number of intents within each iteration
+ """
+ import time
+ 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']
+ assertion = main.TRUE
+ ONOSIpList = []
+
+ for i in range(1, 8):
+ ONOSIpList.append(main.params['CTRL']['ip' + str(i)])
+
+ ONOSUser = main.params['CTRL']['user']
+ defaultSwPort = main.params['CTRL']['port1']
+ batchIntentSize = int(main.params['TEST']['batchIntentSize'])
+ batchThreshMin = int(main.params['TEST']['batchThresholdMin'])
+ batchThreshMax = int(main.params['TEST']['batchThresholdMax'])
+ numIter = main.params['TEST']['numIter']
+ numIgnore = int(main.params['TEST']['numIgnore'])
+ numSwitch = int(main.params['TEST']['numSwitch'])
+ nThread = main.params['TEST']['numMult']
+ intentFilePath = main.params['DB']['intentFilePath']
+
+ if clusterCount == 1:
+ for i in range(1, numSwitch + 1):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS1Ip, port1=defaultSwPort)
+ if clusterCount == 3:
+ for i in range(1, 3):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS1Ip, port1=defaultSwPort)
+ for i in range(3, 6):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS2Ip, port1=defaultSwPort)
+ for i in range(6, 9):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS3Ip, port1=defaultSwPort)
+ if clusterCount == 5:
+ main.Mininet1.assignSwController(sw='1',
+ ip1=ONOS1Ip, port1=defaultSwPort)
+ main.Mininet1.assignSwController(sw='2',
+ ip1=ONOS2Ip, port1=defaultSwPort)
+ for i in range(3, 6):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS3Ip, port1=defaultSwPort)
+ main.Mininet1.assignSwController(sw='6',
+ ip1=ONOS4Ip, port1=defaultSwPort)
+ main.Mininet1.assignSwController(sw='7',
+ ip1=ONOS5Ip, port1=defaultSwPort)
+ main.Mininet1.assignSwController(sw='8',
+ ip1=ONOS5Ip, port1=defaultSwPort)
+ if clusterCount == 7:
+ for i in range(1, 9):
+ if i < 8:
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOSIpList[i - 1], port1=defaultSwPort)
+ elif i >= 8:
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOSIpList[6], port1=defaultSwPort)
+
+ time.sleep(20)
+
+ batchResultList = []
+ deviceIdList = []
+ batchInstallLat = []
+ batchWithdrawLat = []
+
+ main.log.report('Batch intent installation test of ' +
+ str(batchIntentSize) + ' intent(s)')
+ main.log.info('Getting list of available devices')
+
+ jsonStr = main.ONOS1cli.devices()
+ jsonObj = json.loads(jsonStr)
+ for device in jsonObj:
+ deviceIdList.append(device['id'])
+
+ sleepTime = 10
+ baseDir = '/tmp/'
+ for batch in range(0, 5):
+ maxInstallLat = []
+ maxWithdrawLat = []
+ maxSingleInstallLat = []
+ maxSingleWithdrawLat = []
+ for i in range(0, int(numIter)):
+ main.log.info('Pushing ' + str(
+ int(batchIntentSize) * int(nThread)) +
+ ' intents. Iteration ' + str(i))
+ saveDir = baseDir + 'batch_intent_1.txt'
+ main.ONOSbench.pushTestIntentsShell(deviceIdList[0] +
+ '/2', deviceIdList[7] + '/2', batchIntentSize,
+ saveDir, ONOSIpList[0], numMult=nThread)
+ time.sleep(sleepTime)
+ intent = ''
+ counter = 300
+ while len(intent) > 0 and counter > 0:
+ main.ONOS1cli.handle.sendline('intents | wc -l')
+ main.ONOS1cli.handle.expect('intents | wc -l')
+ main.ONOS1cli.handle.expect('onos>')
+ intentTemp = main.ONOS1cli.handle.before()
+ intent = main.ONOS1cli.intents()
+ intent = json.loads(intent)
+ counter = counter - 1
+ time.sleep(1)
+
+ time.sleep(5)
+ saveDir = baseDir + 'batch_intent_1.txt'
+ with open(saveDir) as fOnos:
+ lineCount = 0
+ for line in fOnos:
+ line_temp = ''
+ main.log.info('Line read: ' + str(line))
+ line_temp = line[1:]
+ line_temp = line_temp.split(': ')
+ if ' ' in str(line_temp):
+ result = line_temp[1].split(' ')[0]
+ else:
+ main.log.warn('Empty line read')
+ result = 0
+ if lineCount == 0:
+ if 'Failure' in str(line):
+ main.log.warn('Intent installation failed')
+ result = 'NA'
+ else:
+ main.log.info('Install result: ' + result)
+ batchInstallLat.append(int(result))
+ installResult = result
+ elif lineCount == 1:
+ if 'Failure' in str(line):
+ main.log.warn('Intent withdraw failed')
+ result = 'NA'
+ else:
+ main.log.info('Withdraw result: ' + result)
+ batchWithdrawLat.append(int(result))
+ withdrawResult = result
+ else:
+ main.log.warn('Invalid results')
+ installResult = 'NA'
+ withdrawResult = 'NA'
+ lineCount += 1
+
+ main.log.info('Batch install latency with' +
+ str(batchIntentSize) + 'intents: ' +
+ str(installResult) + ' ms')
+ main.log.info('Batch withdraw latency with' +
+ str(batchIntentSize) + 'intents: ' +
+ str(withdrawResult) + ' ms')
+ main.log.info('Single intent install latency with' +
+ str(batchIntentSize) + 'intents: ' +
+ str(float(installResult) / int(batchIntentSize))+' ms')
+ main.log.info('Single intent withdraw latency with' +
+ str(batchIntentSize) + 'intents: ' +
+ str(float(withdrawResult)/ int(batchIntentSize))+' ms')
+ if len(batchInstallLat) > 0 and int(i) > numIgnore:
+ maxInstallLat.append(max(batchInstallLat))
+ maxSingleInstallLat.append(
+ max(batchInstallLat) / int(batchIntentSize))
+ elif len(batchInstallLat) == 0:
+ sleepTime += 30
+ if len(batchWithdrawLat) > 0 and int(i) > numIgnore:
+ maxWithdrawLat.append(max(batchWithdrawLat))
+ maxSingleWithdrawLat.append(
+ max(batchWithdrawLat) / int(batchIntentSize))
+ batchInstallLat = []
+ batchWithdrawLat = []
+ time.sleep(5)
+
+ if maxInstallLat:
+ avgInstallLat = str(round(
+ numpy.average(maxInstallLat), 2))
+ stdInstallLat = str(round(
+ numpy.std(maxInstallLat), 2))
+ avgSingleInstallLat = str(round(
+ numpy.average(maxSingleInstallLat), 3))
+ stdSingleInstallLat = str(round(
+ numpy.std(maxSingleInstallLat), 3))
+ else:
+ avgInstallLat = 'NA'
+ stdInstallLat = 'NA'
+ main.log.report('Batch installation failed')
+ assertion = main.FALSE
+ if maxWithdrawLat:
+ avgWithdrawLat = str(round(
+ numpy.average(maxWithdrawLat), 2))
+ stdWithdrawLat = str(round(
+ numpy.std(maxWithdrawLat), 2))
+ avgSingleWithdrawLat = str(round(
+ numpy.average(maxSingleWithdrawLat), 3))
+ stdSingleWithdrawLat = str(round(
+ numpy.std(maxSingleWithdrawLat), 3))
+ else:
+ avgWithdrawLat = 'NA'
+ stdWithdrawLat = 'NA'
+ main.log.report('Batch withdraw failed')
+ assertion = main.FALSE
+ main.log.report('Avg of batch installation latency ' +
+ 'of size ' + str(batchIntentSize) + ': ' +
+ str(avgInstallLat) + ' ms')
+ main.log.report('Std Deviation of batch installation latency ' +
+ ': ' + str(round(numpy.std(maxInstallLat), 2)) + ' ms')
+ main.log.report('Avg of batch withdraw latency ' +
+ 'of size ' + str(batchIntentSize) + ': ' +
+ str(avgWithdrawLat) + ' ms')
+ main.log.report('Std Deviation of batch withdraw latency ' +
+ ': ' + str(round(numpy.std(maxWithdrawLat), 2)) + ' ms')
+ main.log.report('Avg of batch withdraw latency ' + 'of size ' +
+ str(batchIntentSize) + ': ' + str(avgWithdrawLat) + ' ms')
+ main.log.report('Std Deviation of batch withdraw latency ' +
+ ': ' + str(stdWithdrawLat) + ' ms')
+ main.log.report('Avg of single withdraw latency ' + 'of size ' +
+ str(batchIntentSize) + ': ' +
+ str(avgSingleWithdrawLat) + ' ms')
+ main.log.report('Std Deviation of single withdraw latency ' +
+ ': ' + str(stdSingleWithdrawLat) + ' ms')
+ dbCmd = "INSERT INTO intents_latency_tests VALUES('" +\
+ timeToPost + "','intents_latency_results'," +\
+ runNum + ',' + str(clusterCount) + ',' +\
+ str(batchIntentSize) + ',' + str(avgInstallLat) +\
+ ',' + str(stdInstallLat) + ',' + str(avgWithdrawLat) +\
+ ',' + str(stdWithdrawLat) + ');'
+
+ fResult = open(intentFilePath, 'a')
+ if dbCmd:
+ fResult.write(dbCmd + '\n')
+ fResult.close()
+ if batch == 0:
+ batchIntentSize = 10
+ elif batch == 1:
+ batchIntentSize = 100
+ elif batch == 2:
+ batchIntentSize = 1000
+ elif batch == 3:
+ batchIntentSize = 1500
+ if batch < 4:
+ main.log.report('Increasing batch intent size to ' +
+ str(batchIntentSize))
+
+ utilities.assert_equals(expect=main.TRUE, actual=assertion,
+ onpass='Batch intent install/withdraw test successful',
+ onfail='Batch intent install/withdraw test failed')
+
+ def CASE3(self, main):
+ """
+ Batch intent reroute latency
+ """
+ import time
+ 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']
+
+ ONOSIpList = []
+ for i in range(1, 8):
+ ONOSIpList.append(main.params['CTRL']['ip' + str(i)])
+
+ ONOSUser = main.params['CTRL']['user']
+ defaultSwPort = main.params['CTRL']['port1']
+ batchIntentSize = main.params['TEST']['batchIntentSize']
+ thresholdMin = int(main.params['TEST']['batchThresholdMin'])
+ thresholdMax = int(main.params['TEST']['batchThresholdMax'])
+
+ intfs = main.params['TEST']['intfs']
+ installTime = main.params['JSON']['installedTime']
+ numIter = main.params['TEST']['numIter']
+ numIgnore = int(main.params['TEST']['numIgnore'])
+ numSwitch = int(main.params['TEST']['numSwitch'])
+ nThread = main.params['TEST']['numMult']
+
+ tsharkPortStatus = main.params[ 'TSHARK' ][ 'ofpPortStatus' ]
+ tsharkPortDown = '/tmp/tshark_port_down_reroute.txt'
+
+ if clusterCount == 1:
+ for i in range(1, numSwitch + 1):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS1Ip, port1=defaultSwPort)
+ if clusterCount == 3:
+ for i in range(1, 3):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS1Ip, port1=defaultSwPort)
+ for i in range(3, 6):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS2Ip, port1=defaultSwPort)
+ for i in range(6, 9):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS3Ip, port1=defaultSwPort)
+ if clusterCount == 5:
+ main.Mininet1.assignSwController(sw='1',
+ ip1=ONOS1Ip, port1=defaultSwPort)
+ main.Mininet1.assignSwController(sw='2',
+ ip1=ONOS2Ip, port1=defaultSwPort)
+ for i in range(3, 6):
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOS3Ip, port1=defaultSwPort)
+ main.Mininet1.assignSwController(sw='6',
+ ip1=ONOS4Ip, port1=defaultSwPort)
+ main.Mininet1.assignSwController(sw='7',
+ ip1=ONOS5Ip, port1=defaultSwPort)
+ main.Mininet1.assignSwController(sw='8',
+ ip1=ONOS5Ip, port1=defaultSwPort)
+ if clusterCount == 7:
+ for i in range(1, 9):
+ if i < 8:
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOSIpList[i - 1], port1=defaultSwPort)
+ elif i >= 8:
+ main.Mininet1.assignSwController(sw=str(i),
+ ip1=ONOSIpList[6], port1=defaultSwPort)
+
+ main.log.report('Batch intent reroute test ')
+
+ batchIntentRerouteAvgSystem = numpy.zeros((
+ clusterCount, int(numIter)))
+ batchIntentRerouteStdSystem = numpy.zeros((
+ clusterCount, int(numIter)))
+ batchIntentRerouteAvgPort = numpy.zeros((
+ clusterCount, int(numIter)))
+ batchIntentRerouteStdSystem = numpy.zeros((
+ clusterCount, int(numIter)))
+
+ time.sleep(10)
+
+ main.log.info('Getting list of available devices')
+
+ deviceIdList = []
+ jsonStr = main.ONOS1cli.devices()
+ jsonObj = json.loads(jsonStr)
+ for device in jsonObj:
+ deviceIdList.append(device['id'])
+ if not jsonObj:
+ main.log.warn('No devices have been discovered')
+ assertion = main.FALSE
+
+ sleepTime = 10
+
+ baseDir = '/tmp/'
+ for batch in range(0, 5):
+ maxRerouteLatSystem = []
+ maxRerouteLatPort = []
+ for i in range(0, int(numIter)):
+ rerouteLatSystem = []
+ rerouteLatPort = []
+ main.log.info('Pushing ' + str(
+ int(batchIntentSize) * int(nThread)) +
+ ' intents. Iteration ' + str(i))
+ main.ONOSbench.pushTestIntentsShell(
+ deviceIdList[0] + '/2', deviceIdList[7] +
+ '/2', batchIntentSize, '/tmp/batch_install.txt',
+ ONOSIpList[0], numMult='1', report=False,
+ options='-i')
+
+ time.sleep(10)
+
+ main.ONOS1.tsharkGrep(tsharkPortStatus, tsharkPortDown)
+ main.log.info('Disabling interface ' + intfs)
+ main.Mininet1.handle.sendline(
+ 'sh ifconfig ' + intfs + ' down')
+ t0System = time.time() * 1000
+
+ time.sleep(3)
+
+ main.ONOS1.tsharkStop()
+
+ time.sleep(2)
+
+ os.system('scp ' + ONOSUser + '@' + ONOSIpList[0] +
+ ':' + tsharkPortDown + ' /tmp/')
+ time.sleep(5)
+
+ 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(fLine))
+ fPortDown.close()
+
+ intentsJsonStr1 = main.ONOS1cli.intentsEventsMetrics()
+ intentsJsonObj1 = json.loads(intentsJsonStr1)
+ intentInstall1 = intentsJsonObj1[installTime]['value']
+ intentRerouteLat1 = int(intentInstall1) - int(t0System)
+ intentRerouteLatPort1 =\
+ int(intentInstall1) - int(timestampBeginPtDown)
+
+ if intentRerouteLat1 > thresholdMin and \
+ intentRerouteLat1 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatSystem.append(intentRerouteLat1)
+ main.log.info('ONOS1 Intent Reroute Lat ' +
+ ' size: ' + str(batchIntentSize) +
+ ' system-to-install: ' +
+ str(intentRerouteLat1) + ' ms')
+ if intentRerouteLatPort1 > thresholdMin and\
+ intentRerouteLatPort1 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatPort.append(intentRerouteLatPort1)
+
+ main.log.info('ONOS1 Intent Reroute Lat ' +
+ ' size: ' + str(batchIntentSize) +
+ ' system-to-install: ' +
+ str(intentRerouteLatPort1) + ' ms')
+
+ if clusterCount == 3:
+ intentsJsonStr2 = main.ONOS2cli.intentsEventsMetrics()
+ intentsJsonStr3 = main.ONOS3cli.intentsEventsMetrics()
+ intentsJsonObj2 = json.loads(intentsJsonStr2)
+ intentsJsonObj3 = json.loads(intentsJsonStr3)
+ intentInstall2 = intentsJsonObj2[installTime]['value']
+ intentInstall3 = intentsJsonObj3[installTime]['value']
+ intentRerouteLat2 = int(intentInstall2) - int(t0System)
+ intentRerouteLat3 = int(intentInstall3) - int(t0System)
+ intentRerouteLatPort2 = int(intentInstall2) - int(timestampBeginPtDown)
+ intentRerouteLatPort3 = int(intentInstall3) - int(timestampBeginPtDown)
+
+ if intentRerouteLat2 > thresholdMin and\
+ intentRerouteLat2 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatSystem.append(intentRerouteLat2)
+ main.log.info('ONOS2 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' system-to-install: ' + str(intentRerouteLat2) + ' ms')
+ if intentRerouteLat3 > thresholdMin and\
+ intentRerouteLat3 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatSystem.append(intentRerouteLat3)
+ main.log.info('ONOS3 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' system-to-install: ' + str(intentRerouteLat3) +
+ ' ms')
+ if intentRerouteLatPort2 > thresholdMin and\
+ intentRerouteLatPort2 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatPort.append(intentRerouteLatPort2)
+ main.log.info('ONOS2 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' port-to-install: ' +
+ str(intentRerouteLatPort2) + ' ms')
+ if intentRerouteLatPort3 > thresholdMin and\
+ intentRerouteLatPort3 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatPort.append(intentRerouteLatPort3)
+ main.log.info('ONOS3 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' port-to-install: ' +
+ str(intentRerouteLatPort2) + ' ms')
+
+ if clusterCount == 5:
+ intentsJsonStr4 = main.ONOS4cli.intentsEventsMetrics()
+ intentsJsonStr5 = main.ONOS5cli.intentsEventsMetrics()
+ intentsJsonObj4 = json.loads(intentsJsonStr4)
+ intentsJsonObj5 = json.loads(intentsJsonStr5)
+ intentInstall4 = intentsJsonObj4[installTime]['value']
+ intentInstall5 = intentsJsonObj5[installTime]['value']
+ intentRerouteLat4 = int(intentInstall4) - int(t0System)
+ intentRerouteLat5 = int(intentInstall5) - int(t0System)
+ intentRerouteLatPort4 =\
+ int(intentInstall4) - int(timestampBeginPtDown)
+ intentRerouteLatPort5 =\
+ int(intentInstall5) - int(timestampBeginPtDown)
+ if intentRerouteLat4 > thresholdMin and\
+ intentRerouteLat4 < thresholdMax and \
+ i > numIgnore:
+ rerouteLatSystem.append(intentRerouteLat4)
+ main.log.info('ONOS4 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' system-to-install: ' + str(intentRerouteLat4) +
+ ' ms')
+ if intentRerouteLat5 > thresholdMin and\
+ intentRerouteLat5 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatSystem.append(intentRerouteLat5)
+ main.log.info('ONOS5 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' system-to-install: ' +
+ str(intentRerouteLat5) + ' ms')
+ if intentRerouteLatPort4 > thresholdMin and\
+ intentRerouteLatPort4 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatPort.append(intentRerouteLatPort4)
+ main.log.info('ONOS4 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' port-to-install: ' +
+ str(intentRerouteLatPort4) + ' ms')
+ if intentRerouteLatPort5 > thresholdMin and\
+ intentRerouteLatPort5 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatPort.append(intentRerouteLatPort5)
+ main.log.info('ONOS5 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' port-to-install: ' +
+ str(intentRerouteLatPort5) + ' ms')
+
+ if clusterCount == 7:
+ intentsJsonStr6 = main.ONOS6cli.intentsEventsMetrics()
+ intentsJsonStr7 = main.ONOS7cli.intentsEventsMetrics()
+ intentsJsonObj6 = json.loads(intentsJsonStr6)
+ intentsJsonObj7 = json.loads(intentsJsonStr7)
+ intentInstall6 = intentsJsonObj6[installTime]['value']
+ intentInstall7 = intentsJsonObj7[installTime]['value']
+ intentRerouteLat6 = int(intentInstall6) - int(t0System)
+ intentRerouteLat7 = int(intentInstall7) - int(t0System)
+ intentRerouteLatPort4 =\
+ int(intentInstall4) - int(timestampBeginPtDown)
+ intentRerouteLatPort5 =\
+ int(intentInstall5) - int(timestampBeginPtDown)
+ if intentRerouteLat6 > thresholdMin and\
+ intentRerouteLat6 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatSystem.append(intentRerouteLat6)
+ main.log.info('ONOS6 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' system-to-install: ' +
+ str(intentRerouteLat6) + ' ms')
+ if intentRerouteLat7 > thresholdMin and\
+ intentRerouteLat7 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatSystem.append(intentRerouteLat7)
+ main.log.info('ONOS7 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' system-to-install: ' +
+ str(intentRerouteLat7) + ' ms')
+ if intentRerouteLatPort6 > thresholdMin and\
+ intentRerouteLatPort6 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatPort.append(intentRerouteLatPort6)
+ main.log.info('ONOS6 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' port-to-install: ' +
+ str(intentRerouteLatPort6) + ' ms')
+ if intentRerouteLatPort7 > thresholdMin and\
+ intentRerouteLatPort7 < thresholdMax and\
+ i > numIgnore:
+ rerouteLatPort.append(intentRerouteLatPort7)
+ main.log.info('ONOS7 Intent Reroute Lat' +
+ ' size: ' + str(batchIntentSize) +
+ ' port-to-install: ' +
+ str(intentRerouteLatPort7) + ' ms')
+
+ time.sleep(5)
+
+ main.log.info('System: ' + str(rerouteLatSystem))
+ main.log.info('Port: ' + str(rerouteLatPort))
+ if rerouteLatSystem:
+ maxRerouteLatSystem = max(rerouteLatSystem)
+ main.log.info('Max system: ' + str(maxRerouteLatSystem))
+ if rerouteLatPort:
+ maxRerouteLatPort = max(rerouteLatPort)
+ main.log.info('Max port: ' + str(maxRerouteLatPort))
+
+ # Bring port back up for next iteration
+ main.Mininet1.handle.sendline('sh ifconfig ' + intfs + ' up')
+ time.sleep(5)
+
+ # Use 'withdraw' option to withdraw batch intents
+ main.ONOSbench.pushTestIntentsShell(
+ deviceIdList[0] + '/2', deviceIdList[7] + '/2',
+ batchIntentSize, '/tmp/batch_install.txt',
+ ONOSIpList[0], numMult='1', report=False, options='-w')
+ main.log.info('Intents removed and port back up')
+
+ # NOTE: End iteration loop
+ if batch == 1:
+ batchIntentSize = 10
+ elif batch == 2:
+ batchIntentSize = 100
+ elif batch == 3:
+ batchIntentSize = 500
+ elif batch == 4:
+ batchIntentSize = 1000
+ main.log.info('Batch intent size increased to ' + str(batchIntentSize))
+
+ def CASE4(self, main):
+ """
+ Increase number of nodes and initiate CLI
+ """
+ global clusterCount
+ import time
+ import json
+
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ features = main.params[ 'ENV' ][ 'cellFeatures' ]
+ benchIp = main.params[ 'BENCH' ][ 'ip' ]
+ mininetIp = main.params[ 'TEST' ][ 'MN' ]
+
+ clusterCount += 2
+ main.log.report('Increasing cluster size to ' + str(clusterCount))
+
+ ONOSIp = []
+ for i in range( 1, 8 ):
+ ONOSIp.append( main.params[ 'CTRL' ][ 'ip'+str(i) ]
+
+ main.step( "Cleaning environment" )
+ for i in range( 1, 8 ):
+ main.ONOSbench.onosDie( ONOSIp[i] )
+ main.log.info( "Uninstalling ONOS "+str(i) )
+ main.ONOSbench.onosUninstall( ONOSIp[i] )
+
+ main.step( "Creating new cell file" )
+ cellIp = []
+ for node in range( 1, clusterCount + 1 )
+ cellIp.append( ONOSIp[node] )
+ 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 ):
+ time.sleep(10)
+ main.log.info( "Starting ONOS "+str(node) +
+ " at IP: "+ONOSIp[node] )
+ main.ONOSbench.onosInstall( ONOSIp[node] )
+ exec "a = main.ONOS%scli.startOnosCli" %str(node)
+ a( ONOSIp[node] )
+
+ for node in range( 1, clusterCount + 1 ):
+ for i in range( 2 ):
+ isup = main.ONOSbench.isup( ONOSIp[node] )
+ if isup:
+ main.log.info( "ONOS "+str(node) + " is up\n")
+ assertion = main.TRUE
+ break
+ if not isup:
+ main.log.info( "ONOS" + str(node) + " did not start")
+
+ utilities.assert_equals(expect=main.TRUE, actual=assertion,
+ onpass='Scale out to ' + str(clusterCount) + ' nodes successful',
+ onfail='Scale out to ' + str(clusterCount) + ' nodes failed')
+
diff --git a/TestON/tests/IntentPerfNextBM/IntentPerfNextBM.topo b/TestON/tests/IntentPerfNextBM/IntentPerfNextBM.topo
new file mode 100644
index 0000000..197acfa
--- /dev/null
+++ b/TestON/tests/IntentPerfNextBM/IntentPerfNextBM.topo
@@ -0,0 +1,109 @@
+<TOPOLOGY>
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1cli>
+
+ <ONOS2cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2cli>
+
+ <ONOS3cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS3cli>
+
+ <ONOS4cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4cli>
+
+ <ONOS5cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>6</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5cli>
+
+ <ONOS6cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>7</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6cli>
+
+ <ONOS7cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>8</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7cli>
+
+ <ONOS1>
+ <host>10.254.1.201</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>9</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <Mininet1>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>MininetCliDriver</type>
+ <connect_order>10</connect_order>
+ <COMPONENTS>
+ <arg1> --custom topo-intent-8sw.py </arg1>
+ <arg2> --arp --mac --topo mytopo </arg2>
+ <arg3> </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet1>
+
+ <Mininet2>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>11</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </Mininet2>
+
+ </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/IntentsLoad/IntentsLoad.params b/TestON/tests/IntentsLoad/IntentsLoad.params
deleted file mode 100644
index b60621c..0000000
--- a/TestON/tests/IntentsLoad/IntentsLoad.params
+++ /dev/null
@@ -1,49 +0,0 @@
-<PARAMS>
-
- <testcases>1,2,4</testcases>
-
- <ENV>
- <cellName>cam_cells</cellName>
- </ENV>
-
- <SCALE>1</SCALE>
-
- <GIT>
- <autopull>off</autopull>
- <checkout>master</checkout>
- </GIT>
-
- <CTRL>
- <USER>admin</USER>
- <ip1>10.128.5.51</ip1>
- <port1>6633</port1>
- <ip2>10.128.5.52</ip2>
- <port2>6633</port2>
- <ip3>10.128.5.53</ip3>
- <port3>6633</port3>
- </CTRL>
-
- <MN>
- <ip1>10.128.5.59</ip1>
- <ip2>10.128.5.59</ip2>
- </MN>
-
- <BENCH>
- <user>admin</user>
- <ip1>10.128.5.55</ip1>
- </BENCH>
-
- <TEST>
- <loadstart>curl --fail http://localhost:8181/onos/demo/intents/setup -H "Content-Type:application/json" -d '{"type" : "random"}'</loadstart>
- <loadstop>curl --fail http://localhost:8181/onos/demo/intents/teardown</loadstop>
- <arping>py [h.cmd("arping -c 1 -w 1 10.0.0.225") for h in net.hosts]</arping>
- <metric1>intents-events-metrics|grep "Intent Installed Events"</metric1>
- <duration>90</duration>
- <log_interval>5</log_interval>
- </TEST>
-
- <JSON>
- <intents_rate>intentInstalledRate</intents_rate>
- </JSON>
-
-</PARAMS>
diff --git a/TestON/tests/IntentsLoad/IntentsLoad.py b/TestON/tests/IntentsLoad/IntentsLoad.py
deleted file mode 100644
index f13e60d..0000000
--- a/TestON/tests/IntentsLoad/IntentsLoad.py
+++ /dev/null
@@ -1,263 +0,0 @@
-# ScaleOutTemplate --> IntentsLoad
-#
-# CASE1 starts number of nodes specified in param file
-#
-# cameron@onlab.us
-
-import sys
-import os
-
-
-class IntentsLoad:
- def __init__(self):
- self.default = ''
-
- def CASE1(self, main):
-
- global cluster_count
- cluster_count = 1
-
- checkout_branch = main.params['GIT']['checkout']
- git_pull = main.params['GIT']['autopull']
- cell_name = main.params['ENV']['cellName']
- BENCH_ip = main.params['BENCH']['ip1']
- BENCH_user = main.params['BENCH']['user']
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
- MN1_ip = main.params['MN']['ip1']
-
- main.log.step("Cleaning Enviornment...")
- main.ONOSbench.onos_uninstall(ONOS1_ip)
- main.ONOSbench.onos_uninstall(ONOS2_ip)
- main.ONOSbench.onos_uninstall(ONOS3_ip)
-
- main.step("Git checkout and pull "+checkout_branch)
- if git_pull == 'on':
- checkout_result = main.ONOSbench.git_checkout(checkout_branch)
- pull_result = main.ONOSbench.git_pull()
-
- else:
- checkout_result = main.TRUE
- pull_result = main.TRUE
- main.log.info("Skipped git checkout and pull")
-
- #mvn_result = main.ONOSbench.clean_install()
-
- main.step("Set cell for ONOS cli env")
- main.ONOS1cli.set_cell(cell_name)
- main.ONOS2cli.set_cell(cell_name)
- main.ONOS3cli.set_cell(cell_name)
-
- main.step("Creating ONOS package")
- package_result = main.ONOSbench.onos_package() #no file or directory
-
- main.step("Installing ONOS package")
- install1_result = main.ONOSbench.onos_install(node=ONOS1_ip)
-
- cell_name = main.params['ENV']['cellName']
- main.step("Applying cell file to environment")
- cell_apply_result = main.ONOSbench.set_cell(cell_name)
- main.step("verify cells")
- verify_cell_result = main.ONOSbench.verify_cell()
-
- main.step("Set cell for ONOS cli env")
- main.ONOS1cli.set_cell(cell_name)
-
- cli1 = main.ONOS1cli.start_onos_cli(ONOS1_ip)
-
- def CASE2(self, main):
-
- '''
- Increase number of nodes and initiate CLI
- '''
- import time
-
- global cluster_count
-
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
- #ONOS4_ip = main.params['CTRL']['ip4']
- #ONOS5_ip = main.params['CTRL']['ip5']
- #ONOS6_ip = main.params['CTRL']['ip6']
- #ONOS7_ip = main.params['CTRL']['ip7']
- cell_name = main.params['ENV']['cellName']
- scale = int(main.params['SCALE'])
-
-
- #Cluster size increased everytime the case is defined
- cluster_count += scale
-
- main.log.report("Increasing cluster size to "+
- str(cluster_count))
- install_result = main.FALSE
-
- if scale == 2:
- if cluster_count == 3:
- main.log.info("Installing nodes 2 and 3")
- install2_result = main.ONOSbench.onos_install(node=ONOS2_ip)
- install3_result = main.ONOSbench.onos_install(node=ONOS3_ip)
- cli2 = main.ONOS2cli.start_onos_cli(ONOS2_ip)
- cli3 = main.ONOS3cli.start_onos_cli(ONOS3_ip)
- '''
- elif cluster_count == 5:
-
- main.log.info("Installing nodes 4 and 5")
- node4_result = main.ONOSbench.onos_install(node=ONOS4_ip)
- node5_result = main.ONOSbench.onos_install(node=ONOS5_ip)
- install_result = node4_result and node5_result
- time.sleep(5)
-
- main.ONOS4cli.start_onos_cli(ONOS4_ip)
- main.ONOS5cli.start_onos_cli(ONOS5_ip)
-
- elif cluster_count == 7:
-
- main.log.info("Installing nodes 4 and 5")
- node6_result = main.ONOSbench.onos_install(node=ONOS6_ip)
- node7_result = main.ONOSbench.onos_install(node=ONOS7_ip)
- install_result = node6_result and node7_result
- time.sleep(5)
-
- main.ONOS6cli.start_onos_cli(ONOS6_ip)
- main.ONOS7cli.start_onos_cli(ONOS7_ip)
- '''
- if scale == 1:
- if cluster_count == 2:
- main.log.info("Installing node 2")
- install2_result = main.ONOSbench.onos_install(node=ONOS2_ip)
- cli2 = main.ONOS2cli.start_onos_cli(ONOS2_ip)
-
- if cluster_count == 3:
- main.log.info("Installing node 3")
- install3_result = main.ONOSbench.onos_install(node=ONOS3_ip)
- cli3 = main.ONOS3cli.start_onos_cli(ONOS3_ip)
-
-
-
- def CASE3(self,main):
- import time
- import json
- import string
-
- intents_rate = main.params['JSON']['intents_rate']
-
- default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
-
- main.Mininet1.assign_sw_controller(sw="1", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="2", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="3", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="4", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="5", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="6", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="7", ip1=ONOS1_ip, port1=default_sw_port )
-
- mn_arp = main.params['TEST']['arping']
- main.Mininet1.handle.sendline(mn_arp)
-
- generate_load = main.params['TEST']['loadstart']
-
- main.ONOS1.handle.sendline(generate_load)
- main.ONOS1.handle.expect("sdn")
- print("before: ", main.ONOS1.handle.before)
- print("after: ",main.ONOS1.handle.after)
-
- load_confirm = main.ONOS1.handle.after
- if load_confirm == "{}":
- main.log.info("Load started")
-
- else:
- main.log.error("Load start failure")
- main.log.error("expected '{}', got: " + str(load_confirm))
-
- devices_json_str = main.ONOS1cli.devices()
- devices_json_obj = json.loads(devices_json_str)
-
- get_metric = main.params['TEST']['metric1']
- test_duration = main.params['TEST']['duration']
- stop = time.time() + float(test_duration)
-
-
- main.log.info("Starting test loop...")
- log_interval = main.params['TEST']['log_interval']
-
- while time.time() < stop:
- time.sleep(float(log_interval))
-
- intents_json_str_1 = main.ONOS1cli.intents_events_metrics()
- intents_json_obj_1 = json.loads(intents_json_str_1)
- main.log.info("Node 1 rate: " + str(intents_json_obj_1[intents_rate]['m1_rate']))
- last_rate_1 = intents_json_obj_1[intents_rate]['m1_rate']
-
- stop_load = main.params['TEST']['loadstop']
- main.ONOS1.handle.sendline(stop_load)
-
-
- msg = ("Final rate on node 1: " + str(last_rate_1))
- main.log.report(msg)
-
- def CASE4(self, main): #2 node scale
- import time
- import json
- import string
-
- intents_rate = main.params['JSON']['intents_rate']
-
- default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
-
- main.Mininet1.assign_sw_controller(sw="1", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="2", ip1=ONOS2_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="3", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="4", ip1=ONOS2_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="5", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="6", ip1=ONOS2_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(sw="7", ip1=ONOS1_ip, port1=default_sw_port )
-
- mn_arp = main.params['TEST']['arping']
- main.Mininet1.handle.sendline(mn_arp)
-
- generate_load = main.params['TEST']['loadstart']
-
- main.ONOS1.handle.sendline(generate_load)
- main.ONOS2.handle.sendline(generate_load)
-
- devices_json_str_1 = main.ONOS1cli.devices()
- devices_json_obj_1 = json.loads(devices_json_str_1)
- devices_json_str_2 = main.ONOS2cli.devices()
- devices_json_obj_2 = json.loads(devices_json_str_2)
-
- get_metric = main.params['TEST']['metric1']
- test_duration = main.params['TEST']['duration']
- stop = time.time() + float(test_duration)
-
-
- main.log.info("Starting test loop...")
- log_interval = main.params['TEST']['log_interval']
-
- while time.time() < stop:
- time.sleep(float(log_interval))
-
- intents_json_str_1 = main.ONOS1cli.intents_events_metrics()
- intents_json_obj_1 = json.loads(intents_json_str_1)
- main.log.info("Node 1 rate: " + str(intents_json_obj_1[intents_rate]['m1_rate']))
- last_rate_1 = intents_json_obj_1[intents_rate]['m1_rate']
-
- intents_json_str_2 = main.ONOS2cli.intents_events_metrics()
- intents_json_obj_2 = json.loads(intents_json_str_2)
- main.log.info("Node 2 rate: " + str(intents_json_obj_2[intents_rate]['m1_rate']))
- last_rate_2 = intents_json_obj_2[intents_rate]['m1_rate']
-
- stop_load = main.params['TEST']['loadstop']
- main.ONOS1.handle.sendline(stop_load)
- main.ONOS2.handle.sendline(stop_load)
-
-
- msg = ("Final rate on node 1: " + str(last_rate_1))
- main.log.report(msg)
-
- msg = ("Final rate on node 2: " + str(last_rate_2))
- main.log.report(msg)
-
-
-
diff --git a/TestON/tests/IntentsLoad/IntentsLoad.topo b/TestON/tests/IntentsLoad/IntentsLoad.topo
deleted file mode 100644
index 985baf9..0000000
--- a/TestON/tests/IntentsLoad/IntentsLoad.topo
+++ /dev/null
@@ -1,94 +0,0 @@
-<TOPOLOGY>
-
- <COMPONENT>
-
- <ONOSbench>
- <host>10.128.5.55</host>
- <user>admin</user>
- <password>onos_test</password>
- <type>OnosDriver</type>
- <connect_order>1</connect_order>
- <COMPONENTS> </COMPONENTS>
- </ONOSbench>
-
- <ONOS1cli>
- <host>10.128.5.55</host>
- <user>admin</user>
- <password>onos_test</password>
- <type>OnosCliDriver</type>
- <connect_order>2</connect_order>
- <COMPONENTS> </COMPONENTS>
- </ONOS1cli>
-
- <ONOS2cli>
- <host>10.128.5.55</host>
- <user>admin</user>
- <password>onos_test</password>
- <type>OnosCliDriver</type>
- <connect_order>3</connect_order>
- <COMPONENTS> </COMPONENTS>
- </ONOS2cli>
-
- <ONOS3cli>
- <host>10.128.5.55</host>
- <user>admin</user>
- <password>onos_test</password>
- <type>OnosCliDriver</type>
- <connect_order>4</connect_order>
- <COMPONENTS> </COMPONENTS>
- </ONOS3cli>
-
- <ONOS1>
- <host>10.128.5.51</host>
- <user>sdn</user>
- <password>rocks</password>
- <type>OnosDriver</type>
- <connect_order>5</connect_order>
- <COMPONENTS> </COMPONENTS>
- </ONOS1>
-
- <ONOS2>
- <host>10.128.5.52</host>
- <user>sdn</user>
- <password>rocks</password>
- <type>OnosDriver</type>
- <connect_order>6</connect_order>
- <COMPONENTS> </COMPONENTS>
- </ONOS2>
-
- <ONOS3>
- <host>10.128.5.53</host>
- <user>sdn</user>
- <password>rocks</password>
- <type>OnosDriver</type>
- <connect_order>7</connect_order>
- <COMPONENTS> </COMPONENTS>
- </ONOS3>
-
- <Mininet1>
- <host>10.128.5.59</host>
- <user>admin</user>
- <password>onos_test</password>
- <type>MininetCliDriver</type>
- <connect_order>8</connect_order>
- <COMPONENTS>
- <arg1> --custom ~/topo-intentTPtest.py </arg1>
- <arg2> --mac --topo mytopo </arg2>
- <arg3> </arg3>
- <controller> remote </controller>
- </COMPONENTS>
- </Mininet1>
-
- <Mininet2>
- <host>10.128.5.59</host>
- <user>admin</user>
- <password>onos_test</password>
- <type>RemoteMininetDriver</type>
- <connect_order>9</connect_order>
- <COMPONENTS> </COMPONENTS>
- </Mininet2>
-
- </COMPONENT>
-
-</TOPOLOGY>
-
diff --git a/TestON/tests/LinkEventTP/LinkEventTP.params b/TestON/tests/LinkEventTP/LinkEventTP.params
index 2beb9aa..b4d50e5 100644
--- a/TestON/tests/LinkEventTP/LinkEventTP.params
+++ b/TestON/tests/LinkEventTP/LinkEventTP.params
@@ -1,12 +1,9 @@
<PARAMS>
-
<testcases>1,3,2,3,2,3,2,3</testcases>
-
<ENV>
<cellName>network_tp_test</cellName>
<cellFeatures>"webconsole,onos-core,onos-api,onos-cli,onos-null,onos-rest,onos-app-metrics,onos-app-metrics-intent,onos-app-metrics-topology"</cellFeatures>
</ENV>
-
<SCALE>2</SCALE>
<availableNodes>7</availableNodes>
@@ -38,20 +35,20 @@
<ip1>localhost</ip1>
</BENCH>
- <TEST> # duration = time the test loop runs
- # log_interval = how often the data is reported
- # wait = time between tests, used to let the averages run down
-
- <metric1>topologyLinkEventRate</metric1>
- <metric2>topologyGraphEventRate</metric2>
- <flickerRate>2</flickerRate>
- <duration>180</duration>
- <log_interval>20</log_interval>
- <wait>30</wait>
- <configFile>/onos/tools/package/etc/org.onosproject.net.topology.impl.DefaultTopologyProvider.cfg</configFile>
+ <TEST> # duration = time the test loop runs
+ # log_interval = how often the data is reported
+ # wait = time between tests, used to let the averages run down
+
+ <flickerRates>1000,0,0,0,0,0,0</flickerRates>
+ <devicesPerNode>20,0,0,0,0,0,0</devicesPerNode>
+ <flickerRate>1000</flickerRate>
+ <linkgraphdif>.03</linkgraphdif> # 0-1 indicated link/graph rate dif tolerance
+ <duration>120</duration>
+ <log_interval>15</log_interval>
+ <wait>60</wait>
<skipCleanInstall>yes</skipCleanInstall>
<MN>localhost</MN>
- <logFile>link_event_tp_results_LOG</logFile>
+ <logFile>link_event_tp_results_LOG</logFile>
</TEST>
<JSON>
diff --git a/TestON/tests/LinkEventTP/LinkEventTP.py b/TestON/tests/LinkEventTP/LinkEventTP.py
index 1f5861e..e7d2133 100644
--- a/TestON/tests/LinkEventTP/LinkEventTP.py
+++ b/TestON/tests/LinkEventTP/LinkEventTP.py
@@ -34,14 +34,18 @@
Features = main.params[ 'ENV' ][ 'cellFeatures' ]
skipMvn = main.params[ 'TEST' ][ 'skipCleanInstall' ]
flickerRate = main.params[ 'TEST' ][ 'flickerRate']
+ deviceDistribution = (main.params[ 'TEST' ][ 'devicesPerNode']).split(",")
MNip = main.params[ 'TEST' ][ 'MN' ]
-
- #Populate ONOSIp with ips from params
+
+ main.ONOSbench.handle.sendline("export TERM=vt100")
+ main.ONOSbench.handle.expect(":~")
+
+ #Populate ONOSIp with ips from params
for i in range(1, maxNodes + 1):
ipString = 'ip' + str(i)
ONOSIp.append(main.params[ 'CTRL' ][ ipString ])
- #kill off all onos processes
+ #kill off all onos processes
main.log.step("Safety check, killing all ONOS processes")
main.log.step("before initiating enviornment setup")
for node in range(1, maxNodes + 1):
@@ -49,11 +53,10 @@
#construct the cell file
main.log.step("Creating cell file")
- exec "a = main.ONOSbench.createCellFile"
cellIp = []
- for node in range (1, maxNodes + 1):
- cellIp.append(ONOSIp[node])
- a(BENCHIp,cellName,MNip,str(Features), *cellIp) #'0' as third arg because we are not using mininet
+ for node in range (1, clusterCount + 1):
+ cellIp.append(ONOSIp[node])
+ main.ONOSbench.createCellFile(BENCHIp,cellName,MNip,str(Features), *cellIp)
main.step( "Set Cell" )
main.ONOSbench.setCell(cellName)
@@ -64,6 +67,14 @@
main.log.info(" Uninstalling ONOS " + str(i) )
main.ONOSbench.onosUninstall( ONOSIp[i] )
+ myDistribution = []
+ for node in range (1, clusterCount + 1):
+ myDistribution.append(deviceDistribution[node-1])
+
+ main.ONOSbench.createLinkGraphFile( BENCHIp,cellIp,myDistribution)
+ main.ONOSbench.createNullDevProviderFile( BENCHIp, cellIp, myDistribution)
+ main.ONOSbench.createNullLinkProviderFile(BENCHIp)
+
#git step - skipable
main.step( "Git checkout and pull " + checkoutBranch )
if gitPull == 'on':
@@ -153,8 +164,8 @@
main.step( "Enviornment setup and verification complete." )
main.ONOS1cli.startOnosCli( ONOSIp[1] )
main.step( "ONOS 1 is up and running." )
-
-
+ main.ONOSbench.handle.expect(":~") #there is a dangling sendline somewhere...
+
def CASE2( self, main ):
# This case increases the cluster size by whatever scale is
# Note: 'scale' is the size of the step
@@ -168,18 +179,55 @@
''
import time
global clusterCount
+
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ Features= main.params[ 'ENV' ][ 'cellFeatures' ]
+ BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
+ MNip = main.params[ 'TEST' ][ 'MN' ]
+ deviceDistribution = (main.params[ 'TEST' ][ 'devicesPerNode']).split(",")
scale = int( main.params[ 'SCALE' ] )
clusterCount += scale
+ main.log.step( "Cleaning Enviornment..." )
+ for i in range(1, maxNodes + 1):
+ main.ONOSbench.onosDie(ONOSIp[i])
+ main.log.info(" Uninstalling ONOS " + str(i) )
+ main.ONOSbench.onosUninstall( ONOSIp[i] )
+
+ myDistribution = []
+ for node in range (1, clusterCount + 1):
+ myDistribution.append(deviceDistribution[node-1])
+
+ main.log.step("Creating cell file")
+ cellIp = []
+ for node in range (1, clusterCount + 1):
+ cellIp.append(ONOSIp[node])
+ main.ONOSbench.createCellFile(BENCHIp,cellName,MNip,str(Features), *cellIp)
+
+ main.ONOSbench.createLinkGraphFile( BENCHIp,cellIp,myDistribution)
+ main.ONOSbench.createNullDevProviderFile( BENCHIp, cellIp, myDistribution)
+ main.ONOSbench.createNullLinkProviderFile(BENCHIp)
+
+ main.step( "Set Cell" )
+ main.ONOSbench.setCell(cellName)
+
main.log.report( "Increasing cluster size to " + str( clusterCount ) )
- for node in range((clusterCount - scale) + 1, clusterCount + 1):
- main.ONOSbench.onosDie(ONOSIp[node])
+ for node in range(1, clusterCount + 1):
time.sleep(10)
main.log.info("Starting ONOS " + str(node) + " at IP: " + ONOSIp[node])
main.ONOSbench.onosInstall( ONOSIp[node] )
exec "a = main.ONOS%scli.startOnosCli" %str(node)
a(ONOSIp[node])
+
+ for node in range(1, clusterCount + 1):
+ for i in range( 2 ):
+ isup = main.ONOSbench.isup( ONOSIp[node] )
+ if isup:
+ main.log.info("ONOS " + str(node) + " is up\n")
+ break
+ if not isup:
+ main.log.report( "ONOS " + str(node) + " didn't start!" )
def CASE3( self, main ):
import time
@@ -187,16 +235,23 @@
import string
import csv
import os.path
+ import requests
+ import numpy
+ sustainability = float(main.params[ 'TEST' ][ 'linkgraphdif' ])
+ flickerRates = (main.params[ 'TEST' ][ 'flickerRates']).split(",")
+ homeDir = os.path.expanduser('~')
linkResult = main.FALSE
scale = int( main.params[ 'SCALE' ] )
testDelay = main.params[ 'TEST' ][ 'wait']
time.sleep( float( testDelay ) )
+
+ for node in range(1, clusterCount + 1):
+ main.log.info("Writing flicker file to node " + str(node))
+ main.ONOSbench.createNullLinkProviderFile( ONOSIp[node], eventRate=flickerRates[node-1], onNode=True )
- metric1 = main.params[ 'TEST' ][ 'metric1' ]
- metric2 = main.params[ 'TEST' ][ 'metric2' ]
testDuration = main.params[ 'TEST' ][ 'duration' ]
stop = time.time() + float( testDuration )
@@ -211,33 +266,62 @@
while time.time() < stop:
time.sleep( float( logInterval ) )
- for node in range(1, clusterCount+1):
- exec "a = main.ONOS%scli.topologyEventsMetrics" %str(node)
- JsonStr[node] = a()
- JsonObj[node] = json.loads( JsonStr[node] )
- msg = ( "Node " + str(node) + " Link Event TP: " + str( JsonObj[node][ metric1 ][ 'm1_rate' ] ) )
+ for node in range(1, clusterCount+1):
+ main.ONOSbench.handle.sendline("""onos $OC1 topology-events-metrics|grep "Topology Link Events"|cut -d ' ' -f7 """)
+ main.ONOSbench.handle.expect(":~")
+ raw = (main.ONOSbench.handle.before).splitlines()
+ myresult = "--"
+ for word in raw:
+ if "m1" in word:
+ myresult = word
+ myresult = myresult.replace("m1=","")
+ break
+ if myresult == "--":
+ main.log.error("Parse error or no data error")
+ msg = ( "Node " + str(node) + " Link Event TP: " + str(myresult) )
main.log.info( msg )
- msg = ( "Node " + str(node) + " Graph Event TP: " + str( JsonObj[node][ metric2 ][ 'm1_rate' ] ) )
+ linkResults[node] = round(float(myresult),2)
+ myLinkRate = round(float(myresult),2)
+
+ main.ONOSbench.handle.sendline("""onos $OC1 topology-events-metrics|grep "Topology Graph Events"|cut -d ' ' -f7 """)
+ main.ONOSbench.handle.expect(":~")
+ raw = (main.ONOSbench.handle.before).splitlines()
+ myresult = "--"
+ for word in raw:
+ if "m1" in word:
+ myresult = word
+ myresult = myresult.replace("m1=","")
+ break
+ if myresult == "--":
+ main.log.error("Parse error or no data error")
+ msg = ( "Node " + str(node) + " Graph Event TP: " + str(myresult) )
main.log.info( msg )
-
- linkResults[node] = round(JsonObj[node][ metric2 ][ 'm1_rate' ],2)
- graphResults[node] = round(JsonObj[node][ metric1 ][ 'm1_rate' ],2)
+ graphResults[node] = round(float(myresult),2)
+ myGraphRate = round(float(myresult),2)
+
+ difLinkGraph = float(myLinkRate - myGraphRate)
+ difLinkGraph = numpy.absolute(difLinkGraph)
+ main.log.info("Node " + str(node) + " abs(Link event - Graph event) = " + str(difLinkGraph))
+ tempx = numpy.divide(difLinkGraph,float(myLinkRate))
+ if tempx > sustainability:
+ main.log.error("Difference in link event rate and graph event rate above " + str(sustainability) + " tolerance")
+ print("")
print("")
print("")
- main.log.info("Final Link Event TP Results on " + str(clusterCount) + " node cluster")
- main.log.info("_______________________________________________")
+ main.log.report("Final Link Event TP Results on " + str(clusterCount) + " node cluster")
+ main.log.report("_______________________________________________")
for node in range(1, clusterCount+1):
- main.log.info("Node " + str(node) + ": " + str(linkResults[node]))
+ main.log.report("Node " + str(node) + ": " + str(linkResults[node]))
print("")
print("")
- main.log.info("Final Graph Event TP Results on " + str(clusterCount) + " node cluster")
- main.log.info("_______________________________________________")
+ main.log.report("Final Graph Event TP Results on " + str(clusterCount) + " node cluster")
+ main.log.report("_______________________________________________")
for node in range(1, clusterCount+1):
- main.log.info("Node " + str(node) + ": " + str(graphResults[node]))
+ main.log.report("Node " + str(node) + ": " + str(graphResults[node]))
#################################################################################
# Data Logging
@@ -248,7 +332,7 @@
flickerRate = main.params[ 'TEST' ][ 'flickerRate']
for node in range (1, clusterCount + 1):
- logFile.write( str(clusterCount) + "," )
+ # replare -> logFile.write( str(clusterCount) + "," + flickerNodes + "," )
logFile.write("'" + "baremetal" + str(node) + "'," )
logFile.write( testDuration + "," )
logFile.write( flickerRate + "," )
diff --git a/TestON/tests/LinkEventTP/LinkEventTP.topo b/TestON/tests/LinkEventTP/LinkEventTP.topo
index 1c48a85..cf5fc94 100644
--- a/TestON/tests/LinkEventTP/LinkEventTP.topo
+++ b/TestON/tests/LinkEventTP/LinkEventTP.topo
@@ -3,7 +3,7 @@
<COMPONENT>
<ONOSbench>
- <host>localhost</host>
+ <host>10.128.5.55</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosDriver</type>
@@ -15,7 +15,7 @@
</ONOSbench>
<ONOS1cli>
- <host>localhost</host>
+ <host>10.128.5.55</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -24,7 +24,7 @@
</ONOS1cli>
<ONOS2cli>
- <host>localhost</host>
+ <host>10.128.5.55</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -33,7 +33,7 @@
</ONOS2cli>
<ONOS3cli>
- <host>localhost</host>
+ <host>10.128.5.55</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -42,7 +42,7 @@
</ONOS3cli>
<ONOS4cli>
- <host>localhost</host>
+ <host>10.128.5.55</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -51,7 +51,7 @@
</ONOS4cli>
<ONOS5cli>
- <host>localhost</host>
+ <host>10.128.5.55</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -60,7 +60,7 @@
</ONOS5cli>
<ONOS6cli>
- <host>localhost</host>
+ <host>10.128.5.55</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -69,7 +69,7 @@
</ONOS6cli>
<ONOS7cli>
- <host>localhost</host>
+ <host>10.128.5.55</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -78,7 +78,7 @@
</ONOS7cli>
<ONOS1>
- <host>10.254.1.201</host>
+ <host>10.128.5.51</host>
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
@@ -87,7 +87,7 @@
</ONOS1>
<ONOS2>
- <host>10.254.1.202</host>
+ <host>10.128.5.52</host>
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
@@ -96,7 +96,7 @@
</ONOS2>
<ONOS3>
- <host>10.254.1.203</host>
+ <host>10.128.5.53</host>
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
@@ -105,7 +105,7 @@
</ONOS3>
<ONOS4>
- <host>10.254.1.204</host>
+ <host>10.128.5.54</host>
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
@@ -115,7 +115,7 @@
<ONOS5>
- <host>10.254.1.205</host>
+ <host>10.128.5.65</host>
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
@@ -124,7 +124,7 @@
</ONOS5>
<ONOS6>
- <host>10.254.1.206</host>
+ <host>10.128.5.66</host>
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
@@ -133,7 +133,7 @@
</ONOS6>
<ONOS7>
- <host>10.254.1.207</host>
+ <host>10.128.5.67</host>
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
diff --git a/TestON/tests/LinkEventTP/OLDLinkEventTP.py b/TestON/tests/LinkEventTP/OLDLinkEventTP.py
deleted file mode 100644
index e12befa..0000000
--- a/TestON/tests/LinkEventTP/OLDLinkEventTP.py
+++ /dev/null
@@ -1,348 +0,0 @@
-# ScaleOutTemplate --> LinkEventTp
-#
-# CASE1 starts number of nodes specified in param file
-#
-# cameron@onlab.us
-
-import sys
-import os
-
-
-class LinkEventTP:
-
- def __init__( self ):
- self.default = ''
-
- def CASE1( self, main ):
- import os.path
- global clusterCount
- clusterCount = 1
-
- checkoutBranch = main.params[ 'GIT' ][ 'checkout' ]
- gitPull = main.params[ 'GIT' ][ 'autopull' ]
- cellName = main.params[ 'ENV' ][ 'cellName' ]
- BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
- BENCHUser = main.params[ 'BENCH' ][ 'user' ]
- ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
- ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
- ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
- flickerRate = main.params[ 'TEST' ][ 'flickerRate']
-
-
- main.log.step( "Cleaning Enviornment..." )
- main.ONOSbench.onosUninstall( ONOS1Ip )
- main.ONOSbench.onosUninstall( ONOS2Ip )
- main.ONOSbench.onosUninstall( ONOS3Ip )
-
- 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" )
-
- #mvnResult = main.ONOSbench.cleanInstall()
-
- main.step( "Set cell for ONOS cli env" )
- main.ONOS1cli.setCell( cellName )
- main.ONOS2cli.setCell( cellName )
- main.ONOS3cli.setCell( cellName )
-
- ### configuring file to enable flicker ###
- main.log.info(" Configuring null provider to enable flicker. Flicker Rate = " + flickerRate )
- homeDir = os.path.expanduser('~')
- main.log.info(homeDir)
- localPath = "/ONOS/tools/package/etc/org.onosproject.provider.nil.link.impl.NullLinkProvider.cfg"
- filePath = homeDir + localPath
- main.log.info(filePath)
-
- configFile = open(filePath, 'w+')
- main.log.info("File opened")
- configFile.write("# Sample configurations for the NullLinkProvider.\n")
- configFile.write("# \n")
- configFile.write("# If enabled, generates LinkDetected and LinkVanished events\n")
- configFile.write("# to make the link appear to be flapping.\n")
- configFile.write("#\n")
- configFile.write("flicker = true\n")
- configFile.write("#\n")
- configFile.write("# If enabled, sets the time between LinkEvent generation,\n")
- configFile.write("# in milliseconds.\n")
- configFile.write("#\n")
- configFile.write("eventRate = " + flickerRate)
- configFile.close()
- main.log.info("Configuration completed")
-
- #############################
- #config file default topo provider
- ###########################
-
- ### configure deafult topo provider event rate ###??????????????????
- localPath = main.params[ 'TEST' ][ 'configFile' ]
- filePath = homeDir + localPath
- main.log.info(filePath)
- configFile = open(filePath, 'w+')
- main.log.info("File Opened")
- configFile.write("maxEvents = 1\n")
- configFile.write("maxIdleMs = 0\n")
- configFile.write("maxBatchMs = 0\n")
- main.log.info("File written and closed")
-
- main.step( "Creating ONOS package" )
- packageResult = main.ONOSbench.onosPackage() # no file or directory
-
- main.step( "Installing ONOS package" )
- install1Result = main.ONOSbench.onosInstall( node=ONOS1Ip )
-
- cellName = main.params[ 'ENV' ][ 'cellName' ]
- main.step( "Applying cell file to environment" )
- cellApplyResult = main.ONOSbench.setCell( cellName )
- main.step( "verify cells" )
- verifyCellResult = main.ONOSbench.verifyCell()
-
- main.step( "Set cell for ONOS cli env" )
- main.ONOS1cli.setCell( cellName )
-
- cli1 = main.ONOS1cli.startOnosCli( ONOS1Ip )
-
- def CASE2( self, main ):
- """
- Increase number of nodes and initiate CLI
- """
- import time
- global clusterCount
-
- 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' ]
- cellName = main.params[ 'ENV' ][ 'cellName' ]
- scale = int( main.params[ 'SCALE' ] )
-
- # Cluster size increased everytime the case is defined
- clusterCount += scale
-
- main.log.report( "Increasing cluster size to " +
- str( clusterCount ) )
- installResult = main.FALSE
-
- if scale == 2:
- if clusterCount == 3:
- main.log.info( "Installing nodes 2 and 3" )
- install2Result = main.ONOSbench.onosInstall( node=ONOS2Ip )
- install3Result = main.ONOSbench.onosInstall( node=ONOS3Ip )
- cli2 = main.ONOS2cli.startOnosCli( ONOS2Ip )
- cli3 = main.ONOS3cli.startOnosCli( ONOS3Ip )
- installResult = main.TRUE
-
- if scale == 1:
- if clusterCount == 2:
- main.log.info( "Installing node 2" )
- install2Result = main.ONOSbench.onosInstall( node=ONOS2Ip )
- cli2 = main.ONOS2cli.startOnosCli( ONOS2Ip )
- installResult = main.TRUE
-
- if clusterCount == 3:
- main.log.info( "Installing node 3" )
- install3Result = main.ONOSbench.onosInstall( node=ONOS3Ip )
- cli3 = main.ONOS3cli.startOnosCli( ONOS3Ip )
- installResult = main.TRUE
-
-
- def CASE3( self, main ):
- import time
- import json
- import string
- import csv
-
- linkResult = main.FALSE
-
- testDelay = main.params[ 'TEST' ][ 'wait']
- time.sleep( float( testDelay ) )
-
- metric1 = main.params[ 'TEST' ][ 'metric1' ]
- metric2 = main.params[ 'TEST' ][ 'metric2' ]
- testDuration = main.params[ 'TEST' ][ 'duration' ]
- stop = time.time() + float( testDuration )
-
- main.ONOS1cli.featureInstall("onos-null")
-
- msg = ( "Starting test loop for " + str(testDuration) + " seconds" )
- main.log.info( msg )
- logInterval = main.params[ 'TEST' ][ 'log_interval' ]
-
- while time.time() < stop:
- time.sleep( float( logInterval ) )
-
- JsonStr1 = main.ONOS1cli.topologyEventsMetrics()
- JsonObj1 = json.loads( JsonStr1 )
- msg = ( "Node 1 Link Event TP: " + str( JsonObj1[ metric1 ][ 'm1_rate' ] ) )
- main.log.info( msg )
- msg = ( "Node 1 Graph Event TP: " + str( JsonObj1[ metric2 ][ 'm1_rate' ] ) )
- main.log.info( msg )
-
- lastGraphRate = round(JsonObj1[ metric2 ][ 'm1_rate' ],2)
- lastLinkRate = round(JsonObj1[ metric1 ][ 'm1_rate' ],2)
-
- msg = ( "Final Link Event TP: " + str( lastLinkRate ) )
- main.log.report( msg )
- msg = ( "Final Graph Event TP: " + str( lastGraphRate ) )
- main.log.report( msg )
-
- linkResult = main.TRUE
- '''
- jenkinsReport = open('LinkEventTP.csv', 'w')
- jenkinsReport.write("T1 - Node 1, T2 - Node 1, T2 - Node 2, T3 - Node 1, T3 - Node 2, T3 - Node 3\n")
- jenkinsReport.write(str(lastRate1))
- jenkinsReport.write("\n")
- jenkinsReport.close()
-
- dbReportS1 = open('LinkEventTP-S1.csv','w') #must be the name of the test "-S" followed by the scale
- dbReportS1.write(str(linkResult))
- dbReportS1.write("\n")
- dbReportS1.write(str(lastRate1))
- dbReportS1.write("\n") #additional newline needed for bash script reading
- dbReportS1.close()
- '''
-
-
- def CASE4( self, main ):
- import time
- import json
- import string
-
- linkResult = main.FALSE
-
- testDelay = main.params[ 'TEST' ][ 'wait']
- time.sleep( float( testDelay ) )
-
- getMetric = main.params[ 'TEST' ][ 'metric1' ]
- testDuration = main.params[ 'TEST' ][ 'duration' ]
- stop = time.time() + float( testDuration )
-
- main.ONOS2cli.featureInstall("onos-null")
-
- msg = ( "Starting test loop for " + str(testDuration) + " seconds" )
- main.log.info( msg )
- logInterval = main.params[ 'TEST' ][ 'log_interval' ]
-
- while time.time() < stop:
- time.sleep( float( logInterval ) )
-
- JsonStr1 = main.ONOS1cli.topologyEventsMetrics()
- JsonObj1 = json.loads( JsonStr1 )
- msg = ( "Node 1 TP: " + str( JsonObj1[ getMetric ][ 'm1_rate' ] ) )
- main.log.info( msg )
- lastRate1 = round(JsonObj1[ getMetric ][ 'm1_rate' ],2)
-
-
- JsonStr2 = main.ONOS2cli.topologyEventsMetrics()
- JsonObj2 = json.loads( JsonStr2 )
- msg = ( "Node 2 TP: " + str( JsonObj2[ getMetric ][ 'm1_rate' ] ) )
- main.log.info( msg )
- lastRate2 = round(JsonObj2[ getMetric ][ 'm1_rate' ],2)
-
-
- msg = ( "Final TP on node 1: " + str( lastRate1 ) )
- main.log.report( msg )
-
- msg = ( "Final TP on node 2: " + str( lastRate2 ) )
- main.log.report( msg )
-
- linkResult = main.TRUE
-
- jenkinsReport = open('LinkEventTP.csv', 'a')
- jenkinsReport.write(str(lastRate1))
- jenkinsReport.write(", ")
- jenkinsReport.write(str(lastRate2))
- jenkinsReport.write(", ")
- jenkinsReport.close()
-
- dbReportS2 = open('LinkEventTP-S2.csv','w') #must be the name of the test "-S" followed by the scale
- dbReportS2.write(str(linkResult))
- dbReportS2.write("\n")
- dbReportS2.write(str(lastRate1))
- dbReportS2.write("\n")
- dbReportS2.write(str(lastRate2))
- dbReportS2.write("\n")
- dbReportS2.close()
-
-
-
- def CASE5( self, main ):
- import time
- import json
- import string
-
- linkResult = main.FALSE
-
- testDelay = main.params[ 'TEST' ][ 'wait']
- time.sleep( float( testDelay ) )
-
- getMetric = main.params[ 'TEST' ][ 'metric1' ]
- testDuration = main.params[ 'TEST' ][ 'duration' ]
- stop = time.time() + float( testDuration )
-
- main.ONOS3cli.featureInstall("onos-null")
-
- msg = ( "Starting test loop for " + str(testDuration) + " seconds" )
- main.log.info( msg )
- logInterval = main.params[ 'TEST' ][ 'log_interval' ]
-
- while time.time() < stop:
- time.sleep( float( logInterval ) )
-
- JsonStr1 = main.ONOS1cli.topologyEventsMetrics()
- JsonObj1 = json.loads( JsonStr1 )
- msg = ( "Node 1 TP: " + str( JsonObj1[ getMetric ][ 'm1_rate' ] ) )
- main.log.info( msg )
- lastRate1 = round(JsonObj1[ getMetric ][ 'm1_rate' ],2)
-
- JsonStr2 = main.ONOS2cli.topologyEventsMetrics()
- JsonObj2 = json.loads( JsonStr2 )
- msg = ( "Node 2 TP: " + str( JsonObj2[ getMetric ][ 'm1_rate' ] ) )
- main.log.info( msg )
- lastRate2 = round(JsonObj2[ getMetric ][ 'm1_rate' ],2)
-
- JsonStr3 = main.ONOS3cli.topologyEventsMetrics()
- JsonObj3 = json.loads( JsonStr3 )
- msg = ( "Node 3 TP: " + str( JsonObj3[ getMetric ][ 'm1_rate' ] ) )
- main.log.info( msg )
- lastRate3 = round(JsonObj3[ getMetric ][ 'm1_rate' ],2)
-
- msg = ( "Final TP on node 1: " + str( lastRate1 ) )
- main.log.report( msg )
-
- msg = ( "Final TP on node 2: " + str( lastRate2 ) )
- main.log.report( msg )
-
- msg = ( "Final TP on node 3: " + str( lastRate3 ) )
- main.log.report( msg )
-
- linkResult = main.TRUE
-
- jenkinsReport = open('LinkEventTP.csv', 'a')
- jenkinsReport.write(str(lastRate1))
- jenkinsReport.write(", ")
- jenkinsReport.write(str(lastRate2))
- jenkinsReport.write(", ")
- jenkinsReport.write(str(lastRate3))
- jenkinsReport.close()
-
- dbReportS3 = open('LinkEventTP-S3.csv','w') #must be the name of the test "-S" followed by the scale
- dbReportS3.write(str(linkResult))
- dbReportS3.write("\n")
- dbReportS3.write(str(lastRate1))
- dbReportS3.write("\n")
- dbReportS3.write(str(lastRate2))
- dbReportS3.write("\n")
- dbReportS3.write(str(lastRate3))
- dbReportS3.write("\n")
- dbReportS3.close()
-
-
diff --git a/TestON/tests/MultiProd/MultiProd.params b/TestON/tests/MultiProd/MultiProd.params
index 6e5c85e..4818d09 100755
--- a/TestON/tests/MultiProd/MultiProd.params
+++ b/TestON/tests/MultiProd/MultiProd.params
@@ -1,7 +1,6 @@
<PARAMS>
- <testcases>1,4,10,5,6,7,8,6,8,9,8,31,32,8,33,8</testcases>
-
+ <testcases>1,4,10,5,6,7,8,6,8,9,8,31,32,8,33,8</testcases>
#Environment variables
<ENV>
<cellName>multi_test</cellName>
diff --git a/TestON/tests/MultiProd/MultiProd.py b/TestON/tests/MultiProd/MultiProd.py
index 52519d8..eca4da5 100644
--- a/TestON/tests/MultiProd/MultiProd.py
+++ b/TestON/tests/MultiProd/MultiProd.py
@@ -637,10 +637,8 @@
main.step( "Determine the current number of switches and links" )
topologyOutput = main.ONOScli1.topology()
topologyResult = main.ONOSbench.getTopology( topologyOutput )
- activeSwitches = topologyResult[ 'devices' ]
- links = topologyResult[ 'links' ]
- print "activeSwitches = ", type( activeSwitches )
- print "links = ", type( links )
+ activeSwitches = topologyResult[ 'deviceCount' ]
+ links = topologyResult[ 'linkCount' ]
main.log.info(
"Currently there are %s switches and %s links" %
( str( activeSwitches ), str( links ) ) )
@@ -1535,39 +1533,54 @@
main.Mininet1.verifyStaticGWandMAC( host='h9' )
main.Mininet1.verifyStaticGWandMAC( host='h10' )
+ ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ]
+ ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ]
+ ingressDeviceList = []
+ ingressDeviceList.append( ingressDevice1 )
+ ingressDeviceList.append( ingressDevice2 )
+
main.step( "Adding multipoint to singlepoint intent" )
pIntentResult1 = main.ONOScli1.addMultipointToSinglepointIntent(
- ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
- ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ ingressDeviceList,
egressDevice=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip1' ],
setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac1' ] )
+ ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ]
+ ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ]
+ ingressDeviceList = [ingressDevice1, ingressDevice2]
+
pIntentResult2 = main.ONOScli1.addMultipointToSinglepointIntent(
- ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
- ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ ingressDeviceList,
egressDevice=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip2' ],
setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac2' ] )
- getIntentResult = main.ONOScli1.intents( jsonFormat=False )
- main.log.info( "intents = " + getIntentResult )
+ pIntentResult = pIntentResult1 and pIntentResult2
+ if pIntentResult == main.FALSE:
+ main.log.info(
+ "Multi point to single point intent " +
+ "installation failed" )
+ else:
+ pIntentResult = main.TRUE
+ getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+ main.log.info( "intents = " + getIntentResult )
- time.sleep( 10 )
- getFlowsResult = main.ONOScli1.flows( jsonFormat=False )
- main.log.info( "flows = " + getFlowsResult )
+ time.sleep( 10 )
+ getFlowsResult = main.ONOScli1.flows( jsonFormat=False )
+ main.log.info( "flows = " + getFlowsResult )
- count = 1
- i = 8
- PingResult = main.TRUE
+ count = 1
+ i = 8
+ PingResult = main.TRUE
- main.log.info( "\n\nh" + str( i ) + " is Pinging h" + str( i + 2 ) )
- ping = main.Mininet1.pingHost(
+ main.log.info( "\n\nh" + str( i ) + " is Pinging h" + str( i + 2 ) )
+ ping = main.Mininet1.pingHost(
src="h" + str( i ), target="h" + str( i + 2 ) )
- if ping == main.FALSE and count < 3:
- count += 1
- PingResult = main.FALSE
- main.log.report( "Ping between h" +
+ if ping == main.FALSE and count < 3:
+ count += 1
+ PingResult = main.FALSE
+ main.log.report( "Ping between h" +
str( i ) +
" and h" +
str( i +
@@ -1575,43 +1588,38 @@
" failed. Making attempt number " +
str( count ) +
" in 2 seconds" )
- time.sleep( 2 )
- elif ping == main.FALSE:
- main.log.report( "All ping attempts between h" +
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
str( i ) +
" and h" +
str( i +
10 ) +
"have failed" )
- PingResult = main.FALSE
- elif ping == main.TRUE:
- main.log.info( "Ping test between h" +
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
str( i ) +
" and h" +
str( i +
2 ) +
"passed!" )
- PingResult = main.TRUE
- else:
- main.log.info( "Unknown error" )
- PingResult = main.ERROR
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
- if PingResult == main.FALSE:
- main.log.report( "Ping test failed." )
- # main.cleanup()
- # main.exit()
- if PingResult == main.TRUE:
- main.log.report( "Ping all successful" )
+ if PingResult == main.FALSE:
+ main.log.report( "Ping test failed." )
+ # main.cleanup()
+ # main.exit()
+ if PingResult == main.TRUE:
+ main.log.report( "Ping all successful" )
- pIntentResult = pIntentResult1 and pIntentResult2
if pIntentResult == main.TRUE:
main.log.info(
"Multi point intent with rewrite mac " +
- "address installation successful" )
- else:
- main.log.info(
- "Multi point intent with rewrite mac" +
- " address installation failed" )
+ "address installation and ping successful" )
case33Result = pIntentResult and PingResult
utilities.assertEquals(
diff --git a/TestON/tests/MultiProd13/MultiProd13.py b/TestON/tests/MultiProd13/MultiProd13.py
index c68640e..6c0b8d7 100644
--- a/TestON/tests/MultiProd13/MultiProd13.py
+++ b/TestON/tests/MultiProd13/MultiProd13.py
@@ -637,10 +637,8 @@
main.step( "Determine the current number of switches and links" )
topologyOutput = main.ONOScli1.topology()
topologyResult = main.ONOSbench.getTopology( topologyOutput )
- activeSwitches = topologyResult[ 'devices' ]
- links = topologyResult[ 'links' ]
- print "activeSwitches = ", type( activeSwitches )
- print "links = ", type( links )
+ activeSwitches = topologyResult[ 'deviceCount' ]
+ links = topologyResult[ 'linkCount' ]
main.log.info(
"Currently there are %s switches and %s links" %
( str( activeSwitches ), str( links ) ) )
@@ -1535,39 +1533,54 @@
main.Mininet1.verifyStaticGWandMAC( host='h9' )
main.Mininet1.verifyStaticGWandMAC( host='h10' )
+ ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ]
+ ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ]
+ ingressDeviceList = []
+ ingressDeviceList.append( ingressDevice1 )
+ ingressDeviceList.append( ingressDevice2 )
+
main.step( "Adding multipoint to singlepoint intent" )
pIntentResult1 = main.ONOScli1.addMultipointToSinglepointIntent(
- ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
- ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ ingressDeviceList,
egressDevice=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip1' ],
setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac1' ] )
+ ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ]
+ ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ]
+ ingressDeviceList = [ingressDevice1, ingressDevice2]
+
pIntentResult2 = main.ONOScli1.addMultipointToSinglepointIntent(
- ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
- ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ ingressDeviceList,
egressDevice=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip2' ],
setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac2' ] )
- getIntentResult = main.ONOScli1.intents( jsonFormat=False )
- main.log.info( "intents = " + getIntentResult )
+ pIntentResult = pIntentResult1 and pIntentResult2
+ if pIntentResult == main.FALSE:
+ main.log.info(
+ "Multi point to single point intent " +
+ "installation failed" )
+ else:
+ pIntentResult = main.TRUE
+ getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+ main.log.info( "intents = " + getIntentResult )
- time.sleep( 10 )
- getFlowsResult = main.ONOScli1.flows( jsonFormat=False )
- main.log.info( "flows = " + getFlowsResult )
+ time.sleep( 10 )
+ getFlowsResult = main.ONOScli1.flows( jsonFormat=False )
+ main.log.info( "flows = " + getFlowsResult )
- count = 1
- i = 8
- PingResult = main.TRUE
+ count = 1
+ i = 8
+ PingResult = main.TRUE
- main.log.info( "\n\nh" + str( i ) + " is Pinging h" + str( i + 2 ) )
- ping = main.Mininet1.pingHost(
+ main.log.info( "\n\nh" + str( i ) + " is Pinging h" + str( i + 2 ) )
+ ping = main.Mininet1.pingHost(
src="h" + str( i ), target="h" + str( i + 2 ) )
- if ping == main.FALSE and count < 3:
- count += 1
- PingResult = main.FALSE
- main.log.report( "Ping between h" +
+ if ping == main.FALSE and count < 3:
+ count += 1
+ PingResult = main.FALSE
+ main.log.report( "Ping between h" +
str( i ) +
" and h" +
str( i +
@@ -1575,43 +1588,38 @@
" failed. Making attempt number " +
str( count ) +
" in 2 seconds" )
- time.sleep( 2 )
- elif ping == main.FALSE:
- main.log.report( "All ping attempts between h" +
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
str( i ) +
" and h" +
str( i +
10 ) +
"have failed" )
- PingResult = main.FALSE
- elif ping == main.TRUE:
- main.log.info( "Ping test between h" +
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
str( i ) +
" and h" +
str( i +
2 ) +
"passed!" )
- PingResult = main.TRUE
- else:
- main.log.info( "Unknown error" )
- PingResult = main.ERROR
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
- if PingResult == main.FALSE:
- main.log.report( "Ping test failed." )
- # main.cleanup()
- # main.exit()
- if PingResult == main.TRUE:
- main.log.report( "Ping all successful" )
+ if PingResult == main.FALSE:
+ main.log.report( "Ping test failed." )
+ # main.cleanup()
+ # main.exit()
+ if PingResult == main.TRUE:
+ main.log.report( "Ping all successful" )
- pIntentResult = pIntentResult1 and pIntentResult2
if pIntentResult == main.TRUE:
main.log.info(
"Multi point intent with rewrite mac " +
- "address installation successful" )
- else:
- main.log.info(
- "Multi point intent with rewrite mac" +
- " address installation failed" )
+ "address installation and ping successful" )
case33Result = pIntentResult and PingResult
utilities.assertEquals(
diff --git a/TestON/tests/OnosCHO/OnosCHO.params b/TestON/tests/OnosCHO/OnosCHO.params
index edc7540..02a016c 100644
--- a/TestON/tests/OnosCHO/OnosCHO.params
+++ b/TestON/tests/OnosCHO/OnosCHO.params
@@ -13,9 +13,9 @@
# 1,2,3,[4,5,6,5,70,80,5,10,5,9,5,71,81,5,10,5]*100
# 1,2,3,4,5,6,10,12,3,4,5,6,10,13,3,4,5,6,10
- <testcases>1,2,3,4,5,6,10</testcases>
+ <testcases>1,[2,3,4,5,6,70,80,10,12,3,4,5,14,10,13,3,4,5,15,10]*3</testcases>
<ENV>
- <cellName>fiveNodes</cellName>
+ <cellName>choTest5New</cellName>
</ENV>
<GIT>
#autoPull 'on' or 'off'
@@ -45,15 +45,15 @@
</TOPO3>
<CTRL>
<numCtrl>5</numCtrl>
- <ip1>10.128.10.21</ip1>
+ <ip1>10.128.40.41</ip1>
<port1>6633</port1>
- <ip2>10.128.10.22</ip2>
+ <ip2>10.128.40.42</ip2>
<port2>6633</port2>
- <ip3>10.128.10.23</ip3>
+ <ip3>10.128.40.43</ip3>
<port3>6633</port3>
- <ip4>10.128.10.24</ip4>
+ <ip4>10.128.40.44</ip4>
<port4>6633</port4>
- <ip5>10.128.10.25</ip5>
+ <ip5>10.128.40.45</ip5>
<port5>6633</port5>
</CTRL>
<HOSTS>
diff --git a/TestON/tests/OnosCHO/OnosCHO.py b/TestON/tests/OnosCHO/OnosCHO.py
index 955d996..93dc11b 100644
--- a/TestON/tests/OnosCHO/OnosCHO.py
+++ b/TestON/tests/OnosCHO/OnosCHO.py
@@ -163,7 +163,7 @@
utilities.assert_equals( expect=main.TRUE, actual=case1Result,
onpass="Set up test environment PASS",
onfail="Set up test environment FAIL" )
-
+ time.sleep(30)
def CASE2( self, main ):
"""
This test loads a Topology (ATT) on Mininet and balances all switches.
@@ -249,8 +249,10 @@
main.step( "Collect and store current number of switches and links" )
topology_output = main.ONOScli1.topology()
topology_result = main.ONOSbench.getTopology( topology_output )
- numOnosDevices = topology_result[ 'devices' ]
- numOnosLinks = topology_result[ 'links' ]
+ numOnosDevices = topology_result[ 'deviceCount' ]
+ numOnosLinks = topology_result[ 'linkCount' ]
+ print numOnosDevices
+ print numOnosLinks
if ( ( main.numMNswitches == int(numOnosDevices) ) and ( main.numMNlinks >= int(numOnosLinks) ) ):
main.step( "Store Device DPIDs" )
@@ -529,7 +531,7 @@
main.log.report( "Add 300 host intents and verify pingall" )
main.log.report( "_______________________________________" )
import itertools
-
+ import time
main.case( "Install 300 host intents" )
main.step( "Add host Intents" )
intentResult = main.TRUE
@@ -547,6 +549,7 @@
name="addHostIntent",
args=[hostCombos[i][0],hostCombos[i][1]])
pool.append(t)
+ time.sleep(1)
t.start()
i = i + 1
main.threadID = main.threadID + 1
@@ -560,7 +563,7 @@
getIntentStateResult = main.ONOScli1.getIntentState(intentsId = intentIdList,
intentsJson = intentsJson)
print getIntentStateResult
-
+ time.sleep(30)
main.step( "Verify Ping across all hosts" )
pingResult = main.FALSE
time1 = time.time()
@@ -940,6 +943,208 @@
onpass="Ping all test after Point intents addition successful",
onfail="Ping all test after Point intents addition failed" )
+ def CASE90( self ):
+ """
+ Install single-multi point intents and verify Ping all works
+ for att topology
+ """
+ import copy
+ main.log.report( "Install single-multi point intents and verify Ping all" )
+ main.log.report( "___________________________________________" )
+ main.case( "Install single-multi point intents and Ping all" )
+ deviceLinksCopy = copy.copy( main.deviceLinks )
+ main.step( "Install single-multi point intents" )
+ for i in range( len( deviceLinksCopy ) ):
+ pointLink = str(
+ deviceLinksCopy[ i ] ).replace(
+ "src=",
+ "" ).replace(
+ "dst=",
+ "" ).split( ',' )
+ point1 = pointLink[ 0 ].split( '/' )
+ point2 = pointLink[ 1 ].split( '/' )
+ installResult = main.ONOScli1.addPointIntent(
+ point1[ 0 ], point2[ 0 ], int(
+ point1[ 1 ] ), int(
+ point2[ 1 ] ) )
+ if installResult == main.TRUE:
+ print "Installed Point intent between :", point1[ 0 ], int( point1[ 1 ] ), point2[ 0 ], int( point2[ 1 ] )
+
+ main.step( "Obtain the intent id's" )
+ intentsList = main.ONOScli1.getAllIntentIds()
+ ansi_escape = re.compile( r'\x1b[^m]*m' )
+ intentsList = ansi_escape.sub( '', intentsList )
+ intentsList = intentsList.replace(
+ " onos:intents | grep id=",
+ "" ).replace(
+ "id=",
+ "" ).replace(
+ "\r\r",
+ "" )
+ intentsList = intentsList.splitlines()
+ intentsList = intentsList[ 1: ]
+ intentIdList = []
+ for i in range( len( intentsList ) ):
+ intentsTemp = intentsList[ i ].split( ',' )
+ intentIdList.append( intentsTemp[ 0 ] )
+ print "Intent IDs: ", intentIdList
+ print "Total Intents installed: ", len( intentIdList )
+
+ main.step( "Verify Ping across all hosts" )
+ pingResult = main.FALSE
+ time1 = time.time()
+ pingResult = main.Mininet1.pingall()
+ time2 = time.time()
+ timeDiff = round( ( time2 - time1 ), 2 )
+ main.log.report(
+ "Time taken for Ping All: " +
+ str( timeDiff ) +
+ " seconds" )
+ utilities.assert_equals( expect=main.TRUE, actual=pingResult,
+ onpass="PING ALL PASS",
+ onfail="PING ALL FAIL" )
+
+ case8_result = installResult and pingResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case8_result,
+ onpass="Ping all test after Point intents addition successful",
+ onfail="Ping all test after Point intents addition failed" )
+
+ def CASE91( self ):
+ """
+ Install single-multi point intents and verify Ping all works
+ """
+ import copy
+ main.log.report( "Install single-multi point intents and verify Ping all" )
+ main.log.report( "___________________________________________" )
+ main.case( "Install single-multi point intents and Ping all" )
+ deviceLinksCopy = copy.copy( main.deviceLinks )
+ main.step( "Install single-multi point intents" )
+ for i in range( len( deviceLinksCopy ) ):
+ pointLink = str(
+ deviceLinksCopy[ i ] ).replace(
+ "src=",
+ "" ).replace(
+ "dst=",
+ "" ).split( ',' )
+ point1 = pointLink[ 0 ].split( '/' )
+ point2 = pointLink[ 1 ].split( '/' )
+ installResult = main.ONOScli1.addPointIntent(
+ point1[ 0 ], point2[ 0 ], int(
+ point1[ 1 ] ), int(
+ point2[ 1 ] ) )
+ if installResult == main.TRUE:
+ print "Installed Point intent between :", point1[ 0 ], int( point1[ 1 ] ), point2[ 0 ], int( point2[ 1 ] )
+
+ main.step( "Obtain the intent id's" )
+ intentsList = main.ONOScli1.getAllIntentIds()
+ ansi_escape = re.compile( r'\x1b[^m]*m' )
+ intentsList = ansi_escape.sub( '', intentsList )
+ intentsList = intentsList.replace(
+ " onos:intents | grep id=",
+ "" ).replace(
+ "id=",
+ "" ).replace(
+ "\r\r",
+ "" )
+ intentsList = intentsList.splitlines()
+ intentsList = intentsList[ 1: ]
+ intentIdList = []
+ for i in range( len( intentsList ) ):
+ intentsTemp = intentsList[ i ].split( ',' )
+ intentIdList.append( intentsTemp[ 0 ] )
+ print "Intent IDs: ", intentIdList
+ print "Total Intents installed: ", len( intentIdList )
+
+ main.step( "Verify Ping across all hosts" )
+ pingResult = main.FALSE
+ time1 = time.time()
+ pingResult = main.Mininet1.pingall()
+ time2 = time.time()
+ timeDiff = round( ( time2 - time1 ), 2 )
+ main.log.report(
+ "Time taken for Ping All: " +
+ str( timeDiff ) +
+ " seconds" )
+ utilities.assert_equals( expect=main.TRUE, actual=pingResult,
+ onpass="PING ALL PASS",
+ onfail="PING ALL FAIL" )
+
+ case8_result = installResult and pingResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case8_result,
+ onpass="Ping all test after Point intents addition successful",
+ onfail="Ping all test after Point intents addition failed" )
+
+ def CASE92( self ):
+ """
+ Install 114 point intents and verify Ping all works
+ """
+ import copy
+ main.log.report( "Install 114 point intents and verify Ping all" )
+ main.log.report( "___________________________________________" )
+ main.case( "Install 114 point intents and Ping all" )
+ deviceLinksCopy = copy.copy( main.deviceLinks )
+ main.step( "Install 114 point intents" )
+ for i in range( len( deviceLinksCopy ) ):
+ pointLink = str(
+ deviceLinksCopy[ i ] ).replace(
+ "src=",
+ "" ).replace(
+ "dst=",
+ "" ).split( ',' )
+ point1 = pointLink[ 0 ].split( '/' )
+ point2 = pointLink[ 1 ].split( '/' )
+ installResult = main.ONOScli1.addPointIntent(
+ point1[ 0 ], point2[ 0 ], int(
+ point1[ 1 ] ), int(
+ point2[ 1 ] ) )
+ if installResult == main.TRUE:
+ print "Installed Point intent between :", point1[ 0 ], int( point1[ 1 ] ), point2[ 0 ], int( point2[ 1 ] )
+
+ main.step( "Obtain the intent id's" )
+ intentsList = main.ONOScli1.getAllIntentIds()
+ ansi_escape = re.compile( r'\x1b[^m]*m' )
+ intentsList = ansi_escape.sub( '', intentsList )
+ intentsList = intentsList.replace(
+ " onos:intents | grep id=",
+ "" ).replace(
+ "id=",
+ "" ).replace(
+ "\r\r",
+ "" )
+ intentsList = intentsList.splitlines()
+ intentsList = intentsList[ 1: ]
+ intentIdList = []
+ for i in range( len( intentsList ) ):
+ intentsTemp = intentsList[ i ].split( ',' )
+ intentIdList.append( intentsTemp[ 0 ] )
+ print "Intent IDs: ", intentIdList
+ print "Total Intents installed: ", len( intentIdList )
+
+ main.step( "Verify Ping across all hosts" )
+ pingResult = main.FALSE
+ time1 = time.time()
+ pingResult = main.Mininet1.pingall()
+ time2 = time.time()
+ timeDiff = round( ( time2 - time1 ), 2 )
+ main.log.report(
+ "Time taken for Ping All: " +
+ str( timeDiff ) +
+ " seconds" )
+ utilities.assert_equals( expect=main.TRUE, actual=pingResult,
+ onpass="PING ALL PASS",
+ onfail="PING ALL FAIL" )
+
+ case8_result = installResult and pingResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case8_result,
+ onpass="Ping all test after Point intents addition successful",
+ onfail="Ping all test after Point intents addition failed" )
+
def CASE10( self ):
import time
"""
@@ -964,84 +1169,57 @@
intentsList = intentsList[ 1: ]
intentIdList = []
step1Result = main.TRUE
+ moreIntents = main.TRUE
+ removeIntentCount = 0
+ print "Current number of intents" , len(intentsList)
if ( len( intentsList ) > 1 ):
- for i in range( len( intentsList ) ):
- intentsTemp = intentsList[ i ].split( ',' )
- intentIdList.append( intentsTemp[ 0 ] )
- print "Intent IDs: ", intentIdList
-
results = main.TRUE
- time1 = time.time()
-
- for i in xrange(0,len( intentIdList ), int(main.numCtrls)):
- pool = []
- for cli in main.CLIs:
- if i >= len(intentIdList):
- break
- print "Removing intent id (round 1) :", intentIdList[ i ]
- t = main.Thread(target=cli.removeIntent,
- threadID=main.threadID,
- name="removeIntent",
- args=[intentIdList[i],'org.onosproject.cli',False,False])
- pool.append(t)
- t.start()
- i = i + 1
- main.threadID = main.threadID + 1
- for t in pool:
- t.join()
- results = results and t.result
-
- time2 = time.time()
- main.log.info("Time for feature:install onos-app-fwd: %2f seconds" %(time2-time1))
+ main.log.info("Removing intent...")
+ while moreIntents:
+ removeIntentCount = removeIntentCount + 1
+ intentsList1 = main.ONOScli1.getAllIntentIds()
+ if len( intentsList1 ) == 0:
+ break
+ ansi_escape = re.compile( r'\x1b[^m]*m' )
+ intentsList1 = ansi_escape.sub( '', intentsList1 )
+ intentsList1 = intentsList1.replace(
+ " onos:intents | grep id=",
+ "" ).replace(
+ " state=",
+ "" ).replace(
+ "\r\r",
+ "" )
+ intentsList1 = intentsList1.splitlines()
+ intentsList1 = intentsList1[ 1: ]
+ print "Round %d intents to remove: " %(removeIntentCount)
+ print intentsList1
+ intentIdList1 = []
+ if ( len( intentsList1 ) > 1 ):
+ moreIntents = main.TRUE
+ for i in range( len( intentsList1 ) ):
+ intentsTemp1 = intentsList1[ i ].split( ',' )
+ intentIdList1.append( intentsTemp1[ 0 ].split('=')[1] )
+ print "Leftover Intent IDs: ", intentIdList1
+ print len(intentIdList1)
+ for intent in intentIdList1:
+ main.CLIs[0].removeIntent(intent,'org.onosproject.cli',True,False)
+ else:
+ time.sleep(15)
+ if len(main.ONOScli1.intents()):
+ continue
+ break
+ if removeIntentCount == 5:
+ break
- main.log.info(
- "Verify all intents are removed and if any leftovers try remove one more time" )
- intentsList1 = main.ONOScli1.getAllIntentIds()
- ansi_escape = re.compile( r'\x1b[^m]*m' )
- intentsList1 = ansi_escape.sub( '', intentsList1 )
- intentsList1 = intentsList1.replace(
- " onos:intents | grep id=",
- "" ).replace(
- " state=",
- "" ).replace(
- "\r\r",
- "" )
- intentsList1 = intentsList1.splitlines()
- intentsList1 = intentsList1[ 1: ]
-
- print "Round 2 (leftover) intents to remove: ", intentsList1
- intentIdList1 = []
- if ( len( intentsList1 ) > 1 ):
- for i in range( len( intentsList1 ) ):
- intentsTemp1 = intentsList1[ i ].split( ',' )
- intentIdList1.append( intentsTemp1[ 0 ].split('=')[1] )
- print "Leftover Intent IDs: ", intentIdList1
- for i in xrange(0, len( intentIdList1 ), int(main.numCtrls)):
- pool = []
- for cli in main.CLIs:
- if i >= len(intentIdList1):
- break
- print "Removing intent id (round 2) :", intentIdList1[ i ]
- t = main.Thread(target=cli.removeIntent,threadID=main.threadID,
- name="removeIntent",
- args=[intentIdList1[i],'org.onosproject.cli',True,False])
- pool.append(t)
- t.start()
- i = i + 1
- main.threadID = main.threadID + 1
-
- for t in pool:
- t.join()
- results = results and t.result
- step1Result = results
else:
print "There are no more intents that need to be removed"
step1Result = main.TRUE
else:
print "No Intent IDs found in Intents list: ", intentsList
step1Result = main.FALSE
-
+
print main.ONOScli1.intents()
+ # time.sleep(300)
caseResult10 = step1Result
utilities.assert_equals( expect=main.TRUE, actual=caseResult10,
onpass="Intent removal test successful",
@@ -1147,7 +1325,6 @@
import re
import time
import copy
-
Thread = imp.load_source('Thread','/home/admin/ONLabTest/TestON/tests/OnosCHO/Thread.py')
newTopo = main.params['TOPO2']['topo']
@@ -1155,6 +1332,8 @@
main.numMNlinks = int ( main.params[ 'TOPO2' ][ 'numLinks' ] )
main.numMNhosts = int ( main.params[ 'TOPO2' ][ 'numHosts' ] )
main.pingTimeout = 60
+
+ time.sleep(60)
main.log.report(
"Load Chordal topology and Balance all Mininet switches across controllers" )
main.log.report(
@@ -1279,6 +1458,8 @@
main.numMNlinks = int ( main.params[ 'TOPO3' ][ 'numLinks' ] )
main.numMNhosts = int ( main.params[ 'TOPO3' ][ 'numHosts' ] )
main.pingTimeout = 600
+
+ time.sleep(60)
main.log.report(
"Load Spine and Leaf topology and Balance all Mininet switches across controllers" )
main.log.report(
@@ -1518,3 +1699,4 @@
onpass="Install 300 Host Intents and Ping All test PASS",
onfail="Install 300 Host Intents and Ping All test FAIL" )
+
diff --git a/TestON/tests/OnosCHO/OnosCHO.topo b/TestON/tests/OnosCHO/OnosCHO.topo
index 53de6dc..040e3c5 100644
--- a/TestON/tests/OnosCHO/OnosCHO.topo
+++ b/TestON/tests/OnosCHO/OnosCHO.topo
@@ -2,18 +2,16 @@
<COMPONENT>
<ONOSbench>
- <host>10.128.10.20</host>
+ <host>10.128.40.40</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosDriver</type>
<connect_order>1</connect_order>
- <COMPONENTS>
- <home>~/onos</home>
- </COMPONENTS>
+ <COMPONENTS> </COMPONENTS>
</ONOSbench>
<ONOScli1>
- <host>10.128.10.20</host>
+ <host>10.128.40.40</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -22,7 +20,7 @@
</ONOScli1>
<ONOScli2>
- <host>10.128.10.20</host>
+ <host>10.128.40.40</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -31,7 +29,7 @@
</ONOScli2>
<ONOScli3>
- <host>10.128.10.20</host>
+ <host>10.128.40.40</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -40,7 +38,7 @@
</ONOScli3>
<ONOScli4>
- <host>10.128.10.20</host>
+ <host>10.128.40.40</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -49,7 +47,7 @@
</ONOScli4>
<ONOScli5>
- <host>10.128.10.20</host>
+ <host>10.128.40.40</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -58,7 +56,7 @@
</ONOScli5>
<ONOS1>
- <host>10.128.10.21</host>
+ <host>10.128.40.41</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -67,7 +65,7 @@
</ONOS1>
<ONOS2>
- <host>10.128.10.22</host>
+ <host>10.128.40.42</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -76,7 +74,7 @@
</ONOS2>
<ONOS3>
- <host>10.128.10.23</host>
+ <host>10.128.40.43</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -85,7 +83,7 @@
</ONOS3>
<ONOS4>
- <host>10.128.10.24</host>
+ <host>10.128.40.44</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -94,7 +92,7 @@
</ONOS4>
<ONOS5>
- <host>10.128.10.25</host>
+ <host>10.128.40.45</host>
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
@@ -103,7 +101,7 @@
</ONOS5>
<Mininet1>
- <host>10.128.10.20</host>
+ <host>10.128.40.50</host>
<user>admin</user>
<password>onos_test</password>
<type>MininetCliDriver</type>
@@ -118,7 +116,7 @@
</Mininet1>
<Mininet2>
- <host>10.128.10.20</host>
+ <host>10.128.40.50</host>
<user>admin</user>
<password>onos_test</password>
<type>RemoteMininetDriver</type>
diff --git a/TestON/tests/ProdFunc/ProdFunc.params b/TestON/tests/ProdFunc/ProdFunc.params
index c02cbd0..a9b212f 100755
--- a/TestON/tests/ProdFunc/ProdFunc.params
+++ b/TestON/tests/ProdFunc/ProdFunc.params
@@ -1,7 +1,6 @@
<PARAMS>
- <testcases>1,4,11,10,8,12,5,6</testcases>
-
+ <testcases>1,4,10,5,6,7,8,9,8,11,8,2,20,21,22,10,23,24</testcases>
#Environment variables
<ENV>
<cellName>driver_test</cellName>
diff --git a/TestON/tests/ProdFunc13/ProdFunc13.params b/TestON/tests/ProdFunc13/ProdFunc13.params
index f28d620..a9b212f 100755
--- a/TestON/tests/ProdFunc13/ProdFunc13.params
+++ b/TestON/tests/ProdFunc13/ProdFunc13.params
@@ -1,7 +1,6 @@
<PARAMS>
- <testcases>1,4,11,10,5,6,7,8,12,9,2,20,21,22,10,23,24</testcases>
-
+ <testcases>1,4,10,5,6,7,8,9,8,11,8,2,20,21,22,10,23,24</testcases>
#Environment variables
<ENV>
<cellName>driver_test</cellName>
diff --git a/TestON/tests/ProdFunc13/ProdFunc13.py b/TestON/tests/ProdFunc13/ProdFunc13.py
index afa538f..44e78b7 100644
--- a/TestON/tests/ProdFunc13/ProdFunc13.py
+++ b/TestON/tests/ProdFunc13/ProdFunc13.py
@@ -768,16 +768,22 @@
def CASE12( self ):
"""
- Verify the default flows on each switch
+ Verify the default flows on each switch in proactive mode
"""
+ main.log.report( "This testcase is verifying num of default" +
+ " flows on each switch" )
+ main.log.report( "__________________________________" )
+ main.case( "Verify num of default flows on each switch" )
+ main.step( "Obtaining the device id's and flowrule count on them" )
+
case12Result = main.TRUE
idList = main.ONOS2.getAllDevicesId()
for id in idList:
- count = main.ONOS2.FlowStateCount( id )
- print "count = ", count
- if count != 5:
+ count = main.ONOS2.FlowAddedCount( id )
+ main.log.info("count = " +count)
+ if int(count) != 3:
case12Result = main.FALSE
-
+ break
utilities.assert_equals(
expect=main.TRUE,
actual=case12Result,
@@ -1070,8 +1076,8 @@
main.step( "Determine the current number of switches and links" )
topologyOutput = main.ONOS2.topology()
topologyResult = main.ONOS1.getTopology( topologyOutput )
- activeSwitches = topologyResult[ 'devices' ]
- links = topologyResult[ 'links' ]
+ activeSwitches = topologyResult[ 'deviceCount' ]
+ links = topologyResult[ 'linkCount' ]
print "activeSwitches = ", type( activeSwitches )
print "links = ", type( links )
main.log.info(
diff --git a/TestON/tests/ScaleOutTemplate/.ScaleOutTemplate.py.swo b/TestON/tests/ScaleOutTemplate/.ScaleOutTemplate.py.swo
new file mode 100644
index 0000000..a1a28ae
--- /dev/null
+++ b/TestON/tests/ScaleOutTemplate/.ScaleOutTemplate.py.swo
Binary files differ
diff --git a/TestON/tests/ScaleOutTemplate/README b/TestON/tests/ScaleOutTemplate/README
new file mode 100644
index 0000000..2d5ae1c
--- /dev/null
+++ b/TestON/tests/ScaleOutTemplate/README
@@ -0,0 +1,22 @@
+-------------------
+----Setup Guide----
+-------------------
+
+CASE 1: init case; cleans and sets up enviornment, starts up node 1
+
+CASE 2: Increments scale case; starts up additional nodes, determined by 'SCALE' in params
+ Ex: cluster size = 1 and scale = 2 ==> call CASE2 ==> cluster size = 3
+
+Params file:
+ SCALE = cluster scale step size
+ availableNodes = number of nodes you have provided data for in .topo file
+
+ ENV:
+ cellName = desired name of cell file to be created at runtime
+ cellFeatures = list of features desired
+ NOTE: webconsole, onos-api, onos-cli and onos-openflow are loaded automatically.
+ adjust your test and feature list accordingly
+ TEST:
+ skipCleanInstall = set yes if you want to skip for the sake of test debugging, otherwise set no
+
+
diff --git a/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.params b/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.params
index 4dacc99..641d16a 100644
--- a/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.params
+++ b/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.params
@@ -2,11 +2,17 @@
<testcases>1,2</testcases>
+ <SCALE>2</SCALE>
+ <availableNodes>7</availableNodes>
+
<ENV>
- <cellName>cam_cells</cellName>
+ <cellName>defaultCell</cellName>
+ <cellFeatures></cellFeatures>
</ENV>
- <SCALE>2</SCALE>
+ <TEST>
+ <skipCleanInstall>yes</skipCleanInstall>
+ </TEST>
<GIT>
<autopull>on</autopull>
@@ -15,12 +21,28 @@
<CTRL>
<USER>admin</USER>
+
<ip1>10.128.5.51</ip1>
<port1>6633</port1>
+
<ip2>10.128.5.52</ip2>
<port2>6633</port2>
+
<ip3>10.128.5.53</ip3>
<port3>6633</port3>
+
+ <ip4>10.128.5.54</ip4>
+ <port4>6633</port4>
+
+ <ip5>10.128.5.65</ip5>
+ <port5>6633</port5>
+
+ <ip6>10.128.5.66</ip6>
+ <port6>6633</port6>
+
+ <ip7>10.128.5.67</ip7>
+ <port7>6633</port7>
+
</CTRL>
<MN>
@@ -32,9 +54,6 @@
<ip1>10.128.5.55</ip1>
</BENCH>
- <TEST>
- </TEST>
-
<JSON>
</JSON>
diff --git a/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.py b/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.py
index a75d694..fdcd680 100644
--- a/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.py
+++ b/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.py
@@ -4,133 +4,131 @@
#
# cameron@onlab.us
-import sys
-import os
+import sys
+import os.path
class ScaleOutTemplate:
- def __init__(self):
+
+ def __init__( self ):
self.default = ''
-
- def CASE1(self, main):
+
+ def CASE1( self, main ): #This is the initialization case
+ #this case will clean up all nodes
+ import time #but only node 1 is started in this case
- global cluster_count
- cluster_count = 1
+ global clusterCount #number of nodes running
+ global ONOSIp #list of ONOS IP addresses
+ clusterCount = 1
+ ONOSIp = [ 0 ]
- checkout_branch = main.params['GIT']['checkout']
- git_pull = main.params['GIT']['autopull']
- cell_name = main.params['ENV']['cellName']
- BENCH_ip = main.params['BENCH']['ip1']
- BENCH_user = main.params['BENCH']['user']
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
- MN1_ip = main.params['MN']['ip1']
- main.log.step("Cleaning Enviornment...")
- main.ONOSbench.onos_uninstall(ONOS1_ip)
- main.ONOSbench.onos_uninstall(ONOS2_ip)
- main.ONOSbench.onos_uninstall(ONOS3_ip)
+ #Load values from params file
+ checkoutBranch = main.params[ 'GIT' ][ 'checkout' ]
+ gitPull = main.params[ 'GIT' ][ 'autopull' ]
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ Features= main.params[ 'ENV' ][ 'cellFeatures' ]
+ BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
+ BENCHUser = main.params[ 'BENCH' ][ 'user' ]
+ MN1Ip = main.params[ 'MN' ][ 'ip1' ]
+ maxNodes = int(main.params[ 'availableNodes' ])
+ Features = main.params[ 'ENV' ][ 'cellFeatures' ]
+ skipMvn = main.params[ 'TEST' ][ 'skipCleanInstall' ]
+
+ #Populate ONOSIp with ips from params
+ for i in range(1, maxNodes + 1):
+ ipString = 'ip' + str(i)
+ ONOSIp.append(main.params[ 'CTRL' ][ ipString ])
+
+ #############################
+ tempIp = [ ONOSIp[1],ONOSIp[2],ONOSIp[3],ONOSIp[4],ONOSIp[5]]
+ main.ONOSbench.createLinkGraphFile(BENCHIp, tempIp, str(7))
+
+ main.log.info("marker")
+ #############################
+
+
+ #kill off all onos processes
+ main.log.step("Safety check, killing all ONOS processes")
+ main.log.step("before initiating enviornment setup")
+ for node in range(1, maxNodes + 1):
+ main.ONOSbench.onosDie(ONOSIp[node])
+
+
+ #construct the cell file
+ main.log.info("Creating cell file")
+ exec "a = main.ONOSbench.createCellFile"
+ cellIp = []
+ for node in range (1, maxNodes + 1):
+ cellIp.append(ONOSIp[node])
+ a(BENCHIp,cellName,MN1Ip,str(Features), *cellIp)
+
+ #Uninstall everywhere
+ main.log.step( "Cleaning Enviornment..." )
+ for i in range(1, maxNodes + 1):
+ main.log.info(" Uninstalling ONOS " + str(i) )
+ main.ONOSbench.onosUninstall( ONOSIp[i] )
- main.step("Git checkout and pull "+checkout_branch)
- if git_pull == 'on':
- checkout_result = main.ONOSbench.git_checkout(checkout_branch)
- pull_result = main.ONOSbench.git_pull()
-
- else:
- checkout_result = main.TRUE
- pull_result = main.TRUE
- main.log.info("Skipped git checkout and pull")
+ #mvn clean install, for debugging set param 'skipCleanInstall' to yes to speed up test
+ if skipMvn != "yes":
+ mvnResult = main.ONOSbench.cleanInstall()
+
+ #git
+ main.step( "Git checkout and pull " + checkoutBranch )
+ if gitPull == 'on':
+ checkoutResult = main.ONOSbench.gitCheckout( checkoutBranch )
+ pullResult = main.ONOSbench.gitPull()
- mvn_result = main.ONOSbench.clean_install()
-
- main.step("Set cell for ONOS cli env")
- main.ONOS1cli.set_cell(cell_name)
- main.ONOS2cli.set_cell(cell_name)
- main.ONOS3cli.set_cell(cell_name)
+ else:
+ checkoutResult = main.TRUE
+ pullResult = main.TRUE
+ main.log.info( "Skipped git checkout and pull" )
- main.step("Creating ONOS package")
- package_result = main.ONOSbench.onos_package() #no file or directory
- main.step("Installing ONOS package")
- install1_result = main.ONOSbench.onos_install(node=ONOS1_ip)
-
- cell_name = main.params['ENV']['cellName']
- main.step("Applying cell file to environment")
- cell_apply_result = main.ONOSbench.set_cell(cell_name)
- main.step("verify cells")
- verify_cell_result = main.ONOSbench.verify_cell()
-
- main.step("Set cell for ONOS cli env")
- main.ONOS1cli.set_cell(cell_name)
- cli1 = main.ONOS1cli.start_onos_cli(ONOS1_ip)
-
-
- def CASE2(self, main):
-
- '''
- Increase number of nodes and initiate CLI
- '''
- import time
+ #main.step( "Set cell for ONOS cli env" )
+ #main.ONOS1cli.setCell( cellName )
- global cluster_count
+ main.step( "Creating ONOS package" )
+ packageResult = main.ONOSbench.onosPackage()
+
+ main.step( "Installing ONOS package" )
+ install1Result = main.ONOSbench.onosInstall( node=ONOSIp[1] )
+
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ main.step( "Applying cell file to environment" )
+ cellApplyResult = main.ONOSbench.setCell( cellName )
+ main.step( "verify cells" )
+ verifyCellResult = main.ONOSbench.verifyCell()
+
+ main.step( "Set cell for ONOS cli env" )
+ cli1 = main.ONOS1cli.startOnosCli( ONOSIp[1] )
+
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
- #ONOS4_ip = main.params['CTRL']['ip4']
- #ONOS5_ip = main.params['CTRL']['ip5']
- #ONOS6_ip = main.params['CTRL']['ip6']
- #ONOS7_ip = main.params['CTRL']['ip7']
- cell_name = main.params['ENV']['cellName']
- scale = int(main.params['SCALE'])
-
- #Cluster size increased everytime the case is defined
- cluster_count += scale
-
- main.log.report("Increasing cluster size to "+
- str(cluster_count))
- install_result = main.FALSE
+ def CASE2( self, main ):
+ # This case increases the cluster size by whatever scale is
+ # Note: 'scale' is the size of the step
+ # if scaling is not a part of your test, simply run this case
+ # once after CASE1 to set up your enviornment for your desired
+ # cluster size. If scaling is a part of you test call this case each time
+ # you want to increase cluster size
+
+ ''
+ 'Increase number of nodes and initiate CLI'
+ ''
+ import time
+ global clusterCount
- if scale == 2:
- if cluster_count == 3:
- main.log.info("Installing nodes 2 and 3")
- install2_result = main.ONOSbench.onos_install(node=ONOS2_ip)
- install3_result = main.ONOSbench.onos_install(node=ONOS3_ip)
- cli2 = main.ONOS1cli.start_onos_cli(ONOS2_ip)
- cli3 = main.ONOS1cli.start_onos_cli(ONOS3_ip)
+ BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
+ scale = int( main.params[ 'SCALE' ] )
+ clusterCount += scale
- '''
- elif cluster_count == 5:
-
- main.log.info("Installing nodes 4 and 5")
- node4_result = main.ONOSbench.onos_install(node=ONOS4_ip)
- node5_result = main.ONOSbench.onos_install(node=ONOS5_ip)
- install_result = node4_result and node5_result
- time.sleep(5)
-
- main.ONOS4cli.start_onos_cli(ONOS4_ip)
- main.ONOS5cli.start_onos_cli(ONOS5_ip)
-
- elif cluster_count == 7:
-
- main.log.info("Installing nodes 4 and 5")
- node6_result = main.ONOSbench.onos_install(node=ONOS6_ip)
- node7_result = main.ONOSbench.onos_install(node=ONOS7_ip)
- install_result = node6_result and node7_result
- time.sleep(5)
-
- main.ONOS6cli.start_onos_cli(ONOS6_ip)
- main.ONOS7cli.start_onos_cli(ONOS7_ip)
- '''
- if scale == 1:
- if cluster_count == 2:
- main.log.info("Installing node 2")
- install2_result = main.ONOSbench.onos_install(node=ONOS2_ip)
- cli2 = main.ONOS1cli.start_onos_cli(ONOS2_ip)
-
- if cluster_count == 3:
- main.log.info("Installing node 3")
- install3_result = main.ONOSbench.onos_install(node=ONOS3_ip)
- cli3 = main.ONOS1cli.start_onos_cli(ONOS3_ip)
+ main.log.report( "Increasing cluster size to " + str( clusterCount ) )
+ for node in range((clusterCount - scale) + 1, clusterCount + 1):
+ main.ONOSbench.onosDie(ONOSIp[node])
+ time.sleep(10)
+ main.log.info("Starting ONOS " + str(node) + " at IP: " + ONOSIp[node])
+ main.ONOSbench.onosInstall( node=ONOSIp[node])
+ exec "a = main.ONOS%scli.startOnosCli" %str(node)
+ a(ONOSIp[node])
+
diff --git a/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.topo b/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.topo
index 88c4d35..8bd5a9f 100644
--- a/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.topo
+++ b/TestON/tests/ScaleOutTemplate/ScaleOutTemplate.topo
@@ -37,13 +37,13 @@
<connect_order>4</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS3cli>
-
+
<ONOS1>
<host>10.128.5.51</host>
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
- <connect_order>5</connect_order>
+ <connect_order>9</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS1>
@@ -52,7 +52,7 @@
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
- <connect_order>6</connect_order>
+ <connect_order>10</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS2>
@@ -61,7 +61,7 @@
<user>sdn</user>
<password>rocks</password>
<type>OnosDriver</type>
- <connect_order>7</connect_order>
+ <connect_order>11</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS3>
@@ -70,7 +70,7 @@
<user>admin</user>
<password>onos_test</password>
<type>MininetCliDriver</type>
- <connect_order>8</connect_order>
+ <connect_order>16</connect_order>
<COMPONENTS>
<arg1> --custom ~/mininet/custom/topo-2sw-2host.py </arg1>
<arg2> --arp --mac --topo mytopo</arg2>
diff --git a/TestON/tests/TopoPerfNextBM/TopoPerfNextBM.params b/TestON/tests/TopoPerfNextBM/TopoPerfNextBM.params
new file mode 100644
index 0000000..09c741c
--- /dev/null
+++ b/TestON/tests/TopoPerfNextBM/TopoPerfNextBM.params
@@ -0,0 +1,93 @@
+<PARAMS>
+ <testcases>1,2,3,4,2,3,4,2,3,4,2,3</testcases>
+
+ <ENV>
+ <cellName>topo_perf_test</cellName>
+ <cellFeatures>"webconsole,onos-core,onos-api,onos-cli,onos-app-metrics,onos-app-gui,onos-openflow"</cellFeatures>
+ </ENV>
+
+ <GIT>
+ #autoPull 'on' or 'off'
+ <autoPull>off</autoPull>
+ <checkout>master</checkout>
+ </GIT>
+
+ <CTRL>
+ <user>sdn</user>
+ <ip1>10.254.1.201</ip1>
+ <port1>6633</port1>
+ <ip2>10.254.1.202</ip2>
+ <port2>6633</port2>
+ <ip3>10.254.1.203</ip3>
+ <port3>6633</port3>
+ <ip4>10.254.1.204</ip4>
+
+ <ip5>10.254.1.205</ip5>
+ <ip6>10.254.1.206</ip6>
+ <ip7>10.254.1.207</ip7>
+ </CTRL>
+
+ <MN>
+ <ip1>10.254.1.200</ip1>
+ <ip2>10.254.1.200</ip2>
+ </MN>
+
+ <BENCH>
+ <ip>10.254.1.200</ip>
+ </BENCH>
+
+ <TSHARK>
+ <ofpPortStatus>OF 1.3 146</ofpPortStatus>
+ <ofpRoleReply>OF 1.3 90 of_role_reply</ofpRoleReply>
+ <tcpSynAck>TCP 74 6633</tcpSynAck>
+ </TSHARK>
+
+ <TEST>
+ #'on' or 'off' debug mode.
+ #If on, logging will be more verbose and
+ #tshark pcap will be enabled
+ #pcap file located at /tmp/'capture_name'
+ <debugMode>on</debugMode>
+ <onosLogFile>/opt/onos/log/karaf*</onosLogFile>
+ <mci>off</mci>
+
+ <topoConfigFile>
+ single_topo_event_accumulator.cfg
+ </topoConfigFile>
+ <topoConfigName>
+ org.onlab.onos.net.topology.impl.DefaultTopologyProvider.cfg
+ </topoConfigName>
+
+ #Number of times to iterate each case
+ <numIter>10</numIter>
+ <numSwitch>2</numSwitch>
+ #Number of iterations to ignore initially
+ <iterIgnore>2</iterIgnore>
+
+ <singleSwThreshold>0,1000</singleSwThreshold>
+ <portUpThreshold>0,1000</portUpThreshold>
+ <portDownThreshold>0,1000</portDownThreshold>
+ <linkUpThreshold>0,10000</linkUpThreshold>
+ <linkDownThreshold>0,10000</linkDownThreshold>
+ <swDisc100Threshold>0,10000</swDisc100Threshold>
+
+ <tabletFile>tablets_3node.json</tabletFile>
+ </TEST>
+
+ <DB>
+ <postToDB>on</postToDB>
+ <portEventResultPath>
+ /home/admin/ONLabTest/TestON/tests/TopoPerfNextBM/portEventResultDb.log
+ </portEventResultPath>
+ <switchEventResultPath>
+ /home/admin/ONLabTest/TestON/tests/TopoPerfNextBM/switchEventResultDb.log
+ </switchEventResultPath>
+ </DB>
+
+ <JSON>
+ <deviceTimestamp>topologyDeviceEventTimestamp</deviceTimestamp>
+ <hostTimestamp>topologyHostEventTimestamp</hostTimestamp>
+ <linkTimestamp>topologyLinkEventTimestamp</linkTimestamp>
+ <graphTimestamp>topologyGraphEventTimestamp</graphTimestamp>
+ </JSON>
+</PARAMS>
diff --git a/TestON/tests/TopoPerfNextBM/TopoPerfNextBM.py b/TestON/tests/TopoPerfNextBM/TopoPerfNextBM.py
new file mode 100644
index 0000000..872238e
--- /dev/null
+++ b/TestON/tests/TopoPerfNextBM/TopoPerfNextBM.py
@@ -0,0 +1,1186 @@
+# 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])
+
+ #TODO: Look for 'role-request' messages,
+ # which replaces the 'vendor' messages previously seen
+ # on OVS 2.0.1
+ tsharkOfString = main.params[ 'TSHARK' ][ 'ofpRoleReply' ]
+ tsharkTcpString = main.params[ 'TSHARK' ][ 'tcpSynAck' ]
+ tsharkOfOutput = '/tmp/tshark_of_topo.txt'
+ tsharkTcpOutput = '/tmp/tshark_tcp_topo.txt'
+
+ latencyEndToEndList = []
+ latencyOfpToGraphList = []
+ latencyOfpToDeviceList = []
+ latencyT0ToDeviceList = []
+ latencyTcpToOfpList = []
+
+ endToEndLatNodeIter = numpy.zeros((clusterCount, int(numIter)))
+ ofpToGraphLatNodeIter = numpy.zeros((clusterCount, int(numIter)))
+ ofpToDeviceLatNodeIter = numpy.zeros((clusterCount, int(numIter)))
+
+ tcpToOfpLatIter = []
+ 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)
+
+ 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/')
+ 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()
+
+ os.system('scp ' + ONOSUser + '@' +
+ ONOS1Ip + ':' + tsharkOfOutput + ' /tmp/')
+
+ 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()
+
+ 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)
+ deltaTcpOfp1 = 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')
+ else:
+ tcpToOfpLatIter.append(0)
+ main.log.info('ONOS1 iter' + str(i) +
+ ' tcp-to-ofp: ' + str(deltaTcpOfp1) +
+ ' ms - ignored this iteration')
+ 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')
+ else:
+ main.log.info('ONOS1 iter' + str(i) +
+ ' end-to-end: ' + str(deltaGraph1) +
+ ' ms - ignored this iteration')
+ 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))
+ 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
+ endToEndList = []
+ ofpToGraphList = []
+ ofpToDeviceList = []
+ dbCmdList = []
+ for node in range(0, clusterCount):
+ 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)
+
+ endToEndAvg = round(numpy.mean(endToEndList), 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(' 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()
+
+ 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')
+ else:
+ main.log.info('ONOS1 iter' + str(i) +
+ ' skipped. Result: ' +
+ 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')
+ else:
+ main.log.info('ONOS1 iter' + str(i) +
+ ' skipped. Result: ' +
+ 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')
+ else:
+ main.log.info('ONOS1 Link-to-ofp skipped. Result: ' +
+ 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()
+ 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')
+ else:
+ main.log.info('ONOS1 iter' + str(i) +
+ ' skipped. Result: ' +
+ 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')
+ else:
+ main.log.info('ONOS1 iter' + str(i) +
+ ' skipped. Result: ' +
+ 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 ptUpGraphToOfp5 > upThresholdMin and\
+ ptUpGraphToOfp5 < upThresholdMax and i > iterIgnore:
+ portUpGraphNodeIter[4][i] = ptUpGraphToOfp5
+ main.log.info('ONSO5 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 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']
+ ptUpGraphToOfp6 = int(graphTimestamp6) - int(timestampBeginPtUp)
+ ptUpGraphToOfp7 = int(graphTimestamp7) - int(timestampBeginPtUp)
+ ptUpDeviceToOfp6 = int(deviceTimestamp6) - int(timestampBeginPtUp)
+ ptUpDeviceToOfp7 = int(deviceTimestamp7) - int(timestampBeginPtUp)
+ if ptUpGraphToOfp6 > upThresholdMin and\
+ ptUpGraphToOfp6 < upThresholdMax and i > iterIgnore:
+ portUpGraphNodeIter[5][i] = ptUpGraphToOfp6
+ main.log.info('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('iter' + str(i) +
+ ' port up device-to-ofp: ' +
+ str(ptUpDeviceToOfp6) + ' ms')
+ if ptUpGraphToOfp7 > upThresholdMin and \
+ ptUpGraphToOfp7 < upThresholdMax and i > iterIgnore:
+ portUpGraphNodeIter[6][i] = ptUpGraphToOfp7
+ main.log.info('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('iter' + str(i) +
+ ' port up device-to-ofp: ' +
+ str(ptUpDeviceToOfp7) + ' ms')
+
+ dbCmdList = []
+ for node in range(0, clusterCount):
+ portUpDevList = []
+ portUpGraphList = []
+ portDownDevList = []
+ portDownGraphList = []
+ portUpDevAvg = 0
+ portUpGraphAvg = 0
+ portDownDevAvg = 0
+ portDownGraphAvg = 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 portDownDevNodeIter[node]:
+ if item > 0.0:
+ portDownDevList.append(item)
+
+ for item in portDownGraphNodeIter[node]:
+ if item > 0.0:
+ portDownGraphList.append(item)
+
+ portUpDevAvg = round(numpy.mean(portUpDevList), 2)
+ portUpGraphAvg = round(numpy.mean(portUpGraphList), 2)
+ portDownDevAvg = round(numpy.mean(portDownDevList), 2)
+ portDownGraphAvg = round(numpy.mean(portDownGraphList), 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(round(portUpDevAvg, 2)) + ' ms')
+ main.log.report(' Port up ofp-to-graph ' +
+ str(portUpGraphAvg) + ' 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')
+ 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) ])
+
diff --git a/TestON/tests/TopoPerfNextBM/TopoPerfNextBM.topo b/TestON/tests/TopoPerfNextBM/TopoPerfNextBM.topo
new file mode 100644
index 0000000..a92e391
--- /dev/null
+++ b/TestON/tests/TopoPerfNextBM/TopoPerfNextBM.topo
@@ -0,0 +1,163 @@
+<TOPOLOGY>
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1cli>
+
+ <ONOS2cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2cli>
+
+ <ONOS3cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS3cli>
+
+ <ONOS4cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4cli>
+
+ <ONOS5cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>6</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5cli>
+
+ <ONOS6cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>7</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6cli>
+
+ <ONOS7cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>8</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7cli>
+
+ <ONOS1>
+ <host>10.254.1.201</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>9</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.254.1.202</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>10</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <ONOS3>
+ <host>10.254.1.203</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>11</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS3>
+
+ <ONOS4>
+ <host>10.254.1.204</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>12</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4>
+
+ <ONOS5>
+ <host>10.254.1.205</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>13</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5>
+
+ <ONOS6>
+ <host>10.254.1.206</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>14</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6>
+
+ <ONOS7>
+ <host>10.254.1.207</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>15</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7>
+
+ <Mininet1>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>MininetCliDriver</type>
+ <connect_order>16</connect_order>
+ <COMPONENTS>
+ <arg1> --custom topo-perf-2sw.py </arg1>
+ <arg2> --arp --mac --topo mytopo</arg2>
+ <arg3> </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet1>
+
+ <Mininet2>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>17</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </Mininet2>
+
+ </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/IntentsLoad/__init__.py b/TestON/tests/flowTP1g/__init__.py
similarity index 100%
copy from TestON/tests/IntentsLoad/__init__.py
copy to TestON/tests/flowTP1g/__init__.py
diff --git a/TestON/tests/flowTP1g/flowTP1g.params b/TestON/tests/flowTP1g/flowTP1g.params
new file mode 100644
index 0000000..93b3923
--- /dev/null
+++ b/TestON/tests/flowTP1g/flowTP1g.params
@@ -0,0 +1,73 @@
+<PARAMS>
+
+ <testcases>1,3</testcases>
+
+ <isOnBaremetal>true</isOnBaremetal>
+ <SCALE>1</SCALE>
+ <availableNodes>7</availableNodes>
+
+
+
+ <ENV>
+ <cellName>flowTP</cellName>
+ <cellFeatures>webconsole,onos-core,onos-api,onos-cli,onos-null,onos-app-demo,onos-rest,onos-app-metrics,onos-app-metrics-intent,onos-app-metrics-topology</cellFeatures>
+ </ENV>
+
+ <TEST>
+ <skipCleanInstall>yes</skipCleanInstall>
+ <warmUp>4</warmUp> #number of runs to warm up the system
+ <sampleSize>20</sampleSize> #number of runs to take data from
+ <neighbors>6</neighbors> #list of number of neighbors
+ <servers>7</servers> #list of servers
+ <flows>122500</flows>
+ <switches>35</switches>
+
+ <testCMD0>flow-tester.py -f</testCMD0> #base command
+ <testCMD1> -n </testCMD1> #neighbors
+
+ </TEST>
+
+ <GIT>
+ <autopull>on</autopull>
+ <checkout>master</checkout>
+ </GIT>
+
+ <CTRL>
+ <USER>admin</USER>
+
+ <ip1>10.254.1.201</ip1>
+ <port1>6633</port1>
+
+ <ip2>10.254.1.202</ip2>
+ <port2>6633</port2>
+
+ <ip3>10.254.1.203</ip3>
+ <port3>6633</port3>
+
+ <ip4>10.254.1.204</ip4>
+ <port4>6633</port4>
+
+ <ip5>10.254.1.205</ip5>
+ <port5>6633</port5>
+
+ <ip6>10.254.1.206</ip6>
+ <port6>6633</port6>
+
+ <ip7>10.254.1.207</ip7>
+ <port7>6633</port7>
+
+ </CTRL>
+
+ <MN>
+ <ip1>10.254.1.200</ip1>
+ </MN>
+
+ <BENCH>
+ <user>admin</user>
+ <ip1>10.254.1.200</ip1>
+ </BENCH>
+
+ <JSON>
+ </JSON>
+
+</PARAMS>
diff --git a/TestON/tests/flowTP1g/flowTP1g.py b/TestON/tests/flowTP1g/flowTP1g.py
new file mode 100644
index 0000000..b8450fd
--- /dev/null
+++ b/TestON/tests/flowTP1g/flowTP1g.py
@@ -0,0 +1,412 @@
+# ScaleOutTemplate -> flowTP
+#
+# CASE1 starts number of nodes specified in param file
+#
+# cameron@onlab.us
+
+import sys
+import os.path
+
+
+class flowTP1g:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE1( self, main ): #This is the initialization case
+ #this case will clean up all nodes
+ #but only node 1 is started in this case
+
+ global clusterCount #number of nodes running
+ global ONOSIp #list of ONOS IP addresses
+ clusterCount = 1
+ ONOSIp = [ 0 ]
+
+
+ #Load values from params file
+ checkoutBranch = main.params[ 'GIT' ][ 'checkout' ]
+ gitPull = main.params[ 'GIT' ][ 'autopull' ]
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ Features= main.params[ 'ENV' ][ 'cellFeatures' ]
+ BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
+ BENCHUser = main.params[ 'BENCH' ][ 'user' ]
+ MN1Ip = main.params[ 'MN' ][ 'ip1' ]
+ maxNodes = int(main.params[ 'availableNodes' ])
+ Features = main.params[ 'ENV' ][ 'cellFeatures' ]
+ skipMvn = main.params[ 'TEST' ][ 'skipCleanInstall' ]
+
+ main.ONOSbench.handle.sendline("export TERM=vt100")
+
+ #Populate ONOSIp with ips from params
+ for i in range(1, maxNodes + 1):
+ ipString = 'ip' + str(i)
+ ONOSIp.append(main.params[ 'CTRL' ][ ipString ])
+
+ #kill off all onos processes
+ main.log.step("Safety check, killing all ONOS processes")
+ main.log.step("before initiating enviornment setup")
+ for node in range(1, maxNodes + 1):
+ main.ONOSbench.onosDie(ONOSIp[node])
+
+
+ #construct the cell file
+ main.log.info("Creating initial cell file")
+ exec "a = main.ONOSbench.createCellFile"
+ cellIp = []
+ for node in range(1, 2):
+ #for node in range (1, maxNodes + 1):
+ cellIp.append(ONOSIp[node])
+ a(BENCHIp,cellName,MN1Ip,str(Features), *cellIp)
+
+ main.log.info(cellIp)
+
+ #Uninstall everywhere
+ #main.log.step( "Cleaning Enviornment..." )
+ #for i in range(1, maxNodes + 1):
+ # main.log.info(" Uninstalling ONOS " + str(i) )
+ # main.ONOSbench.onosUninstall( ONOSIp[i] )
+
+ #mvn clean install, for debugging set param 'skipCleanInstall' to yes to speed up test
+ if skipMvn != "yes":
+ 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( "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=ONOSIp[1] )
+
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ main.step( "Applying cell file to environment" )
+ cellApplyResult = main.ONOSbench.setCell( cellName )
+ main.step( "verify cells" )
+ verifyCellResult = main.ONOSbench.verifyCell()
+
+ #main.step( "Set cell for ONOS cli env" )
+ #cli1 = main.ONOS1cli.startOnosCli( node=ONOSIp[1] )
+
+ def CASE2( self, main ):
+ # This case increases the cluster size by whatever scale is
+ # Note: 'scale' is the size of the step
+ # if scaling is not a part of your test, simply run this case
+ # once after CASE1 to set up your enviornment for your desired
+ # cluster size. If scaling is a part of you test call this case each time
+ # you want to increase cluster size
+
+ ''
+ 'Increase number of nodes and initiate CLI'
+ ''
+ import time
+ global clusterCount
+
+ scale = int( main.params[ 'SCALE' ] )
+ clusterCount += scale
+
+ main.log.report( "Increasing cluster size to " + str( clusterCount ) )
+ for node in range((clusterCount - scale) + 1, clusterCount + 1):
+ main.ONOSbench.onosDie(ONOSIp[node])
+ time.sleep(10)
+ main.log.info("Starting ONOS " + str(node) + " at IP: " + ONOSIp[node])
+ main.ONOSbench.onosInstall( node=ONOSIp[node])
+ exec "a = main.ONOS%scli.startOnosCli" %str(node)
+ a(ONOSIp[node])
+
+
+ def CASE3( self, main ):
+ #
+ # This is the flow TP test
+ #
+ import os.path
+ import numpy
+ import math
+ import time
+ import datetime
+ import traceback
+
+ testCMD = [ 0,0,0,0 ]
+ warmUp = int(main.params[ 'TEST' ][ 'warmUp' ])
+ sampleSize = int(main.params[ 'TEST' ][ 'sampleSize' ])
+ switches = int(main.params[ 'TEST' ][ 'switches' ])
+ neighborList = main.params[ 'TEST' ][ 'neighbors' ]
+ serverList = main.params[ 'TEST' ][ 'servers' ]
+ #flows = int(main.params[ 'TEST' ][ 'flows' ])
+ testCMD[0] = main.params[ 'TEST' ][ 'testCMD0' ]
+ testCMD[1] = main.params[ 'TEST' ][ 'testCMD1' ]
+ maxNodes = main.params[ 'availableNodes' ]
+ onBaremetal = main.params['isOnBaremetal']
+
+
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ Features= main.params[ 'ENV' ][ 'cellFeatures' ]
+ BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
+ BENCHUser = main.params[ 'BENCH' ][ 'user' ]
+ MN1Ip = main.params[ 'MN' ][ 'ip1' ]
+ maxNodes = int(main.params[ 'availableNodes' ])
+ Features = main.params[ 'ENV' ][ 'cellFeatures' ]
+ homeDir = os.path.expanduser('~')
+
+ serverList = serverList.split(",")
+ main.log.info("serverlist: " + str(serverList))
+ neighborList = neighborList.split(",")
+ main.log.info("neightborlist: " + str(neighborList))
+
+ ts = time.time()
+ st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
+ logFileName = "../logs/flowTPResultsLog" + str(st)
+
+ #initialize log file, remove any previous data
+ resultsLog = open("flowTPResultsLog","w+")
+ resultsLog.close()
+
+ #write file to change mem limit to 32 gigs (BAREMETAL ONLY!)
+ if onBaremetal == "true":
+ filename = "/onos/tools/package/bin/onos-service"
+ serviceConfig = open(homeDir + filename, 'w+')
+ serviceConfig.write("#!/bin/bash\n ")
+ serviceConfig.write("#------------------------------------- \n ")
+ serviceConfig.write("# Starts ONOS Apache Karaf container\n ")
+ serviceConfig.write("#------------------------------------- \n ")
+ serviceConfig.write("#export JAVA_HOME=${JAVA_HOME:-/usr/lib/jvm/java-7-openjdk-amd64/}\n ")
+ serviceConfig.write("""export JAVA_OPTS="${JAVA_OPTS:--Xms256m -Xmx8G}" \n """)
+ serviceConfig.write("")
+ serviceConfig.write("ONOS_HOME=/opt/onos \n ")
+ serviceConfig.write("")
+ serviceConfig.write("[ -d $ONOS_HOME ] && cd $ONOS_HOME || ONOS_HOME=$(dirname $0)/..\n")
+ serviceConfig.write("""${ONOS_HOME}/apache-karaf-$KARAF_VERSION/bin/karaf "$@" \n """)
+ serviceConfig.close()
+
+ for n in neighborList:
+ for servers in serverList:
+ main.log.step("\tSTARTING TEST")
+ main.log.step("\tSERVERS: \t" + servers )
+ main.log.step("\tNEIGHBORS:\t" + n )
+ main.log.info("=============================================================")
+ main.log.info("=============================================================")
+ #write file to configure nil link
+ ipCSV = ""
+ for i in range (1, int(maxNodes) + 1):
+ tempstr = "ip" + str(i)
+ ipCSV += main.params[ 'CTRL' ][ tempstr ]
+ if i < int(maxNodes):
+ ipCSV +=","
+
+ filename = "/onos/tools/package/etc/org.onosproject.provider.nil.link.impl.NullLinkProvider.cfg"
+ linkConfig = open(homeDir + filename,'w+')
+ linkConfig.write("# eventRate = 2000\n")
+ linkConfig.write("neighbors = " + ipCSV)
+ main.log.info(" NullLinkProvider.cfg: " + ipCSV)
+ linkConfig.close()
+
+
+ #write file for null device
+ filename = "/onos/tools/package/etc/org.onosproject.provider.nil.device.impl.NullDeviceProvider.cfg"
+ deviceConfig = open(homeDir + filename,'w+')
+
+ serversToRun = max(int(servers), (int(n) + 1))
+
+ switchDistribution = [(switches/int(serversToRun))]*int(serversToRun)
+ main.log.info("Switch distribution init: " + str(switchDistribution))
+ remainder = switches % int(serversToRun)
+ for r in range(0, remainder):
+ switchDistribution[r] += 1
+ main.log.info("Switch distribution: " + str(switchDistribution))
+
+ deviceSettings = ""
+ for i in range(0, serversToRun):
+ deviceSettings += (ONOSIp[i+1] + ":" + str(switchDistribution[i]))
+ if i < int(serversToRun)-1:
+ deviceSettings +=","
+
+ deviceConfig.write("devConfigs = " + deviceSettings)
+ main.log.info(" NullDeviceProvider.cfg: " + deviceSettings)
+ deviceConfig.close()
+
+ main.log.info("Creating cell file for this step")
+ exec "a = main.ONOSbench.createCellFile"
+ cellIp = []
+ for node in range (1, serversToRun + 1):
+ cellIp.append(ONOSIp[node])
+ main.log.info("Cells are: " + str(cellIp) )
+ a(BENCHIp,cellName,MN1Ip,str(Features), *cellIp)
+ main.step( "Applying cell file to environment for this step" )
+ cellApplyResult = main.ONOSbench.setCell( cellName )
+ main.step( "verify cells for this step" )
+ verifyCellResult = main.ONOSbench.verifyCell()
+
+ #devide flows
+ flows = int(main.params[ 'TEST' ][ 'flows' ])
+ main.log.info("Flow Target = " + str(flows))
+
+ flows = (flows *max(int(n)+1,int(servers)))/((int(n) + 1)*int(servers)*(switches))
+
+ main.log.info("Flows per switch = " + str(flows))
+ #main.log.info("Total flows = " + str(switches * flows))
+
+
+ #kill off all onos processes
+ main.log.step("Safety check, killing all ONOS processes")
+ for node in range(1, int(maxNodes) + 1):
+ main.ONOSbench.onosDie(ONOSIp[node])
+
+ #Uninstall everywhere
+ main.log.step( "Cleaning Enviornment..." )
+ for i in range(1, int(maxNodes) + 1):
+ main.log.info(" Uninstalling ONOS " + str(i) )
+ main.ONOSbench.onosUninstall( ONOSIp[i] )
+
+ #package
+ main.log.step( "Repackaging onos to reflect config file changes" )
+ main.ONOSbench.onosPackage()
+
+ # install on relevant nodes
+ startNodes = max(int(n), serversToRun)
+ main.log.step( "Reinstalling ONOS on relevant nodes (1-" + str(startNodes) + ")" )
+ for s in range(1, startNodes + 1):
+ main.ONOSbench.onosInstall( node=ONOSIp[s])
+ exec "a = main.ONOS%scli.startOnosCli" %str(s)
+ a(ONOSIp[s])
+
+ main.log.info("sleeping 30 second waiting for null provider bundle...")
+ time.sleep(30)
+
+ #build list of servers in "$OC1, $OC2...." format
+ serverEnvVars = ""
+ for i in range (1,int(servers)+1):
+ serverEnvVars += ("-s " + ONOSIp[i] + " ")
+
+ data = [[""]*int(servers)]*int(sampleSize)
+ maxes = [""]*int(sampleSize)
+
+ for test in range(0, (warmUp + sampleSize)):
+ flowCMD = "python3 " + homeDir + "/onos/tools/test/bin/"
+ flowCMD += testCMD[0] + " " + str(flows) + " " + testCMD[1]
+ flowCMD += " " + str(n) + " " + str(serverEnvVars)
+ print("\n")
+ main.log.info("COMMAND: " + flowCMD)
+ main.log.info("Executing command")
+ main.ONOSbench.handle.sendline(flowCMD)
+ result = []
+ for s in range(0, int(servers)):
+ result.append("q")
+
+ for s in range(0, int(servers)):
+ main.ONOSbench.handle.expect("ms")
+ rawResult = ((main.ONOSbench.handle.before).splitlines())
+
+ rawResult = ((rawResult.pop()).split(" "))
+ main.log.info("Debug: rawResult: " + str(rawResult))
+
+ myresult = int(rawResult[2])
+ main.log.info("Result: " + str(myresult))
+
+ myIp = rawResult[0]
+ main.log.info("myIp: " + myIp)
+
+ serverIndex = int(ONOSIp.index(myIp))
+ main.log.info("server index = " + str(serverIndex))
+
+ result[serverIndex - 1] = myresult
+
+ if test >= warmUp:
+ maxes[test-warmUp] = max(result)
+ main.log.info("Data collection iteration: " + str(test-warmUp) + " of " + str(sampleSize))
+ main.log.info("Throughput time: " + str(maxes[test-warmUp]) + "(ms)")
+
+ if test >= warmUp:
+ data[test-warmUp] = result
+
+ # wait for flows = 0
+ removedFlows = False
+ repeat = 0
+ time.sleep(3)
+ while removedFlows == False & repeat <= 10:
+ main.ONOSbench.handle.sendline("onos $OC1 summary| cut -d ' ' -f6")
+ main.ONOSbench.handle.expect("~")
+ before = main.ONOSbench.handle.before
+ parseTest = before.splitlines()
+ flowsummary = ""
+ for line in parseTest:
+ if "flow" in str(line):
+ flowsummary = line
+ break
+ currentflow = ""
+ for word in flowsummary.split(" "):
+ if "flow" in str(word):
+ currentflow = str(word)
+ currentflow = currentflow.replace(",","")
+ currentflow = currentflow.replace("\n","")
+ main.log.info(currentflow)
+
+ zeroFlow = "flows=0"
+ if zeroFlow in before:
+ removedFlows = True
+ main.log.info("\t Wait 5 sec of cool down...")
+ time.sleep(5)
+
+ time.sleep(5)
+ repeat +=1
+
+ main.log.info("raw data: " + str(data))
+ main.log.info("maxes:" + str(maxes))
+
+
+ # report data
+ print("")
+ main.log.info("\t Results (measurments are in milliseconds)")
+ print("")
+
+ nodeString = ""
+ for i in range(1, int(servers) + 1):
+ nodeString += ("\tNode " + str(i))
+
+ for test in range(0, sampleSize ):
+ main.log.info("\t Test iteration " + str(test + 1) )
+ main.log.info("\t------------------")
+ main.log.info(nodeString)
+ resultString = ""
+
+ for i in range(0, int(servers) ):
+ resultString += ("\t" + str(data[test][i]) )
+ main.log.info(resultString)
+
+ print("\n")
+
+ avgOfMaxes = numpy.mean(maxes)
+ main.log.info("Average of max value from each test iteration: " + str(avgOfMaxes))
+
+ stdOfMaxes = numpy.std(maxes)
+ main.log.info("Standard Deviation of max values: " + str(stdOfMaxes))
+ print("\n\n")
+
+ avgTP = int(main.params[ 'TEST' ][ 'flows' ]) / avgOfMaxes #result in kflows/second
+
+ tp = []
+ for i in maxes:
+ tp.append((int(main.params[ 'TEST' ][ 'flows' ]) / i ))
+
+ stdTP = numpy.std(tp)
+
+ main.log.info("Average thoughput: " + str(avgTP) + " Kflows/second" )
+ main.log.info("Standard deviation of throughput: " + str(stdTP) + " Kflows/second")
+
+ resultsLog = open(logFileName,"a")
+ resultsLog.write(str(main.params[ 'TEST' ][ 'flows' ]) + "," + n + "," + str(servers) + str(switches) + "," + str(warmUp))
+ resultsLog.write("," +str(sampleSize) + "," + str(avgTP) + "," + str(stdTP) + "\n")
+ resultsLog.close()
+
+
diff --git a/TestON/tests/flowTP1g/flowTP1g.topo b/TestON/tests/flowTP1g/flowTP1g.topo
new file mode 100644
index 0000000..0e45e0f
--- /dev/null
+++ b/TestON/tests/flowTP1g/flowTP1g.topo
@@ -0,0 +1,146 @@
+<TOPOLOGY>
+
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS><home>~/onos</home></COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1cli>
+
+ <ONOS2cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2cli>
+
+ <ONOS3cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS3cli>
+
+ <ONOS4cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4cli>
+
+ <ONOS5cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>6</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5cli>
+
+ <ONOS6cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>7</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6cli>
+
+ <ONOS7cli>
+ <host>10.254.1.200</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>8</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7cli>
+
+ <ONOS1>
+ <host>10.254.1.201</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>9</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.254.1.202</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>10</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <ONOS3>
+ <host>10.254.1.203</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>11</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS3>
+
+ <ONOS4>
+ <host>10.254.1.204</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>12</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4>
+
+
+ <ONOS5>
+ <host>10.254.1.205</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>13</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5>
+
+ <ONOS6>
+ <host>10.254.1.206</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>14</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6>
+
+ <ONOS7>
+ <host>10.254.1.207</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>15</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7>
+
+ </COMPONENT>
+
+</TOPOLOGY>
+
+
+
diff --git a/TestON/tests/IntentsLoad/__init__.py b/TestON/tests/pushTestIntents/__init__.py
similarity index 100%
copy from TestON/tests/IntentsLoad/__init__.py
copy to TestON/tests/pushTestIntents/__init__.py
diff --git a/TestON/tests/pushTestIntents/pushTestIntents.params b/TestON/tests/pushTestIntents/pushTestIntents.params
new file mode 100644
index 0000000..c6b79d5
--- /dev/null
+++ b/TestON/tests/pushTestIntents/pushTestIntents.params
@@ -0,0 +1,66 @@
+<PARAMS>
+
+ <testcases>1,2,3,2,3,2,3</testcases>
+
+ <SCALE>2</SCALE>
+ <availableNodes>7</availableNodes>
+
+ <ENV>
+ <cellName>defaultCell</cellName>
+ <cellFeatures>webconsole,onos-core,onos-api,onos-cli,onos-null,onos-gui,onos-rest,onos-app-metrics,onos-app-metrics-intent,onos-app-metrics-topology </cellFeatures>
+ </ENV>
+
+ <TEST>
+ <skipCleanInstall>yes</skipCleanInstall>
+ <switchCount>7</switchCount>
+ <warmUp>4</warmUp>
+ <sampleSize>10</sampleSize>
+ <wait></wait>
+ <intents>1,1000</intents> #list format, will be split on ','
+ <debug></debug> #empty for false/no
+ </TEST>
+
+ <GIT>
+ <autopull>on</autopull>
+ <checkout>master</checkout>
+ </GIT>
+
+ <CTRL>
+ <USER>admin</USER>
+
+ <ip1>10.128.5.51</ip1>
+ <port1>6633</port1>
+
+ <ip2>10.128.5.52</ip2>
+ <port2>6633</port2>
+
+ <ip3>10.128.5.53</ip3>
+ <port3>6633</port3>
+
+ <ip4>10.128.5.54</ip4>
+ <port4>6633</port4>
+
+ <ip5>10.128.5.65</ip5>
+ <port5>6633</port5>
+
+ <ip6>10.128.5.66</ip6>
+ <port6>6633</port6>
+
+ <ip7>10.128.5.67</ip7>
+ <port7>6633</port7>
+
+ </CTRL>
+
+ <MN>
+ <ip1>10.128.5.59</ip1>
+ </MN>
+
+ <BENCH>
+ <user>admin</user>
+ <ip1>10.128.5.55</ip1>
+ </BENCH>
+
+ <JSON>
+ </JSON>
+
+</PARAMS>
diff --git a/TestON/tests/pushTestIntents/pushTestIntents.py b/TestON/tests/pushTestIntents/pushTestIntents.py
new file mode 100644
index 0000000..d5623cf
--- /dev/null
+++ b/TestON/tests/pushTestIntents/pushTestIntents.py
@@ -0,0 +1,260 @@
+# ScaleOutTemplate
+#
+# CASE1 starts number of nodes specified in param file
+#
+# cameron@onlab.us
+
+import sys
+import os.path
+
+
+class pushTestIntents:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE1( self, main ): #This is the initialization case
+ #this case will clean up all nodes
+ import time #but only node 1 is started in this case
+
+ global clusterCount #number of nodes running
+ global ONOSIp #list of ONOS IP addresses
+ clusterCount = 1
+ ONOSIp = [ 0 ]
+
+
+ #Load values from params file
+ checkoutBranch = main.params[ 'GIT' ][ 'checkout' ]
+ gitPull = main.params[ 'GIT' ][ 'autopull' ]
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ Features= main.params[ 'ENV' ][ 'cellFeatures' ]
+ BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
+ BENCHUser = main.params[ 'BENCH' ][ 'user' ]
+ MN1Ip = main.params[ 'MN' ][ 'ip1' ]
+ maxNodes = int(main.params[ 'availableNodes' ])
+ Features = main.params[ 'ENV' ][ 'cellFeatures' ]
+ skipMvn = main.params[ 'TEST' ][ 'skipCleanInstall' ]
+ switchCount = main.params[ 'TEST' ][ 'switchCount' ]
+
+ #Populate ONOSIp with ips from params
+ for i in range(1, maxNodes + 1):
+ ipString = 'ip' + str(i)
+ ONOSIp.append(main.params[ 'CTRL' ][ ipString ])
+
+ tempIp = []
+ for node in range( 1, clusterCount + 1):
+ tempIp.append(ONOSIp[node])
+
+ #kill off all onos processes
+ main.log.step("Safety check, killing all ONOS processes")
+ main.log.step("before initiating enviornment setup")
+ for node in range(1, maxNodes + 1):
+ main.ONOSbench.onosDie(ONOSIp[node])
+
+ #construct the cell file
+ main.log.info("Creating cell file")
+ exec "a = main.ONOSbench.createCellFile"
+ cellIp = []
+ for node in range (1, clusterCount + 1):
+ cellIp.append(ONOSIp[node])
+ a(BENCHIp,cellName,MN1Ip,str(Features), *cellIp)
+
+ main.step( "Applying cell file to environment" )
+ cellApplyResult = main.ONOSbench.setCell( cellName )
+
+ #Uninstall everywhere
+ main.log.step( "Cleaning Enviornment..." )
+ for i in range(1, maxNodes + 1):
+ main.log.info(" Uninstalling ONOS " + str(i) )
+ main.ONOSbench.onosUninstall( ONOSIp[i] )
+
+ #mvn clean install, for debugging set param 'skipCleanInstall' to yes to speed up test
+ if skipMvn != "yes":
+ 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.ONOSbench.createLinkGraphFile(BENCHIp, tempIp, switchCount)
+ main.ONOSbench.createNullDevProviderFile(BENCHIp, tempIp, switchCount)
+ main.ONOSbench.createNullLinkProviderFile(BENCHIp)
+
+ main.step( "Creating ONOS package" )
+ packageResult = main.ONOSbench.onosPackage()
+
+ main.step( "Installing ONOS package" )
+ install1Result = main.ONOSbench.onosInstall( node=ONOSIp[1] )
+
+ main.step( "verify cells" )
+ verifyCellResult = main.ONOSbench.verifyCell()
+
+ main.step( "Set cell for ONOS cli env" )
+ cli1 = main.ONOS1cli.startOnosCli( ONOSIp[1] )
+
+
+ def CASE2( self, main ):
+ # This case increases the cluster size by whatever scale is
+ # Note: 'scale' is the size of the step
+ # if scaling is not a part of your test, simply run this case
+ # once after CASE1 to set up your enviornment for your desired
+ # cluster size. If scaling is a part of you test call this case each time
+ # you want to increase cluster size
+
+ ''
+ 'Increase number of nodes and initiate CLI'
+ ''
+ import time
+ global clusterCount
+
+ BENCHIp = main.params[ 'BENCH' ][ 'ip1' ]
+ scale = int( main.params[ 'SCALE' ] )
+ clusterCount += scale
+ switchCount = main.params[ 'TEST' ][ 'switchCount' ]
+
+ main.log.info("Creating cell file")
+ exec "a = main.ONOSbench.createCellFile"
+ cellIp = []
+ for node in range (1, clusterCount + 1):
+ cellIp.append(ONOSIp[node])
+ a(BENCHIp,cellName,MN1Ip,str(Features), *cellIp)
+
+ main.step( "Applying cell file to environment" )
+ cellApplyResult = main.ONOSbench.setCell( cellName )
+
+ #Uninstall everywhere
+ main.log.step( "Cleaning Enviornment..." )
+ for node in range(1, maxNodes + 1):
+ main.ONOSbench.onosDie(ONOSIp[node])
+ main.log.info(" Uninstalling ONOS " + str(node) )
+ main.ONOSbench.onosUninstall( ONOSIp[node] )
+
+ tempIp = []
+ for node in range( 1, clusterCount + 1):
+ tempIp.append(ONOSIp[node])
+
+ main.ONOSbench.createLinkGraphFile(BENCHIp, tempIp, switchCount)
+ main.ONOSbench.createNullDevProviderFile(BENCHIp, tempIp, switchCount)
+ main.ONOSbench.createNullLinkProviderFile(BENCHIp)
+
+ main.ONOSbench.onosPackage()
+
+ main.log.report( "Increasing cluster size to " + str( clusterCount ) )
+ for node in range(1, clusterCount + 1):
+ main.log.info("Starting ONOS " + str(node) + " at IP: " + ONOSIp[node])
+ main.ONOSbench.onosInstall( node=ONOSIp[node])
+ if node == 1:
+ main.ONOS1cli.startOnosCli( ONOSIp[1] )
+
+ for node in range(1, clusterCount + 1):
+ for i in range( 2 ):
+ isup = main.ONOSbench.isup( ONOSIp[node] )
+ if isup:
+ main.log.info("ONOS " + str(node) + " is up\n")
+ break
+ if not isup:
+ main.log.report( "ONOS " + str(node) + " didn't start!" )
+
+ def CASE3( self, main ):
+
+ import time
+ import numpy
+
+
+ sampleSize = int(main.params[ 'TEST' ][ 'sampleSize' ])
+ warmUp = int(main.params[ 'TEST' ][ 'warmUp' ])
+ intentsList = (main.params[ 'TEST' ][ 'intents' ]).split(",")
+ switchCount = int(main.params[ 'TEST' ][ 'switchCount' ])
+ debug = main.params[ 'TEST' ][ 'switchCount' ]
+ for i in range(0,len(intentsList)):
+ intentsList[i] = int(intentsList[i])
+
+
+ linkCount = 0
+ while True:
+ main.ONOSbench.handle.sendline("onos $OC1 links|wc -l")
+ main.ONOSbench.handle.expect(":~")
+ linkCount = main.ONOSbench.handle.before
+ if debug: main.log.info("Link Count check: " + linkCount)
+ if str((switchCount*2)-2) in linkCount:
+ break
+
+ links = "--"
+ while "=null:" not in links:
+ if debug: main.log.info("top of loop")
+ main.ONOSbench.handle.sendline("onos $OC1 links")
+ main.ONOSbench.handle.expect(":~")
+ links = main.ONOSbench.handle.before
+ if debug: main.log.info(str(links))
+ time.sleep(1)
+ links = links.splitlines()
+ templinks = links
+
+ tempDevices = []
+ for line in links:
+ temp = line.split(" ")
+ temp[0].replace("src=","")
+ temp[0] = (temp[0].split("/"))[0]
+ tempDevices.append(temp[0])
+
+ tempDevices.sort()
+ devices = []
+ for i in tempDevices:
+ if "src=null" in i:
+ devices.append(i.replace("src=", ""))
+ if debug: main.log.info(str(devices))
+
+ ingress = devices[0]
+ egress = devices.pop()
+ if debug: main.log.info(ingress)
+ if debug: main.log.info(egress)
+
+ for intentSize in intentsList:
+ cmd = "onos $OC1 push-test-intents "
+ cmd += ingress + "/6 "
+ cmd += egress + "/5 "
+ cmd += str(intentSize) + " 1"
+ installed = []
+ withdrawn = []
+
+ for run in range(0, (warmUp + sampleSize)):
+
+ myRawResult = "--"
+ while "ms" not in myRawResult:
+ main.ONOSbench.handle.sendline(cmd)
+ main.ONOSbench.handle.expect(":~")
+ myRawResult = main.ONOSbench.handle.before
+ if debug: main.log.info(myRawResult)
+
+ main.log.info(myRawResult)
+
+ if run >= warmUp:
+ myRawResult = myRawResult.splitlines()
+ for line in myRawResult:
+ if "install" in line:
+ installed.append(line.split(" ")[5])
+ if "withdrawn" in line:
+ withdrawn.append(line.split(" ")[5])
+ print(installed)
+ print(withdrawn)
+
+ main.log.info("Scale: " + str(clusterCount) + "\tIntent batch size: " + str(intentSize))
+
+
+ time.sleep(5)
+
+
+
+
+
+
+
+
+
diff --git a/TestON/tests/pushTestIntents/pushTestIntents.topo b/TestON/tests/pushTestIntents/pushTestIntents.topo
new file mode 100644
index 0000000..30a1467
--- /dev/null
+++ b/TestON/tests/pushTestIntents/pushTestIntents.topo
@@ -0,0 +1,146 @@
+<TOPOLOGY>
+
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS><home>~/onos</home></COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1cli>
+
+ <ONOS2cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2cli>
+
+ <ONOS3cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS3cli>
+
+ <ONOS4cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4cli>
+
+ <ONOS5cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>6</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5cli>
+
+ <ONOS6cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>7</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6cli>
+
+ <ONOS7cli>
+ <host>10.128.5.55</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>8</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7cli>
+
+ <ONOS1>
+ <host>10.128.5.51</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>9</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.128.5.52</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>10</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <ONOS3>
+ <host>10.128.5.53</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>11</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS3>
+
+ <ONOS4>
+ <host>10.128.5.54</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>12</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4>
+
+
+ <ONOS5>
+ <host>10.128.5.65</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>13</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5>
+
+ <ONOS6>
+ <host>10.128.5.66</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>14</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6>
+
+ <ONOS7>
+ <host>10.128.5.67</host>
+ <user>sdn</user>
+ <password>rocks</password>
+ <type>OnosDriver</type>
+ <connect_order>15</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7>
+
+ </COMPONENT>
+
+</TOPOLOGY>
+
+
+