Merge branch 'OnosCHO' of https://github.com/OPENNETWORKINGLAB/ONLabTest into OnosCHO
Conflicts:
TestON/drivers/common/cli/onosclidriver.py
TestON/tests/OnosCHO/OnosCHO.params
TestON/tests/OnosCHO/OnosCHO.py
diff --git a/.gitignore b/.gitignore
index 6cccacc..ae5f64f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
*.swp
+*.swo
TestON/logs/*
*.pyc
diff --git a/TestON/dependencies/Jenkins_getresult_HA.py b/TestON/dependencies/Jenkins_getresult_HA.py
new file mode 100755
index 0000000..859612d
--- /dev/null
+++ b/TestON/dependencies/Jenkins_getresult_HA.py
@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import re
+import datetime
+import time
+import argparse
+import shutil
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-n", "--name", help="Comma Separated string of test names. Ex: --name='test1, test2, test3'")
+parser.add_argument("-w", "--workspace", help="The name of the Jenkin's job/workspace where csv files will be saved'")
+args = parser.parse_args()
+
+#Pass in test names as a comma separated string argument.
+#Example: ./Jenkins_getresult.py "Test1,Test2,Test3,Test4"
+name_list = args.name.split(",")
+result_list = map(lambda x: x.strip(), name_list)
+job = args.workspace
+if job is None:
+ job = ""
+print job
+
+#NOTE: testnames list should be in order in which it is run
+testnames = result_list
+output = ''
+header = ''
+graphs = ''
+testdate = datetime.datetime.now()
+#workspace = "/var/lib/jenkins/workspace/ONOS-HA"
+workspace = "/var/lib/jenkins/workspace/"
+workspace = workspace + job
+
+header +="<p>**************************************</p>"
+header +=testdate.strftime('Jenkins test result for %H:%M on %b %d, %Y. %Z')
+
+
+#NOTE: CASE SPECIFIC THINGS
+
+#THIS LINE IS LOUSY FIXME
+if any("HA" in s for s in testnames):
+ ##Graphs
+ graphs += '<ac:structured-macro ac:name="html">\n'
+ graphs += '<ac:plain-text-body><![CDATA[\n'
+ graphs += '<iframe src="https://onos-jenkins.onlab.us/job/'+job+'/plot/getPlot?index=2&width=500&height=300" noborder="0" width="500" height="300" scrolling="yes" seamless="seamless"></iframe>\n'
+ graphs += '<iframe src="https://onos-jenkins.onlab.us/job/'+job+'/plot/getPlot?index=1&width=500&height=300" noborder="0" width="500" height="300" scrolling="yes" seamless="seamless"></iframe>\n'
+ graphs += '<iframe src="https://onos-jenkins.onlab.us/job/'+job+'/plot/getPlot?index=0&width=500&height=300" noborder="0" width="500" height="300" scrolling="yes" seamless="seamless"></iframe>\n'
+ graphs += '<iframe src="https://onos-jenkins.onlab.us/job/'+job+'/plot/getPlot?index=3&width=500&height=300" noborder="0" width="500" height="300" scrolling="yes" seamless="seamless"></iframe>\n'
+ graphs += ']]></ac:plain-text-body>\n'
+ graphs += '</ac:structured-macro>\n'
+ header +="<p> <a href='https://wiki.onosproject.org/display/OST/Test+Plan+-+HA'>Test Plan for HA Test Cases</a></p>"
+
+
+# ***
+
+
+#TestON reporting
+for test in testnames:
+ passes = 0
+ fails = 0
+ name = os.popen("ls /home/admin/ONLabTest/TestON/logs/ -rt | grep %s_ | tail -1" % test).read().split()[0]
+ path = "/home/admin/ONLabTest/TestON/logs/" + name + "/"
+ try:
+ #IF exists, move the csv file to the workspace
+ shutil.copy(path + test + ".csv", workspace)
+ except IOError:
+ #File probably doesn't exist
+ pass
+
+ output +="<p></p>"
+ #output +=" Date: %s, %s %s" % (name.split("_")[2], name.split("_")[1], name.split("_")[3]) + "<p>*******************<p>"
+ #Open the latest log folder
+ output += "<h2>Test "+str(test)+"</h2><p>************************************</p>"
+
+ f = open(path + name + ".rpt")
+
+ #Parse through each line of logs and look for specific strings to output to wiki.
+ #NOTE: with current implementation, you must specify which output to output to wiki by using
+ #main.log.report("") since it is looking for the [REPORT] tag in the logs
+ for line in f:
+ if re.search("Result summary for Testcase", line):
+ output += "<h3>"+str(line)+"</h3>"
+ #output += "<br>"
+ if re.search("\[REPORT\]", line):
+ line_split = line.split("] ")
+ #line string is split by bracket, and first two items (log tags) in list are omitted from output
+ #join is used to convert list to string
+ line_str = ''.join(line_split[2:])
+ output += "<p>"
+ output += line_str
+ output += "</p>"
+ if re.search("Result:", line):
+ output += "<p>"
+ output += line
+ output += "</p>"
+ if re.search("Pass", line):
+ passes = passes + 1
+ elif re.search("Fail", line):
+ fails = fails + 1
+ f.close()
+ #https://wiki.onosproject.org/display/OST/Test+Results+-+HA#Test+Results+-+HA
+ #Example anchor on new wiki: #TestResults-HA-TestHATestSanity
+ page_name = "Master+-+HA"
+ if "ONOS-HA-Maint" in job:
+ page_name = "1.0+-+HA"
+
+ header += "<li><a href=\'#" + str(page_name) + str(test) + "\'> " + str(test) + " - Results: " + str(passes) + " Passed, " + str(fails) + " Failed</a></li>"
+
+ #*********************
+ #include any other phrase specific to case you would like to include in wiki here
+ if test == "IntentPerf":
+ output += "URL to Historical Performance results data: <a href='http://10.128.5.54perf.html'>Perf Graph</a>"
+ #*********************
+
+#header_file = open("/tmp/header_ha.txt",'w')
+#header_file.write(header)
+output = header + graphs + output
+print output
diff --git a/TestON/dependencies/onos.properties.proactive b/TestON/dependencies/onos.properties.proactive
deleted file mode 100644
index 2b5150a..0000000
--- a/TestON/dependencies/onos.properties.proactive
+++ /dev/null
@@ -1,16 +0,0 @@
-floodlight.modules = net.floodlightcontroller.core.FloodlightProvider,\
-net.floodlightcontroller.threadpool.ThreadPool,\
-net.onrc.onos.core.topology.TopologyPublisher, \
-net.onrc.onos.core.datagrid.HazelcastDatagrid,\
-net.onrc.onos.core.flowprogrammer.FlowProgrammer,\
-net.onrc.onos.core.intent.runtime.PathCalcRuntimeModule,\
-net.onrc.onos.core.intent.runtime.PlanInstallModule,\
-net.onrc.onos.core.registry.ZookeeperRegistry
-net.floodlightcontroller.restserver.RestApiServer.port = 8080
-net.floodlightcontroller.core.FloodlightProvider.openflowport = 6633
-net.floodlightcontroller.core.FloodlightProvider.workerthreads = 16
-net.floodlightcontroller.forwarding.Forwarding.idletimeout = 5
-net.floodlightcontroller.forwarding.Forwarding.hardtimeout = 0
-net.onrc.onos.core.datagrid.HazelcastDatagrid.datagridConfig = conf/hazelcast.xml
-net.onrc.onos.ofcontroller.floodlightlistener.NetworkGraphPublisher.dbconf = conf/ramcloud.conf
-net.onrc.onos.ofcontroller.floodlightlistener.NetworkGraphPublisher.graph_db_store = ramcloud
diff --git a/TestON/dependencies/onos.properties.reactive b/TestON/dependencies/onos.properties.reactive
deleted file mode 100644
index 8d78222..0000000
--- a/TestON/dependencies/onos.properties.reactive
+++ /dev/null
@@ -1,19 +0,0 @@
-floodlight.modules = net.floodlightcontroller.core.FloodlightProvider,\
-net.floodlightcontroller.threadpool.ThreadPool,\
-net.onrc.onos.core.topology.TopologyPublisher, \
-net.onrc.onos.core.datagrid.HazelcastDatagrid,\
-net.onrc.onos.core.flowprogrammer.FlowProgrammer,\
-net.onrc.onos.core.intent.runtime.PathCalcRuntimeModule,\
-net.onrc.onos.core.intent.runtime.PlanInstallModule,\
-net.onrc.onos.core.registry.ZookeeperRegistry,\
-net.onrc.onos.apps.proxyarp.ProxyArpManager,\
-net.onrc.onos.core.main.config.DefaultConfiguration,\
-net.onrc.onos.apps.forwarding.Forwarding
-net.floodlightcontroller.restserver.RestApiServer.port = 8080
-net.floodlightcontroller.core.FloodlightProvider.openflowport = 6633
-net.floodlightcontroller.core.FloodlightProvider.workerthreads = 16
-net.floodlightcontroller.forwarding.Forwarding.idletimeout = 5
-net.floodlightcontroller.forwarding.Forwarding.hardtimeout = 0
-net.onrc.onos.core.datagrid.HazelcastDatagrid.datagridConfig = conf/hazelcast.xml
-net.onrc.onos.ofcontroller.floodlightlistener.NetworkGraphPublisher.dbconf = conf/ramcloud.conf
-net.onrc.onos.ofcontroller.floodlightlistener.NetworkGraphPublisher.graph_db_store = ramcloud
diff --git a/TestON/dependencies/pyintents.py b/TestON/dependencies/pyintents.py
deleted file mode 100755
index b593845..0000000
--- a/TestON/dependencies/pyintents.py
+++ /dev/null
@@ -1,46 +0,0 @@
-#! /usr/bin/env python
-'''
-This file creates the ONOS intents for the sanity 4 nodes tests. These intents will be translated into flows by ONOS and pushed to the switches.
-'''
-
-import json
-import requests
-
-url = 'http://127.0.0.1:8080/wm/onos/datagrid/add/intents/json'
-headers = {'Content-type': 'application/json', 'Accept': 'application/json'}
-
-
-'''response
-[{'intent_id':'5','status':'CREATED','log':['created, time:73268214932534']}]
-'''
-
-
-
-for i in range(6,16):
- #intent = [{'intent_id': '%d' %i,'intent_type':'shortest_intent_type','intent_op':'add','srcSwitch':'8249','srcPort':1,'srcMac':'00:00:00:00:00:01','dstSwitch':'4103','dstPort':1,'dstMac':'00:00:00:00:00:02'}]
- srcMac = '00:00:00:00:00:'+ str(hex(i)[2:]).zfill(2)
- dstMac = '00:00:00:00:00:'+ str(hex(i+10)[2:])
- srcSwitch = '00:00:00:00:00:00:10:'+ str(i).zfill(2)
- dstSwitch = '00:00:00:00:00:00:20:'+ str(i+25)
- srcPort = 1
- dstPort = 1
-
- intent = [{'intent_id': '%d' %(i),'intent_type':'shortest_intent_type','intent_op':'add','srcSwitch':srcSwitch,'srcPort':srcPort,'srcMac':srcMac,'dstSwitch':dstSwitch,'dstPort':dstPort,'dstMac':dstMac}]
-
-
- print json.dumps(intent, sort_keys = True)
-
-
- #r = requests.post(url, data=json.dumps(iid, sort_keys=True)+json.dumps(intent, sort_keys=True), headers = headers)
- r = requests.post(url, data=json.dumps(intent, sort_keys=True), headers = headers)
- print r
- print r.content
-
-
-
- intent = [{'intent_id': '%d' %(i+10),'intent_type':'shortest_intent_type','intent_op':'add','srcSwitch':dstSwitch,'srcPort':dstPort,'srcMac':dstMac,'dstSwitch':srcSwitch,'dstPort':srcPort,'dstMac':srcMac}]
- print json.dumps(intent, sort_keys = True)
- r = requests.post(url, data=json.dumps(intent, sort_keys=True), headers = headers)
- print r
- print r.content
-
diff --git a/TestON/dependencies/rmpyintents.py b/TestON/dependencies/rmpyintents.py
deleted file mode 100755
index 10bb5d4..0000000
--- a/TestON/dependencies/rmpyintents.py
+++ /dev/null
@@ -1,49 +0,0 @@
-#! /usr/bin/env python
-
-'''
-This file removes the ONOS intents for the sanity 4 nodes tests. The flows associated with these intents should be deleted from the switches.
-'''
-
-import json
-import requests
-
-
-
-url = 'http://127.0.0.1:8080/wm/onos/datagrid/add/intents/json'
-headers = {'Content-type': 'application/json', 'Accept': 'application/json'}
-
-
-'''response
-[{'intent_id':'5','status':'CREATED','log':['created, time:73268214932534']}]
-'''
-
-
-
-for i in range(6,16):
- #intent = [{'intent_id': '%d' %i,'intent_type':'shortest_intent_type','intent_op':'remove','srcSwitch':'8249','srcPort':1,'srcMac':'00:00:00:00:00:01','dstSwitch':'4103','dstPort':1,'dstMac':'00:00:00:00:00:02'}]
- srcMac = '00:00:00:00:00:'+ str(hex(i)[2:]).zfill(2)
- dstMac = '00:00:00:00:00:'+ str(hex(i+10)[2:])
- srcSwitch = '00:00:00:00:00:00:10:'+ str(i).zfill(2)
- dstSwitch = '00:00:00:00:00:00:20:'+ str(i+25)
- srcPort = 1
- dstPort = 1
-
- intent = [{'intent_id': '%d' %(i),'intent_type':'shortest_intent_type','intent_op':'remove','srcSwitch':srcSwitch,'srcPort':srcPort,'srcMac':srcMac,'dstSwitch':dstSwitch,'dstPort':dstPort,'dstMac':dstMac}]
-
-
- print json.dumps(intent, sort_keys = True)
-
-
- #r = requests.post(url, data=json.dumps(iid, sort_keys=True)+json.dumps(intent, sort_keys=True), headers = headers)
- r = requests.post(url, data=json.dumps(intent, sort_keys=True), headers = headers)
- print r
- print r.content
-
-
-
- intent = [{'intent_id': '%d' %(i+10),'intent_type':'shortest_intent_type','intent_op':'remove','srcSwitch':dstSwitch,'srcPort':dstPort,'srcMac':dstMac,'dstSwitch':srcSwitch,'dstPort':srcPort,'dstMac':srcMac}]
- print json.dumps(intent, sort_keys = True)
- r = requests.post(url, data=json.dumps(intent, sort_keys=True), headers = headers)
- print r
- print r.content
-
diff --git a/TestON/drivers/common/cli/emulator/mininetclidriver.py b/TestON/drivers/common/cli/emulator/mininetclidriver.py
index 95e0cb9..acef039 100644
--- a/TestON/drivers/common/cli/emulator/mininetclidriver.py
+++ b/TestON/drivers/common/cli/emulator/mininetclidriver.py
@@ -59,20 +59,51 @@
"""
Here the main is the TestON instance after creating
all the log handles."""
- for key in connectargs:
- vars( self )[ key ] = connectargs[ key ]
+ try:
+ for key in connectargs:
+ vars( self )[ key ] = connectargs[ key ]
- self.name = self.options[ 'name' ]
- self.handle = super(
- MininetCliDriver,
- self ).connect(
- user_name=self.user_name,
- ip_address=self.ip_address,
- port=None,
- pwd=self.pwd )
+ self.name = self.options[ 'name' ]
+ self.handle = super(
+ MininetCliDriver,
+ self ).connect(
+ user_name=self.user_name,
+ ip_address=self.ip_address,
+ port=None,
+ pwd=self.pwd )
- self.sshHandle = self.handle
+ if self.handle:
+ main.log.info("Connection successful to the host " +
+ self.user_name +
+ "@" +
+ self.ip_address )
+ return main.TRUE
+ else:
+ main.log.error( "Connection failed to the host " +
+ self.user_name +
+ "@" +
+ self.ip_address )
+ msin.log.error( "Failed to connect to the Mininet CLI" )
+ return main.FALSE
+ except pexpect.EOF:
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
+ main.cleanup()
+ main.exit()
+ except:
+ main.log.info( self.name + ":::::::::::::::::::::::" )
+ main.log.error( traceback.print_exc() )
+ main.log.info( ":::::::::::::::::::::::" )
+ main.cleanup()
+ main.exit()
+
+ def startNet( self, topoFile = '', args = '', timeout = 120 ):
+ """
+ Starts Mininet accepts a topology(.py) file and/or an optional
+ arguement ,to start the mininet, as a parameter.
+ Returns true if the mininet starts successfully
+ """
if self.handle:
main.log.info(
self.name +
@@ -82,7 +113,7 @@
'Cleanup\scomplete',
pexpect.EOF,
pexpect.TIMEOUT ],
- 120 )
+ timeout )
if i == 0:
main.log.info( self.name + ": Sending sudo password" )
self.handle.sendline( self.pwd )
@@ -90,7 +121,7 @@
'\$',
pexpect.EOF,
pexpect.TIMEOUT ],
- 120 )
+ timeout )
if i == 1:
main.log.info( self.name + ": Clean" )
elif i == 2:
@@ -99,51 +130,68 @@
main.log.error(
self.name +
": Something while cleaning MN took too long... " )
+ if topoFile == '' and args == '':
+ main.log.info( self.name + ": building fresh mininet" )
+ # for reactive/PARP enabled tests
+ cmdString = "sudo mn " + self.options[ 'arg1' ] +\
+ " " + self.options[ 'arg2' ] +\
+ " --mac --controller " +\
+ self.options[ 'controller' ] + " " +\
+ self.options[ 'arg3' ]
- main.log.info( self.name + ": building fresh mininet" )
- # for reactive/PARP enabled tests
- cmdString = "sudo mn " + self.options[ 'arg1' ] +\
- " " + self.options[ 'arg2' ] +\
- " --mac --controller " +\
- self.options[ 'controller' ] + " " +\
- self.options[ 'arg3' ]
+ argList = self.options[ 'arg1' ].split( "," )
+ global topoArgList
+ topoArgList = argList[ 0 ].split( " " )
+ argList = map( int, argList[ 1: ] )
+ topoArgList = topoArgList[ 1: ] + argList
- argList = self.options[ 'arg1' ].split( "," )
- global topoArgList
- topoArgList = argList[ 0 ].split( " " )
- argList = map( int, argList[ 1: ] )
- topoArgList = topoArgList[ 1: ] + argList
-
- self.handle.sendline( cmdString )
- self.handle.expect( [ "sudo mn", pexpect.EOF, pexpect.TIMEOUT ] )
- while True:
+ self.handle.sendline( cmdString )
+ self.handle.expect( [ "sudo mn",
+ pexpect.EOF,
+ pexpect.TIMEOUT ] )
+ while True:
+ i = self.handle.expect( [ 'mininet>',
+ '\*\*\*',
+ 'Exception',
+ pexpect.EOF,
+ pexpect.TIMEOUT ],
+ timeout )
+ if i == 0:
+ main.log.info( self.name + ": mininet built" )
+ return main.TRUE
+ if i == 1:
+ self.handle.expect(
+ [ "\n", pexpect.EOF, pexpect.TIMEOUT ] )
+ main.log.info( self.handle.before )
+ elif i == 2:
+ main.log.error(
+ self.name +
+ ": Launching mininet failed..." )
+ return main.FALSE
+ elif i == 3:
+ main.log.error( self.name + ": Connection timeout" )
+ return main.FALSE
+ elif i == 4: # timeout
+ main.log.error(
+ self.name +
+ ": Something took too long... " )
+ return main.FALSE
+ return main.TRUE
+ else:
+ main.log.info( "Starting topo file " + topoFile )
+ if args == None:
+ args = ''
+ else:
+ main.log.info( "args = " + args)
+ self.handle.sendline( 'sudo ' + topoFile + ' ' + args)
+ i = 1
i = self.handle.expect( [ 'mininet>',
- '\*\*\*',
- 'Exception',
- pexpect.EOF,
- pexpect.TIMEOUT ],
- 300 )
- if i == 0:
- main.log.info( self.name + ": mininet built" )
- return main.TRUE
- if i == 1:
- self.handle.expect(
- [ "\n", pexpect.EOF, pexpect.TIMEOUT ] )
- main.log.info( self.handle.before )
- elif i == 2:
- main.log.error(
- self.name +
- ": Launching mininet failed..." )
- return main.FALSE
- elif i == 3:
- main.log.error( self.name + ": Connection timeout" )
- return main.FALSE
- elif i == 4: # timeout
- main.log.error(
- self.name +
- ": Something took too long... " )
- return main.FALSE
- return main.TRUE
+ pexpect.EOF ,
+ pexpect.TIMEOUT ],
+ timeout)
+ main.log.info(self.name + ": Network started")
+ return main.TRUE
+
else: # if no handle
main.log.error(
self.name +
@@ -367,6 +415,89 @@
else:
return main.TRUE
+ def moveHost( self, host, oldSw, newSw, ):
+ """
+ Moves a host from one switch to another on the fly
+ Note: The intf between host and oldSw when detached
+ using detach(), will still show up in the 'net'
+ cmd, because switch.detach() doesn't affect switch.intfs[]
+ (which is correct behavior since the interfaces
+ haven't moved).
+ """
+ if self.handle:
+ try:
+ # Bring link between oldSw-host down
+ cmd = "py net.configLinkStatus('" + oldSw + "'," + "'" + host + "'," +\
+ "'down')"
+ print "cmd1= ", cmd
+ response = self.execute(
+ cmd=cmd,
+ prompt="mininet>",
+ timeout=10 )
+
+ # Determine hostintf and Oldswitchintf
+ cmd = "px hintf,sintf = " + host + ".connectionsTo(" + oldSw +\
+ ")[0]"
+ print "cmd2= ", cmd
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
+
+ # Determine ipaddress of the host-oldSw interface
+ cmd = "px ipaddr = hintf.IP()"
+ print "cmd3= ", cmd
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
+
+ # Detach interface between oldSw-host
+ cmd = "px " + oldSw + ".detach( sintf )"
+ print "cmd4= ", cmd
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
+
+ # Add link between host-newSw
+ cmd = "py net.addLink(" + host + "," + newSw + ")"
+ print "cmd5= ", cmd
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
+
+ # Determine hostintf and Newswitchintf
+ cmd = "px hintf,sintf = " + host + ".connectionsTo(" + newSw +\
+ ")[0]"
+ print "cmd6= ", cmd
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
+
+ # Attach interface between newSw-host
+ cmd = "px " + newSw + ".attach( sintf )"
+ print "cmd3= ", cmd
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
+
+ # Set ipaddress of the host-newSw interface
+ cmd = "px " + host + ".setIP( ip = ipaddr, intf = hintf)"
+ print "cmd7 = ", cmd
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
+
+ cmd = "net"
+ print "cmd8 = ", cmd
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
+ print "output = ", self.handle.before
+
+ # Determine ipaddress of the host-newSw interface
+ cmd = "h1 ifconfig"
+ print "cmd9= ", cmd
+ self.handle.sendline( cmd )
+ self.handle.expect( "mininet>" )
+ print "ifconfig o/p = ", self.handle.before
+
+ return main.TRUE
+ except pexpect.EOF:
+ main.log.error( self.name + ": EOF exception found" )
+ main.log.error( self.name + ": " + self.handle.before )
+ return main.FALSE
+
def changeIP( self, host, intf, newIP, newNetmask ):
"""
Changes the ip address of a host on the fly
@@ -1108,6 +1239,34 @@
main.exit()
def disconnect( self ):
+ """
+ Called at the end of the test to stop the mininet and
+ disconnect the handle.
+ """
+ self.handle.sendline('')
+ i = 1
+ i = self.handle.expect( ['mininet>',pexpect.EOF,pexpect.TIMEOUT ], timeout = 2)
+ if i == 0:
+ self.stopNet()
+ response = ''
+ # print "Disconnecting Mininet"
+ if self.handle:
+ self.handle.sendline( "exit" )
+ self.handle.expect( "exit" )
+ self.handle.expect( "(.*)" )
+ main.log.info( "Mininet CLI is successfully disconnected" )
+ response = self.handle.before
+ else:
+ main.log.error( "Connection failed to the host" )
+ response = main.FALSE
+
+ return response
+
+ def stopNet( self ):
+ """
+ Stops mininet. returns true if the mininet succesfully stops.
+ """
+
main.log.info( self.name + ": Disconnecting mininet..." )
response = ''
if self.handle:
@@ -1116,10 +1275,7 @@
cmd="exit",
prompt="(.*)",
timeout=120 )
- response = self.execute(
- cmd="exit",
- prompt="(.*)",
- timeout=120 )
+ main.log.info( self.name + ": Disconnected")
self.handle.sendline( "sudo mn -c" )
response = main.TRUE
except pexpect.EOF:
@@ -1132,6 +1288,8 @@
response = main.FALSE
return response
+
+
def arping( self, src, dest, destmac ):
self.handle.sendline( '' )
self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
@@ -1492,9 +1650,9 @@
else:
linkResults = main.FALSE
main.log.report(
- "Mininet has %i bidirectional links and " +
- "ONOS has %i unidirectional links" %
- ( len( mnLinks ), len( onos ) ) )
+ "Mininet has " + str( len( mnLinks ) ) +
+ " bidirectional links and ONOS has " +
+ str( len( onos ) ) + " unidirectional links" )
# iterate through MN links and check if an ONOS link exists in
# both directions
diff --git a/TestON/drivers/common/cli/onosclidriver.py b/TestON/drivers/common/cli/onosclidriver.py
index 097a303..a660caa 100644
--- a/TestON/drivers/common/cli/onosclidriver.py
+++ b/TestON/drivers/common/cli/onosclidriver.py
@@ -19,7 +19,6 @@
import sys
import pexpect
import re
-import traceback
sys.path.append( "../" )
from drivers.common.clidriver import CLI
@@ -60,15 +59,16 @@
else:
main.log.info( "NO ONOS HANDLE" )
return main.FALSE
+ 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:
- main.log.info( self.name + ":::::::::::::::::::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( ":::::::::::::::::::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -90,11 +90,14 @@
self.handle.sendline( "exit" )
self.handle.expect( "closed" )
+ 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 )
except:
- main.log.error( self.name + ": Connection failed to the host" )
+ main.log.exception( self.name + ": Connection failed to the host" )
response = main.FALSE
return response
@@ -113,6 +116,9 @@
elif i == 1:
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 + ": " +
@@ -120,9 +126,7 @@
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -155,15 +159,16 @@
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -232,15 +237,16 @@
str( ONOSIp ) + " timeout" )
return main.FALSE
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -277,15 +283,16 @@
return output
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -316,15 +323,16 @@
else:
main.log.info( "Node " + str( ONOSIp ) + " added" )
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -343,15 +351,16 @@
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -365,15 +374,16 @@
cmdStr = "nodes"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -388,15 +398,16 @@
handle = self.sendline( cmdStr )
main.log.info( "onos:topology returned: " + str( handle ) )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -410,6 +421,9 @@
self.sendline( cmdStr )
# TODO: Check for possible error responses from karaf
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 )
@@ -418,11 +432,9 @@
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.log.report( "Failed to install feature" )
main.log.report( "Exiting test" )
- main.log.info( self.name + " ::::::" )
main.cleanup()
main.exit()
@@ -436,15 +448,16 @@
self.sendline( cmdStr )
# TODO: Check for possible error responses from karaf
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -478,15 +491,16 @@
cmdStr = "devices"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -501,15 +515,16 @@
self.sendline( cmdStr )
# TODO: Check for error responses from ONOS
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -543,15 +558,16 @@
cmdStr = "links"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -586,15 +602,16 @@
cmdStr = "ports"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -631,15 +648,16 @@
cmdStr = "roles"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -667,16 +685,16 @@
if str( deviceId ) in device[ 'id' ]:
return device
return None
-
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -698,15 +716,16 @@
return main.FALSE
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -725,15 +744,16 @@
path = handle.split( ";" )[ 0 ]
cost = handle.split( ";" )[ 1 ]
return ( path, cost )
+ except TypeError:
+ main.log.exception( self.name + ": Object not as expected" )
+ return ( handle, "Error" )
except pexpect.EOF:
main.log.error( self.name + ": EOF exception found" )
main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -767,15 +787,16 @@
cmdStr = "hosts"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -799,18 +820,21 @@
# search json for the host with mac then return the device
for host in hostsJson:
# print "%s in %s?" % ( mac, host[ 'id' ] )
- if mac in host[ 'id' ]:
+ if not host:
+ pass
+ elif mac in host[ 'id' ]:
return host
return None
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -843,15 +867,16 @@
return onosHostList
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -876,15 +901,19 @@
str( hostIdOne ) + " and " + str( hostIdTwo ) )
return main.TRUE
+<<<<<<< HEAD
+ except TypeError:
+ main.log.exception( self.name + ": Object not as expected" )
+ return None
+=======
+>>>>>>> 1c7509b87a65d457eaf41f5551e560f1aa2ea0df
except pexpect.EOF:
main.log.error( self.name + ": EOF exception found" )
main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -905,15 +934,16 @@
return handle
else:
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1024,15 +1054,16 @@
return main.FALSE
else:
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1171,15 +1202,16 @@
return self.handle
else:
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1200,15 +1232,16 @@
else:
# TODO: Should this be main.TRUE
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1231,15 +1264,16 @@
cmdStr = "routes"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1260,15 +1294,16 @@
cmdStr = "intents"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1292,15 +1327,16 @@
main.log.error( self.name + ".flows() response: " +
str( handle ) )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1350,15 +1386,16 @@
return latResult
else:
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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1379,15 +1416,16 @@
cmdStr = "intents-events-metrics"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1408,15 +1446,16 @@
cmdStr = "topology-events-metrics"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1459,15 +1498,16 @@
return intentIdList
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1504,15 +1544,16 @@
idList.append( arg.split( "id=" )[ 1 ] )
return idList
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1543,15 +1584,16 @@
return idList
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1574,15 +1616,16 @@
if dpid in device[ 'id' ]:
return device
return None
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1639,15 +1682,16 @@
else:
main.log.info( output )
return result
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1681,15 +1725,16 @@
main.log.error( "Invalid 'role' given to device_role(). " +
"Value was '" + str(role) + "'." )
return main.FALSE
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1723,15 +1768,16 @@
cmdStr = "clusters"
handle = self.sendline( cmdStr )
return handle
+ 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:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1774,15 +1820,16 @@
"unexpected response" )
main.log.error( repr( response ) )
return main.FALSE
+ except TypeError:
+ main.log.exception( self.name + ": Object not as expected" )
+ return main.FALSE
except pexpect.EOF:
main.log.error( self.name + ": EOF exception found" )
main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1814,15 +1861,16 @@
"unexpected response" )
main.log.error( repr( response ) )
return main.FALSE
+ except TypeError:
+ main.log.exception( self.name + ": Object not as expected" )
+ return main.FALSE
except pexpect.EOF:
main.log.error( self.name + ": EOF exception found" )
main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1854,15 +1902,16 @@
"unexpected response" )
main.log.error( repr( response ) )
return main.FALSE
+ except TypeError:
+ main.log.exception( self.name + ": Object not as expected" )
+ return main.FALSE
except pexpect.EOF:
main.log.error( self.name + ": EOF exception found" )
main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1879,15 +1928,16 @@
return ( output, "Error" )
else:
return output
+ except TypeError:
+ main.log.exception( self.name + ": Object not as expected" )
+ return ( output, "Error" )
except pexpect.EOF:
main.log.error( self.name + ": EOF exception found" )
main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1904,15 +1954,16 @@
return ( output, "Error " )
else:
return output
+ except TypeError:
+ main.log.exception( self.name + ": Object not as expected" )
+ return ( output, "Error " )
except pexpect.EOF:
main.log.error( self.name + ": EOF exception found" )
main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
@@ -1928,14 +1979,36 @@
return ( output, "Error" )
else:
return output
+ except TypeError:
+ main.log.exception( self.name + ": Object not as expected" )
+ return ( output, "Error" )
except pexpect.EOF:
main.log.error( self.name + ": EOF exception found" )
main.log.error( self.name + ": " + self.handle.before )
main.cleanup()
main.exit()
except:
- main.log.info( self.name + " ::::::" )
- main.log.error( traceback.print_exc() )
- main.log.info( self.name + " ::::::" )
+ main.log.exception( self.name + ": Uncaught exception!" )
+ main.cleanup()
+ main.exit()
+
+ def testExceptions( self, obj ):
+ """
+ Test exception logging
+ """
+ # FIXME: Remove this before you commit
+
+ try:
+ return obj[ 'dedf' ]
+ 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:
+ main.log.exception( self.name + ": Uncaught exception!" )
main.cleanup()
main.exit()
diff --git a/TestON/drivers/common/cli/onosdriver.py b/TestON/drivers/common/cli/onosdriver.py
index a9a5a03..50994ee 100644
--- a/TestON/drivers/common/cli/onosdriver.py
+++ b/TestON/drivers/common/cli/onosdriver.py
@@ -45,7 +45,9 @@
if key == "home":
self.home = self.options[ 'home' ]
break
-
+ if self.home == None or self.home == "":
+ self.home = "~/ONOS"
+
self.name = self.options[ 'name' ]
self.handle = super( OnosDriver, self ).connect(
user_name=self.user_name,
@@ -238,7 +240,7 @@
# main.log.info( self.name + ": Stopping ONOS" )
# self.stop()
self.handle.sendline( "cd " + self.home )
- self.handle.expect( "ONOS\$" )
+ self.handle.expect( self.home + "\$" )
if comp1 == "":
self.handle.sendline( "git pull" )
else:
@@ -274,7 +276,7 @@
main.log.info(
self.name +
": Git Pull - pulling repository now" )
- self.handle.expect( "ONOS\$", 120 )
+ self.handle.expect( self.home + "\$", 120 )
# So that only when git pull is done, we do mvn clean compile
return main.TRUE
elif i == 3:
@@ -345,7 +347,7 @@
"""
try:
self.handle.sendline( "cd " + self.home )
- self.handle.expect( "ONOS\$" )
+ self.handle.expect( self.home + "\$" )
main.log.info(
self.name +
": Checking out git branch: " +
@@ -385,7 +387,7 @@
self.name +
": Git Checkout %s : Already on this branch" %
branch )
- self.handle.expect( "ONOS\$" )
+ self.handle.expect( self.home + "\$" )
# main.log.info( "DEBUG: after checkout cmd = "+
# self.handle.before )
return main.TRUE
@@ -394,7 +396,7 @@
self.name +
": Git checkout %s - Switched to this branch" %
branch )
- self.handle.expect( "ONOS\$" )
+ self.handle.expect( self.home + "\$" )
# main.log.info( "DEBUG: after checkout cmd = "+
# self.handle.before )
return main.TRUE
@@ -413,7 +415,7 @@
files would be overwritten by checkout:" +
str(
self.handle.before ) )
- self.handle.expect( "ONOS\$" )
+ self.handle.expect( self.home + "\$" )
return main.ERROR
elif i == 6:
main.log.error( self.name +
@@ -421,7 +423,7 @@
"You need to resolve your\
current index first:" +
str( self.handle.before ) )
- self.handle.expect( "ONOS\$" )
+ self.handle.expect( self.home + "\$" )
return main.ERROR
else:
main.log.error(
diff --git a/TestON/drivers/common/cli/quaggaclidriver.py b/TestON/drivers/common/cli/quaggaclidriver.py
index 8724454..98f83d2 100644
--- a/TestON/drivers/common/cli/quaggaclidriver.py
+++ b/TestON/drivers/common/cli/quaggaclidriver.py
@@ -28,19 +28,14 @@
# self.handle = super( QuaggaCliDriver,self ).connect(
# user_name=self.user_name, ip_address=self.ip_address,port=self.port,
# pwd=self.pwd )
- self.handle = super(
- QuaggaCliDriver,
- self ).connect(
+ self.handle = super( QuaggaCliDriver, self ).connect(
user_name=self.user_name,
- ip_address="1.1.1.1",
- port=self.port,
- pwd=self.pwd )
- main.log.info(
- "connect parameters:" + str(
- self.user_name ) + ";" + str(
- self.ip_address ) + ";" + str(
- self.port ) + ";" + str(
- self.pwd ) )
+ ip_address="1.1.1.1",
+ port=self.port,
+ pwd=self.pwd )
+ main.log.info( "connect parameters:" + str( self.user_name ) + ";"
+ + str( self.ip_address ) + ";" + str( self.port )
+ + ";" + str(self.pwd ) )
if self.handle:
# self.handle.expect( "",timeout=10 )
@@ -64,14 +59,9 @@
self.handle = super( QuaggaCliDriver, self ).connect(
user_name=self.user_name, ip_address=ip_address,
port=self.port, pwd=self.pwd )
- main.log.info( "connect parameters:" +
- str( self.user_name ) +
- ";" +
- str( self.ip_address ) +
- ";" +
- str( self.port ) +
- ";" +
- str( self.pwd ) )
+ main.log.info( "connect parameters:" + str( self.user_name ) + ";"
+ + str( self.ip_address ) + ";" + str( self.port )
+ + ";" + str( self.pwd ) )
if self.handle:
# self.handle.expect( "" )
@@ -85,7 +75,7 @@
self.handle.sendline( "enable" )
# self.handle.expect( "bgpd#", timeout=5 )
self.handle.expect( "bgpd#" )
- main.log.info( "I in quagga on host " + str( ip_address ) )
+ main.log.info( "I am in quagga on host " + str( ip_address ) )
return self.handle
else:
@@ -114,8 +104,7 @@
def generatePrefixes( self, net, numRoutes ):
main.log.info( "I am in generate_prefixes method!" )
- # each IP prefix will be composed by
- #"net" + "." + m + "." + n + "." + x
+ # each IP prefix is composed by "net" + "." + m + "." + n + "." + x
# the length of each IP prefix is 24
routes = []
routesGen = 0
@@ -124,10 +113,8 @@
for i in range( 0, m ):
for j in range( 0, 256 ):
- network = str(
- net ) + "." + str(
- i ) + "." + str(
- j ) + ".0/24"
+ network = str( net ) + "." + str( i ) + "." + str( j ) \
+ + ".0/24"
routes.append( network )
routesGen = routesGen + 1
@@ -144,39 +131,36 @@
# This method generates a multiple to single point intent(
# MultiPointToSinglePointIntent ) for a given route
- def generateExpectedSingleRouteIntent(
- self,
- prefix,
- nextHop,
- nextHopMac,
- sdnipData ):
+ def generateExpectedSingleRouteIntent( self, prefix, nextHop, nextHopMac,
+ sdnipData ):
- ingress = []
+ ingresses = []
egress = ""
for peer in sdnipData[ 'bgpPeers' ]:
- if peer[ 'ip_address' ] == nextHop:
- egress = "of:" + \
- str( peer[ 'attachmentDpid' ] ).replace( ":", "" ) + ":" +\
- str( peer[ 'attachmentPort' ] )
- else:
- ingress.append( "of:" +
- str( peer[ 'attachmentDpid' ] ).replace( ":",
- "" ) + ":" +
- str( peer[ 'attachmentPort' ] ) )
+ if peer[ 'ipAddress' ] == nextHop:
+ egress = "of:" + str(
+ peer[ 'attachmentDpid' ] ).replace( ":", "" ) + ":" \
+ + str( peer[ 'attachmentPort' ] )
+ for peer in sdnipData[ 'bgpPeers' ]:
+ if not peer[ 'ipAddress' ] == nextHop:
+ ingress = "of:" + str(
+ peer[ 'attachmentDpid' ] ).replace( ":", "" ) + ":" \
+ + str( peer[ 'attachmentPort' ] )
+ if not ingress == egress and ingress not in ingresses:
+ ingresses.append( ingress )
+ # ingresses.append( "of:" + str( peer[ 'attachmentDpid' ]
+ # ).replace( ":", "" ) + ":" + str( peer[ 'attachmentPort'
+ # ] ) )
selector = "ETH_TYPE{ethType=800},IPV4_DST{ip=" + prefix + "}"
treatment = "[ETH_DST{mac=" + str( nextHopMac ) + "}]"
- intent = egress + "/" + \
- str( sorted( ingress ) ) + "/" + selector + "/" + treatment
+ intent = egress + "/" + str( sorted( ingresses ) ) + "/" + \
+ selector + "/" + treatment
return intent
- def generateExpectedOnePeerRouteIntents(
- self,
- prefixes,
- nextHop,
- nextHopMac,
- sdnipJsonFilePath ):
+ def generateExpectedOnePeerRouteIntents( self, prefixes, nextHop,
+ nextHopMac, sdnipJsonFilePath ):
intents = []
sdnipJsonFile = open( sdnipJsonFilePath ).read()
@@ -185,10 +169,7 @@
for prefix in prefixes:
intents.append(
self.generateExpectedSingleRouteIntent(
- prefix,
- nextHop,
- nextHopMac,
- sdnipData ) )
+ prefix, nextHop, nextHopMac, sdnipData ) )
return sorted( intents )
# TODO
@@ -220,14 +201,15 @@
for intent in intentsJsonObj:
if intent[ 'appId' ] != "org.onosproject.sdnip":
continue
- if intent[ 'type' ] == "MultiPointToSinglePointIntent" and intent[
- 'state' ] == 'INSTALLED':
- egress = str( intent[ 'egress' ][ 'device' ] ) + ":" + str(
- intent[ 'egress' ][ 'port' ] )
+ if intent[ 'type' ] == "MultiPointToSinglePointIntent" \
+ and intent[ 'state' ] == 'INSTALLED':
+ egress = str( intent[ 'egress' ][ 'device' ] ) + ":" \
+ + str( intent[ 'egress' ][ 'port' ] )
ingress = []
for attachmentPoint in intent[ 'ingress' ]:
- ingress.append( str( attachmentPoint[ 'device' ] ) +
- ":" + str( attachmentPoint[ 'port' ] ) )
+ ingress.append(
+ str( attachmentPoint[ 'device' ] ) + ":"
+ + str( attachmentPoint[ 'port' ] ) )
selector = intent[ 'selector' ].replace(
"[", "" ).replace( "]", "" ).replace( " ", "" )
@@ -235,8 +217,7 @@
str1, str2 = str( selector ).split( "," )
selector = str2 + "," + str1
- intent = egress + "/" + \
- str( sorted( ingress ) ) + "/" + \
+ intent = egress + "/" + str( sorted( ingress ) ) + "/" + \
selector + "/" + intent[ 'treatment' ]
intents.append( intent )
return sorted( intents )
@@ -251,22 +232,16 @@
for intent in intentsJsonObj:
if intent[ 'appId' ] != "org.onosproject.sdnip":
continue
- if intent[ 'type' ] == "PointToPointIntent" and "protocol=6"\
- in str( intent[ 'selector' ] ):
- ingress = str( intent[ 'ingress' ][ 'device' ] ) + ":" + str(
- intent[ 'ingress' ][ 'port' ] )
- egress = str( intent[ 'egress' ][ 'device' ] ) + ":" + str(
- intent[ 'egress' ][ 'port' ] )
- selector = str(
- intent[ 'selector' ] ).replace(
- " ",
- "" ).replace(
- "[",
- "" ).replace(
- "]",
- "" ).split( "," )
- intent = ingress + "/" + egress + \
- "/" + str( sorted( selector ) )
+ if intent[ 'type' ] == "PointToPointIntent" \
+ and "protocol=6" in str( intent[ 'selector' ] ):
+ ingress = str( intent[ 'ingress' ][ 'device' ] ) + ":" \
+ + str( intent[ 'ingress' ][ 'port' ] )
+ egress = str( intent[ 'egress' ][ 'device' ] ) + ":" + \
+ str( intent[ 'egress' ][ 'port' ] )
+ selector = str( intent[ 'selector' ] ).replace( " ", "" )\
+ .replace( "[", "" ).replace( "]", "" ).split( "," )
+ intent = ingress + "/" + egress + "/" + \
+ str( sorted( selector ) )
intents.append( intent )
return sorted( intents )
@@ -282,73 +257,72 @@
intents = []
bgpPeerAttachmentPoint = ""
bgpSpeakerAttachmentPoint = "of:" + str(
- sdnipData[ 'bgpSpeakers' ][ 0 ][ 'attachmentDpid' ] ).replace( ":",
- "" ) + ":" +\
- str( sdnipData[ 'bgpSpeakers' ][ 0 ][ 'attachmentPort' ] )
+ sdnipData[ 'bgpSpeakers' ][ 0 ][ 'attachmentDpid' ] )\
+ .replace( ":", "" ) + ":" \
+ + str( sdnipData[ 'bgpSpeakers' ][ 0 ][ 'attachmentPort' ] )
for peer in sdnipData[ 'bgpPeers' ]:
- bgpPeerAttachmentPoint = "of:" + \
- str( peer[ 'attachmentDpid' ] ).replace( ":", "" ) +\
- ":" + str( peer[ 'attachmentPort' ] )
+ bgpPeerAttachmentPoint = "of:" \
+ + str( peer[ 'attachmentDpid' ] ).replace( ":", "" ) \
+ + ":" + str( peer[ 'attachmentPort' ] )
# find out the BGP speaker IP address for this BGP peer
bgpSpeakerIpAddress = ""
- for interfaceAddress in sdnipData[
- 'bgpSpeakers' ][ 0 ][ 'interfaceAddresses' ]:
+ for interfaceAddress in \
+ sdnipData[ 'bgpSpeakers' ][ 0 ][ 'interfaceAddresses' ]:
# if eq( interfaceAddress[ 'interfaceDpid' ],sdnipData[
# 'bgpSpeakers' ][ 0 ][ 'attachmentDpid' ] ) and eq(
- # interfaceAddress[ 'interfacePort' ], sdnipData[
- # 'bgpSpeakers' ][ 0 ][ 'attachmentPort' ] ):
- if eq(
- interfaceAddress[ 'interfaceDpid' ],
- peer[ 'attachmentDpid' ] ) and eq(
- interfaceAddress[ 'interfacePort' ],
+ # interfaceAddress[ 'interfacePort' ], sdnipData[ 'bgpSpeakers'
+ # ][ 0 ][ 'attachmentPort' ] ):
+ if eq( interfaceAddress[ 'interfaceDpid' ],
+ peer[ 'attachmentDpid' ] ) \
+ and eq( interfaceAddress[ 'interfacePort' ],
peer[ 'attachmentPort' ] ):
- bgpSpeakerIpAddress = interfaceAddress[ 'ip_address' ]
+ bgpSpeakerIpAddress = interfaceAddress[ 'ipAddress' ]
break
else:
continue
# from bgpSpeakerAttachmentPoint to bgpPeerAttachmentPoint
# direction
- selectorStr = "IPV4_SRC{ip=" + bgpSpeakerIpAddress +\
- "/32}," + "IPV4_DST{ip=" + peer[ 'ip_address' ] + "/32}," +\
- "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800},\
- TCP_DST{tcpPort=179}"
- selector = selectorStr.replace( " ", "" ).replace(
- "[", "" ).replace( "]", "" ).split( "," )
+ selectorStr = "IPV4_SRC{ip=" + bgpSpeakerIpAddress + "/32}," \
+ + "IPV4_DST{ip=" + peer[ 'ipAddress' ] + "/32}," \
+ + "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800}, \
+ TCP_DST{tcpPort=179}"
+ selector = selectorStr.replace( " ", "" ).replace("[", "" )\
+ .replace( "]", "" ).split( "," )
intent = bgpSpeakerAttachmentPoint + "/" + \
bgpPeerAttachmentPoint + "/" + str( sorted( selector ) )
intents.append( intent )
- selectorStr = "IPV4_SRC{ip=" + bgpSpeakerIpAddress + "/32}," +\
- "IPV4_DST{ip=" + peer[ 'ip_address' ] + "/32}," +\
- "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800},\
- TCP_SRC{tcpPort=179}"
- selector = selectorStr.replace( " ", "" ).replace(
- "[", "" ).replace( "]", "" ).split( "," )
- intent = bgpSpeakerAttachmentPoint + "/" + \
- bgpPeerAttachmentPoint + "/" + str( sorted( selector ) )
+ selectorStr = "IPV4_SRC{ip=" + bgpSpeakerIpAddress + "/32}," \
+ + "IPV4_DST{ip=" + peer[ 'ipAddress' ] + "/32}," \
+ + "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800}, \
+ TCP_SRC{tcpPort=179}"
+ selector = selectorStr.replace( " ", "" ).replace("[", "" )\
+ .replace( "]", "" ).split( "," )
+ intent = bgpSpeakerAttachmentPoint + "/" \
+ + bgpPeerAttachmentPoint + "/" + str( sorted( selector ) )
intents.append( intent )
# from bgpPeerAttachmentPoint to bgpSpeakerAttachmentPoint
# direction
- selectorStr = "IPV4_SRC{ip=" + peer[ 'ip_address' ] + "/32}," +\
- "IPV4_DST{ip=" + bgpSpeakerIpAddress + "/32}," + \
- "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800},\
- TCP_DST{tcpPort=179}"
- selector = selectorStr.replace( " ", "" ).replace(
- "[", "" ).replace( "]", "" ).split( "," )
- intent = bgpPeerAttachmentPoint + "/" + \
- bgpSpeakerAttachmentPoint + "/" + str( sorted( selector ) )
+ selectorStr = "IPV4_SRC{ip=" + peer[ 'ipAddress' ] + "/32}," \
+ + "IPV4_DST{ip=" + bgpSpeakerIpAddress + "/32}," \
+ + "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800}, \
+ TCP_DST{tcpPort=179}"
+ selector = selectorStr.replace( " ", "" ).replace("[", "" )\
+ .replace( "]", "" ).split( "," )
+ intent = bgpPeerAttachmentPoint + "/" \
+ + bgpSpeakerAttachmentPoint + "/" + str( sorted( selector ) )
intents.append( intent )
- selectorStr = "IPV4_SRC{ip=" + peer[ 'ip_address' ] + "/32}," +\
- "IPV4_DST{ip=" + bgpSpeakerIpAddress + "/32}," +\
- "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800},\
- TCP_SRC{tcpPort=179}"
- selector = selectorStr.replace( " ", "" ).replace(
- "[", "" ).replace( "]", "" ).split( "," )
- intent = bgpPeerAttachmentPoint + "/" + \
- bgpSpeakerAttachmentPoint + "/" + str( sorted( selector ) )
+ selectorStr = "IPV4_SRC{ip=" + peer[ 'ipAddress' ] + "/32}," \
+ + "IPV4_DST{ip=" + bgpSpeakerIpAddress + "/32}," \
+ + "IP_PROTO{protocol=6}, ETH_TYPE{ethType=800}, \
+ TCP_SRC{tcpPort=179}"
+ selector = selectorStr.replace( " ", "" ).replace( "[", "" )\
+ .replace( "]", "" ).split( "," )
+ intent = bgpPeerAttachmentPoint + "/" \
+ + bgpSpeakerAttachmentPoint + "/" + str( sorted( selector ) )
intents.append( intent )
return sorted( intents )
@@ -374,8 +348,8 @@
except:
main.log.warn( "Failed to add route" )
self.disconnect()
- waitTimer = 1.00 / routeRate
- time.sleep( waitTimer )
+ # waitTimer = 1.00 / routeRate
+ # time.sleep( waitTimer )
if routesAdded == len( routes ):
main.log.info( "Finished adding routes" )
return main.TRUE
@@ -400,10 +374,10 @@
self.handle.sendline( routeCmd )
self.handle.expect( "bgpd", timeout=5 )
except:
- main.log.warn( "Failed to add route" )
+ main.log.warn( "Failed to delete route" )
self.disconnect()
- waitTimer = 1.00 / routeRate
- time.sleep( waitTimer )
+ # waitTimer = 1.00 / routeRate
+ # time.sleep( waitTimer )
if routesAdded == len( routes ):
main.log.info( "Finished deleting routes" )
return main.TRUE
@@ -416,24 +390,15 @@
self.handle = super( QuaggaCliDriver, self ).connect(
user_name=self.user_name, ip_address=ip_address,
port=self.port, pwd=self.pwd )
- main.log.info( "connect parameters:" +
- str( self.user_name ) +
- ";" +
- str( self.ip_address ) +
- ";" +
- str( self.port ) +
- ";" +
- str( self.pwd ) )
+ main.log.info( "connect parameters:" + str( self.user_name ) + ";"
+ + str( self.ip_address ) + ";" + str( self.port )
+ + ";" + str( self.pwd ) )
if self.handle:
# self.handle.expect( "" )
# self.handle.expect( "\$" )
main.log.info( "I in host " + str( ip_address ) )
- main.log.info(
- pingTestFile +
- " > " +
- pingTestResultFile +
- " &" )
+ main.log.info( pingTestFile + " > " + pingTestResultFile + " &" )
self.handle.sendline(
pingTestFile +
" > " +
@@ -447,7 +412,7 @@
main.log.info( "NO HANDLE" )
return main.FALSE
- # Please use the generateRoutes plus addRoutes instead of this one
+ # Please use the generateRoutes plus addRoutes instead of this one!
def addRoute( self, net, numRoutes, routeRate ):
try:
self.handle.sendline( "" )
@@ -467,8 +432,8 @@
numRoutes = 255
for m in range( 1, j + 1 ):
for n in range( 1, numRoutes + 1 ):
- network = str( net ) + "." + str( m ) + \
- "." + str( n ) + ".0/24"
+ network = str( net ) + "." + str( m ) + "." + str( n ) \
+ + ".0/24"
routeCmd = "network " + network
try:
self.handle.sendline( routeCmd )
@@ -481,10 +446,8 @@
routesAdded = routesAdded + 1
for d in range( j + 1, j + 2 ):
for e in range( 1, k + 1 ):
- network = str(
- net ) + "." + str(
- d ) + "." + str(
- e ) + ".0/24"
+ network = str( net ) + "." + str( d ) + "." + str( e ) \
+ + ".0/24"
routeCmd = "network " + network
try:
self.handle.sendline( routeCmd )
@@ -498,7 +461,8 @@
if routesAdded == numRoutes:
return main.TRUE
return main.FALSE
-
+
+ # Please use deleteRoutes method instead of this one!
def delRoute( self, net, numRoutes, routeRate ):
try:
self.handle.sendline( "" )
@@ -518,8 +482,8 @@
numRoutes = 255
for m in range( 1, j + 1 ):
for n in range( 1, numRoutes + 1 ):
- network = str( net ) + "." + str( m ) + \
- "." + str( n ) + ".0/24"
+ network = str( net ) + "." + str( m ) + "." + str( n ) \
+ + ".0/24"
routeCmd = "no network " + network
try:
self.handle.sendline( routeCmd )
@@ -532,8 +496,8 @@
routesDeleted = routesDeleted + 1
for d in range( j + 1, j + 2 ):
for e in range( 1, k + 1 ):
- network = str( net ) + "." + str( d ) + \
- "." + str( e ) + ".0/24"
+ network = str( net ) + "." + str( d ) + "." + str( e ) \
+ + ".0/24"
routeCmd = "no network " + network
try:
self.handle.sendline( routeCmd )
@@ -554,7 +518,7 @@
child = pexpect.spawn( "telnet " + ip )
i = child.expect( [ "login:", "CLI#", pexpect.TIMEOUT ] )
if i == 0:
- print "Username and password required. Passing login info."
+ print "user_name and password required. Passing login info."
child.sendline( user )
child.expect( "Password:" )
child.sendline( passwd )
@@ -570,10 +534,8 @@
child.expect( "Flow table show" )
count = 0
while True:
- i = child.expect(
- [ '17\d\.\d{1,3}\.\d{1,3}\.\d{1,3}',
- 'CLI#',
- pexpect.TIMEOUT ] )
+ i = child.expect( [ '17\d\.\d{1,3}\.\d{1,3}\.\d{1,3}',
+ 'CLI#', pexpect.TIMEOUT ] )
if i == 0:
count = count + 1
elif i == 1:
@@ -620,3 +582,4 @@
main.log.error( "Connection failed to the host" )
response = main.FALSE
return response
+
diff --git a/TestON/drivers/common/clidriver.py b/TestON/drivers/common/clidriver.py
index 6d7fb2a..1b8998b 100644
--- a/TestON/drivers/common/clidriver.py
+++ b/TestON/drivers/common/clidriver.py
@@ -81,7 +81,7 @@
while i == 5:
i = self.handle.expect( [
ssh_newkey,
- 'password:',
+ 'password:|\$',
pexpect.EOF,
pexpect.TIMEOUT,
refused,
diff --git a/TestON/tests/FuncNext13/FuncNext13.params b/TestON/tests/FuncNext13/FuncNext13.params
new file mode 100755
index 0000000..13a4691
--- /dev/null
+++ b/TestON/tests/FuncNext13/FuncNext13.params
@@ -0,0 +1,37 @@
+<PARAMS>
+
+ <testcases>1,4,5,3</testcases>
+
+ #Environment variables
+ <ENV>
+ <cellName>driver_test</cellName>
+ </ENV>
+
+ <CTRL>
+ <ip1>10.128.20.11</ip1>
+ <port1>6633</port1>
+ </CTRL>
+
+ <PING>
+ <source1>h8</source1>
+ <source2>h9</source2>
+ <source3>h10</source3>
+ <source4>h11</source4>
+ <source5>h12</source5>
+ <source6>h13</source6>
+ <source7>h14</source7>
+ <source8>h15</source8>
+ <source9>h16</source9>
+ <source10>h17</source10>
+ <target1>10.0.0.18</target1>
+ <target2>10.0.0.19</target2>
+ <target3>10.0.0.20</target3>
+ <target4>10.0.0.21</target4>
+ <target5>10.0.0.22</target5>
+ <target6>10.0.0.23</target6>
+ <target7>10.0.0.24</target7>
+ <target8>10.0.0.25</target8>
+ <target9>10.0.0.26</target9>
+ <target10>10.0.0.27</target10>
+ </PING>
+</PARAMS>
diff --git a/TestON/tests/FuncNext13/FuncNext13.py b/TestON/tests/FuncNext13/FuncNext13.py
new file mode 100755
index 0000000..6b24695
--- /dev/null
+++ b/TestON/tests/FuncNext13/FuncNext13.py
@@ -0,0 +1,608 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import sys
+import os
+import re
+import time
+import json
+
+time.sleep(1)
+class FuncNext13:
+ def __init__(self):
+ self.default = ''
+
+ def CASE1(self, main):
+ '''
+ Startup sequence:
+ git pull
+ mvn clean install
+ onos-package
+ cell <name>
+ onos-verify-cell
+ onos-install -f
+ onos-wait-for-start
+ '''
+
+ cell_name = main.params['ENV']['cellName']
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS1_port = main.params['CTRL']['port1']
+
+ main.case("Setting up test environment")
+
+ main.step("Git checkout and pull master and get version")
+ main.ONOSbench.git_checkout("master")
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ version_result = main.ONOSbench.get_version()
+
+ if git_pull_result == 1:
+ main.step("Using mvn clean & install")
+ clean_install_result = main.ONOSbench.clean_install()
+ #clean_install_result = main.TRUE
+
+ main.step("Applying cell variable to environment")
+ cell_result1 = main.ONOSbench.set_cell(cell_name)
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result2 = main.ONOS2.set_cell(cell_name)
+ #verify_result = main.ONOS2.verify_cell()
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ cell_result = cell_result1 and cell_result2
+
+ main.step("Creating ONOS package")
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step("Creating a cell")
+ #cell_create_result = main.ONOSbench.create_cell_file(**************)
+
+ main.step("Installing ONOS package")
+ onos_install_result = main.ONOSbench.onos_install()
+ onos1_isup = main.ONOSbench.isup()
+
+ main.step("Starting ONOS service")
+ start_result = main.ONOSbench.onos_start(ONOS1_ip)
+
+ case1_result = (package_result and\
+ cell_result and verify_result and onos_install_result and\
+ onos1_isup and start_result )
+ utilities.assert_equals(expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful")
+
+ def CASE11(self, main):
+ '''
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Cleaning up test environment")
+
+ main.step("Testing ONOS kill function")
+ kill_result = main.ONOSbench.onos_kill(ONOS1_ip)
+
+ main.step("Stopping ONOS service")
+ stop_result = main.ONOSbench.onos_stop(ONOS1_ip)
+
+ main.step("Uninstalling ONOS service")
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ def CASE3(self, main):
+ '''
+ Test 'onos' command and its functionality in driver
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Testing 'onos' command")
+
+ main.step("Sending command 'onos -w <onos-ip> system:name'")
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result1)
+
+ main.step("Sending command 'onos -w <onos-ip> onos:topology'")
+ cmdstr2 = "onos:topology"
+ cmd_result2 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result2)
+
+
+
+ def CASE4(self, main):
+ import re
+ import time
+ main.case("Pingall Test")
+ main.step("Assigning switches to controllers")
+ for i in range(1,29):
+ if i ==1:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=2 and i<5:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=5 and i<8:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=8 and i<18:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=18 and i<28:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ else:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ Switch_Mastership = main.TRUE
+ for i in range (1,29):
+ if i==1:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=2 and i<5:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=5 and i<8:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=8 and i<18:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=18 and i<28:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ else:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is" + str(response))
+ if re.search("tcp:" +ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+
+ if Switch_Mastership == main.TRUE:
+ main.log.report("MasterControllers assigned correctly")
+ utilities.assert_equals(expect = main.TRUE,actual=Switch_Mastership,
+ onpass="MasterControllers assigned correctly")
+ '''
+ for i in range (1,29):
+ main.Mininet1.assign_sw_controller(sw=str(i),count=5,
+ ip1=ONOS1_ip,port1=ONOS1_port,
+ ip2=ONOS2_ip,port2=ONOS2_port,
+ ip3=ONOS3_ip,port3=ONOS3_port,
+ ip4=ONOS4_ip,port4=ONOS4_port,
+ ip5=ONOS5_ip,port5=ONOS5_port)
+ '''
+ #REACTIVE FWD test
+
+ main.step("Get list of hosts from Mininet")
+ host_list = main.Mininet1.get_hosts()
+ main.log.info(host_list)
+
+ main.step("Get host list in ONOS format")
+ host_onos_list = main.ONOS2.get_hosts_id(host_list)
+ main.log.info(host_onos_list)
+ #time.sleep(5)
+
+ #We must use ping from hosts we want to add intents from
+ #to make the hosts talk
+ #main.Mininet2.handle.sendline("\r")
+ #main.Mininet2.handle.sendline("h4 ping 10.1.1.1 -c 1 -W 1")
+ #time.sleep(3)
+ #main.Mininet2.handle.sendline("h5 ping 10.1.1.1 -c 1 -W 1")
+ #time.sleep(5)
+
+ main.step("Pingall")
+ ping_result = main.FALSE
+ while ping_result == main.FALSE:
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % (time2 - time1)
+
+ #Start onos cli again because u might have dropped out of onos prompt to the shell prompt
+ #if there was no activity
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ main.step("Get hosts")
+ main.ONOS2.handle.sendline("hosts")
+ main.ONOS2.handle.expect("onos>")
+ hosts = main.ONOS2.handle.before
+ main.log.info(hosts)
+
+ main.step("Get all devices id")
+ devices_id_list = main.ONOS2.get_all_devices_id()
+ main.log.info(devices_id_list)
+
+ #ONOS displays the hosts in hex format unlike mininet which does in decimal format
+ #So take care while adding intents
+
+ main.step("Add host-to-host intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1")
+
+
+
+ print "_____________________________________________________________________________________"
+ '''
+ main.step("Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003008", 1, "of:0000000000006018", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006018", 1, "of:0000000000003008", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h9 and h19 or ONOS hosts h9 and h13")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003009", 1, "of:0000000000006019", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006019", 1, "of:0000000000003009", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h10 and h20 or ONOS hosts hA and h14")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003010", 1, "of:0000000000006020", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006020", 1, "of:0000000000003010", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h11 and h21 or ONOS hosts hB and h15")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003011", 1, "of:0000000000006021", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006021", 1, "of:0000000000003011", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h12 and h22 or ONOS hosts hC and h16")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003012", 1, "of:0000000000006022", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006022", 1, "of:0000000000003012", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h13 and h23 or ONOS hosts hD and h17")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003013", 1, "of:0000000000006023", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006023", 1, "of:0000000000003013", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h14 and h24 or ONOS hosts hE and h18")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003014", 1, "of:0000000000006024", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006024", 1, "of:0000000000003014", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h15 and h25 or ONOS hosts hF and h19")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003015", 1, "of:0000000000006025", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006025", 1, "of:0000000000003015", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h16 and h26 or ONOS hosts h10 and h1A")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003016", 1, "of:0000000000006026", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006026", 1, "of:0000000000003016", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h17 and h27 or ONOS hosts h11 and h1B")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003017", 1, "of:0000000000006027", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006027", 1, "of:0000000000003017", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ print("_______________________________________________________________________________________")
+ '''
+
+ #Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstall_result = main.ONOS2.feature_uninstall("onos-app-fwd")
+ main.log.info("onos-app-fwd uninstalled")
+
+ #After reactive forwarding is disabled, the reactive flows on switches timeout in 10-15s
+ #So sleep for 15s
+ time.sleep(15)
+
+ flowHandle = main.ONOS2.flows()
+ print "flowHandle = ", flowHandle
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ #while i<10:
+ while i <18 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping == main.FALSE and count <5:
+ count+=1
+ i = 8
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+10) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts have failed")
+ i=19
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test passed!")
+ i+=1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+ if Ping_Result==main.FALSE:
+ main.log.report("Intents have not ben installed correctly. Cleaning up")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Intents have been installed correctly")
+
+ case4_result = Switch_Mastership and Ping_Result
+ utilities.assert_equals(expect=main.TRUE, actual=case4_result,
+ onpass="Pingall Test successful",
+ onfail="Pingall Test NOT successful")
+
+ def CASE5(self,main) :
+ import json
+ from subprocess import Popen, PIPE
+ from sts.topology.teston_topology import TestONTopology # assumes that sts is already in you PYTHONPATH
+ #main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+ deviceResult = main.ONOS2.devices()
+ linksResult = main.ONOS2.links()
+ portsResult = main.ONOS2.ports()
+ print "**************"
+ main.step("Start continuous pings")
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+ main.step("Create TestONTopology object")
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ('ip' + str(count)) in main.params['CTRL']:
+ temp = temp + (getattr(main,('ONOS' + str(count))),)
+ temp = temp + ("ONOS"+str(count),)
+ temp = temp + (main.params['CTRL']['ip'+str(count)],)
+ temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
+ ctrls.append(temp)
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step("Compare ONOS Topology to MN Topology")
+ devices_json = main.ONOS2.devices()
+ links_json = main.ONOS2.links()
+ ports_json = main.ONOS2.ports()
+ print "devices_json= ", devices_json
+
+ result1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices_json))
+ print "***********************"
+ result2 = main.Mininet1.compare_links(MNTopo, json.loads(links_json))
+ print "***********************"
+ result3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports_json))
+
+ result = result1 and result2 and result3
+ print "***********************"
+ if result == main.TRUE:
+ main.log.report("ONOS"+ " Topology matches MN Topology")
+ utilities.assert_equals(expect=main.TRUE,actual=result,
+ onpass="ONOS" + " Topology matches MN Topology",
+ onfail="ONOS" + " Topology does not match MN Topology")
+ Topology_Check = Topology_Check and result
+ utilities.assert_equals(expect=main.TRUE,actual=Topology_Check,
+ onpass="Topology checks passed", onfail="Topology checks failed")
+
+
+ def CASE7 (self,main):
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ link_sleep = int(main.params['timers']['LinkDiscovery'])
+
+ main.log.report("Killing a link to ensure that link discovery is consistent")
+ main.case("Killing a link to Ensure that Link Discovery is Working Properly")
+ main.step("Start continuous pings")
+
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+
+ main.step("Determine the current number of switches and links")
+ topology_output = main.ONOS2.topology()
+ topology_result = main.ONOS1.get_topology(topology_output)
+ activeSwitches = topology_result['devices']
+ links = topology_result['links']
+ print "activeSwitches = ", type(activeSwitches)
+ print "links = ", type(links)
+ main.log.info("Currently there are %s switches and %s links" %(str(activeSwitches), str(links)))
+
+ main.step("Kill Link between s3 and s28")
+ main.Mininet1.link(END1="s3",END2="s28",OPTION="down")
+ time.sleep(link_sleep)
+ topology_output = main.ONOS2.topology()
+ Link_Down = main.ONOS1.check_status(topology_output,activeSwitches,str(int(links)-2))
+ if Link_Down == main.TRUE:
+ main.log.report("Link Down discovered properly")
+ utilities.assert_equals(expect=main.TRUE,actual=Link_Down,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in "+ str(link_sleep) + " seconds")
+
+ main.step("Bring link between s3 and s28 back up")
+ Link_Up = main.Mininet1.link(END1="s3",END2="s28",OPTION="up")
+ time.sleep(link_sleep)
+ topology_output = main.ONOS2.topology()
+ Link_Up = main.ONOS1.check_status(topology_output,activeSwitches,str(links))
+ if Link_Up == main.TRUE:
+ main.log.report("Link up discovered properly")
+ utilities.assert_equals(expect=main.TRUE,actual=Link_Up,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in "+ str(link_sleep) + " seconds")
+
+
+
+
+ main.step("Compare ONOS Topology to MN Topology")
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+ Topology_Check = main.TRUE
+ devices_json = main.ONOS2.devices()
+ links_json = main.ONOS2.links()
+ ports_json = main.ONOS2.ports()
+ print "devices_json= ", devices_json
+
+ result1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices_json))
+ print "***********************"
+ result2 = main.Mininet1.compare_links(MNTopo, json.loads(links_json))
+ print "***********************"
+ result3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports_json))
+
+ result = result1 and result2 and result3
+ print "***********************"
+ if result == main.TRUE:
+ main.log.report("ONOS"+ " Topology matches MN Topology")
+ utilities.assert_equals(expect=main.TRUE,actual=result,
+ onpass="ONOS" + " Topology matches MN Topology",
+ onfail="ONOS" + " Topology does not match MN Topology")
+ Topology_Check = Topology_Check and result
+ utilities.assert_equals(expect=main.TRUE,actual=Topology_Check,
+ onpass="Topology checks passed", onfail="Topology checks failed")
+
+ result = Link_Down and Link_Up and Topology_Check
+ utilities.assert_equals(expect=main.TRUE,actual=result,
+ onpass="Link failure is discovered correctly",
+ onfail="Link Discovery failed")
+
+
+
diff --git a/TestON/tests/FuncNext13/FuncNext13.topo b/TestON/tests/FuncNext13/FuncNext13.topo
new file mode 100755
index 0000000..85b6cab
--- /dev/null
+++ b/TestON/tests/FuncNext13/FuncNext13.topo
@@ -0,0 +1,61 @@
+<TOPOLOGY>
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1>
+ <host>10.128.10.11</host>
+ <user>sdn</user>
+ <password>sdn</password>
+ <type>OnosDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <Mininet1>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>MininetCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow13</arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet1>
+
+ <Mininet2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow13 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet2>
+ </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/FuncNext13/__init__.py b/TestON/tests/FuncNext13/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/FuncNext13/__init__.py
diff --git a/TestON/tests/HATestClusterRestart/HATestClusterRestart.params b/TestON/tests/HATestClusterRestart/HATestClusterRestart.params
index 7556184..6f2002d 100644
--- a/TestON/tests/HATestClusterRestart/HATestClusterRestart.params
+++ b/TestON/tests/HATestClusterRestart/HATestClusterRestart.params
@@ -4,6 +4,7 @@
<cellName>HA</cellName>
</ENV>
<Git>False</Git>
+ <branch> master </branch>
<num_controllers> 7 </num_controllers>
<CTRL>
diff --git a/TestON/tests/HATestClusterRestart/HATestClusterRestart.py b/TestON/tests/HATestClusterRestart/HATestClusterRestart.py
index 2b28907..ff38cfe 100644
--- a/TestON/tests/HATestClusterRestart/HATestClusterRestart.py
+++ b/TestON/tests/HATestClusterRestart/HATestClusterRestart.py
@@ -49,7 +49,7 @@
PULLCODE = False
if main.params[ 'Git' ] == 'True':
PULLCODE = True
-
+ gitBranch = main.params[ 'branch' ]
cellName = main.params[ 'ENV' ][ 'cellName' ]
# set global variables
@@ -104,17 +104,17 @@
cleanInstallResult = main.TRUE
gitPullResult = main.TRUE
+ main.step( "Starting Mininet" )
+ main.Mininet1.startNet( )
+
main.step( "Compiling the latest version of ONOS" )
if PULLCODE:
# TODO Configure branch in params
main.step( "Git checkout and pull master" )
- main.ONOSbench.gitCheckout( "master" )
+ main.ONOSbench.gitCheckout( gitBranch )
gitPullResult = main.ONOSbench.gitPull()
main.step( "Using mvn clean & install" )
- cleanInstallResult = main.TRUE
- # In Sanity test, always re-compile ONOS
- if gitPullResult == main.TRUE:
cleanInstallResult = main.ONOSbench.cleanInstall()
else:
main.log.warn( "Did not pull new code so skipping mvn " +
@@ -385,7 +385,6 @@
def CASE3( self, main ):
"""
Assign intents
-
"""
# FIXME: we must reinstall intents until we have a persistant
# datastore!
@@ -410,6 +409,11 @@
pingResult = main.FALSE
time1 = time.time()
pingResult = main.Mininet1.pingall()
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=pingResult,
+ onpass="Reactive Pingall test passed",
+ onfail="Reactive Pingall failed, one or more ping pairs failed" )
time2 = time.time()
main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
@@ -435,23 +439,41 @@
str( hex( i )[ 2: ] ).zfill( 2 ).upper()
host2 = "00:00:00:00:00:" + \
str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
- host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
- host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
- # NOTE: get host can return None
+ # NOTE: getHost can return None
+ host1Dict = main.ONOScli1.getHost( host1 )
+ host2Dict = main.ONOScli1.getHost( host2 )
+ host1Id = None
+ host2Id = None
+ if host1Dict and host2Dict:
+ host1Id = host1Dict.get( 'id', None )
+ host2Id = host2Dict.get( 'id', None )
if host1Id and host2Id:
tmpResult = main.ONOScli1.addHostIntent(
host1Id,
host2Id )
else:
main.log.error( "Error, getHost() failed" )
+ main.log.warn( json.dumps( json.loads( main.ONOScli1.hosts() ),
+ sort_keys=True,
+ indent=4,
+ separators=( ',', ': ' ) ) )
tmpResult = main.FALSE
intentAddResult = bool( pingResult and intentAddResult
and tmpResult )
+ # TODO Check that intents were added?
+ # Print the intent states
+ intents = main.ONOScli1.intents( )
+ intentStates = []
+ for intent in json.loads( intents ): # Iter through intents of a node
+ intentStates.append( intent.get( 'state', None ) )
+ out = [ (i, intentStates.count( i ) ) for i in set( intentStates ) ]
+ main.log.info( dict( out ) )
+
utilities.assert_equals(
expect=True,
actual=intentAddResult,
- onpass="Switch mastership correctly assigned",
- onfail="Error in ( re )assigning switch mastership" )
+ onpass="Pushed host intents to ONOS",
+ onfail="Error in pushing host intents to ONOS" )
# TODO Check if intents all exist in datastore
def CASE4( self, main ):
@@ -475,6 +497,12 @@
if PingResult == main.FALSE:
main.log.report(
"Intents have not been installed correctly, pings failed." )
+ #TODO: pretty print
+ main.log.warn( "ONSO1 intents: " )
+ main.log.warn( json.dumps( json.loads( main.ONOScli1.intents() ),
+ sort_keys=True,
+ indent=4,
+ separators=( ',', ': ' ) ) )
if PingResult == main.TRUE:
main.log.report(
"Intents have been installed correctly and verified by pings" )
@@ -924,23 +952,7 @@
clusters.append( main.ONOScli5.clusters() )
clusters.append( main.ONOScli6.clusters() )
clusters.append( main.ONOScli7.clusters() )
- paths = []
- tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
-
- # Compare json objects for hosts, dataplane clusters and paths
+ # Compare json objects for hosts and dataplane clusters
# hosts
consistentHostsResult = main.TRUE
@@ -1003,30 +1015,6 @@
str( numClusters ) +
" SCCs" )
- # paths
- consistentPathsResult = main.TRUE
- for controller in range( len( paths ) ):
- controllerStr = str( controller + 1 )
- if "Error" not in paths[ controller ]:
- if paths[ controller ] == paths[ 0 ]:
- continue
- else: # paths not consistent
- main.log.report( "paths from ONOS" + controllerStr +
- " is inconsistent with ONOS1" )
- consistentPathsResult = main.FALSE
-
- else:
- main.log.report( "Error in getting paths from ONOS" +
- controllerStr )
- consistentPathsResult = main.FALSE
- main.log.warn( "ONOS" + controllerStr + " paths response: " +
- repr( paths[ controller ] ) )
- utilities.assert_equals(
- expect=main.TRUE,
- actual=consistentPathsResult,
- onpass="Paths count is consistent across all ONOS nodes",
- onfail="ONOS nodes have different counts of paths" )
-
main.step( "Comparing ONOS topology to MN" )
devicesResults = main.TRUE
portsResults = main.TRUE
@@ -1080,8 +1068,7 @@
linksResults = linksResults and currentLinksResult
topoResult = devicesResults and portsResults and linksResults\
- and consistentHostsResult and consistentClustersResult\
- and consistentPathsResult
+ and consistentHostsResult and consistentClustersResult
utilities.assert_equals( expect=main.TRUE, actual=topoResult,
onpass="Topology Check Test successful",
onfail="Topology Check Test NOT successful" )
@@ -1323,6 +1310,24 @@
actual=intentCheck,
onpass="Intents are consistent across all ONOS nodes",
onfail="ONOS nodes have different views of intents" )
+ # Print the intent states
+ intents = []
+ intents.append( ONOS1Intents )
+ intents.append( ONOS2Intents )
+ intents.append( ONOS3Intents )
+ intents.append( ONOS4Intents )
+ intents.append( ONOS5Intents )
+ intents.append( ONOS6Intents )
+ intents.append( ONOS7Intents )
+ intentStates = []
+ for node in intents: # Iter through ONOS nodes
+ nodeStates = []
+ for intent in json.loads( node ): # Iter through intents of a node
+ nodeStates.append( intent[ 'state' ] )
+ intentStates.append( nodeStates )
+ out = [ (i, nodeStates.count( i ) ) for i in set( nodeStates ) ]
+ main.log.info( dict( out ) )
+
# NOTE: Hazelcast has no durability, so intents are lost across system
# restarts
@@ -1330,7 +1335,8 @@
main.step( "Compare current intents with intents before the failure" )
# NOTE: this requires case 5 to pass for intentState to be set.
# maybe we should stop the test if that fails?
- if intentState == ONOS1Intents:
+ sameIntents = main.TRUE
+ if intentState and intentState == ONOS1Intents:
sameIntents = main.TRUE
main.log.report( "Intents are consistent with before failure" )
# TODO: possibly the states have changed? we may need to figure out
@@ -1509,13 +1515,20 @@
devices.append( main.ONOScli6.devices() )
devices.append( main.ONOScli7.devices() )
hosts = []
- hosts.append( main.ONOScli1.hosts() )
- hosts.append( main.ONOScli2.hosts() )
- hosts.append( main.ONOScli3.hosts() )
- hosts.append( main.ONOScli4.hosts() )
- hosts.append( main.ONOScli5.hosts() )
- hosts.append( main.ONOScli6.hosts() )
- hosts.append( main.ONOScli7.hosts() )
+ hosts.append( json.loads( main.ONOScli1.hosts() ) )
+ hosts.append( json.loads( main.ONOScli2.hosts() ) )
+ hosts.append( json.loads( main.ONOScli3.hosts() ) )
+ hosts.append( json.loads( main.ONOScli4.hosts() ) )
+ hosts.append( json.loads( main.ONOScli5.hosts() ) )
+ hosts.append( json.loads( main.ONOScli6.hosts() ) )
+ hosts.append( json.loads( main.ONOScli7.hosts() ) )
+ for controller in range( 0, len( hosts ) ):
+ controllerStr = str( controller + 1 )
+ for host in hosts[ controller ]:
+ if host[ 'ips' ] == []:
+ main.log.error(
+ "DEBUG:Error with host ips on controller" +
+ controllerStr + ": " + str( host ) )
ports = []
ports.append( main.ONOScli1.ports() )
ports.append( main.ONOScli2.ports() )
@@ -1540,21 +1553,6 @@
clusters.append( main.ONOScli5.clusters() )
clusters.append( main.ONOScli6.clusters() )
clusters.append( main.ONOScli7.clusters() )
- paths = []
- tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
elapsed = time.time() - startTime
cliTime = time.time() - cliStart
@@ -1608,7 +1606,7 @@
portsResults = portsResults and currentPortsResult
linksResults = linksResults and currentLinksResult
- # Compare json objects for hosts, dataplane clusters and paths
+ # Compare json objects for hosts and dataplane clusters
# hosts
consistentHostsResult = main.TRUE
@@ -1671,41 +1669,15 @@
str( numClusters ) +
" SCCs" )
- # paths
- consistentPathsResult = main.TRUE
- for controller in range( len( paths ) ):
- controllerStr = str( controller + 1 )
- if "Error" not in paths[ controller ]:
- if paths[ controller ] == paths[ 0 ]:
- continue
- else: # paths not consistent
- main.log.report( "paths from ONOS" + controllerStr +
- " is inconsistent with ONOS1" )
- consistentPathsResult = main.FALSE
-
- else:
- main.log.report( "Error in getting paths from ONOS" +
- controllerStr )
- consistentPathsResult = main.FALSE
- main.log.warn( "ONOS" + controllerStr +
- " paths response: " +
- repr( paths[ controller ] ) )
- utilities.assert_equals(
- expect=main.TRUE,
- actual=consistentPathsResult,
- onpass="Paths count is consistent across all ONOS nodes",
- onfail="ONOS nodes have different counts of paths" )
-
topoResult = ( devicesResults and portsResults and linksResults
and consistentHostsResult
- and consistentClustersResult
- and consistentPathsResult )
+ and consistentClustersResult )
topoResult = topoResult and int( count <= 2 )
note = "note it takes about " + str( int( cliTime ) ) + \
" seconds for the test to make all the cli calls to fetch " +\
"the topology from each ONOS instance"
- main.log.report(
+ main.log.info(
"Very crass estimate for topology discovery/convergence( " +
str( note ) + " ): " + str( elapsed ) + " seconds, " +
str( count ) + " tries" )
diff --git a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params
index cf0ca61..7d79860 100644
--- a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params
+++ b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.params
@@ -4,6 +4,7 @@
<cellName>HA</cellName>
</ENV>
<Git>False</Git>
+ <branch> master </branch>
<num_controllers> 7 </num_controllers>
<CTRL>
diff --git a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py
index 7517827..3d9adc7 100644
--- a/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py
+++ b/TestON/tests/HATestMinorityRestart/HATestMinorityRestart.py
@@ -49,7 +49,7 @@
PULLCODE = False
if main.params[ 'Git' ] == 'True':
PULLCODE = True
-
+ gitBranch = main.params[ 'branch' ]
cellName = main.params[ 'ENV' ][ 'cellName' ]
# set global variables
@@ -104,21 +104,21 @@
cleanInstallResult = main.TRUE
gitPullResult = main.TRUE
+ main.step( "Starting Mininet" )
+ main.Mininet1.startNet( )
+
main.step( "Compiling the latest version of ONOS" )
if PULLCODE:
# TODO Configure branch in params
main.step( "Git checkout and pull master" )
- main.ONOSbench.gitCheckout( "master" )
+ main.ONOSbench.gitCheckout( gitBranch )
gitPullResult = main.ONOSbench.gitPull()
main.step( "Using mvn clean & install" )
- cleanInstallResult = main.TRUE
-
- if gitPullResult == main.TRUE:
- cleanInstallResult = main.ONOSbench.cleanInstall()
- else:
- main.log.warn( "Did not pull new code so skipping mvn " +
- "clean install" )
+ cleanInstallResult = main.ONOSbench.cleanInstall()
+ else:
+ main.log.warn( "Did not pull new code so skipping mvn " +
+ "clean install" )
main.ONOSbench.getVersion( report=True )
main.step( "Creating ONOS package" )
@@ -385,7 +385,6 @@
def CASE3( self, main ):
"""
Assign intents
-
"""
import time
main.log.report( "Adding host intents" )
@@ -408,6 +407,11 @@
pingResult = main.FALSE
time1 = time.time()
pingResult = main.Mininet1.pingall()
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=pingResult,
+ onpass="Reactive Pingall test passed",
+ onfail="Reactive Pingall failed, one or more ping pairs failed" )
time2 = time.time()
main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
@@ -433,23 +437,42 @@
str( hex( i )[ 2: ] ).zfill( 2 ).upper()
host2 = "00:00:00:00:00:" + \
str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
- host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
- host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
- # NOTE: get host can return None
+ # NOTE: getHost can return None
+ host1Dict = main.ONOScli1.getHost( host1 )
+ host2Dict = main.ONOScli1.getHost( host2 )
+ host1Id = None
+ host2Id = None
+ if host1Dict and host2Dict:
+ host1Id = host1Dict.get( 'id', None )
+ host2Id = host2Dict.get( 'id', None )
if host1Id and host2Id:
- tmpResult = main.ONOScli1.addHostIntent(
+ #Changed onos node to test something
+ tmpResult = main.ONOScli4.addHostIntent(
host1Id,
host2Id )
else:
main.log.error( "Error, getHost() failed" )
+ main.log.warn( json.dumps( json.loads( main.ONOScli1.hosts() ),
+ sort_keys=True,
+ indent=4,
+ separators=( ',', ': ' ) ) )
tmpResult = main.FALSE
intentAddResult = bool( pingResult and intentAddResult
and tmpResult )
+ # TODO Check that intents were added?
+ # Print the intent states
+ intents = main.ONOScli1.intents( )
+ intentStates = []
+ for intent in json.loads( intents ): # Iter through intents of a node
+ intentStates.append( intent.get( 'state', None ) )
+ out = [ (i, intentStates.count( i ) ) for i in set( intentStates ) ]
+ main.log.info( dict( out ) )
+
utilities.assert_equals(
expect=True,
actual=intentAddResult,
- onpass="Switch mastership correctly assigned",
- onfail="Error in ( re )assigning switch mastership" )
+ onpass="Pushed host intents to ONOS",
+ onfail="Error in pushing host intents to ONOS" )
# TODO Check if intents all exist in datastore
def CASE4( self, main ):
@@ -473,6 +496,12 @@
if PingResult == main.FALSE:
main.log.report(
"Intents have not been installed correctly, pings failed." )
+ #TODO: pretty print
+ main.log.warn( "ONSO1 intents: " )
+ main.log.warn( json.dumps( json.loads( main.ONOScli1.intents() ),
+ sort_keys=True,
+ indent=4,
+ separators=( ',', ': ' ) ) )
if PingResult == main.TRUE:
main.log.report(
"Intents have been installed correctly and verified by pings" )
@@ -898,12 +927,6 @@
hosts.append( main.ONOScli5.hosts() )
hosts.append( main.ONOScli6.hosts() )
hosts.append( main.ONOScli7.hosts() )
- for controller in range( 0, len( hosts ) ):
- controllerStr = str( controller + 1 )
- for host in hosts[ controller ]:
- if host[ 'ips' ] == []:
- main.log.error( "DEBUG:Error with host ips on controller" +
- controllerStr + ": " + str( host ) )
ports = []
ports.append( main.ONOScli1.ports() )
ports.append( main.ONOScli2.ports() )
@@ -928,23 +951,7 @@
clusters.append( main.ONOScli5.clusters() )
clusters.append( main.ONOScli6.clusters() )
clusters.append( main.ONOScli7.clusters() )
- paths = []
- tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
-
- # Compare json objects for hosts, dataplane clusters and paths
+ # Compare json objects for hosts and dataplane clusters
# hosts
consistentHostsResult = main.TRUE
@@ -1007,30 +1014,6 @@
str( numClusters ) +
" SCCs" )
- # paths
- consistentPathsResult = main.TRUE
- for controller in range( len( paths ) ):
- controllerStr = str( controller + 1 )
- if "Error" not in paths[ controller ]:
- if paths[ controller ] == paths[ 0 ]:
- continue
- else: # paths not consistent
- main.log.report( "paths from ONOS" + controllerStr +
- " is inconsistent with ONOS1" )
- consistentPathsResult = main.FALSE
-
- else:
- main.log.report( "Error in getting paths from ONOS" +
- controllerStr )
- consistentPathsResult = main.FALSE
- main.log.warn( "ONOS" + controllerStr + " paths response: " +
- repr( paths[ controller ] ) )
- utilities.assert_equals(
- expect=main.TRUE,
- actual=consistentPathsResult,
- onpass="Paths count is consistent across all ONOS nodes",
- onfail="ONOS nodes have different counts of paths" )
-
main.step( "Comparing ONOS topology to MN" )
devicesResults = main.TRUE
portsResults = main.TRUE
@@ -1084,8 +1067,7 @@
linksResults = linksResults and currentLinksResult
topoResult = devicesResults and portsResults and linksResults\
- and consistentHostsResult and consistentClustersResult\
- and consistentPathsResult
+ and consistentHostsResult and consistentClustersResult
utilities.assert_equals( expect=main.TRUE, actual=topoResult,
onpass="Topology Check Test successful",
onfail="Topology Check Test NOT successful" )
@@ -1320,13 +1302,32 @@
actual=intentCheck,
onpass="Intents are consistent across all ONOS nodes",
onfail="ONOS nodes have different views of intents" )
+ # Print the intent states
+ intents = []
+ intents.append( ONOS1Intents )
+ intents.append( ONOS2Intents )
+ intents.append( ONOS3Intents )
+ intents.append( ONOS4Intents )
+ intents.append( ONOS5Intents )
+ intents.append( ONOS6Intents )
+ intents.append( ONOS7Intents )
+ intentStates = []
+ for node in intents: # Iter through ONOS nodes
+ nodeStates = []
+ for intent in json.loads( node ): # Iter through intents of a node
+ nodeStates.append( intent[ 'state' ] )
+ intentStates.append( nodeStates )
+ out = [ (i, nodeStates.count( i ) ) for i in set( nodeStates ) ]
+ main.log.info( dict( out ) )
+
# NOTE: Hazelcast has no durability, so intents are lost across system
# restarts
main.step( "Compare current intents with intents before the failure" )
# NOTE: this requires case 5 to pass for intentState to be set.
# maybe we should stop the test if that fails?
- if intentState == ONOS1Intents:
+ sameIntents = main.TRUE
+ if intentState and intentState == ONOS1Intents:
sameIntents = main.TRUE
main.log.report( "Intents are consistent with before failure" )
# TODO: possibly the states have changed? we may need to figure out
@@ -1520,7 +1521,6 @@
for controller in range( 0, len( hosts ) ):
controllerStr = str( controller + 1 )
for host in hosts[ controller ]:
- host
if host[ 'ips' ] == []:
main.log.error(
"DEBUG:Error with host ips on controller" +
@@ -1549,21 +1549,6 @@
clusters.append( main.ONOScli5.clusters() )
clusters.append( main.ONOScli6.clusters() )
clusters.append( main.ONOScli7.clusters() )
- paths = []
- tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
elapsed = time.time() - startTime
cliTime = time.time() - cliStart
@@ -1617,7 +1602,7 @@
portsResults = portsResults and currentPortsResult
linksResults = linksResults and currentLinksResult
- # Compare json objects for hosts, dataplane clusters and paths
+ # Compare json objects for hosts and dataplane clusters
# hosts
consistentHostsResult = main.TRUE
@@ -1680,41 +1665,15 @@
str( numClusters ) +
" SCCs" )
- # paths
- consistentPathsResult = main.TRUE
- for controller in range( len( paths ) ):
- controllerStr = str( controller + 1 )
- if "Error" not in paths[ controller ]:
- if paths[ controller ] == paths[ 0 ]:
- continue
- else: # paths not consistent
- main.log.report( "paths from ONOS" + controllerStr +
- " is inconsistent with ONOS1" )
- consistentPathsResult = main.FALSE
-
- else:
- main.log.report( "Error in getting paths from ONOS" +
- controllerStr )
- consistentPathsResult = main.FALSE
- main.log.warn( "ONOS" + controllerStr +
- " paths response: " +
- repr( paths[ controller ] ) )
- utilities.assert_equals(
- expect=main.TRUE,
- actual=consistentPathsResult,
- onpass="Paths count is consistent across all ONOS nodes",
- onfail="ONOS nodes have different counts of paths" )
-
topoResult = ( devicesResults and portsResults and linksResults
and consistentHostsResult
- and consistentClustersResult
- and consistentPathsResult )
+ and consistentClustersResult )
topoResult = topoResult and int( count <= 2 )
note = "note it takes about " + str( int( cliTime ) ) + \
" seconds for the test to make all the cli calls to fetch " +\
"the topology from each ONOS instance"
- main.log.report(
+ main.log.info(
"Very crass estimate for topology discovery/convergence( " +
str( note ) + " ): " + str( elapsed ) + " seconds, " +
str( count ) + " tries" )
diff --git a/TestON/tests/HATestSanity/HATestSanity.params b/TestON/tests/HATestSanity/HATestSanity.params
index bc44e59..ee4374d 100644
--- a/TestON/tests/HATestSanity/HATestSanity.params
+++ b/TestON/tests/HATestSanity/HATestSanity.params
@@ -1,9 +1,10 @@
<PARAMS>
<testcases>1,2,8,3,4,5,14,[6],8,7,4,15,9,8,4,10,8,4,11,8,4,12,8,4,13</testcases>
<ENV>
- <cellName>HA</cellName>
+ <cellName>HA</cellName>
</ENV>
- <Git>True</Git>
+ <Git> True </Git>
+ <branch> master </branch>
<num_controllers> 7 </num_controllers>
<CTRL>
diff --git a/TestON/tests/HATestSanity/HATestSanity.py b/TestON/tests/HATestSanity/HATestSanity.py
index 16df59c..58f9954 100644
--- a/TestON/tests/HATestSanity/HATestSanity.py
+++ b/TestON/tests/HATestSanity/HATestSanity.py
@@ -43,18 +43,13 @@
"""
main.log.report( "ONOS HA Sanity test - initialization" )
main.case( "Setting up test environment" )
- # main.step( "This is a multiline \
- # comment\
- # this is \
- # a long \comment" )
- print "First Line"
# TODO: save all the timers and output them for plotting
# load some vairables from the params file
PULLCODE = False
if main.params[ 'Git' ] == 'True':
PULLCODE = True
-
+ gitBranch = main.params[ 'branch' ]
cellName = main.params[ 'ENV' ][ 'cellName' ]
# set global variables
@@ -109,21 +104,21 @@
cleanInstallResult = main.TRUE
gitPullResult = main.TRUE
+ main.step( "Starting Mininet" )
+ main.Mininet1.startNet( )
+
main.step( "Compiling the latest version of ONOS" )
if PULLCODE:
# TODO Configure branch in params
main.step( "Git checkout and pull master" )
- main.ONOSbench.gitCheckout( "master" )
+ main.ONOSbench.gitCheckout( gitBranch )
gitPullResult = main.ONOSbench.gitPull()
main.step( "Using mvn clean & install" )
- cleanInstallResult = main.TRUE
-
- if gitPullResult == main.TRUE:
- cleanInstallResult = main.ONOSbench.cleanInstall()
- else:
- main.log.warn( "Did not pull new code so skipping mvn " +
- "clean install" )
+ cleanInstallResult = main.ONOSbench.cleanInstall()
+ else:
+ main.log.warn( "Did not pull new code so skipping mvn " +
+ "clean install" )
main.ONOSbench.getVersion( report=True )
main.step( "Creating ONOS package" )
@@ -412,6 +407,11 @@
pingResult = main.FALSE
time1 = time.time()
pingResult = main.Mininet1.pingall()
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=pingResult,
+ onpass="Reactive Pingall test passed",
+ onfail="Reactive Pingall failed, one or more ping pairs failed" )
time2 = time.time()
main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
@@ -437,19 +437,36 @@
str( hex( i )[ 2: ] ).zfill( 2 ).upper()
host2 = "00:00:00:00:00:" + \
str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
- host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
- host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
- # NOTE: get host can return None
+ # NOTE: getHost can return None
+ host1Dict = main.ONOScli1.getHost( host1 )
+ host2Dict = main.ONOScli1.getHost( host2 )
+ host1Id = None
+ host2Id = None
+ if host1Dict and host2Dict:
+ host1Id = host1Dict.get( 'id', None )
+ host2Id = host2Dict.get( 'id', None )
if host1Id and host2Id:
tmpResult = main.ONOScli1.addHostIntent(
host1Id,
host2Id )
else:
main.log.error( "Error, getHost() failed" )
+ main.log.warn( json.dumps( json.loads( main.ONOScli1.hosts() ),
+ sort_keys=True,
+ indent=4,
+ separators=( ',', ': ' ) ) )
tmpResult = main.FALSE
intentAddResult = bool( pingResult and intentAddResult
and tmpResult )
# TODO Check that intents were added?
+ # Print the intent states
+ intents = main.ONOScli1.intents( )
+ intentStates = []
+ for intent in json.loads( intents ): # Iter through intents of a node
+ intentStates.append( intent.get( 'state', None ) )
+ out = [ (i, intentStates.count( i ) ) for i in set( intentStates ) ]
+ main.log.info( dict( out ) )
+
utilities.assert_equals(
expect=True,
actual=intentAddResult,
@@ -478,7 +495,12 @@
if PingResult == main.FALSE:
main.log.report(
"Intents have not been installed correctly, pings failed." )
- main.log.info( main.ONOScli1.intents() )
+ #TODO: pretty print
+ main.log.warn( "ONSO1 intents: " )
+ main.log.warn( json.dumps( json.loads( main.ONOScli1.intents() ),
+ sort_keys=True,
+ indent=4,
+ separators=( ',', ': ' ) ) )
if PingResult == main.TRUE:
main.log.report(
"Intents have been installed correctly and verified by pings" )
@@ -930,23 +952,7 @@
clusters.append( main.ONOScli5.clusters() )
clusters.append( main.ONOScli6.clusters() )
clusters.append( main.ONOScli7.clusters() )
- paths = []
- tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
-
- # Compare json objects for hosts, dataplane clusters and paths
+ # Compare json objects for hosts and dataplane clusters
# hosts
consistentHostsResult = main.TRUE
@@ -1009,30 +1015,6 @@
str( numClusters ) +
" SCCs" )
- # paths
- consistentPathsResult = main.TRUE
- for controller in range( len( paths ) ):
- controllerStr = str( controller + 1 )
- if "Error" not in paths[ controller ]:
- if paths[ controller ] == paths[ 0 ]:
- continue
- else: # paths not consistent
- main.log.report( "paths from ONOS" + controllerStr +
- " is inconsistent with ONOS1" )
- consistentPathsResult = main.FALSE
-
- else:
- main.log.report( "Error in getting paths from ONOS" +
- controllerStr )
- consistentPathsResult = main.FALSE
- main.log.warn( "ONOS" + controllerStr + " paths response: " +
- repr( paths[ controller ] ) )
- utilities.assert_equals(
- expect=main.TRUE,
- actual=consistentPathsResult,
- onpass="Paths count is consistent across all ONOS nodes",
- onfail="ONOS nodes have different counts of paths" )
-
main.step( "Comparing ONOS topology to MN" )
devicesResults = main.TRUE
portsResults = main.TRUE
@@ -1086,8 +1068,7 @@
linksResults = linksResults and currentLinksResult
topoResult = devicesResults and portsResults and linksResults\
- and consistentHostsResult and consistentClustersResult\
- and consistentPathsResult
+ and consistentHostsResult and consistentClustersResult
utilities.assert_equals( expect=main.TRUE, actual=topoResult,
onpass="Topology Check Test successful",
onfail="Topology Check Test NOT successful" )
@@ -1297,13 +1278,32 @@
actual=intentCheck,
onpass="Intents are consistent across all ONOS nodes",
onfail="ONOS nodes have different views of intents" )
+ # Print the intent states
+ intents = []
+ intents.append( ONOS1Intents )
+ intents.append( ONOS2Intents )
+ intents.append( ONOS3Intents )
+ intents.append( ONOS4Intents )
+ intents.append( ONOS5Intents )
+ intents.append( ONOS6Intents )
+ intents.append( ONOS7Intents )
+ intentStates = []
+ for node in intents: # Iter through ONOS nodes
+ nodeStates = []
+ for intent in json.loads( node ): # Iter through intents of a node
+ nodeStates.append( intent[ 'state' ] )
+ intentStates.append( nodeStates )
+ out = [ (i, nodeStates.count( i ) ) for i in set( nodeStates ) ]
+ main.log.info( dict( out ) )
+
# NOTE: Hazelcast has no durability, so intents are lost across system
# restarts
main.step( "Compare current intents with intents before the failure" )
# NOTE: this requires case 5 to pass for intentState to be set.
# maybe we should stop the test if that fails?
- if intentState == ONOS1Intents:
+ sameIntents = main.TRUE
+ if intentState and intentState == ONOS1Intents:
sameIntents = main.TRUE
main.log.report( "Intents are consistent with before failure" )
# TODO: possibly the states have changed? we may need to figure out
@@ -1483,13 +1483,20 @@
devices.append( main.ONOScli6.devices() )
devices.append( main.ONOScli7.devices() )
hosts = []
- hosts.append( main.ONOScli1.hosts() )
- hosts.append( main.ONOScli2.hosts() )
- hosts.append( main.ONOScli3.hosts() )
- hosts.append( main.ONOScli4.hosts() )
- hosts.append( main.ONOScli5.hosts() )
- hosts.append( main.ONOScli6.hosts() )
- hosts.append( main.ONOScli7.hosts() )
+ hosts.append( json.loads( main.ONOScli1.hosts() ) )
+ hosts.append( json.loads( main.ONOScli2.hosts() ) )
+ hosts.append( json.loads( main.ONOScli3.hosts() ) )
+ hosts.append( json.loads( main.ONOScli4.hosts() ) )
+ hosts.append( json.loads( main.ONOScli5.hosts() ) )
+ hosts.append( json.loads( main.ONOScli6.hosts() ) )
+ hosts.append( json.loads( main.ONOScli7.hosts() ) )
+ for controller in range( 0, len( hosts ) ):
+ controllerStr = str( controller + 1 )
+ for host in hosts[ controller ]:
+ if host[ 'ips' ] == []:
+ main.log.error(
+ "DEBUG:Error with host ips on controller" +
+ controllerStr + ": " + str( host ) )
ports = []
ports.append( main.ONOScli1.ports() )
ports.append( main.ONOScli2.ports() )
@@ -1514,180 +1521,145 @@
clusters.append( main.ONOScli5.clusters() )
clusters.append( main.ONOScli6.clusters() )
clusters.append( main.ONOScli7.clusters() )
- paths = []
- tempTopo = main.ONOSbench.getTopology( main.ONOScli1.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli2.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli3.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli4.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli5.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli6.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
- tempTopo = main.ONOSbench.getTopology( main.ONOScli7.topology() )
- paths.append( tempTopo.get( 'paths', False ) )
elapsed = time.time() - startTime
cliTime = time.time() - cliStart
print "CLI time: " + str( cliTime )
- for controller in range( numControllers ):
- controllerStr = str( controller + 1 )
- if devices[ controller ] or "Error" not in devices[
- controller ]:
- currentDevicesResult = main.Mininet1.compareSwitches(
- MNTopo,
- json.loads(
- devices[ controller ] ) )
- else:
- currentDevicesResult = main.FALSE
- utilities.assert_equals( expect=main.TRUE,
- actual=currentDevicesResult,
- onpass="ONOS" + controllerStr +
- " Switches view is correct",
- onfail="ONOS" + controllerStr +
- " Switches view is incorrect" )
+ try:
+ for controller in range( numControllers ):
+ controllerStr = str( controller + 1 )
+ if devices[ controller ] or "Error" not in devices[
+ controller ]:
+ currentDevicesResult = main.Mininet1.compareSwitches(
+ MNTopo,
+ json.loads(
+ devices[ controller ] ) )
+ else:
+ currentDevicesResult = main.FALSE
+ utilities.assert_equals( expect=main.TRUE,
+ actual=currentDevicesResult,
+ onpass="ONOS" + controllerStr +
+ " Switches view is correct",
+ onfail="ONOS" + controllerStr +
+ " Switches view is incorrect" )
- if ports[ controller ] or "Error" not in ports[ controller ]:
- currentPortsResult = main.Mininet1.comparePorts(
- MNTopo,
- json.loads(
- ports[ controller ] ) )
- else:
- currentPortsResult = main.FALSE
- utilities.assert_equals( expect=main.TRUE,
- actual=currentPortsResult,
- onpass="ONOS" + controllerStr +
- " ports view is correct",
- onfail="ONOS" + controllerStr +
- " ports view is incorrect" )
+ if ports[ controller ] or "Error" not in ports[ controller ]:
+ currentPortsResult = main.Mininet1.comparePorts(
+ MNTopo,
+ json.loads(
+ ports[ controller ] ) )
+ else:
+ currentPortsResult = main.FALSE
+ utilities.assert_equals( expect=main.TRUE,
+ actual=currentPortsResult,
+ onpass="ONOS" + controllerStr +
+ " ports view is correct",
+ onfail="ONOS" + controllerStr +
+ " ports view is incorrect" )
- if links[ controller ] or "Error" not in links[ controller ]:
- currentLinksResult = main.Mininet1.compareLinks(
- MNTopo,
- json.loads(
- links[ controller ] ) )
- else:
- currentLinksResult = main.FALSE
- utilities.assert_equals( expect=main.TRUE,
- actual=currentLinksResult,
- onpass="ONOS" + controllerStr +
- " links view is correct",
- onfail="ONOS" + controllerStr +
- " links view is incorrect" )
- devicesResults = devicesResults and currentDevicesResult
- portsResults = portsResults and currentPortsResult
- linksResults = linksResults and currentLinksResult
+ if links[ controller ] or "Error" not in links[ controller ]:
+ currentLinksResult = main.Mininet1.compareLinks(
+ MNTopo,
+ json.loads(
+ links[ controller ] ) )
+ else:
+ currentLinksResult = main.FALSE
+ utilities.assert_equals( expect=main.TRUE,
+ actual=currentLinksResult,
+ onpass="ONOS" + controllerStr +
+ " links view is correct",
+ onfail="ONOS" + controllerStr +
+ " links view is incorrect" )
+ devicesResults = devicesResults and currentDevicesResult
+ portsResults = portsResults and currentPortsResult
+ linksResults = linksResults and currentLinksResult
- # Compare json objects for hosts, dataplane clusters and paths
+ # Compare json objects for hosts and dataplane clusters
- # hosts
- consistentHostsResult = main.TRUE
- for controller in range( len( hosts ) ):
- controllerStr = str( controller + 1 )
- if "Error" not in hosts[ controller ]:
- if hosts[ controller ] == hosts[ 0 ]:
- continue
- else: # hosts not consistent
- main.log.report( "hosts from ONOS" + controllerStr +
- " is inconsistent with ONOS1" )
- main.log.warn( repr( hosts[ controller ] ) )
+ # hosts
+ consistentHostsResult = main.TRUE
+ for controller in range( len( hosts ) ):
+ controllerStr = str( controller + 1 )
+ if "Error" not in hosts[ controller ]:
+ if hosts[ controller ] == hosts[ 0 ]:
+ continue
+ else: # hosts not consistent
+ main.log.report( "hosts from ONOS" + controllerStr +
+ " is inconsistent with ONOS1" )
+ main.log.warn( repr( hosts[ controller ] ) )
+ consistentHostsResult = main.FALSE
+
+ else:
+ main.log.report( "Error in getting ONOS hosts from ONOS" +
+ controllerStr )
consistentHostsResult = main.FALSE
+ main.log.warn( "ONOS" + controllerStr +
+ " hosts response: " +
+ repr( hosts[ controller ] ) )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=consistentHostsResult,
+ onpass="Hosts view is consistent across all ONOS nodes",
+ onfail="ONOS nodes have different views of hosts" )
- else:
- main.log.report( "Error in getting ONOS hosts from ONOS" +
- controllerStr )
- consistentHostsResult = main.FALSE
- main.log.warn( "ONOS" + controllerStr +
- " hosts response: " +
- repr( hosts[ controller ] ) )
- utilities.assert_equals(
- expect=main.TRUE,
- actual=consistentHostsResult,
- onpass="Hosts view is consistent across all ONOS nodes",
- onfail="ONOS nodes have different views of hosts" )
+ # Strongly connected clusters of devices
+ consistentClustersResult = main.TRUE
+ for controller in range( len( clusters ) ):
+ controllerStr = str( controller + 1 )
+ if "Error" not in clusters[ controller ]:
+ if clusters[ controller ] == clusters[ 0 ]:
+ continue
+ else: # clusters not consistent
+ main.log.report( "clusters from ONOS" +
+ controllerStr +
+ " is inconsistent with ONOS1" )
+ consistentClustersResult = main.FALSE
- # Strongly connected clusters of devices
- consistentClustersResult = main.TRUE
- for controller in range( len( clusters ) ):
- controllerStr = str( controller + 1 )
- if "Error" not in clusters[ controller ]:
- if clusters[ controller ] == clusters[ 0 ]:
- continue
- else: # clusters not consistent
- main.log.report( "clusters from ONOS" +
- controllerStr +
- " is inconsistent with ONOS1" )
+ else:
+ main.log.report( "Error in getting dataplane clusters " +
+ "from ONOS" + controllerStr )
consistentClustersResult = main.FALSE
+ main.log.warn( "ONOS" + controllerStr +
+ " clusters response: " +
+ repr( clusters[ controller ] ) )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=consistentClustersResult,
+ onpass="Clusters view is consistent across all ONOS nodes",
+ onfail="ONOS nodes have different views of clusters" )
+ # there should always only be one cluster
+ numClusters = len( json.loads( clusters[ 0 ] ) )
+ utilities.assert_equals(
+ expect=1,
+ actual=numClusters,
+ onpass="ONOS shows 1 SCC",
+ onfail="ONOS shows " +
+ str( numClusters ) +
+ " SCCs" )
- else:
- main.log.report( "Error in getting dataplane clusters " +
- "from ONOS" + controllerStr )
- consistentClustersResult = main.FALSE
- main.log.warn( "ONOS" + controllerStr +
- " clusters response: " +
- repr( clusters[ controller ] ) )
- utilities.assert_equals(
- expect=main.TRUE,
- actual=consistentClustersResult,
- onpass="Clusters view is consistent across all ONOS nodes",
- onfail="ONOS nodes have different views of clusters" )
- # there should always only be one cluster
- numClusters = len( json.loads( clusters[ 0 ] ) )
- utilities.assert_equals(
- expect=1,
- actual=numClusters,
- onpass="ONOS shows 1 SCC",
- onfail="ONOS shows " +
- str( numClusters ) +
- " SCCs" )
+ topoResult = ( devicesResults and portsResults and linksResults
+ and consistentHostsResult
+ and consistentClustersResult )
- # paths
- consistentPathsResult = main.TRUE
- for controller in range( len( paths ) ):
- controllerStr = str( controller + 1 )
- if "Error" not in paths[ controller ]:
- if paths[ controller ] == paths[ 0 ]:
- continue
- else: # paths not consistent
- main.log.report( "paths from ONOS" + controllerStr +
- " is inconsistent with ONOS1" )
- consistentPathsResult = main.FALSE
+ topoResult = topoResult and int( count <= 2 )
+ note = "note it takes about " + str( int( cliTime ) ) + \
+ " seconds for the test to make all the cli calls to fetch " +\
+ "the topology from each ONOS instance"
+ main.log.info(
+ "Very crass estimate for topology discovery/convergence( " +
+ str( note ) + " ): " + str( elapsed ) + " seconds, " +
+ str( count ) + " tries" )
+ utilities.assert_equals( expect=main.TRUE, actual=topoResult,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
+ if topoResult == main.TRUE:
+ main.log.report( "ONOS topology view matches Mininet topology" )
+ except:
+ main.log.info( self.name + " ::::::" )
+ main.log.error( traceback.print_exc() )
+ main.log.info( self.name + " ::::::" )
- else:
- main.log.report( "Error in getting paths from ONOS" +
- controllerStr )
- consistentPathsResult = main.FALSE
- main.log.warn( "ONOS" + controllerStr +
- " paths response: " +
- repr( paths[ controller ] ) )
- utilities.assert_equals(
- expect=main.TRUE,
- actual=consistentPathsResult,
- onpass="Paths count is consistent across all ONOS nodes",
- onfail="ONOS nodes have different counts of paths" )
-
- topoResult = ( devicesResults and portsResults and linksResults
- and consistentHostsResult
- and consistentClustersResult
- and consistentPathsResult )
-
- topoResult = topoResult and int( count <= 2 )
- note = "note it takes about " + str( int( cliTime ) ) + \
- " seconds for the test to make all the cli calls to fetch " +\
- "the topology from each ONOS instance"
- main.log.report(
- "Very crass estimate for topology discovery/convergence( " +
- str( note ) + " ): " + str( elapsed ) + " seconds, " +
- str( count ) + " tries" )
- utilities.assert_equals( expect=main.TRUE, actual=topoResult,
- onpass="Topology Check Test successful",
- onfail="Topology Check Test NOT successful" )
- if topoResult == main.TRUE:
- main.log.report( "ONOS topology view matches Mininet topology" )
def CASE9( self, main ):
"""
diff --git a/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params
index 6699caf..7f5cf4e 100644
--- a/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params
+++ b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.params
@@ -4,6 +4,7 @@
<cellName>HA</cellName>
</ENV>
<Git>False</Git>
+ <branch> master </branch>
<num_controllers> 1 </num_controllers>
<CTRL>
diff --git a/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py
index 2aea5bf..4b9b287 100644
--- a/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py
+++ b/TestON/tests/HATestSingleInstanceRestart/HATestSingleInstanceRestart.py
@@ -49,7 +49,7 @@
PULLCODE = False
if main.params[ 'Git' ] == 'True':
PULLCODE = True
-
+ gitBranch = main.params[ 'branch' ]
cellName = main.params[ 'ENV' ][ 'cellName' ]
# set global variables
@@ -104,21 +104,21 @@
cleanInstallResult = main.TRUE
gitPullResult = main.TRUE
+ main.step( "Starting Mininet" )
+ main.Mininet1.startNet( )
+
main.step( "Compiling the latest version of ONOS" )
if PULLCODE:
# TODO Configure branch in params
main.step( "Git checkout and pull master" )
- main.ONOSbench.gitCheckout( "master" )
+ main.ONOSbench.gitCheckout( gitBranch )
gitPullResult = main.ONOSbench.gitPull()
main.step( "Using mvn clean & install" )
- cleanInstallResult = main.TRUE
-
- if gitPullResult == main.TRUE:
- cleanInstallResult = main.ONOSbench.cleanInstall()
- else:
- main.log.warn( "Did not pull new code so skipping mvn " +
- "clean install" )
+ cleanInstallResult = main.ONOSbench.cleanInstall()
+ else:
+ main.log.warn( "Did not pull new code so skipping mvn " +
+ "clean install" )
main.ONOSbench.getVersion( report=True )
cellResult = main.ONOSbench.setCell( "SingleHA" )
@@ -197,7 +197,6 @@
def CASE3( self, main ):
"""
Assign intents
-
"""
# FIXME: we must reinstall intents until we have a persistant
# datastore!
@@ -216,6 +215,11 @@
pingResult = main.FALSE
time1 = time.time()
pingResult = main.Mininet1.pingall()
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=pingResult,
+ onpass="Reactive Pingall test passed",
+ onfail="Reactive Pingall failed, one or more ping pairs failed" )
time2 = time.time()
main.log.info( "Time for pingall: %2f seconds" % ( time2 - time1 ) )
@@ -235,23 +239,41 @@
str( hex( i )[ 2: ] ).zfill( 2 ).upper()
host2 = "00:00:00:00:00:" + \
str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
- host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
- host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
- # NOTE: get host can return None
+ # NOTE: getHost can return None
+ host1Dict = main.ONOScli1.getHost( host1 )
+ host2Dict = main.ONOScli1.getHost( host2 )
+ host1Id = None
+ host2Id = None
+ if host1Dict and host2Dict:
+ host1Id = host1Dict.get( 'id', None )
+ host2Id = host2Dict.get( 'id', None )
if host1Id and host2Id:
tmpResult = main.ONOScli1.addHostIntent(
host1Id,
host2Id )
else:
main.log.error( "Error, getHost() failed" )
+ main.log.warn( json.dumps( json.loads( main.ONOScli1.hosts() ),
+ sort_keys=True,
+ indent=4,
+ separators=( ',', ': ' ) ) )
tmpResult = main.FALSE
intentAddResult = bool( pingResult and intentAddResult
and tmpResult )
+ # TODO Check that intents were added?
+ # Print the intent states
+ intents = main.ONOScli1.intents( )
+ intentStates = []
+ for intent in json.loads( intents ): # Iter through intents of a node
+ intentStates.append( intent.get( 'state', None ) )
+ out = [ (i, intentStates.count( i ) ) for i in set( intentStates ) ]
+ main.log.info( dict( out ) )
+
utilities.assert_equals(
expect=True,
actual=intentAddResult,
- onpass="Switch mastership correctly assigned",
- onfail="Error in ( re )assigning switch mastership" )
+ onpass="Pushed host intents to ONOS",
+ onfail="Error in pushing host intents to ONOS" )
# TODO Check if intents all exist in datastore
def CASE4( self, main ):
@@ -275,6 +297,12 @@
if PingResult == main.FALSE:
main.log.report(
"Intents have not been installed correctly, pings failed." )
+ #TODO: pretty print
+ main.log.warn( "ONSO1 intents: " )
+ main.log.warn( json.dumps( json.loads( main.ONOScli1.intents() ),
+ sort_keys=True,
+ indent=4,
+ separators=( ',', ': ' ) ) )
if PingResult == main.TRUE:
main.log.report(
"Intents have been installed correctly and verified by pings" )
@@ -554,6 +582,18 @@
actual=intentCheck,
onpass="Intents are consistent across all ONOS nodes",
onfail="ONOS nodes have different views of intents" )
+ # Print the intent states
+ intents = []
+ intents.append( ONOS1Intents )
+ intentStates = []
+ for node in intents: # Iter through ONOS nodes
+ nodeStates = []
+ for intent in json.loads( node ): # Iter through intents of a node
+ nodeStates.append( intent[ 'state' ] )
+ intentStates.append( nodeStates )
+ out = [ (i, nodeStates.count( i ) ) for i in set( nodeStates ) ]
+ main.log.info( dict( out ) )
+
# NOTE: Hazelcast has no durability, so intents are lost across system
# restarts
@@ -561,7 +601,8 @@
main.step( "Compare current intents with intents before the failure" )
# NOTE: this requires case 5 to pass for intentState to be set.
# maybe we should stop the test if that fails?
- if intentState == ONOS1Intents:
+ sameIntents = main.TRUE
+ if intentState and intentState == ONOS1Intents:
sameIntents = main.TRUE
main.log.report( "Intents are consistent with before failure" )
# TODO: possibly the states have changed? we may need to figure out
@@ -762,7 +803,7 @@
note = "note it takes about " + str( int( cliTime ) ) + \
" seconds for the test to make all the cli calls to fetch " +\
"the topology from each ONOS instance"
- main.log.report(
+ main.log.info(
"Very crass estimate for topology discovery/convergence( " +
str( note ) + " ): " + str( elapsed ) + " seconds, " +
str( count ) + " tries" )
diff --git a/TestON/tests/IntentPerfNext/IntentPerfNext.params b/TestON/tests/IntentPerfNext/IntentPerfNext.params
index dbcd05c..88f2bc7 100644
--- a/TestON/tests/IntentPerfNext/IntentPerfNext.params
+++ b/TestON/tests/IntentPerfNext/IntentPerfNext.params
@@ -1,5 +1,5 @@
<PARAMS>
- <testcases>1,4,5,2,3,4,5,2,3,4,5,2,3,4</testcases>
+ <testcases>1,4,5,4,5,4,5,4</testcases>
<ENV>
<cellName>intent_perf_test</cellName>
@@ -36,7 +36,7 @@
<TEST>
#Number of times to iterate each case
- <numIter>12</numIter>
+ <numIter>8</numIter>
<numIgnore>2</numIgnore>
<numSwitch>8</numSwitch>
<batchThresholdMin>0</batchThresholdMin>
diff --git a/TestON/tests/IntentPerfNext/IntentPerfNext.py b/TestON/tests/IntentPerfNext/IntentPerfNext.py
index 74ce298..0661073 100644
--- a/TestON/tests/IntentPerfNext/IntentPerfNext.py
+++ b/TestON/tests/IntentPerfNext/IntentPerfNext.py
@@ -1,164 +1,166 @@
-#Intent Performance Test for ONOS-next
+# Intent Performance Test for ONOS-next
#
-#andrew@onlab.us
+# andrew@onlab.us
#
-#November 5, 2014
+# November 5, 2014
+
class IntentPerfNext:
- def __init__(self):
+
+ def __init__( self ):
self.default = ""
- def CASE1(self, main):
- '''
+ def CASE1( self, main ):
+ """
ONOS startup sequence
- '''
-
+ """
import time
- global cluster_count
- cluster_count = 1
+ global clusterCount
+ clusterCount = 1
- cell_name = main.params['ENV']['cellName']
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
- git_pull = main.params['GIT']['autoPull']
- checkout_branch = main.params['GIT']['checkout']
+ gitPull = main.params[ 'GIT' ][ 'autoPull' ]
+ checkoutBranch = main.params[ 'GIT' ][ 'checkout' ]
- 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']
+ 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' ]
- main.ONOSbench.onos_uninstall(node_ip=ONOS1_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS2_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS3_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS4_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS5_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS6_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS7_ip)
+ main.ONOSbench.onosUninstall( nodeIp=ONOS1Ip )
+ 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 )
+ #TODO: Investigate why node 7 uninstall fails
+ #main.ONOSbench.onosUninstall( nodeIp=ONOS7Ip )
- MN1_ip = main.params['MN']['ip1']
- BENCH_ip = main.params['BENCH']['ip']
-
- main.case("Setting up test environment")
+ MN1Ip = main.params[ 'MN' ][ 'ip1' ]
+ BENCHIp = main.params[ 'BENCH' ][ 'ip' ]
- main.step("Creating cell file")
- cell_file_result = main.ONOSbench.create_cell_file(
- BENCH_ip, cell_name, MN1_ip,
- "onos-core,onos-app-metrics,onos-gui",
- ONOS1_ip)
+ main.case( "Setting up test environment" )
- main.step("Applying cell file to environment")
- cell_apply_result = main.ONOSbench.set_cell(cell_name)
- verify_cell_result = main.ONOSbench.verify_cell()
+ main.step( "Creating cell file" )
+ cellFileResult = main.ONOSbench.createCellFile(
+ BENCHIp, cellName, MN1Ip,
+ "onos-core,onos-app-metrics,onos-gui",
+ ONOS1Ip )
- main.step("Removing raft logs")
- main.ONOSbench.onos_remove_raft_logs()
+ main.step( "Applying cell file to environment" )
+ cellApplyResult = main.ONOSbench.setCell( cellName )
+ verifyCellResult = main.ONOSbench.verifyCell()
- 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()
-
- #If you used git pull, auto compile
- main.step("Using onos-build to compile ONOS")
- build_result = main.ONOSbench.onos_build()
+ 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()
+
+ # If you used git pull, auto compile
+ main.step( "Using onos-build to compile ONOS" )
+ buildResult = main.ONOSbench.onosBuild()
else:
- checkout_result = main.TRUE
- pull_result = main.TRUE
- build_result = main.TRUE
- main.log.info("Git pull skipped by configuration")
+ checkoutResult = main.TRUE
+ pullResult = main.TRUE
+ buildResult = main.TRUE
+ main.log.info( "Git pull skipped by configuration" )
- main.log.report("Commit information - ")
- main.ONOSbench.get_version(report=True)
+ main.log.report( "Commit information - " )
+ main.ONOSbench.getVersion( report=True )
- main.step("Creating ONOS package")
- package_result = main.ONOSbench.onos_package()
+ main.step( "Creating ONOS package" )
+ packageResult = main.ONOSbench.onosPackage()
- main.step("Installing ONOS package")
- install1_result = main.ONOSbench.onos_install(node=ONOS1_ip)
- #install2_result = main.ONOSbench.onos_install(node=ONOS2_ip)
- #install3_result = main.ONOSbench.onos_install(node=ONOS3_ip)
+ main.step( "Installing ONOS package" )
+ install1Result = main.ONOSbench.onosInstall( node=ONOS1Ip )
+ #install2Result = main.ONOSbench.onosInstall( node=ONOS2Ip )
+ #install3Result = main.ONOSbench.onosInstall( node=ONOS3Ip )
- main.step("Set cell for ONOScli env")
- main.ONOS1cli.set_cell(cell_name)
- #main.ONOS2cli.set_cell(cell_name)
- #main.ONOS3cli.set_cell(cell_name)
+ main.step( "Set cell for ONOScli env" )
+ main.ONOS1cli.setCell( cellName )
+ # main.ONOS2cli.setCell( cellName )
+ # main.ONOS3cli.setCell( cellName )
- time.sleep(5)
+ time.sleep( 5 )
- main.step("Start onos cli")
- cli1 = main.ONOS1cli.start_onos_cli(ONOS1_ip)
- #cli2 = main.ONOS2cli.start_onos_cli(ONOS2_ip)
- #cli3 = main.ONOS3cli.start_onos_cli(ONOS3_ip)
+ main.step( "Start onos cli" )
+ cli1 = main.ONOS1cli.startOnosCli( ONOS1Ip )
+ #cli2 = main.ONOS2cli.startOnosCli( ONOS2Ip )
+ #cli3 = main.ONOS3cli.startOnosCli( ONOS3Ip )
- utilities.assert_equals(expect=main.TRUE,
- actual = cell_file_result and cell_apply_result and\
- verify_cell_result and checkout_result and\
- pull_result and build_result and\
- install1_result, #and install2_result and\
- #install3_result,
- onpass="ONOS started successfully",
- onfail="Failed to start ONOS")
+ utilities.assert_equals( expect=main.TRUE,
+ actual=cellFileResult and cellApplyResult and
+ verifyCellResult and checkoutResult and
+ pullResult and buildResult and
+ install1Result, # and install2Result and
+ # install3Result,
+ onpass="ONOS started successfully",
+ onfail="Failed to start ONOS" )
- def CASE2(self, main):
- '''
+ def CASE2( self, main ):
+ """
Single intent add latency
- '''
+ """
import time
import json
import requests
import os
import numpy
- global cluster_count
+ global clusterCount
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
- ONOS_ip_list = []
- for i in range(1, 8):
- ONOS_ip_list.append(main.params['CTRL']['ip'+str(i)])
-
- ONOS_user = main.params['CTRL']['user']
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOSIpList = []
+ for i in range( 1, 8 ):
+ ONOSIpList.append( main.params[ 'CTRL' ][ 'ip' + str( i ) ] )
- default_sw_port = main.params['CTRL']['port1']
+ ONOSUser = main.params[ 'CTRL' ][ 'user' ]
- #number of iterations of case
- num_iter = main.params['TEST']['numIter']
- num_ignore = int(main.params['TEST']['numIgnore'])
+ defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
- #Timestamp keys for json metrics output
- submit_time = main.params['JSON']['submittedTime']
- install_time = main.params['JSON']['installedTime']
- wdRequest_time = main.params['JSON']['wdRequestTime']
- withdrawn_time = main.params['JSON']['withdrawnTime']
-
+ # number of iterations of case
+ numIter = main.params[ 'TEST' ][ 'numIter' ]
+ numIgnore = int( main.params[ 'TEST' ][ 'numIgnore' ] )
+
+ # Timestamp keys for json metrics output
+ submitTime = main.params[ 'JSON' ][ 'submittedTime' ]
+ installTime = main.params[ 'JSON' ][ 'installedTime' ]
+ wdRequestTime = main.params[ 'JSON' ][ 'wdRequestTime' ]
+ withdrawnTime = main.params[ 'JSON' ][ 'withdrawnTime' ]
+
assertion = main.TRUE
- intent_add_lat_list = []
-
- #Distribute switches according to cluster count
- for i in range(1, 9):
- if cluster_count == 1:
- main.Mininet1.assign_sw_controller(
- sw=str(i), ip1=ONOS_ip_list[0],
- port1=default_sw_port
- )
- elif cluster_count == 3:
+ intentAddLatList = []
+
+ # Distribute switches according to cluster count
+ for i in range( 1, 9 ):
+ if clusterCount == 1:
+ main.Mininet1.assignSwController(
+ sw=str( i ), ip1=ONOSIpList[ 0 ],
+ port1=defaultSwPort
+ )
+ elif clusterCount == 3:
if i < 3:
index = 0
elif i < 6 and i >= 3:
index = 1
else:
index = 2
- main.Mininet1.assign_sw_controller(
- sw=str(i), ip1=ONOS_ip_list[index],
- port1=default_sw_port
- )
- elif cluster_count == 5:
+ main.Mininet1.assignSwController(
+ sw=str( i ), ip1=ONOSIpList[ index ],
+ port1=defaultSwPort
+ )
+ elif clusterCount == 5:
if i < 3:
index = 0
elif i < 5 and i >= 3:
@@ -169,947 +171,978 @@
index = 3
else:
index = 4
- main.Mininet1.assign_sw_controller(
- sw=str(i), ip1=ONOS_ip_list[index],
- port1=default_sw_port
- )
- elif cluster_count == 7:
+ main.Mininet1.assignSwController(
+ sw=str( i ), ip1=ONOSIpList[ index ],
+ port1=defaultSwPort
+ )
+ elif clusterCount == 7:
if i < 6:
index = i
else:
index = 6
- main.Mininet1.assign_sw_controller(
- sw=str(i), ip1=ONOS_ip_list[index],
- port1=default_sw_port
- )
+ main.Mininet1.assignSwController(
+ sw=str( i ), ip1=ONOSIpList[ index ],
+ port1=defaultSwPort
+ )
- time.sleep(10)
+ time.sleep( 10 )
- main.log.report("Single intent add latency test")
+ main.log.report( "Single intent add latency test" )
- devices_json_str = main.ONOS1cli.devices()
- devices_json_obj = json.loads(devices_json_str)
-
- if not devices_json_obj:
- main.log.report("Devices not discovered")
- main.log.report("Aborting test")
+ devicesJsonStr = main.ONOS1cli.devices()
+ devicesJsonObj = json.loads( devicesJsonStr )
+
+ if not devicesJsonObj:
+ main.log.report( "Devices not discovered" )
+ main.log.report( "Aborting test" )
main.exit()
else:
- main.log.info("Devices discovered successfully")
+ main.log.info( "Devices discovered successfully" )
- device_id_list = []
+ deviceIdList = []
- #Obtain device id list in ONOS format.
- #They should already be in order (1,2,3,10,11,12,13, etc)
- for device in devices_json_obj:
- device_id_list.append(device['id'])
+ # Obtain device id list in ONOS format.
+ # They should already be in order ( 1,2,3,10,11,12,13, etc )
+ for device in devicesJsonObj:
+ deviceIdList.append( device[ 'id' ] )
- for i in range(0, int(num_iter)):
- #add_point_intent(ingr_device, egr_device,
- # ingr_port, egr_port)
- main.ONOS1cli.add_point_intent(
- device_id_list[0]+"/2", device_id_list[7]+"/2")
-
- #Allow some time for intents to propagate
- time.sleep(5)
-
- intents_str = main.ONOS1cli.intents(json_format=True)
- intents_obj = json.loads(intents_str)
- for intent in intents_obj:
- if intent['state'] == "INSTALLED":
- main.log.info("Intent installed successfully")
- intent_id = intent['id']
- main.log.info("Intent id: "+str(intent_id))
+ for i in range( 0, int( numIter ) ):
+ # addPointIntent( ingrDevice, egrDevice,
+ # ingrPort, egrPort )
+ main.ONOS1cli.addPointIntent(
+ deviceIdList[ 0 ] + "/2", deviceIdList[ 7 ] + "/2" )
+
+ # Allow some time for intents to propagate
+ time.sleep( 5 )
+
+ intentsStr = main.ONOS1cli.intents( jsonFormat=True )
+ intentsObj = json.loads( intentsStr )
+ for intent in intentsObj:
+ if intent[ 'state' ] == "INSTALLED":
+ main.log.info( "Intent installed successfully" )
+ intentId = intent[ 'id' ]
+ main.log.info( "Intent id: " + str( intentId ) )
else:
- #TODO: Add error handling
- main.log.info("Intent installation failed")
- intent_id = ""
+ # TODO: Add error handling
+ main.log.info( "Intent installation failed" )
+ intentId = ""
- #Obtain metrics from ONOS 1, 2, 3
- intents_json_str_1 = main.ONOS1cli.intents_events_metrics()
- intents_json_obj_1 = json.loads(intents_json_str_1)
- #Parse values from the json object
- intent_submit_1 = \
- intents_json_obj_1[submit_time]['value']
- intent_install_1 = \
- intents_json_obj_1[install_time]['value']
- intent_install_lat_1 = \
- int(intent_install_1) - int(intent_submit_1)
-
- if cluster_count == 3:
- intents_json_str_2 = main.ONOS2cli.intents_events_metrics()
- intents_json_str_3 = main.ONOS3cli.intents_events_metrics()
- intents_json_obj_2 = json.loads(intents_json_str_2)
- intents_json_obj_3 = json.loads(intents_json_str_3)
- intent_submit_2 = \
- intents_json_obj_2[submit_time]['value']
- intent_submit_3 = \
- intents_json_obj_3[submit_time]['value']
- intent_install_2 = \
- intents_json_obj_2[install_time]['value']
- intent_install_3 = \
- intents_json_obj_3[install_time]['value']
- intent_install_lat_2 = \
- int(intent_install_2) - int(intent_submit_2)
- intent_install_lat_3 = \
- int(intent_install_3) - int(intent_submit_3)
+ # Obtain metrics from ONOS 1, 2, 3
+ intentsJsonStr1 = main.ONOS1cli.intentsEventsMetrics()
+ intentsJsonObj1 = json.loads( intentsJsonStr1 )
+ # Parse values from the json object
+ intentSubmit1 = \
+ intentsJsonObj1[ submitTime ][ 'value' ]
+ intentInstall1 = \
+ intentsJsonObj1[ installTime ][ 'value' ]
+ intentInstallLat1 = \
+ int( intentInstall1 ) - int( intentSubmit1 )
+
+ if clusterCount == 3:
+ intentsJsonStr2 = main.ONOS2cli.intentsEventsMetrics()
+ intentsJsonStr3 = main.ONOS3cli.intentsEventsMetrics()
+ intentsJsonObj2 = json.loads( intentsJsonStr2 )
+ intentsJsonObj3 = json.loads( intentsJsonStr3 )
+ intentSubmit2 = \
+ intentsJsonObj2[ submitTime ][ 'value' ]
+ intentSubmit3 = \
+ intentsJsonObj3[ submitTime ][ 'value' ]
+ intentInstall2 = \
+ intentsJsonObj2[ installTime ][ 'value' ]
+ intentInstall3 = \
+ intentsJsonObj3[ installTime ][ 'value' ]
+ intentInstallLat2 = \
+ int( intentInstall2 ) - int( intentSubmit2 )
+ intentInstallLat3 = \
+ int( intentInstall3 ) - int( intentSubmit3 )
else:
- intent_install_lat_2 = 0
- intent_install_lat_3 = 0
+ intentInstallLat2 = 0
+ intentInstallLat3 = 0
- if cluster_count == 5:
- intents_json_str_4 = main.ONOS4cli.intents_events_metrics()
- intents_json_str_5 = main.ONOS5cli.intents_events_metrics()
- intents_json_obj_4 = json.loads(intents_json_str_4)
- intents_json_obj_5 = json.loads(intents_json_str_5)
- intent_submit_4 = \
- intents_json_obj_4[submit_time]['value']
- intent_submit_5 = \
- intents_json_obj_5[submit_time]['value']
- intent_install_4 = \
- intents_json_obj_5[install_time]['value']
- intent_install_5 = \
- intents_json_obj_5[install_time]['value']
- intent_install_lat_4 = \
- int(intent_install_4) - int(intent_submit_4)
- intent_install_lat_5 = \
- int(intent_install_5) - int(intent_submit_5)
+ if clusterCount == 5:
+ intentsJsonStr4 = main.ONOS4cli.intentsEventsMetrics()
+ intentsJsonStr5 = main.ONOS5cli.intentsEventsMetrics()
+ intentsJsonObj4 = json.loads( intentsJsonStr4 )
+ intentsJsonObj5 = json.loads( intentsJsonStr5 )
+ intentSubmit4 = \
+ intentsJsonObj4[ submitTime ][ 'value' ]
+ intentSubmit5 = \
+ intentsJsonObj5[ submitTime ][ 'value' ]
+ intentInstall4 = \
+ intentsJsonObj5[ installTime ][ 'value' ]
+ intentInstall5 = \
+ intentsJsonObj5[ installTime ][ 'value' ]
+ intentInstallLat4 = \
+ int( intentInstall4 ) - int( intentSubmit4 )
+ intentInstallLat5 = \
+ int( intentInstall5 ) - int( intentSubmit5 )
else:
- intent_install_lat_4 = 0
- intent_install_lat_5 = 0
+ intentInstallLat4 = 0
+ intentInstallLat5 = 0
- if cluster_count == 7:
- intents_json_str_6 = main.ONOS6cli.intents_events_metrics()
- intents_json_str_7 = main.ONOS7cli.intents_events_metrics()
- intents_json_obj_6 = json.loads(intents_json_str_6)
- intents_json_obj_7 = json.loads(intents_json_str_7)
- intent_submit_6 = \
- intents_json_obj_6[submit_time]['value']
- intent_submit_7 = \
- intents_json_obj_6[submit_time]['value']
- intent_install_6 = \
- intents_json_obj_6[install_time]['value']
- intent_install_7 = \
- intents_json_obj_7[install_time]['value']
- intent_install_lat_6 = \
- int(intent_install_6) - int(intent_submit_6)
- intent_install_lat_7 = \
- int(intent_install_7) - int(intent_submit_7)
+ if clusterCount == 7:
+ intentsJsonStr6 = main.ONOS6cli.intentsEventsMetrics()
+ intentsJsonStr7 = main.ONOS7cli.intentsEventsMetrics()
+ intentsJsonObj6 = json.loads( intentsJsonStr6 )
+ intentsJsonObj7 = json.loads( intentsJsonStr7 )
+ intentSubmit6 = \
+ intentsJsonObj6[ submitTime ][ 'value' ]
+ intentSubmit7 = \
+ intentsJsonObj6[ submitTime ][ 'value' ]
+ intentInstall6 = \
+ intentsJsonObj6[ installTime ][ 'value' ]
+ intentInstall7 = \
+ intentsJsonObj7[ installTime ][ 'value' ]
+ intentInstallLat6 = \
+ int( intentInstall6 ) - int( intentSubmit6 )
+ intentInstallLat7 = \
+ int( intentInstall7 ) - int( intentSubmit7 )
else:
- intent_install_lat_6 = 0
- intent_install_lat_7 = 0
+ intentInstallLat6 = 0
+ intentInstallLat7 = 0
- intent_install_lat_avg = \
- (intent_install_lat_1 +
- intent_install_lat_2 +
- intent_install_lat_3 +
- intent_install_lat_4 +
- intent_install_lat_5 +
- intent_install_lat_6 +
- intent_install_lat_7) / cluster_count
+ intentInstallLatAvg = \
+ ( intentInstallLat1 +
+ intentInstallLat2 +
+ intentInstallLat3 +
+ intentInstallLat4 +
+ intentInstallLat5 +
+ intentInstallLat6 +
+ intentInstallLat7 ) / clusterCount
- main.log.info("Intent add latency avg for iteration "+str(i)+
- ": "+str(intent_install_lat_avg)+" ms")
+ main.log.info( "Intent add latency avg for iteration " + str( i ) +
+ ": " + str( intentInstallLatAvg ) + " ms" )
- if intent_install_lat_avg > 0.0 and \
- intent_install_lat_avg < 1000 and i > num_ignore:
- intent_add_lat_list.append(intent_install_lat_avg)
+ if intentInstallLatAvg > 0.0 and \
+ intentInstallLatAvg < 1000 and i > numIgnore:
+ intentAddLatList.append( intentInstallLatAvg )
else:
- main.log.info("Intent add latency exceeded "+
- "threshold. Skipping iteration "+str(i))
+ main.log.info( "Intent add latency exceeded " +
+ "threshold. Skipping iteration " + str( i ) )
- time.sleep(3)
-
- #TODO: Only remove intents that were installed
+ time.sleep( 3 )
+
+ # TODO: Only remove intents that were installed
# in this case... Otherwise many other intents
# may show up distorting the results
- main.log.info("Removing intents for next iteration")
- json_temp = \
- main.ONOS1cli.intents(json_format=True)
- json_obj_intents = json.loads(json_temp)
- if json_obj_intents:
- for intents in json_obj_intents:
- temp_id = intents['id']
- #main.ONOS1cli.remove_intent(temp_id)
- main.log.info("Removing intent id: "+
- str(temp_id))
- main.ONOS1cli.remove_intent(temp_id)
+ main.log.info( "Removing intents for next iteration" )
+ jsonTemp = \
+ main.ONOS1cli.intents( jsonFormat=True )
+ jsonObjIntents = json.loads( jsonTemp )
+ if jsonObjIntents:
+ for intents in jsonObjIntents:
+ tempId = intents[ 'id' ]
+ # main.ONOS1cli.removeIntent( tempId )
+ main.log.info( "Removing intent id: " +
+ str( tempId ) )
+ main.ONOS1cli.removeIntent( tempId )
else:
- main.log.info("Intents were not installed correctly")
+ main.log.info( "Intents were not installed correctly" )
- time.sleep(5)
+ time.sleep( 5 )
- if intent_add_lat_list:
- intent_add_lat_avg = sum(intent_add_lat_list) /\
- len(intent_add_lat_list)
+ if intentAddLatList:
+ intentAddLatAvg = sum( intentAddLatList ) /\
+ len( intentAddLatList )
else:
- main.log.report("Intent installation latency test failed")
- intent_add_lat_avg = "NA"
+ main.log.report( "Intent installation latency test failed" )
+ intentAddLatAvg = "NA"
assertion = main.FALSE
- intent_add_lat_std = \
- round(numpy.std(intent_add_lat_list),1)
- #END ITERATION FOR LOOP
- main.log.report("Single intent add latency - ")
- main.log.report("Avg: "+str(intent_add_lat_avg)+" ms")
- main.log.report("Std Deviation: "+str(intent_add_lat_std)+" ms")
-
- utilities.assert_equals(expect=main.TRUE, actual=assertion,
+ intentAddLatStd = \
+ round( numpy.std( intentAddLatList ), 1 )
+ # END ITERATION FOR LOOP
+ main.log.report( "Single intent add latency - " )
+ main.log.report( "Avg: " + str( intentAddLatAvg ) + " ms" )
+ main.log.report( "Std Deviation: " + str( intentAddLatStd ) + " ms" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=assertion,
onpass="Single intent install latency test successful",
- onfail="Single intent install latency test failed")
+ onfail="Single intent install latency test failed" )
- def CASE3(self, main):
- '''
+ def CASE3( self, main ):
+ """
Intent Reroute latency
- '''
+ """
import time
import json
import requests
import os
import numpy
- global cluster_count
+ global clusterCount
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
- ONOS_user = main.params['CTRL']['user']
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOSUser = main.params[ 'CTRL' ][ 'user' ]
- default_sw_port = main.params['CTRL']['port1']
+ defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
- #number of iterations of case
- num_iter = main.params['TEST']['numIter']
- num_ignore = int(main.params['TEST']['numIgnore'])
+ # number of iterations of case
+ numIter = main.params[ 'TEST' ][ 'numIter' ]
+ numIgnore = int( main.params[ 'TEST' ][ 'numIgnore' ] )
assertion = main.TRUE
- #Timestamp keys for json metrics output
- submit_time = main.params['JSON']['submittedTime']
- install_time = main.params['JSON']['installedTime']
- wdRequest_time = main.params['JSON']['wdRequestTime']
- withdrawn_time = main.params['JSON']['withdrawnTime']
+ # Timestamp keys for json metrics output
+ submitTime = main.params[ 'JSON' ][ 'submittedTime' ]
+ installTime = main.params[ 'JSON' ][ 'installedTime' ]
+ wdRequestTime = main.params[ 'JSON' ][ 'wdRequestTime' ]
+ withdrawnTime = main.params[ 'JSON' ][ 'withdrawnTime' ]
- #NOTE: May need to configure interface depending on topology
- intfs = main.params['TEST']['intfs']
+ # NOTE: May need to configure interface depending on topology
+ intfs = main.params[ 'TEST' ][ 'intfs' ]
- devices_json_str = main.ONOS1cli.devices()
- devices_json_obj = json.loads(devices_json_str)
+ devicesJsonStr = main.ONOS1cli.devices()
+ devicesJsonObj = json.loads( devicesJsonStr )
- device_id_list = []
+ deviceIdList = []
- #Obtain device id list in ONOS format.
- #They should already be in order (1,2,3,10,11,12,13, etc)
- for device in devices_json_obj:
- device_id_list.append(device['id'])
+ # Obtain device id list in ONOS format.
+ # They should already be in order ( 1,2,3,10,11,12,13, etc )
+ for device in devicesJsonObj:
+ deviceIdList.append( device[ 'id' ] )
- intent_reroute_lat_list = []
+ intentRerouteLatList = []
- for i in range(0, int(num_iter)):
- #add_point_intent(ingr_device, ingr_port,
- # egr_device, egr_port)
- if len(device_id_list) > 0:
- main.ONOS1cli.add_point_intent(
- device_id_list[0]+"/2", device_id_list[7]+"/2")
+ for i in range( 0, int( numIter ) ):
+ # addPointIntent( ingrDevice, ingrPort,
+ # egrDevice, egrPort )
+ if len( deviceIdList ) > 0:
+ main.ONOS1cli.addPointIntent(
+ deviceIdList[ 0 ] + "/2", deviceIdList[ 7 ] + "/2" )
else:
- main.log.info("Failed to fetch devices from ONOS")
+ main.log.info( "Failed to fetch devices from ONOS" )
- time.sleep(5)
+ time.sleep( 5 )
- intents_str = main.ONOS1cli.intents(json_format=True)
- intents_obj = json.loads(intents_str)
- for intent in intents_obj:
- if intent['state'] == "INSTALLED":
- main.log.info("Intent installed successfully")
- intent_id = intent['id']
- main.log.info("Intent id: "+str(intent_id))
+ intentsStr = main.ONOS1cli.intents( jsonFormat=True )
+ intentsObj = json.loads( intentsStr )
+ for intent in intentsObj:
+ if intent[ 'state' ] == "INSTALLED":
+ main.log.info( "Intent installed successfully" )
+ intentId = intent[ 'id' ]
+ main.log.info( "Intent id: " + str( intentId ) )
else:
- #TODO: Add error handling
- main.log.info("Intent installation failed")
- intent_id = ""
-
- main.log.info("Disabling interface "+intfs)
- t0_system = time.time()*1000
+ # TODO: Add error handling
+ main.log.info( "Intent installation failed" )
+ intentId = ""
+
+ main.log.info( "Disabling interface " + intfs )
+ t0System = time.time() * 1000
main.Mininet1.handle.sendline(
- "sh ifconfig "+intfs+" down")
- main.Mininet1.handle.expect("mininet>")
+ "sh ifconfig " + intfs + " down" )
+ main.Mininet1.handle.expect( "mininet>" )
- #TODO: Check for correct intent reroute
- time.sleep(1)
+ # TODO: Check for correct intent reroute
+ time.sleep( 1 )
- #Obtain metrics from ONOS 1, 2, 3
- intents_json_str_1 = main.ONOS1cli.intents_events_metrics()
- intents_json_obj_1 = json.loads(intents_json_str_1)
- #Parse values from the json object
- intent_install_1 = \
- intents_json_obj_1[install_time]['value']
- intent_reroute_lat_1 = \
- int(intent_install_1) - int(t0_system)
-
- if cluster_count == 3:
- intents_json_str_2 = main.ONOS2cli.intents_events_metrics()
- intents_json_str_3 = main.ONOS3cli.intents_events_metrics()
+ # Obtain metrics from ONOS 1, 2, 3
+ intentsJsonStr1 = main.ONOS1cli.intentsEventsMetrics()
+ intentsJsonObj1 = json.loads( intentsJsonStr1 )
+ # Parse values from the json object
+ intentInstall1 = \
+ intentsJsonObj1[ installTime ][ 'value' ]
+ intentRerouteLat1 = \
+ int( intentInstall1 ) - int( t0System )
- intents_json_obj_2 = json.loads(intents_json_str_2)
- intents_json_obj_3 = json.loads(intents_json_str_3)
- intent_install_2 = \
- intents_json_obj_2[install_time]['value']
- intent_install_3 = \
- intents_json_obj_3[install_time]['value']
- intent_reroute_lat_2 = \
- int(intent_install_2) - int(t0_system)
- intent_reroute_lat_3 = \
- int(intent_install_3) - int(t0_system)
+ 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 )
else:
- intent_reroute_lat_2 = 0
- intent_reroute_lat_3 = 0
+ intentRerouteLat2 = 0
+ intentRerouteLat3 = 0
- if cluster_count == 5:
- intents_json_str_4 = main.ONOS4cli.intents_events_metrics()
- intents_json_str_5 = main.ONOS5cli.intents_events_metrics()
+ if clusterCount == 5:
+ intentsJsonStr4 = main.ONOS4cli.intentsEventsMetrics()
+ intentsJsonStr5 = main.ONOS5cli.intentsEventsMetrics()
- intents_json_obj_4 = json.loads(intents_json_str_4)
- intents_json_obj_5 = json.loads(intents_json_str_5)
- intent_install_4 = \
- intents_json_obj_4[install_time]['value']
- intent_install_5 = \
- intents_json_obj_5[install_time]['value']
- intent_reroute_lat_4 = \
- int(intent_install_4) - int(t0_system)
- intent_reroute_lat_5 = \
- int(intent_install_5) - int(t0_system)
+ 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 )
else:
- intent_reroute_lat_4 = 0
- intent_reroute_lat_5 = 0
+ intentRerouteLat4 = 0
+ intentRerouteLat5 = 0
- if cluster_count == 7:
- intents_json_str_6 = main.ONOS6cli.intents_events_metrics()
- intents_json_str_7 = main.ONOS7cli.intents_events_metrics()
+ if clusterCount == 7:
+ intentsJsonStr6 = main.ONOS6cli.intentsEventsMetrics()
+ intentsJsonStr7 = main.ONOS7cli.intentsEventsMetrics()
- intents_json_obj_6 = json.loads(intents_json_str_6)
- intents_json_obj_7 = json.loads(intents_json_str_7)
- intent_install_6 = \
- intents_json_obj_6[install_time]['value']
- intent_install_7 = \
- intents_json_obj_7[install_time]['value']
- intent_reroute_lat_6 = \
- int(intent_install_6) - int(t0_system)
- intent_reroute_lat_7 = \
- int(intent_install_7) - int(t0_system)
+ 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 )
else:
- intent_reroute_lat_6 = 0
- intent_reroute_lat_7 = 0
+ intentRerouteLat6 = 0
+ intentRerouteLat7 = 0
- intent_reroute_lat_avg = \
- (intent_reroute_lat_1 +
- intent_reroute_lat_2 +
- intent_reroute_lat_3 +
- intent_reroute_lat_4 +
- intent_reroute_lat_5 +
- intent_reroute_lat_6 +
- intent_reroute_lat_7) / cluster_count
-
- main.log.info("Intent reroute latency avg for iteration "+
- str(i)+": "+str(intent_reroute_lat_avg))
+ intentRerouteLatAvg = \
+ ( intentRerouteLat1 +
+ intentRerouteLat2 +
+ intentRerouteLat3 +
+ intentRerouteLat4 +
+ intentRerouteLat5 +
+ intentRerouteLat6 +
+ intentRerouteLat7 ) / clusterCount
- if intent_reroute_lat_avg > 0.0 and \
- intent_reroute_lat_avg < 1000 and i > num_ignore:
- intent_reroute_lat_list.append(intent_reroute_lat_avg)
+ main.log.info( "Intent reroute latency avg for iteration " +
+ str( i ) + ": " + str( intentRerouteLatAvg ) )
+
+ if intentRerouteLatAvg > 0.0 and \
+ intentRerouteLatAvg < 1000 and i > numIgnore:
+ intentRerouteLatList.append( intentRerouteLatAvg )
else:
- main.log.info("Intent reroute latency exceeded "+
- "threshold. Skipping iteration "+str(i))
+ main.log.info( "Intent reroute latency exceeded " +
+ "threshold. Skipping iteration " + str( i ) )
- main.log.info("Removing intents for next iteration")
- main.ONOS1cli.remove_intent(intent_id)
+ main.log.info( "Removing intents for next iteration" )
+ main.ONOS1cli.removeIntent( intentId )
- main.log.info("Bringing Mininet interface up for next "+
- "iteration")
+ main.log.info( "Bringing Mininet interface up for next " +
+ "iteration" )
main.Mininet1.handle.sendline(
- "sh ifconfig "+intfs+" up")
- main.Mininet1.handle.expect("mininet>")
+ "sh ifconfig " + intfs + " up" )
+ main.Mininet1.handle.expect( "mininet>" )
- if intent_reroute_lat_list:
- intent_reroute_lat_avg = sum(intent_reroute_lat_list) /\
- len(intent_reroute_lat_list)
+ if intentRerouteLatList:
+ intentRerouteLatAvg = sum( intentRerouteLatList ) /\
+ len( intentRerouteLatList )
else:
- main.log.report("Intent reroute test failed. Results NA")
- intent_reroute_lat_avg = "NA"
- #NOTE: fails test when list is empty
+ main.log.report( "Intent reroute test failed. Results NA" )
+ intentRerouteLatAvg = "NA"
+ # NOTE: fails test when list is empty
assertion = main.FALSE
-
- intent_reroute_lat_std = \
- round(numpy.std(intent_reroute_lat_list),1)
- #END ITERATION FOR LOOP
- main.log.report("Single intent reroute latency - ")
- main.log.report("Avg: "+str(intent_reroute_lat_avg)+" ms")
- main.log.report("Std Deviation: "+str(intent_reroute_lat_std)+" ms")
-
- utilities.assert_equals(expect=main.TRUE, actual=assertion,
+
+ intentRerouteLatStd = \
+ round( numpy.std( intentRerouteLatList ), 1 )
+ # END ITERATION FOR LOOP
+ main.log.report( "Single intent reroute latency - " )
+ main.log.report( "Avg: " + str( intentRerouteLatAvg ) + " ms" )
+ main.log.report(
+ "Std Deviation: " +
+ str( intentRerouteLatStd ) +
+ " ms" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=assertion,
onpass="Single intent reroute latency test successful",
- onfail="Single intent reroute latency test failed")
-
- def CASE4(self, main):
- '''
+ onfail="Single intent reroute latency test failed" )
+
+ def CASE4( self, main ):
+ """
Batch intent install
- '''
-
+ """
import time
import json
import requests
import os
import numpy
- global cluster_count
+ global clusterCount
- 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']
+ 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
- ONOS_ip_list = []
- for i in range(1, 8):
- ONOS_ip_list.append(main.params['CTRL']['ip'+str(i)])
+ ONOSIpList = []
+ for i in range( 1, 8 ):
+ ONOSIpList.append( main.params[ 'CTRL' ][ 'ip' + str( i ) ] )
- ONOS_user = main.params['CTRL']['user']
+ ONOSUser = main.params[ 'CTRL' ][ 'user' ]
- default_sw_port = main.params['CTRL']['port1']
-
- batch_intent_size = main.params['TEST']['batchIntentSize']
- batch_thresh_min = int(main.params['TEST']['batchThresholdMin'])
- batch_thresh_max = int(main.params['TEST']['batchThresholdMax'])
+ defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
- #number of iterations of case
- num_iter = main.params['TEST']['numIter']
- num_ignore = int(main.params['TEST']['numIgnore'])
- num_switch = int(main.params['TEST']['numSwitch'])
- n_thread = main.params['TEST']['numMult']
- #n_thread = 105
+ batchIntentSize = int( main.params[ 'TEST' ][ 'batchIntentSize' ] )
+ batchThreshMin = int( main.params[ 'TEST' ][ 'batchThresholdMin' ] )
+ batchThreshMax = int( main.params[ 'TEST' ][ 'batchThresholdMax' ] )
- #Switch assignment NOTE: hardcoded
- if cluster_count == 1:
- for i in range(1, num_switch+1):
- main.Mininet1.assign_sw_controller(
- sw=str(i),
- ip1=ONOS1_ip,
- port1=default_sw_port)
- if cluster_count == 3:
- for i in range(1, 3):
- main.Mininet1.assign_sw_controller(
- sw=str(i),
- ip1=ONOS1_ip,
- port1=default_sw_port)
- for i in range(3, 6):
- main.Mininet1.assign_sw_controller(
- sw=str(i),
- ip1=ONOS2_ip,
- port1=default_sw_port)
- for i in range(6, 9):
- main.Mininet1.assign_sw_controller(
- sw=str(i),
- ip1=ONOS3_ip,
- port1=default_sw_port)
- if cluster_count == 5:
- 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)
- for i in range(3, 6):
- main.Mininet1.assign_sw_controller(
- sw=str(i),
- ip1=ONOS3_ip,
- port1=default_sw_port)
- main.Mininet1.assign_sw_controller(
- sw="6",
- ip1=ONOS4_ip,
- port1=default_sw_port)
- main.Mininet1.assign_sw_controller(
- sw="7",
- ip1=ONOS5_ip,
- port1=default_sw_port)
- main.Mininet1.assign_sw_controller(
- sw="8",
- ip1=ONOS5_ip,
- port1=default_sw_port)
-
- if cluster_count == 7:
- for i in range(1,9):
+ # number of iterations of case
+ numIter = main.params[ 'TEST' ][ 'numIter' ]
+ numIgnore = int( main.params[ 'TEST' ][ 'numIgnore' ] )
+ numSwitch = int( main.params[ 'TEST' ][ 'numSwitch' ] )
+ nThread = main.params[ 'TEST' ][ 'numMult' ]
+ #nThread = 105
+
+ # Switch assignment NOTE: hardcoded
+ 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.assign_sw_controller(
- sw=str(i),
- ip1=ONOS_ip_list[i-1],
- port1=default_sw_port)
- elif i >= 8:
- main.Mininet1.assign_sw_controller(
- sw=str(i),
- ip1=ONOS_ip_list[6],
- port1=default_sw_port)
+ 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)
+ time.sleep( 20 )
- main.log.report("Batch intent installation test of "+
- batch_intent_size +" intent(s)")
+ main.log.report( "Batch intent installation test of " +
+ str( batchIntentSize ) + " intent(s)" )
- batch_result_list = []
+ batchResultList = []
- main.log.info("Getting list of available devices")
- device_id_list = []
- json_str = main.ONOS1cli.devices()
- json_obj = json.loads(json_str)
- for device in json_obj:
- device_id_list.append(device['id'])
+ 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' ] )
- batch_install_lat = []
- batch_withdraw_lat = []
-
- #Max intent install measurement of all nodes
- max_install_lat = []
- max_withdraw_lat = []
- sleep_time = 10
-
- base_dir = "/tmp/"
+ batchInstallLat = []
+ batchWithdrawLat = []
- for batch in range(0, 5):
- for i in range(0, int(num_iter)):
- main.log.info("Pushing "+
- str(int(batch_intent_size)*int(n_thread))+
- " intents. Iteration "+str(i))
-
- for node in range(1, cluster_count+1):
- save_dir = base_dir + "batch_intent_"+str(node)+".txt"
- main.ONOSbench.push_test_intents_shell(
- device_id_list[0]+"/2",
- device_id_list[7]+"/2",
- int(batch_intent_size),
- save_dir, ONOS_ip_list[node-1],
- num_mult=n_thread, app_id=node)
-
- #Wait sufficient time for intents to start
- #installing
- time.sleep(sleep_time)
+ # Max intent install measurement of all nodes
+ maxInstallLat = []
+ maxWithdrawLat = []
+ sleepTime = 10
+
+ baseDir = "/tmp/"
+
+ for batch in range( 0, 5 ):
+ for i in range( 0, int( numIter ) ):
+ main.log.info( "Pushing " +
+ str( int( batchIntentSize ) * int( nThread ) ) +
+ " intents. Iteration " + str( i ) )
+
+ for node in range( 1, clusterCount + 1 ):
+ saveDir = baseDir + "batch_intent_" + str( node ) + ".txt"
+ main.ONOSbench.pushTestIntentsShell(
+ deviceIdList[ 0 ] + "/2",
+ deviceIdList[ 7 ] + "/2",
+ batchIntentSize,
+ saveDir, ONOSIpList[ node - 1 ],
+ numMult=nThread, appId=node )
+
+ # Wait sufficient time for intents to start
+ # installing
+ time.sleep( sleepTime )
intent = ""
counter = 300
- while len(intent) > 0 and counter > 0:
+ while len( intent ) > 0 and counter > 0:
main.ONOS1cli.handle.sendline(
- "intents | wc -l")
+ "intents | wc -l" )
main.ONOS1cli.handle.expect(
- "intents | wc -l")
+ "intents | wc -l" )
main.ONOS1cli.handle.expect(
- "onos>")
- intent_temp = main.ONOS1cli.handle.before()
+ "onos>" )
+ intentTemp = main.ONOS1cli.handle.before()
intent = main.ONOS1cli.intents()
- intent = json.loads(intent)
- counter = counter-1
- time.sleep(1)
+ intent = json.loads( intent )
+ counter = counter - 1
+ time.sleep( 1 )
- time.sleep(5)
+ time.sleep( 5 )
- for node in range(1, cluster_count+1):
- save_dir = base_dir + "batch_intent_"+str(node)+".txt"
- with open(save_dir) as f_onos:
- line_count = 0
- for line in f_onos:
- line = line[1:]
- line = line.split(": ")
- main.log.info("Line read: "+str(line))
- result = line[1].split(" ")[0]
- #TODO: add parameters before appending latency
- if line_count == 0:
- batch_install_lat.append(int(result))
- install_result = result
- elif line_count == 1:
- batch_withdraw_lat.append(int(result))
- withdraw_result = result
- line_count += 1
- main.log.info("Batch install latency for ONOS"+
- str(node)+" with "+\
- str(batch_intent_size) + "intents: "+\
- str(install_result)+" ms")
- main.log.info("Batch withdraw latency for ONOS"+
- str(node)+" with "+
- str(batch_intent_size) + "intents: "+
- str(withdraw_result)+" ms")
+ for node in range( 1, clusterCount + 1 ):
+ saveDir = baseDir + "batch_intent_" + str( node ) + ".txt"
+ with open( saveDir ) as fOnos:
+ lineCount = 0
+ for line in fOnos:
+ line = line[ 1: ]
+ line = line.split( ": " )
+ main.log.info( "Line read: " + str( line ) )
+ #Prevent split method if line doesn't have
+ #space
+ if " " in str(line):
+ result = line[ 1 ].split( " " )[ 0 ]
+ else:
+ main.log.warn( "Empty line read" )
+ result = 0
+ # TODO: add parameters before appending latency
+ if lineCount == 0:
+ batchInstallLat.append( int( result ) )
+ installResult = result
+ elif lineCount == 1:
+ batchWithdrawLat.append( int( result ) )
+ withdrawResult = result
+ else:
+ main.log.warn("Invalid results")
+ installResult = 'NA'
+ withdrawResult = 'NA'
+ lineCount += 1
+ main.log.info( "Batch install latency for ONOS" +
+ str( node ) + " with " +
+ str( batchIntentSize ) + "intents: " +
+ str( installResult ) + " ms" )
+ main.log.info( "Batch withdraw latency for ONOS" +
+ str( node ) + " with " +
+ str( batchIntentSize ) + "intents: " +
+ str( withdrawResult ) + " ms" )
- if len(batch_install_lat) > 0 and int(i) > num_ignore:
- max_install_lat.append(max(batch_install_lat))
- elif len(batch_install_lat) == 0:
- #If I failed to read anything from the file,
- #increase the wait time before checking intents
- sleep_time += 30
- if len(batch_withdraw_lat) > 0 and int(i) > num_ignore:
- max_withdraw_lat.append(max(batch_withdraw_lat))
- batch_install_lat = []
- batch_withdraw_lat = []
-
- #Sleep in between iterations
- time.sleep(5)
-
- if max_install_lat:
- avg_install_lat = str(sum(max_install_lat) /\
- len(max_install_lat))
+ if len( batchInstallLat ) > 0 and int( i ) > numIgnore:
+ maxInstallLat.append( max( batchInstallLat ) )
+ elif len( batchInstallLat ) == 0:
+ # If I failed to read anything from the file,
+ # increase the wait time before checking intents
+ sleepTime += 30
+ if len( batchWithdrawLat ) > 0 and int( i ) > numIgnore:
+ maxWithdrawLat.append( max( batchWithdrawLat ) )
+ batchInstallLat = []
+ batchWithdrawLat = []
+
+ # Sleep in between iterations
+ time.sleep( 5 )
+
+ if maxInstallLat:
+ avgInstallLat = str( round(
+ sum( maxInstallLat ) /
+ len( maxInstallLat )
+ , 2 ))
else:
- avg_install_lat = "NA"
- main.log.report("Batch installation failed")
+ avgInstallLat = "NA"
+ main.log.report( "Batch installation failed" )
assertion = main.FALSE
- if max_withdraw_lat:
- avg_withdraw_lat = str(sum(max_withdraw_lat) /\
- len(max_withdraw_lat))
+ if maxWithdrawLat:
+ avgWithdrawLat = str( round(
+ sum( maxWithdrawLat ) /
+ len( maxWithdrawLat )
+ , 2 ))
else:
- avg_withdraw_lat = "NA"
- main.log.report("Batch withdraw failed")
+ avgWithdrawLat = "NA"
+ main.log.report( "Batch withdraw failed" )
assertion = main.FALSE
- main.log.report("Avg of batch installation latency "+
- "of size "+batch_intent_size+": "+
- str(avg_install_lat)+" ms")
- main.log.report("Std Deviation of batch installation latency "+
- ": "+str(numpy.std(max_install_lat))+" ms")
+ 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 "+batch_intent_size+": "+
- str(avg_withdraw_lat)+" ms")
- main.log.report("Std Deviation of batch withdraw latency "+
- ": "+str(numpy.std(max_withdraw_lat))+" ms")
-
- batch_intent_size += 1000
- main.log.report("Increasing batch intent size to "+
- batch_intent_size)
-
- #main.log.info("Removing all intents for next test case")
- #json_temp = main.ONOS1cli.intents(json_format=True)
- #json_obj_intents = json.loads(json_temp)
- #if json_obj_intents:
- # for intents in json_obj_intents:
- # temp_id = intents['id']
- #main.ONOS1cli.remove_intent(temp_id)
- # main.ONOS1cli.remove_intent(temp_id)
-
- utilities.assert_equals(expect=main.TRUE, actual=assertion,
+ 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" )
+
+ if batch == 0:
+ batchIntentSize = 10
+ elif batch == 1:
+ batchIntentSize = 100
+ elif batch == 2:
+ batchIntentSize = 1000
+ elif batch == 3:
+ batchIntentSize = 2000
+ if batch < 4:
+ main.log.report( "Increasing batch intent size to " +
+ str(batchIntentSize) )
+
+ #main.log.info( "Removing all intents for next test case" )
+ #jsonTemp = main.ONOS1cli.intents( jsonFormat=True )
+ #jsonObjIntents = json.loads( jsonTemp )
+ # if jsonObjIntents:
+ # for intents in jsonObjIntents:
+ # tempId = intents[ 'id' ]
+ # main.ONOS1cli.removeIntent( tempId )
+ # main.ONOS1cli.removeIntent( tempId )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=assertion,
onpass="Batch intent install/withdraw test successful",
- onfail="Batch intent install/withdraw test failed")
+ onfail="Batch intent install/withdraw test failed" )
- def CASE5(self,main):
- '''
+ def CASE5( self, main ):
+ """
Increase number of nodes and initiate CLI
- '''
+ """
import time
import json
- 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']
+ 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' ]
- global cluster_count
- cluster_count += 2
- main.log.report("Increasing cluster size to "+
- str(cluster_count))
+ global clusterCount
+ clusterCount += 2
+ main.log.report( "Increasing cluster size to " +
+ str( clusterCount ) )
- install_result = main.FALSE
+ installResult = main.FALSE
- if cluster_count == 3:
- install_result1 = \
- main.ONOSbench.onos_install(node=ONOS2_ip)
- install_result2 = \
- main.ONOSbench.onos_install(node=ONOS3_ip)
- time.sleep(5)
+ if clusterCount == 3:
+ installResult1 = \
+ main.ONOSbench.onosInstall( node=ONOS2Ip )
+ installResult2 = \
+ main.ONOSbench.onosInstall( node=ONOS3Ip )
+ time.sleep( 5 )
- main.log.info("Starting ONOS CLI")
- main.ONOS2cli.start_onos_cli(ONOS2_ip)
- main.ONOS3cli.start_onos_cli(ONOS3_ip)
+ main.log.info( "Starting ONOS CLI" )
+ main.ONOS2cli.startOnosCli( ONOS2Ip )
+ main.ONOS3cli.startOnosCli( ONOS3Ip )
- install_result = install_result1 and install_result2
+ installResult = installResult1 and installResult2
- if cluster_count == 5:
- main.log.info("Installing ONOS on node 4 and 5")
- install_result1 = \
- main.ONOSbench.onos_install(node=ONOS4_ip)
- install_result2 = \
- main.ONOSbench.onos_install(node=ONOS5_ip)
+ if clusterCount == 5:
+ main.log.info( "Installing ONOS on node 4 and 5" )
+ installResult1 = \
+ main.ONOSbench.onosInstall( node=ONOS4Ip )
+ installResult2 = \
+ main.ONOSbench.onosInstall( node=ONOS5Ip )
- main.log.info("Starting ONOS CLI")
- main.ONOS4cli.start_onos_cli(ONOS4_ip)
- main.ONOS5cli.start_onos_cli(ONOS5_ip)
+ main.log.info( "Starting ONOS CLI" )
+ main.ONOS4cli.startOnosCli( ONOS4Ip )
+ main.ONOS5cli.startOnosCli( ONOS5Ip )
- install_result = install_result1 and install_result2
+ installResult = installResult1 and installResult2
- if cluster_count == 7:
- main.log.info("Installing ONOS on node 6 and 7")
- install_result1 = \
- main.ONOSbench.onos_install(node=ONOS6_ip)
- install_result2 = \
- main.ONOSbench.onos_install(node=ONOS7_ip)
+ if clusterCount == 7:
+ main.log.info( "Installing ONOS on node 6 and 7" )
+ installResult1 = \
+ main.ONOSbench.onosInstall( node=ONOS6Ip )
+ installResult2 = \
+ main.ONOSbench.onosInstall( node=ONOS7Ip )
- main.log.info("Starting ONOS CLI")
- main.ONOS6cli.start_onos_cli(ONOS6_ip)
- main.ONOS7cli.start_onos_cli(ONOS7_ip)
+ main.log.info( "Starting ONOS CLI" )
+ main.ONOS6cli.startOnosCli( ONOS6Ip )
+ main.ONOS7cli.startOnosCli( ONOS7Ip )
- install_result = install_result1 and install_result2
+ installResult = installResult1 and installResult2
- time.sleep(5)
+ time.sleep( 5 )
- if install_result == main.TRUE:
+ if installResult == main.TRUE:
assertion = main.TRUE
else:
assertion = main.FALSE
- utilities.assert_equals(expect=main.TRUE, actual=assertion,
- onpass="Scale out to "+str(cluster_count)+\
- " nodes successful",
- onfail="Scale out to "+str(cluster_count)+\
- " nodes failed")
-
- def CASE7(self, main):
- #TODO: Fix for scale-out scenario
+ utilities.assert_equals( expect=main.TRUE, actual=assertion,
+ onpass="Scale out to " + str( clusterCount ) +
+ " nodes successful",
+ onfail="Scale out to " + str( clusterCount ) +
+ " nodes failed" )
- '''
+ def CASE7( self, main ):
+ # TODO: Fix for scale-out scenario
+ """
Batch intent reroute latency
- '''
+ """
import time
import json
import requests
import os
import numpy
- global cluster_count
+ global clusterCount
- ONOS_ip_list = []
- for i in range(1, 8):
- ONOS_ip_list.append(main.params['CTRL']['ip'+str(i)])
+ ONOSIpList = []
+ for i in range( 1, 8 ):
+ ONOSIpList.append( main.params[ 'CTRL' ][ 'ip' + str( i ) ] )
- ONOS_user = main.params['CTRL']['user']
- default_sw_port = main.params['CTRL']['port1']
-
- batch_intent_size = main.params['TEST']['batchIntentSize']
- batch_thresh_min = int(main.params['TEST']['batchThresholdMin'])
- batch_thresh_max = int(main.params['TEST']['batchThresholdMax'])
- intfs = main.params['TEST']['intfs']
- install_time = main.params['JSON']['installedTime']
+ ONOSUser = main.params[ 'CTRL' ][ 'user' ]
+ defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
- #number of iterations of case
- num_iter = main.params['TEST']['numIter']
- num_ignore = int(main.params['TEST']['numIgnore'])
- num_switch = int(main.params['TEST']['numSwitch'])
- n_thread = main.params['TEST']['numMult']
+ batchIntentSize = main.params[ 'TEST' ][ 'batchIntentSize' ]
+ batchThreshMin = int( main.params[ 'TEST' ][ 'batchThresholdMin' ] )
+ batchThreshMax = int( main.params[ 'TEST' ][ 'batchThresholdMax' ] )
+ intfs = main.params[ 'TEST' ][ 'intfs' ]
+ installTime = main.params[ 'JSON' ][ 'installedTime' ]
- main.log.report("Batch intent installation test of "+
- batch_intent_size +" intents")
+ # number of iterations of case
+ numIter = main.params[ 'TEST' ][ 'numIter' ]
+ numIgnore = int( main.params[ 'TEST' ][ 'numIgnore' ] )
+ numSwitch = int( main.params[ 'TEST' ][ 'numSwitch' ] )
+ nThread = main.params[ 'TEST' ][ 'numMult' ]
- batch_result_list = []
+ main.log.report( "Batch intent installation test of " +
+ batchIntentSize + " intents" )
- time.sleep(10)
+ batchResultList = []
- main.log.info("Getting list of available devices")
- device_id_list = []
- json_str = main.ONOS1cli.devices()
- json_obj = json.loads(json_str)
- for device in json_obj:
- device_id_list.append(device['id'])
+ time.sleep( 10 )
- batch_install_lat = []
- batch_withdraw_lat = []
- sleep_time = 10
-
- base_dir = "/tmp/"
- max_install_lat = []
+ 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' ] )
- for i in range(0, int(num_iter)):
- main.log.info("Pushing "+
- str(int(batch_intent_size)*int(n_thread))+
- " intents. Iteration "+str(i))
+ batchInstallLat = []
+ batchWithdrawLat = []
+ sleepTime = 10
- main.ONOSbench.push_test_intents_shell(
- device_id_list[0]+"/2",
- device_id_list[7]+"/2",
- batch_intent_size, "/tmp/batch_install.txt",
- ONOS_ip_list[0], num_mult="1", app_id="1",
- report=False, options="--install")
- #main.ONOSbench.push_test_intents_shell(
+ baseDir = "/tmp/"
+ maxInstallLat = []
+
+ for i in range( 0, int( numIter ) ):
+ 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", appId="1",
+ report=False, options="--install" )
+ # main.ONOSbench.pushTestIntentsShell(
# "of:0000000000001002/1",
# "of:0000000000002002/1",
# 133, "/tmp/temp2.txt", "10.128.174.2",
- # num_mult="6", app_id="2",report=False)
-
- #TODO: Check for installation success then proceed
- time.sleep(30)
-
- #NOTE: this interface is specific to
+ # numMult="6", appId="2",report=False )
+
+ # TODO: Check for installation success then proceed
+ time.sleep( 30 )
+
+ # NOTE: this interface is specific to
# topo-intentFlower.py topology
# reroute case.
- main.log.info("Disabling interface "+intfs)
+ main.log.info( "Disabling interface " + intfs )
main.Mininet1.handle.sendline(
- "sh ifconfig "+intfs+" down")
- t0_system = time.time()*1000
+ "sh ifconfig " + intfs + " down" )
+ t0System = time.time() * 1000
- #TODO: Wait sufficient time for intents to install
- time.sleep(10)
+ # TODO: Wait sufficient time for intents to install
+ time.sleep( 10 )
- #TODO: get intent installation time
-
- #Obtain metrics from ONOS 1, 2, 3
- intents_json_str_1 = main.ONOS1cli.intents_events_metrics()
- intents_json_obj_1 = json.loads(intents_json_str_1)
- #Parse values from the json object
- intent_install_1 = \
- intents_json_obj_1[install_time]['value']
- intent_reroute_lat_1 = \
- int(intent_install_1) - int(t0_system)
-
-
- if cluster_count == 3:
- intents_json_str_2 =\
- main.ONOS2cli.intents_events_metrics()
- intents_json_str_3 =\
- main.ONOS3cli.intents_events_metrics()
- intents_json_obj_2 = json.loads(intents_json_str_2)
- intents_json_obj_3 = json.loads(intents_json_str_3)
- intent_install_2 = \
- intents_json_obj_2[install_time]['value']
- intent_install_3 = \
- intents_json_obj_3[install_time]['value']
- intent_reroute_lat_2 = \
- int(intent_install_2) - int(t0_system)
- intent_reroute_lat_3 = \
- int(intent_install_3) - int(t0_system)
+ # TODO: get intent installation time
+
+ # Obtain metrics from ONOS 1, 2, 3
+ intentsJsonStr1 = main.ONOS1cli.intentsEventsMetrics()
+ intentsJsonObj1 = json.loads( intentsJsonStr1 )
+ # Parse values from the json object
+ intentInstall1 = \
+ intentsJsonObj1[ installTime ][ 'value' ]
+ intentRerouteLat1 = \
+ int( intentInstall1 ) - int( t0System )
+
+ 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 )
else:
- intent_reroute_lat_2 = 0
- intent_reroute_lat_3 = 0
+ intentRerouteLat2 = 0
+ intentRerouteLat3 = 0
- if cluster_count == 5:
- intents_json_str_4 =\
- main.ONOS4cli.intents_events_metrics()
- intents_json_str_5 =\
- main.ONOS5cli.intents_events_metrics()
- intents_json_obj_4 = json.loads(intents_json_str_4)
- intents_json_obj_5 = json.loads(intents_json_str_5)
- intent_install_4 = \
- intents_json_obj_4[install_time]['value']
- intent_install_5 = \
- intents_json_obj_5[install_time]['value']
- intent_reroute_lat_4 = \
- int(intent_install_4) - int(t0_system)
- intent_reroute_lat_5 = \
- int(intent_install_5) - int(t0_system)
+ 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 )
else:
- intent_reroute_lat_4 = 0
- intent_reroute_lat_5 = 0
+ intentRerouteLat4 = 0
+ intentRerouteLat5 = 0
- if cluster_count == 7:
- intents_json_str_6 =\
- main.ONOS6cli.intents_events_metrics()
- intents_json_str_7 =\
- main.ONOS7cli.intents_events_metrics()
- intents_json_obj_6 = json.loads(intents_json_str_6)
- intents_json_obj_7 = json.loads(intents_json_str_7)
- intent_install_6 = \
- intents_json_obj_6[install_time]['value']
- intent_install_7 = \
- intents_json_obj_7[install_time]['value']
- intent_reroute_lat_6 = \
- int(intent_install_6) - int(t0_system)
- intent_reroute_lat_7 = \
- int(intent_install_7) - int(t0_system)
+ 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 )
else:
- intent_reroute_lat_6 = 0
- intent_reroute_lat_7 = 0
+ intentRerouteLat6 = 0
+ intentRerouteLat7 = 0
- intent_reroute_lat_avg = \
- (intent_reroute_lat_1 +
- intent_reroute_lat_2 +
- intent_reroute_lat_3 +
- intent_reroute_lat_4 +
- intent_reroute_lat_5 +
- intent_reroute_lat_6 +
- intent_reroute_lat_7) / cluster_count
-
- main.log.info("Intent reroute latency avg for iteration "+
- str(i)+": "+str(intent_reroute_lat_avg))
- #TODO: Remove intents for next iteration
-
- time.sleep(5)
+ intentRerouteLatAvg = \
+ ( intentRerouteLat1 +
+ intentRerouteLat2 +
+ intentRerouteLat3 +
+ intentRerouteLat4 +
+ intentRerouteLat5 +
+ intentRerouteLat6 +
+ intentRerouteLat7 ) / clusterCount
- intents_str = main.ONOS1cli.intents()
- intents_json = json.loads(intents_str)
- for intents in intents_json:
- intent_id = intents['id']
- #TODO: make sure this removes all intents
- #print intent_id
- if intent_id:
- main.ONOS1cli.remove_intent(intent_id)
+ main.log.info( "Intent reroute latency avg for iteration " +
+ str( i ) + ": " + str( intentRerouteLatAvg ) )
+ # TODO: Remove intents for next iteration
+
+ time.sleep( 5 )
+
+ intentsStr = main.ONOS1cli.intents()
+ intentsJson = json.loads( intentsStr )
+ for intents in intentsJson:
+ intentId = intents[ 'id' ]
+ # TODO: make sure this removes all intents
+ # print intentId
+ if intentId:
+ main.ONOS1cli.removeIntent( intentId )
main.Mininet1.handle.sendline(
- "sh ifconfig "+intfs+" up")
-
- main.log.info("Intents removed and port back up")
+ "sh ifconfig " + intfs + " up" )
- def CASE9(self, main):
+ main.log.info( "Intents removed and port back up" )
+
+ def CASE9( self, main ):
count = 0
- sw_num1 = 1
- sw_num2 = 1
+ swNum1 = 1
+ swNum2 = 1
appid = 0
- port_num1 = 1
- port_num2 = 1
-
- time.sleep(30)
+ portNum1 = 1
+ portNum2 = 1
+
+ time.sleep( 30 )
while True:
- #main.ONOS1cli.push_test_intents(
+ # main.ONOS1cli.pushTestIntents(
#"of:0000000000001001/1",
#"of:0000000000002001/1",
- # 100, num_mult="10", app_id="1")
- #main.ONOS2cli.push_test_intents(
+ # 100, numMult="10", appId="1" )
+ # main.ONOS2cli.pushTestIntents(
# "of:0000000000001002/1",
# "of:0000000000002002/1",
- # 100, num_mult="10", app_id="2")
- #main.ONOS2cli.push_test_intents(
+ # 100, numMult="10", appId="2" )
+ # main.ONOS2cli.pushTestIntents(
# "of:0000000000001003/1",
# "of:0000000000002003/1",
- # 100, num_mult="10", app_id="3")
+ # 100, numMult="10", appId="3" )
count += 1
-
+
if count >= 100:
main.ONOSbench.handle.sendline(
- "onos 10.128.174.1 intents-events-metrics >>"+\
- " /tmp/metrics_intents_temp.txt &")
+ "onos 10.128.174.1 intents-events-metrics >>" +
+ " /tmp/metrics_intents_temp.txt &" )
count = 0
- arg1 = "of:000000000000100"+str(sw_num1)+"/"+str(port_num1)
- arg2 = "of:000000000000200"+str(sw_num2)+"/"+str(port_num2)
-
- sw_num1 += 1
+ arg1 = "of:000000000000100" + str( swNum1 ) + "/" + str( portNum1 )
+ arg2 = "of:000000000000200" + str( swNum2 ) + "/" + str( portNum2 )
- if sw_num1 > 7:
- sw_num1 = 1
- sw_num2 += 1
- if sw_num2 > 7:
+ swNum1 += 1
+
+ if swNum1 > 7:
+ swNum1 = 1
+ swNum2 += 1
+ if swNum2 > 7:
appid += 1
- if sw_num2 > 7:
- sw_num2 = 1
-
- main.ONOSbench.push_test_intents_shell(
+ if swNum2 > 7:
+ swNum2 = 1
+
+ main.ONOSbench.pushTestIntentsShell(
arg1,
- arg2,
+ arg2,
100, "/tmp/temp.txt", "10.128.174.1",
- num_mult="10", app_id=appid,report=False)
- #main.ONOSbench.push_test_intents_shell(
+ numMult="10", appId=appid, report=False )
+ # main.ONOSbench.pushTestIntentsShell(
# "of:0000000000001002/1",
# "of:0000000000002002/1",
# 133, "/tmp/temp2.txt", "10.128.174.2",
- # num_mult="6", app_id="2",report=False)
- #main.ONOSbench.push_test_intents_shell(
+ # numMult="6", appId="2",report=False )
+ # main.ONOSbench.pushTestIntentsShell(
# "of:0000000000001003/1",
# "of:0000000000002003/1",
# 133, "/tmp/temp3.txt", "10.128.174.3",
- # num_mult="6", app_id="3",report=False)
-
- time.sleep(0.2)
+ # numMult="6", appId="3",report=False )
+ time.sleep( 0.2 )
diff --git a/TestON/tests/LincOETest/LincOETest.py b/TestON/tests/LincOETest/LincOETest.py
index 6c59c5b..b693138 100644
--- a/TestON/tests/LincOETest/LincOETest.py
+++ b/TestON/tests/LincOETest/LincOETest.py
@@ -29,62 +29,62 @@
"""
import time
- cell_name = main.params[ 'ENV' ][ 'cellName' ]
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
- ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
- git_pull_trigger = main.params[ 'GIT' ][ 'autoPull' ]
- git_checkout_branch = main.params[ 'GIT' ][ 'checkout' ]
+ gitPullTrigger = main.params[ 'GIT' ][ 'autoPull' ]
+ gitCheckoutBranch = main.params[ 'GIT' ][ 'checkout' ]
main.case( "Setting up test environment" )
main.step( "Creating cell file" )
# params: ( bench ip, cell name, mininet ip, *onos ips )
- cell_file_result = main.ONOSbench.create_cell_file(
- "10.128.20.10", cell_name, "10.128.10.90",
+ cellFileResult = main.ONOSbench.createCellFile(
+ "10.128.20.10", cellName, "10.128.10.90",
"onos-core-trivial,onos-app-fwd",
"10.128.174.1" )
main.step( "Applying cell variable to environment" )
- #cell_result = main.ONOSbench.set_cell( cell_name )
- cell_result = main.ONOSbench.set_cell( "temp_cell_2" )
- verify_result = main.ONOSbench.verify_cell()
+ # cellResult = main.ONOSbench.setCell( cellName )
+ cellResult = main.ONOSbench.setCell( "temp_cell_2" )
+ verifyResult = main.ONOSbench.verifyCell()
- if git_pull_trigger == 'on':
+ if gitPullTrigger == 'on':
main.step( "Git checkout and pull master" )
- main.ONOSbench.git_checkout( git_checkout_branch )
- git_pull_result = main.ONOSbench.git_pull()
+ main.ONOSbench.gitCheckout( gitCheckoutBranch )
+ gitPullResult = main.ONOSbench.gitPull()
else:
main.log.info( "Git checkout and pull skipped by config" )
- git_pull_result = main.TRUE
+ gitPullResult = main.TRUE
main.step( "Using mvn clean & install" )
- #clean_install_result = main.ONOSbench.clean_install()
- clean_install_result = main.TRUE
+ # cleanInstallResult = main.ONOSbench.cleanInstall()
+ cleanInstallResult = main.TRUE
main.step( "Creating ONOS package" )
- package_result = main.ONOSbench.onos_package()
+ packageResult = main.ONOSbench.onosPackage()
main.step( "Installing ONOS package" )
- onos_install_result = main.ONOSbench.onos_install()
- onos1_isup = main.ONOSbench.isup()
+ onosInstallResult = main.ONOSbench.onosInstall()
+ onos1Isup = main.ONOSbench.isup()
main.step( "Starting ONOS service" )
- start_result = main.ONOSbench.onos_start( ONOS1_ip )
+ startResult = main.ONOSbench.onosStart( ONOS1Ip )
main.step( "Setting cell for ONOScli" )
- main.ONOScli.set_cell( cell_name )
+ main.ONOScli.setCell( cellName )
main.step( "Starting ONOScli" )
- main.ONOScli.start_onos_cli( ONOS1_ip )
+ main.ONOScli.startOnosCli( ONOS1Ip )
- case1_result = ( clean_install_result and package_result and
- cell_result and verify_result and onos_install_result and
- onos1_isup and start_result )
- utilities.assert_equals( expect=main.TRUE, actual=case1_result,
- onpass="Test startup successful",
- onfail="Test startup NOT successful" )
+ case1Result = ( cleanInstallResult and packageResult and
+ cellResult and verifyResult and onosInstallResult and
+ onos1Isup and startResult )
+ utilities.assertEquals( expect=main.TRUE, actual=case1Result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful" )
time.sleep( 10 )
@@ -94,18 +94,18 @@
"""
import time
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
- default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
# Assign packet level switches to controller
- main.Mininet1.assign_sw_controller(
+ main.Mininet1.assignSwController(
sw="1",
- ip1=ONOS1_ip,
- port1=default_sw_port )
- main.Mininet1.assign_sw_controller(
+ ip1=ONOS1Ip,
+ port1=defaultSwPort )
+ main.Mininet1.assignSwController(
sw="2",
- ip1=ONOS1_ip,
- port1=default_sw_port )
+ ip1=ONOS1Ip,
+ port1=defaultSwPort )
# Check devices in controller
# This should include Linc-OE devices as well
diff --git a/TestON/tests/MultiProd/MultiProd.bak b/TestON/tests/MultiProd/MultiProd.bak
new file mode 100755
index 0000000..11af10b
--- /dev/null
+++ b/TestON/tests/MultiProd/MultiProd.bak
@@ -0,0 +1,1156 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import time
+import json
+
+time.sleep(1)
+class MultiProd:
+ def __init__(self):
+ self.default = ''
+
+ def CASE1(self, main):
+ '''
+ Startup sequence:
+ cell <name>
+ onos-verify-cell
+ onos-remove-raft-logs
+ git pull
+ mvn clean install
+ onos-package
+ onos-install -f
+ onos-wait-for-start
+ '''
+
+ cell_name = main.params['ENV']['cellName']
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
+ main.case("Setting up test environment")
+ main.log.report("This testcase is testing setting up test environment")
+ main.log.report("__________________________________")
+
+ main.step("Applying cell variable to environment")
+ cell_result1 = main.ONOSbench.set_cell(cell_name)
+ #cell_result2 = main.ONOScli1.set_cell(cell_name)
+ #cell_result3 = main.ONOScli2.set_cell(cell_name)
+ #cell_result4 = main.ONOScli3.set_cell(cell_name)
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result = cell_result1
+
+ main.step("Removing raft logs before a clen installation of ONOS")
+ remove_log_Result = main.ONOSbench.onos_remove_raft_logs()
+
+ main.step("Git checkout and pull master and get version")
+ main.ONOSbench.git_checkout("master")
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ main.ONOSbench.get_version(report=True)
+
+ if git_pull_result == 1:
+ main.step("Using mvn clean & install")
+ main.ONOSbench.clean_install()
+
+ main.step("Creating ONOS package")
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step("Creating a cell")
+ #cell_create_result = main.ONOSbench.create_cell_file(**************)
+
+ main.step("Installing ONOS package")
+ onos1_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS1_ip)
+ onos2_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS2_ip)
+ onos3_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS3_ip)
+ onos_install_result = onos1_install_result and onos2_install_result and onos3_install_result
+ if onos_install_result == main.TRUE:
+ main.log.report("Installing ONOS package successful")
+ else:
+ main.log.report("Installing ONOS package failed")
+
+ onos1_isup = main.ONOSbench.isup(ONOS1_ip)
+ onos2_isup = main.ONOSbench.isup(ONOS2_ip)
+ onos3_isup = main.ONOSbench.isup(ONOS3_ip)
+ onos_isup = onos1_isup and onos2_isup and onos3_isup
+ if onos_isup == main.TRUE:
+ main.log.report("ONOS instances are up and ready")
+ else:
+ main.log.report("ONOS instances may not be up")
+
+ main.step("Starting ONOS service")
+ start_result = main.TRUE
+ #start_result = main.ONOSbench.onos_start(ONOS1_ip)
+ startcli1 = main.ONOScli1.start_onos_cli(ONOS_ip = ONOS1_ip)
+ startcli2 = main.ONOScli2.start_onos_cli(ONOS_ip = ONOS2_ip)
+ startcli3 = main.ONOScli3.start_onos_cli(ONOS_ip = ONOS3_ip)
+ print startcli1
+ print startcli2
+ print startcli3
+
+ case1_result = (package_result and\
+ cell_result and verify_result and onos_install_result and\
+ onos_isup and start_result )
+ utilities.assert_equals(expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful")
+
+ def CASE11(self, main):
+ '''
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
+ main.case("Cleaning up test environment")
+
+ main.step("Testing ONOS kill function")
+ kill_result1 = main.ONOSbench.onos_kill(ONOS1_ip)
+ kill_result2 = main.ONOSbench.onos_kill(ONOS2_ip)
+ kill_result3 = main.ONOSbench.onos_kill(ONOS3_ip)
+
+ main.step("Stopping ONOS service")
+ stop_result1 = main.ONOSbench.onos_stop(ONOS1_ip)
+ stop_result2 = main.ONOSbench.onos_stop(ONOS2_ip)
+ stop_result3 = main.ONOSbench.onos_stop(ONOS3_ip)
+
+ main.step("Uninstalling ONOS service")
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ def CASE3(self, main):
+ '''
+ Test 'onos' command and its functionality in driver
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
+ main.case("Testing 'onos' command")
+
+ main.step("Sending command 'onos -w <onos-ip> system:name'")
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result1)
+ cmd_result2 = main.ONOSbench.onos_cli(ONOS2_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result2)
+ cmd_result3 = main.ONOSbench.onos_cli(ONOS3_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result3)
+
+ main.step("Sending command 'onos -w <onos-ip> onos:topology'")
+ cmdstr2 = "onos:topology"
+ cmd_result4 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result4)
+ cmd_result5 = main.ONOSbench.onos_cli(ONOS2_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result5)
+ cmd_result6 = main.ONOSbench.onos_cli(ONOS6_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result6)
+
+
+ def CASE4(self, main):
+ import re
+ import time
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+ ONOS1_port = main.params['CTRL']['port1']
+ ONOS2_port = main.params['CTRL']['port2']
+ ONOS3_port = main.params['CTRL']['port3']
+
+ main.log.report("This testcase is testing the assignment of all the switches to all controllers and discovering the hosts in reactive mode")
+ main.log.report("__________________________________")
+ main.case("Pingall Test(No intents are added)")
+ main.step("Assigning switches to controllers")
+ for i in range(1,29): #1 to (num of switches +1)
+ main.Mininet1.assign_sw_controller(sw=str(i),count=3,
+ ip1=ONOS1_ip, port1=ONOS1_port,
+ ip2=ONOS2_ip, port2=ONOS2_port,
+ ip3=ONOS3_ip, port3=ONOS3_port)
+
+ switch_mastership = main.TRUE
+ for i in range (1,29):
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ switch_mastership = switch_mastership and main.TRUE
+ else:
+ switch_mastership = main.FALSE
+
+ if switch_mastership == main.TRUE:
+ main.log.report("Controller assignment successfull")
+ else:
+ main.log.report("Controller assignment failed")
+ #REACTIVE FWD test
+ main.step("Pingall")
+ ping_result = main.FALSE
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % (time2 - time1)
+
+ case4_result = switch_mastership and ping_result
+ if ping_result == main.TRUE:
+ main.log.report("Pingall Test in reactive mode to discover the hosts successful")
+ else:
+ main.log.report("Pingall Test in reactive mode to discover the hosts failed")
+
+ utilities.assert_equals(expect=main.TRUE, actual=case4_result,onpass="Controller assignment and Pingall Test successful",onfail="Controller assignment and Pingall Test NOT successful")
+
+
+
+ def CASE5(self,main) :
+ import json
+ from subprocess import Popen, PIPE
+ from sts.topology.teston_topology import TestONTopology # assumes that sts is already in you PYTHONPATH
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
+ main.log.report("This testcase is testing if all ONOS nodes are in topology sync with mininet and its peer ONOS nodes")
+ main.log.report("__________________________________")
+ main.case ("Testing Mininet topology with the topology of multi instances ONOS")
+ main.step("Collecting topology information from ONOS")
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ #print "devices1 = ", devices1
+ #print "devices2 = ", devices2
+ #print "devices3 = ", devices3
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ #print "hosts1 = ", hosts1
+ #print "hosts2 = ", hosts2
+ #print "hosts3 = ", hosts3
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ #print "ports1 = ", ports1
+ #print "ports2 = ", ports2
+ #print "ports3 = ", ports3
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+ #print "links1 = ", links1
+ #print "links2 = ", links2
+ #print "links3 = ", links3
+
+ print "**************"
+
+ main.step("Start continuous pings")
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+ main.step("Create TestONTopology object")
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ('ip' + str(count)) in main.params['CTRL']:
+ temp = temp + (getattr(main,('ONOS' + str(count))),)
+ temp = temp + ("ONOS"+str(count),)
+ temp = temp + (main.params['CTRL']['ip'+str(count)],)
+ temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
+ ctrls.append(temp)
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step("Compare ONOS Topology to MN Topology")
+
+ switches_results1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices1))
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect")
+
+ switches_results2 = main.Mininet1.compare_switches(MNTopo, json.loads(devices2))
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect")
+
+ switches_results3 = main.Mininet1.compare_switches(MNTopo, json.loads(devices3))
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect")
+
+ '''
+ ports_results1 = main.Mininet1.compare_ports(MNTopo, json.loads(ports1))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect")
+
+ ports_results2 = main.Mininet1.compare_ports(MNTopo, json.loads(ports2))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect")
+
+ ports_results3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports3))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect")
+ '''
+
+ links_results1 = main.Mininet1.compare_links(MNTopo, json.loads(links1))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect")
+
+ links_results2 = main.Mininet1.compare_links(MNTopo, json.loads(links2))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect")
+
+ links_results3 = main.Mininet1.compare_links(MNTopo, json.loads(links3))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect")
+
+ #topo_result = switches_results1 and switches_results2 and switches_results3\
+ #and ports_results1 and ports_results2 and ports_results3\
+ #and links_results1 and links_results2 and links_results3
+
+ topo_result = switches_results1 and switches_results2 and switches_results3\
+ and links_results1 and links_results2 and links_results3
+
+ if topo_result == main.TRUE:
+ main.log.report("Topology Check Test with mininet and ONOS instances successful")
+ else:
+ main.log.report("Topology Check Test with mininet and ONOS instances failed")
+
+ utilities.assert_equals(expect=main.TRUE, actual=topo_result,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful")
+
+
+
+
+ def CASE10(self):
+ main.log.report("This testcase uninstalls the reactive forwarding app")
+ main.log.report("__________________________________")
+ main.case("Uninstalling reactive forwarding app")
+ #Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall("onos-app-fwd")
+ appUninstall_result2 = main.ONOScli2.feature_uninstall("onos-app-fwd")
+ appUninstall_result3 = main.ONOScli3.feature_uninstall("onos-app-fwd")
+ main.log.info("onos-app-fwd uninstalled")
+
+ #After reactive forwarding is disabled, the reactive flows on switches timeout in 10-15s
+ #So sleep for 15s
+ time.sleep(15)
+
+ hosts = main.ONOScli1.hosts()
+ main.log.info(hosts)
+
+ case10_result = appUninstall_result1 and appUninstall_result2 and appUninstall_result3
+ utilities.assert_equals(expect=main.TRUE, actual=case10_result,onpass="Reactive forwarding app uninstallation successful",onfail="Reactive forwarding app uninstallation failed")
+
+
+ def CASE6(self):
+ main.log.report("This testcase is testing the addition of host intents and then doing pingall")
+ main.log.report("__________________________________")
+ main.case("Obtaining hostsfor adding host intents")
+ main.step("Get hosts")
+ hosts = main.ONOScli1.hosts()
+ main.log.info(hosts)
+
+ main.step("Get all devices id")
+ devices_id_list = main.ONOScli1.get_all_devices_id()
+ main.log.info(devices_id_list)
+
+ #ONOS displays the hosts in hex format unlike mininet which does in decimal format
+ #So take care while adding intents
+
+ '''
+ main.step("Add host intents for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1")
+ '''
+
+ for i in range(8,18):
+ main.log.info("Adding host intent between h"+str(i)+" and h"+str(i+10))
+ host1 = "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
+ host2 = "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
+ #NOTE: get host can return None
+ #TODO: handle this
+ host1_id = main.ONOScli1.get_host(host1)['id']
+ host2_id = main.ONOScli1.get_host(host2)['id']
+ tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
+
+ flowHandle = main.ONOScli1.flows()
+ #print "flowHandle = ", flowHandle
+ main.log.info("flows:" +flowHandle)
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i <18 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping == main.FALSE and count <5:
+ count+=1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+10) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h" + str(i) + " and h" + str(i+10) +"have failed")
+ i=19
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h" + str(i) + " and h" + str(i+10) + "passed!")
+ i+=1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+ if Ping_Result==main.FALSE:
+ main.log.report("Host intents have not ben installed correctly. Cleaning up")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Host intents have been installed correctly")
+
+ case6_result = Ping_Result
+ utilities.assert_equals(expect=main.TRUE, actual=case6_result,
+ onpass="Host intent addition and Pingall Test successful",
+ onfail="Host intent addition and Pingall Test NOT successful")
+
+
+ def CASE7 (self,main):
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ link_sleep = int(main.params['timers']['LinkDiscovery'])
+
+ main.log.report("This testscase is killing a link to ensure that link discovery is consistent")
+ main.log.report("__________________________________")
+ main.case("Killing a link to Ensure that Link Discovery is Working Properly")
+ main.step("Start continuous pings")
+
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+
+ main.step("Determine the current number of switches and links")
+ topology_output = main.ONOScli1.topology()
+ topology_result = main.ONOSbench.get_topology(topology_output)
+ activeSwitches = topology_result['devices']
+ links = topology_result['links']
+ print "activeSwitches = ", type(activeSwitches)
+ print "links = ", type(links)
+ main.log.info("Currently there are %s switches and %s links" %(str(activeSwitches), str(links)))
+
+ main.step("Kill Link between s3 and s28")
+ main.Mininet1.link(END1="s3",END2="s28",OPTION="down")
+ time.sleep(link_sleep)
+ topology_output = main.ONOScli2.topology()
+ Link_Down = main.ONOSbench.check_status(topology_output,activeSwitches,str(int(links)-2))
+ if Link_Down == main.TRUE:
+ main.log.report("Link Down discovered properly")
+ utilities.assert_equals(expect=main.TRUE,actual=Link_Down,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in "+ str(link_sleep) + " seconds")
+
+ main.step("Bring link between s3 and s28 back up")
+ Link_Up = main.Mininet1.link(END1="s3",END2="s28",OPTION="up")
+ time.sleep(link_sleep)
+ topology_output = main.ONOScli2.topology()
+ Link_Up = main.ONOSbench.check_status(topology_output,activeSwitches,str(links))
+ if Link_Up == main.TRUE:
+ main.log.report("Link up discovered properly")
+ utilities.assert_equals(expect=main.TRUE,actual=Link_Up,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in "+ str(link_sleep) + " seconds")
+
+ main.step("Compare ONOS Topology to MN Topology")
+ main.case ("Testing Mininet topology with the topology of multi instances ONOS")
+ main.step("Collecting topology information from ONOS")
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ print "devices1 = ", devices1
+ print "devices2 = ", devices2
+ print "devices3 = ", devices3
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ #print "hosts1 = ", hosts1
+ #print "hosts2 = ", hosts2
+ #print "hosts3 = ", hosts3
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ #print "ports1 = ", ports1
+ #print "ports2 = ", ports2
+ #print "ports3 = ", ports3
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+ #print "links1 = ", links1
+ #print "links2 = ", links2
+ #print "links3 = ", links3
+
+ print "**************"
+
+ main.step("Start continuous pings")
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+ main.step("Create TestONTopology object")
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ('ip' + str(count)) in main.params['CTRL']:
+ temp = temp + (getattr(main,('ONOS' + str(count))),)
+ temp = temp + ("ONOS"+str(count),)
+ temp = temp + (main.params['CTRL']['ip'+str(count)],)
+ temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
+ ctrls.append(temp)
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step("Compare ONOS Topology to MN Topology")
+
+ switches_results1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices1))
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect")
+
+ switches_results2 = main.Mininet1.compare_switches(MNTopo, json.loads(devices2))
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect")
+
+ switches_results3 = main.Mininet1.compare_switches(MNTopo, json.loads(devices3))
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect")
+
+ '''
+ ports_results1 = main.Mininet1.compare_ports(MNTopo, json.loads(ports1))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect")
+
+ ports_results2 = main.Mininet1.compare_ports(MNTopo, json.loads(ports2))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect")
+
+ ports_results3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports3))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect")
+ '''
+
+ links_results1 = main.Mininet1.compare_links(MNTopo, json.loads(links1))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect")
+
+ links_results2 = main.Mininet1.compare_links(MNTopo, json.loads(links2))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect")
+
+ links_results3 = main.Mininet1.compare_links(MNTopo, json.loads(links3))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect")
+
+ #topo_result = switches_results1 and switches_results2 and switches_results3\
+ #and ports_results1 and ports_results2 and ports_results3\
+ #and links_results1 and links_results2 and links_results3
+
+ topo_result = switches_results1 and switches_results2 and switches_results3\
+ and links_results1 and links_results2 and links_results3
+
+ utilities.assert_equals(expect=main.TRUE, actual=topo_result and Link_Up and Link_Down,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful")
+
+
+ def CASE8(self):
+ '''
+ Intent removal
+ '''
+ main.log.report("This testcase removes host any previously added intents")
+ main.log.report("__________________________________")
+ main.log.info("Removing any previously installed intents")
+ main.case("Removing intents")
+ main.step("Obtain the intent id's")
+ intent_result = main.ONOScli1.intents(json_format = False)
+
+ intent_linewise = intent_result.split("\n")
+ intentList = []
+ for line in intent_linewise:
+ if line.startswith("id="):
+ intentList.append(line)
+
+ intentids = []
+ for line in intentList:
+ intentids.append(line.split(",")[0].split("=")[1])
+ for id in intentids:
+ main.log.info("id = " +id)
+
+ main.step("Iterate through the intentids list and remove each intent")
+ for id in intentids:
+ main.ONOScli1.remove_intent(intent_id = id)
+
+ intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info("intent_result = " +intent_result)
+ case8_result = main.TRUE
+
+ i = 8
+ Ping_Result = main.TRUE
+ while i <18 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping==main.TRUE:
+ i = 19
+ Ping_Result = main.TRUE
+ elif ping==main.FALSE:
+ i+=1
+ Ping_Result = main.FALSE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+
+ #Note: If the ping result failed, that means the intents have been withdrawn correctly.
+ if Ping_Result==main.TRUE:
+ main.log.report("Host intents have not been withdrawn correctly")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.FALSE:
+ main.log.report("Host intents have been withdrawn correctly")
+
+ case8_result = case8_result and Ping_Result
+
+ if case8_result == main.FALSE:
+ main.log.report("Intent removal successful")
+ else:
+ main.log.report("Intent removal failed")
+
+ utilities.assert_equals(expect=main.FALSE, actual=case8_result,
+ onpass="Intent removal test failed",
+ onfail="Intent removal test successful")
+
+
+ def CASE9(self):
+ '''
+ This test case adds point intents. Make sure you run test case 8 which is host intent removal before executing this test case.
+ Else the host intent's flows will persist on switches and the pings would work even if there is some issue with the point intent's flows
+ '''
+ main.log.report("This testcase adds point intents and then does pingall")
+ main.log.report("__________________________________")
+ main.log.info("Adding point intents")
+ main.case("Adding bidirectional point for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)")
+ main.step("Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003008/1", "of:0000000000006018/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006018/1", "of:0000000000003008/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h9 and h19 or ONOS hosts h9 and h13")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003009/1", "of:0000000000006019/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006019/1", "of:0000000000003009/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h10 and h20 or ONOS hosts hA and h14")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003010/1", "of:0000000000006020/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006020/1", "of:0000000000003010/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h11 and h21 or ONOS hosts hB and h15")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003011/1", "of:0000000000006021/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006021/1", "of:0000000000003011/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h12 and h22 or ONOS hosts hC and h16")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003012/1", "of:0000000000006022/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006022/1", "of:0000000000003012/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h13 and h23 or ONOS hosts hD and h17")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003013/1", "of:0000000000006023/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006023/1", "of:0000000000003013/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h14 and h24 or ONOS hosts hE and h18")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003014/1", "of:0000000000006024/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006024/1", "of:0000000000003014/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h15 and h25 or ONOS hosts hF and h19")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003015/1", "of:0000000000006025/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006025/1", "of:0000000000003015/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h16 and h26 or ONOS hosts h10 and h1A")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003016/1", "of:0000000000006026/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006026/1", "of:0000000000003016/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+
+ main.step("Add point-to-point intents for mininet hosts h17 and h27 or ONOS hosts h11 and h1B")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003017/1", "of:0000000000006027/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006027/1", "of:0000000000003017/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ print("_______________________________________________________________________________________")
+
+ flowHandle = main.ONOScli1.flows()
+ #print "flowHandle = ", flowHandle
+ main.log.info("flows :" + flowHandle)
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i <18 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping == main.FALSE and count <5:
+ count+=1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+10) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h" + str(i) + " and h" + str(i+10) +"have failed")
+ i=19
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h" + str(i) + " and h" + str(i+10) + "passed!")
+ i+=1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+ if Ping_Result==main.FALSE:
+ main.log.report("Ping all test after Point intents addition failed. Cleaning up")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Ping all test after Point intents addition successful")
+
+ case8_result = Ping_Result
+ 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 CASE31(self):
+ '''
+ This test case adds point intent related to SDN-IP matching on ICMP (ethertype=IPV4, ipProto=1)
+ '''
+ import json
+
+ main.log.report("This test case adds point intent related to SDN-IP matching on ICMP")
+ main.case("Adding bidirectional point intent related to SDN-IP matching on ICMP")
+ main.step("Adding bidirectional point intent")
+ #add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=1 of:0000000000003008/1 of:0000000000006018/1
+
+ hosts_json = json.loads(main.ONOScli1.hosts())
+ for i in range(8,11):
+ main.log.info("Adding point intent between h"+str(i)+" and h"+str(i+10))
+ host1 = "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
+ host2 = "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
+ host1_id = main.ONOScli1.get_host(host1)['id']
+ host2_id = main.ONOScli1.get_host(host2)['id']
+ for host in hosts_json:
+ if host['id'] == host1_id:
+ ip1 = host['ips'][0]
+ ip1 = str(ip1+"/32")
+ device1 = host['location']['device']
+ device1 = str(device1+"/1")
+ elif host['id'] == host2_id:
+ ip2 = str(host['ips'][0])+"/32"
+ device2 = host['location']["device"]
+ device2 = str(device2+"/1")
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(ingress_device=device1, egress_device=device2, ipSrc=ip1, ipDst=ip2,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['icmpProto'])
+
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info(get_intent_result)
+
+ p_intent_result2 = main.ONOScli1.add_point_intent(ingress_device=device2, egress_device=device1, ipSrc=ip2, ipDst=ip1,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['icmpProto'])
+
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info(get_intent_result)
+ if (p_intent_result1 and p_intent_result2) == main.TRUE:
+ #get_intent_result = main.ONOScli1.intents()
+ #main.log.info(get_intent_result)
+ main.log.info("Point intent related to SDN-IP matching on ICMP install successful")
+
+ time.sleep(15)
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info("intents = "+ get_intent_result)
+ get_flows_result = main.ONOScli1.flows()
+ main.log.info("flows = " + get_flows_result)
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i <11 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping == main.FALSE and count <3:
+ count+=1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+10) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h" + str(i) + " and h" + str(i+10) +"have failed")
+ i=19
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h" + str(i) + " and h" + str(i+10) + "passed!")
+ i+=1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+ if Ping_Result==main.FALSE:
+ main.log.report("Ping test after Point intents related to SDN-IP matching on ICMP failed.")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Ping all test after Point intents related to SDN-IP matching on ICMP successful")
+
+ case31_result = Ping_Result and p_intent_result1 and p_intent_result2
+ utilities.assert_equals(expect=main.TRUE, actual=case31_result,
+ onpass="Point intent related to SDN-IP matching on ICMP and ping test successful",
+ onfail="Point intent related to SDN-IP matching on ICMP and ping test failed")
+
+ def CASE32(self):
+ '''
+ This test case adds point intent related to SDN-IP matching on TCP (ethertype=IPV4, ipProto=6, DefaultPort for iperf=5001)
+ Note: Although BGP port is 179, we are using 5001 because iperf is used for verifying and iperf's default port is 5001
+ '''
+ import json
+
+ main.log.report("This test case adds point intent related to SDN-IP matching on TCP")
+ main.case("Adding bidirectional point intent related to SDN-IP matching on TCP")
+ main.step("Adding bidirectional point intent")
+ """
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001 of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001 of:0000000000006018/1 of:0000000000003008/1
+
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001 of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001 of:0000000000006018/1 of:0000000000003008/1
+
+ """
+
+ hosts_json = json.loads(main.ONOScli1.hosts())
+ for i in range(8,9):
+ main.log.info("Adding point intent between h"+str(i)+" and h"+str(i+10))
+ host1 = "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
+ host2 = "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
+ host1_id = main.ONOScli1.get_host(host1)['id']
+ host2_id = main.ONOScli1.get_host(host2)['id']
+ for host in hosts_json:
+ if host['id'] == host1_id:
+ ip1 = host['ips'][0]
+ ip1 = str(ip1+"/32")
+ device1 = host['location']['device']
+ device1 = str(device1+"/1")
+ elif host['id'] == host2_id:
+ ip2 = str(host['ips'][0])+"/32"
+ device2 = host['location']["device"]
+ device2 = str(device2+"/1")
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(ingress_device=device1, egress_device=device2, ipSrc=ip1, ipDst=ip2,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpDst=main.params['SDNIP']['dstPort'])
+ p_intent_result2 = main.ONOScli1.add_point_intent(ingress_device=device2, egress_device=device1, ipSrc=ip2, ipDst=ip1,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpDst=main.params['SDNIP']['dstPort'])
+
+ p_intent_result3 = main.ONOScli1.add_point_intent(ingress_device=device1, egress_device=device2, ipSrc=ip1, ipDst=ip2,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpSrc=main.params['SDNIP']['srcPort'])
+ p_intent_result4 = main.ONOScli1.add_point_intent(ingress_device=device2, egress_device=device1, ipSrc=ip2, ipDst=ip1,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpSrc=main.params['SDNIP']['srcPort'])
+
+ p_intent_result = p_intent_result1 and p_intent_result2 and p_intent_result3 and p_intent_result4
+ if p_intent_result ==main.TRUE:
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info(get_intent_result)
+ main.log.info("Point intent related to SDN-IP matching on TCP install successful")
+
+ iperf_result = main.Mininet1.iperf('h8', 'h18')
+ if iperf_result == main.TRUE:
+ main.log.report("iperf test successful")
+ else:
+ main.log.report("iperf test failed")
+
+
+ case32_result = p_intent_result and iperf_result
+ utilities.assert_equals(expect=main.TRUE, actual=case32_result,
+ onpass="Ping all test after Point intents addition related to SDN-IP on TCP match successful",
+ onfail="Ping all test after Point intents addition related to SDN-IP on TCP match failed")
+
+
+ def CASE33(self):
+ '''
+ This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and the action is to rewrite the mac address
+ Here the mac address to be rewritten is the mac address of the egress device
+ '''
+ import json
+ import time
+
+ main.log.report("This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and rewrite mac address action")
+ main.case("Adding multipoint to singlepoint intent related to SDN-IP matching on destination ip")
+ main.step("Adding bidirectional multipoint to singlepoint intent")
+ """
+ add-multi-to-single-intent --ipDst=10.0.3.0/24 --setEthDst=00:00:00:00:00:12 of:0000000000003008/1 0000000000003009/1 of:0000000000006018/1
+
+ add-multi-to-single-intent --ipDst=10.0.1.0/24 --setEthDst=00:00:00:00:00:08 of:0000000000006018/1 0000000000003009/1 of:0000000000003008/1
+ """
+
+ main.case("Installing multipoint to single point intent with rewrite mac address")
+ main.step("Uninstalling proxy arp app")
+ #Unistall onos-app-proxyarp app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall("onos-app-proxyarp")
+ appUninstall_result2 = main.ONOScli2.feature_uninstall("onos-app-proxyarp")
+ appUninstall_result3 = main.ONOScli3.feature_uninstall("onos-app-proxyarp")
+ main.log.info("onos-app-proxyarp uninstalled")
+
+ main.step("Changing ipaddress of hosts h8,h9 and h18")
+ main.Mininet1.changeIP(host='h8', intf='h8-eth0', newIP='10.0.1.1', newNetmask='255.255.255.0')
+ main.Mininet1.changeIP(host='h9', intf='h9-eth0', newIP='10.0.2.1', newNetmask='255.255.255.0')
+ main.Mininet1.changeIP(host='h10', intf='h10-eth0', newIP='10.0.3.1', newNetmask='255.255.255.0')
+
+ main.step("Changing default gateway of hosts h8,h9 and h18")
+ main.Mininet1.changeDefaultGateway(host='h8', newGW='10.0.1.254')
+ main.Mininet1.changeDefaultGateway(host='h9', newGW='10.0.2.254')
+ main.Mininet1.changeDefaultGateway(host='h10', newGW='10.0.3.254')
+
+ main.step("Assigning random mac address to the default gateways since proxyarp app is uninstalled")
+ main.Mininet1.addStaticMACAddress(host='h8', GW='10.0.1.254', macaddr='00:00:00:00:11:11')
+ main.Mininet1.addStaticMACAddress(host='h9', GW='10.0.2.254', macaddr='00:00:00:00:22:22')
+ main.Mininet1.addStaticMACAddress(host='h10', GW='10.0.3.254', macaddr='00:00:00:00:33:33')
+
+ main.step("Verify static gateway and MAC address assignment")
+ main.Mininet1.verifyStaticGWandMAC(host='h8')
+ main.Mininet1.verifyStaticGWandMAC(host='h9')
+ main.Mininet1.verifyStaticGWandMAC(host='h10')
+
+ main.step("Adding multipoint to singlepoint intent")
+ p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(ingress_device1=main.params['MULTIPOINT_INTENT']['device1'], ingress_device2=main.params['MULTIPOINT_INTENT']['device2'],
+ egress_device=main.params['MULTIPOINT_INTENT']['device3'], ipDst=main.params['MULTIPOINT_INTENT']['ip1'], setEthDst=main.params['MULTIPOINT_INTENT']['mac1'])
+
+ p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(ingress_device1=main.params['MULTIPOINT_INTENT']['device3'], ingress_device2=main.params['MULTIPOINT_INTENT']['device2'],
+ egress_device=main.params['MULTIPOINT_INTENT']['device1'], ipDst=main.params['MULTIPOINT_INTENT']['ip2'], setEthDst=main.params['MULTIPOINT_INTENT']['mac2'])
+
+
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info("intents = "+ get_intent_result)
+
+ time.sleep(10)
+ get_flows_result = main.ONOScli1.flows(json_format = False)
+ main.log.info("flows = " + get_flows_result)
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+
+ 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
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+2) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h" + str(i) + " and h" + str(i+10) +"have failed")
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h" + str(i) + " and h" + str(i+2) + "passed!")
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+
+ if Ping_Result==main.FALSE:
+ main.log.report("Ping test failed.")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Ping all successful")
+
+
+ p_intent_result = p_intent_result1 and p_intent_result2
+ if p_intent_result ==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")
+
+ case33_result = p_intent_result and Ping_Result
+ utilities.assert_equals(expect=main.TRUE, actual=case33_result,
+ onpass="Ping all test after multipoint to single point intent addition with rewrite mac address successful",
+ onfail="Ping all test after multipoint to single point intent addition with rewrite mac address failed")
diff --git a/TestON/tests/MultiProd/MultiProd.bak1 b/TestON/tests/MultiProd/MultiProd.bak1
new file mode 100644
index 0000000..6b67f63
--- /dev/null
+++ b/TestON/tests/MultiProd/MultiProd.bak1
@@ -0,0 +1,1523 @@
+
+# Testing the basic functionality of ONOS Next
+# For sanity and driver functionality excercises only.
+
+import time
+import sys
+import os
+import re
+import time
+import json
+
+time.sleep( 1 )
+
+
+class MultiProd:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE1( self, main ):
+ """
+ Startup sequence:
+ cell <name>
+ onos-verify-cell
+ onos-remove-raft-logs
+ git pull
+ mvn clean install
+ onos-package
+ onos-install -f
+ onos-wait-for-start
+ """
+ cell_name = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+ ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+
+ main.case( "Setting up test environment" )
+ main.log.report(
+ "This testcase is testing setting up test environment" )
+ main.log.report( "__________________________________" )
+
+ main.step( "Applying cell variable to environment" )
+ cell_result1 = main.ONOSbench.set_cell( cell_name )
+ #cell_result2 = main.ONOScli1.set_cell( cell_name )
+ #cell_result3 = main.ONOScli2.set_cell( cell_name )
+ #cell_result4 = main.ONOScli3.set_cell( cell_name )
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result = cell_result1
+
+ main.step( "Removing raft logs before a clen installation of ONOS" )
+ remove_log_Result = main.ONOSbench.onos_remove_raft_logs()
+
+ main.step( "Git checkout and pull master and get version" )
+ main.ONOSbench.git_checkout( "master" )
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ version_result = main.ONOSbench.get_version( report=True )
+
+ if git_pull_result == 1:
+ main.step( "Using mvn clean & install" )
+ clean_install_result = main.ONOSbench.clean_install()
+ #clean_install_result = main.TRUE
+
+ main.step( "Creating ONOS package" )
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step( "Creating a cell" )
+ # cell_create_result = main.ONOSbench.create_cell_file( **************
+ # )
+
+ main.step( "Installing ONOS package" )
+ onos1_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS1_ip )
+ onos2_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS2_ip )
+ onos3_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS3_ip )
+ onos_install_result = onos1_install_result and onos2_install_result and onos3_install_result
+ if onos_install_result == main.TRUE:
+ main.log.report( "Installing ONOS package successful" )
+ else:
+ main.log.report( "Installing ONOS package failed" )
+
+ onos1_isup = main.ONOSbench.isup( ONOS1_ip )
+ onos2_isup = main.ONOSbench.isup( ONOS2_ip )
+ onos3_isup = main.ONOSbench.isup( ONOS3_ip )
+ onos_isup = onos1_isup and onos2_isup and onos3_isup
+ if onos_isup == main.TRUE:
+ main.log.report( "ONOS instances are up and ready" )
+ else:
+ main.log.report( "ONOS instances may not be up" )
+
+ main.step( "Starting ONOS service" )
+ start_result = main.TRUE
+ #start_result = main.ONOSbench.onos_start( ONOS1_ip )
+ startcli1 = main.ONOScli1.start_onos_cli( ONOS_ip=ONOS1_ip )
+ startcli2 = main.ONOScli2.start_onos_cli( ONOS_ip=ONOS2_ip )
+ startcli3 = main.ONOScli3.start_onos_cli( ONOS_ip=ONOS3_ip )
+ print startcli1
+ print startcli2
+ print startcli3
+
+ case1_result = ( package_result and
+ cell_result and verify_result and onos_install_result and
+ onos_isup and start_result )
+ utilities.assert_equals( expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful" )
+
+ def CASE11( self, main ):
+ """
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ """
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Cleaning up test environment" )
+
+ main.step( "Testing ONOS kill function" )
+ kill_result1 = main.ONOSbench.onos_kill( ONOS1_ip )
+ kill_result2 = main.ONOSbench.onos_kill( ONOS2_ip )
+ kill_result3 = main.ONOSbench.onos_kill( ONOS3_ip )
+
+ main.step( "Stopping ONOS service" )
+ stop_result1 = main.ONOSbench.onos_stop( ONOS1_ip )
+ stop_result2 = main.ONOSbench.onos_stop( ONOS2_ip )
+ stop_result3 = main.ONOSbench.onos_stop( ONOS3_ip )
+
+ main.step( "Uninstalling ONOS service" )
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ def CASE3( self, main ):
+ """
+ Test 'onos' command and its functionality in driver
+ """
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Testing 'onos' command" )
+
+ main.step( "Sending command 'onos -w <onos-ip> system:name'" )
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result1 )
+ cmd_result2 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result2 )
+ cmd_result3 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result3 )
+
+ main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
+ cmdstr2 = "onos:topology"
+ cmd_result4 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result4 )
+ cmd_result5 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result5 )
+ cmd_result6 = main.ONOSbench.onos_cli( ONOS6_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result6 )
+
+ def CASE4( self, main ):
+ import re
+ import time
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+ ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+
+ main.log.report(
+ "This testcase is testing the assignment of all the switches to all controllers and discovering the hosts in reactive mode" )
+ main.log.report( "__________________________________" )
+ main.case( "Pingall Test(No intents are added)" )
+ main.step( "Assigning switches to controllers" )
+ for i in range( 1, 29 ): # 1 to ( num of switches +1 )
+ main.Mininet1.assign_sw_controller(
+ sw=str( i ),
+ count=3,
+ ip1=ONOS1_ip,
+ port1=ONOS1_port,
+ ip2=ONOS2_ip,
+ port2=ONOS2_port,
+ ip3=ONOS3_ip,
+ port3=ONOS3_port )
+
+ switch_mastership = main.TRUE
+ for i in range( 1, 29 ):
+ response = main.Mininet1.get_sw_controller( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1_ip, response ):
+ switch_mastership = switch_mastership and main.TRUE
+ else:
+ switch_mastership = main.FALSE
+
+ if switch_mastership == main.TRUE:
+ main.log.report( "Controller assignment successfull" )
+ else:
+ main.log.report( "Controller assignment failed" )
+ # REACTIVE FWD test
+ main.step( "Pingall" )
+ ping_result = main.FALSE
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % ( time2 - time1 )
+
+ case4_result = switch_mastership and ping_result
+ if ping_result == main.TRUE:
+ main.log.report(
+ "Pingall Test in reactive mode to discover the hosts successful" )
+ else:
+ main.log.report(
+ "Pingall Test in reactive mode to discover the hosts failed" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case4_result,
+ onpass="Controller assignment and Pingall Test successful",
+ onfail="Controller assignment and Pingall Test NOT successful" )
+
+ def CASE5( self, main ):
+ import json
+ from subprocess import Popen, PIPE
+ # assumes that sts is already in you PYTHONPATH
+ from sts.topology.teston_topology import TestONTopology
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.log.report(
+ "This testcase is testing if all ONOS nodes are in topology sync with mininet and its peer ONOS nodes" )
+ main.log.report( "__________________________________" )
+ main.case(
+ "Testing Mininet topology with the topology of multi instances ONOS" )
+ main.step( "Collecting topology information from ONOS" )
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ # print "devices1 = ", devices1
+ # print "devices2 = ", devices2
+ # print "devices3 = ", devices3
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ # print "hosts1 = ", hosts1
+ # print "hosts2 = ", hosts2
+ # print "hosts3 = ", hosts3
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ # print "ports1 = ", ports1
+ # print "ports2 = ", ports2
+ # print "ports3 = ", ports3
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+ # print "links1 = ", links1
+ # print "links2 = ", links2
+ # print "links3 = ", links3
+
+ print "**************"
+
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+
+ switches_results1 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices1 ) )
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
+
+ switches_results2 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
+
+ switches_results3 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect" )
+
+ """
+ ports_results1 = main.Mininet1.compare_ports( MNTopo, json.loads( ports1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect" )
+
+ ports_results2 = main.Mininet1.compare_ports( MNTopo, json.loads( ports2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect" )
+
+ ports_results3 = main.Mininet1.compare_ports( MNTopo, json.loads( ports3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect" )
+ """
+ links_results1 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
+
+ links_results2 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ links_results3 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ #topo_result = switches_results1 and switches_results2 and switches_results3\
+ # and ports_results1 and ports_results2 and ports_results3\
+ # and links_results1 and links_results2 and links_results3
+
+ topo_result = switches_results1 and switches_results2 and switches_results3\
+ and links_results1 and links_results2 and links_results3
+
+ if topo_result == main.TRUE:
+ main.log.report(
+ "Topology Check Test with mininet and ONOS instances successful" )
+ else:
+ main.log.report(
+ "Topology Check Test with mininet and ONOS instances failed" )
+
+ utilities.assert_equals( expect=main.TRUE, actual=topo_result,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
+
+ def CASE10( self ):
+ main.log.report(
+ "This testcase uninstalls the reactive forwarding app" )
+ main.log.report( "__________________________________" )
+ main.case( "Uninstalling reactive forwarding app" )
+ # Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall(
+ "onos-app-fwd" )
+ appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ "onos-app-fwd" )
+ appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ "onos-app-fwd" )
+ main.log.info( "onos-app-fwd uninstalled" )
+
+ # After reactive forwarding is disabled, the reactive flows on switches timeout in 10-15s
+ # So sleep for 15s
+ time.sleep( 15 )
+
+ hosts = main.ONOScli1.hosts()
+ main.log.info( hosts )
+
+ case10_result = appUninstall_result1 and appUninstall_result2 and appUninstall_result3
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case10_result,
+ onpass="Reactive forwarding app uninstallation successful",
+ onfail="Reactive forwarding app uninstallation failed" )
+
+ def CASE6( self ):
+ main.log.report(
+ "This testcase is testing the addition of host intents and then doing pingall" )
+ main.log.report( "__________________________________" )
+ main.case( "Obtaining hostsfor adding host intents" )
+ main.step( "Get hosts" )
+ hosts = main.ONOScli1.hosts()
+ main.log.info( hosts )
+
+ main.step( "Get all devices id" )
+ devices_id_list = main.ONOScli1.get_all_devices_id()
+ main.log.info( devices_id_list )
+
+ # ONOS displays the hosts in hex format unlike mininet which does in decimal format
+ # So take care while adding intents
+
+ """
+ main.step( "Add host intents for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+ """
+ for i in range( 8, 18 ):
+ main.log.info(
+ "Adding host intent between h" + str( i ) + " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ # NOTE: get host can return None
+ # TODO: handle this
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ tmp_result = main.ONOScli1.add_host_intent( host1_id, host2_id )
+
+ flowHandle = main.ONOScli1.flows()
+ # print "flowHandle = ", flowHandle
+ main.log.info( "flows:" + flowHandle )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Host intents have not ben installed correctly. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report( "Host intents have been installed correctly" )
+
+ case6_result = Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case6_result,
+ onpass="Host intent addition and Pingall Test successful",
+ onfail="Host intent addition and Pingall Test NOT successful" )
+
+ def CASE7( self, main ):
+
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+
+ main.log.report(
+ "This testscase is killing a link to ensure that link discovery is consistent" )
+ main.log.report( "__________________________________" )
+ main.case(
+ "Killing a link to Ensure that Link Discovery is Working Properly" )
+ main.step( "Start continuous pings" )
+
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Determine the current number of switches and links" )
+ topology_output = main.ONOScli1.topology()
+ topology_result = main.ONOSbench.get_topology( topology_output )
+ activeSwitches = topology_result[ 'devices' ]
+ links = topology_result[ 'links' ]
+ print "activeSwitches = ", type( activeSwitches )
+ print "links = ", type( links )
+ main.log.info(
+ "Currently there are %s switches and %s links" %
+ ( str( activeSwitches ), str( links ) ) )
+
+ main.step( "Kill Link between s3 and s28" )
+ main.Mininet1.link( END1="s3", END2="s28", OPTION="down" )
+ time.sleep( link_sleep )
+ topology_output = main.ONOScli2.topology()
+ Link_Down = main.ONOSbench.check_status(
+ topology_output, activeSwitches, str(
+ int( links ) - 2 ) )
+ if Link_Down == main.TRUE:
+ main.log.report( "Link Down discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=Link_Down,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in " +
+ str( link_sleep ) +
+ " seconds" )
+
+ main.step( "Bring link between s3 and s28 back up" )
+ Link_Up = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
+ time.sleep( link_sleep )
+ topology_output = main.ONOScli2.topology()
+ Link_Up = main.ONOSbench.check_status(
+ topology_output,
+ activeSwitches,
+ str( links ) )
+ if Link_Up == main.TRUE:
+ main.log.report( "Link up discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=Link_Up,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in " +
+ str( link_sleep ) +
+ " seconds" )
+
+ main.step( "Compare ONOS Topology to MN Topology" )
+ main.case(
+ "Testing Mininet topology with the topology of multi instances ONOS" )
+ main.step( "Collecting topology information from ONOS" )
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ print "devices1 = ", devices1
+ print "devices2 = ", devices2
+ print "devices3 = ", devices3
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ # print "hosts1 = ", hosts1
+ # print "hosts2 = ", hosts2
+ # print "hosts3 = ", hosts3
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ # print "ports1 = ", ports1
+ # print "ports2 = ", ports2
+ # print "ports3 = ", ports3
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+ # print "links1 = ", links1
+ # print "links2 = ", links2
+ # print "links3 = ", links3
+
+ print "**************"
+
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+
+ switches_results1 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices1 ) )
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
+
+ switches_results2 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
+
+ switches_results3 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect" )
+
+ """
+ ports_results1 = main.Mininet1.compare_ports( MNTopo, json.loads( ports1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect" )
+
+ ports_results2 = main.Mininet1.compare_ports( MNTopo, json.loads( ports2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect" )
+
+ ports_results3 = main.Mininet1.compare_ports( MNTopo, json.loads( ports3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect" )
+ """
+ links_results1 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
+
+ links_results2 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ links_results3 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ #topo_result = switches_results1 and switches_results2 and switches_results3\
+ # and ports_results1 and ports_results2 and ports_results3\
+ # and links_results1 and links_results2 and links_results3
+
+ topo_result = switches_results1 and switches_results2 and switches_results3\
+ and links_results1 and links_results2 and links_results3
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=topo_result and Link_Up and Link_Down,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
+
+ def CASE8( self ):
+ """
+ Intent removal
+ """
+ main.log.report(
+ "This testcase removes host any previously added intents" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Removing any previously installed intents" )
+ main.case( "Removing intents" )
+ main.step( "Obtain the intent id's" )
+ intent_result = main.ONOScli1.intents( json_format=False )
+
+ intent_linewise = intent_result.split( "\n" )
+ intentList = []
+ for line in intent_linewise:
+ if line.startswith( "id=" ):
+ intentList.append( line )
+
+ intentids = []
+ for line in intentList:
+ intentids.append( line.split( "," )[ 0 ].split( "=" )[ 1 ] )
+ for id in intentids:
+ main.log.info( "id = " + id )
+
+ main.step(
+ "Iterate through the intentids list and remove each intent" )
+ for id in intentids:
+ main.ONOScli1.remove_intent( intent_id=id )
+
+ intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intent_result = " + intent_result )
+ case8_result = main.TRUE
+
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.TRUE:
+ i = 19
+ Ping_Result = main.TRUE
+ elif ping == main.FALSE:
+ i += 1
+ Ping_Result = main.FALSE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ # Note: If the ping result failed, that means the intents have been
+ # withdrawn correctly.
+ if Ping_Result == main.TRUE:
+ main.log.report( "Host intents have not been withdrawn correctly" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.FALSE:
+ main.log.report( "Host intents have been withdrawn correctly" )
+
+ case8_result = case8_result and Ping_Result
+
+ if case8_result == main.FALSE:
+ main.log.report( "Intent removal successful" )
+ else:
+ main.log.report( "Intent removal failed" )
+
+ utilities.assert_equals( expect=main.FALSE, actual=case8_result,
+ onpass="Intent removal test failed",
+ onfail="Intent removal test successful" )
+
+ def CASE9( self ):
+ """
+ This test case adds point intents. Make sure you run test case 8 which is host intent removal before executing this test case.
+ Else the host intent's flows will persist on switches and the pings would work even if there is some issue with the point intent's flows
+ """
+ main.log.report(
+ "This testcase adds point intents and then does pingall" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Adding point intents" )
+ main.case(
+ "Adding bidirectional point for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)" )
+ main.step(
+ "Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003008/1",
+ "of:0000000000006018/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006018/1",
+ "of:0000000000003008/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h9 and h19 or ONOS hosts h9 and h13" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003009/1",
+ "of:0000000000006019/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006019/1",
+ "of:0000000000003009/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h10 and h20 or ONOS hosts hA and h14" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003010/1",
+ "of:0000000000006020/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006020/1",
+ "of:0000000000003010/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h11 and h21 or ONOS hosts hB and h15" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003011/1",
+ "of:0000000000006021/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006021/1",
+ "of:0000000000003011/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h12 and h22 or ONOS hosts hC and h16" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003012/1",
+ "of:0000000000006022/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006022/1",
+ "of:0000000000003012/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h13 and h23 or ONOS hosts hD and h17" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003013/1",
+ "of:0000000000006023/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006023/1",
+ "of:0000000000003013/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h14 and h24 or ONOS hosts hE and h18" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003014/1",
+ "of:0000000000006024/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006024/1",
+ "of:0000000000003014/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h15 and h25 or ONOS hosts hF and h19" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003015/1",
+ "of:0000000000006025/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006025/1",
+ "of:0000000000003015/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h16 and h26 or ONOS hosts h10 and h1A" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003016/1",
+ "of:0000000000006026/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006026/1",
+ "of:0000000000003016/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h17 and h27 or ONOS hosts h11 and h1B" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003017/1",
+ "of:0000000000006027/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006027/1",
+ "of:0000000000003017/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ print(
+ "_______________________________________________________________________________________" )
+
+ flowHandle = main.ONOScli1.flows()
+ # print "flowHandle = ", flowHandle
+ main.log.info( "flows :" + flowHandle )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Ping all test after Point intents addition failed. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report(
+ "Ping all test after Point intents addition successful" )
+
+ case8_result = Ping_Result
+ 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 CASE31( self ):
+ """
+ This test case adds point intent related to SDN-IP matching on ICMP ( ethertype=IPV4, ipProto=1 )
+ """
+ import json
+
+ main.log.report(
+ "This test case adds point intent related to SDN-IP matching on ICMP" )
+ main.case(
+ "Adding bidirectional point intent related to SDN-IP matching on ICMP" )
+ main.step( "Adding bidirectional point intent" )
+ # add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+ # --ethType=IPV4 --ipProto=1 of:0000000000003008/1
+ # of:0000000000006018/1
+
+ hosts_json = json.loads( main.ONOScli1.hosts() )
+ for i in range( 8, 11 ):
+ main.log.info(
+ "Adding point intent between h" + str( i ) + " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ for host in hosts_json:
+ if host[ 'id' ] == host1_id:
+ ip1 = host[ 'ips' ][ 0 ]
+ ip1 = str( ip1 + "/32" )
+ device1 = host[ 'location' ][ 'device' ]
+ device1 = str( device1 + "/1" )
+ elif host[ 'id' ] == host2_id:
+ ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+ device2 = host[ 'location' ][ "device" ]
+ device2 = str( device2 + "/1" )
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+
+ p_intent_result2 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+ if ( p_intent_result1 and p_intent_result2 ) == main.TRUE:
+ #get_intent_result = main.ONOScli1.intents()
+ # main.log.info( get_intent_result )
+ main.log.info(
+ "Point intent related to SDN-IP matching on ICMP install successful" )
+
+ time.sleep( 15 )
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intents = " + get_intent_result )
+ get_flows_result = main.ONOScli1.flows()
+ main.log.info( "flows = " + get_flows_result )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 11:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 3:
+ count += 1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Ping test after Point intents related to SDN-IP matching on ICMP failed." )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report(
+ "Ping all test after Point intents related to SDN-IP matching on ICMP successful" )
+
+ case31_result = Ping_Result and p_intent_result1 and p_intent_result2
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case31_result,
+ onpass="Point intent related to SDN-IP matching on ICMP and ping test successful",
+ onfail="Point intent related to SDN-IP matching on ICMP and ping test failed" )
+
+ def CASE32( self ):
+ """
+ This test case adds point intent related to SDN-IP matching on TCP ( ethertype=IPV4, ipProto=6, DefaultPort for iperf=5001 )
+ Note: Although BGP port is 179, we are using 5001 because iperf is used for verifying and iperf's default port is 5001
+ """
+ import json
+
+ main.log.report(
+ "This test case adds point intent related to SDN-IP matching on TCP" )
+ main.case(
+ "Adding bidirectional point intent related to SDN-IP matching on TCP" )
+ main.step( "Adding bidirectional point intent" )
+ """
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001 of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001 of:0000000000006018/1 of:0000000000003008/1
+
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001 of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001 of:0000000000006018/1 of:0000000000003008/1
+
+ """
+ hosts_json = json.loads( main.ONOScli1.hosts() )
+ for i in range( 8, 9 ):
+ main.log.info(
+ "Adding point intent between h" + str( i ) + " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ for host in hosts_json:
+ if host[ 'id' ] == host1_id:
+ ip1 = host[ 'ips' ][ 0 ]
+ ip1 = str( ip1 + "/32" )
+ device1 = host[ 'location' ][ 'device' ]
+ device1 = str( device1 + "/1" )
+ elif host[ 'id' ] == host2_id:
+ ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+ device2 = host[ 'location' ][ "device" ]
+ device2 = str( device2 + "/1" )
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+ p_intent_result2 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+
+ p_intent_result3 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+ p_intent_result4 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+
+ p_intent_result = p_intent_result1 and p_intent_result2 and p_intent_result3 and p_intent_result4
+ if p_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+ main.log.info(
+ "Point intent related to SDN-IP matching on TCP install successful" )
+
+ iperf_result = main.Mininet1.iperf( 'h8', 'h18' )
+ if iperf_result == main.TRUE:
+ main.log.report( "iperf test successful" )
+ else:
+ main.log.report( "iperf test failed" )
+
+ case32_result = p_intent_result and iperf_result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case32_result,
+ onpass="Ping all test after Point intents addition related to SDN-IP on TCP match successful",
+ onfail="Ping all test after Point intents addition related to SDN-IP on TCP match failed" )
+
+ def CASE33( self ):
+ """
+ This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and the action is to rewrite the mac address
+ Here the mac address to be rewritten is the mac address of the egress device
+ """
+ import json
+ import time
+
+ main.log.report(
+ "This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and rewrite mac address action" )
+ main.case(
+ "Adding multipoint to singlepoint intent related to SDN-IP matching on destination ip" )
+ main.step( "Adding bidirectional multipoint to singlepoint intent" )
+ """
+ add-multi-to-single-intent --ipDst=10.0.3.0/24 --setEthDst=00:00:00:00:00:12 of:0000000000003008/1 0000000000003009/1 of:0000000000006018/1
+
+ add-multi-to-single-intent --ipDst=10.0.1.0/24 --setEthDst=00:00:00:00:00:08 of:0000000000006018/1 0000000000003009/1 of:0000000000003008/1
+ """
+ main.case(
+ "Installing multipoint to single point intent with rewrite mac address" )
+ main.step( "Uninstalling proxy arp app" )
+ # Unistall onos-app-proxyarp app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall(
+ "onos-app-proxyarp" )
+ appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ "onos-app-proxyarp" )
+ appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ "onos-app-proxyarp" )
+ main.log.info( "onos-app-proxyarp uninstalled" )
+
+ main.step( "Changing ipaddress of hosts h8,h9 and h18" )
+ main.Mininet1.changeIP(
+ host='h8',
+ intf='h8-eth0',
+ newIP='10.0.1.1',
+ newNetmask='255.255.255.0' )
+ main.Mininet1.changeIP(
+ host='h9',
+ intf='h9-eth0',
+ newIP='10.0.2.1',
+ newNetmask='255.255.255.0' )
+ main.Mininet1.changeIP(
+ host='h10',
+ intf='h10-eth0',
+ newIP='10.0.3.1',
+ newNetmask='255.255.255.0' )
+
+ main.step( "Changing default gateway of hosts h8,h9 and h18" )
+ main.Mininet1.changeDefaultGateway( host='h8', newGW='10.0.1.254' )
+ main.Mininet1.changeDefaultGateway( host='h9', newGW='10.0.2.254' )
+ main.Mininet1.changeDefaultGateway( host='h10', newGW='10.0.3.254' )
+
+ main.step(
+ "Assigning random mac address to the default gateways since proxyarp app is uninstalled" )
+ main.Mininet1.addStaticMACAddress(
+ host='h8',
+ GW='10.0.1.254',
+ macaddr='00:00:00:00:11:11' )
+ main.Mininet1.addStaticMACAddress(
+ host='h9',
+ GW='10.0.2.254',
+ macaddr='00:00:00:00:22:22' )
+ main.Mininet1.addStaticMACAddress(
+ host='h10',
+ GW='10.0.3.254',
+ macaddr='00:00:00:00:33:33' )
+
+ main.step( "Verify static gateway and MAC address assignment" )
+ main.Mininet1.verifyStaticGWandMAC( host='h8' )
+ main.Mininet1.verifyStaticGWandMAC( host='h9' )
+ main.Mininet1.verifyStaticGWandMAC( host='h10' )
+
+ main.step( "Adding multipoint to singlepoint intent" )
+ p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+ ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+ ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+ ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip1' ],
+ setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac1' ] )
+
+ p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+ ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+ ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+ ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip2' ],
+ setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac2' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intents = " + get_intent_result )
+
+ time.sleep( 10 )
+ get_flows_result = main.ONOScli1.flows( json_format=False )
+ main.log.info( "flows = " + get_flows_result )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+
+ 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
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 2 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 2 ) +
+ "passed!" )
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ if Ping_Result == main.FALSE:
+ main.log.report( "Ping test failed." )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report( "Ping all successful" )
+
+ p_intent_result = p_intent_result1 and p_intent_result2
+ if p_intent_result == 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" )
+
+ case33_result = p_intent_result and Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case33_result,
+ onpass="Ping all test after multipoint to single point intent addition with rewrite mac address successful",
+ onfail="Ping all test after multipoint to single point intent addition with rewrite mac address failed" )
diff --git a/TestON/tests/MultiProd/MultiProd.params b/TestON/tests/MultiProd/MultiProd.params
index 8bf1600..6e5c85e 100755
--- a/TestON/tests/MultiProd/MultiProd.params
+++ b/TestON/tests/MultiProd/MultiProd.params
@@ -1,6 +1,6 @@
<PARAMS>
- <testcases>1,4,10,5,6,7,8,6,8,9,31,32,8,33</testcases>
+ <testcases>1,4,10,5,6,7,8,6,8,9,8,31,32,8,33,8</testcases>
#Environment variables
<ENV>
diff --git a/TestON/tests/MultiProd/MultiProd.py b/TestON/tests/MultiProd/MultiProd.py
index ea61a25..d3ed757 100644
--- a/TestON/tests/MultiProd/MultiProd.py
+++ b/TestON/tests/MultiProd/MultiProd.py
@@ -11,7 +11,6 @@
time.sleep( 1 )
-
class MultiProd:
def __init__( self ):
@@ -53,8 +52,8 @@
main.step( "Removing raft logs before a clen installation of ONOS" )
removeLogResult = main.ONOSbench.onosRemoveRaftLogs()
- main.step( "Git checkout and pull master and get version" )
- main.ONOSbench.gitCheckout( "master" )
+ main.step( "Git checkout, pull and get version" )
+ #main.ONOSbench.gitCheckout( "master" )
gitPullResult = main.ONOSbench.gitPull()
print "git_pull_result = ", gitPullResult
versionResult = main.ONOSbench.getVersion( report=True )
@@ -514,7 +513,6 @@
tmpResult = main.ONOScli1.addHostIntent( host1Id, host2Id )
flowHandle = main.ONOScli1.flows()
- # print "flowHandle = ", flowHandle
main.log.info( "flows:" + flowHandle )
count = 1
@@ -857,7 +855,7 @@
Intent removal
"""
main.log.report(
- "This testcase removes host any previously added intents" )
+ "This testcase removes any previously added intents" )
main.log.report( "__________________________________" )
main.log.info( "Removing any previously installed intents" )
main.case( "Removing intents" )
@@ -1424,9 +1422,13 @@
if pIntentResult == main.TRUE:
getIntentResult = main.ONOScli1.intents( jsonFormat=False )
main.log.info( getIntentResult )
- main.log.info(
+ main.log.report(
"Point intent related to SDN-IP matching" +
" on TCP install successful" )
+ else:
+ main.log.report(
+ "Point intent related to SDN-IP matching" +
+ " on TCP install failed" )
iperfResult = main.Mininet1.iperf( 'h8', 'h18' )
if iperfResult == main.TRUE:
diff --git a/TestON/tests/MultiProd/MultiProd.py.fixed b/TestON/tests/MultiProd/MultiProd.py.fixed
new file mode 100644
index 0000000..e0e772a
--- /dev/null
+++ b/TestON/tests/MultiProd/MultiProd.py.fixed
@@ -0,0 +1,1566 @@
+
+# Testing the basic functionality of ONOS Next
+# For sanity and driver functionality excercises only.
+
+import time
+import json
+
+time.sleep( 1 )
+
+
+class MultiProd:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE1( self, main ):
+ """
+ Startup sequence:
+ cell <name>
+ onos-verify-cell
+ onos-remove-raft-logs
+ git pull
+ mvn clean install
+ onos-package
+ onos-install -f
+ onos-wait-for-start
+ """
+ cell_name = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Setting up test environment" )
+ main.log.report(
+ "This testcase is testing setting up test environment" )
+ main.log.report( "__________________________________" )
+
+ main.step( "Applying cell variable to environment" )
+ cell_result1 = main.ONOSbench.set_cell( cell_name )
+ # cell_result2 = main.ONOScli1.set_cell( cell_name )
+ # cell_result3 = main.ONOScli2.set_cell( cell_name )
+ # cell_result4 = main.ONOScli3.set_cell( cell_name )
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result = cell_result1
+
+ main.step( "Removing raft logs before a clen installation of ONOS" )
+ main.ONOSbench.onos_remove_raft_logs()
+
+ main.step( "Git checkout and pull master and get version" )
+ main.ONOSbench.git_checkout( "master" )
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ main.ONOSbench.get_version( report=True )
+
+ if git_pull_result == 1:
+ main.step( "Using mvn clean & install" )
+ main.ONOSbench.clean_install()
+
+ main.step( "Creating ONOS package" )
+ package_result = main.ONOSbench.onos_package()
+
+ # main.step( "Creating a cell" )
+ # cell_create_result = main.ONOSbench.create_cell_file( **************
+ # )
+
+ main.step( "Installing ONOS package" )
+ onos1_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS1_ip )
+ onos2_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS2_ip )
+ onos3_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS3_ip )
+ onos_install_result = onos1_install_result and onos2_install_result \
+ and onos3_install_result
+ if onos_install_result == main.TRUE:
+ main.log.report( "Installing ONOS package successful" )
+ else:
+ main.log.report( "Installing ONOS package failed" )
+
+ onos1_isup = main.ONOSbench.isup( ONOS1_ip )
+ onos2_isup = main.ONOSbench.isup( ONOS2_ip )
+ onos3_isup = main.ONOSbench.isup( ONOS3_ip )
+ onos_isup = onos1_isup and onos2_isup and onos3_isup
+ if onos_isup == main.TRUE:
+ main.log.report( "ONOS instances are up and ready" )
+ else:
+ main.log.report( "ONOS instances may not be up" )
+
+ main.step( "Starting ONOS service" )
+ start_result = main.TRUE
+ # start_result = main.ONOSbench.onos_start( ONOS1_ip )
+ startcli1 = main.ONOScli1.start_onos_cli( ONOS_ip=ONOS1_ip )
+ startcli2 = main.ONOScli2.start_onos_cli( ONOS_ip=ONOS2_ip )
+ startcli3 = main.ONOScli3.start_onos_cli( ONOS_ip=ONOS3_ip )
+ print startcli1
+ print startcli2
+ print startcli3
+
+ case1_result = ( package_result and cell_result and
+ verify_result and onos_install_result
+ and onos_isup and start_result )
+ utilities.assert_equals( expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful" )
+
+ def CASE11( self, main ):
+ """
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ """
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Cleaning up test environment" )
+
+ main.step( "Testing ONOS kill function" )
+ kill_result1 = main.ONOSbench.onos_kill( ONOS1_ip )
+ kill_result2 = main.ONOSbench.onos_kill( ONOS2_ip )
+ kill_result3 = main.ONOSbench.onos_kill( ONOS3_ip )
+ kill_result = kill_result1 and kill_result2 and kill_result3
+
+ main.step( "Stopping ONOS service" )
+ stop_result1 = main.ONOSbench.onos_stop( ONOS1_ip )
+ stop_result2 = main.ONOSbench.onos_stop( ONOS2_ip )
+ stop_result3 = main.ONOSbench.onos_stop( ONOS3_ip )
+ stop_result = stop_result1 and stop_result2 and stop_result3
+
+ main.step( "Uninstalling ONOS service" )
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ case11_result = kill_result and stop_result and uninstall_result
+ utilities.assert_equals( expect=main.TRUE, actual=case11_result,
+ onpass="Cleanup successful",
+ onfail="Cleanup failed" )
+
+ def CASE3( self, main ):
+ """
+ Test 'onos' command and its functionality in driver
+ """
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Testing 'onos' command" )
+
+ main.step( "Sending command 'onos -w <onos-ip> system:name'" )
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result1 )
+ cmd_result2 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result2 )
+ cmd_result3 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result3 )
+
+ main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
+ cmdstr2 = "onos:topology"
+ cmd_result4 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result4 )
+ cmd_result5 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result5 )
+ cmd_result6 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result6 )
+
+ def CASE4( self, main ):
+ import re
+ import time
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+ ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+
+ main.log.report(
+ "This testcase is testing the assignment of all the switches to \
+ all controllers and discovering the hosts in reactive mode" )
+ main.log.report( "__________________________________" )
+ main.case( "Pingall Test(No intents are added)" )
+ main.step( "Assigning switches to controllers" )
+ for i in range( 1, 29 ): # 1 to ( num of switches +1 )
+ main.Mininet1.assign_sw_controller(
+ sw=str( i ),
+ count=3,
+ ip1=ONOS1_ip,
+ port1=ONOS1_port,
+ ip2=ONOS2_ip,
+ port2=ONOS2_port,
+ ip3=ONOS3_ip,
+ port3=ONOS3_port )
+
+ switch_mastership = main.TRUE
+ for i in range( 1, 29 ):
+ response = main.Mininet1.get_sw_controller( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1_ip, response ):
+ switch_mastership = switch_mastership and main.TRUE
+ else:
+ switch_mastership = main.FALSE
+
+ if switch_mastership == main.TRUE:
+ main.log.report( "Controller assignment successfull" )
+ else:
+ main.log.report( "Controller assignment failed" )
+ # REACTIVE FWD test
+ main.step( "Pingall" )
+ ping_result = main.FALSE
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % ( time2 - time1 )
+
+ case4_result = switch_mastership and ping_result
+ if ping_result == main.TRUE:
+ main.log.report( "Pingall Test in reactive mode to discover \
+ the hosts successful" )
+ else:
+ main.log.report( "Pingall Test in reactive mode to discover \
+ the hosts failed" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case4_result,
+ onpass="Controller assignment and Pingall Test successful",
+ onfail="Controller assignment and Pingall Test NOT successful" )
+
+ def CASE5( self, main ):
+ import json
+ from subprocess import Popen, PIPE
+ # assumes that sts is already in you PYTHONPATH
+ from sts.topology.teston_topology import TestONTopology
+
+ main.log.report( "This testcase is testing if all ONOS nodes are in \
+ topology sync with mininet and its peer ONOS nodes" )
+ main.log.report( "__________________________________" )
+ main.case(
+ "Testing Mininet topology with the topology \
+ of multi instances ONOS" )
+ main.step( "Collecting topology information from ONOS" )
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+
+ switches_results1 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices1 ) )
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
+
+ switches_results2 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
+
+ switches_results3 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect" )
+
+ ports_results1 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect" )
+
+ ports_results2 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect" )
+
+ ports_results3 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect" )
+
+ links_results1 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
+
+ links_results2 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ links_results3 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ topo_result = switches_results1 and switches_results2 and \
+ switches_results3\
+ and ports_results1 and ports_results2 and ports_results3\
+ and links_results1 and links_results2 and links_results3
+
+ '''
+ topo_result = switches_results1 and switches_results2 and \
+ switches_results3 and links_results1 and \
+ links_results2 and links_results3
+ '''
+
+ if topo_result == main.TRUE:
+ main.log.report(
+ "Topology Check Test with mininet and \
+ ONOS instances successful" )
+ else:
+ main.log.report(
+ "Topology Check Test with mininet and \
+ ONOS instances failed" )
+
+ utilities.assert_equals( expect=main.TRUE, actual=topo_result,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
+
+ def CASE10( self ):
+ main.log.report(
+ "This testcase uninstalls the reactive forwarding app" )
+ main.log.report( "__________________________________" )
+ main.case( "Uninstalling reactive forwarding app" )
+ # Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall(
+ "onos-app-fwd" )
+ appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ "onos-app-fwd" )
+ appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ "onos-app-fwd" )
+ main.log.info( "onos-app-fwd uninstalled" )
+
+ # After reactive forwarding is disabled,
+ # the reactive flows on switches timeout in 10-15s
+ # So sleep for 15s
+ time.sleep( 15 )
+
+ hosts = main.ONOScli1.hosts()
+ main.log.info( hosts )
+
+ case10_result = appUninstall_result1 and appUninstall_result2 and \
+ appUninstall_result3
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case10_result,
+ onpass="Reactive forwarding app uninstallation successful",
+ onfail="Reactive forwarding app uninstallation failed" )
+
+ def CASE6( self ):
+ main.log.report(
+ "This testcase is testing the addition of host intents and \
+ then doing pingall" )
+ main.log.report( "__________________________________" )
+ main.case( "Obtaining hostsfor adding host intents" )
+ main.step( "Get hosts" )
+ hosts = main.ONOScli1.hosts()
+ main.log.info( hosts )
+
+ main.step( "Get all devices id" )
+ devices_id_list = main.ONOScli1.get_all_devices_id()
+ main.log.info( devices_id_list )
+
+ # ONOS displays the hosts in hex format unlike mininet
+ # which does in decimal format
+ # So take care while adding intents
+
+ """
+ main.step(
+ "Add host intents for mn hosts
+ (h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,
+ h15-h25,h16-h26,h17-h27)" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+ """
+ for i in range( 8, 18 ):
+ main.log.info(
+ "Adding host intent between h" + str( i ) +
+ " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ # NOTE: get host can return None
+ # TODO: handle this
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ tmp_result = main.ONOScli1.add_host_intent( host1_id, host2_id )
+
+ flowHandle = main.ONOScli1.flows()
+ main.log.info( "flows:" + flowHandle )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ # i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Host intents have not ben installed correctly. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report( "Host intents have been installed correctly" )
+
+ case6_result = Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case6_result,
+ onpass="Host intent addition and Pingall Test successful",
+ onfail="Host intent addition and Pingall Test NOT successful" )
+
+ def CASE7( self, main ):
+
+ from sts.topology.teston_topology import TestONTopology
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+
+ main.log.report(
+ "This testscase is killing a link to ensure that \
+ link discovery is consistent" )
+ main.log.report( "__________________________________" )
+ main.case(
+ "Killing a link to ensure that \
+ Link Discovery is Working Properly" )
+ main.step( "Start continuous pings" )
+
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Determine the current number of switches and links" )
+ topology_output = main.ONOScli1.topology()
+ topology_result = main.ONOSbench.get_topology( topology_output )
+ activeSwitches = topology_result[ 'devices' ]
+ links = topology_result[ 'links' ]
+ main.log.info(
+ "Currently there are %s switches and %s links" %
+ ( str( activeSwitches ), str( links ) ) )
+
+ main.step( "Kill Link between s3 and s28" )
+ main.Mininet1.link( END1="s3", END2="s28", OPTION="down" )
+ time.sleep( link_sleep )
+ topology_output = main.ONOScli2.topology()
+ Link_Down = main.ONOSbench.check_status(
+ topology_output, activeSwitches, str(
+ int( links ) - 2 ) )
+ if Link_Down == main.TRUE:
+ main.log.report( "Link Down discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=Link_Down,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in " +
+ str( link_sleep ) +
+ " seconds" )
+
+ main.step( "Bring link between s3 and s28 back up" )
+ Link_Up = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
+ time.sleep( link_sleep )
+ topology_output = main.ONOScli2.topology()
+ Link_Up = main.ONOSbench.check_status(
+ topology_output,
+ activeSwitches,
+ str( links ) )
+ if Link_Up == main.TRUE:
+ main.log.report( "Link up discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=Link_Up,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in " +
+ str( link_sleep ) +
+ " seconds" )
+
+ main.step( "Compare ONOS Topology to MN Topology" )
+ main.case(
+ "Testing Mininet topology with the topology of \
+ multi instances ONOS" )
+ main.step( "Collecting topology information from ONOS" )
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+
+ switches_results1 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices1 ) )
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
+
+ switches_results2 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
+
+ switches_results3 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect" )
+
+ """
+ ports_results1 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect" )
+
+ ports_results2 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect" )
+
+ ports_results3 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect" )
+ """
+ links_results1 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
+
+ links_results2 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ links_results3 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ # topo_result = switches_results1 and switches_results2 and \
+ # switches_results3 and ports_results1 and ports_results2 and \
+ # ports_results3 and links_results1 and links_results2 and \
+ # links_results3
+
+ topo_result = switches_results1 and switches_results2 \
+ and switches_results3 and links_results1 and \
+ links_results2 and links_results3
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=topo_result and Link_Up and Link_Down,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
+
+ def CASE8( self ):
+ """
+ Intent removal
+ """
+ main.log.report(
+ "This testcase removes host any previously added intents" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Removing any previously installed intents" )
+ main.case( "Removing intents" )
+ main.step( "Obtain the intent id's" )
+ intent_result = main.ONOScli1.intents( json_format=False )
+
+ intent_linewise = intent_result.split( "\n" )
+ intentList = []
+ for line in intent_linewise:
+ if line.startswith( "id=" ):
+ intentList.append( line )
+
+ intentids = []
+ for line in intentList:
+ intentids.append( line.split( "," )[ 0 ].split( "=" )[ 1 ] )
+ for id in intentids:
+ main.log.info( "id = " + id )
+
+ main.step(
+ "Iterate through the intentids list and remove each intent" )
+ for id in intentids:
+ main.ONOScli1.remove_intent( intent_id=id )
+
+ intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intent_result = " + intent_result )
+ case8_result = main.TRUE
+
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.TRUE:
+ i = 19
+ Ping_Result = main.TRUE
+ elif ping == main.FALSE:
+ i += 1
+ Ping_Result = main.FALSE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ # Note: If the ping result failed, that means the intents have been
+ # withdrawn correctly.
+ if Ping_Result == main.TRUE:
+ main.log.report( "Host intents have not been withdrawn correctly" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.FALSE:
+ main.log.report( "Host intents have been withdrawn correctly" )
+
+ case8_result = case8_result and Ping_Result
+
+ if case8_result == main.FALSE:
+ main.log.report( "Intent removal successful" )
+ else:
+ main.log.report( "Intent removal failed" )
+
+ utilities.assert_equals( expect=main.FALSE, actual=case8_result,
+ onpass="Intent removal test failed",
+ onfail="Intent removal test successful" )
+
+ def CASE9( self ):
+ """
+ This test case adds point intents. Make sure you run test case 8
+ which is host intent removal before executing this test case.
+ Else the host intents flows will persist on switches and the ping
+ would work even if there is some issue with the point intent's flows
+ """
+ main.log.report(
+ "This testcase adds point intents and then does pingall" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Adding point intents" )
+ main.case(
+ "Adding bidirectional point for mn hosts \
+ h8-h18 h9-h19 h10-h20 h11-h21 h12-h22 h13-h23 \
+ h14-h24 h15-h25 h16-h26 h17-h27" )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h8 and h18 or ONOS hosts h8 and h12" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003008/1",
+ "of:0000000000006018/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006018/1",
+ "of:0000000000003008/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h9 and h19 or ONOS hosts h9 and h13" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003009/1",
+ "of:0000000000006019/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006019/1",
+ "of:0000000000003009/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h10 and h20 or ONOS hosts hA and h14" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003010/1",
+ "of:0000000000006020/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006020/1",
+ "of:0000000000003010/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h11 and h21 or ONOS hosts hB and h15" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003011/1",
+ "of:0000000000006021/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006021/1",
+ "of:0000000000003011/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h12 and h22 or ONOS hosts hC and h16" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003012/1",
+ "of:0000000000006022/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006022/1",
+ "of:0000000000003012/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h13 and h23 or ONOS hosts hD and h17" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003013/1",
+ "of:0000000000006023/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006023/1",
+ "of:0000000000003013/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h14 and h24 or ONOS hosts hE and h18" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003014/1",
+ "of:0000000000006024/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006024/1",
+ "of:0000000000003014/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h15 and h25 or ONOS hosts hF and h19" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003015/1",
+ "of:0000000000006025/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006025/1",
+ "of:0000000000003015/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h16 and h26 or ONOS hosts h10 and h1A" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003016/1",
+ "of:0000000000006026/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006026/1",
+ "of:0000000000003016/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h17 and h27 or ONOS hosts h11 and h1B" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003017/1",
+ "of:0000000000006027/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006027/1",
+ "of:0000000000003017/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ print("___________________________________________________________" )
+
+ flowHandle = main.ONOScli1.flows()
+ main.log.info( "flows :" + flowHandle )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ # i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Ping all test after Point intents addition failed. \
+ Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report(
+ "Ping all test after Point intents addition successful" )
+
+ case8_result = Ping_Result
+ 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 CASE31( self ):
+ """
+ This test case adds point intent related to SDN-IP
+ matching on ICMP ( ethertype=IPV4, ipProto=1 )
+ """
+ import json
+
+ main.log.report(
+ '''This test case adds point intent related to SDN-IP
+ matching on ICMP''' )
+ main.case(
+ '''Adding bidirectional point intent related to SDN-IP
+ matching on ICMP''' )
+ main.step( "Adding bidirectional point intent" )
+ # add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+ # --ethType=IPV4 --ipProto=1 of:0000000000003008/1
+ # of:0000000000006018/1
+
+ hosts_json = json.loads( main.ONOScli1.hosts() )
+ for i in range( 8, 11 ):
+ main.log.info(
+ "Adding point intent between h" + str( i ) +
+ " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ for host in hosts_json:
+ if host[ 'id' ] == host1_id:
+ ip1 = host[ 'ips' ][ 0 ]
+ ip1 = str( ip1 + "/32" )
+ device1 = host[ 'location' ][ 'device' ]
+ device1 = str( device1 + "/1" )
+ elif host[ 'id' ] == host2_id:
+ ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+ device2 = host[ 'location' ][ "device" ]
+ device2 = str( device2 + "/1" )
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+
+ p_intent_result2 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+ if ( p_intent_result1 and p_intent_result2 ) == main.TRUE:
+ # get_intent_result = main.ONOScli1.intents()
+ # main.log.info( get_intent_result )
+ main.log.info(
+ '''Point intent related to SDN-IP matching on ICMP install
+ successful''' )
+
+ time.sleep( 15 )
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intents = " + get_intent_result )
+ get_flows_result = main.ONOScli1.flows()
+ main.log.info( "flows = " + get_flows_result )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 11:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 3:
+ count += 1
+ # i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Ping test after Point intents related to SDN-IP \
+ matching on ICMP failed." )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report(
+ "Ping all test after Point intents related to SDN-IP \
+ matching on ICMP successful" )
+
+ case31_result = Ping_Result and p_intent_result1 and p_intent_result2
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case31_result,
+ onpass="Point intent related to SDN-IP matching on ICMP and \
+ ping test successful",
+ onfail="Point intent related to SDN-IP matching on ICMP and \
+ ping test failed" )
+
+ def CASE32( self ):
+ '''
+ This test case adds point intent related to SDN-IP matching on TCP
+ ( ethertype=IPV4, ipProto=6, DefaultPort for iperf=5001 )
+ Note: Although BGP port is 179, we are using 5001 because iperf is
+ used for verifying and iperf's default port is 5001
+ '''
+ import json
+
+ main.log.report( '''This test case adds point intent related
+ to SDN-IP matching on TCP''' )
+ main.case( '''Adding bidirectional point intent related to SDN-IP
+ matching on TCP''' )
+ main.step( "Adding bidirectional point intent" )
+
+ """
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+ --ethType=IPV4 --ipProto=6 --tcpDst=5001
+ of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32
+ --ethType=IPV4 --ipProto=6 --tcpDst=5001
+ of:0000000000006018/1 of:0000000000003008/1
+
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+ --ethType=IPV4 --ipProto=6 --tcpSrc=5001
+ of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32
+ --ethType=IPV4 --ipProto=6 --tcpSrc=5001
+ of:0000000000006018/1 of:0000000000003008/1
+
+ """
+ hosts_json = json.loads( main.ONOScli1.hosts() )
+ for i in range( 8, 9 ):
+ main.log.info(
+ "Adding point intent between h" + str( i ) +
+ " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ for host in hosts_json:
+ if host[ 'id' ] == host1_id:
+ ip1 = host[ 'ips' ][ 0 ]
+ ip1 = str( ip1 + "/32" )
+ device1 = host[ 'location' ][ 'device' ]
+ device1 = str( device1 + "/1" )
+ elif host[ 'id' ] == host2_id:
+ ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+ device2 = host[ 'location' ][ "device" ]
+ device2 = str( device2 + "/1" )
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+ p_intent_result2 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+
+ p_intent_result3 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+ p_intent_result4 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+
+ p_intent_result = p_intent_result1 and p_intent_result2 and \
+ p_intent_result3 and p_intent_result4
+ if p_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+ main.log.info( '''Point intent related to SDN-IP matching
+ on TCP install successful''' )
+
+ iperf_result = main.Mininet1.iperf( 'h8', 'h18' )
+ if iperf_result == main.TRUE:
+ main.log.report( "iperf test successful" )
+ else:
+ main.log.report( "iperf test failed" )
+
+ case32_result = p_intent_result and iperf_result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case32_result,
+ onpass="Ping all test after Point intents addition related to \
+ SDN-IP on TCP match successful",
+ onfail="Ping all test after Point intents addition related to \
+ SDN-IP on TCP match failed" )
+
+ def CASE33( self ):
+ """
+ This test case adds multipoint to singlepoint intent related
+ to SDN-IP matching on destination ip and the action is to
+ rewrite the mac address.
+ Here the mac address to be rewritten is the mac address
+ of the egress device
+ """
+ import json
+ import time
+
+ main.log.report( "This test case adds multipoint to singlepoint intent\
+ related to SDN-IP matching on destination ip and\
+ rewrite mac address action" )
+ main.case( "Adding multipoint to singlepoint intent related to SDN-IP\
+ matching on destination ip" )
+ main.step( "Adding bidirectional multipoint to singlepoint intent" )
+ """
+ add-multi-to-single-intent --ipDst=10.0.3.0/24
+ --setEthDst=00:00:00:00:00:12
+ of:0000000000003008/1 0000000000003009/1 of:0000000000006018/1
+
+ add-multi-to-single-intent --ipDst=10.0.1.0/24
+ --setEthDst=00:00:00:00:00:08
+ of:0000000000006018/1 0000000000003009/1 of:0000000000003008/1
+ """
+ main.case( "Installing multipoint to single point intent with\
+ rewrite mac address" )
+ main.step( "Uninstalling proxy arp app" )
+ # Unistall onos-app-proxyarp app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall(
+ "onos-app-proxyarp" )
+ appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ "onos-app-proxyarp" )
+ appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ "onos-app-proxyarp" )
+ main.log.info( "onos-app-proxyarp uninstalled" )
+
+ main.step( "Changing ipaddress of hosts h8,h9 and h18" )
+ main.Mininet1.changeIP(
+ host='h8',
+ intf='h8-eth0',
+ newIP='10.0.1.1',
+ newNetmask='255.255.255.0' )
+ main.Mininet1.changeIP(
+ host='h9',
+ intf='h9-eth0',
+ newIP='10.0.2.1',
+ newNetmask='255.255.255.0' )
+ main.Mininet1.changeIP(
+ host='h10',
+ intf='h10-eth0',
+ newIP='10.0.3.1',
+ newNetmask='255.255.255.0' )
+
+ main.step( "Changing default gateway of hosts h8,h9 and h18" )
+ main.Mininet1.changeDefaultGateway( host='h8', newGW='10.0.1.254' )
+ main.Mininet1.changeDefaultGateway( host='h9', newGW='10.0.2.254' )
+ main.Mininet1.changeDefaultGateway( host='h10', newGW='10.0.3.254' )
+
+ main.step( "Assigning random mac address to the default gateways\
+ since proxyarp app is uninstalled" )
+ main.Mininet1.addStaticMACAddress(
+ host='h8',
+ GW='10.0.1.254',
+ macaddr='00:00:00:00:11:11' )
+ main.Mininet1.addStaticMACAddress(
+ host='h9',
+ GW='10.0.2.254',
+ macaddr='00:00:00:00:22:22' )
+ main.Mininet1.addStaticMACAddress(
+ host='h10',
+ GW='10.0.3.254',
+ macaddr='00:00:00:00:33:33' )
+
+ main.step( "Verify static gateway and MAC address assignment" )
+ main.Mininet1.verifyStaticGWandMAC( host='h8' )
+ main.Mininet1.verifyStaticGWandMAC( host='h9' )
+ main.Mininet1.verifyStaticGWandMAC( host='h10' )
+
+ main.step( "Adding multipoint to singlepoint intent" )
+ p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+ ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+ ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+ ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip1' ],
+ setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac1' ] )
+
+ p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+ ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+ ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+ ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip2' ],
+ setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac2' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intents = " + get_intent_result )
+
+ time.sleep( 10 )
+ get_flows_result = main.ONOScli1.flows( json_format=False )
+ main.log.info( "flows = " + get_flows_result )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+
+ 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
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 2 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 2 ) +
+ "passed!" )
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ if Ping_Result == main.FALSE:
+ main.log.report( "Ping test failed." )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report( "Ping all successful" )
+
+ p_intent_result = p_intent_result1 and p_intent_result2
+ if p_intent_result == 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" )
+
+ case33_result = p_intent_result and Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case33_result,
+ onpass="Ping all test after multipoint to single point intent \
+ addition with rewrite mac address successful",
+ onfail="Ping all test after multipoint to single point intent \
+ addition with rewrite mac address failed" )
+
diff --git a/TestON/tests/MultiProd13/MultiProd13.params b/TestON/tests/MultiProd13/MultiProd13.params
index 8bf1600..6e5c85e 100755
--- a/TestON/tests/MultiProd13/MultiProd13.params
+++ b/TestON/tests/MultiProd13/MultiProd13.params
@@ -1,6 +1,6 @@
<PARAMS>
- <testcases>1,4,10,5,6,7,8,6,8,9,31,32,8,33</testcases>
+ <testcases>1,4,10,5,6,7,8,6,8,9,8,31,32,8,33,8</testcases>
#Environment variables
<ENV>
diff --git a/TestON/tests/MultiProd13/MultiProd13.py b/TestON/tests/MultiProd13/MultiProd13.py
index cbf27a4..d3ed757 100644
--- a/TestON/tests/MultiProd13/MultiProd13.py
+++ b/TestON/tests/MultiProd13/MultiProd13.py
@@ -11,8 +11,7 @@
time.sleep( 1 )
-
-class MultiProd13:
+class MultiProd:
def __init__( self ):
self.default = ''
@@ -53,8 +52,8 @@
main.step( "Removing raft logs before a clen installation of ONOS" )
removeLogResult = main.ONOSbench.onosRemoveRaftLogs()
- main.step( "Git checkout and pull master and get version" )
- main.ONOSbench.gitCheckout( "master" )
+ main.step( "Git checkout, pull and get version" )
+ #main.ONOSbench.gitCheckout( "master" )
gitPullResult = main.ONOSbench.gitPull()
print "git_pull_result = ", gitPullResult
versionResult = main.ONOSbench.getVersion( report=True )
@@ -514,7 +513,6 @@
tmpResult = main.ONOScli1.addHostIntent( host1Id, host2Id )
flowHandle = main.ONOScli1.flows()
- # print "flowHandle = ", flowHandle
main.log.info( "flows:" + flowHandle )
count = 1
@@ -857,7 +855,7 @@
Intent removal
"""
main.log.report(
- "This testcase removes host any previously added intents" )
+ "This testcase removes any previously added intents" )
main.log.report( "__________________________________" )
main.log.info( "Removing any previously installed intents" )
main.case( "Removing intents" )
@@ -1424,9 +1422,13 @@
if pIntentResult == main.TRUE:
getIntentResult = main.ONOScli1.intents( jsonFormat=False )
main.log.info( getIntentResult )
- main.log.info(
+ main.log.report(
"Point intent related to SDN-IP matching" +
" on TCP install successful" )
+ else:
+ main.log.report(
+ "Point intent related to SDN-IP matching" +
+ " on TCP install failed" )
iperfResult = main.Mininet1.iperf( 'h8', 'h18' )
if iperfResult == main.TRUE:
diff --git a/TestON/tests/OnosCHO/OnosCHO.params b/TestON/tests/OnosCHO/OnosCHO.params
index ceedc19..af23c70 100644
--- a/TestON/tests/OnosCHO/OnosCHO.params
+++ b/TestON/tests/OnosCHO/OnosCHO.params
@@ -12,15 +12,36 @@
# 10. Remove all intents on ONOS
# 1,2,3,[4,5,6,5,70,80,5,10,5,9,5,71,81,5,10,5]*100
- <testcases>1,2,3,[4,5,6,5,70,80,5,10,5,9,5,71,81,5,10,5]*100</testcases>
+ <testcases>1,2,3,4,5,12,3,4,5,13,3,4,5</testcases>
<ENV>
<cellName>choTest5</cellName>
</ENV>
<GIT>
#autoPull 'on' or 'off'
- <autoPull>on</autoPull>
- <branch>onos-1.0</branch>
+ <autoPull>off</autoPull>
+ <branch>master</branch>
</GIT>
+ <TOPO1>
+ <topo>~/mininet/custom/topoAtt.py</topo>
+ <numSwitches>25</numSwitches>
+ <numHosts>25</numHosts>
+ <numLinks>114</numLinks>
+ <numPaths>1</numPaths>
+ </TOPO1>
+ <TOPO2>
+ <topo>~/mininet/custom/topoChordal.py</topo>
+ <numSwitches>25</numSwitches>
+ <numHosts>25</numHosts>
+ <numLinks>600</numLinks>
+ <numPaths>1</numPaths>
+ </TOPO2>
+ <TOPO3>
+ <topo>~/mininet/custom/topoSpine.py</topo>
+ <numSwitches>78</numSwitches>
+ <numHosts>68</numHosts>
+ <numLinks>284</numLinks>
+ <numPaths>1</numPaths>
+ </TOPO3>
<CTRL>
<numCtrl>5</numCtrl>
<ip1>10.128.40.41</ip1>
@@ -38,13 +59,6 @@
<startMAC>00:00:00:00:00:01</startMAC>
<endMAC>00:00:00:00:00:19</endMAC>
</HOSTS>
- <ONOSTOPO>
- <numDevices>25</numDevices>
- <numLinks>114</numLinks>
- <numHosts>25</numHosts>
- <numIntents>300</numIntents>
- <numPaths>1360</numPaths>
- </ONOSTOPO>
<CORELINKS>
<toggleLinks>3</toggleLinks>
diff --git a/TestON/tests/OnosCHO/OnosCHO.py b/TestON/tests/OnosCHO/OnosCHO.py
index db7bc4e..eb71518 100644
--- a/TestON/tests/OnosCHO/OnosCHO.py
+++ b/TestON/tests/OnosCHO/OnosCHO.py
@@ -11,13 +11,6 @@
def __init__( self ):
self.default = ''
- global deviceDPIDs
- global hostMACs
- global deviceLinks
- global deviceActiveLinksCount
- global devicePortsEnabledCount
- global installedIntents
- global randomLink1, randomLink2, randomLink3, numSwitches, numLinks
def CASE1( self, main ):
"""
@@ -31,9 +24,20 @@
onos-wait-for-start
"""
import time
+
+ main.numCtrls = main.params[ 'CTRL' ][ 'numCtrl' ]
+ main.ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ main.ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ main.ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+ main.ONOS4_ip = main.params[ 'CTRL' ][ 'ip4' ]
+ main.ONOS5_ip = main.params[ 'CTRL' ][ 'ip5' ]
+ main.ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+ main.ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+ main.ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+ main.ONOS4_port = main.params[ 'CTRL' ][ 'port4' ]
+ main.ONOS5_port = main.params[ 'CTRL' ][ 'port5' ]
cell_name = main.params[ 'ENV' ][ 'cellName' ]
git_pull = main.params[ 'GIT' ][ 'autoPull' ]
- numCtrls = main.params[ 'CTRL' ][ 'numCtrl' ]
git_branch = main.params[ 'GIT' ][ 'branch' ]
main.case( "Set up test environment" )
@@ -55,10 +59,14 @@
onfail="Test step FAIL" )
main.step( "mvn clean & install" )
- mvn_result = main.ONOSbench.cleanInstall()
- utilities.assert_equals( expect=main.TRUE, actual=mvn_result,
+ if git_pull == 'on':
+ mvn_result = main.ONOSbench.cleanInstall()
+ utilities.assert_equals( expect=main.TRUE, actual=mvn_result,
onpass="Test step PASS",
onfail="Test step FAIL" )
+ else:
+ mvn_result = main.TRUE
+ main.log.info("Skipped mvn clean install as git pull is disabled in params file")
main.ONOSbench.getVersion( report=True )
@@ -76,7 +84,7 @@
main.step( "Uninstall ONOS package on all Nodes" )
uninstallResult = main.TRUE
- for i in range( 1, int( numCtrls ) + 1 ):
+ for i in range( 1, int( main.numCtrls ) + 1 ):
ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
main.log.info( "Unintsalling package on ONOS Node IP: " + ONOS_ip )
u_result = main.ONOSbench.onosUninstall( ONOS_ip )
@@ -90,7 +98,7 @@
main.step( "Install ONOS package on all Nodes" )
installResult = main.TRUE
- for i in range( 1, int( numCtrls ) + 1 ):
+ for i in range( 1, int( main.numCtrls ) + 1 ):
ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
main.log.info( "Intsalling package on ONOS Node IP: " + ONOS_ip )
i_result = main.ONOSbench.onosInstall( node=ONOS_ip )
@@ -101,7 +109,7 @@
main.step( "Verify ONOS nodes UP status" )
statusResult = main.TRUE
- for i in range( 1, int( numCtrls ) + 1 ):
+ for i in range( 1, int( main.numCtrls ) + 1 ):
ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
main.log.info( "ONOS Node " + ONOS_ip + " status:" )
onos_status = main.ONOSbench.onosStatus( node=ONOS_ip )
@@ -115,8 +123,8 @@
karafTimeout = "3600000"
# need to wait here for sometime. This will be removed once ONOS is
# stable enough
- time.sleep( 15 )
- for i in range( 1, int( numCtrls ) + 1 ):
+ time.sleep( 20 )
+ for i in range( 1, int( main.numCtrls ) + 1 ):
ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
ONOScli = 'ONOScli' + str( i )
main.log.info( "ONOS Node " + ONOS_ip + " cli start:" )
@@ -135,24 +143,15 @@
def CASE2( self, main ):
"""
- This test script still needs more refactoring
+ This test loads a Topology (ATT) on Mininet and balances all switches.
"""
import re
import time
import copy
- numCtrls = main.params[ 'CTRL' ][ 'numCtrl' ]
- 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' ]
- ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
- ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
- ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
- ONOS4_port = main.params[ 'CTRL' ][ 'port4' ]
- ONOS5_port = main.params[ 'CTRL' ][ 'port5' ]
+ main.numMNswitches = int ( main.params[ 'TOPO1' ][ 'numSwitches' ] )
+ main.numMNlinks = int ( main.params[ 'TOPO1' ][ 'numLinks' ] )
+ main.numMNhosts = int ( main.params[ 'TOPO1' ][ 'numHosts' ] )
- numCtrls = main.params[ 'CTRL' ][ 'numCtrl' ]
main.log.report(
"Assign and Balance all Mininet switches across controllers" )
main.log.report(
@@ -163,26 +162,27 @@
main.case(
"Assign and Balance all Mininet switches across controllers" )
main.step( "Assign switches to controllers" )
- for i in range( 1, 26 ): # 1 to ( num of switches +1 )
+ netStatus = main.Mininet1.startNet()
+ for i in range( 1, ( main.numMNswitches + 1 ) ): # 1 to ( num of switches +1 )
main.Mininet1.assignSwController(
sw=str( i ),
- count=int( numCtrls ),
- ip1=ONOS1_ip,
- port1=ONOS1_port,
- ip2=ONOS2_ip,
- port2=ONOS2_port,
- ip3=ONOS3_ip,
- port3=ONOS3_port,
- ip4=ONOS4_ip,
- port4=ONOS4_port,
- ip5=ONOS5_ip,
- port5=ONOS5_port )
+ count=int( main.numCtrls ),
+ ip1=main.ONOS1_ip,
+ port1=main.ONOS1_port,
+ ip2=main.ONOS2_ip,
+ port2=main.ONOS2_port,
+ ip3=main.ONOS3_ip,
+ port3=main.ONOS3_port,
+ ip4=main.ONOS4_ip,
+ port4=main.ONOS4_port,
+ ip5=main.ONOS5_ip,
+ port5=main.ONOS5_port )
switch_mastership = main.TRUE
- for i in range( 1, 26 ):
+ for i in range( 1, ( main.numMNswitches + 1 ) ):
response = main.Mininet1.getSwController( "s" + str( i ) )
print( "Response is " + str( response ) )
- if re.search( "tcp:" + ONOS1_ip, response ):
+ if re.search( "tcp:" + main.ONOS1_ip, response ):
switch_mastership = switch_mastership and main.TRUE
else:
switch_mastership = main.FALSE
@@ -191,19 +191,19 @@
main.log.report( "Controller assignment successfull" )
else:
main.log.report( "Controller assignment failed" )
- time.sleep( 5 )
+ time.sleep( 15 )
- main.step( "Balance devices across controllers" )
- for i in range( int( numCtrls ) ):
- balanceResult = main.ONOScli1.balanceMasters()
+ #main.step( "Balance devices across controllers" )
+ #for i in range( int( main.numCtrls ) ):
+ # balanceResult = main.ONOScli1.balanceMasters()
# giving some breathing time for ONOS to complete re-balance
- time.sleep( 3 )
+ # time.sleep( 3 )
- utilities.assert_equals(
- expect=main.TRUE,
- actual=balanceResult,
- onpass="Assign and Balance devices test PASS",
- onfail="Assign and Balance devices test FAIL" )
+ #utilities.assert_equals(
+ # expect=main.TRUE,
+ # actual=balanceResult,
+ # onpass="Assign and Balance devices test PASS",
+ #onfail="Assign and Balance devices test FAIL" )
def CASE3( self, main ):
"""
@@ -212,11 +212,11 @@
"""
import re
import copy
- deviceDPIDs = []
- hostMACs = []
- deviceLinks = []
- deviceActiveLinksCount = []
- devicePortsEnabledCount = []
+ main.deviceDPIDs = []
+ main.hostMACs = []
+ main.deviceLinks = []
+ main.deviceActiveLinksCount = []
+ main.devicePortsEnabledCount = []
main.log.report(
"Collect and Store topology details from ONOS before running any Tests" )
@@ -227,57 +227,64 @@
main.step( "Collect and store current number of switches and links" )
topology_output = main.ONOScli1.topology()
topology_result = main.ONOSbench.getTopology( topology_output )
- numSwitches = topology_result[ 'devices' ]
- numLinks = topology_result[ 'links' ]
- main.log.info(
- "Currently there are %s switches and %s links" %
- ( str( numSwitches ), str( numLinks ) ) )
+ numOnosDevices = topology_result[ 'devices' ]
+ numOnosLinks = topology_result[ 'links' ]
- main.step( "Store Device DPIDs" )
- for i in range( 1, 26 ):
- deviceDPIDs.append( "of:00000000000000" + format( i, '02x' ) )
- print "Device DPIDs in Store: \n", str( deviceDPIDs )
+ if ( ( main.numMNswitches == int(numOnosDevices) ) and ( main.numMNlinks == int(numOnosLinks) ) ):
+ main.step( "Store Device DPIDs" )
+ for i in range( 1, (main.numMNswitches+1) ):
+ main.deviceDPIDs.append( "of:00000000000000" + format( i, '02x' ) )
+ print "Device DPIDs in Store: \n", str( main.deviceDPIDs )
- main.step( "Store Host MACs" )
- for i in range( 1, 26 ):
- hostMACs.append( "00:00:00:00:00:" + format( i, '02x' ) + "/-1" )
- print "Host MACs in Store: \n", str( hostMACs )
+ main.step( "Store Host MACs" )
+ for i in range( 1, ( main.numMNhosts + 1 ) ):
+ main.hostMACs.append( "00:00:00:00:00:" + format( i, '02x' ) + "/-1" )
+ print "Host MACs in Store: \n", str( main.hostMACs )
- main.step( "Collect and store all Devices Links" )
- linksResult = main.ONOScli1.links( jsonFormat=False )
- ansi_escape = re.compile( r'\x1b[^m]*m' )
- linksResult = ansi_escape.sub( '', linksResult )
- linksResult = linksResult.replace( " links", "" ).replace( "\r\r", "" )
- linksResult = linksResult.splitlines()
- linksResult = linksResult[ 1: ]
- deviceLinks = copy.copy( linksResult )
- print "Device Links Stored: \n", str( deviceLinks )
- # this will be asserted to check with the params provided count of
- # links
- print "Length of Links Store", len( deviceLinks )
+ main.step( "Collect and store all Devices Links" )
+ linksResult = main.ONOScli1.links( jsonFormat=False )
+ ansi_escape = re.compile( r'\x1b[^m]*m' )
+ linksResult = ansi_escape.sub( '', linksResult )
+ linksResult = linksResult.replace( " links", "" ).replace( "\r\r", "" )
+ linksResult = linksResult.splitlines()
+ linksResult = linksResult[ 1: ]
+ main.deviceLinks = copy.copy( linksResult )
+ print "Device Links Stored: \n", str( main.deviceLinks )
+ # this will be asserted to check with the params provided count of
+ # links
+ print "Length of Links Store", len( main.deviceLinks )
- main.step( "Collect and store each Device ports enabled Count" )
- for i in range( 1, 26 ):
- portResult = main.ONOScli1.getDevicePortsEnabledCount(
- "of:00000000000000" + format( i,'02x' ) )
- print portResult
- portTemp = re.split( r'\t+', portResult )
- portCount = portTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
- devicePortsEnabledCount.append( portCount )
- print "Device Enabled Port Counts Stored: \n", str( devicePortsEnabledCount )
+ main.step( "Collect and store each Device ports enabled Count" )
+ for i in range( 1, ( main.numMNswitches + 1) ):
+ portResult = main.ONOScli1.getDevicePortsEnabledCount(
+ "of:00000000000000" + format( i,'02x' ) )
+ portTemp = re.split( r'\t+', portResult )
+ portCount = portTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
+ main.devicePortsEnabledCount.append( portCount )
+ print "Device Enabled Port Counts Stored: \n", str( main.devicePortsEnabledCount )
- main.step( "Collect and store each Device active links Count" )
- for i in range( 1, 26 ):
- linkCountResult = main.ONOScli1.getDeviceLinksActiveCount(
- "of:00000000000000" + format( i,'02x' ) )
- linkCountTemp = re.split( r'\t+', linkCountResult )
- linkCount = linkCountTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
- deviceActiveLinksCount.append( linkCount )
- print "Device Active Links Count Stored: \n", str( deviceActiveLinksCount )
+ main.step( "Collect and store each Device active links Count" )
+ for i in range( 1, ( main.numMNswitches + 1) ):
+ linkCountResult = main.ONOScli1.getDeviceLinksActiveCount(
+ "of:00000000000000" + format( i,'02x' ) )
+ linkCountTemp = re.split( r'\t+', linkCountResult )
+ linkCount = linkCountTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
+ main.deviceActiveLinksCount.append( linkCount )
+ print "Device Active Links Count Stored: \n", str( main.deviceActiveLinksCount )
+
+ else:
+ main.log.info("Devices (expected): %s, Links (expected): %s" %
+ ( str( main.numMNswitches ), str( main.numMNlinks ) ) )
+ main.log.info("Devices (actual): %s, Links (actual): %s" %
+ ( numOnosDevices , numOnosLinks ) )
+ main.log.info("Topology does not match, exiting CHO test...")
+ time.sleep(300)
+ #main.cleanup()
+ #main.exit()
# just returning TRUE for now as this one just collects data
- caseResult = main.TRUE
- utilities.assert_equals( expect=main.TRUE, actual=case1Result,
+ case3Result = main.TRUE
+ utilities.assert_equals( expect=main.TRUE, actual=case3Result,
onpass="Saving ONOS topology data test PASS",
onfail="Saving ONOS topology data test FAIL" )
@@ -288,13 +295,13 @@
import re
import copy
import time
- numCtrls = main.params[ 'CTRL' ][ 'numCtrl' ]
+
main.log.report( "Enable Reactive forwarding and Verify ping all" )
main.log.report( "______________________________________________" )
main.case( "Enable Reactive forwarding and Verify ping all" )
main.step( "Enable Reactive forwarding" )
installResult = main.TRUE
- for i in range( 1, int( numCtrls ) + 1 ):
+ for i in range( 1, int( main.numCtrls ) + 1 ):
onosFeature = 'onos-app-fwd'
ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
ONOScli = 'ONOScli' + str( i )
@@ -323,7 +330,7 @@
main.step( "Disable Reactive forwarding" )
uninstallResult = main.TRUE
- for i in range( 1, int( numCtrls ) + 1 ):
+ for i in range( 1, int( main.numCtrls ) + 1 ):
onosFeature = 'onos-app-fwd'
ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
ONOScli = 'ONOScli' + str( i )
@@ -344,11 +351,11 @@
Compare current ONOS topology with reference data
"""
import re
- devicesDPID_tmp = []
- hostMACs_tmp = []
- deviceLinks_tmp = []
- deviceActiveLinksCount_tmp = []
- devicePortsEnabledCount_tmp = []
+ devicesDPIDTemp = []
+ hostMACsTemp = []
+ deviceLinksTemp = []
+ deviceActiveLinksCountTemp = []
+ devicePortsEnabledCountTemp = []
main.log.report(
"Compare ONOS topology with reference data in Stores" )
@@ -364,16 +371,16 @@
'02x' ) )
portTemp = re.split( r'\t+', portResult )
portCount = portTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
- devicePortsEnabledCount_tmp.append( portCount )
+ devicePortsEnabledCountTemp.append( portCount )
time.sleep( 2 )
- print (
- "Device Enabled ports EXPECTED: \n" +
- str( devicePortsEnabledCount ) )
- print (
- "Device Enabled ports ACTUAL: \n" +
- str( devicePortsEnabledCount_tmp ) )
- if ( cmp( devicePortsEnabledCount,
- devicePortsEnabledCount_tmp ) == 0 ):
+ main.log.info (
+ "Device Enabled ports EXPECTED: %s" %
+ str( main.devicePortsEnabledCount ) )
+ main.log.info (
+ "Device Enabled ports ACTUAL: %s" %
+ str( devicePortsEnabledCountTemp ) )
+ if ( cmp( main.devicePortsEnabledCount,
+ devicePortsEnabledCountTemp ) == 0 ):
stepResult1 = main.TRUE
else:
stepResult1 = main.FALSE
@@ -387,29 +394,26 @@
'02x' ) )
linkTemp = re.split( r'\t+', linkResult )
linkCount = linkTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
- deviceActiveLinksCount_tmp.append( linkCount )
+ deviceActiveLinksCountTemp.append( linkCount )
time.sleep( 3 )
- print (
- "Device Active links EXPECTED: \n" +
- str( deviceActiveLinksCount ) )
- print (
- "Device Active links ACTUAL: \n" +
- str( deviceActiveLinksCount_tmp ) )
- if ( cmp( deviceActiveLinksCount, deviceActiveLinksCount_tmp ) == 0 ):
+ main.log.info (
+ "Device Active links EXPECTED: %s" %
+ str( main.deviceActiveLinksCount ) )
+ main.log.info (
+ "Device Active links ACTUAL: %s" % str( deviceActiveLinksCountTemp ) )
+ if ( cmp( main.deviceActiveLinksCount, deviceActiveLinksCountTemp ) == 0 ):
stepResult2 = main.TRUE
else:
stepResult2 = main.FALSE
"""
- place holder for comparing devices, hosts and paths if required.
+ place holder for comparing devices, hosts, paths and intents if required.
Links and ports data would be incorrect with out devices anyways.
"""
- caseResult = ( stepResult1 and stepResult2 )
- utilities.assert_equals( expect=main.TRUE, actual=case1Result,
+ case5Result = ( stepResult1 and stepResult2 )
+ utilities.assert_equals( expect=main.TRUE, actual=case5Result,
onpass="Compare Topology test PASS",
onfail="Compare Topology test FAIL" )
- if caseResult == main.TRUE:
- main.log.report( "Compare Topology test Pass" )
def CASE6( self ):
"""
@@ -418,10 +422,11 @@
main.log.report( "Add 300 host intents and verify pingall" )
main.log.report( "_______________________________________" )
import itertools
+
main.case( "Install 300 host intents" )
main.step( "Add host Intents" )
intentResult = main.TRUE
- hostCombos = list( itertools.combinations( hostMACs, 2 ) )
+ hostCombos = list( itertools.combinations( main.hostMACs, 2 ) )
for i in range( len( hostCombos ) ):
iResult = main.ONOScli1.addHostIntent(
hostCombos[ i ][ 0 ],
@@ -455,7 +460,9 @@
Randomly bring some core links down and verify ping all ( Host Intents Scenario )
"""
import random
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ main.randomLink1 = []
+ main.randomLink2 = []
+ main.randomLink3 = []
link1End1 = main.params[ 'CORELINKS' ][ 'linkS3a' ]
link1End2 = main.params[ 'CORELINKS' ][ 'linkS3b' ].split( ',' )
link2End1 = main.params[ 'CORELINKS' ][ 'linkS14a' ]
@@ -478,28 +485,28 @@
main.log.info( "User provided Core switch links range to toggle is correct, proceeding to run the test" )
main.step( "Cut links on Core devices using user provided range" )
- randomLink1 = random.sample( link1End2, int( switchLinksToToggle ) )
- randomLink2 = random.sample( link2End2, int( switchLinksToToggle ) )
- randomLink3 = random.sample( link3End2, int( switchLinksToToggle ) )
+ main.randomLink1 = random.sample( link1End2, int( switchLinksToToggle ) )
+ main.randomLink2 = random.sample( link2End2, int( switchLinksToToggle ) )
+ main.randomLink3 = random.sample( link3End2, int( switchLinksToToggle ) )
for i in range( int( switchLinksToToggle ) ):
main.Mininet1.link(
END1=link1End1,
- END2=randomLink1[ i ],
+ END2=main.randomLink1[ i ],
OPTION="down" )
main.Mininet1.link(
END1=link2End1,
- END2=randomLink2[ i ],
+ END2=main.randomLink2[ i ],
OPTION="down" )
main.Mininet1.link(
END1=link3End1,
- END2=randomLink3[ i ],
+ END2=main.randomLink3[ i ],
OPTION="down" )
time.sleep( link_sleep )
topology_output = main.ONOScli2.topology()
linkDown = main.ONOSbench.checkStatus(
- topology_output, numSwitches, str(
- int( numLinks ) - int( switchLinksToToggle ) * 6 ) )
+ topology_output, main.numMNswitches, str(
+ int( main.numMNlinks ) - int( switchLinksToToggle ) * 6 ) )
utilities.assert_equals(
expect=main.TRUE,
actual=linkDown,
@@ -522,8 +529,8 @@
onpass="PING ALL PASS",
onfail="PING ALL FAIL" )
- caseResult7 = linkDown and pingResultLinkDown
- utilities.assert_equals( expect=main.TRUE, actual=caseResult7,
+ caseResult70 = linkDown and pingResultLinkDown
+ utilities.assert_equals( expect=main.TRUE, actual=caseResult70,
onpass="Random Link cut Test PASS",
onfail="Random Link cut Test FAIL" )
@@ -532,7 +539,6 @@
Bring the core links up that are down and verify ping all ( Host Intents Scenario )
"""
import random
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
link1End1 = main.params[ 'CORELINKS' ][ 'linkS3a' ]
link2End1 = main.params[ 'CORELINKS' ][ 'linkS14a' ]
link3End1 = main.params[ 'CORELINKS' ][ 'linkS18a' ]
@@ -564,8 +570,8 @@
topology_output = main.ONOScli2.topology()
linkUp = main.ONOSbench.checkStatus(
topology_output,
- numSwitches,
- str( numLinks ) )
+ main.numMNswitches,
+ str( main.numMNlinks ) )
utilities.assert_equals(
expect=main.TRUE,
actual=linkUp,
@@ -588,8 +594,8 @@
onpass="PING ALL PASS",
onfail="PING ALL FAIL" )
- caseResult8 = linkUp and pingResultLinkUp
- utilities.assert_equals( expect=main.TRUE, actual=caseResult8,
+ caseResult80 = linkUp and pingResultLinkUp
+ utilities.assert_equals( expect=main.TRUE, actual=caseResult80,
onpass="Link Up Test PASS",
onfail="Link Up Test FAIL" )
@@ -598,7 +604,9 @@
Randomly bring some core links down and verify ping all ( Point Intents Scenario )
"""
import random
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ main.randomLink1 = []
+ main.randomLink2 = []
+ main.randomLink3 = []
link1End1 = main.params[ 'CORELINKS' ][ 'linkS3a' ]
link1End2 = main.params[ 'CORELINKS' ][ 'linkS3b' ].split( ',' )
link2End1 = main.params[ 'CORELINKS' ][ 'linkS14a' ]
@@ -629,22 +637,22 @@
for i in range( int( switchLinksToToggle ) ):
main.Mininet1.link(
END1=link1End1,
- END2=randomLink1[ i ],
+ END2=main.randomLink1[ i ],
OPTION="down" )
main.Mininet1.link(
END1=link2End1,
- END2=randomLink2[ i ],
+ END2=main.randomLink2[ i ],
OPTION="down" )
main.Mininet1.link(
END1=link3End1,
- END2=randomLink3[ i ],
+ END2=main.randomLink3[ i ],
OPTION="down" )
time.sleep( link_sleep )
topology_output = main.ONOScli2.topology()
linkDown = main.ONOSbench.checkStatus(
- topology_output, numSwitches, str(
- int( numLinks ) - int( switchLinksToToggle ) * 6 ) )
+ topology_output, main.numSwitches, str(
+ int( main.numLinks ) - int( switchLinksToToggle ) * 6 ) )
utilities.assert_equals(
expect=main.TRUE,
actual=linkDown,
@@ -677,7 +685,6 @@
Bring the core links up that are down and verify ping all ( Point Intents Scenario )
"""
import random
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
link1End1 = main.params[ 'CORELINKS' ][ 'linkS3a' ]
link2End1 = main.params[ 'CORELINKS' ][ 'linkS14a' ]
link3End1 = main.params[ 'CORELINKS' ][ 'linkS18a' ]
@@ -694,23 +701,23 @@
for i in range( int( switchLinksToToggle ) ):
main.Mininet1.link(
END1=link1End1,
- END2=randomLink1[ i ],
+ END2=main.randomLink1[ i ],
OPTION="up" )
main.Mininet1.link(
END1=link2End1,
- END2=randomLink2[ i ],
+ END2=main.randomLink2[ i ],
OPTION="up" )
main.Mininet1.link(
END1=link3End1,
- END2=randomLink3[ i ],
+ END2=main.randomLink3[ i ],
OPTION="up" )
time.sleep( link_sleep )
topology_output = main.ONOScli2.topology()
linkUp = main.ONOSbench.checkStatus(
topology_output,
- numSwitches,
- str( numLinks ) )
+ main.numMNswitches,
+ str( main.numMNlinks ) )
utilities.assert_equals(
expect=main.TRUE,
actual=linkUp,
@@ -733,8 +740,8 @@
onpass="PING ALL PASS",
onfail="PING ALL FAIL" )
- caseResult8 = linkUp and pingResultLinkUp
- utilities.assert_equals( expect=main.TRUE, actual=caseResult8,
+ caseResult81 = linkUp and pingResultLinkUp
+ utilities.assert_equals( expect=main.TRUE, actual=caseResult81,
onpass="Link Up Test PASS",
onfail="Link Up Test FAIL" )
@@ -746,11 +753,11 @@
main.log.report( "Install 114 point intents and verify Ping all" )
main.log.report( "___________________________________________" )
main.case( "Install 114 point intents and Ping all" )
- deviceLinks_copy = copy.copy( deviceLinks )
+ deviceLinksCopy = copy.copy( main.deviceLinks )
main.step( "Install 114 point intents" )
- for i in range( len( deviceLinks_copy ) ):
+ for i in range( len( deviceLinksCopy ) ):
pointLink = str(
- deviceLinks_copy[ i ] ).replace(
+ deviceLinksCopy[ i ] ).replace(
"src=",
"" ).replace(
"dst=",
@@ -836,7 +843,7 @@
for id in range( len( intentIdList ) ):
print "Removing intent id (round 1) :", intentIdList[ id ]
main.ONOScli1.removeIntent( intentId=intentIdList[ id ] )
- time.sleep( 1 )
+ #time.sleep( 1 )
main.log.info(
"Verify all intents are removed and if any leftovers try remove one more time" )
@@ -863,7 +870,7 @@
print "Removing intent id (round 2):", intentIdList1[ id ]
main.ONOScli1.removeIntent(
intentId=intentIdList1[ id ] )
- time.sleep( 2 )
+ #time.sleep( 2 )
else:
print "There are no more intents that need to be removed"
step1Result = main.TRUE
@@ -875,3 +882,281 @@
utilities.assert_equals( expect=main.TRUE, actual=caseResult7,
onpass="Intent removal test successful",
onfail="Intent removal test failed" )
+
+ def CASE11( self, main ):
+ """
+ Enable onos-app-ifwd, Verify Intent based Reactive forwarding through ping all and Disable it
+ """
+ import re
+ import copy
+ import time
+
+ main.log.report( "Enable Intent based Reactive forwarding and Verify ping all" )
+ main.log.report( "_____________________________________________________" )
+ main.case( "Enable Intent based Reactive forwarding and Verify ping all" )
+ main.step( "Enable intent based Reactive forwarding" )
+ installResult = main.TRUE
+ for i in range( 1, int( main.numCtrls ) + 1 ):
+ onosFeature = 'onos-app-ifwd'
+ ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
+ ONOScli = 'ONOScli' + str( i )
+ main.log.info( "Enabling Intent based Reactive forwarding on ONOS Node " + ONOS_ip )
+ exec "inResult=main." + ONOScli + ".featureInstall(onosFeature)"
+ time.sleep( 3 )
+ installResult = inResult and installResult
+
+ time.sleep( 5 )
+
+ main.step( "Verify Pingall" )
+ ping_result = main.FALSE
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ timeDiff = round( ( time2 - time1 ), 2 )
+ main.log.report(
+ "Time taken for Ping All: " +
+ str( timeDiff ) +
+ " seconds" )
+
+ if ping_result == main.TRUE:
+ main.log.report( "Pingall Test in Reactive mode successful" )
+ else:
+ main.log.report( "Pingall Test in Reactive mode failed" )
+
+ main.step( "Disable Intent based Reactive forwarding" )
+ uninstallResult = main.TRUE
+ for i in range( 1, int( main.numCtrls ) + 1 ):
+ onosFeature = 'onos-app-ifwd'
+ ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
+ ONOScli = 'ONOScli' + str( i )
+ main.log.info( "Disabling Intent based Reactive forwarding on ONOS Node " + ONOS_ip )
+ exec "unResult=main." + ONOScli + ".featureUninstall(onosFeature)"
+ uninstallResult = unResult and uninstallResult
+
+ # Waiting for reative flows to be cleared.
+ time.sleep( 10 )
+
+ case11Result = installResult and ping_result and uninstallResult
+ utilities.assert_equals( expect=main.TRUE, actual=case11Result,
+ onpass="Intent based Reactive forwarding Pingall test PASS",
+ onfail="Intent based Reactive forwarding Pingall test FAIL" )
+
+ def CASE12( self, main ):
+ """
+ This test script Loads a new Topology (Chordal) on CHO setup and balances all switches
+ """
+ import re
+ import time
+ import copy
+
+ newTopo = main.params['TOPO2']['topo']
+ main.numMNswitches = int ( main.params[ 'TOPO2' ][ 'numSwitches' ] )
+ main.numMNlinks = int ( main.params[ 'TOPO2' ][ 'numLinks' ] )
+ main.numMNhosts = int ( main.params[ 'TOPO2' ][ 'numHosts' ] )
+
+ main.log.report(
+ "Load Chordal topology and Balance all Mininet switches across controllers" )
+ main.log.report(
+ "________________________________________________________________________" )
+ # need to wait here for sometime until ONOS bootup
+ time.sleep( 15 )
+ main.case(
+ "Assign and Balance all Mininet switches across controllers" )
+ main.step( "Stop any previous Mininet network topology" )
+ stopStatus = main.Mininet1.stopNet()
+
+ # WORK AROUND FOR ONOS-581. STOP ONOS BEFORE ASSIGNING CONTROLLERS AT MININET & START ONCE DONE
+ main.step( "Stop ONOS on all Nodes" )
+ stopResult = main.TRUE
+ for i in range( 1, int( main.numCtrls ) + 1 ):
+ ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
+ main.log.info( "Stopping ONOS Node IP: " + ONOS_ip )
+ sresult = main.ONOSbench.onosStop( ONOS_ip )
+ utilities.assert_equals( expect=main.TRUE, actual=sresult,
+ onpass="Test step PASS",
+ onfail="Test step FAIL" )
+ stopResult = ( stopResult and sresult )
+
+ main.step( "Start Mininet with Chordal topology" )
+ startStatus = main.Mininet1.startNet(topoFile = newTopo)
+
+ main.step( "Assign switches to controllers" )
+ for i in range( 1, ( main.numMNswitches + 1 ) ): # 1 to ( num of switches +1 )
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ count=int( main.numCtrls ),
+ ip1=main.ONOS1_ip,
+ port1=main.ONOS1_port,
+ ip2=main.ONOS2_ip,
+ port2=main.ONOS2_port,
+ ip3=main.ONOS3_ip,
+ port3=main.ONOS3_port,
+ ip4=main.ONOS4_ip,
+ port4=main.ONOS4_port,
+ ip5=main.ONOS5_ip,
+ port5=main.ONOS5_port )
+
+ switch_mastership = main.TRUE
+ for i in range( 1, ( main.numMNswitches + 1 ) ):
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + main.ONOS1_ip, response ):
+ switch_mastership = switch_mastership and main.TRUE
+ else:
+ switch_mastership = main.FALSE
+
+ if switch_mastership == main.TRUE:
+ main.log.report( "Controller assignment successfull" )
+ else:
+ main.log.report( "Controller assignment failed" )
+ time.sleep( 5 )
+
+ main.step( "Start ONOS on all Nodes" )
+ startResult = main.TRUE
+ for i in range( 1, int( main.numCtrls ) + 1 ):
+ ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
+ main.log.info( "Starting ONOS Node IP: " + ONOS_ip )
+ sresult = main.ONOSbench.onosStart( ONOS_ip )
+ utilities.assert_equals( expect=main.TRUE, actual=sresult,
+ onpass="Test step PASS",
+ onfail="Test step FAIL" )
+ startResult = ( startResult and sresult )
+
+ main.step( "Start ONOS CLI on all nodes" )
+ cliResult = main.TRUE
+ #karafTimeout = "3600000" # This is not needed here as it is already set before.
+ # need to wait here sometime for ONOS to bootup.
+ time.sleep( 30 )
+ for i in range( 1, int( main.numCtrls ) + 1 ):
+ ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
+ ONOScli = 'ONOScli' + str( i )
+ main.log.info( "ONOS Node " + ONOS_ip + " cli start:" )
+ exec "startcli=main." + ONOScli + \
+ ".startOnosCli(ONOS_ip)"
+ utilities.assert_equals( expect=main.TRUE, actual=startcli,
+ onpass="Test step PASS",
+ onfail="Test step FAIL" )
+ cliResult = ( cliResult and startcli )
+
+ main.step( "Balance devices across controllers" )
+ for i in range( int( main.numCtrls ) ):
+ balanceResult = main.ONOScli1.balanceMasters()
+ # giving some breathing time for ONOS to complete re-balance
+ time.sleep( 3 )
+
+ case12Result = ( startResult and cliResult )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case12Result,
+ onpass="Starting new Chordal topology test PASS",
+ onfail="Starting new Chordal topology test FAIL" )
+
+ def CASE13( self, main ):
+ """
+ This test script Loads a new Topology (Spine) on CHO setup and balances all switches
+ """
+ import re
+ import time
+ import copy
+
+ newTopo = main.params['TOPO3']['topo']
+ main.numMNswitches = int ( main.params[ 'TOPO3' ][ 'numSwitches' ] )
+ main.numMNlinks = int ( main.params[ 'TOPO3' ][ 'numLinks' ] )
+ main.numMNhosts = int ( main.params[ 'TOPO3' ][ 'numHosts' ] )
+
+ main.log.report(
+ "Load Spine and Leaf topology and Balance all Mininet switches across controllers" )
+ main.log.report(
+ "________________________________________________________________________" )
+ # need to wait here for sometime until ONOS bootup
+ time.sleep( 15 )
+ main.case(
+ "Assign and Balance all Mininet switches across controllers" )
+ main.step( "Stop any previous Mininet network topology" )
+ stopStatus = main.Mininet1.stopNet()
+
+ # WORK AROUND FOR ONOS-581. STOP ONOS BEFORE ASSIGNING CONTROLLERS AT MININET & START ONCE DONE
+ main.step( "Stop ONOS on all Nodes" )
+ stopResult = main.TRUE
+ for i in range( 1, int( main.numCtrls ) + 1 ):
+ ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
+ main.log.info( "Stopping ONOS Node IP: " + ONOS_ip )
+ sresult = main.ONOSbench.onosStop( ONOS_ip )
+ utilities.assert_equals( expect=main.TRUE, actual=sresult,
+ onpass="Test step PASS",
+ onfail="Test step FAIL" )
+ stopResult = ( stopResult and sresult )
+
+ main.step( "Start Mininet with Spine topology" )
+ startStatus = main.Mininet1.startNet(topoFile = newTopo)
+
+ main.step( "Assign switches to controllers" )
+ for i in range( 1, ( main.numMNswitches + 1 ) ): # 1 to ( num of switches +1 )
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ count=int( main.numCtrls ),
+ ip1=main.ONOS1_ip,
+ port1=main.ONOS1_port,
+ ip2=main.ONOS2_ip,
+ port2=main.ONOS2_port,
+ ip3=main.ONOS3_ip,
+ port3=main.ONOS3_port,
+ ip4=main.ONOS4_ip,
+ port4=main.ONOS4_port,
+ ip5=main.ONOS5_ip,
+ port5=main.ONOS5_port )
+
+ switch_mastership = main.TRUE
+ for i in range( 1, ( main.numMNswitches + 1 ) ):
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + main.ONOS1_ip, response ):
+ switch_mastership = switch_mastership and main.TRUE
+ else:
+ switch_mastership = main.FALSE
+
+ if switch_mastership == main.TRUE:
+ main.log.report( "Controller assignment successfull" )
+ else:
+ main.log.report( "Controller assignment failed" )
+ time.sleep( 5 )
+
+ main.step( "Start ONOS on all Nodes" )
+ startResult = main.TRUE
+ for i in range( 1, int( main.numCtrls ) + 1 ):
+ ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
+ main.log.info( "Starting ONOS Node IP: " + ONOS_ip )
+ sresult = main.ONOSbench.onosStart( ONOS_ip )
+ utilities.assert_equals( expect=main.TRUE, actual=sresult,
+ onpass="Test step PASS",
+ onfail="Test step FAIL" )
+ startResult = ( startResult and sresult )
+
+ main.step( "Start ONOS CLI on all nodes" )
+ cliResult = main.TRUE
+ #karafTimeout = "3600000" # This is not needed here as it is already set before.
+ # need to wait here sometime for ONOS to bootup.
+ time.sleep( 30 )
+ for i in range( 1, int( main.numCtrls ) + 1 ):
+ ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
+ ONOScli = 'ONOScli' + str( i )
+ main.log.info( "ONOS Node " + ONOS_ip + " cli start:" )
+ exec "startcli=main." + ONOScli + \
+ ".startOnosCli(ONOS_ip)"
+ utilities.assert_equals( expect=main.TRUE, actual=startcli,
+ onpass="Test step PASS",
+ onfail="Test step FAIL" )
+ cliResult = ( cliResult and startcli )
+
+ main.step( "Balance devices across controllers" )
+ for i in range( int( main.numCtrls ) ):
+ balanceResult = main.ONOScli1.balanceMasters()
+ # giving some breathing time for ONOS to complete re-balance
+ time.sleep( 3 )
+
+ case13Result = ( startResult and cliResult )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case13Result,
+ onpass="Starting new Spine topology test PASS",
+ onfail="Starting new Spine topology test FAIL" )
diff --git a/TestON/tests/OnosCHO/OnosCHO.topo b/TestON/tests/OnosCHO/OnosCHO.topo
index 2a79611..b36c789 100644
--- a/TestON/tests/OnosCHO/OnosCHO.topo
+++ b/TestON/tests/OnosCHO/OnosCHO.topo
@@ -101,7 +101,7 @@
</ONOS5>
<Mininet1>
- <host>10.128.40.40</host>
+ <host>10.128.40.50</host>
<user>admin</user>
<password>onos_test</password>
<type>MininetCliDriver</type>
@@ -116,7 +116,7 @@
</Mininet1>
<Mininet2>
- <host>10.128.40.40</host>
+ <host>10.128.40.50</host>
<user>admin</user>
<password>onos_test</password>
<type>RemoteMininetDriver</type>
diff --git a/TestON/tests/OpticalFunc13/OpticalFunc13.params b/TestON/tests/OpticalFunc13/OpticalFunc13.params
new file mode 100755
index 0000000..173d48b
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/OpticalFunc13.params
@@ -0,0 +1,47 @@
+<PARAMS>
+
+ <testcases>1,21,22,23</testcases>
+
+ #Environment variables
+ <ENV>
+ <cellName>driver_test</cellName>
+ </ENV>
+
+ <CTRL>
+ <ip1>10.128.20.11</ip1>
+ <port1>6633</port1>
+ </CTRL>
+
+ <PING>
+ <source1>h8</source1>
+ <source2>h9</source2>
+ <source3>h10</source3>
+ <source4>h11</source4>
+ <source5>h12</source5>
+ <source6>h13</source6>
+ <source7>h14</source7>
+ <source8>h15</source8>
+ <source9>h16</source9>
+ <source10>h17</source10>
+ <target1>10.0.0.18</target1>
+ <target2>10.0.0.19</target2>
+ <target3>10.0.0.20</target3>
+ <target4>10.0.0.21</target4>
+ <target5>10.0.0.22</target5>
+ <target6>10.0.0.23</target6>
+ <target7>10.0.0.24</target7>
+ <target8>10.0.0.25</target8>
+ <target9>10.0.0.26</target9>
+ <target10>10.0.0.27</target10>
+ </PING>
+
+ <timers>
+ <LinkDiscovery>5</LinkDiscovery>
+ <SwitchDiscovery>31</SwitchDiscovery>
+ </timers>
+
+ <OPTICAL>
+ <jsonfile> /home/admin/ONOS/tools/test/topos/oe-nonlinear-4.json </jsonfile>
+ </OPTICAL>
+
+</PARAMS>
diff --git a/TestON/tests/OpticalFunc13/OpticalFunc13.py b/TestON/tests/OpticalFunc13/OpticalFunc13.py
new file mode 100755
index 0000000..7ddd532
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/OpticalFunc13.py
@@ -0,0 +1,248 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import sys
+import os
+import re
+import time
+import json
+
+time.sleep(1)
+class OpticalFunc13:
+ def __init__(self):
+ self.default = ''
+
+ def CASE1(self, main):
+ '''
+ Startup sequence:
+ git pull
+ mvn clean install
+ onos-package
+ cell <name>
+ onos-verify-cell
+ onos-install -f
+ onos-wait-for-start
+ '''
+
+ cell_name = main.params['ENV']['cellName']
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS1_port = main.params['CTRL']['port1']
+
+ main.case("Setting up test environment")
+
+ main.step("Git checkout and pull master and get version")
+ main.ONOSbench.git_checkout("master")
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ version_result = main.ONOSbench.get_version()
+ main.log.report(main.ONOSbench.get_version())
+ if git_pull_result == 1:
+ main.step("Using mvn clean & install")
+ clean_install_result = main.ONOSbench.clean_install()
+ #clean_install_result = main.TRUE
+
+ main.step("Applying cell variable to environment")
+ cell_result1 = main.ONOSbench.set_cell(cell_name)
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result2 = main.ONOS2.set_cell(cell_name)
+ #verify_result = main.ONOS2.verify_cell()
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ cell_result = cell_result1 and cell_result2
+
+ main.step("Creating ONOS package")
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step("Creating a cell")
+ #cell_create_result = main.ONOSbench.create_cell_file(**************)
+
+ main.step("Installing ONOS package")
+ onos_install_result = main.ONOSbench.onos_install()
+ onos1_isup = main.ONOSbench.isup()
+
+ main.step("Starting ONOS service")
+ start_result = main.ONOSbench.onos_start(ONOS1_ip)
+
+ case1_result = (package_result and\
+ cell_result and verify_result and onos_install_result and\
+ onos1_isup and start_result )
+ utilities.assert_equals(expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful")
+
+ def CASE11(self, main):
+ '''
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Cleaning up test environment")
+
+ main.step("Testing ONOS kill function")
+ kill_result = main.ONOSbench.onos_kill(ONOS1_ip)
+
+ main.step("Stopping ONOS service")
+ stop_result = main.ONOSbench.onos_stop(ONOS1_ip)
+
+ main.step("Uninstalling ONOS service")
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+
+ def CASE21(self, main):
+ import time
+ '''
+ On ONOS bench, run this command: ./~/ONOS/tools/test/bin/onos-topo-cfg
+ which starts the rest and copies the links json file to the onos instance
+ Note that in case of Packet Optical, the links are not learnt from the topology, instead the links are learnt
+ from the json config file
+ '''
+ main.log.report("This testcase starts the packet layer topology and REST")
+ main.log.report("_____________________________________________")
+ sart_console_result = main.LincOE1.start_console()
+ optical_mn_script = main.LincOE2.run_optical_mn_script()
+ onos_topo_cfg_result = main.ONOSbench.run_onos_topo_cfg(instance_name = main.params['CTRL']['ip1'], json_file = main.params['OPTICAL']['jsonfile'])
+
+
+
+ def CASE22(self, main):
+ '''
+ Curretly we use, 4 linear switch optical topology and 2 packet layer mininet switches each with one host.
+ Therefore, the roadmCount variable = 4, packetLayerSWCount variable = 2, hostCount =2
+ and this is hardcoded in the testcase. If the topology changes, these hardcoded values need to be changed
+ '''
+
+ main.log.report("This testcase compares the optical+packet topology against what is expected")
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+ devices_result = main.ONOS2.devices(json_format = False)
+
+ print "devices_result = ", devices_result
+ devices_linewise = devices_result.split("\n")
+ devices_linewise = devices_linewise[1:-1]
+ roadmCount = 0
+ packetLayerSWCount = 0
+ for line in devices_linewise:
+ components = line.split(",")
+ availability = components[1].split("=")[1]
+ type = components[3].split("=")[1]
+ if availability == 'true' and type == 'ROADM':
+ roadmCount += 1
+ elif availability == 'true' and type =='SWITCH':
+ packetLayerSWCount += 1
+ if roadmCount == 4:
+ print "Number of Optical Switches = %d and is correctly detected" %roadmCount
+ main.log.info ("Number of Optical Switches = " +str(roadmCount) +" and is correctly detected")
+ opticalSW_result = main.TRUE
+ else:
+ print "Number of Optical Switches = %d and is wrong" %roadCount
+ main.log.info ("Number of Optical Switches = " +str(roadmCount) +" and is wrong")
+ opticalSW_result = main.FALSE
+
+ if packetLayerSWCount == 2:
+ print "Number of Packet layer or mininet Switches = %d and is correctly detected" %packetLayerSWCount
+ main.log.info("Number of Packet layer or mininet Switches = " +str(packetLayerSWCount) + " and is correctly detected")
+ packetSW_result = main.TRUE
+ else:
+ print "Number of Packet layer or mininet Switches = %d and is wrong" %packetLayerSWCount
+ main.log.info("Number of Packet layer or mininet Switches = " +str(packetLayerSWCount) + " and is wrong")
+ packetSW_result = main.FALSE
+ print "_________________________________"
+
+ links_result = main.ONOS2.links(json_format = False)
+ print "links_result = ", links_result
+ print "_________________________________"
+
+
+
+ #Discover hosts using pingall
+ pingall_result = main.LincOE2.pingall()
+
+ hosts_result = main.ONOS2.hosts(json_format = False)
+ print "hosts_result = ", hosts_result
+ print "_________________________________"
+ hosts_linewise = hosts_result.split("\n")
+ hosts_linewise = hosts_linewise[1:-1]
+ hostCount = 0
+ for line in hosts_linewise:
+ hostid = line.split(",")[0].split("=")[1]
+ hostCount +=1
+ if hostCount ==2:
+ print "Number of hosts = %d and is correctly detected" %hostCount
+ main.log.info("Number of hosts = " + str(hostCount) +" and is correctly detected")
+ hostDiscovery = main.TRUE
+ else:
+ print "Number of hosts = %d and is wrong" %hostCount
+ main.log.info("Number of hosts = " + str(hostCount) +" and is wrong")
+ hostDiscovery = main.FALSE
+
+ case22_result = opticalSW_result and packetSW_result and hostDiscovery
+ utilities.assert_equals(expect=main.TRUE, actual=case22_result,
+ onpass="Packet optical topology discovery successful",
+ onfail="Packet optical topology discovery failed")
+
+ def CASE23(self, main):
+ import time
+ '''
+ Add bidirectional point intents between 2 packet layer(mininet) devices and
+ ping mininet hosts
+ '''
+ main.log.report("This testcase adds bidirectional point intents between 2 packet layer(mininet) devices and ping mininet hosts")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000ffffffff0001", 1, "of:0000ffffffff0002", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000ffffffff0002", 1, "of:0000ffffffff0001", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ time.sleep(10)
+ flowHandle = main.ONOS2.flows()
+ #print "flowHandle = ", flowHandle
+ main.log.info("flows :" + flowHandle)
+ intentHandle = main.ONOS2.intents()
+ main.log.info("intents :" + intentHandle)
+
+ Ping_Result = main.TRUE
+ count = 1
+ main.log.info("\n\nh1 is Pinging h2")
+ ping = main.LincOE2.pingHostOptical(src="h1", target="h2")
+ #ping = main.LincOE2.pinghost()
+ if ping == main.FALSE and count<5:
+ count+=1
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h1 and h2 failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ ping = main.LincOE2.pingHostOptical(src="h1", target="h2")
+ #ping = main.LincOE2.pinghost()
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h1 and h2 have failed")
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h1 and h2 passed!")
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+
+ if Ping_Result==main.FALSE:
+ main.log.report("Point intents for packet optical have not ben installed correctly. Cleaning up")
+ if Ping_Result==main.TRUE:
+ main.log.report("Point Intents for packet optical have been installed correctly")
+
+ case23_result = Ping_Result
+ utilities.assert_equals(expect=main.TRUE, actual=case23_result,
+ onpass="Point intents addition for packet optical and Pingall Test successful",
+ onfail="Point intents addition for packet optical and Pingall Test NOT successful")
+
+
diff --git a/TestON/tests/OpticalFunc13/OpticalFunc13.topo b/TestON/tests/OpticalFunc13/OpticalFunc13.topo
new file mode 100755
index 0000000..a3d6cfd
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/OpticalFunc13.topo
@@ -0,0 +1,94 @@
+<TOPOLOGY>
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1>
+ <host>10.128.10.11</host>
+ <user>sdn</user>
+ <password>sdn</password>
+ <type>OnosDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <Mininet1>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>MininetCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow13 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet1>
+
+ <Mininet2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow13 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet2>
+
+ <LincOE1>
+ <host>10.128.20.30</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>LincOEDriver</type>
+ <connect_order>6</connect_order>
+ <COMPONENTS>
+ <arg1> </arg1>
+ </COMPONENTS>
+ </LincOE1>
+
+ <LincOE2>
+ <host>10.128.20.30</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>7</connect_order>
+ <COMPONENTS>
+ <arg1> sudo python /home/admin/optical.py </arg1>
+ <arg2> </arg2>
+ </COMPONENTS>
+ </LincOE2>
+
+ <LincOE3>
+ <host>10.128.20.30</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>8</connect_order>
+ </LincOE3>
+
+
+ </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/OpticalFunc13/__init__.py b/TestON/tests/OpticalFunc13/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/__init__.py
diff --git a/TestON/tests/PingallExample/PingallExample.py b/TestON/tests/PingallExample/PingallExample.py
index bb2b1cf..653397e 100644
--- a/TestON/tests/PingallExample/PingallExample.py
+++ b/TestON/tests/PingallExample/PingallExample.py
@@ -94,6 +94,14 @@
if case1Result == main.FALSE:
main.cleanup()
main.exit()
+
+ # Starting the mininet using the old way
+ main.step( "Starting Mininet ..." )
+ netIsUp = main.Mininet1.startNet()
+ if netIsUp:
+ main.log.info("Mininet CLI is up")
+ else:
+ main.log.info("Mininet CLI is down")
def CASE2( self, main ):
"""
diff --git a/TestON/tests/ProdFunc/ProdFunc.params b/TestON/tests/ProdFunc/ProdFunc.params
index 2d1f421..1189301 100755
--- a/TestON/tests/ProdFunc/ProdFunc.params
+++ b/TestON/tests/ProdFunc/ProdFunc.params
@@ -1,6 +1,6 @@
<PARAMS>
- <testcases>1,4,9</testcases>
+ <testcases>1,4,10,5,6,7,8,9,2,8,20,21,22,10,23,24</testcases>
#Environment variables
<ENV>
<cellName>driver_test</cellName>
diff --git a/TestON/tests/ProdFunc/ProdFunc.py b/TestON/tests/ProdFunc/ProdFunc.py
index b2797f3..5e31df3 100755
--- a/TestON/tests/ProdFunc/ProdFunc.py
+++ b/TestON/tests/ProdFunc/ProdFunc.py
@@ -43,8 +43,8 @@
main.step( "Removing raft logs before a clen installation of ONOS" )
main.ONOSbench.onosRemoveRaftLogs()
- main.step( "Git checkout and pull master and get version" )
- main.ONOSbench.gitCheckout( "master" )
+ main.step( "Git checkout and get version" )
+ #main.ONOSbench.gitCheckout( "master" )
gitPullResult = main.ONOSbench.gitPull()
main.log.info( "git_pull_result = " + gitPullResult )
main.ONOSbench.getVersion( report=True )
diff --git a/TestON/tests/ProdFunc/ProdFunc.py.fixed b/TestON/tests/ProdFunc/ProdFunc.py.fixed
new file mode 100644
index 0000000..6f4b72b
--- /dev/null
+++ b/TestON/tests/ProdFunc/ProdFunc.py.fixed
@@ -0,0 +1,1395 @@
+
+# Testing the basic functionality of ONOS Next
+# For sanity and driver functionality excercises only.
+
+import time
+# import sys
+# import os
+# import re
+import json
+
+time.sleep( 1 )
+
+
+class ProdFunc:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE1( self, main ):
+ """
+ Startup sequence:
+ cell <name>
+ onos-verify-cell
+ onos-remove-raft-log
+ git pull
+ mvn clean install
+ onos-package
+ onos-install -f
+ onos-wait-for-start
+ """
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ main.case( "Setting up test environment" )
+ main.log.report(
+ "This testcase is testing setting up test environment" )
+ main.log.report( "__________________________________" )
+
+ main.step( "Applying cell variable to environment" )
+ cellResult = main.ONOSbench.setCell( cellName )
+ verifyResult = main.ONOSbench.verifyCell()
+
+ main.step( "Removing raft logs before a clen installation of ONOS" )
+ main.ONOSbench.onosRemoveRaftLogs()
+
+ main.step( "Git checkout and pull master and get version" )
+ main.ONOSbench.gitCheckout( "master" )
+ gitPullResult = main.ONOSbench.gitPull()
+ main.log.info( "git_pull_result = " + gitPullResult )
+ main.ONOSbench.getVersion( report=True )
+
+ if gitPullResult == 1:
+ main.step( "Using mvn clean & install" )
+ main.ONOSbench.cleanInstall()
+ elif gitPullResult == 0:
+ main.log.report(
+ "Git Pull Failed, look into logs for detailed reason" )
+ main.cleanup()
+ main.exit()
+
+ main.step( "Creating ONOS package" )
+ packageResult = main.ONOSbench.onosPackage()
+
+ main.step( "Installing ONOS package" )
+ onosInstallResult = main.ONOSbench.onosInstall()
+ if onosInstallResult == main.TRUE:
+ main.log.report( "Installing ONOS package successful" )
+ else:
+ main.log.report( "Installing ONOS package failed" )
+
+ onos1Isup = main.ONOSbench.isup()
+ if onos1Isup == main.TRUE:
+ main.log.report( "ONOS instance is up and ready" )
+ else:
+ main.log.report( "ONOS instance may not be up" )
+
+ main.step( "Starting ONOS service" )
+ startResult = main.ONOSbench.onosStart( ONOS1Ip )
+
+ main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+
+ case1Result = ( packageResult and
+ cellResult and verifyResult
+ and onosInstallResult and
+ onos1Isup and startResult )
+ utilities.assert_equals( expect=main.TRUE, actual=case1Result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful" )
+
+ def CASE2( self, main ):
+ """
+ Switch Down
+ """
+ # NOTE: You should probably run a topology check after this
+ import time
+
+ main.case( "Switch down discovery" )
+ main.log.report( "This testcase is testing a switch down discovery" )
+ main.log.report( "__________________________________" )
+
+ switchSleep = int( main.params[ 'timers' ][ 'SwitchDiscovery' ] )
+
+ description = "Killing a switch to ensure it is discovered correctly"
+ main.log.report( description )
+ main.case( description )
+
+ # TODO: Make this switch parameterizable
+ main.step( "Kill s28 " )
+ main.log.report( "Deleting s28" )
+ # FIXME: use new dynamic topo functions
+ main.Mininet1.delSwitch( "s28" )
+ main.log.info(
+ "Waiting " +
+ str( switchSleep ) +
+ " seconds for switch down to be discovered" )
+ time.sleep( switchSleep )
+ # Peek at the deleted switch
+ device = main.ONOS2.getDevice( dpid="0028" )
+ print "device = ", device
+ if device[ u'available' ] == 'False':
+ case2Result = main.FALSE
+ else:
+ case2Result = main.TRUE
+ utilities.assert_equals( expect=main.TRUE, actual=case2Result,
+ onpass="Switch down discovery successful",
+ onfail="Switch down discovery failed" )
+
+ def CASE11( self, main ):
+ """
+ Cleanup sequence:
+ onos-service <nodeIp> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ """
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ main.case( "Cleaning up test environment" )
+
+ main.step( "Testing ONOS kill function" )
+ killResult = main.ONOSbench.onosKill( ONOS1Ip )
+
+ main.step( "Stopping ONOS service" )
+ stopResult = main.ONOSbench.onosStop( ONOS1Ip )
+
+ main.step( "Uninstalling ONOS service" )
+ uninstallResult = main.ONOSbench.onosUninstall()
+
+ case11Result = killResult and stopResult and uninstallResult
+ utilities.assert_equals( expect=main.TRUE, actual=case11Result,
+ onpass="Cleanup successful",
+ onfail="Cleanup failed" )
+
+ def CASE3( self, main ):
+ """
+ Test 'onos' command and its functionality in driver
+ """
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ main.case( "Testing 'onos' command" )
+
+ main.step( "Sending command 'onos -w <onos-ip> system:name'" )
+ cmdstr1 = "system:name"
+ cmdResult1 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmdResult1 )
+
+ main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
+ cmdstr2 = "onos:topology"
+ cmdResult2 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmdResult2 )
+
+ def CASE20( self ):
+ """
+ Exit from mininet cli
+ reinstall ONOS
+ """
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ main.log.report( "This testcase exits the mininet cli and reinstalls\
+ ONOS to switch over to Packet Optical topology" )
+ main.log.report( "_____________________________________________" )
+ main.case( "Disconnecting mininet and restarting ONOS" )
+ main.step( "Disconnecting mininet and restarting ONOS" )
+ mininetDisconnect = main.Mininet1.disconnect()
+
+ main.step( "Removing raft logs before a clen installation of ONOS" )
+ main.ONOSbench.onosRemoveRaftLogs()
+
+ main.step( "Applying cell variable to environment" )
+ cellResult = main.ONOSbench.setCell( cellName )
+ verifyResult = main.ONOSbench.verifyCell()
+
+ onosInstallResult = main.ONOSbench.onosInstall()
+ if onosInstallResult == main.TRUE:
+ main.log.report( "Installing ONOS package successful" )
+ else:
+ main.log.report( "Installing ONOS package failed" )
+
+ onos1Isup = main.ONOSbench.isup()
+ if onos1Isup == main.TRUE:
+ main.log.report( "ONOS instance is up and ready" )
+ else:
+ main.log.report( "ONOS instance may not be up" )
+
+ main.step( "Starting ONOS service" )
+ startResult = main.ONOSbench.onosStart( ONOS1Ip )
+
+ main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+ case20Result = mininetDisconnect and cellResult and verifyResult \
+ and onosInstallResult and onos1Isup and \
+ startResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case20Result,
+ onpass="Exiting functionality mininet topology and reinstalling \
+ ONOS successful",
+ onfail="Exiting functionality mininet topology and reinstalling \
+ ONOS failed" )
+
+ def CASE21( self, main ):
+ """
+ On ONOS bench, run this command:
+ ./~/ONOS/tools/test/bin/onos-topo-cfg
+ which starts the rest and copies the links
+ json file to the onos instance.
+ Note that in case of Packet Optical, the links are not learnt
+ from the topology, instead the links are learnt
+ from the json config file
+ """
+ main.log.report(
+ "This testcase starts the packet layer topology and REST" )
+ main.log.report( "_____________________________________________" )
+ main.case( "Starting LINC-OE and other components" )
+ main.step( "Starting LINC-OE and other components" )
+ startConsoleResult = main.LincOE1.startConsole()
+ opticalMnScript = main.LincOE2.runOpticalMnScript()
+ onosTopoCfgResult = main.ONOSbench.runOnosTopoCfg(
+ instanceName=main.params[ 'CTRL' ][ 'ip1' ],
+ jsonFile=main.params[ 'OPTICAL' ][ 'jsonfile' ] )
+
+ print "start_console_result =", startConsoleResult
+ print "optical_mn_script = ", opticalMnScript
+ print "onos_topo_cfg_result =", onosTopoCfgResult
+
+ case21Result = startConsoleResult and opticalMnScript and \
+ onosTopoCfgResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case21Result,
+ onpass="Packet optical topology spawned successsfully",
+ onfail="Packet optical topology spawning failed" )
+
+ def CASE22( self, main ):
+ """
+ Curretly we use, 4 linear switch optical topology and
+ 2 packet layer mininet switches each with one host.
+ Therefore, the roadmCount variable = 4,
+ packetLayerSWCount variable = 2 and hostCount = 2
+ and this is hardcoded in the testcase. If the topology changes,
+ these hardcoded values need to be changed
+ """
+ main.log.report(
+ "This testcase compares the optical+packet topology against what\
+ is expected" )
+ main.case( "Topology comparision" )
+ main.step( "Topology comparision" )
+ main.ONOS3.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+ devicesResult = main.ONOS3.devices( jsonFormat=False )
+
+ print "devices_result = ", devicesResult
+ devicesLinewise = devicesResult.split( "\n" )
+ devicesLinewise = devicesLinewise[ 1:-1 ]
+ roadmCount = 0
+ packetLayerSWCount = 0
+ for line in devicesLinewise:
+ components = line.split( "," )
+ availability = components[ 1 ].split( "=" )[ 1 ]
+ type = components[ 3 ].split( "=" )[ 1 ]
+ if availability == 'true' and type == 'ROADM':
+ roadmCount += 1
+ elif availability == 'true' and type == 'SWITCH':
+ packetLayerSWCount += 1
+ if roadmCount == 4:
+ print "Number of Optical Switches = %d and is \
+ correctly detected" % roadmCount
+ main.log.info(
+ "Number of Optical Switches = " +
+ str( roadmCount ) +
+ " and is correctly detected" )
+ opticalSWResult = main.TRUE
+ else:
+ print "Number of Optical Switches = %d and is wrong" % roadmCount
+ main.log.info(
+ "Number of Optical Switches = " +
+ str( roadmCount ) +
+ " and is wrong" )
+ opticalSWResult = main.FALSE
+
+ if packetLayerSWCount == 2:
+ print "Number of Packet layer or mininet Switches = %d and \
+ is correctly detected" % packetLayerSWCount
+ main.log.info(
+ "Number of Packet layer or mininet Switches = " +
+ str( packetLayerSWCount ) +
+ " and is correctly detected" )
+ packetSWResult = main.TRUE
+ else:
+ print "Number of Packet layer or mininet Switches = %d and \
+ is wrong" % packetLayerSWCount
+ main.log.info(
+ "Number of Packet layer or mininet Switches = " +
+ str( packetLayerSWCount ) +
+ " and is wrong" )
+ packetSWResult = main.FALSE
+ print "_________________________________"
+
+ linksResult = main.ONOS3.links( jsonFormat=False )
+ print "links_result = ", linksResult
+ print "_________________________________"
+
+ # NOTE:Since only point intents are added, there is no
+ # requirement to discover the hosts
+ # Therfore, the below portion of the code is commented.
+ """
+ #Discover hosts using pingall
+ pingallResult = main.LincOE2.pingall()
+
+ hostsResult = main.ONOS3.hosts( jsonFormat=False )
+ main.log.info( "hosts_result = "+hostsResult )
+ main.log.info( "_________________________________" )
+ hostsLinewise = hostsResult.split( "\n" )
+ hostsLinewise = hostsLinewise[ 1:-1 ]
+ hostCount = 0
+ for line in hostsLinewise:
+ hostid = line.split( "," )[ 0 ].split( "=" )[ 1 ]
+ hostCount +=1
+ if hostCount ==2:
+ print "Number of hosts = %d and is correctly detected" %hostCount
+ main.log.info( "Number of hosts = " + str( hostCount ) +" and \
+ is correctly detected" )
+ hostDiscovery = main.TRUE
+ else:
+ print "Number of hosts = %d and is wrong" %hostCount
+ main.log.info( "Number of hosts = " + str( hostCount ) +" and \
+ is wrong" )
+ hostDiscovery = main.FALSE
+ """
+ case22Result = opticalSWResult and packetSWResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case22Result,
+ onpass="Packet optical topology discovery successful",
+ onfail="Packet optical topology discovery failed" )
+
+ def CASE23( self, main ):
+ import time
+ """
+ Add bidirectional point intents between 2 packet layer( mininet )
+ devices and
+ ping mininet hosts
+ """
+ main.log.report(
+ "This testcase adds bidirectional point intents between 2 \
+ packet layer( mininet ) devices and ping mininet hosts" )
+ main.case( "Topology comparision" )
+ main.step( "Adding point intents" )
+ ptpIntentResult = main.ONOS3.addPointIntent(
+ "of:0000ffffffff0001/1",
+ "of:0000ffffffff0002/1" )
+ if ptpIntentResult == main.TRUE:
+ main.ONOS3.intents( jsonFormat=False )
+ main.log.info( "Point to point intent install successful" )
+
+ ptpIntentResult = main.ONOS3.addPointIntent(
+ "of:0000ffffffff0002/1",
+ "of:0000ffffffff0001/1" )
+ if ptpIntentResult == main.TRUE:
+ main.ONOS3.intents( jsonFormat=False )
+ main.log.info( "Point to point intent install successful" )
+
+ time.sleep( 10 )
+ flowHandle = main.ONOS3.flows()
+ main.log.info( "flows :" + flowHandle )
+
+ # Sleep for 30 seconds to provide time for the intent state to change
+ time.sleep( 30 )
+ intentHandle = main.ONOS3.intents( jsonFormat=False )
+ main.log.info( "intents :" + intentHandle )
+
+ PingResult = main.TRUE
+ count = 1
+ main.log.info( "\n\nh1 is Pinging h2" )
+ ping = main.LincOE2.pingHostOptical( src="h1", target="h2" )
+ # ping = main.LincOE2.pinghost()
+ if ping == main.FALSE and count < 5:
+ count += 1
+ PingResult = main.FALSE
+ main.log.info(
+ "Ping between h1 and h2 failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.info( "All ping attempts between h1 and h2 have failed" )
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h1 and h2 passed!" )
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+
+ if PingResult == main.FALSE:
+ main.log.report(
+ "Point intents for packet optical have not ben installed\
+ correctly. Cleaning up" )
+ if PingResult == main.TRUE:
+ main.log.report(
+ "Point Intents for packet optical have been\
+ installed correctly" )
+
+ case23Result = PingResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case23Result,
+ onpass="Point intents addition for packet optical and\
+ Pingall Test successful",
+ onfail="Point intents addition for packet optical and\
+ Pingall Test NOT successful" )
+
+ def CASE24( self, main ):
+ import time
+ import json
+ """
+ Test Rerouting of Packet Optical by bringing a port down
+ ( port 22 ) of a switch( switchID=1 ), so that link
+ ( between switch1 port22 - switch4-port30 ) is inactive
+ and do a ping test. If rerouting is successful,
+ ping should pass. also check the flows
+ """
+ main.log.report(
+ "This testcase tests rerouting and pings mininet hosts" )
+ main.case( "Test rerouting and pings mininet hosts" )
+ main.step( "Bring a port down and verify the link state" )
+ main.LincOE1.portDown( swId="1", ptId="22" )
+ linksNonjson = main.ONOS3.links( jsonFormat=False )
+ main.log.info( "links = " + linksNonjson )
+
+ links = main.ONOS3.links()
+ main.log.info( "links = " + links )
+
+ linksResult = json.loads( links )
+ linksStateResult = main.FALSE
+ for item in linksResult:
+ if item[ 'src' ][ 'device' ] == "of:0000ffffffffff01" and item[
+ 'src' ][ 'port' ] == "22":
+ if item[ 'dst' ][ 'device' ] == "of:0000ffffffffff04" and item[
+ 'dst' ][ 'port' ] == "30":
+ linksState = item[ 'state' ]
+ if linksState == "INACTIVE":
+ main.log.info(
+ "Links state is inactive as expected due to one \
+ of the ports being down" )
+ main.log.report(
+ "Links state is inactive as expected due to one \
+ of the ports being down" )
+ linksStateResult = main.TRUE
+ break
+ else:
+ main.log.info(
+ "Links state is not inactive as expected" )
+ main.log.report(
+ "Links state is not inactive as expected" )
+ linksStateResult = main.FALSE
+
+ print "links_state_result = ", linksStateResult
+ time.sleep( 10 )
+ flowHandle = main.ONOS3.flows()
+ main.log.info( "flows :" + flowHandle )
+
+ main.step( "Verify Rerouting by a ping test" )
+ PingResult = main.TRUE
+ count = 1
+ main.log.info( "\n\nh1 is Pinging h2" )
+ ping = main.LincOE2.pingHostOptical( src="h1", target="h2" )
+ # ping = main.LincOE2.pinghost()
+ if ping == main.FALSE and count < 5:
+ count += 1
+ PingResult = main.FALSE
+ main.log.info(
+ "Ping between h1 and h2 failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.info( "All ping attempts between h1 and h2 have failed" )
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h1 and h2 passed!" )
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+
+ if PingResult == main.TRUE:
+ main.log.report( "Ping test successful " )
+ if PingResult == main.FALSE:
+ main.log.report( "Ping test failed" )
+
+ case24Result = PingResult and linksStateResult
+ utilities.assert_equals( expect=main.TRUE, actual=case24Result,
+ onpass="Packet optical rerouting successful",
+ onfail="Packet optical rerouting failed" )
+
+ def CASE4( self, main ):
+ import re
+ import time
+ main.log.report( "This testcase is testing the assignment of \
+ all the switches to all the controllers and \
+ discovering the hists in reactive mode" )
+ main.log.report( "__________________________________" )
+ main.case( "Pingall Test" )
+ main.step( "Assigning switches to controllers" )
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
+ for i in range( 1, 29 ):
+ if i == 1:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ elif i >= 2 and i < 5:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ elif i >= 5 and i < 8:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ elif i >= 8 and i < 18:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ elif i >= 18 and i < 28:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ else:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ SwitchMastership = main.TRUE
+ for i in range( 1, 29 ):
+ if i == 1:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ elif i >= 2 and i < 5:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ elif i >= 5 and i < 8:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ elif i >= 8 and i < 18:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ elif i >= 18 and i < 28:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ else:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is" + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+
+ if SwitchMastership == main.TRUE:
+ main.log.report( "Controller assignmnet successful" )
+ else:
+ main.log.report( "Controller assignmnet failed" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=SwitchMastership,
+ onpass="MasterControllers assigned correctly" )
+ """
+ for i in range ( 1,29 ):
+ main.Mininet1.assignSwController( sw=str( i ),count=5,
+ ip1=ONOS1Ip,port1=ONOS1Port,
+ ip2=ONOS2Ip,port2=ONOS2Port,
+ ip3=ONOS3Ip,port3=ONOS3Port,
+ ip4=ONOS4Ip,port4=ONOS4Port,
+ ip5=ONOS5Ip,port5=ONOS5Port )
+ """
+ # REACTIVE FWD test
+
+ main.step( "Get list of hosts from Mininet" )
+ hostList = main.Mininet1.getHosts()
+ main.log.info( hostList )
+
+ main.step( "Get host list in ONOS format" )
+ hostOnosList = main.ONOS2.getHostsId( hostList )
+ main.log.info( hostOnosList )
+ # time.sleep( 5 )
+
+ main.step( "Pingall" )
+ pingResult = main.FALSE
+ while pingResult == main.FALSE:
+ time1 = time.time()
+ pingResult = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % ( time2 - time1 )
+
+ # Start onos cli again because u might have dropped out of
+ # onos prompt to the shell prompt
+ # if there was no activity
+ main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+
+ case4Result = SwitchMastership and pingResult
+ if pingResult == main.TRUE:
+ main.log.report( "Pingall Test in reactive mode to \
+ discover the hosts successful" )
+ else:
+ main.log.report( "Pingall Test in reactive mode to \
+ discover the hosts failed" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case4Result,
+ onpass="Controller assignment and Pingall Test successful",
+ onfail="Controller assignment and Pingall Test NOT successful" )
+
+ def CASE10( self ):
+ main.log.report(
+ "This testcase uninstalls the reactive forwarding app" )
+ main.log.report( "__________________________________" )
+ main.case( "Uninstalling reactive forwarding app" )
+ # Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstallResult = main.ONOS2.featureUninstall( "onos-app-fwd" )
+ main.log.info( "onos-app-fwd uninstalled" )
+
+ # After reactive forwarding is disabled, the reactive flows on
+ # switches timeout in 10-15s
+ # So sleep for 15s
+ time.sleep( 15 )
+
+ flows = main.ONOS2.flows()
+ main.log.info( flows )
+
+ case10Result = appUninstallResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case10Result,
+ onpass="Reactive forwarding app uninstallation successful",
+ onfail="Reactive forwarding app uninstallation failed" )
+
+ def CASE6( self ):
+ main.log.report( "This testcase is testing the addition of \
+ host intents and then does pingall" )
+ main.log.report( "__________________________________" )
+ main.case( "Obtaining host id's" )
+ main.step( "Get hosts" )
+ hosts = main.ONOS2.hosts()
+ main.log.info( hosts )
+
+ main.step( "Get all devices id" )
+ devicesIdList = main.ONOS2.getAllDevicesId()
+ main.log.info( devicesIdList )
+
+ # ONOS displays the hosts in hex format unlike mininet which does
+ # in decimal format
+ # So take care while adding intents
+ """
+ main.step( "Add host-to-host intents for mininet hosts h8 and h18 or
+ ONOS hosts h8 and h12" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+ print "______________________________________________________"
+ """
+ for i in range( 8, 18 ):
+ main.log.info(
+ "Adding host intent between h" + str( i ) +
+ " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ # NOTE: get host can return None
+ # TODO: handle this
+ host1Id = main.ONOS2.getHost( host1 )[ 'id' ]
+ host2Id = main.ONOS2.getHost( host2 )[ 'id' ]
+ main.ONOS2.addHostIntent( host1Id, host2Id )
+
+ time.sleep( 10 )
+ hIntents = main.ONOS2.intents( jsonFormat=False )
+ main.log.info( "intents:" + hIntents )
+ main.ONOS2.flows()
+
+ count = 1
+ i = 8
+ PingResult = main.TRUE
+ # while i<10:
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ # i = 8
+ PingResult = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+ if PingResult == main.FALSE:
+ main.log.report(
+ "Ping all test after Host intent addition failed. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if PingResult == main.TRUE:
+ main.log.report(
+ "Ping all test after Host intent addition successful" )
+
+ case6Result = PingResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case6Result,
+ onpass="Pingall Test after Host intents addition successful",
+ onfail="Pingall Test after Host intents addition failed" )
+
+ def CASE5( self, main ):
+ import json
+ # assumes that sts is already in you PYTHONPATH
+ from sts.topology.testonTopology import TestONTopology
+ # main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+ main.log.report( "This testcase is testing if all ONOS nodes \
+ are in topology sync with mininet" )
+ main.log.report( "__________________________________" )
+ main.case( "Comparing Mininet topology with the topology of ONOS" )
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ TopologyCheck = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+ devicesJson = main.ONOS2.devices()
+ linksJson = main.ONOS2.links()
+ # portsJson = main.ONOS2.ports()
+
+ result1 = main.Mininet1.compareSwitches(
+ MNTopo,
+ json.loads( devicesJson ) )
+ result2 = main.Mininet1.compareLinks(
+ MNTopo,
+ json.loads( linksJson ) )
+ # result3 = main.Mininet1.comparePorts(
+ # MNTopo, json.loads( portsJson ) )
+
+ # result = result1 and result2 and result3
+ result = result1 and result2
+
+ print "***********************"
+ if result == main.TRUE:
+ main.log.report( "ONOS" + " Topology matches MN Topology" )
+ else:
+ main.log.report( "ONOS" + " Topology does not match MN Topology" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=result,
+ onpass="ONOS" +
+ " Topology matches MN Topology",
+ onfail="ONOS" +
+ " Topology does not match MN Topology" )
+
+ TopologyCheck = TopologyCheck and result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=TopologyCheck,
+ onpass="Topology checks passed",
+ onfail="Topology checks failed" )
+
+ def CASE7( self, main ):
+ from sts.topology.testonTopology import TestONTopology
+
+ linkSleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+
+ main.log.report( "This testscase is killing a link to ensure that \
+ link discovery is consistent" )
+ main.log.report( "__________________________________" )
+ main.log.report( "Killing a link to ensure that link discovery \
+ is consistent" )
+ main.case( "Killing a link to Ensure that Link Discovery \
+ is Working Properly" )
+ """
+ main.step( "Start continuous pings" )
+
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+ """
+ 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' ]
+ print "activeSwitches = ", type( activeSwitches )
+ print "links = ", type( links )
+ main.log.info(
+ "Currently there are %s switches and %s links" %
+ ( str( activeSwitches ), str( links ) ) )
+
+ main.step( "Kill Link between s3 and s28" )
+ main.Mininet1.link( END1="s3", END2="s28", OPTION="down" )
+ time.sleep( linkSleep )
+ topologyOutput = main.ONOS2.topology()
+ LinkDown = main.ONOS1.checkStatus(
+ topologyOutput, activeSwitches, str(
+ int( links ) - 2 ) )
+ if LinkDown == main.TRUE:
+ main.log.report( "Link Down discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=LinkDown,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in " +
+ str( linkSleep ) +
+ " seconds" )
+
+ # Check ping result here..add code for it
+
+ main.step( "Bring link between s3 and s28 back up" )
+ LinkUp = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
+ time.sleep( linkSleep )
+ topologyOutput = main.ONOS2.topology()
+ LinkUp = main.ONOS1.checkStatus(
+ topologyOutput,
+ activeSwitches,
+ str( links ) )
+ if LinkUp == main.TRUE:
+ main.log.report( "Link up discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=LinkUp,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in " +
+ str( linkSleep ) +
+ " seconds" )
+
+ # NOTE Check ping result here..add code for it
+
+ main.step( "Compare ONOS Topology to MN Topology" )
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+ TopologyCheck = main.TRUE
+
+ devicesJson = main.ONOS2.devices()
+ linksJson = main.ONOS2.links()
+ portsJson = main.ONOS2.ports()
+
+ result1 = main.Mininet1.compareSwitches(
+ MNTopo,
+ json.loads( devicesJson ) )
+ result2 = main.Mininet1.compareLinks(
+ MNTopo,
+ json.loads( linksJson ) )
+ # result3 = main.Mininet1.comparePorts(
+ # MNTopo, json.loads( portsJson ) )
+
+ # result = result1 and result2 and result3
+ result = result1 and result2
+ print "***********************"
+
+ if result == main.TRUE:
+ main.log.report( "ONOS" + " Topology matches MN Topology" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=result,
+ onpass="ONOS" +
+ " Topology matches MN Topology",
+ onfail="ONOS" +
+ " Topology does not match MN Topology" )
+
+ TopologyCheck = TopologyCheck and result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=TopologyCheck,
+ onpass="Topology checks passed",
+ onfail="Topology checks failed" )
+
+ result = LinkDown and LinkUp and TopologyCheck
+ utilities.assert_equals( expect=main.TRUE, actual=result,
+ onpass="Link failure is discovered correctly",
+ onfail="Link Discovery failed" )
+
+ def CASE8( self ):
+ """
+ Host intents removal
+ """
+ main.log.report( "This testcase removes any previously added intents \
+ before adding the same intents or point intents" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Host intents removal" )
+ main.case( "Removing host intents" )
+ main.step( "Obtain the intent id's" )
+ intentResult = main.ONOS2.intents( jsonFormat=False )
+ main.log.info( "intent_result = " + intentResult )
+
+ intentLinewise = intentResult.split( "\n" )
+ intentList = []
+ for line in intentLinewise:
+ if line.startswith( "id=" ):
+ intentList.append( line )
+
+ intentids = []
+ for line in intentList:
+ intentids.append( line.split( "," )[ 0 ].split( "=" )[ 1 ] )
+ for id in intentids:
+ print "id = ", id
+
+ main.step(
+ "Iterate through the intentids list and remove each intent" )
+ for id in intentids:
+ main.ONOS2.removeIntent( intentId=id )
+
+ intentResult = main.ONOS2.intents( jsonFormat=False )
+ main.log.info( "intent_result = " + intentResult )
+
+ case8Result = main.TRUE
+ if case8Result == main.TRUE:
+ main.log.report( "Intent removal successful" )
+ else:
+ main.log.report( "Intent removal failed" )
+
+ PingResult = main.TRUE
+ if case8Result == main.TRUE:
+ i = 8
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.TRUE:
+ i = 19
+ PingResult = PingResult and main.TRUE
+ elif ping == main.FALSE:
+ i += 1
+ PingResult = PingResult and main.FALSE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+
+ # Note: If the ping result failed, that means the intents have been
+ # withdrawn correctly.
+ if PingResult == main.TRUE:
+ main.log.report( "Host intents have not been withdrawn correctly" )
+ # main.cleanup()
+ # main.exit()
+ if PingResult == main.FALSE:
+ main.log.report( "Host intents have been withdrawn correctly" )
+
+ case8Result = case8Result and PingResult
+
+ if case8Result == main.FALSE:
+ main.log.report( "Intent removal successful" )
+ else:
+ main.log.report( "Intent removal failed" )
+
+ utilities.assert_equals( expect=main.FALSE, actual=case8Result,
+ onpass="Intent removal test failed",
+ onfail="Intent removal test passed" )
+
+ def CASE9( self ):
+ main.log.report(
+ "This testcase adds point intents and then does pingall" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Adding point intents" )
+ main.case(
+ "Adding bidirectional point for mn hosts \
+ ( h8-h18, h9-h19, h10-h20, h11-h21, h12-h22,\
+ h13-h23, h14-h24, h15-h25, h16-h26, h17-h27 )" )
+ main.step(
+ "Add point intents for mininet hosts h8 and h18 or \
+ ONOS hosts h8 and h12" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003008/1",
+ "of:0000000000006018/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006018/1",
+ "of:0000000000003008/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h9 and h19 or \
+ ONOS hosts h9 and h13" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003009/1",
+ "of:0000000000006019/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006019/1",
+ "of:0000000000003009/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h10 and h20 or \
+ ONOS hosts hA and h14" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003010/1",
+ "of:0000000000006020/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006020/1",
+ "of:0000000000003010/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h11 and h21 or \
+ ONOS hosts hB and h15" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003011/1",
+ "of:0000000000006021/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006021/1",
+ "of:0000000000003011/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h12 and h22 \
+ ONOS hosts hC and h16" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003012/1",
+ "of:0000000000006022/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006022/1",
+ "of:0000000000003012/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h13 and h23 or \
+ ONOS hosts hD and h17" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003013/1",
+ "of:0000000000006023/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006023/1",
+ "of:0000000000003013/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h14 and h24 or \
+ ONOS hosts hE and h18" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003014/1",
+ "of:0000000000006024/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006024/1",
+ "of:0000000000003014/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h15 and h25 or \
+ ONOS hosts hF and h19" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003015/1",
+ "of:0000000000006025/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006025/1",
+ "of:0000000000003015/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add intents for mininet hosts h16 and h26 or \
+ ONOS hosts h10 and h1A" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003016/1",
+ "of:0000000000006026/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006026/1",
+ "of:0000000000003016/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h17 and h27 or \
+ ONOS hosts h11 and h1B" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003017/1",
+ "of:0000000000006027/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006027/1",
+ "of:0000000000003017/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ main.log.info( getIntentResult )
+
+ print(
+ "___________________________________________________________" )
+
+ flowHandle = main.ONOS2.flows()
+ # print "flowHandle = ", flowHandle
+ main.log.info( "flows :" + flowHandle )
+
+ count = 1
+ i = 8
+ PingResult = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ # i = 8
+ PingResult = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+
+ if PingResult == main.FALSE:
+ main.log.report(
+ "Point intents have not ben installed correctly. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if PingResult == main.TRUE:
+ main.log.report( "Point Intents have been installed correctly" )
+
+ case9Result = PingResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case9Result,
+ onpass="Point intents addition and Pingall Test successful",
+ onfail="Point intents addition and Pingall Test NOT successful" )
diff --git a/TestON/tests/ProdFunc13/ProdFunc13.py b/TestON/tests/ProdFunc13/ProdFunc13.py
index f6f60ee..b1246c2 100644
--- a/TestON/tests/ProdFunc13/ProdFunc13.py
+++ b/TestON/tests/ProdFunc13/ProdFunc13.py
@@ -43,8 +43,8 @@
main.step( "Removing raft logs before a clen installation of ONOS" )
main.ONOSbench.onosRemoveRaftLogs()
- main.step( "Git checkout and pull master and get version" )
- main.ONOSbench.gitCheckout( "master" )
+ main.step( "Git checkout, pull and get version" )
+ #main.ONOSbench.gitCheckout( "master" )
gitPullResult = main.ONOSbench.gitPull()
main.log.info( "git_pull_result = " + gitPullResult )
main.ONOSbench.getVersion( report=True )
diff --git a/TestON/tests/SdnIpTest/SdnIpTest.params b/TestON/tests/SdnIpTest/SdnIpTest.params
index bb5826d..7f7ef2d 100755
--- a/TestON/tests/SdnIpTest/SdnIpTest.params
+++ b/TestON/tests/SdnIpTest/SdnIpTest.params
@@ -1,6 +1,6 @@
<PARAMS>
- <testcases>1,2</testcases>
+ <testcases>4</testcases>
#Environment variables
<ENV>
diff --git a/TestON/tests/SdnIpTest/SdnIpTest.py b/TestON/tests/SdnIpTest/SdnIpTest.py
index 081b1ca..85ac21e 100644
--- a/TestON/tests/SdnIpTest/SdnIpTest.py
+++ b/TestON/tests/SdnIpTest/SdnIpTest.py
@@ -8,15 +8,27 @@
def __init__( self ):
self.default = ''
- def CASE1( self, main ):
+# from cupshelpers.config import prefix
+
+# Testing the basic functionality of SDN-IP
+
+
+class SdnIpTest:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE4( self, main ):
"""
Test the SDN-IP functionality
- allRoutes_expected: all expected routes for all BGP peers
- routeIntents_expected: all expected MultiPointToSinglePointIntent intents
- bgpIntents_expected: expected PointToPointIntent intents
- allRoutes_actual: all routes from ONOS LCI
- routeIntents_actual: actual MultiPointToSinglePointIntent intents from ONOS CLI
- bgpIntents_actual: actual PointToPointIntent intents from ONOS CLI
+ allRoutesExpected: all expected routes for all BGP peers
+ routeIntentsExpected: all expected MultiPointToSinglePointIntent \
+ intents
+ bgpIntentsExpected: expected PointToPointIntent intents
+ allRoutesActual: all routes from ONOS LCI
+ routeIntentsActual: actual MultiPointToSinglePointIntent intents from \
+ ONOS CLI
+ bgpIntentsActual: actual PointToPointIntent intents from ONOS CLI
"""
import time
import json
@@ -24,124 +36,148 @@
# from datetime import datetime
from time import localtime, strftime
- main.case(
- "The test case is to help to setup the TestON environment and test new drivers" )
- SDNIP_JSON_FILE_PATH = "../tests/SdnIpTest/sdnip.json"
+ main.case("The test case is to help to setup the TestON environment \
+ and test new drivers" )
+ # SDNIPJSONFILEPATH = "../tests/SdnIpTest/sdnip.json"
+ SDNIPJSONFILEPATH = \
+ "/home/admin/workspace/onos/tools/package/config/sdnip.json"
# all expected routes for all BGP peers
- allRoutes_expected = []
+ allRoutesExpected = []
main.step( "Start to generate routes for all BGP peers" )
- # bgpPeerHosts = []
- # for i in range( 3, 5 ):
- # bgpPeerHosts.append( "host" + str( i ) )
- # main.log.info( "BGP Peer Hosts are:" + bgpPeerHosts )
-
- # for i in range( 3, 5 ):
- # QuaggaCliHost = "QuaggaCliHost" + str( i )
- # prefixes = main.QuaggaCliHost.generate_prefixes( 3, 10 )
-
- # main.log.info( prefixes )
- # allRoutes_expected.append( prefixes )
main.log.info( "Generate prefixes for host3" )
- prefixes_host3 = main.QuaggaCliHost3.generate_prefixes( 3, 10 )
- main.log.info( prefixes_host3 )
+ prefixesHost3 = main.QuaggaCliHost3.generatePrefixes( 3, 10 )
+ main.log.info( prefixesHost3 )
# generate route with next hop
- for prefix in prefixes_host3:
- allRoutes_expected.append( prefix + "/" + "192.168.20.1" )
- routeIntents_expected_host3 = main.QuaggaCliHost3.generate_expected_onePeerRouteIntents(
- prefixes_host3,
- "192.168.20.1",
- "00:00:00:00:02:02",
- SDNIP_JSON_FILE_PATH )
+ for prefix in prefixesHost3:
+ allRoutesExpected.append( prefix + "/" + "192.168.20.1" )
+ routeIntentsExpectedHost3 = \
+ main.QuaggaCliHost3.generateExpectedOnePeerRouteIntents(
+ prefixesHost3, "192.168.20.1", "00:00:00:00:02:02",
+ SDNIPJSONFILEPATH )
main.log.info( "Generate prefixes for host4" )
- prefixes_host4 = main.QuaggaCliHost4.generate_prefixes( 4, 10 )
- main.log.info( prefixes_host4 )
+ prefixesHost4 = main.QuaggaCliHost4.generatePrefixes( 4, 10 )
+ main.log.info( prefixesHost4 )
# generate route with next hop
- for prefix in prefixes_host4:
- allRoutes_expected.append( prefix + "/" + "192.168.30.1" )
- routeIntents_expected_host4 = main.QuaggaCliHost4.generate_expected_onePeerRouteIntents(
- prefixes_host4,
- "192.168.30.1",
- "00:00:00:00:03:01",
- SDNIP_JSON_FILE_PATH )
+ for prefix in prefixesHost4:
+ allRoutesExpected.append( prefix + "/" + "192.168.30.1" )
+ routeIntentsExpectedHost4 = \
+ main.QuaggaCliHost4.generateExpectedOnePeerRouteIntents(
+ prefixesHost4, "192.168.30.1", "00:00:00:00:03:01",
+ SDNIPJSONFILEPATH )
- routeIntents_expected = routeIntents_expected_host3 + \
- routeIntents_expected_host4
+ main.log.info( "Generate prefixes for host5" )
+ prefixesHost5 = main.QuaggaCliHost5.generatePrefixes( 5, 10 )
+ main.log.info( prefixesHost5 )
+ for prefix in prefixesHost5:
+ allRoutesExpected.append( prefix + "/" + "192.168.60.2" )
+ routeIntentsExpectedHost5 = \
+ main.QuaggaCliHost5.generateExpectedOnePeerRouteIntents(
+ prefixesHost5, "192.168.60.1", "00:00:00:00:06:02",
+ SDNIPJSONFILEPATH )
- cell_name = main.params[ 'ENV' ][ 'cellName' ]
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ routeIntentsExpected = routeIntentsExpectedHost3 + \
+ routeIntentsExpectedHost4 + routeIntentsExpectedHost5
+
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
main.step( "Set cell for ONOS-cli environment" )
- main.ONOScli.set_cell( cell_name )
- verify_result = main.ONOSbench.verify_cell()
- main.log.report( "Removing raft logs" )
- main.ONOSbench.onos_remove_raft_logs()
- main.log.report( "Uninstalling ONOS" )
- main.ONOSbench.onos_uninstall( ONOS1_ip )
- main.step( "Creating ONOS package" )
- package_result = main.ONOSbench.onos_package()
+ main.ONOScli.setCell( cellName )
+ verifyResult = main.ONOSbench.verifyCell()
- main.step( "Starting ONOS service" )
- # TODO: start ONOS from Mininet Script
- # start_result = main.ONOSbench.onos_start( "127.0.0.1" )
+ main.log.report( "Removing raft logs" )
+ main.ONOSbench.onosRemoveRaftLogs()
+ main.log.report( "Uninstalling ONOS" )
+ main.ONOSbench.onosUninstall( ONOS1Ip )
+
main.step( "Installing ONOS package" )
- onos1_install_result = main.ONOSbench.onos_install(
- options="-f",
- node=ONOS1_ip )
+ onos1InstallResult = main.ONOSbench.onosInstall(
+ options="-f", node=ONOS1Ip )
main.step( "Checking if ONOS is up yet" )
- time.sleep( 60 )
- onos1_isup = main.ONOSbench.isup( ONOS1_ip )
- if not onos1_isup:
+ time.sleep( 150 )
+ onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+ if not onos1Isup:
main.log.report( "ONOS1 didn't start!" )
main.step( "Start ONOS-cli" )
- # TODO: change the hardcode in start_onos_cli method in ONOS CLI driver
- main.ONOScli.start_onos_cli( ONOS1_ip )
+ main.ONOScli.startOnosCli( ONOS1Ip )
main.step( "Get devices in the network" )
- list_result = main.ONOScli.devices( json_format=False )
- main.log.info( list_result )
+ listResult = main.ONOScli.devices( jsonFormat=False )
+ main.log.info( listResult )
time.sleep( 10 )
main.log.info( "Installing sdn-ip feature" )
- main.ONOScli.feature_install( "onos-app-sdnip" )
+ main.ONOScli.featureInstall( "onos-app-sdnip" )
time.sleep( 10 )
main.step( "Login all BGP peers and add routes into peers" )
+
main.log.info( "Login Quagga CLI on host3" )
main.QuaggaCliHost3.loginQuagga( "1.168.30.2" )
main.log.info( "Enter configuration model of Quagga CLI on host3" )
- main.QuaggaCliHost3.enter_config( 64514 )
+ main.QuaggaCliHost3.enterConfig( 64514 )
main.log.info( "Add routes to Quagga on host3" )
- main.QuaggaCliHost3.add_routes( prefixes_host3, 1 )
+ main.QuaggaCliHost3.addRoutes( prefixesHost3, 1 )
main.log.info( "Login Quagga CLI on host4" )
main.QuaggaCliHost4.loginQuagga( "1.168.30.3" )
main.log.info( "Enter configuration model of Quagga CLI on host4" )
- main.QuaggaCliHost4.enter_config( 64516 )
+ main.QuaggaCliHost4.enterConfig( 64516 )
main.log.info( "Add routes to Quagga on host4" )
- main.QuaggaCliHost4.add_routes( prefixes_host4, 1 )
+ main.QuaggaCliHost4.addRoutes( prefixesHost4, 1 )
+
+ main.log.info( "Login Quagga CLI on host5" )
+ main.QuaggaCliHost5.loginQuagga( "1.168.30.5" )
+ main.log.info( "Enter configuration model of Quagga CLI on host5" )
+ main.QuaggaCliHost5.enterConfig( 64521 )
+ main.log.info( "Add routes to Quagga on host5" )
+ main.QuaggaCliHost5.addRoutes( prefixesHost5, 1 )
+
+ for i in range( 101, 201 ):
+ prefixesHostX = main.QuaggaCliHost.generatePrefixes( str( i ), 10 )
+ main.log.info( prefixesHostX )
+ for prefix in prefixesHostX:
+ allRoutesExpected.append(
+ prefix + "/" + "192.168.40." + str( i - 100 ) )
+
+ routeIntentsExpectedHostX = \
+ main.QuaggaCliHost.generateExpectedOnePeerRouteIntents(
+ prefixesHostX, "192.168.40." + str( i - 100 ),
+ "00:00:%02d:00:00:90" % ( i - 101 ), SDNIPJSONFILEPATH )
+ routeIntentsExpected = routeIntentsExpected + \
+ routeIntentsExpectedHostX
+
+ main.log.info( "Login Quagga CLI on host" + str( i ) )
+ QuaggaCliHostX = getattr( main, ( 'QuaggaCliHost' + str( i ) ) )
+ QuaggaCliHostX.loginQuagga( "1.168.30." + str( i ) )
+ main.log.info(
+ "Enter configuration model of Quagga CLI on host" + str( i ) )
+ QuaggaCliHostX.enterConfig( 65000 + i - 100 )
+ main.log.info( "Add routes to Quagga on host" + str( i ) )
+ QuaggaCliHostX.addRoutes( prefixesHostX, 1 )
+
time.sleep( 60 )
- # get all routes inside SDN-IP
- get_routes_result = main.ONOScli.routes( json_format=True )
+ # get routes inside SDN-IP
+ getRoutesResult = main.ONOScli.routes( jsonFormat=True )
# parse routes from ONOS CLI
- allRoutes_actual = main.QuaggaCliHost3.extract_actual_routes(
- get_routes_result )
+ allRoutesActual = \
+ main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
- allRoutes_str_expected = str( sorted( allRoutes_expected ) )
- allRoutes_str_actual = str( allRoutes_actual ).replace( 'u', "" )
+ allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+ allRoutesStrActual = str( allRoutesActual ).replace( 'u', "" )
main.step( "Check routes installed" )
main.log.info( "Routes expected:" )
- main.log.info( allRoutes_str_expected )
+ main.log.info( allRoutesStrExpected )
main.log.info( "Routes get from ONOS CLI:" )
- main.log.info( allRoutes_str_actual )
- utilities.assert_equals(
- expect=allRoutes_str_expected,
- actual=allRoutes_str_actual,
+ main.log.info( allRoutesStrActual )
+ utilities.assertEquals(
+ expect=allRoutesStrExpected, actual=allRoutesStrActual,
onpass="***Routes in SDN-IP are correct!***",
onfail="***Routes in SDN-IP are wrong!***" )
- if( eq( allRoutes_str_expected, allRoutes_str_actual ) ):
+ if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
main.log.report(
"***Routes in SDN-IP after adding routes are correct!***" )
else:
@@ -149,58 +185,57 @@
"***Routes in SDN-IP after adding routes are wrong!***" )
time.sleep( 20 )
- get_intents_result = main.ONOScli.intents( json_format=True )
+ getIntentsResult = main.ONOScli.intents( jsonFormat=True )
main.step( "Check MultiPointToSinglePointIntent intents installed" )
- # route_intents_expected are generated when generating routes
+ # routeIntentsExpected are generated when generating routes
# get rpoute intents from ONOS CLI
- routeIntents_actual = main.QuaggaCliHost3.extract_actual_routeIntents(
- get_intents_result )
- routeIntents_str_expected = str( sorted( routeIntents_expected ) )
- routeIntents_str_actual = str( routeIntents_actual ).replace( 'u', "" )
+ routeIntentsActual = \
+ main.QuaggaCliHost3.extractActualRouteIntents(
+ getIntentsResult )
+ routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+ routeIntentsStrActual = str( routeIntentsActual ).replace( 'u', "" )
main.log.info( "MultiPointToSinglePoint intents expected:" )
- main.log.info( routeIntents_str_expected )
+ main.log.info( routeIntentsStrExpected )
main.log.info( "MultiPointToSinglePoint intents get from ONOS CLI:" )
- main.log.info( routeIntents_str_actual )
- utilities.assert_equals(
+ main.log.info( routeIntentsStrActual )
+ utilities.assertEquals(
expect=True,
- actual=eq(
- routeIntents_str_expected,
- routeIntents_str_actual ),
- onpass="***MultiPointToSinglePoint Intents in SDN-IP are correct!***",
- onfail="***MultiPointToSinglePoint Intents in SDN-IP are wrong!***" )
+ actual=eq( routeIntentsStrExpected, routeIntentsStrActual ),
+ onpass="***MultiPointToSinglePoint Intents in SDN-IP are \
+ correct!***",
+ onfail="***MultiPointToSinglePoint Intents in SDN-IP are \
+ wrong!***" )
- if( eq( routeIntents_str_expected, routeIntents_str_actual ) ):
- main.log.report(
- "***MultiPointToSinglePoint Intents before deleting routes correct!***" )
+ if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+ main.log.report( "***MultiPointToSinglePoint Intents before \
+ deleting routes correct!***" )
else:
- main.log.report(
- "***MultiPointToSinglePoint Intents before deleting routes wrong!***" )
+ main.log.report( "***MultiPointToSinglePoint Intents before \
+ deleting routes wrong!***" )
main.step( "Check BGP PointToPointIntent intents installed" )
# bgp intents expected
- bgpIntents_expected = main.QuaggaCliHost3.generate_expected_bgpIntents(
- SDNIP_JSON_FILE_PATH )
+ bgpIntentsExpected = \
+ main.QuaggaCliHost3.generateExpectedBgpIntents( SDNIPJSONFILEPATH )
# get BGP intents from ONOS CLI
- bgpIntents_actual = main.QuaggaCliHost3.extract_actual_bgpIntents(
- get_intents_result )
+ bgpIntentsActual = \
+ main.QuaggaCliHost3.extractActualBgpIntents( getIntentsResult )
- bgpIntents_str_expected = str( bgpIntents_expected ).replace( 'u', "" )
- bgpIntents_str_actual = str( bgpIntents_actual )
+ bgpIntentsStrExpected = str( bgpIntentsExpected ).replace( 'u', "" )
+ bgpIntentsStrActual = str( bgpIntentsActual )
main.log.info( "PointToPointIntent intents expected:" )
- main.log.info( bgpIntents_str_expected )
+ main.log.info( bgpIntentsStrExpected )
main.log.info( "PointToPointIntent intents get from ONOS CLI:" )
- main.log.info( bgpIntents_str_actual )
+ main.log.info( bgpIntentsStrActual )
- utilities.assert_equals(
+ utilities.assertEquals(
expect=True,
- actual=eq(
- bgpIntents_str_expected,
- bgpIntents_str_actual ),
+ actual=eq( bgpIntentsStrExpected, bgpIntentsStrActual ),
onpass="***PointToPointIntent Intents in SDN-IP are correct!***",
onfail="***PointToPointIntent Intents in SDN-IP are wrong!***" )
- if ( eq( bgpIntents_str_expected, bgpIntents_str_actual ) ):
+ if ( eq( bgpIntentsStrExpected, bgpIntentsStrActual ) ):
main.log.report(
"***PointToPointIntent Intents in SDN-IP are correct!***" )
else:
@@ -210,71 +245,634 @@
#============================= Ping Test ========================
# wait until all MultiPointToSinglePoint
time.sleep( 20 )
- ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
- ping_test_results_file = "~/SDNIP/SdnIpIntentDemo/log/CASE1-ping-results-before-delete-routes-" + \
- strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
- ping_test_results = main.QuaggaCliHost.ping_test(
- "1.168.30.100",
- ping_test_script,
- ping_test_results_file )
- main.log.info( ping_test_results )
-
- # ping test
+ pingTestScript = "~/SDNIP/test-tools/CASE4-ping-as2host.sh"
+ pingTestResultsFile = \
+ "~/SDNIP/SdnIpIntentDemo/log/CASE4-ping-results-before-delete-routes-" \
+ + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+ pingTestResults = main.QuaggaCliHost.pingTest(
+ "1.168.30.100", pingTestScript, pingTestResultsFile )
+ main.log.info( pingTestResults )
+ time.sleep( 20 )
#============================= Deleting Routes ==================
main.step( "Check deleting routes installed" )
- main.QuaggaCliHost3.delete_routes( prefixes_host3, 1 )
- main.QuaggaCliHost4.delete_routes( prefixes_host4, 1 )
+ main.QuaggaCliHost3.deleteRoutes( prefixesHost3, 1 )
+ main.QuaggaCliHost4.deleteRoutes( prefixesHost4, 1 )
+ main.QuaggaCliHost5.deleteRoutes( prefixesHost5, 1 )
- # main.log.info( "main.ONOScli.get_routes_num() = " )
- # main.log.info( main.ONOScli.get_routes_num() )
- # utilities.assert_equals( expect="Total SDN-IP routes = 1", actual=
- # main.ONOScli.get_routes_num(),
- get_routes_result = main.ONOScli.routes( json_format=True )
- allRoutes_actual = main.QuaggaCliHost3.extract_actual_routes(
- get_routes_result )
+ for i in range( 101, 201 ):
+ prefixesHostX = main.QuaggaCliHost.generatePrefixes( str( i ), 10 )
+ main.log.info( prefixesHostX )
+ QuaggaCliHostX = getattr( main, ( 'QuaggaCliHost' + str( i ) ) )
+ QuaggaCliHostX.deleteRoutes( prefixesHostX, 1 )
+
+ getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+ allRoutesActual = \
+ main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
main.log.info( "allRoutes_actual = " )
- main.log.info( allRoutes_actual )
+ main.log.info( allRoutesActual )
- utilities.assert_equals(
- expect="[]",
- actual=str( allRoutes_actual ),
+ utilities.assertEquals(
+ expect="[]", actual=str( allRoutesActual ),
onpass="***Route number in SDN-IP is 0, correct!***",
onfail="***Routes number in SDN-IP is not 0, wrong!***" )
- if( eq( allRoutes_str_expected, allRoutes_str_actual ) ):
+ if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
main.log.report( "***Routes in SDN-IP after deleting correct!***" )
else:
main.log.report( "***Routes in SDN-IP after deleting wrong!***" )
main.step( "Check intents after deleting routes" )
- get_intents_result = main.ONOScli.intents( json_format=True )
- routeIntents_actual = main.QuaggaCliHost3.extract_actual_routeIntents(
- get_intents_result )
+ getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+ routeIntentsActual = \
+ main.QuaggaCliHost3.extractActualRouteIntents(
+ getIntentsResult )
main.log.info( "main.ONOScli.intents()= " )
- main.log.info( routeIntents_actual )
- utilities.assert_equals(
- expect="[]",
- actual=str( routeIntents_actual ),
- onpass="***MultiPointToSinglePoint Intents number in SDN-IP is 0, correct!***",
- onfail="***MultiPointToSinglePoint Intents number in SDN-IP is 0, wrong!***" )
+ main.log.info( routeIntentsActual )
+ utilities.assertEquals(
+ expect="[]", actual=str( routeIntentsActual ),
+ onpass="***MultiPointToSinglePoint Intents number in SDN-IP is 0, \
+ correct!***",
+ onfail="***MultiPointToSinglePoint Intents number in SDN-IP is 0, \
+ wrong!***" )
- if( eq( routeIntents_str_expected, routeIntents_str_actual ) ):
- main.log.report(
- "***MultiPointToSinglePoint Intents after deleting routes correct!***" )
+ if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+ main.log.report( "***MultiPointToSinglePoint Intents after \
+ deleting routes correct!***" )
else:
- main.log.report(
- "***MultiPointToSinglePoint Intents after deleting routes wrong!***" )
+ main.log.report( "***MultiPointToSinglePoint Intents after \
+ deleting routes wrong!***" )
time.sleep( 20 )
- ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
- ping_test_results_file = "~/SDNIP/SdnIpIntentDemo/log/CASE1-ping-results-after-delete-routes-" + \
- strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
- ping_test_results = main.QuaggaCliHost.ping_test(
- "1.168.30.100",
- ping_test_script,
- ping_test_results_file )
- main.log.info( ping_test_results )
+ pingTestScript = "~/SDNIP/test-tools/CASE4-ping-as2host.sh"
+ pingTestResultsFile = \
+ "~/SDNIP/SdnIpIntentDemo/log/CASE4-ping-results-after-delete-routes-" \
+ + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+ pingTestResults = main.QuaggaCliHost.pingTest(
+ "1.168.30.100", pingTestScript, pingTestResultsFile )
+ main.log.info( pingTestResults )
+ time.sleep( 100 )
+
+ # main.step( "Test whether Mininet is started" )
+ # main.Mininet2.handle.sendline( "xterm host1" )
+ # main.Mininet2.handle.expect( "mininet>" )
+
+ def CASE3( self, main ):
+ """
+ Test the SDN-IP functionality
+ allRoutesExpected: all expected routes for all BGP peers
+ routeIntentsExpected: all expected MultiPointToSinglePointIntent intents
+ bgpIntentsExpected: expected PointToPointIntent intents
+ allRoutesActual: all routes from ONOS LCI
+ routeIntentsActual: actual MultiPointToSinglePointIntent intents from \
+ ONOS CLI
+ bgpIntentsActual: actual PointToPointIntent intents from ONOS CLI
+ """
+ import time
+ import json
+ from operator import eq
+ # from datetime import datetime
+ from time import localtime, strftime
+
+ main.case( "The test case is to help to setup the TestON \
+ environment and test new drivers" )
+ # SDNIPJSONFILEPATH = "../tests/SdnIpTest/sdnip.json"
+ SDNIPJSONFILEPATH = \
+ "/home/admin/workspace/onos/tools/package/config/sdnip.json"
+ # all expected routes for all BGP peers
+ allRoutesExpected = []
+ main.step( "Start to generate routes for all BGP peers" )
+ main.log.info( "Generate prefixes for host3" )
+ prefixesHost3 = main.QuaggaCliHost3.generatePrefixes( 3, 10 )
+ main.log.info( prefixesHost3 )
+ # generate route with next hop
+ for prefix in prefixesHost3:
+ allRoutesExpected.append( prefix + "/" + "192.168.20.1" )
+ routeIntentsExpectedHost3 = \
+ main.QuaggaCliHost3.generateExpectedOnePeerRouteIntents(
+ prefixesHost3, "192.168.20.1", "00:00:00:00:02:02",
+ SDNIPJSONFILEPATH )
+
+ main.log.info( "Generate prefixes for host4" )
+ prefixesHost4 = main.QuaggaCliHost4.generatePrefixes( 4, 10 )
+ main.log.info( prefixesHost4 )
+ # generate route with next hop
+ for prefix in prefixesHost4:
+ allRoutesExpected.append( prefix + "/" + "192.168.30.1" )
+ routeIntentsExpectedHost4 = \
+ main.QuaggaCliHost4.generateExpectedOnePeerRouteIntents(
+ prefixesHost4, "192.168.30.1", "00:00:00:00:03:01",
+ SDNIPJSONFILEPATH )
+
+ routeIntentsExpected = routeIntentsExpectedHost3 + \
+ routeIntentsExpectedHost4
+
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ main.step( "Set cell for ONOS-cli environment" )
+ main.ONOScli.setCell( cellName )
+ verifyResult = main.ONOSbench.verifyCell()
+
+ main.log.report( "Removing raft logs" )
+ main.ONOSbench.onosRemoveRaftLogs()
+ main.log.report( "Uninstalling ONOS" )
+ main.ONOSbench.onosUninstall( ONOS1Ip )
+
+ main.step( "Installing ONOS package" )
+ onos1InstallResult = main.ONOSbench.onosInstall(
+ options="-f", node=ONOS1Ip )
+
+ main.step( "Checking if ONOS is up yet" )
+ time.sleep( 60 )
+ onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+ if not onos1Isup:
+ main.log.report( "ONOS1 didn't start!" )
+
+ main.step( "Start ONOS-cli" )
+
+ main.ONOScli.startOnosCli( ONOS1Ip )
+
+ main.step( "Get devices in the network" )
+ listResult = main.ONOScli.devices( jsonFormat=False )
+ main.log.info( listResult )
+ time.sleep( 10 )
+ main.log.info( "Installing sdn-ip feature" )
+ main.ONOScli.featureInstall( "onos-app-sdnip" )
+ time.sleep( 10 )
+ main.step( "Login all BGP peers and add routes into peers" )
+
+ main.log.info( "Login Quagga CLI on host3" )
+ main.QuaggaCliHost3.loginQuagga( "1.168.30.2" )
+ main.log.info( "Enter configuration model of Quagga CLI on host3" )
+ main.QuaggaCliHost3.enterConfig( 64514 )
+ main.log.info( "Add routes to Quagga on host3" )
+ main.QuaggaCliHost3.addRoutes( prefixesHost3, 1 )
+
+ main.log.info( "Login Quagga CLI on host4" )
+ main.QuaggaCliHost4.loginQuagga( "1.168.30.3" )
+ main.log.info( "Enter configuration model of Quagga CLI on host4" )
+ main.QuaggaCliHost4.enterConfig( 64516 )
+ main.log.info( "Add routes to Quagga on host4" )
+ main.QuaggaCliHost4.addRoutes( prefixesHost4, 1 )
+
+ for i in range( 101, 201 ):
+ prefixesHostX = \
+ main.QuaggaCliHost.generatePrefixes( str( i ), 10 )
+ main.log.info( prefixesHostX )
+ for prefix in prefixesHostX:
+ allRoutesExpected.append(
+ prefix + "/" + "192.168.40." + str( i - 100 ) )
+
+ routeIntentsExpectedHostX = \
+ main.QuaggaCliHost.generateExpectedOnePeerRouteIntents(
+ prefixesHostX, "192.168.40." + str( i - 100 ),
+ "00:00:%02d:00:00:90" % ( i - 101 ), SDNIPJSONFILEPATH )
+ routeIntentsExpected = routeIntentsExpected + \
+ routeIntentsExpectedHostX
+
+ main.log.info( "Login Quagga CLI on host" + str( i ) )
+ QuaggaCliHostX = getattr( main, ( 'QuaggaCliHost' + str( i ) ) )
+ QuaggaCliHostX.loginQuagga( "1.168.30." + str( i ) )
+ main.log.info(
+ "Enter configuration model of Quagga CLI on host" + str( i ) )
+ QuaggaCliHostX.enterConfig( 65000 + i - 100 )
+ main.log.info( "Add routes to Quagga on host" + str( i ) )
+ QuaggaCliHostX.addRoutes( prefixesHostX, 1 )
+
+ time.sleep( 60 )
+
+ # get routes inside SDN-IP
+ getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+
+ # parse routes from ONOS CLI
+ allRoutesActual = \
+ main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
+
+ allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+ allRoutesStrActual = str( allRoutesActual ).replace( 'u', "" )
+ main.step( "Check routes installed" )
+ main.log.info( "Routes expected:" )
+ main.log.info( allRoutesStrExpected )
+ main.log.info( "Routes get from ONOS CLI:" )
+ main.log.info( allRoutesStrActual )
+ utilities.assertEquals(
+ expect=allRoutesStrExpected, actual=allRoutesStrActual,
+ onpass="***Routes in SDN-IP are correct!***",
+ onfail="***Routes in SDN-IP are wrong!***" )
+ if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
+ main.log.report(
+ "***Routes in SDN-IP after adding routes are correct!***" )
+ else:
+ main.log.report(
+ "***Routes in SDN-IP after adding routes are wrong!***" )
+
+ time.sleep( 20 )
+ getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+
+ main.step( "Check MultiPointToSinglePointIntent intents installed" )
+ # routeIntentsExpected are generated when generating routes
+ # get rpoute intents from ONOS CLI
+ routeIntentsActual = \
+ main.QuaggaCliHost3.extractActualRouteIntents(
+ getIntentsResult )
+ routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+ routeIntentsStrActual = str( routeIntentsActual ).replace( 'u', "" )
+ main.log.info( "MultiPointToSinglePoint intents expected:" )
+ main.log.info( routeIntentsStrExpected )
+ main.log.info( "MultiPointToSinglePoint intents get from ONOS CLI:" )
+ main.log.info( routeIntentsStrActual )
+ utilities.assertEquals(
+ expect=True,
+ actual=eq( routeIntentsStrExpected, routeIntentsStrActual ),
+ onpass="***MultiPointToSinglePoint Intents in SDN-IP are \
+ correct!***",
+ onfail="***MultiPointToSinglePoint Intents in SDN-IP are \
+ wrong!***" )
+
+ if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+ main.log.report(
+ "***MultiPointToSinglePoint Intents before deleting routes \
+ correct!***" )
+ else:
+ main.log.report(
+ "***MultiPointToSinglePoint Intents before deleting routes \
+ wrong!***" )
+
+ main.step( "Check BGP PointToPointIntent intents installed" )
+ # bgp intents expected
+ bgpIntentsExpected = main.QuaggaCliHost3.generateExpectedBgpIntents(
+ SDNIPJSONFILEPATH )
+ # get BGP intents from ONOS CLI
+ bgpIntentsActual = main.QuaggaCliHost3.extractActualBgpIntents(
+ getIntentsResult )
+
+ bgpIntentsStrExpected = str( bgpIntentsExpected ).replace( 'u', "" )
+ bgpIntentsStrActual = str( bgpIntentsActual )
+ main.log.info( "PointToPointIntent intents expected:" )
+ main.log.info( bgpIntentsStrExpected )
+ main.log.info( "PointToPointIntent intents get from ONOS CLI:" )
+ main.log.info( bgpIntentsStrActual )
+
+ utilities.assertEquals(
+ expect=True,
+ actual=eq( bgpIntentsStrExpected, bgpIntentsStrActual ),
+ onpass="***PointToPointIntent Intents in SDN-IP are correct!***",
+ onfail="***PointToPointIntent Intents in SDN-IP are wrong!***" )
+
+ if ( eq( bgpIntentsStrExpected, bgpIntentsStrActual ) ):
+ main.log.report(
+ "***PointToPointIntent Intents in SDN-IP are correct!***" )
+ else:
+ main.log.report(
+ "***PointToPointIntent Intents in SDN-IP are wrong!***" )
+
+ #============================= Ping Test ========================
+ # wait until all MultiPointToSinglePoint
+ time.sleep( 20 )
+ pingTestScript = "~/SDNIP/test-tools/CASE3-ping-as2host.sh"
+ pingTestResultsFile = \
+ "~/SDNIP/SdnIpIntentDemo/log/CASE3-ping-results-before-delete-routes-" \
+ + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+ pingTestResults = main.QuaggaCliHost.pingTest(
+ "1.168.30.100", pingTestScript, pingTestResultsFile )
+ main.log.info( pingTestResults )
+ time.sleep( 20 )
+
+ #============================= Deleting Routes ==================
+ main.step( "Check deleting routes installed" )
+ main.QuaggaCliHost3.deleteRoutes( prefixesHost3, 1 )
+ main.QuaggaCliHost4.deleteRoutes( prefixesHost4, 1 )
+ for i in range( 101, 201 ):
+ prefixesHostX = \
+ main.QuaggaCliHost.generatePrefixes( str( i ), 10 )
+ main.log.info( prefixesHostX )
+ QuaggaCliHostX = getattr( main, ( 'QuaggaCliHost' + str( i ) ) )
+ QuaggaCliHostX.deleteRoutes( prefixesHostX, 1 )
+
+ getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+ allRoutesActual = main.QuaggaCliHost3.extractActualRoutes(
+ getRoutesResult )
+ main.log.info( "allRoutes_actual = " )
+ main.log.info( allRoutesActual )
+
+ utilities.assertEquals(
+ expect="[]", actual=str( allRoutesActual ),
+ onpass="***Route number in SDN-IP is 0, correct!***",
+ onfail="***Routes number in SDN-IP is not 0, wrong!***" )
+
+ if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
+ main.log.report(
+ "***Routes in SDN-IP after deleting correct!***" )
+ else:
+ main.log.report(
+ "***Routes in SDN-IP after deleting wrong!***" )
+
+ main.step( "Check intents after deleting routes" )
+ getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+ routeIntentsActual = \
+ main.QuaggaCliHost3.extractActualRouteIntents(
+ getIntentsResult )
+ main.log.info( "main.ONOScli.intents()= " )
+ main.log.info( routeIntentsActual )
+ utilities.assertEquals(
+ expect="[]", actual=str( routeIntentsActual ),
+ onpass="***MultiPointToSinglePoint Intents number in SDN-IP is \
+ 0, correct!***",
+ onfail="***MultiPointToSinglePoint Intents number in SDN-IP is \
+ 0, wrong!***" )
+
+ if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+ main.log.report(
+ "***MultiPointToSinglePoint Intents after deleting routes \
+ correct!***" )
+ else:
+ main.log.report(
+ "***MultiPointToSinglePoint Intents after deleting routes \
+ wrong!***" )
+
+ time.sleep( 20 )
+ pingTestScript = "~/SDNIP/test-tools/CASE3-ping-as2host.sh"
+ pingTestResultsFile = \
+ "~/SDNIP/SdnIpIntentDemo/log/CASE3-ping-results-after-delete-routes-" \
+ + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+ pingTestResults = main.QuaggaCliHost.pingTest(
+ "1.168.30.100", pingTestScript, pingTestResultsFile )
+ main.log.info( pingTestResults )
+ time.sleep( 100 )
+
+ # main.step( "Test whether Mininet is started" )
+ # main.Mininet2.handle.sendline( "xterm host1" )
+ # main.Mininet2.handle.expect( "mininet>" )
+
+ def CASE1( self, main ):
+ """
+ Test the SDN-IP functionality
+ allRoutesExpected: all expected routes for all BGP peers
+ routeIntentsExpected: all expected MultiPointToSinglePointIntent \
+ intents
+ bgpIntentsExpected: expected PointToPointIntent intents
+ allRoutesActual: all routes from ONOS LCI
+ routeIntentsActual: actual MultiPointToSinglePointIntent intents \
+ from ONOS CLI
+ bgpIntentsActual: actual PointToPointIntent intents from ONOS CLI
+ """
+ import time
+ import json
+ from operator import eq
+ # from datetime import datetime
+ from time import localtime, strftime
+
+ main.case("The test case is to help to setup the TestON environment \
+ and test new drivers" )
+ SDNIPJSONFILEPATH = "../tests/SdnIpTest/sdnip.json"
+ # all expected routes for all BGP peers
+ allRoutesExpected = []
+ main.step( "Start to generate routes for all BGP peers" )
+ # bgpPeerHosts = []
+ # for i in range( 3, 5 ):
+ # bgpPeerHosts.append( "host" + str( i ) )
+ # main.log.info( "BGP Peer Hosts are:" + bgpPeerHosts )
+
+ # for i in range( 3, 5 ):
+ # QuaggaCliHost = "QuaggaCliHost" + str( i )
+ # prefixes = main.QuaggaCliHost.generatePrefixes( 3, 10 )
+
+ # main.log.info( prefixes )
+ # allRoutesExpected.append( prefixes )
+ main.log.info( "Generate prefixes for host3" )
+ prefixesHost3 = main.QuaggaCliHost3.generatePrefixes( 3, 10 )
+ main.log.info( prefixesHost3 )
+ # generate route with next hop
+ for prefix in prefixesHost3:
+ allRoutesExpected.append( prefix + "/" + "192.168.20.1" )
+ routeIntentsExpectedHost3 = \
+ main.QuaggaCliHost3.generateExpectedOnePeerRouteIntents(
+ prefixesHost3, "192.168.20.1", "00:00:00:00:02:02",
+ SDNIPJSONFILEPATH )
+
+ main.log.info( "Generate prefixes for host4" )
+ prefixesHost4 = main.QuaggaCliHost4.generatePrefixes( 4, 10 )
+ main.log.info( prefixesHost4 )
+ # generate route with next hop
+ for prefix in prefixesHost4:
+ allRoutesExpected.append( prefix + "/" + "192.168.30.1" )
+ routeIntentsExpectedHost4 = \
+ main.QuaggaCliHost4.generateExpectedOnePeerRouteIntents(
+ prefixesHost4, "192.168.30.1", "00:00:00:00:03:01",
+ SDNIPJSONFILEPATH )
+
+ routeIntentsExpected = routeIntentsExpectedHost3 + \
+ routeIntentsExpectedHost4
+
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ main.step( "Set cell for ONOS-cli environment" )
+ main.ONOScli.setCell( cellName )
+ verifyResult = main.ONOSbench.verifyCell()
+ main.log.report( "Removing raft logs" )
+ main.ONOSbench.onosRemoveRaftLogs()
+ main.log.report( "Uninstalling ONOS" )
+ main.ONOSbench.onosUninstall( ONOS1Ip )
+ main.step( "Creating ONOS package" )
+ packageResult = main.ONOSbench.onosPackage()
+
+ main.step( "Starting ONOS service" )
+ # TODO: start ONOS from Mininet Script
+ # startResult = main.ONOSbench.onosStart( "127.0.0.1" )
+ main.step( "Installing ONOS package" )
+ onos1InstallResult = main.ONOSbench.onosInstall(
+ options="-f", node=ONOS1Ip )
+
+ main.step( "Checking if ONOS is up yet" )
+ time.sleep( 60 )
+ onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+ if not onos1Isup:
+ main.log.report( "ONOS1 didn't start!" )
+
+ main.step( "Start ONOS-cli" )
+ # TODO: change the hardcode in startOnosCli method in ONOS CLI driver
+
+ main.ONOScli.startOnosCli( ONOS1Ip )
+
+ main.step( "Get devices in the network" )
+ listResult = main.ONOScli.devices( jsonFormat=False )
+ main.log.info( listResult )
+ time.sleep( 10 )
+ main.log.info( "Installing sdn-ip feature" )
+ main.ONOScli.featureInstall( "onos-app-sdnip" )
+ time.sleep( 10 )
+ main.step( "Login all BGP peers and add routes into peers" )
+ main.log.info( "Login Quagga CLI on host3" )
+ main.QuaggaCliHost3.loginQuagga( "1.168.30.2" )
+ main.log.info( "Enter configuration model of Quagga CLI on host3" )
+ main.QuaggaCliHost3.enterConfig( 64514 )
+ main.log.info( "Add routes to Quagga on host3" )
+ main.QuaggaCliHost3.addRoutes( prefixesHost3, 1 )
+
+ main.log.info( "Login Quagga CLI on host4" )
+ main.QuaggaCliHost4.loginQuagga( "1.168.30.3" )
+ main.log.info( "Enter configuration model of Quagga CLI on host4" )
+ main.QuaggaCliHost4.enterConfig( 64516 )
+ main.log.info( "Add routes to Quagga on host4" )
+ main.QuaggaCliHost4.addRoutes( prefixesHost4, 1 )
+ time.sleep( 60 )
+
+ # get all routes inside SDN-IP
+ getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+
+ # parse routes from ONOS CLI
+ allRoutesActual = \
+ main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
+
+ allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+ allRoutesStrActual = str( allRoutesActual ).replace( 'u', "" )
+ main.step( "Check routes installed" )
+ main.log.info( "Routes expected:" )
+ main.log.info( allRoutesStrExpected )
+ main.log.info( "Routes get from ONOS CLI:" )
+ main.log.info( allRoutesStrActual )
+ utilities.assertEquals(
+ expect=allRoutesStrExpected, actual=allRoutesStrActual,
+ onpass="***Routes in SDN-IP are correct!***",
+ onfail="***Routes in SDN-IP are wrong!***" )
+ if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
+ main.log.report(
+ "***Routes in SDN-IP after adding routes are correct!***" )
+ else:
+ main.log.report(
+ "***Routes in SDN-IP after adding routes are wrong!***" )
+
+ time.sleep( 20 )
+ getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+
+ main.step( "Check MultiPointToSinglePointIntent intents installed" )
+ # routeIntentsExpected are generated when generating routes
+ # get rpoute intents from ONOS CLI
+ routeIntentsActual = \
+ main.QuaggaCliHost3.extractActualRouteIntents(
+ getIntentsResult )
+ routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+ routeIntentsStrActual = str( routeIntentsActual ).replace( 'u', "" )
+ main.log.info( "MultiPointToSinglePoint intents expected:" )
+ main.log.info( routeIntentsStrExpected )
+ main.log.info( "MultiPointToSinglePoint intents get from ONOS CLI:" )
+ main.log.info( routeIntentsStrActual )
+ utilities.assertEquals(
+ expect=True,
+ actual=eq( routeIntentsStrExpected, routeIntentsStrActual ),
+ onpass="***MultiPointToSinglePoint Intents in SDN-IP are \
+ correct!***",
+ onfail="***MultiPointToSinglePoint Intents in SDN-IP are \
+ wrong!***" )
+
+ if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+ main.log.report(
+ "***MultiPointToSinglePoint Intents before deleting routes \
+ correct!***" )
+ else:
+ main.log.report(
+ "***MultiPointToSinglePoint Intents before deleting routes \
+ wrong!***" )
+
+ main.step( "Check BGP PointToPointIntent intents installed" )
+ # bgp intents expected
+ bgpIntentsExpected = \
+ main.QuaggaCliHost3.generateExpectedBgpIntents( SDNIPJSONFILEPATH )
+ # get BGP intents from ONOS CLI
+ bgpIntentsActual = main.QuaggaCliHost3.extractActualBgpIntents(
+ getIntentsResult )
+
+ bgpIntentsStrExpected = str( bgpIntentsExpected ).replace( 'u', "" )
+ bgpIntentsStrActual = str( bgpIntentsActual )
+ main.log.info( "PointToPointIntent intents expected:" )
+ main.log.info( bgpIntentsStrExpected )
+ main.log.info( "PointToPointIntent intents get from ONOS CLI:" )
+ main.log.info( bgpIntentsStrActual )
+
+ utilities.assertEquals(
+ expect=True,
+ actual=eq( bgpIntentsStrExpected, bgpIntentsStrActual ),
+ onpass="***PointToPointIntent Intents in SDN-IP are correct!***",
+ onfail="***PointToPointIntent Intents in SDN-IP are wrong!***" )
+
+ if ( eq( bgpIntentsStrExpected, bgpIntentsStrActual ) ):
+ main.log.report(
+ "***PointToPointIntent Intents in SDN-IP are correct!***" )
+ else:
+ main.log.report(
+ "***PointToPointIntent Intents in SDN-IP are wrong!***" )
+
+ #============================= Ping Test ========================
+ # wait until all MultiPointToSinglePoint
+ time.sleep( 20 )
+ pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+ pingTestResultsFile = \
+ "~/SDNIP/SdnIpIntentDemo/log/CASE1-ping-results-before-delete-routes-" \
+ + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+ pingTestResults = main.QuaggaCliHost.pingTest(
+ "1.168.30.100", pingTestScript, pingTestResultsFile )
+ main.log.info( pingTestResults )
+
+ # ping test
+
+ #============================= Deleting Routes ==================
+ main.step( "Check deleting routes installed" )
+ main.QuaggaCliHost3.deleteRoutes( prefixesHost3, 1 )
+ main.QuaggaCliHost4.deleteRoutes( prefixesHost4, 1 )
+
+ # main.log.info( "main.ONOScli.get_routes_num() = " )
+ # main.log.info( main.ONOScli.getRoutesNum() )
+ # utilities.assertEquals( expect="Total SDN-IP routes = 1", actual=
+ # main.ONOScli.getRoutesNum(),
+ getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+ allRoutesActual = \
+ main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
+ main.log.info( "allRoutes_actual = " )
+ main.log.info( allRoutesActual )
+
+ utilities.assertEquals(
+ expect="[]", actual=str( allRoutesActual ),
+ onpass="***Route number in SDN-IP is 0, correct!***",
+ onfail="***Routes number in SDN-IP is not 0, wrong!***" )
+
+ if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
+ main.log.report(
+ "***Routes in SDN-IP after deleting correct!***" )
+ else:
+ main.log.report(
+ "***Routes in SDN-IP after deleting wrong!***" )
+
+ main.step( "Check intents after deleting routes" )
+ getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+ routeIntentsActual = \
+ main.QuaggaCliHost3.extractActualRouteIntents(
+ getIntentsResult )
+ main.log.info( "main.ONOScli.intents()= " )
+ main.log.info( routeIntentsActual )
+ utilities.assertEquals(
+ expect="[]", actual=str( routeIntentsActual ),
+ onpass="***MultiPointToSinglePoint Intents number in SDN-IP is \
+ 0, correct!***",
+ onfail="***MultiPointToSinglePoint Intents number in SDN-IP is \
+ 0, wrong!***" )
+
+ if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
+ main.log.report(
+ "***MultiPointToSinglePoint Intents after deleting routes \
+ correct!***" )
+ else:
+ main.log.report(
+ "***MultiPointToSinglePoint Intents after deleting routes \
+ wrong!***" )
+
+ time.sleep( 20 )
+ pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+ pingTestResultsFile = \
+ "~/SDNIP/SdnIpIntentDemo/log/CASE1-ping-results-after-delete-routes-" \
+ + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+ pingTestResults = main.QuaggaCliHost.pingTest(
+ "1.168.30.100", pingTestScript, pingTestResultsFile )
+ main.log.info( pingTestResults )
time.sleep( 30 )
# main.step( "Test whether Mininet is started" )
@@ -284,12 +882,14 @@
def CASE2( self, main ):
"""
Test the SDN-IP functionality
- allRoutes_expected: all expected routes for all BGP peers
- routeIntents_expected: all expected MultiPointToSinglePointIntent intents
- bgpIntents_expected: expected PointToPointIntent intents
- allRoutes_actual: all routes from ONOS LCI
- routeIntents_actual: actual MultiPointToSinglePointIntent intents from ONOS CLI
- bgpIntents_actual: actual PointToPointIntent intents from ONOS CLI
+ allRoutesExpected: all expected routes for all BGP peers
+ routeIntentsExpected: all expected MultiPointToSinglePointIntent \
+ intents
+ bgpIntentsExpected: expected PointToPointIntent intents
+ allRoutesActual: all routes from ONOS LCI
+ routeIntentsActual: actual MultiPointToSinglePointIntent intents \
+ from ONOS CLI
+ bgpIntentsActual: actual PointToPointIntent intents from ONOS CLI
"""
import time
import json
@@ -297,227 +897,225 @@
from time import localtime, strftime
main.case(
- "The test case is to help to setup the TestON environment and test new drivers" )
- SDNIP_JSON_FILE_PATH = "../tests/SdnIpTest/sdnip.json"
+ "The test case is to help to setup the TestON environment and \
+ test new drivers" )
+ SDNIPJSONFILEPATH = "../tests/SdnIpTest/sdnip.json"
# all expected routes for all BGP peers
- allRoutes_expected = []
+ allRoutesExpected = []
main.step( "Start to generate routes for all BGP peers" )
main.log.info( "Generate prefixes for host3" )
- prefixes_host3 = main.QuaggaCliHost3.generate_prefixes( 3, 10 )
- main.log.info( prefixes_host3 )
+ prefixesHost3 = main.QuaggaCliHost3.generatePrefixes( 3, 10 )
+ main.log.info( prefixesHost3 )
# generate route with next hop
- for prefix in prefixes_host3:
- allRoutes_expected.append( prefix + "/" + "192.168.20.1" )
- routeIntents_expected_host3 = main.QuaggaCliHost3.generate_expected_onePeerRouteIntents(
- prefixes_host3,
- "192.168.20.1",
- "00:00:00:00:02:02",
- SDNIP_JSON_FILE_PATH )
+ for prefix in prefixesHost3:
+ allRoutesExpected.append( prefix + "/" + "192.168.20.1" )
+ routeIntentsExpectedHost3 = \
+ main.QuaggaCliHost3.generateExpectedOnePeerRouteIntents(
+ prefixesHost3, "192.168.20.1", "00:00:00:00:02:02",
+ SDNIPJSONFILEPATH )
main.log.info( "Generate prefixes for host4" )
- prefixes_host4 = main.QuaggaCliHost4.generate_prefixes( 4, 10 )
- main.log.info( prefixes_host4 )
+ prefixesHost4 = main.QuaggaCliHost4.generatePrefixes( 4, 10 )
+ main.log.info( prefixesHost4 )
# generate route with next hop
- for prefix in prefixes_host4:
- allRoutes_expected.append( prefix + "/" + "192.168.30.1" )
- routeIntents_expected_host4 = main.QuaggaCliHost4.generate_expected_onePeerRouteIntents(
- prefixes_host4,
- "192.168.30.1",
- "00:00:00:00:03:01",
- SDNIP_JSON_FILE_PATH )
+ for prefix in prefixesHost4:
+ allRoutesExpected.append( prefix + "/" + "192.168.30.1" )
+ routeIntentsExpectedHost4 = \
+ main.QuaggaCliHost4.generateExpectedOnePeerRouteIntents(
+ prefixesHost4, "192.168.30.1", "00:00:00:00:03:01",
+ SDNIPJSONFILEPATH )
- routeIntents_expected = routeIntents_expected_host3 + \
- routeIntents_expected_host4
+ routeIntentsExpected = routeIntentsExpectedHost3 + \
+ routeIntentsExpectedHost4
main.log.report( "Removing raft logs" )
- main.ONOSbench.onos_remove_raft_logs()
+ main.ONOSbench.onosRemoveRaftLogs()
main.log.report( "Uninstalling ONOS" )
- main.ONOSbench.onos_uninstall( ONOS1_ip )
+ main.ONOSbench.onosUninstall( ONOS1Ip )
- cell_name = main.params[ 'ENV' ][ 'cellName' ]
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
main.step( "Set cell for ONOS-cli environment" )
- main.ONOScli.set_cell( cell_name )
- verify_result = main.ONOSbench.verify_cell()
- #main.log.report( "Removing raft logs" )
- # main.ONOSbench.onos_remove_raft_logs()
- #main.log.report( "Uninstalling ONOS" )
- # main.ONOSbench.onos_uninstall( ONOS1_ip )
+ main.ONOScli.setCell( cellName )
+ verifyResult = main.ONOSbench.verifyCell()
+ # main.log.report( "Removing raft logs" )
+ # main.ONOSbench.onosRemoveRaftLogs()
+ # main.log.report( "Uninstalling ONOS" )
+ # main.ONOSbench.onosUninstall( ONOS1Ip )
main.step( "Creating ONOS package" )
- package_result = main.ONOSbench.onos_package()
+ # packageResult = main.ONOSbench.onosPackage()
main.step( "Installing ONOS package" )
- onos1_install_result = main.ONOSbench.onos_install(
- options="-f",
- node=ONOS1_ip )
+ # onos1InstallResult = main.ONOSbench.onosInstall( options="-f",
+ # node=ONOS1Ip )
main.step( "Checking if ONOS is up yet" )
- time.sleep( 60 )
- onos1_isup = main.ONOSbench.isup( ONOS1_ip )
- if not onos1_isup:
+ # time.sleep( 60 )
+ onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+ if not onos1Isup:
main.log.report( "ONOS1 didn't start!" )
main.step( "Start ONOS-cli" )
- main.ONOScli.start_onos_cli( ONOS1_ip )
+ main.ONOScli.startOnosCli( ONOS1Ip )
main.step( "Get devices in the network" )
- list_result = main.ONOScli.devices( json_format=False )
- main.log.info( list_result )
+ listResult = main.ONOScli.devices( jsonFormat=False )
+ main.log.info( listResult )
time.sleep( 10 )
main.log.info( "Installing sdn-ip feature" )
- main.ONOScli.feature_install( "onos-app-sdnip" )
+ main.ONOScli.featureInstall( "onos-app-sdnip" )
time.sleep( 10 )
main.step( "Check BGP PointToPointIntent intents installed" )
# bgp intents expected
- bgpIntents_expected = main.QuaggaCliHost3.generate_expected_bgpIntents(
- SDNIP_JSON_FILE_PATH )
+ bgpIntentsExpected = main.QuaggaCliHost3.generateExpectedBgpIntents(
+ SDNIPJSONFILEPATH )
# get BGP intents from ONOS CLI
- get_intents_result = main.ONOScli.intents( json_format=True )
- bgpIntents_actual = main.QuaggaCliHost3.extract_actual_bgpIntents(
- get_intents_result )
+ getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+ bgpIntentsActual = main.QuaggaCliHost3.extractActualBgpIntents(
+ getIntentsResult )
- bgpIntents_str_expected = str( bgpIntents_expected ).replace( 'u', "" )
- bgpIntents_str_actual = str( bgpIntents_actual )
+ bgpIntentsStrExpected = str( bgpIntentsExpected ).replace( 'u', "" )
+ bgpIntentsStrActual = str( bgpIntentsActual )
main.log.info( "PointToPointIntent intents expected:" )
- main.log.info( bgpIntents_str_expected )
+ main.log.info( bgpIntentsStrExpected )
main.log.info( "PointToPointIntent intents get from ONOS CLI:" )
- main.log.info( bgpIntents_str_actual )
+ main.log.info( bgpIntentsStrActual )
- utilities.assert_equals(
+ utilities.assertEquals(
expect=True,
- actual=eq(
- bgpIntents_str_expected,
- bgpIntents_str_actual ),
+ actual=eq( bgpIntentsStrExpected, bgpIntentsStrActual ),
onpass="***PointToPointIntent Intents in SDN-IP are correct!***",
onfail="***PointToPointIntent Intents in SDN-IP are wrong!***" )
- if ( eq( bgpIntents_str_expected, bgpIntents_str_actual ) ):
+ if ( eq( bgpIntentsStrExpected, bgpIntentsStrActual ) ):
main.log.report(
"***PointToPointIntent Intents in SDN-IP are correct!***" )
else:
main.log.report(
"***PointToPointIntent Intents in SDN-IP are wrong!***" )
- allRoutes_str_expected = str( sorted( allRoutes_expected ) )
- routeIntents_str_expected = str( sorted( routeIntents_expected ) )
- ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
- # round_num = 0;
+ allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+ routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+ pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+ # roundNum = 0;
# while( True ):
- for round_num in range( 1, 6 ):
+ for roundNum in range( 1, 6 ):
# round = round + 1;
- main.log.report(
- "The Round " +
- str( round_num ) +
- " test starts........................................" )
+ main.log.report( "The Round " + str( roundNum ) +
+ " test starts................................" )
main.step( "Login all BGP peers and add routes into peers" )
main.log.info( "Login Quagga CLI on host3" )
main.QuaggaCliHost3.loginQuagga( "1.168.30.2" )
- main.log.info( "Enter configuration model of Quagga CLI on host3" )
- main.QuaggaCliHost3.enter_config( 64514 )
+ main.log.info(
+ "Enter configuration model of Quagga CLI on host3" )
+ main.QuaggaCliHost3.enterConfig( 64514 )
main.log.info( "Add routes to Quagga on host3" )
- main.QuaggaCliHost3.add_routes( prefixes_host3, 1 )
+ main.QuaggaCliHost3.addRoutes( prefixesHost3, 1 )
main.log.info( "Login Quagga CLI on host4" )
main.QuaggaCliHost4.loginQuagga( "1.168.30.3" )
- main.log.info( "Enter configuration model of Quagga CLI on host4" )
- main.QuaggaCliHost4.enter_config( 64516 )
+ main.log.info(
+ "Enter configuration model of Quagga CLI on host4" )
+ main.QuaggaCliHost4.enterConfig( 64516 )
main.log.info( "Add routes to Quagga on host4" )
- main.QuaggaCliHost4.add_routes( prefixes_host4, 1 )
+ main.QuaggaCliHost4.addRoutes( prefixesHost4, 1 )
time.sleep( 60 )
# get all routes inside SDN-IP
- get_routes_result = main.ONOScli.routes( json_format=True )
+ getRoutesResult = main.ONOScli.routes( jsonFormat=True )
# parse routes from ONOS CLI
- allRoutes_actual = main.QuaggaCliHost3.extract_actual_routes(
- get_routes_result )
+ allRoutesActual = \
+ main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
- # allRoutes_str_expected = str( sorted( allRoutes_expected ) )
- allRoutes_str_actual = str( allRoutes_actual ).replace( 'u', "" )
+ # allRoutesStrExpected = str( sorted( allRoutesExpected ) )
+ allRoutesStrActual = str( allRoutesActual ).replace( 'u', "" )
main.step( "Check routes installed" )
main.log.info( "Routes expected:" )
- main.log.info( allRoutes_str_expected )
+ main.log.info( allRoutesStrExpected )
main.log.info( "Routes get from ONOS CLI:" )
- main.log.info( allRoutes_str_actual )
- utilities.assert_equals(
- expect=allRoutes_str_expected,
- actual=allRoutes_str_actual,
+ main.log.info( allRoutesStrActual )
+ utilities.assertEquals(
+ expect=allRoutesStrExpected, actual=allRoutesStrActual,
onpass="***Routes in SDN-IP are correct!***",
onfail="***Routes in SDN-IP are wrong!***" )
- if( eq( allRoutes_str_expected, allRoutes_str_actual ) ):
+ if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
main.log.report(
"***Routes in SDN-IP after adding correct!***" )
else:
- main.log.report( "***Routes in SDN-IP after adding wrong!***" )
+ main.log.report(
+ "***Routes in SDN-IP after adding wrong!***" )
time.sleep( 20 )
- get_intents_result = main.ONOScli.intents( json_format=True )
+ getIntentsResult = main.ONOScli.intents( jsonFormat=True )
main.step(
"Check MultiPointToSinglePointIntent intents installed" )
- # route_intents_expected are generated when generating routes
+ # routeIntentsExpected are generated when generating routes
# get route intents from ONOS CLI
- routeIntents_actual = main.QuaggaCliHost3.extract_actual_routeIntents(
- get_intents_result )
- # routeIntents_str_expected = str( sorted( routeIntents_expected ) )
- routeIntents_str_actual = str(
- routeIntents_actual ).replace( 'u', "" )
+ routeIntentsActual = \
+ main.QuaggaCliHost3.extractActualRouteIntents(
+ getIntentsResult )
+ # routeIntentsStrExpected = str( sorted( routeIntentsExpected ) )
+ routeIntentsStrActual = str(
+ routeIntentsActual ).replace( 'u', "" )
main.log.info( "MultiPointToSinglePoint intents expected:" )
- main.log.info( routeIntents_str_expected )
+ main.log.info( routeIntentsStrExpected )
main.log.info(
"MultiPointToSinglePoint intents get from ONOS CLI:" )
- main.log.info( routeIntents_str_actual )
- utilities.assert_equals(
+ main.log.info( routeIntentsStrActual )
+ utilities.assertEquals(
expect=True,
- actual=eq(
- routeIntents_str_expected,
- routeIntents_str_actual ),
- onpass="***MultiPointToSinglePoint Intents in SDN-IP are correct!***",
- onfail="***MultiPointToSinglePoint Intents in SDN-IP are wrong!***" )
+ actual=eq( routeIntentsStrExpected, routeIntentsStrActual ),
+ onpass="***MultiPointToSinglePoint Intents in SDN-IP are \
+ correct!***",
+ onfail="***MultiPointToSinglePoint Intents in SDN-IP are \
+ wrong!***" )
- if( eq( routeIntents_str_expected, routeIntents_str_actual ) ):
+ if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
main.log.report(
- "***MultiPointToSinglePoint Intents after adding routes correct!***" )
+ "***MultiPointToSinglePoint Intents after adding routes \
+ correct!***" )
else:
main.log.report(
- "***MultiPointToSinglePoint Intents after adding routes wrong!***" )
+ "***MultiPointToSinglePoint Intents after adding routes \
+ wrong!***" )
#============================= Ping Test ========================
# wait until all MultiPointToSinglePoint
time.sleep( 20 )
- # ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
- ping_test_results_file = "~/SDNIP/SdnIpIntentDemo/log/CASE2-Round" + \
- str( round_num ) + "-ping-results-before-delete-routes-" + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
- ping_test_results = main.QuaggaCliHost.ping_test(
- "1.168.30.100",
- ping_test_script,
- ping_test_results_file )
- main.log.info( ping_test_results )
+ # pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+ pingTestResultsFile = \
+ "~/SDNIP/SdnIpIntentDemo/log/CASE2-Round" \
+ + str( roundNum ) + "-ping-results-before-delete-routes-" \
+ + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+ pingTestResults = main.QuaggaCliHost.pingTest(
+ "1.168.30.100", pingTestScript, pingTestResultsFile )
+ main.log.info( pingTestResults )
# ping test
#============================= Deleting Routes ==================
main.step( "Check deleting routes installed" )
main.log.info( "Delete routes to Quagga on host3" )
- main.QuaggaCliHost3.delete_routes( prefixes_host3, 1 )
+ main.QuaggaCliHost3.deleteRoutes( prefixesHost3, 1 )
main.log.info( "Delete routes to Quagga on host4" )
- main.QuaggaCliHost4.delete_routes( prefixes_host4, 1 )
+ main.QuaggaCliHost4.deleteRoutes( prefixesHost4, 1 )
- get_routes_result = main.ONOScli.routes( json_format=True )
- allRoutes_actual = main.QuaggaCliHost3.extract_actual_routes(
- get_routes_result )
+ getRoutesResult = main.ONOScli.routes( jsonFormat=True )
+ allRoutesActual = \
+ main.QuaggaCliHost3.extractActualRoutes( getRoutesResult )
main.log.info( "allRoutes_actual = " )
- main.log.info( allRoutes_actual )
+ main.log.info( allRoutesActual )
- utilities.assert_equals(
- expect="[]",
- actual=str( allRoutes_actual ),
+ utilities.assertEquals(
+ expect="[]", actual=str( allRoutesActual ),
onpass="***Route number in SDN-IP is 0, correct!***",
onfail="***Routes number in SDN-IP is not 0, wrong!***" )
- if( eq( allRoutes_str_expected, allRoutes_str_actual ) ):
+ if( eq( allRoutesStrExpected, allRoutesStrActual ) ):
main.log.report(
"***Routes in SDN-IP after deleting correct!***" )
else:
@@ -525,31 +1123,37 @@
"***Routes in SDN-IP after deleting wrong!***" )
main.step( "Check intents after deleting routes" )
- get_intents_result = main.ONOScli.intents( json_format=True )
- routeIntents_actual = main.QuaggaCliHost3.extract_actual_routeIntents(
- get_intents_result )
+ getIntentsResult = main.ONOScli.intents( jsonFormat=True )
+ routeIntentsActual = \
+ main.QuaggaCliHost3.extractActualRouteIntents(
+ getIntentsResult )
main.log.info( "main.ONOScli.intents()= " )
- main.log.info( routeIntents_actual )
- utilities.assert_equals(
- expect="[]",
- actual=str( routeIntents_actual ),
- onpass="***MultiPointToSinglePoint Intents number in SDN-IP is 0, correct!***",
- onfail="***MultiPointToSinglePoint Intents number in SDN-IP is 0, wrong!***" )
+ main.log.info( routeIntentsActual )
+ utilities.assertEquals(
+ expect="[]", actual=str( routeIntentsActual ),
+ onpass=
+ "***MultiPointToSinglePoint Intents number in SDN-IP \
+ is 0, correct!***",
+ onfail="***MultiPointToSinglePoint Intents number in SDN-IP \
+ is 0, wrong!***" )
- if( eq( routeIntents_str_expected, routeIntents_str_actual ) ):
+ if( eq( routeIntentsStrExpected, routeIntentsStrActual ) ):
main.log.report(
- "***MultiPointToSinglePoint Intents after deleting routes correct!***" )
+ "***MultiPointToSinglePoint Intents after deleting \
+ routes correct!***" )
else:
main.log.report(
- "***MultiPointToSinglePoint Intents after deleting routes wrong!***" )
+ "***MultiPointToSinglePoint Intents after deleting \
+ routes wrong!***" )
time.sleep( 20 )
- # ping_test_script = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
- ping_test_results_file = "~/SDNIP/SdnIpIntentDemo/log/CASE2-Round" + \
- str( round_num ) + "-ping-results-after-delete-routes-" + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
- ping_test_results = main.QuaggaCliHost.ping_test(
- "1.168.30.100",
- ping_test_script,
- ping_test_results_file )
- main.log.info( ping_test_results )
+ # pingTestScript = "~/SDNIP/SdnIpIntentDemo/CASE1-ping-as2host.sh"
+ pingTestResultsFile = \
+ "~/SDNIP/SdnIpIntentDemo/log/CASE2-Round" \
+ + str( roundNum ) + "-ping-results-after-delete-routes-" \
+ + strftime( "%Y-%m-%d_%H:%M:%S", localtime() ) + ".txt"
+ pingTestResults = main.QuaggaCliHost.pingTest(
+ "1.168.30.100", pingTestScript, pingTestResultsFile )
+ main.log.info( pingTestResults )
time.sleep( 30 )
+
diff --git a/TestON/tests/SdnIpTest/SdnIpTest.topo b/TestON/tests/SdnIpTest/SdnIpTest.topo
index 6df1975..fe9d1bb 100755
--- a/TestON/tests/SdnIpTest/SdnIpTest.topo
+++ b/TestON/tests/SdnIpTest/SdnIpTest.topo
@@ -33,7 +33,7 @@
<user>admin</user>
<password>onos_test</password>
<type>QuaggaCliDriver</type>
- <connect_order>5</connect_order>
+ <connect_order>4</connect_order>
<COMPONENTS> </COMPONENTS>
</QuaggaCliHost3>
<QuaggaCliHost4>
@@ -44,14 +44,827 @@
<connect_order>5</connect_order>
<COMPONENTS> </COMPONENTS>
</QuaggaCliHost4>
+ <QuaggaCliHost5>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>6</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost5>
+
<QuaggaCliHost>
<host>127.0.0.1</host>
<user>admin</user>
<password>onos_test</password>
<type>QuaggaCliDriver</type>
- <connect_order>5</connect_order>
+ <connect_order>7</connect_order>
<COMPONENTS> </COMPONENTS>
</QuaggaCliHost>
+ <QuaggaCliHost101>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>101</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost101>
+ <QuaggaCliHost102>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>102</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost102>
+ <QuaggaCliHost103>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>103</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost103>
+ <QuaggaCliHost104>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>104</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost104>
+ <QuaggaCliHost105>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>105</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost105>
+ <QuaggaCliHost106>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>106</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost106>
+ <QuaggaCliHost107>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>107</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost107>
+ <QuaggaCliHost108>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>108</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost108>
+ <QuaggaCliHost109>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>109</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost109>
+ <QuaggaCliHost110>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>110</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost110>
+ <QuaggaCliHost111>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>111</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost111>
+ <QuaggaCliHost112>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>112</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost112>
+ <QuaggaCliHost113>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>113</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost113>
+ <QuaggaCliHost114>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>114</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost114>
+ <QuaggaCliHost115>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>115</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost115>
+ <QuaggaCliHost116>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>116</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost116>
+ <QuaggaCliHost117>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>117</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost117>
+ <QuaggaCliHost118>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>118</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost118>
+ <QuaggaCliHost119>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>119</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost119>
+ <QuaggaCliHost120>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>120</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost120>
+ <QuaggaCliHost121>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>121</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost121>
+ <QuaggaCliHost122>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>122</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost122>
+ <QuaggaCliHost123>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>123</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost123>
+ <QuaggaCliHost124>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>124</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost124>
+ <QuaggaCliHost125>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>125</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost125>
+ <QuaggaCliHost126>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>126</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost126>
+ <QuaggaCliHost127>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>127</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost127>
+ <QuaggaCliHost128>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>128</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost128>
+ <QuaggaCliHost129>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>129</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost129>
+ <QuaggaCliHost130>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>130</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost130>
+ <QuaggaCliHost131>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>131</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost131>
+ <QuaggaCliHost132>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>132</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost132>
+ <QuaggaCliHost133>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>133</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost133>
+ <QuaggaCliHost134>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>134</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost134>
+ <QuaggaCliHost135>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>135</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost135>
+ <QuaggaCliHost136>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>136</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost136>
+ <QuaggaCliHost137>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>137</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost137>
+ <QuaggaCliHost138>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>138</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost138>
+ <QuaggaCliHost139>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>139</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost139>
+ <QuaggaCliHost140>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>140</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost140>
+ <QuaggaCliHost141>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>141</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost141>
+ <QuaggaCliHost142>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>142</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost142>
+ <QuaggaCliHost143>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>143</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost143>
+ <QuaggaCliHost144>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>144</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost144>
+ <QuaggaCliHost145>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>145</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost145>
+ <QuaggaCliHost146>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>146</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost146>
+ <QuaggaCliHost147>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>147</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost147>
+ <QuaggaCliHost148>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>148</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost148>
+ <QuaggaCliHost149>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>149</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost149>
+ <QuaggaCliHost150>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>150</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost150>
+ <QuaggaCliHost151>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>151</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost151>
+ <QuaggaCliHost152>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>152</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost152>
+ <QuaggaCliHost153>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>153</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost153>
+ <QuaggaCliHost154>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>154</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost154>
+ <QuaggaCliHost155>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>155</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost155>
+ <QuaggaCliHost156>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>156</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost156>
+ <QuaggaCliHost157>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>157</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost157>
+ <QuaggaCliHost158>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>158</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost158>
+ <QuaggaCliHost159>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>159</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost159>
+ <QuaggaCliHost160>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>160</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost160>
+ <QuaggaCliHost161>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>161</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost161>
+ <QuaggaCliHost162>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>162</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost162>
+ <QuaggaCliHost163>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>163</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost163>
+ <QuaggaCliHost164>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>164</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost164>
+ <QuaggaCliHost165>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>165</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost165>
+ <QuaggaCliHost166>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>166</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost166>
+ <QuaggaCliHost167>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>167</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost167>
+ <QuaggaCliHost168>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>168</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost168>
+ <QuaggaCliHost169>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>169</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost169>
+ <QuaggaCliHost170>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>170</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost170>
+ <QuaggaCliHost171>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>171</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost171>
+ <QuaggaCliHost172>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>172</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost172>
+ <QuaggaCliHost173>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>173</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost173>
+ <QuaggaCliHost174>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>174</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost174>
+ <QuaggaCliHost175>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>175</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost175>
+ <QuaggaCliHost176>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>176</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost176>
+ <QuaggaCliHost177>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>177</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost177>
+ <QuaggaCliHost178>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>178</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost178>
+ <QuaggaCliHost179>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>179</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost179>
+ <QuaggaCliHost180>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>180</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost180>
+ <QuaggaCliHost181>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>181</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost181>
+ <QuaggaCliHost182>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>182</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost182>
+ <QuaggaCliHost183>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>183</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost183>
+ <QuaggaCliHost184>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>184</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost184>
+ <QuaggaCliHost185>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>185</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost185>
+ <QuaggaCliHost186>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>186</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost186>
+ <QuaggaCliHost187>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>187</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost187>
+ <QuaggaCliHost188>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>188</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost188>
+ <QuaggaCliHost189>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>189</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost189>
+ <QuaggaCliHost190>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>190</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost190>
+ <QuaggaCliHost191>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>191</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost191>
+ <QuaggaCliHost192>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>192</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost192>
+ <QuaggaCliHost193>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>193</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost193>
+
+ <QuaggaCliHost194>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>194</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost194>
+ <QuaggaCliHost195>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>195</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost195>
+ <QuaggaCliHost196>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>196</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost196>
+ <QuaggaCliHost197>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>197</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost197>
+ <QuaggaCliHost198>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>198</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost198>
+ <QuaggaCliHost199>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>199</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost199>
+ <QuaggaCliHost200>
+ <host>127.0.0.1</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>QuaggaCliDriver</type>
+ <connect_order>200</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </QuaggaCliHost200>
+
+
</COMPONENT>
</TOPOLOGY>
+
diff --git a/TestON/tests/TopoPerfNext/TopoPerfNext.params b/TestON/tests/TopoPerfNext/TopoPerfNext.params
index 8e31e62..e17d6bd 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.params
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.params
@@ -42,16 +42,17 @@
#pcap file located at /tmp/'capture_name'
<debugMode>off</debugMode>
<onosLogFile>/opt/onos/log/karaf*</onosLogFile>
+ <mci>off</mci>
- <topo_config_file>
+ <topoConfigFile>
single_topo_event_accumulator.cfg
- </topo_config_file>
- <topo_config_name>
+ </topoConfigFile>
+ <topoConfigName>
org.onlab.onos.net.topology.impl.DefaultTopologyProvider.cfg
- </topo_config_name>
+ </topoConfigName>
#Number of times to iterate each case
- <numIter>12</numIter>
+ <numIter>10</numIter>
<numSwitch>2</numSwitch>
#Number of iterations to ignore initially
<iterIgnore>2</iterIgnore>
diff --git a/TestON/tests/TopoPerfNext/TopoPerfNext.py b/TestON/tests/TopoPerfNext/TopoPerfNext.py
index b737f4c..d0b66c9 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.py
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.py
@@ -1,1931 +1,1938 @@
-#TopoPerfNext
+# TopoPerfNext
#
-#Topology Performance test for ONOS-next
+# Topology Performance test for ONOS-next
#
-#andrew@onlab.us
+# andrew@onlab.us
#
-#If your machine does not come with numpy
-#run the following command:
-#sudo apt-get install python-numpy python-scipy
+# If your machine does not come with numpy
+# run the following command:
+# sudo apt-get install python-numpy python-scipy
import time
import sys
import os
import re
+
class TopoPerfNext:
- def __init__(self):
+
+ def __init__( self ):
self.default = ''
- def CASE1(self, main):
- '''
+ def CASE1( self, main ):
+ """
ONOS startup sequence
- '''
+ """
import time
-
- ## Global cluster count for scale-out purposes
- global cluster_count
- #Set initial cluster count
- cluster_count = 1
+
+ # Global cluster count for scale-out purposes
+ global clusterCount
+ # Set initial cluster count
+ clusterCount = 1
##
- cell_name = main.params['ENV']['cellName']
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
- git_pull = main.params['GIT']['autoPull']
- checkout_branch = main.params['GIT']['checkout']
+ gitPull = main.params[ 'GIT' ][ 'autoPull' ]
+ checkoutBranch = main.params[ 'GIT' ][ 'checkout' ]
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
+ 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' ]
+
+ mvnCleanInstall = main.params[ 'TEST' ][ 'mci' ]
- #### Hardcoded ONOS nodes particular to my env ####
- ONOS4_ip = "10.128.174.4"
- ONOS5_ip = "10.128.174.5"
- ONOS6_ip = "10.128.174.6"
- ONOS7_ip = "10.128.174.7"
- #### ####
+ 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( "\$" )
- MN1_ip = main.params['MN']['ip1']
- BENCH_ip = main.params['BENCH']['ip']
+ main.log.report( "Setting up test environment" )
- topo_cfg_file = main.params['TEST']['topo_config_file']
- topo_cfg_name = main.params['TEST']['topo_config_name']
-
- main.case("Setting up test environment")
- main.log.info("Copying topology event accumulator config"+\
- " to ONOS /package/etc")
- main.ONOSbench.handle.sendline("cp ~/"+\
- topo_cfg_file+\
- " ~/ONOS/tools/package/etc/"+\
- topo_cfg_name)
- main.ONOSbench.handle.expect("\$")
+ 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.log.report("Setting up test environment")
+ main.step( "Creating cell file" )
+ cellFileResult = main.ONOSbench.createCellFile(
+ BENCHIp, cellName, MN1Ip,
+ "onos-core,onos-app-metrics,onos-app-gui",
+ ONOS1Ip )
- main.step("Cleaning previously installed ONOS if any")
- main.ONOSbench.onos_uninstall(node_ip=ONOS2_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS3_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS4_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS5_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS6_ip)
- main.ONOSbench.onos_uninstall(node_ip=ONOS7_ip)
+ main.step( "Applying cell file to environment" )
+ cellApplyResult = main.ONOSbench.setCell( cellName )
+ verifyCellResult = main.ONOSbench.verifyCell()
- main.step("Creating cell file")
- cell_file_result = main.ONOSbench.create_cell_file(
- BENCH_ip, cell_name, MN1_ip,
- "onos-core,onos-app-metrics,onos-app-gui",
- ONOS1_ip)
-
- main.step("Applying cell file to environment")
- cell_apply_result = main.ONOSbench.set_cell(cell_name)
- verify_cell_result = main.ONOSbench.verify_cell()
-
- #NOTE: This step may be removed after proper
+ # NOTE: This step may be removed after proper
# copy cat log functionality
- main.step("Removing raft/copy-cat logs from ONOS nodes")
- main.ONOSbench.onos_remove_raft_logs()
- time.sleep(30)
+ main.step( "Removing raft/copy-cat logs from ONOS nodes" )
+ main.ONOSbench.onosRemoveRaftLogs()
+ time.sleep( 30 )
- main.step("Git checkout and pull "+checkout_branch)
- if git_pull == 'on':
- #checkout_result = \
- # main.ONOSbench.git_checkout(checkout_branch)
- checkout_result = main.TRUE
- pull_result = main.ONOSbench.git_pull()
+ main.step( "Git checkout and pull " + checkoutBranch )
+ if gitPull == 'on':
+ # checkoutResult = \
+ # main.ONOSbench.gitCheckout( checkoutBranch )
+ checkoutResult = main.TRUE
+ pullResult = main.ONOSbench.gitPull()
else:
- checkout_result = main.TRUE
- pull_result = main.TRUE
- main.log.info("Skipped git checkout and pull")
+ checkoutResult = main.TRUE
+ pullResult = main.TRUE
+ main.log.info( "Skipped git checkout and pull" )
- main.log.report("Commit information - ")
- main.ONOSbench.get_version(report=True)
+ main.log.report( "Commit information - " )
+ main.ONOSbench.getVersion( report=True )
- main.step("Using mvn clean & install")
- mvn_result = main.ONOSbench.clean_install()
- mvn_result = main.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.set_cell(cell_name)
- #main.ONOS2cli.set_cell(cell_name)
- #main.ONOS3cli.set_cell(cell_name)
+ main.step( "Set cell for ONOS cli env" )
+ main.ONOS1cli.setCell( cellName )
+ # main.ONOS2cli.setCell( cellName )
+ # main.ONOS3cli.setCell( cellName )
- main.step("Creating ONOS package")
- package_result = main.ONOSbench.onos_package()
+ main.step( "Creating ONOS package" )
+ packageResult = main.ONOSbench.onosPackage()
- main.step("Installing ONOS package")
- install1_result = main.ONOSbench.onos_install(node=ONOS1_ip)
- #install2_result = main.ONOSbench.onos_install(node=ONOS2_ip)
- #install3_result = main.ONOSbench.onos_install(node=ONOS3_ip)
+ main.step( "Installing ONOS package" )
+ install1Result = main.ONOSbench.onosInstall( node=ONOS1Ip )
+ #install2Result = main.ONOSbench.onosInstall( node=ONOS2Ip )
+ #install3Result = main.ONOSbench.onosInstall( node=ONOS3Ip )
- time.sleep(10)
+ time.sleep( 10 )
- main.step("Start onos cli")
- cli1 = main.ONOS1cli.start_onos_cli(ONOS1_ip)
- #cli2 = main.ONOS2cli.start_onos_cli(ONOS2_ip)
- #cli3 = main.ONOS3cli.start_onos_cli(ONOS3_ip)
+ main.step( "Start onos cli" )
+ cli1 = main.ONOS1cli.startOnosCli( ONOS1Ip )
+ #cli2 = main.ONOS2cli.startOnosCli( ONOS2Ip )
+ #cli3 = main.ONOS3cli.startOnosCli( ONOS3Ip )
- utilities.assert_equals(expect=main.TRUE,
- actual= cell_file_result and cell_apply_result and\
- verify_cell_result and checkout_result and\
- pull_result and mvn_result and\
- install1_result, #and install2_result and\
- #install3_result,
- onpass="Test Environment setup successful",
- onfail="Failed to setup test environment")
+ utilities.assert_equals( expect=main.TRUE,
+ actual=cellFileResult and cellApplyResult and
+ verifyCellResult and checkoutResult and
+ pullResult and mvnResult and
+ install1Result, # and install2Result and
+ # install3Result,
+ onpass="Test Environment setup successful",
+ onfail="Failed to setup test environment" )
- def CASE2(self, main):
- '''
+ 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
+ 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
+ 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)
- '''
+ 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
- global cluster_count
+ global clusterCount
- 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']
+ 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' ]
- ONOS_user = main.params['CTRL']['user']
+ ONOSUser = main.params[ 'CTRL' ][ 'user' ]
- default_sw_port = main.params['CTRL']['port1']
-
- #Number of iterations of case
- num_iter = main.params['TEST']['numIter']
- #Number of first 'x' iterations to ignore:
- iter_ignore = int(main.params['TEST']['iterIgnore'])
+ defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
- #Timestamp 'keys' for json metrics output.
- #These are subject to change, hence moved into params
- deviceTimestamp = main.params['JSON']['deviceTimestamp']
- graphTimestamp = main.params['JSON']['graphTimestamp']
+ # Number of iterations of case
+ numIter = main.params[ 'TEST' ][ 'numIter' ]
+ # Number of first 'x' iterations to ignore:
+ iterIgnore = int( main.params[ 'TEST' ][ 'iterIgnore' ] )
- debug_mode = main.params['TEST']['debugMode']
- onos_log = main.params['TEST']['onosLogFile']
+ # Timestamp 'keys' for json metrics output.
+ # These are subject to change, hence moved into params
+ deviceTimestamp = main.params[ 'JSON' ][ 'deviceTimestamp' ]
+ graphTimestamp = main.params[ 'JSON' ][ 'graphTimestamp' ]
- #Threshold for the test
- threshold_str = main.params['TEST']['singleSwThreshold']
- threshold_obj = threshold_str.split(",")
- threshold_min = int(threshold_obj[0])
- threshold_max = int(threshold_obj[1])
+ debugMode = main.params[ 'TEST' ][ 'debugMode' ]
+ onosLog = main.params[ 'TEST' ][ 'onosLogFile' ]
- #List of switch add latency collected from
- #all iterations
- latency_end_to_end_list = []
- latency_ofp_to_graph_list = []
- latency_ofp_to_device_list = []
- latency_t0_to_device_list = []
- latency_tcp_to_ofp_list = []
+ # Threshold for the test
+ thresholdStr = main.params[ 'TEST' ][ 'singleSwThreshold' ]
+ thresholdObj = thresholdStr.split( "," )
+ thresholdMin = int( thresholdObj[ 0 ] )
+ thresholdMax = int( thresholdObj[ 1 ] )
- #Directory/file to store tshark results
- tshark_of_output = "/tmp/tshark_of_topo.txt"
- tshark_tcp_output = "/tmp/tshark_tcp_topo.txt"
+ # List of switch add latency collected from
+ # all iterations
+ latencyEndToEndList = []
+ latencyOfpToGraphList = []
+ latencyOfpToDeviceList = []
+ latencyT0ToDeviceList = []
+ latencyTcpToOfpList = []
- #String to grep in tshark output
- tshark_tcp_string = "TCP 74 "+default_sw_port
- tshark_of_string = "OFP 86 Vendor"
-
- #Initialize assertion to TRUE
+ # Initialize 2d array for [node][iteration] storage
+ endToEndLatNodeIter = numpy.zeros(( clusterCount, int(numIter) ))
+ ofpToGraphLatNodeIter = numpy.zeros(( clusterCount, int(numIter) ))
+ # tcp-to-ofp measurements are same throughout each iteration
+ tcpToOfpLatIter = []
+
+ # Directory/file to store tshark results
+ tsharkOfOutput = "/tmp/tshark_of_topo.txt"
+ tsharkTcpOutput = "/tmp/tshark_tcp_topo.txt"
+
+ # String to grep in tshark output
+ tsharkTcpString = "TCP 74 " + defaultSwPort
+ tsharkOfString = "OFP 86 Vendor"
+
+ # Initialize assertion to TRUE
assertion = main.TRUE
-
- local_time = time.strftime('%x %X')
- local_time = local_time.replace("/","")
- local_time = local_time.replace(" ","_")
- local_time = local_time.replace(":","")
- if debug_mode == 'on':
- main.ONOS1.tshark_pcap("eth0",
- "/tmp/single_sw_lat_pcap_"+local_time)
- main.log.info("Debug mode is on")
+ 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.report("Latency of adding one switch to controller")
- main.log.report("First "+str(iter_ignore)+" iterations ignored"+
- " for jvm warmup time")
- main.log.report("Total iterations of test: "+str(num_iter))
+ main.log.info( "Debug mode is on" )
- for i in range(0, int(num_iter)):
- main.log.info("Starting tshark capture")
+ 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 ) )
- #* TCP [ACK, SYN] is used as t0_a, the
- # very first "exchange" between ONOS and
+ for i in range( 0, int( numIter ) ):
+ main.log.info( "Starting tshark capture" )
+
+ #* TCP [ ACK, SYN ] is used as t0A, the
+ # very first "exchange" between ONOS and
# the switch for end-to-end measurement
- #* OFP [Stats Reply] is used for t0_b
+ #* OFP [ Stats Reply ] is used for t0B
# the very last OFP message between ONOS
# and the switch for ONOS measurement
- main.ONOS1.tshark_grep(tshark_tcp_string,
- tshark_tcp_output)
- main.ONOS1.tshark_grep(tshark_of_string,
- tshark_of_output)
+ main.ONOS1.tsharkGrep( tsharkTcpString,
+ tsharkTcpOutput )
+ main.ONOS1.tsharkGrep( tsharkOfString,
+ tsharkOfOutput )
- #Wait and ensure tshark is started and
- #capturing
- time.sleep(10)
+ # Wait and ensure tshark is started and
+ # capturing
+ time.sleep( 10 )
- main.log.info("Assigning s1 to controller")
+ main.log.info( "Assigning s1 to controller" )
- main.Mininet1.assign_sw_controller(sw="1",
- ip1=ONOS1_ip, port1=default_sw_port)
+ main.Mininet1.assignSwController(
+ sw="1",
+ ip1=ONOS1Ip,
+ port1=defaultSwPort )
- #Wait and ensure switch is assigned
- #before stopping tshark
- time.sleep(30)
-
- main.log.info("Stopping all Tshark processes")
- main.ONOS1.stop_tshark()
+ # Wait and ensure switch is assigned
+ # before stopping tshark
+ time.sleep( 30 )
- #tshark output is saved in ONOS. Use subprocess
- #to copy over files to TestON for parsing
- main.log.info("Copying over tshark files")
-
- #TCP CAPTURE ****
- #Copy the tshark output from ONOS machine to
- #TestON machine in tshark_tcp_output directory>file
- os.system("scp "+ONOS_user+"@"+ONOS1_ip+":"+
- tshark_tcp_output+" /tmp/")
- tcp_file = open(tshark_tcp_output, 'r')
- temp_text = tcp_file.readline()
- temp_text = temp_text.split(" ")
+ main.log.info( "Stopping all Tshark processes" )
+ main.ONOS1.stopTshark()
- main.log.info("Object read in from TCP capture: "+
- str(temp_text))
- if len(temp_text) > 1:
- t0_tcp = float(temp_text[1])*1000.0
+ # tshark output is saved in ONOS. Use subprocess
+ # to copy over files to TestON for parsing
+ main.log.info( "Copying over tshark files" )
+
+ # TCP CAPTURE ****
+ # Copy the tshark output from ONOS machine to
+ # TestON machine in tsharkTcpOutput directory>file
+ os.system( "scp " + ONOSUser + "@" + ONOS1Ip + ":" +
+ tsharkTcpOutput + " /tmp/" )
+ 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")
- t0_tcp = 0
+ main.log.error( "Tshark output file for TCP" +
+ " returned unexpected results" )
+ t0Tcp = 0
assertion = main.FALSE
-
- tcp_file.close()
+
+ tcpFile.close()
#****************
- #OF CAPTURE ****
- os.system("scp "+ONOS_user+"@"+ONOS1_ip+":"+
- tshark_of_output+" /tmp/")
- of_file = open(tshark_of_output, 'r')
-
- line_ofp = ""
- #Read until last line of file
+ # OF CAPTURE ****
+ os.system( "scp " + ONOSUser + "@" + ONOS1Ip + ":" +
+ tsharkOfOutput + " /tmp/" )
+ ofFile = open( tsharkOfOutput, 'r' )
+
+ lineOfp = ""
+ # Read until last line of file
while True:
- temp_text = of_file.readline()
- if temp_text !='':
- line_ofp = temp_text
+ tempText = ofFile.readline()
+ if tempText != '':
+ lineOfp = tempText
else:
- break
- obj = line_ofp.split(" ")
-
- main.log.info("Object read in from OFP capture: "+
- str(line_ofp))
-
- if len(line_ofp) > 1:
- t0_ofp = float(obj[1])*1000.0
+ break
+ obj = lineOfp.split( " " )
+
+ main.log.info( "Object read in from OFP capture: " +
+ str( lineOfp ) )
+
+ if len( lineOfp ) > 1:
+ t0Ofp = float( obj[ 1 ] ) * 1000.0
else:
- main.log.error("Tshark output file for OFP"+
- " returned unexpected results")
- t0_ofp = 0
+ main.log.error( "Tshark output file for OFP" +
+ " returned unexpected results" )
+ t0Ofp = 0
assertion = main.FALSE
-
- of_file.close()
+
+ ofFile.close()
#****************
+
+ jsonStr1 = main.ONOS1cli.topologyEventsMetrics()
+ # Initialize scale-out variables
+ jsonStr2 = ""
+ jsonStr3 = ""
+ jsonStr4 = ""
+ jsonStr5 = ""
+ jsonStr6 = ""
+ jsonStr7 = ""
+
+ jsonObj1 = json.loads( jsonStr1 )
+ # Initialize scale-out variables
+ jsonObj2 = ""
+ jsonObj3 = ""
+ jsonObj4 = ""
+ jsonObj5 = ""
+ jsonObj6 = ""
+ jsonObj7 = ""
+
+ # Obtain graph timestamp. This timestsamp captures
+ # the epoch time at which the topology graph was updated.
+ graphTimestamp1 = \
+ jsonObj1[ graphTimestamp ][ 'value' ]
+ # Obtain device timestamp. This timestamp captures
+ # the epoch time at which the device event happened
+ deviceTimestamp1 = \
+ jsonObj1[ deviceTimestamp ][ 'value' ]
+
+ # t0 to device processing latency
+ deltaDevice1 = int( deviceTimestamp1 ) - int( t0Tcp )
+ # t0 to graph processing latency ( end-to-end )
+ deltaGraph1 = int( graphTimestamp1 ) - int( t0Tcp )
+ # ofp to graph processing latency ( ONOS processing )
+ deltaOfpGraph1 = int( graphTimestamp1 ) - int( t0Ofp )
+ # ofp to device processing latency ( ONOS processing )
+ deltaOfpDevice1 = float( deviceTimestamp1 ) - float( t0Ofp )
+ # tcp to ofp processing latency ( switch connection )
+ deltaTcpOfp1 = int(t0Ofp) - int(t0Tcp)
+
+ if deltaTcpOfp1 > thresholdMin and deltaTcpOfp1 < thresholdMax\
+ and i >= iterIgnore:
+ tcpToOfpLatIter.append(deltaTcpOfp1)
+ main.log.info("iter"+str(i)+" tcp-to-ofp: "+
+ str(deltaTcpOfp1)+" ms")
+ else:
+ tcpToOfpLatIter.append(0)
+ main.log.info("iter"+str(i)+" tcp-to-ofp: "+
+ str(deltaTcpOfp1)+" ms - ignored this iteration")
+
+ # Store initial measurements in data array
+ #This measurement is for node 1
- json_str_1 = main.ONOS1cli.topology_events_metrics()
- #Initialize scale-out variables
- json_str_2 = ""
- json_str_3 = ""
- json_str_4 = ""
- json_str_5 = ""
- json_str_6 = ""
- json_str_7 = ""
-
- json_obj_1 = json.loads(json_str_1)
- #Initialize scale-out variables
- json_obj_2 = ""
- json_obj_3 = ""
- json_obj_4 = ""
- json_obj_5 = ""
- json_obj_6 = ""
- json_obj_7 = ""
-
- #Obtain graph timestamp. This timestsamp captures
- #the epoch time at which the topology graph was updated.
- graph_timestamp_1 = \
- json_obj_1[graphTimestamp]['value']
- #Obtain device timestamp. This timestamp captures
- #the epoch time at which the device event happened
- device_timestamp_1 = \
- json_obj_1[deviceTimestamp]['value']
-
- #t0 to device processing latency
- delta_device_1 = int(device_timestamp_1) - int(t0_tcp)
-
- #t0 to graph processing latency (end-to-end)
- delta_graph_1 = int(graph_timestamp_1) - int(t0_tcp)
-
- #ofp to graph processing latency (ONOS processing)
- delta_ofp_graph_1 = int(graph_timestamp_1) - int(t0_ofp)
-
- #ofp to device processing latency (ONOS processing)
- delta_ofp_device_1 = float(device_timestamp_1) - float(t0_ofp)
-
- #TODO: Create even cluster number events
-
- #Include scale-out measurements when applicable
- if cluster_count >= 3:
- json_str_2 = main.ONOS2cli.topology_events_metrics()
- json_str_3 = main.ONOS3cli.topology_events_metrics()
- json_obj_2 = json.loads(json_str_2)
- json_obj_3 = json.loads(json_str_3)
- graph_timestamp_2 = \
- json_obj_2[graphTimestamp]['value']
- graph_timestamp_3 = \
- json_obj_3[graphTimestamp]['value']
- device_timestamp_2 = \
- json_obj_2[deviceTimestamp]['value']
- device_timestamp_3 = \
- json_obj_3[deviceTimestamp]['value']
- delta_device_2 = int(device_timestamp_2) - int(t0_tcp)
- delta_device_3 = int(device_timestamp_3) - int(t0_tcp)
- delta_graph_2 = int(graph_timestamp_2) - int(t0_tcp)
- delta_graph_3 = int(graph_timestamp_3) - int(t0_tcp)
- delta_ofp_graph_2 = int(graph_timestamp_2) - int(t0_ofp)
- delta_ofp_graph_3 = int(graph_timestamp_3) - int(t0_ofp)
- delta_ofp_device_2 = float(device_timestamp_2) -\
- float(t0_ofp)
- delta_ofp_device_3 = float(device_timestamp_3) -\
- float(t0_ofp)
+ 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:
- delta_device_2 = 0
- delta_device_3 = 0
- delta_graph_2 = 0
- delta_graph_3 = 0
- delta_ofp_graph_2 = 0
- delta_ofp_graph_3 = 0
- delta_ofp_device_2 = 0
- delta_ofp_device_3 = 0
+ main.log.info("ONOS1 iter"+str(i)+" end-to-end: "+
+ str(deltaGraph1)+" ms - ignored this iteration")
- if cluster_count >= 5:
- json_str_4 = main.ONOS4cli.topology_events_metrics()
- json_str_5 = main.ONOS5cli.topology_events_metrics()
- json_obj_4 = json.loads(json_str_4)
- json_obj_5 = json.loads(json_str_5)
- graph_timestamp_4 = \
- json_obj_4[graphTimestamp]['value']
- graph_timestamp_5 = \
- json_obj_5[graphTimestamp]['value']
- device_timestamp_4 = \
- json_obj_4[deviceTimestamp]['value']
- device_timestamp_5 = \
- json_obj_5[deviceTimestamp]['value']
- delta_device_4 = int(device_timestamp_4) - int(t0_tcp)
- delta_device_5 = int(device_timestamp_5) - int(t0_tcp)
- delta_graph_4 = int(graph_timestamp_4) - int(t0_tcp)
- delta_graph_5 = int(graph_timestamp_5) - int(t0_tcp)
- delta_ofp_graph_4 = int(graph_timestamp_4) - int(t0_ofp)
- delta_ofp_graph_5 = int(graph_timestamp_5) - int(t0_ofp)
- delta_ofp_device_4 = float(device_timestamp_4) -\
- float(t0_ofp)
- delta_ofp_device_5 = float(device_timestamp_5) -\
- float(t0_ofp)
- else:
- delta_device_4 = 0
- delta_device_5 = 0
- delta_graph_4 = 0
- delta_graph_5 = 0
- delta_ofp_graph_4 = 0
- delta_ofp_graph_5 = 0
- delta_ofp_device_4 = 0
- delta_ofp_device_5 = 0
- if cluster_count >= 7:
- json_str_6 = main.ONOS6cli.topology_events_metrics()
- json_str_7 = main.ONOS7cli.topology_events_metrics()
- json_obj_6 = json.loads(json_str_6)
- json_obj_7 = json.loads(json_str_7)
- graph_timestamp_6 = \
- json_obj_6[graphTimestamp]['value']
- graph_timestamp_7 = \
- json_obj_7[graphTimestamp]['value']
- device_timestamp_6 = \
- json_obj_6[deviceTimestamp]['value']
- device_timestamp_7 = \
- json_obj_7[deviceTimestamp]['value']
- delta_device_6 = int(device_timestamp_6) - int(t0_tcp)
- delta_device_7 = int(device_timestamp_7) - int(t0_tcp)
- delta_graph_6 = int(graph_timestamp_6) - int(t0_tcp)
- delta_graph_7 = int(graph_timestamp_7) - int(t0_tcp)
- delta_ofp_graph_6 = int(graph_timestamp_6) - int(t0_ofp)
- delta_ofp_graph_7 = int(graph_timestamp_7) - int(t0_ofp)
- delta_ofp_device_6 = float(device_timestamp_6) -\
- float(t0_ofp)
- delta_ofp_device_7 = float(device_timestamp_7) -\
- float(t0_ofp)
- else:
- delta_device_6 = 0
- delta_device_7 = 0
- delta_graph_6 = 0
- delta_graph_7 = 0
- delta_ofp_graph_6 = 0
- delta_ofp_graph_7 = 0
- delta_ofp_device_6 = 0
- delta_ofp_device_7 = 0
+ 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")
- #Get average of delta from all instances
- avg_delta_device = \
- (int(delta_device_1)+\
- int(delta_device_2)+\
- int(delta_device_3)+\
- int(delta_device_4)+\
- int(delta_device_5)+\
- int(delta_device_6)+\
- int(delta_device_7)) / cluster_count
+ # TODO: Create even cluster number events
- #Ensure avg delta meets the threshold before appending
- if avg_delta_device > 0.0 and avg_delta_device < 10000\
- and int(i) > iter_ignore:
- latency_t0_to_device_list.append(avg_delta_device)
- else:
- main.log.info("Results for t0-to-device ignored"+\
- "due to excess in threshold / warmup iteration.")
+ # Include scale-out measurements when applicable
+ 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 = float( deviceTimestamp2 ) -\
+ float( t0Ofp )
+ deltaOfpDevice3 = float( deviceTimestamp3 ) -\
+ float( t0Ofp )
- #Get average of delta from all instances
- #TODO: use max delta graph
- #max_delta_graph = max(three)
- avg_delta_graph = \
- (int(delta_graph_1)+\
- int(delta_graph_2)+\
- int(delta_graph_3)+\
- int(delta_graph_4)+\
- int(delta_graph_5)+\
- int(delta_graph_6)+\
- int(delta_graph_7)) / cluster_count
+ 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")
- #Ensure avg delta meets the threshold before appending
- if avg_delta_graph > 0.0 and avg_delta_graph < 10000\
- and int(i) > iter_ignore:
- latency_end_to_end_list.append(avg_delta_graph)
- else:
- main.log.info("Results for end-to-end ignored"+\
- "due to excess in threshold")
+ 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 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 = float( deviceTimestamp4 ) -\
+ float( t0Ofp )
+ deltaOfpDevice5 = float( deviceTimestamp5 ) -\
+ float( 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")
+
+ #TODO:
+ 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")
-
- avg_delta_ofp_graph = \
- (int(delta_ofp_graph_1)+\
- int(delta_ofp_graph_2)+\
- int(delta_ofp_graph_3)+\
- int(delta_ofp_graph_4)+\
- int(delta_ofp_graph_5)+\
- int(delta_ofp_graph_6)+\
- int(delta_ofp_graph_7)) / cluster_count
-
- if avg_delta_ofp_graph > threshold_min \
- and avg_delta_ofp_graph < threshold_max\
- and int(i) > iter_ignore:
- latency_ofp_to_graph_list.append(avg_delta_ofp_graph)
- elif avg_delta_ofp_graph > (-10) and \
- avg_delta_ofp_graph < 0.0 and\
- int(i) > iter_ignore:
- main.log.info("Sub-millisecond result likely; "+
- "negative result was rounded to 0")
- #NOTE: Current metrics framework does not
- #support sub-millisecond accuracy. Therefore,
- #if the result is negative, we can reasonably
- #conclude sub-millisecond results and just
- #append the best rounded effort - 0 ms.
- latency_ofp_to_graph_list.append(0)
- else:
- main.log.info("Results for ofp-to-graph "+\
- "ignored due to excess in threshold")
+ 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 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 = float( deviceTimestamp6 ) -\
+ float( t0Ofp )
+ deltaOfpDevice7 = float( deviceTimestamp7 ) -\
+ float( 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")
+
+ #TODO:
+ 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")
-
- avg_delta_ofp_device = \
- (float(delta_ofp_device_1)+\
- float(delta_ofp_device_2)+\
- float(delta_ofp_device_3)+\
- float(delta_ofp_device_4)+\
- float(delta_ofp_device_5)+\
- float(delta_ofp_device_6)+\
- float(delta_ofp_device_7)) / cluster_count
-
- #NOTE: ofp - delta measurements are occasionally negative
- # due to system time misalignment.
- latency_ofp_to_device_list.append(avg_delta_ofp_device)
+ 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 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")
- delta_ofp_tcp = int(t0_ofp) - int(t0_tcp)
- if delta_ofp_tcp > threshold_min \
- and delta_ofp_tcp < threshold_max and\
- int(i) > iter_ignore:
- latency_tcp_to_ofp_list.append(delta_ofp_tcp)
- else:
- main.log.info("Results fo tcp-to-ofp "+\
- "ignored due to excess in threshold")
+ main.step( "Remove switch from controller" )
+ main.Mininet1.deleteSwController( "s1" )
- #TODO:
- #Fetch logs upon threshold excess
+ time.sleep( 5 )
- main.log.info("ONOS1 delta end-to-end: "+
- str(delta_graph_1) + " ms")
+ # END of for loop iteration
- main.log.info("ONOS1 delta OFP - graph: "+
- str(delta_ofp_graph_1) + " ms")
-
- main.log.info("ONOS1 delta device - t0: "+
- str(delta_device_1) + " ms")
-
- main.log.info("TCP to OFP delta: "+
- str(delta_ofp_tcp) + " ms")
+ #str( round( numpy.std( latencyT0ToDeviceList ), 1 ) )
- main.step("Remove switch from controller")
- main.Mininet1.delete_sw_controller("s1")
+ endToEndAvg = 0
+ ofpToGraphAvg = 0
+ endToEndList = []
+ ofpToGraphList = []
- time.sleep(5)
+ for node in range( 0, clusterCount ):
+ # The latency 2d array was initialized to 0.
+ # If an iteration was ignored, then we have some 0's in
+ # our calculation. To avoid having this interfere with our
+ # results, we must delete any index where 0 is found...
+ # WARN: Potentially, we could have latency that hovers at
+ # 0 ms once we have optimized code. FIXME for when this is
+ # the case. Being able to obtain sub-millisecond accuracy
+ # can prevent this from happening
+ for item in endToEndLatNodeIter[node]:
+ if item > 0.0:
+ endToEndList.append(item)
+ for item in ofpToGraphLatNodeIter[node]:
+ if item > 0.0:
+ ofpToGraphList.append(item)
- #END of for loop iteration
+ endToEndAvg = numpy.mean(endToEndList)
+ ofpToGraphAvg = numpy.mean(ofpToGraphList)
- #If there is at least 1 element in each list,
- #pass the test case
- if len(latency_end_to_end_list) > 0 and\
- len(latency_ofp_to_graph_list) > 0 and\
- len(latency_ofp_to_device_list) > 0 and\
- len(latency_t0_to_device_list) > 0 and\
- len(latency_tcp_to_ofp_list) > 0:
- assertion = main.TRUE
- elif len(latency_end_to_end_list) == 0:
- #The appending of 0 here is to prevent
- #the min,max,sum functions from failing
- #below
- latency_end_to_end_list.append(0)
- assertion = main.FALSE
- elif len(latency_ofp_to_graph_list) == 0:
- latency_ofp_to_graph_list.append(0)
- assertion = main.FALSE
- elif len(latency_ofp_to_device_list) == 0:
- latency_ofp_to_device_list.append(0)
- assertion = main.FALSE
- elif len(latency_t0_to_device_list) == 0:
- latency_t0_to_device_list.append(0)
- assertion = main.FALSE
- elif len(latency_tcp_to_ofp_list) == 0:
- latency_tcp_to_ofp_list.append(0)
- assertion = main.FALSE
+ main.log.report( " - Node "+str(node+1)+" Summary - " )
+ main.log.report( " End-to-end Avg: "+
+ str(round(endToEndAvg,2))+" ms"+
+ " End-to-end Std dev: "+
+ str(round(numpy.std(endToEndList),2))+" ms")
+ #main.log.report( " Ofp-to-graph Avg: "+
+ # str(round(ofpToGraphAvg,2))+" ms"+
+ # " Ofp-to-graph Std dev: "+
+ # str(round(numpy.std(ofpToGraphList),2))+
+ # " ms")
- #Calculate min, max, avg of latency lists
- latency_end_to_end_max = \
- int(max(latency_end_to_end_list))
- latency_end_to_end_min = \
- int(min(latency_end_to_end_list))
- latency_end_to_end_avg = \
- (int(sum(latency_end_to_end_list)) / \
- len(latency_end_to_end_list))
- latency_end_to_end_std_dev = \
- str(round(numpy.std(latency_end_to_end_list),1))
+ if debugMode == 'on':
+ main.ONOS1.cpLogsToDir( "/opt/onos/log/karaf.log",
+ "/tmp/", copyFileName="sw_lat_karaf" )
- latency_ofp_to_graph_max = \
- int(max(latency_ofp_to_graph_list))
- latency_ofp_to_graph_min = \
- int(min(latency_ofp_to_graph_list))
- latency_ofp_to_graph_avg = \
- (int(sum(latency_ofp_to_graph_list)) / \
- len(latency_ofp_to_graph_list))
- latency_ofp_to_graph_std_dev = \
- str(round(numpy.std(latency_ofp_to_graph_list),1))
+ #TODO: correct assert
+ assertion = main.TRUE
- latency_ofp_to_device_max = \
- int(max(latency_ofp_to_device_list))
- latency_ofp_to_device_min = \
- int(min(latency_ofp_to_device_list))
- latency_ofp_to_device_avg = \
- (int(sum(latency_ofp_to_device_list)) / \
- len(latency_ofp_to_device_list))
- latency_ofp_to_device_std_dev = \
- str(round(numpy.std(latency_ofp_to_device_list),1))
+ utilities.assert_equals( expect=main.TRUE, actual=assertion,
+ onpass="Switch latency test successful",
+ onfail="Switch latency test failed" )
- latency_t0_to_device_max = \
- int(max(latency_t0_to_device_list))
- latency_t0_to_device_min = \
- int(min(latency_t0_to_device_list))
- latency_t0_to_device_avg = \
- (int(sum(latency_t0_to_device_list)) / \
- len(latency_t0_to_device_list))
- latency_ofp_to_device_std_dev = \
- str(round(numpy.std(latency_t0_to_device_list),1))
-
- latency_tcp_to_ofp_max = \
- int(max(latency_tcp_to_ofp_list))
- latency_tcp_to_ofp_min = \
- int(min(latency_tcp_to_ofp_list))
- latency_tcp_to_ofp_avg = \
- (int(sum(latency_tcp_to_ofp_list)) / \
- len(latency_tcp_to_ofp_list))
- latency_tcp_to_ofp_std_dev = \
- str(round(numpy.std(latency_tcp_to_ofp_list),1))
-
- main.log.report("Cluster size: "+str(cluster_count)+\
- " node(s)")
- main.log.report("Switch add - End-to-end latency: "+\
- "Avg: "+str(latency_end_to_end_avg)+" ms "+
- "Std Deviation: "+latency_end_to_end_std_dev+" ms")
- main.log.report("Switch add - OFP-to-Graph latency: "+\
- "Note: results are not accurate to sub-millisecond. "+
- "Any sub-millisecond results are rounded to 0 ms. ")
- main.log.report("Avg: "+str(latency_ofp_to_graph_avg)+" ms "+
- "Std Deviation: "+latency_ofp_to_graph_std_dev+" ms")
- main.log.report("Switch add - TCP-to-OFP latency: "+\
- "Avg: "+str(latency_tcp_to_ofp_avg)+" ms "+
- "Std Deviation: "+latency_tcp_to_ofp_std_dev+" ms")
-
- if debug_mode == 'on':
- main.ONOS1.cp_logs_to_dir("/opt/onos/log/karaf.log",
- "/tmp/", copy_file_name="sw_lat_karaf")
-
- utilities.assert_equals(expect=main.TRUE, actual=assertion,
- onpass="Switch latency test successful",
- onfail="Switch latency test failed")
-
- def CASE3(self, main):
- '''
+ 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
+
+ In ONOS-next, we must ensure that the port we are
manipulating is connected to another switch with a valid
connection. Otherwise, graph view will not be updated.
- '''
+ """
import time
import subprocess
import os
import requests
import json
import numpy
- global cluster_count
+ global clusterCount
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
- ONOS_user = main.params['CTRL']['user']
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOSUser = main.params[ 'CTRL' ][ 'user' ]
- default_sw_port = main.params['CTRL']['port1']
-
+ defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
+
assertion = main.TRUE
- #Number of iterations of case
- num_iter = main.params['TEST']['numIter']
-
- #Timestamp 'keys' for json metrics output.
- #These are subject to change, hence moved into params
- deviceTimestamp = main.params['JSON']['deviceTimestamp']
- graphTimestamp = main.params['JSON']['graphTimestamp']
-
- debug_mode = main.params['TEST']['debugMode']
+ # Number of iterations of case
+ numIter = main.params[ 'TEST' ][ 'numIter' ]
+ iterIgnore = int( main.params[ 'TEST' ][ 'iterIgnore' ] )
- local_time = time.strftime('%x %X')
- local_time = local_time.replace("/","")
- local_time = local_time.replace(" ","_")
- local_time = local_time.replace(":","")
- if debug_mode == 'on':
- main.ONOS1.tshark_pcap("eth0",
- "/tmp/port_lat_pcap_"+local_time)
+ # Timestamp 'keys' for json metrics output.
+ # These are subject to change, hence moved into params
+ deviceTimestamp = main.params[ 'JSON' ][ 'deviceTimestamp' ]
+ graphTimestamp = main.params[ 'JSON' ][ 'graphTimestamp' ]
- #Threshold for this test case
- up_threshold_str = main.params['TEST']['portUpThreshold']
- down_threshold_str = main.params['TEST']['portDownThreshold']
-
- up_threshold_obj = up_threshold_str.split(",")
- down_threshold_obj = down_threshold_str.split(",")
+ debugMode = main.params[ 'TEST' ][ 'debugMode' ]
- up_threshold_min = int(up_threshold_obj[0])
- up_threshold_max = int(up_threshold_obj[1])
+ 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 )
- down_threshold_min = int(down_threshold_obj[0])
- down_threshold_max = int(down_threshold_obj[1])
+ # Threshold for this test case
+ upThresholdStr = main.params[ 'TEST' ][ 'portUpThreshold' ]
+ downThresholdStr = main.params[ 'TEST' ][ 'portDownThreshold' ]
- #NOTE: Some hardcoded variables you may need to configure
+ upThresholdObj = upThresholdStr.split( "," )
+ downThresholdObj = downThresholdStr.split( "," )
+
+ upThresholdMin = int( upThresholdObj[ 0 ] )
+ upThresholdMax = int( upThresholdObj[ 1 ] )
+
+ downThresholdMin = int( downThresholdObj[ 0 ] )
+ downThresholdMax = int( downThresholdObj[ 1 ] )
+
+ # NOTE: Some hardcoded variables you may need to configure
# besides the params
-
- tshark_port_status = "OFP 130 Port Status"
- tshark_port_up = "/tmp/tshark_port_up.txt"
- tshark_port_down = "/tmp/tshark_port_down.txt"
- interface_config = "s1-eth1"
+ tsharkPortStatus = "OFP 130 Port Status"
- main.log.report("Port enable / disable latency")
- main.log.report("Simulated by ifconfig up / down")
- main.log.report("Total iterations of test: "+str(num_iter))
+ tsharkPortUp = "/tmp/tshark_port_up.txt"
+ tsharkPortDown = "/tmp/tshark_port_down.txt"
+ interfaceConfig = "s1-eth1"
- main.step("Assign switches s1 and s2 to controller 1")
- 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.log.report( "Port enable / disable latency" )
+ main.log.report( "Simulated by ifconfig up / down" )
+ main.log.report( "Total iterations of test: " + str( numIter ) )
- #Give enough time for metrics to propagate the
- #assign controller event. Otherwise, these events may
- #carry over to our measurements
- time.sleep(15)
+ 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 )
- port_up_device_to_ofp_list = []
- port_up_graph_to_ofp_list = []
- port_down_device_to_ofp_list = []
- port_down_graph_to_ofp_list = []
+ # Give enough time for metrics to propagate the
+ # assign controller event. Otherwise, these events may
+ # carry over to our measurements
+ time.sleep( 15 )
- for i in range(0, int(num_iter)):
- main.step("Starting wireshark capture for port status down")
- main.ONOS1.tshark_grep(tshark_port_status,
- tshark_port_down)
-
- time.sleep(5)
+ portUpDeviceToOfpList = []
+ portUpGraphToOfpList = []
+ portDownDeviceToOfpList = []
+ portDownGraphToOfpList = []
+
+ # Initialize 2d array filled with 0's
+ # arraySizeFormat[clusterCount][numIter]
+ portUpDevNodeIter = numpy.zeros(( clusterCount, int(numIter) ))
+ portUpGraphNodeIter = numpy.zeros(( clusterCount, int(numIter) ))
+ portDownDevNodeIter = numpy.zeros(( clusterCount, int(numIter) ))
+ portDownGraphNodeIter = numpy.zeros(( clusterCount, int(numIter) ))
- #Disable interface that is connected to switch 2
- main.step("Disable port: "+interface_config)
- main.Mininet1.handle.sendline("sh ifconfig "+
- interface_config+" down")
- main.Mininet1.handle.expect("mininet>")
+ for i in range( 0, int( numIter ) ):
+ main.step( "Starting wireshark capture for port status down" )
+ main.ONOS1.tsharkGrep( tsharkPortStatus,
+ tsharkPortDown )
- time.sleep(3)
- main.ONOS1.tshark_stop()
-
- #Copy tshark output file from ONOS to TestON instance
+ time.sleep( 5 )
+
+ # Disable interface that is connected to switch 2
+ main.step( "Disable port: " + interfaceConfig )
+ main.Mininet1.handle.sendline( "sh ifconfig " +
+ interfaceConfig + " down" )
+ main.Mininet1.handle.expect( "mininet>" )
+
+ time.sleep( 3 )
+ main.ONOS1.tsharkStop()
+
+ # Copy tshark output file from ONOS to TestON instance
#/tmp directory
- os.system("scp "+ONOS_user+"@"+ONOS1_ip+":"+
- tshark_port_down+" /tmp/")
+ os.system( "scp " + ONOSUser + "@" + ONOS1Ip + ":" +
+ tsharkPortDown + " /tmp/" )
- f_port_down = open(tshark_port_down, 'r')
- #Get first line of port down event from tshark
- f_line = f_port_down.readline()
- obj_down = f_line.split(" ")
- if len(f_line) > 0:
- #NOTE: obj_down[1] is a very unreliable
- # way to determine the timestamp. If
- # results seem way off, check the object
+ fPortDown = open( tsharkPortDown, 'r' )
+ # Get first line of port down event from tshark
+ fLine = fPortDown.readline()
+ objDown = fLine.split( " " )
+ if len( fLine ) > 0:
+ # NOTE: objDown[ 1 ] is a very unreliable
+ # way to determine the timestamp. If
+ # results seem way off, check the object
# itself by printing it out
- timestamp_begin_pt_down = int(float(obj_down[1])*1000)
- # For some reason, wireshark decides to record the
+ timestampBeginPtDown = int( float( objDown[ 1 ] ) * 1000 )
+ # For some reason, wireshark decides to record the
# timestamp at the 3rd object position instead of
- # 2nd at unpredictable times. This statement is
+ # 2nd at unpredictable times. This statement is
# used to capture that odd behavior and use the
# correct epoch time
- if timestamp_begin_pt_down < 1400000000000:
- timestamp_begin_pt_down = \
- int(float(obj_down[2])*1000)
+ if timestampBeginPtDown < 1400000000000:
+ timestampBeginPtDown = \
+ int( float( objDown[ 2 ] ) * 1000 )
- main.log.info("Port down begin timestamp: "+
- str(timestamp_begin_pt_down))
+ main.log.info( "Port down begin timestamp: " +
+ str( timestampBeginPtDown ) )
else:
- main.log.info("Tshark output file returned unexpected"+
- " results: "+str(obj_down))
- timestamp_begin_pt_down = 0
- f_port_down.close()
+ 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 )
+ # Obtain graph timestamp. This timestsamp captures
+ # the epoch time at which the topology graph was updated.
+ graphTimestamp1 = \
+ jsonObj1[ graphTimestamp ][ 'value' ]
+ # Obtain device timestamp. This timestamp captures
+ # the epoch time at which the device event happened
+ deviceTimestamp1 = \
+ jsonObj1[ deviceTimestamp ][ 'value' ]
+ # Get delta between graph event and OFP
+ ptDownGraphToOfp1 = int( graphTimestamp1 ) -\
+ int( timestampBeginPtDown )
+ # Get delta between device event and OFP
+ ptDownDeviceToOfp1 = int( deviceTimestamp1 ) -\
+ int( timestampBeginPtDown )
+
+ if ptDownGraphToOfp1 > downThresholdMin and\
+ ptDownGraphToOfp1 < downThresholdMax and i > iterIgnore:
+ portDownGraphNodeIter[0][i] = ptDownGraphToOfp1
+ main.log.info("iter"+str(i)+" port down graph-to-ofp: "+
+ str(ptDownGraphToOfp1)+" ms")
+ else:
+ main.log.info("iter"+str(i)+" skipped. Result: "+
+ str(ptDownGraphToOfp1)+" ms")
+ if ptDownDeviceToOfp1 > downThresholdMin and\
+ ptDownDeviceToOfp1 < downThresholdMax and i > iterIgnore:
+ portDownDevNodeIter[0][i] = ptDownDeviceToOfp1
+ main.log.info("iter"+str(i)+" port down device-to-ofp: "+
+ str(ptDownDeviceToOfp1)+" ms")
+ else:
+ main.log.info("iter"+str(i)+" skipped. Result: "+
+ str(ptDownDeviceToOfp1)+" 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' ]
+ ptDownGraphToOfp2 = int( graphTimestamp2 ) -\
+ int( timestampBeginPtDown )
+ ptDownGraphToOfp3 = int( graphTimestamp3 ) -\
+ int( timestampBeginPtDown )
+ ptDownDeviceToOfp2 = int( deviceTimestamp2 ) -\
+ int( timestampBeginPtDown )
+ ptDownDeviceToOfp3 = int( deviceTimestamp3 ) -\
+ 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 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 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' ]
+ ptDownGraphToOfp4 = int( graphTimestamp4 ) -\
+ int( timestampBeginPtDown )
+ ptDownGraphToOfp5 = int( graphTimestamp5 ) -\
+ int( timestampBeginPtDown )
+ ptDownDeviceToOfp4 = int( deviceTimestamp4 ) -\
+ int( timestampBeginPtDown )
+ ptDownDeviceToOfp5 = int( deviceTimestamp5 ) -\
+ 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 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 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' ]
+ ptDownGraphToOfp6 = int( graphTimestamp6 ) -\
+ int( timestampBeginPtDown )
+ ptDownGraphToOfp7 = int( graphTimestamp7 ) -\
+ int( timestampBeginPtDown )
+ ptDownDeviceToOfp6 = int( deviceTimestamp6 ) -\
+ int( timestampBeginPtDown )
+ ptDownDeviceToOfp7 = int( deviceTimestamp7 ) -\
+ 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 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")
+
+ time.sleep( 3 )
+
+ # Port up events
+ main.step( "Enable port and obtain timestamp" )
+ main.step( "Starting wireshark capture for port status up" )
+ main.ONOS1.tsharkGrep( tsharkPortStatus, tsharkPortUp )
+ time.sleep( 5 )
+
+ main.Mininet1.handle.sendline( "sh ifconfig " +
+ interfaceConfig + " up" )
+ main.Mininet1.handle.expect( "mininet>" )
+
+ # Allow time for tshark to capture event
+ 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()
+
+ # Obtain metrics shortly afterwards
+ # This timestsamp captures
+ # the epoch time at which the topology graph was updated.
+ main.step( "Obtain t1 by REST call" )
+ jsonStrUp1 = main.ONOS1cli.topologyEventsMetrics()
+ jsonObj1 = json.loads( jsonStrUp1 )
+ graphTimestamp1 = \
+ jsonObj1[ graphTimestamp ][ 'value' ]
+ # Obtain device timestamp. This timestamp captures
+ # the epoch time at which the device event happened
+ deviceTimestamp1 = \
+ jsonObj1[ deviceTimestamp ][ 'value' ]
+ # Get delta between graph event and OFP
+ ptUpGraphToOfp1 = int( graphTimestamp1 ) -\
+ int( timestampBeginPtUp )
+ # Get delta between device event and OFP
+ ptUpDeviceToOfp1 = int( deviceTimestamp1 ) -\
+ int( timestampBeginPtUp )
- main.step("Obtain t1 by metrics call")
- json_str_up_1 = main.ONOS1cli.topology_events_metrics()
- json_obj_1 = json.loads(json_str_up_1)
- #Obtain graph timestamp. This timestsamp captures
- #the epoch time at which the topology graph was updated.
- graph_timestamp_1 = \
- json_obj_1[graphTimestamp]['value']
- #Obtain device timestamp. This timestamp captures
- #the epoch time at which the device event happened
- device_timestamp_1 = \
- json_obj_1[deviceTimestamp]['value']
- #Get delta between graph event and OFP
- pt_down_graph_to_ofp_1 = int(graph_timestamp_1) -\
- int(timestamp_begin_pt_down)
- #Get delta between device event and OFP
- pt_down_device_to_ofp_1 = int(device_timestamp_1) -\
- int(timestamp_begin_pt_down)
+ if ptUpGraphToOfp1 > upThresholdMin and\
+ ptUpGraphToOfp1 < upThresholdMax and i > iterIgnore:
+ portUpGraphNodeIter[0][i] = ptUpGraphToOfp1
+ main.log.info("iter"+str(i)+" port up graph-to-ofp: "+
+ str(ptUpGraphToOfp1)+" ms")
+ else:
+ main.log.info("iter"+str(i)+" skipped. Result: "+
+ str(ptUpGraphToOfp1)+" ms")
- if cluster_count >= 3:
- json_str_up_2 = main.ONOS2cli.topology_events_metrics()
- json_str_up_3 = main.ONOS3cli.topology_events_metrics()
- json_obj_2 = json.loads(json_str_up_2)
- json_obj_3 = json.loads(json_str_up_3)
- graph_timestamp_2 = \
- json_obj_2[graphTimestamp]['value']
- graph_timestamp_3 = \
- json_obj_3[graphTimestamp]['value']
- device_timestamp_2 = \
- json_obj_2[deviceTimestamp]['value']
- device_timestamp_3 = \
- json_obj_3[deviceTimestamp]['value']
- pt_down_graph_to_ofp_2 = int(graph_timestamp_2) -\
- int(timestamp_begin_pt_down)
- pt_down_graph_to_ofp_3 = int(graph_timestamp_3) -\
- int(timestamp_begin_pt_down)
- pt_down_device_to_ofp_2 = int(device_timestamp_2) -\
- int(timestamp_begin_pt_down)
- pt_down_device_to_ofp_3 = int(device_timestamp_3) -\
- int(timestamp_begin_pt_down)
+ if ptUpDeviceToOfp1 > upThresholdMin and\
+ ptUpDeviceToOfp1 < upThresholdMax and i > iterIgnore:
+ portUpDevNodeIter[0][i] = ptUpDeviceToOfp1
+ main.log.info("iter"+str(i)+" port up device-to-ofp: "+
+ str(ptUpDeviceToOfp1)+" ms")
else:
- pt_down_graph_to_ofp_2 = 0
- pt_down_graph_to_ofp_3 = 0
- pt_down_device_to_ofp_2 = 0
- pt_down_device_to_ofp_3 = 0
+ main.log.info("iter"+str(i)+" skipped. Result: "+
+ str(ptUpDeviceToOfp1)+" ms")
- if cluster_count >= 5:
- json_str_up_4 = main.ONOS4cli.topology_events_metrics()
- json_str_up_5 = main.ONOS5cli.topology_events_metrics()
- json_obj_4 = json.loads(json_str_up_4)
- json_obj_5 = json.loads(json_str_up_5)
- graph_timestamp_4 = \
- json_obj_4[graphTimestamp]['value']
- graph_timestamp_5 = \
- json_obj_5[graphTimestamp]['value']
- device_timestamp_4 = \
- json_obj_4[deviceTimestamp]['value']
- device_timestamp_5 = \
- json_obj_5[deviceTimestamp]['value']
- pt_down_graph_to_ofp_4 = int(graph_timestamp_4) -\
- int(timestamp_begin_pt_down)
- pt_down_graph_to_ofp_5 = int(graph_timestamp_5) -\
- int(timestamp_begin_pt_down)
- pt_down_device_to_ofp_4 = int(device_timestamp_4) -\
- int(timestamp_begin_pt_down)
- pt_down_device_to_ofp_5 = int(device_timestamp_5) -\
- int(timestamp_begin_pt_down)
- else:
- pt_down_graph_to_ofp_4 = 0
- pt_down_graph_to_ofp_5 = 0
- pt_down_device_to_ofp_4 = 0
- pt_down_device_to_ofp_5 = 0
-
- if cluster_count >= 7:
- json_str_up_6 = main.ONOS6cli.topology_events_metrics()
- json_str_up_7 = main.ONOS7cli.topology_events_metrics()
- json_obj_6 = json.loads(json_str_up_6)
- json_obj_7 = json.loads(json_str_up_7)
- graph_timestamp_6 = \
- json_obj_6[graphTimestamp]['value']
- graph_timestamp_7 = \
- json_obj_7[graphTimestamp]['value']
- device_timestamp_6 = \
- json_obj_6[deviceTimestamp]['value']
- device_timestamp_7 = \
- json_obj_7[deviceTimestamp]['value']
- pt_down_graph_to_ofp_6 = int(graph_timestamp_6) -\
- int(timestamp_begin_pt_down)
- pt_down_graph_to_ofp_7 = int(graph_timestamp_7) -\
- int(timestamp_begin_pt_down)
- pt_down_device_to_ofp_6 = int(device_timestamp_6) -\
- int(timestamp_begin_pt_down)
- pt_down_device_to_ofp_7 = int(device_timestamp_7) -\
- int(timestamp_begin_pt_down)
- else:
- pt_down_graph_to_ofp_6 = 0
- pt_down_graph_to_ofp_7 = 0
- pt_down_device_to_ofp_6 = 0
- pt_down_device_to_ofp_7 = 0
-
- time.sleep(3)
-
- #Caluclate average across clusters
- pt_down_graph_to_ofp_avg =\
- (int(pt_down_graph_to_ofp_1) +
- int(pt_down_graph_to_ofp_2) +
- int(pt_down_graph_to_ofp_3) +
- int(pt_down_graph_to_ofp_4) +
- int(pt_down_graph_to_ofp_5) +
- int(pt_down_graph_to_ofp_6) +
- int(pt_down_graph_to_ofp_7)) / cluster_count
- pt_down_device_to_ofp_avg = \
- (int(pt_down_device_to_ofp_1) +
- int(pt_down_device_to_ofp_2) +
- int(pt_down_device_to_ofp_3) +
- int(pt_down_device_to_ofp_4) +
- int(pt_down_device_to_ofp_5) +
- int(pt_down_device_to_ofp_6) +
- int(pt_down_device_to_ofp_7)) / cluster_count
-
- if pt_down_graph_to_ofp_avg > down_threshold_min and \
- pt_down_graph_to_ofp_avg < down_threshold_max:
- port_down_graph_to_ofp_list.append(
- pt_down_graph_to_ofp_avg)
- main.log.info("Port down: graph to ofp avg: "+
- str(pt_down_graph_to_ofp_avg) + " ms")
- else:
- main.log.info("Average port down graph-to-ofp result" +
- " exceeded the threshold: "+
- str(pt_down_graph_to_ofp_avg))
-
- if pt_down_device_to_ofp_avg > 0 and \
- pt_down_device_to_ofp_avg < 1000:
- port_down_device_to_ofp_list.append(
- pt_down_device_to_ofp_avg)
- main.log.info("Port down: device to ofp avg: "+
- str(pt_down_device_to_ofp_avg) + " ms")
- else:
- main.log.info("Average port down device-to-ofp result" +
- " exceeded the threshold: "+
- str(pt_down_device_to_ofp_avg))
-
- #Port up events
- main.step("Enable port and obtain timestamp")
- main.step("Starting wireshark capture for port status up")
- main.ONOS1.tshark_grep(tshark_port_status, tshark_port_up)
- time.sleep(5)
-
- main.Mininet1.handle.sendline("sh ifconfig "+
- interface_config+" up")
- main.Mininet1.handle.expect("mininet>")
+ 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' ]
+ ptUpGraphToOfp2 = int( graphTimestamp2 ) -\
+ int( timestampBeginPtUp )
+ ptUpGraphToOfp3 = int( graphTimestamp3 ) -\
+ int( timestampBeginPtUp )
+ ptUpDeviceToOfp2 = int( deviceTimestamp2 ) -\
+ int( timestampBeginPtUp )
+ ptUpDeviceToOfp3 = int( deviceTimestamp3 ) -\
+ int( timestampBeginPtUp )
- #Allow time for tshark to capture event
- time.sleep(5)
- main.ONOS1.tshark_stop()
+ if ptUpGraphToOfp2 > upThresholdMin and\
+ ptUpGraphToOfp2 < upThresholdMax and i > iterIgnore:
+ portUpGraphNodeIter[1][i] = ptUpGraphToOfp2
+ main.log.info("iter"+str(i)+" port up graph-to-ofp: "+
+ str(ptUpGraphToOfp2)+" ms")
- time.sleep(3)
- os.system("scp "+ONOS_user+"@"+ONOS1_ip+":"+
- tshark_port_up+" /tmp/")
- f_port_up = open(tshark_port_up, 'r')
- f_line = f_port_up.readline()
- obj_up = f_line.split(" ")
- if len(f_line) > 0:
- timestamp_begin_pt_up = int(float(obj_up[1])*1000)
- if timestamp_begin_pt_up < 1400000000000:
- timestamp_begin_pt_up = \
- int(float(obj_up[2])*1000)
- main.log.info("Port up begin timestamp: "+
- str(timestamp_begin_pt_up))
- else:
- main.log.info("Tshark output file returned unexpected"+
- " results.")
- timestamp_begin_pt_up = 0
- f_port_up.close()
-
- #Obtain metrics shortly afterwards
- #This timestsamp captures
- #the epoch time at which the topology graph was updated.
- main.step("Obtain t1 by REST call")
- json_str_up_1 = main.ONOS1cli.topology_events_metrics()
- json_obj_1 = json.loads(json_str_up_1)
- graph_timestamp_1 = \
- json_obj_1[graphTimestamp]['value']
- #Obtain device timestamp. This timestamp captures
- #the epoch time at which the device event happened
- device_timestamp_1 = \
- json_obj_1[deviceTimestamp]['value']
- #Get delta between graph event and OFP
- pt_up_graph_to_ofp_1 = int(graph_timestamp_1) -\
- int(timestamp_begin_pt_up)
- #Get delta between device event and OFP
- pt_up_device_to_ofp_1 = int(device_timestamp_1) -\
- int(timestamp_begin_pt_up)
+ if ptUpDeviceToOfp2 > upThresholdMin and\
+ ptUpDeviceToOfp2 < upThresholdMax and i > iterIgnore:
+ portUpDevNodeIter[1][i] = ptUpDeviceToOfp2
+ main.log.info("iter"+str(i)+" port up device-to-ofp: "+
+ str(ptUpDeviceToOfp2)+" ms")
+
+ if ptUpGraphToOfp3 > upThresholdMin and\
+ ptUpGraphToOfp3 < upThresholdMax and i > iterIgnore:
+ portUpGraphNodeIter[2][i] = ptUpGraphToOfp3
+ main.log.info("iter"+str(i)+" port up graph-to-ofp: "+
+ str(ptUpGraphToOfp3)+" ms")
- if cluster_count >= 3:
- json_str_up_2 = main.ONOS2cli.topology_events_metrics()
- json_str_up_3 = main.ONOS3cli.topology_events_metrics()
- json_obj_2 = json.loads(json_str_up_2)
- json_obj_3 = json.loads(json_str_up_3)
- graph_timestamp_2 = \
- json_obj_2[graphTimestamp]['value']
- graph_timestamp_3 = \
- json_obj_3[graphTimestamp]['value']
- device_timestamp_2 = \
- json_obj_2[deviceTimestamp]['value']
- device_timestamp_3 = \
- json_obj_3[deviceTimestamp]['value']
- pt_up_graph_to_ofp_2 = int(graph_timestamp_2) -\
- int(timestamp_begin_pt_up)
- pt_up_graph_to_ofp_3 = int(graph_timestamp_3) -\
- int(timestamp_begin_pt_up)
- pt_up_device_to_ofp_2 = int(device_timestamp_2) -\
- int(timestamp_begin_pt_up)
- pt_up_device_to_ofp_3 = int(device_timestamp_3) -\
- int(timestamp_begin_pt_up)
- else:
- pt_up_graph_to_ofp_2 = 0
- pt_up_graph_to_ofp_3 = 0
- pt_up_device_to_ofp_2 = 0
- pt_up_device_to_ofp_3 = 0
+ if ptUpDeviceToOfp3 > upThresholdMin and\
+ ptUpDeviceToOfp3 < upThresholdMax and i > iterIgnore:
+ portUpDevNodeIter[2][i] = ptUpDeviceToOfp3
+ main.log.info("iter"+str(i)+" port up device-to-ofp: "+
+ str(ptUpDeviceToOfp3)+" 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' ]
+ ptUpGraphToOfp4 = int( graphTimestamp4 ) -\
+ int( timestampBeginPtUp )
+ ptUpGraphToOfp5 = int( graphTimestamp5 ) -\
+ int( timestampBeginPtUp )
+ ptUpDeviceToOfp4 = int( deviceTimestamp4 ) -\
+ int( timestampBeginPtUp )
+ ptUpDeviceToOfp5 = int( deviceTimestamp5 ) -\
+ int( timestampBeginPtUp )
+
+ if ptUpGraphToOfp4 > upThresholdMin and\
+ ptUpGraphToOfp4 < upThresholdMax and i > iterIgnore:
+ portUpGraphNodeIter[3][i] = ptUpGraphToOfp4
+ main.log.info("iter"+str(i)+" port up graph-to-ofp: "+
+ str(ptUpGraphToOfp4)+" ms")
- if cluster_count >= 5:
- json_str_up_4 = main.ONOS4cli.topology_events_metrics()
- json_str_up_5 = main.ONOS5cli.topology_events_metrics()
- json_obj_4 = json.loads(json_str_up_4)
- json_obj_5 = json.loads(json_str_up_5)
- graph_timestamp_4 = \
- json_obj_4[graphTimestamp]['value']
- graph_timestamp_5 = \
- json_obj_5[graphTimestamp]['value']
- device_timestamp_4 = \
- json_obj_4[deviceTimestamp]['value']
- device_timestamp_5 = \
- json_obj_5[deviceTimestamp]['value']
- pt_up_graph_to_ofp_4 = int(graph_timestamp_4) -\
- int(timestamp_begin_pt_up)
- pt_up_graph_to_ofp_5 = int(graph_timestamp_5) -\
- int(timestamp_begin_pt_up)
- pt_up_device_to_ofp_4 = int(device_timestamp_4) -\
- int(timestamp_begin_pt_up)
- pt_up_device_to_ofp_5 = int(device_timestamp_5) -\
- int(timestamp_begin_pt_up)
- else:
- pt_up_graph_to_ofp_4 = 0
- pt_up_graph_to_ofp_5 = 0
- pt_up_device_to_ofp_4 = 0
- pt_up_device_to_ofp_5 = 0
-
- if cluster_count >= 7:
- json_str_up_6 = main.ONOS6cli.topology_events_metrics()
- json_str_up_7 = main.ONOS7cli.topology_events_metrics()
- json_obj_6 = json.loads(json_str_up_6)
- json_obj_7 = json.loads(json_str_up_7)
- graph_timestamp_6 = \
- json_obj_6[graphTimestamp]['value']
- graph_timestamp_7 = \
- json_obj_7[graphTimestamp]['value']
- device_timestamp_6 = \
- json_obj_6[deviceTimestamp]['value']
- device_timestamp_7 = \
- json_obj_7[deviceTimestamp]['value']
- pt_up_graph_to_ofp_6 = int(graph_timestamp_6) -\
- int(timestamp_begin_pt_up)
- pt_up_graph_to_ofp_7 = int(graph_timestamp_7) -\
- int(timestamp_begin_pt_up)
- pt_up_device_to_ofp_6 = int(device_timestamp_6) -\
- int(timestamp_begin_pt_up)
- pt_up_device_to_ofp_7 = int(device_timestamp_7) -\
- int(timestamp_begin_pt_up)
- else:
- pt_up_graph_to_ofp_6 = 0
- pt_up_graph_to_ofp_7 = 0
- pt_up_device_to_ofp_6 = 0
- pt_up_device_to_ofp_7 = 0
-
- pt_up_graph_to_ofp_avg = \
- (int(pt_up_graph_to_ofp_1) +
- int(pt_up_graph_to_ofp_2) +
- int(pt_up_graph_to_ofp_3) +
- int(pt_up_graph_to_ofp_4) +
- int(pt_up_graph_to_ofp_5) +
- int(pt_up_graph_to_ofp_6) +
- int(pt_up_graph_to_ofp_7)) / cluster_count
-
- pt_up_device_to_ofp_avg = \
- (int(pt_up_device_to_ofp_1) +
- int(pt_up_device_to_ofp_2) +
- int(pt_up_device_to_ofp_3) +
- int(pt_up_device_to_ofp_4) +
- int(pt_up_device_to_ofp_5) +
- int(pt_up_device_to_ofp_6) +
- int(pt_up_device_to_ofp_7)) / cluster_count
-
- if pt_up_graph_to_ofp_avg > up_threshold_min and \
- pt_up_graph_to_ofp_avg < up_threshold_max:
- port_up_graph_to_ofp_list.append(
- pt_up_graph_to_ofp_avg)
- main.log.info("Port down: graph to ofp avg: "+
- str(pt_up_graph_to_ofp_avg) + " ms")
- else:
- main.log.info("Average port up graph-to-ofp result"+
- " exceeded the threshold: "+
- str(pt_up_graph_to_ofp_avg))
+ if ptUpDeviceToOfp4 > upThresholdMin and\
+ ptUpDeviceToOfp4 < upThresholdMax and i > iterIgnore:
+ portUpDevNodeIter[3][i] = ptUpDeviceToOfp4
+ main.log.info("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("iter"+str(i)+" port up graph-to-ofp: "+
+ str(ptUpGraphToOfp5)+" ms")
- if pt_up_device_to_ofp_avg > up_threshold_min and \
- pt_up_device_to_ofp_avg < up_threshold_max:
- port_up_device_to_ofp_list.append(
- pt_up_device_to_ofp_avg)
- main.log.info("Port up: device to ofp avg: "+
- str(pt_up_device_to_ofp_avg) + " ms")
- else:
- main.log.info("Average port up device-to-ofp result"+
- " exceeded the threshold: "+
- str(pt_up_device_to_ofp_avg))
+ if ptUpDeviceToOfp5 > upThresholdMin and\
+ ptUpDeviceToOfp5 < upThresholdMax and i > iterIgnore:
+ portUpDevNodeIter[4][i] = ptUpDeviceToOfp5
+ main.log.info("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")
- #END ITERATION FOR LOOP
-
- #Check all list for latency existence and set assertion
- if (port_down_graph_to_ofp_list and port_down_device_to_ofp_list\
- and port_up_graph_to_ofp_list and port_up_device_to_ofp_list):
- assertion = main.TRUE
-
- main.log.report("Cluster size: "+str(cluster_count)+\
- " node(s)")
- #Calculate and report latency measurements
- port_down_graph_to_ofp_min = min(port_down_graph_to_ofp_list)
- port_down_graph_to_ofp_max = max(port_down_graph_to_ofp_list)
- port_down_graph_to_ofp_avg = \
- (sum(port_down_graph_to_ofp_list) /
- len(port_down_graph_to_ofp_list))
- port_down_graph_to_ofp_std_dev = \
- str(round(numpy.std(port_down_graph_to_ofp_list),1))
-
- main.log.report("Port down graph-to-ofp "+
- "Avg: "+str(port_down_graph_to_ofp_avg)+" ms "+
- "Std Deviation: "+port_down_graph_to_ofp_std_dev+" ms")
-
- port_down_device_to_ofp_min = min(port_down_device_to_ofp_list)
- port_down_device_to_ofp_max = max(port_down_device_to_ofp_list)
- port_down_device_to_ofp_avg = \
- (sum(port_down_device_to_ofp_list) /\
- len(port_down_device_to_ofp_list))
- port_down_device_to_ofp_std_dev = \
- str(round(numpy.std(port_down_device_to_ofp_list),1))
-
- main.log.report("Port down device-to-ofp "+
- "Avg: "+str(port_down_device_to_ofp_avg)+" ms "+
- "Std Deviation: "+port_down_device_to_ofp_std_dev+" ms")
-
- port_up_graph_to_ofp_min = min(port_up_graph_to_ofp_list)
- port_up_graph_to_ofp_max = max(port_up_graph_to_ofp_list)
- port_up_graph_to_ofp_avg = \
- (sum(port_up_graph_to_ofp_list) /\
- len(port_up_graph_to_ofp_list))
- port_up_graph_to_ofp_std_dev = \
- str(round(numpy.std(port_up_graph_to_ofp_list),1))
-
- main.log.report("Port up graph-to-ofp "+
- "Avg: "+str(port_up_graph_to_ofp_avg)+" ms "+
- "Std Deviation: "+port_up_graph_to_ofp_std_dev+" ms")
-
- port_up_device_to_ofp_min = min(port_up_device_to_ofp_list)
- port_up_device_to_ofp_max = max(port_up_device_to_ofp_list)
- port_up_device_to_ofp_avg = \
- (sum(port_up_device_to_ofp_list) /\
- len(port_up_device_to_ofp_list))
- port_up_device_to_ofp_std_dev = \
- str(round(numpy.std(port_up_device_to_ofp_list),1))
-
- main.log.report("Port up device-to-ofp "+
- "Avg: "+str(port_up_device_to_ofp_avg)+" ms "+
- "Std Deviation: "+port_up_device_to_ofp_std_dev+" 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")
- #Remove switches from controller for next test
- main.Mininet1.delete_sw_controller("s1")
- main.Mininet1.delete_sw_controller("s2")
+ # END ITERATION FOR LOOP
- utilities.assert_equals(expect=main.TRUE, actual=assertion,
- onpass="Port discovery latency calculation successful",
- onfail="Port discovery test failed")
+ portUpDevList = []
+ portUpGraphList = []
+ portDownDevList = []
+ portDownGraphList = []
- def CASE4(self, main):
- '''
+ portUpDevAvg = 0
+ portUpGraphAvg = 0
+ portDownDevAvg = 0
+ portDownGraphAvg = 0
+
+ for node in range( 0, clusterCount ):
+
+ # NOTE:
+ # Currently the 2d array is initialized with 0's.
+ # We want to avoid skewing our results if the array
+ # was not modified with the correct latency.
+ 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 = numpy.mean(portUpDevList)
+ portUpGraphAvg = numpy.mean(portUpGraphList)
+ portDownDevAvg = numpy.mean(portDownDevList)
+ portDownGraphAvg = numpy.mean(portDownGraphList)
+
+ 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(round(portUpGraphAvg, 2))+" ms")
+ #main.log.report( " Port down ofp-to-device "+
+ # str(round(portDownDevAvg, 2))+" ms")
+ main.log.report( " Port down ofp-to-graph "+
+ str(round(portDownGraphAvg, 2))+" ms")
+
+ # Remove switches from controller for next test
+ main.Mininet1.deleteSwController( "s1" )
+ main.Mininet1.deleteSwController( "s2" )
+
+ #TODO: correct assertion
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=assertion,
+ onpass="Port discovery latency calculation successful",
+ onfail="Port discovery test failed" )
+
+ def CASE4( self, main ):
+ """
Link down event using loss rate 100%
-
+
Important:
Use a simple 2 switch topology with 1 link between
- the two switches. Ensure that mac addresses of the
+ the two switches. Ensure that mac addresses of the
switches are 1 / 2 respectively
- '''
+ """
import time
import subprocess
import os
import requests
import json
- import numpy
-
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
- ONOS_user = main.params['CTRL']['user']
+ import numpy
- default_sw_port = main.params['CTRL']['port1']
-
- #Number of iterations of case
- num_iter = main.params['TEST']['numIter']
-
- #Timestamp 'keys' for json metrics output.
- #These are subject to change, hence moved into params
- deviceTimestamp = main.params['JSON']['deviceTimestamp']
- linkTimestamp = main.params['JSON']['linkTimestamp']
- graphTimestamp = main.params['JSON']['graphTimestamp']
-
- debug_mode = main.params['TEST']['debugMode']
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOSUser = main.params[ 'CTRL' ][ 'user' ]
- local_time = time.strftime('%x %X')
- local_time = local_time.replace("/","")
- local_time = local_time.replace(" ","_")
- local_time = local_time.replace(":","")
- if debug_mode == 'on':
- main.ONOS1.tshark_pcap("eth0",
- "/tmp/link_lat_pcap_"+local_time)
+ defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
- #Threshold for this test case
- up_threshold_str = main.params['TEST']['linkUpThreshold']
- down_threshold_str = main.params['TEST']['linkDownThreshold']
+ # Number of iterations of case
+ numIter = main.params[ 'TEST' ][ 'numIter' ]
- up_threshold_obj = up_threshold_str.split(",")
- down_threshold_obj = down_threshold_str.split(",")
+ # Timestamp 'keys' for json metrics output.
+ # These are subject to change, hence moved into params
+ deviceTimestamp = main.params[ 'JSON' ][ 'deviceTimestamp' ]
+ linkTimestamp = main.params[ 'JSON' ][ 'linkTimestamp' ]
+ graphTimestamp = main.params[ 'JSON' ][ 'graphTimestamp' ]
- up_threshold_min = int(up_threshold_obj[0])
- up_threshold_max = int(up_threshold_obj[1])
+ debugMode = main.params[ 'TEST' ][ 'debugMode' ]
- down_threshold_min = int(down_threshold_obj[0])
- down_threshold_max = int(down_threshold_obj[1])
+ localTime = time.strftime( '%x %X' )
+ localTime = localTime.replace( "/", "" )
+ localTime = localTime.replace( " ", "_" )
+ localTime = localTime.replace( ":", "" )
+ if debugMode == 'on':
+ main.ONOS1.tsharkPcap( "eth0",
+ "/tmp/link_lat_pcap_" + localTime )
+
+ # Threshold for this test case
+ upThresholdStr = main.params[ 'TEST' ][ 'linkUpThreshold' ]
+ downThresholdStr = main.params[ 'TEST' ][ 'linkDownThreshold' ]
+
+ upThresholdObj = upThresholdStr.split( "," )
+ downThresholdObj = downThresholdStr.split( "," )
+
+ upThresholdMin = int( upThresholdObj[ 0 ] )
+ upThresholdMax = int( upThresholdObj[ 1 ] )
+
+ downThresholdMin = int( downThresholdObj[ 0 ] )
+ downThresholdMax = int( downThresholdObj[ 1 ] )
assertion = main.TRUE
- #Link event timestamp to system time list
- link_down_link_to_system_list = []
- link_up_link_to_system_list = []
- #Graph event timestamp to system time list
- link_down_graph_to_system_list = []
- link_up_graph_to_system_list = []
+ # Link event timestamp to system time list
+ linkDownLinkToSystemList = []
+ linkUpLinkToSystemList = []
+ # Graph event timestamp to system time list
+ linkDownGraphToSystemList = []
+ linkUpGraphToSystemList = []
- main.log.report("Link up / down discovery latency between "+
- "two switches")
- main.log.report("Simulated by setting loss-rate 100%")
- main.log.report("'tc qdisc add dev <intfs> root netem loss 100%'")
- main.log.report("Total iterations of test: "+str(num_iter))
+ main.log.report( "Link up / down discovery latency between " +
+ "two switches" )
+ main.log.report( "Simulated by setting loss-rate 100%" )
+ main.log.report( "'tc qdisc add dev <intfs> root netem loss 100%'" )
+ main.log.report( "Total iterations of test: " + str( numIter ) )
- main.step("Assign all switches")
- 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.step( "Assign all switches" )
+ main.Mininet1.assignSwController( sw="1",
+ ip1=ONOS1Ip, port1=defaultSwPort )
+ main.Mininet1.assignSwController( sw="2",
+ ip1=ONOS1Ip, port1=defaultSwPort )
- main.step("Verifying switch assignment")
- result_s1 = main.Mininet1.get_sw_controller(sw="s1")
- result_s2 = main.Mininet1.get_sw_controller(sw="s2")
-
- #Allow time for events to finish before taking measurements
- time.sleep(10)
+ main.step( "Verifying switch assignment" )
+ resultS1 = main.Mininet1.getSwController( sw="s1" )
+ resultS2 = main.Mininet1.getSwController( sw="s2" )
- link_down1 = False
- link_down2 = False
- link_down3 = False
- #Start iteration of link event test
- for i in range(0, int(num_iter)):
- main.step("Getting initial system time as t0")
-
- #System time in epoch ms
- timestamp_link_down_t0 = time.time() * 1000
- #Link down is simulated by 100% loss rate using traffic
- #control command
+ # Allow time for events to finish before taking measurements
+ time.sleep( 10 )
+
+ linkDown1 = False
+ linkDown2 = False
+ linkDown3 = False
+ # Start iteration of link event test
+ for i in range( 0, int( numIter ) ):
+ main.step( "Getting initial system time as t0" )
+
+ # System time in epoch ms
+ timestampLinkDownT0 = time.time() * 1000
+ # Link down is simulated by 100% loss rate using traffic
+ # control command
main.Mininet1.handle.sendline(
- "sh tc qdisc add dev s1-eth1 root netem loss 100%")
+ "sh tc qdisc add dev s1-eth1 root netem loss 100%" )
- #TODO: Iterate through 'links' command to verify that
- # link s1 -> s2 went down (loop timeout 30 seconds)
+ # TODO: Iterate through 'links' command to verify that
+ # link s1 -> s2 went down ( loop timeout 30 seconds )
# on all 3 ONOS instances
- main.log.info("Checking ONOS for link update")
- loop_count = 0
- while( not (link_down1 and link_down2 and link_down3)\
- and loop_count < 30 ):
- json_str1 = main.ONOS1cli.links()
- json_str2 = main.ONOS2cli.links()
- json_str3 = main.ONOS3cli.links()
-
- if not (json_str1 and json_str2 and json_str3):
- main.log.error("CLI command returned error ")
+ main.log.info( "Checking ONOS for link update" )
+ loopCount = 0
+ while( not ( linkDown1 and linkDown2 and linkDown3 )
+ and loopCount < 30 ):
+ jsonStr1 = main.ONOS1cli.links()
+ jsonStr2 = main.ONOS2cli.links()
+ jsonStr3 = main.ONOS3cli.links()
+
+ if not ( jsonStr1 and jsonStr2 and jsonStr3 ):
+ main.log.error( "CLI command returned error " )
break
else:
- json_obj1 = json.loads(json_str1)
- json_obj2 = json.loads(json_str2)
- json_obj3 = json.loads(json_str3)
- for obj1 in json_obj1:
- if '01' not in obj1['src']['device']:
- link_down1 = True
- main.log.info("Link down from "+
- "s1 -> s2 on ONOS1 detected")
- for obj2 in json_obj2:
- if '01' not in obj2['src']['device']:
- link_down2 = True
- main.log.info("Link down from "+
- "s1 -> s2 on ONOS2 detected")
- for obj3 in json_obj3:
- if '01' not in obj3['src']['device']:
- link_down3 = True
- main.log.info("Link down from "+
- "s1 -> s2 on ONOS3 detected")
-
- loop_count += 1
- #If CLI doesn't like the continuous requests
- #and exits in this loop, increase the sleep here.
- #Consequently, while loop timeout will increase
- time.sleep(1)
-
- #Give time for metrics measurement to catch up
- #NOTE: May need to be configured more accurately
- time.sleep(10)
- #If we exited the while loop and link down 1,2,3 are still
- #false, then ONOS has failed to discover link down event
- if not (link_down1 and link_down2 and link_down3):
- main.log.info("Link down discovery failed")
-
- link_down_lat_graph1 = 0
- link_down_lat_graph2 = 0
- link_down_lat_graph3 = 0
- link_down_lat_device1 = 0
- link_down_lat_device2 = 0
- link_down_lat_device3 = 0
-
+ jsonObj1 = json.loads( jsonStr1 )
+ jsonObj2 = json.loads( jsonStr2 )
+ jsonObj3 = json.loads( jsonStr3 )
+ for obj1 in jsonObj1:
+ if '01' not in obj1[ 'src' ][ 'device' ]:
+ linkDown1 = True
+ main.log.info( "Link down from " +
+ "s1 -> s2 on ONOS1 detected" )
+ for obj2 in jsonObj2:
+ if '01' not in obj2[ 'src' ][ 'device' ]:
+ linkDown2 = True
+ main.log.info( "Link down from " +
+ "s1 -> s2 on ONOS2 detected" )
+ for obj3 in jsonObj3:
+ if '01' not in obj3[ 'src' ][ 'device' ]:
+ linkDown3 = True
+ main.log.info( "Link down from " +
+ "s1 -> s2 on ONOS3 detected" )
+
+ loopCount += 1
+ # If CLI doesn't like the continuous requests
+ # and exits in this loop, increase the sleep here.
+ # Consequently, while loop timeout will increase
+ time.sleep( 1 )
+
+ # Give time for metrics measurement to catch up
+ # NOTE: May need to be configured more accurately
+ time.sleep( 10 )
+ # If we exited the while loop and link down 1,2,3 are still
+ # false, then ONOS has failed to discover link down event
+ if not ( linkDown1 and linkDown2 and linkDown3 ):
+ main.log.info( "Link down discovery failed" )
+
+ linkDownLatGraph1 = 0
+ linkDownLatGraph2 = 0
+ linkDownLatGraph3 = 0
+ linkDownLatDevice1 = 0
+ linkDownLatDevice2 = 0
+ linkDownLatDevice3 = 0
+
assertion = main.FALSE
else:
- json_topo_metrics_1 =\
- main.ONOS1cli.topology_events_metrics()
- json_topo_metrics_2 =\
- main.ONOS2cli.topology_events_metrics()
- json_topo_metrics_3 =\
- main.ONOS3cli.topology_events_metrics()
- json_topo_metrics_1 = json.loads(json_topo_metrics_1)
- json_topo_metrics_2 = json.loads(json_topo_metrics_2)
- json_topo_metrics_3 = json.loads(json_topo_metrics_3)
+ jsonTopoMetrics1 =\
+ main.ONOS1cli.topologyEventsMetrics()
+ jsonTopoMetrics2 =\
+ main.ONOS2cli.topologyEventsMetrics()
+ jsonTopoMetrics3 =\
+ main.ONOS3cli.topologyEventsMetrics()
+ jsonTopoMetrics1 = json.loads( jsonTopoMetrics1 )
+ jsonTopoMetrics2 = json.loads( jsonTopoMetrics2 )
+ jsonTopoMetrics3 = json.loads( jsonTopoMetrics3 )
- main.log.info("Obtaining graph and device timestamp")
- graph_timestamp_1 = \
- json_topo_metrics_1[graphTimestamp]['value']
- graph_timestamp_2 = \
- json_topo_metrics_2[graphTimestamp]['value']
- graph_timestamp_3 = \
- json_topo_metrics_3[graphTimestamp]['value']
+ main.log.info( "Obtaining graph and device timestamp" )
+ graphTimestamp1 = \
+ jsonTopoMetrics1[ graphTimestamp ][ 'value' ]
+ graphTimestamp2 = \
+ jsonTopoMetrics2[ graphTimestamp ][ 'value' ]
+ graphTimestamp3 = \
+ jsonTopoMetrics3[ graphTimestamp ][ 'value' ]
- link_timestamp_1 = \
- json_topo_metrics_1[linkTimestamp]['value']
- link_timestamp_2 = \
- json_topo_metrics_2[linkTimestamp]['value']
- link_timestamp_3 = \
- json_topo_metrics_3[linkTimestamp]['value']
+ linkTimestamp1 = \
+ jsonTopoMetrics1[ linkTimestamp ][ 'value' ]
+ linkTimestamp2 = \
+ jsonTopoMetrics2[ linkTimestamp ][ 'value' ]
+ linkTimestamp3 = \
+ jsonTopoMetrics3[ linkTimestamp ][ 'value' ]
- if graph_timestamp_1 and graph_timestamp_2 and\
- graph_timestamp_3 and link_timestamp_1 and\
- link_timestamp_2 and link_timestamp_3:
- link_down_lat_graph1 = int(graph_timestamp_1) -\
- int(timestamp_link_down_t0)
- link_down_lat_graph2 = int(graph_timestamp_2) -\
- int(timestamp_link_down_t0)
- link_down_lat_graph3 = int(graph_timestamp_3) -\
- int(timestamp_link_down_t0)
-
- link_down_lat_link1 = int(link_timestamp_1) -\
- int(timestamp_link_down_t0)
- link_down_lat_link2 = int(link_timestamp_2) -\
- int(timestamp_link_down_t0)
- link_down_lat_link3 = int(link_timestamp_3) -\
- int(timestamp_link_down_t0)
+ if graphTimestamp1 and graphTimestamp2 and\
+ graphTimestamp3 and linkTimestamp1 and\
+ linkTimestamp2 and linkTimestamp3:
+ linkDownLatGraph1 = int( graphTimestamp1 ) -\
+ int( timestampLinkDownT0 )
+ linkDownLatGraph2 = int( graphTimestamp2 ) -\
+ int( timestampLinkDownT0 )
+ linkDownLatGraph3 = int( graphTimestamp3 ) -\
+ int( timestampLinkDownT0 )
+
+ linkDownLatLink1 = int( linkTimestamp1 ) -\
+ int( timestampLinkDownT0 )
+ linkDownLatLink2 = int( linkTimestamp2 ) -\
+ int( timestampLinkDownT0 )
+ linkDownLatLink3 = int( linkTimestamp3 ) -\
+ int( timestampLinkDownT0 )
else:
- main.log.error("There was an error calculating"+
- " the delta for link down event")
- link_down_lat_graph1 = 0
- link_down_lat_graph2 = 0
- link_down_lat_graph3 = 0
-
- link_down_lat_device1 = 0
- link_down_lat_device2 = 0
- link_down_lat_device3 = 0
-
- main.log.info("Link down latency ONOS1 iteration "+
- str(i)+" (end-to-end): "+
- str(link_down_lat_graph1)+" ms")
- main.log.info("Link down latency ONOS2 iteration "+
- str(i)+" (end-to-end): "+
- str(link_down_lat_graph2)+" ms")
- main.log.info("Link down latency ONOS3 iteration "+
- str(i)+" (end-to-end): "+
- str(link_down_lat_graph3)+" ms")
-
- main.log.info("Link down latency ONOS1 iteration "+
- str(i)+" (link-event-to-system-timestamp): "+
- str(link_down_lat_link1)+" ms")
- main.log.info("Link down latency ONOS2 iteration "+
- str(i)+" (link-event-to-system-timestamp): "+
- str(link_down_lat_link2)+" ms")
- main.log.info("Link down latency ONOS3 iteration "+
- str(i)+" (link-event-to-system-timestamp): "+
- str(link_down_lat_link3))
-
- #Calculate avg of node calculations
- link_down_lat_graph_avg =\
- (link_down_lat_graph1 +
- link_down_lat_graph2 +
- link_down_lat_graph3) / 3
- link_down_lat_link_avg =\
- (link_down_lat_link1 +
- link_down_lat_link2 +
- link_down_lat_link3) / 3
+ main.log.error( "There was an error calculating" +
+ " the delta for link down event" )
+ linkDownLatGraph1 = 0
+ linkDownLatGraph2 = 0
+ linkDownLatGraph3 = 0
- #Set threshold and append latency to list
- if link_down_lat_graph_avg > down_threshold_min and\
- link_down_lat_graph_avg < down_threshold_max:
- link_down_graph_to_system_list.append(
- link_down_lat_graph_avg)
- else:
- main.log.info("Link down latency exceeded threshold")
- main.log.info("Results for iteration "+str(i)+
- "have been omitted")
- if link_down_lat_link_avg > down_threshold_min and\
- link_down_lat_link_avg < down_threshold_max:
- link_down_link_to_system_list.append(
- link_down_lat_link_avg)
- else:
- main.log.info("Link down latency exceeded threshold")
- main.log.info("Results for iteration "+str(i)+
- "have been omitted")
+ linkDownLatDevice1 = 0
+ linkDownLatDevice2 = 0
+ linkDownLatDevice3 = 0
- #NOTE: To remove loss rate and measure latency:
+ main.log.info( "Link down latency ONOS1 iteration " +
+ str( i ) + " (end-to-end): " +
+ str( linkDownLatGraph1 ) + " ms" )
+ main.log.info( "Link down latency ONOS2 iteration " +
+ str( i ) + " (end-to-end): " +
+ str( linkDownLatGraph2 ) + " ms" )
+ main.log.info( "Link down latency ONOS3 iteration " +
+ str( i ) + " (end-to-end): " +
+ str( linkDownLatGraph3 ) + " ms" )
+
+ main.log.info( "Link down latency ONOS1 iteration " +
+ str( i ) + " (link-event-to-system-timestamp): " +
+ str( linkDownLatLink1 ) + " ms" )
+ main.log.info( "Link down latency ONOS2 iteration " +
+ str( i ) + " (link-event-to-system-timestamp): " +
+ str( linkDownLatLink2 ) + " ms" )
+ main.log.info( "Link down latency ONOS3 iteration " +
+ str( i ) + " (link-event-to-system-timestamp): " +
+ str( linkDownLatLink3 ) )
+
+ # Calculate avg of node calculations
+ linkDownLatGraphAvg =\
+ ( linkDownLatGraph1 +
+ linkDownLatGraph2 +
+ linkDownLatGraph3 ) / 3
+ linkDownLatLinkAvg =\
+ ( linkDownLatLink1 +
+ linkDownLatLink2 +
+ linkDownLatLink3 ) / 3
+
+ # Set threshold and append latency to list
+ if linkDownLatGraphAvg > downThresholdMin and\
+ linkDownLatGraphAvg < downThresholdMax:
+ linkDownGraphToSystemList.append(
+ linkDownLatGraphAvg )
+ else:
+ main.log.info( "Link down latency exceeded threshold" )
+ main.log.info( "Results for iteration " + str( i ) +
+ "have been omitted" )
+ if linkDownLatLinkAvg > downThresholdMin and\
+ linkDownLatLinkAvg < downThresholdMax:
+ linkDownLinkToSystemList.append(
+ linkDownLatLinkAvg )
+ else:
+ main.log.info( "Link down latency exceeded threshold" )
+ main.log.info( "Results for iteration " + str( i ) +
+ "have been omitted" )
+
+ # NOTE: To remove loss rate and measure latency:
# 'sh tc qdisc del dev s1-eth1 root'
- timestamp_link_up_t0 = time.time() * 1000
- main.Mininet1.handle.sendline("sh tc qdisc del dev "+
- "s1-eth1 root")
- main.Mininet1.handle.expect("mininet>")
-
- main.log.info("Checking ONOS for link update")
-
- link_down1 = True
- link_down2 = True
- link_down3 = True
- loop_count = 0
- while( (link_down1 and link_down2 and link_down3)\
- and loop_count < 30 ):
- json_str1 = main.ONOS1cli.links()
- json_str2 = main.ONOS2cli.links()
- json_str3 = main.ONOS3cli.links()
- if not (json_str1 and json_str2 and json_str3):
- main.log.error("CLI command returned error ")
+ timestampLinkUpT0 = time.time() * 1000
+ main.Mininet1.handle.sendline( "sh tc qdisc del dev " +
+ "s1-eth1 root" )
+ main.Mininet1.handle.expect( "mininet>" )
+
+ main.log.info( "Checking ONOS for link update" )
+
+ linkDown1 = True
+ linkDown2 = True
+ linkDown3 = True
+ loopCount = 0
+ while( ( linkDown1 and linkDown2 and linkDown3 )
+ and loopCount < 30 ):
+ jsonStr1 = main.ONOS1cli.links()
+ jsonStr2 = main.ONOS2cli.links()
+ jsonStr3 = main.ONOS3cli.links()
+ if not ( jsonStr1 and jsonStr2 and jsonStr3 ):
+ main.log.error( "CLI command returned error " )
break
else:
- json_obj1 = json.loads(json_str1)
- json_obj2 = json.loads(json_str2)
- json_obj3 = json.loads(json_str3)
-
- for obj1 in json_obj1:
- if '01' in obj1['src']['device']:
- link_down1 = False
- main.log.info("Link up from "+
- "s1 -> s2 on ONOS1 detected")
- for obj2 in json_obj2:
- if '01' in obj2['src']['device']:
- link_down2 = False
- main.log.info("Link up from "+
- "s1 -> s2 on ONOS2 detected")
- for obj3 in json_obj3:
- if '01' in obj3['src']['device']:
- link_down3 = False
- main.log.info("Link up from "+
- "s1 -> s2 on ONOS3 detected")
-
- loop_count += 1
- time.sleep(1)
-
- if (link_down1 and link_down2 and link_down3):
- main.log.info("Link up discovery failed")
-
- link_up_lat_graph1 = 0
- link_up_lat_graph2 = 0
- link_up_lat_graph3 = 0
- link_up_lat_device1 = 0
- link_up_lat_device2 = 0
- link_up_lat_device3 = 0
-
+ jsonObj1 = json.loads( jsonStr1 )
+ jsonObj2 = json.loads( jsonStr2 )
+ jsonObj3 = json.loads( jsonStr3 )
+
+ for obj1 in jsonObj1:
+ if '01' in obj1[ 'src' ][ 'device' ]:
+ linkDown1 = False
+ main.log.info( "Link up from " +
+ "s1 -> s2 on ONOS1 detected" )
+ for obj2 in jsonObj2:
+ if '01' in obj2[ 'src' ][ 'device' ]:
+ linkDown2 = False
+ main.log.info( "Link up from " +
+ "s1 -> s2 on ONOS2 detected" )
+ for obj3 in jsonObj3:
+ if '01' in obj3[ 'src' ][ 'device' ]:
+ linkDown3 = False
+ main.log.info( "Link up from " +
+ "s1 -> s2 on ONOS3 detected" )
+
+ loopCount += 1
+ time.sleep( 1 )
+
+ if ( linkDown1 and linkDown2 and linkDown3 ):
+ main.log.info( "Link up discovery failed" )
+
+ linkUpLatGraph1 = 0
+ linkUpLatGraph2 = 0
+ linkUpLatGraph3 = 0
+ linkUpLatDevice1 = 0
+ linkUpLatDevice2 = 0
+ linkUpLatDevice3 = 0
+
assertion = main.FALSE
else:
- json_topo_metrics_1 =\
- main.ONOS1cli.topology_events_metrics()
- json_topo_metrics_2 =\
- main.ONOS2cli.topology_events_metrics()
- json_topo_metrics_3 =\
- main.ONOS3cli.topology_events_metrics()
- json_topo_metrics_1 = json.loads(json_topo_metrics_1)
- json_topo_metrics_2 = json.loads(json_topo_metrics_2)
- json_topo_metrics_3 = json.loads(json_topo_metrics_3)
+ jsonTopoMetrics1 =\
+ main.ONOS1cli.topologyEventsMetrics()
+ jsonTopoMetrics2 =\
+ main.ONOS2cli.topologyEventsMetrics()
+ jsonTopoMetrics3 =\
+ main.ONOS3cli.topologyEventsMetrics()
+ jsonTopoMetrics1 = json.loads( jsonTopoMetrics1 )
+ jsonTopoMetrics2 = json.loads( jsonTopoMetrics2 )
+ jsonTopoMetrics3 = json.loads( jsonTopoMetrics3 )
- main.log.info("Obtaining graph and device timestamp")
- graph_timestamp_1 = \
- json_topo_metrics_1[graphTimestamp]['value']
- graph_timestamp_2 = \
- json_topo_metrics_2[graphTimestamp]['value']
- graph_timestamp_3 = \
- json_topo_metrics_3[graphTimestamp]['value']
+ main.log.info( "Obtaining graph and device timestamp" )
+ graphTimestamp1 = \
+ jsonTopoMetrics1[ graphTimestamp ][ 'value' ]
+ graphTimestamp2 = \
+ jsonTopoMetrics2[ graphTimestamp ][ 'value' ]
+ graphTimestamp3 = \
+ jsonTopoMetrics3[ graphTimestamp ][ 'value' ]
- link_timestamp_1 = \
- json_topo_metrics_1[linkTimestamp]['value']
- link_timestamp_2 = \
- json_topo_metrics_2[linkTimestamp]['value']
- link_timestamp_3 = \
- json_topo_metrics_3[linkTimestamp]['value']
+ linkTimestamp1 = \
+ jsonTopoMetrics1[ linkTimestamp ][ 'value' ]
+ linkTimestamp2 = \
+ jsonTopoMetrics2[ linkTimestamp ][ 'value' ]
+ linkTimestamp3 = \
+ jsonTopoMetrics3[ linkTimestamp ][ 'value' ]
- if graph_timestamp_1 and graph_timestamp_2 and\
- graph_timestamp_3 and link_timestamp_1 and\
- link_timestamp_2 and link_timestamp_3:
- link_up_lat_graph1 = int(graph_timestamp_1) -\
- int(timestamp_link_up_t0)
- link_up_lat_graph2 = int(graph_timestamp_2) -\
- int(timestamp_link_up_t0)
- link_up_lat_graph3 = int(graph_timestamp_3) -\
- int(timestamp_link_up_t0)
-
- link_up_lat_link1 = int(link_timestamp_1) -\
- int(timestamp_link_up_t0)
- link_up_lat_link2 = int(link_timestamp_2) -\
- int(timestamp_link_up_t0)
- link_up_lat_link3 = int(link_timestamp_3) -\
- int(timestamp_link_up_t0)
+ if graphTimestamp1 and graphTimestamp2 and\
+ graphTimestamp3 and linkTimestamp1 and\
+ linkTimestamp2 and linkTimestamp3:
+ linkUpLatGraph1 = int( graphTimestamp1 ) -\
+ int( timestampLinkUpT0 )
+ linkUpLatGraph2 = int( graphTimestamp2 ) -\
+ int( timestampLinkUpT0 )
+ linkUpLatGraph3 = int( graphTimestamp3 ) -\
+ int( timestampLinkUpT0 )
+
+ linkUpLatLink1 = int( linkTimestamp1 ) -\
+ int( timestampLinkUpT0 )
+ linkUpLatLink2 = int( linkTimestamp2 ) -\
+ int( timestampLinkUpT0 )
+ linkUpLatLink3 = int( linkTimestamp3 ) -\
+ int( timestampLinkUpT0 )
else:
- main.log.error("There was an error calculating"+
- " the delta for link down event")
- link_up_lat_graph1 = 0
- link_up_lat_graph2 = 0
- link_up_lat_graph3 = 0
-
- link_up_lat_device1 = 0
- link_up_lat_device2 = 0
- link_up_lat_device3 = 0
-
- if debug_mode == 'on':
- main.log.info("Link up latency ONOS1 iteration "+
- str(i)+" (end-to-end): "+
- str(link_up_lat_graph1)+" ms")
- main.log.info("Link up latency ONOS2 iteration "+
- str(i)+" (end-to-end): "+
- str(link_up_lat_graph2)+" ms")
- main.log.info("Link up latency ONOS3 iteration "+
- str(i)+" (end-to-end): "+
- str(link_up_lat_graph3)+" ms")
-
- main.log.info("Link up latency ONOS1 iteration "+
- str(i)+" (link-event-to-system-timestamp): "+
- str(link_up_lat_link1)+" ms")
- main.log.info("Link up latency ONOS2 iteration "+
- str(i)+" (link-event-to-system-timestamp): "+
- str(link_up_lat_link2)+" ms")
- main.log.info("Link up latency ONOS3 iteration "+
- str(i)+" (link-event-to-system-timestamp): "+
- str(link_up_lat_link3))
-
- #Calculate avg of node calculations
- link_up_lat_graph_avg =\
- (link_up_lat_graph1 +
- link_up_lat_graph2 +
- link_up_lat_graph3) / 3
- link_up_lat_link_avg =\
- (link_up_lat_link1 +
- link_up_lat_link2 +
- link_up_lat_link3) / 3
+ main.log.error( "There was an error calculating" +
+ " the delta for link down event" )
+ linkUpLatGraph1 = 0
+ linkUpLatGraph2 = 0
+ linkUpLatGraph3 = 0
- #Set threshold and append latency to list
- if link_up_lat_graph_avg > up_threshold_min and\
- link_up_lat_graph_avg < up_threshold_max:
- link_up_graph_to_system_list.append(
- link_up_lat_graph_avg)
+ linkUpLatDevice1 = 0
+ linkUpLatDevice2 = 0
+ linkUpLatDevice3 = 0
+
+ if debugMode == 'on':
+ main.log.info( "Link up latency ONOS1 iteration " +
+ str( i ) + " (end-to-end): " +
+ str( linkUpLatGraph1 ) + " ms" )
+ main.log.info( "Link up latency ONOS2 iteration " +
+ str( i ) + " (end-to-end): " +
+ str( linkUpLatGraph2 ) + " ms" )
+ main.log.info( "Link up latency ONOS3 iteration " +
+ str( i ) + " (end-to-end): " +
+ str( linkUpLatGraph3 ) + " ms" )
+
+ main.log.info(
+ "Link up latency ONOS1 iteration " +
+ str( i ) +
+ " (link-event-to-system-timestamp): " +
+ str( linkUpLatLink1 ) +
+ " ms" )
+ main.log.info(
+ "Link up latency ONOS2 iteration " +
+ str( i ) +
+ " (link-event-to-system-timestamp): " +
+ str( linkUpLatLink2 ) +
+ " ms" )
+ main.log.info(
+ "Link up latency ONOS3 iteration " +
+ str( i ) +
+ " (link-event-to-system-timestamp): " +
+ str( linkUpLatLink3 ) )
+
+ # Calculate avg of node calculations
+ linkUpLatGraphAvg =\
+ ( linkUpLatGraph1 +
+ linkUpLatGraph2 +
+ linkUpLatGraph3 ) / 3
+ linkUpLatLinkAvg =\
+ ( linkUpLatLink1 +
+ linkUpLatLink2 +
+ linkUpLatLink3 ) / 3
+
+ # Set threshold and append latency to list
+ if linkUpLatGraphAvg > upThresholdMin and\
+ linkUpLatGraphAvg < upThresholdMax:
+ linkUpGraphToSystemList.append(
+ linkUpLatGraphAvg )
else:
- main.log.info("Link up latency exceeded threshold")
- main.log.info("Results for iteration "+str(i)+
- "have been omitted")
- if link_up_lat_link_avg > up_threshold_min and\
- link_up_lat_link_avg < up_threshold_max:
- link_up_link_to_system_list.append(
- link_up_lat_link_avg)
+ main.log.info( "Link up latency exceeded threshold" )
+ main.log.info( "Results for iteration " + str( i ) +
+ "have been omitted" )
+ if linkUpLatLinkAvg > upThresholdMin and\
+ linkUpLatLinkAvg < upThresholdMax:
+ linkUpLinkToSystemList.append(
+ linkUpLatLinkAvg )
else:
- main.log.info("Link up latency exceeded threshold")
- main.log.info("Results for iteration "+str(i)+
- "have been omitted")
+ main.log.info( "Link up latency exceeded threshold" )
+ main.log.info( "Results for iteration " + str( i ) +
+ "have been omitted" )
- #Calculate min, max, avg of list and report
- link_down_min = min(link_down_graph_to_system_list)
- link_down_max = max(link_down_graph_to_system_list)
- link_down_avg = sum(link_down_graph_to_system_list) / \
- len(link_down_graph_to_system_list)
- link_up_min = min(link_up_graph_to_system_list)
- link_up_max = max(link_up_graph_to_system_list)
- link_up_avg = sum(link_up_graph_to_system_list) / \
- len(link_up_graph_to_system_list)
- link_down_std_dev = \
- str(round(numpy.std(link_down_graph_to_system_list),1))
- link_up_std_dev = \
- str(round(numpy.std(link_up_graph_to_system_list),1))
+ # Calculate min, max, avg of list and report
+ linkDownMin = min( linkDownGraphToSystemList )
+ linkDownMax = max( linkDownGraphToSystemList )
+ linkDownAvg = sum( linkDownGraphToSystemList ) / \
+ len( linkDownGraphToSystemList )
+ linkUpMin = min( linkUpGraphToSystemList )
+ linkUpMax = max( linkUpGraphToSystemList )
+ linkUpAvg = sum( linkUpGraphToSystemList ) / \
+ len( linkUpGraphToSystemList )
+ linkDownStdDev = \
+ str( round( numpy.std( linkDownGraphToSystemList ), 1 ) )
+ linkUpStdDev = \
+ str( round( numpy.std( linkUpGraphToSystemList ), 1 ) )
- main.log.report("Link down latency " +
- "Avg: "+str(link_down_avg)+" ms "+
- "Std Deviation: "+link_down_std_dev+" ms")
- main.log.report("Link up latency "+
- "Avg: "+str(link_up_avg)+" ms "+
- "Std Deviation: "+link_up_std_dev+" ms")
+ main.log.report( "Link down latency " +
+ "Avg: " + str( linkDownAvg ) + " ms " +
+ "Std Deviation: " + linkDownStdDev + " ms" )
+ main.log.report( "Link up latency " +
+ "Avg: " + str( linkUpAvg ) + " ms " +
+ "Std Deviation: " + linkUpStdDev + " ms" )
- utilities.assert_equals(expect=main.TRUE, actual=assertion,
- onpass="Link discovery latency calculation successful",
- onfail="Link discovery latency case failed")
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=assertion,
+ onpass="Link discovery latency calculation successful",
+ onfail="Link discovery latency case failed" )
- def CASE5(self, main):
- '''
+ def CASE5( self, main ):
+ """
100 Switch discovery latency
Important:
- This test case can be potentially dangerous if
+ This test case can be potentially dangerous if
your machine has previously set iptables rules.
One of the steps of the test case will flush
all existing iptables rules.
Note:
- You can specify the number of switches in the
+ You can specify the number of switches in the
params file to adjust the switch discovery size
- (and specify the corresponding topology in Mininet1
- .topo file)
- '''
+ ( and specify the corresponding topology in Mininet1
+ .topo file )
+ """
import time
import subprocess
import os
import requests
import json
- ONOS1_ip = main.params['CTRL']['ip1']
- ONOS2_ip = main.params['CTRL']['ip2']
- ONOS3_ip = main.params['CTRL']['ip3']
- MN1_ip = main.params['MN']['ip1']
- ONOS_user = main.params['CTRL']['user']
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
+ MN1Ip = main.params[ 'MN' ][ 'ip1' ]
+ ONOSUser = main.params[ 'CTRL' ][ 'user' ]
- default_sw_port = main.params['CTRL']['port1']
-
- #Number of iterations of case
- num_iter = main.params['TEST']['numIter']
- num_sw = main.params['TEST']['numSwitch']
+ defaultSwPort = main.params[ 'CTRL' ][ 'port1' ]
- #Timestamp 'keys' for json metrics output.
- #These are subject to change, hence moved into params
- deviceTimestamp = main.params['JSON']['deviceTimestamp']
- graphTimestamp = main.params['JSON']['graphTimestamp']
-
- debug_mode = main.params['TEST']['debugMode']
+ # Number of iterations of case
+ numIter = main.params[ 'TEST' ][ 'numIter' ]
+ numSw = main.params[ 'TEST' ][ 'numSwitch' ]
- local_time = time.strftime('%X')
- local_time = local_time.replace("/","")
- local_time = local_time.replace(" ","_")
- local_time = local_time.replace(":","")
- if debug_mode == 'on':
- main.ONOS1.tshark_pcap("eth0",
- "/tmp/100_sw_lat_pcap_"+local_time)
-
- #Threshold for this test case
- sw_disc_threshold_str = main.params['TEST']['swDisc100Threshold']
- sw_disc_threshold_obj = sw_disc_threshold_str.split(",")
- sw_disc_threshold_min = int(sw_disc_threshold_obj[0])
- sw_disc_threshold_max = int(sw_disc_threshold_obj[1])
+ # Timestamp 'keys' for json metrics output.
+ # These are subject to change, hence moved into params
+ deviceTimestamp = main.params[ 'JSON' ][ 'deviceTimestamp' ]
+ graphTimestamp = main.params[ 'JSON' ][ 'graphTimestamp' ]
- tshark_ofp_output = "/tmp/tshark_ofp_"+num_sw+"sw.txt"
- tshark_tcp_output = "/tmp/tshark_tcp_"+num_sw+"sw.txt"
+ debugMode = main.params[ 'TEST' ][ 'debugMode' ]
- tshark_ofp_result_list = []
- tshark_tcp_result_list = []
+ localTime = time.strftime( '%X' )
+ localTime = localTime.replace( "/", "" )
+ localTime = localTime.replace( " ", "_" )
+ localTime = localTime.replace( ":", "" )
+ if debugMode == 'on':
+ main.ONOS1.tsharkPcap( "eth0",
+ "/tmp/100_sw_lat_pcap_" + localTime )
- sw_discovery_lat_list = []
+ # Threshold for this test case
+ swDiscThresholdStr = main.params[ 'TEST' ][ 'swDisc100Threshold' ]
+ swDiscThresholdObj = swDiscThresholdStr.split( "," )
+ swDiscThresholdMin = int( swDiscThresholdObj[ 0 ] )
+ swDiscThresholdMax = int( swDiscThresholdObj[ 1 ] )
- main.case(num_sw+" Switch discovery latency")
- main.step("Assigning all switches to ONOS1")
- for i in range(1, int(num_sw)+1):
- main.Mininet1.assign_sw_controller(
- sw=str(i),
- ip1=ONOS1_ip,
- port1=default_sw_port)
-
- #Ensure that nodes are configured with ptpd
- #Just a warning message
- main.log.info("Please check ptpd configuration to ensure"+\
- " All nodes' system times are in sync")
- time.sleep(5)
+ tsharkOfpOutput = "/tmp/tshark_ofp_" + numSw + "sw.txt"
+ tsharkTcpOutput = "/tmp/tshark_tcp_" + numSw + "sw.txt"
- for i in range(0, int(num_iter)):
-
- main.step("Set iptables rule to block incoming sw connections")
- #Set iptables rule to block incoming switch connections
- #The rule description is as follows:
+ tsharkOfpResultList = []
+ tsharkTcpResultList = []
+
+ swDiscoveryLatList = []
+
+ main.case( numSw + " Switch discovery latency" )
+ main.step( "Assigning all switches to ONOS1" )
+ for i in range( 1, int( numSw ) + 1 ):
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=defaultSwPort )
+
+ # Ensure that nodes are configured with ptpd
+ # Just a warning message
+ main.log.info( "Please check ptpd configuration to ensure" +
+ " All nodes' system times are in sync" )
+ time.sleep( 5 )
+
+ for i in range( 0, int( numIter ) ):
+
+ main.step( "Set iptables rule to block incoming sw connections" )
+ # Set iptables rule to block incoming switch connections
+ # The rule description is as follows:
# Append to INPUT rule,
# behavior DROP that matches following:
# * packet type: tcp
- # * source IP: MN1_ip
+ # * source IP: MN1Ip
# * destination PORT: 6633
main.ONOS1.handle.sendline(
- "sudo iptables -A INPUT -p tcp -s "+MN1_ip+
- " --dport "+default_sw_port+" -j DROP")
- main.ONOS1.handle.expect("\$")
- # Append to OUTPUT rule,
+ "sudo iptables -A INPUT -p tcp -s " + MN1Ip +
+ " --dport " + defaultSwPort + " -j DROP" )
+ main.ONOS1.handle.expect( "\$" )
+ # Append to OUTPUT rule,
# behavior DROP that matches following:
# * packet type: tcp
- # * source IP: MN1_ip
+ # * source IP: MN1Ip
# * destination PORT: 6633
main.ONOS1.handle.sendline(
- "sudo iptables -A OUTPUT -p tcp -s "+MN1_ip+
- " --dport "+default_sw_port+" -j DROP")
- main.ONOS1.handle.expect("\$")
- #Give time to allow rule to take effect
- #NOTE: Sleep period may need to be configured
+ "sudo iptables -A OUTPUT -p tcp -s " + MN1Ip +
+ " --dport " + defaultSwPort + " -j DROP" )
+ main.ONOS1.handle.expect( "\$" )
+ # Give time to allow rule to take effect
+ # NOTE: Sleep period may need to be configured
# based on the number of switches in the topology
- main.log.info("Please wait for switch connection to "+
- "time out")
- time.sleep(60)
-
- #Gather vendor OFP with tshark
- main.ONOS1.tshark_grep("OFP 86 Vendor",
- tshark_ofp_output)
- main.ONOS1.tshark_grep("TCP 74 ",
- tshark_tcp_output)
+ main.log.info( "Please wait for switch connection to " +
+ "time out" )
+ time.sleep( 60 )
- #NOTE: Remove all iptables rule quickly (flush)
- # Before removal, obtain TestON timestamp at which
+ # Gather vendor OFP with tshark
+ main.ONOS1.tsharkGrep( "OFP 86 Vendor",
+ tsharkOfpOutput )
+ main.ONOS1.tsharkGrep( "TCP 74 ",
+ tsharkTcpOutput )
+
+ # NOTE: Remove all iptables rule quickly ( flush )
+ # Before removal, obtain TestON timestamp at which
# removal took place
- # (ensuring nodes are configured via ptp)
+ # ( ensuring nodes are configured via ptp )
# sudo iptables -F
-
- t0_system = time.time() * 1000
+
+ t0System = time.time() * 1000
main.ONOS1.handle.sendline(
- "sudo iptables -F")
+ "sudo iptables -F" )
- #Counter to track loop count
- counter_loop = 0
- counter_avail1 = 0
- counter_avail2 = 0
- counter_avail3 = 0
- onos1_dev = False
- onos2_dev = False
- onos3_dev = False
- while counter_loop < 60:
- #Continue to check devices for all device
- #availability. When all devices in all 3
- #ONOS instances indicate that devices are available
- #obtain graph event timestamp for t1.
- device_str_obj1 = main.ONOS1cli.devices()
- device_str_obj2 = main.ONOS2cli.devices()
- device_str_obj3 = main.ONOS3cli.devices()
+ # Counter to track loop count
+ counterLoop = 0
+ counterAvail1 = 0
+ counterAvail2 = 0
+ counterAvail3 = 0
+ onos1Dev = False
+ onos2Dev = False
+ onos3Dev = False
+ while counterLoop < 60:
+ # Continue to check devices for all device
+ # availability. When all devices in all 3
+ # ONOS instances indicate that devices are available
+ # obtain graph event timestamp for t1.
+ deviceStrObj1 = main.ONOS1cli.devices()
+ deviceStrObj2 = main.ONOS2cli.devices()
+ deviceStrObj3 = main.ONOS3cli.devices()
- device_json1 = json.loads(device_str_obj1)
- device_json2 = json.loads(device_str_obj2)
- device_json3 = json.loads(device_str_obj3)
-
- for device1 in device_json1:
- if device1['available'] == True:
- counter_avail1 += 1
- if counter_avail1 == int(num_sw):
- onos1_dev = True
- main.log.info("All devices have been "+
- "discovered on ONOS1")
+ deviceJson1 = json.loads( deviceStrObj1 )
+ deviceJson2 = json.loads( deviceStrObj2 )
+ deviceJson3 = json.loads( deviceStrObj3 )
+
+ for device1 in deviceJson1:
+ if device1[ 'available' ]:
+ counterAvail1 += 1
+ if counterAvail1 == int( numSw ):
+ onos1Dev = True
+ main.log.info( "All devices have been " +
+ "discovered on ONOS1" )
else:
- counter_avail1 = 0
- for device2 in device_json2:
- if device2['available'] == True:
- counter_avail2 += 1
- if counter_avail2 == int(num_sw):
- onos2_dev = True
- main.log.info("All devices have been "+
- "discovered on ONOS2")
+ counterAvail1 = 0
+ for device2 in deviceJson2:
+ if device2[ 'available' ]:
+ counterAvail2 += 1
+ if counterAvail2 == int( numSw ):
+ onos2Dev = True
+ main.log.info( "All devices have been " +
+ "discovered on ONOS2" )
else:
- counter_avail2 = 0
- for device3 in device_json3:
- if device3['available'] == True:
- counter_avail3 += 1
- if counter_avail3 == int(num_sw):
- onos3_dev = True
- main.log.info("All devices have been "+
- "discovered on ONOS3")
+ counterAvail2 = 0
+ for device3 in deviceJson3:
+ if device3[ 'available' ]:
+ counterAvail3 += 1
+ if counterAvail3 == int( numSw ):
+ onos3Dev = True
+ main.log.info( "All devices have been " +
+ "discovered on ONOS3" )
else:
- counter_avail3 = 0
+ counterAvail3 = 0
- if onos1_dev and onos2_dev and onos3_dev:
- main.log.info("All devices have been discovered "+
- "on all ONOS instances")
- json_str_topology_metrics_1 =\
- main.ONOS1cli.topology_events_metrics()
- json_str_topology_metrics_2 =\
- main.ONOS2cli.topology_events_metrics()
- json_str_topology_metrics_3 =\
- main.ONOS3cli.topology_events_metrics()
-
- #Exit while loop if all devices discovered
- break
-
- counter_loop += 1
- #Give some time in between CLI calls
- #(will not affect measurement)
- time.sleep(3)
+ if onos1Dev and onos2Dev and onos3Dev:
+ main.log.info( "All devices have been discovered " +
+ "on all ONOS instances" )
+ jsonStrTopologyMetrics1 =\
+ main.ONOS1cli.topologyEventsMetrics()
+ jsonStrTopologyMetrics2 =\
+ main.ONOS2cli.topologyEventsMetrics()
+ jsonStrTopologyMetrics3 =\
+ main.ONOS3cli.topologyEventsMetrics()
- main.ONOS1.tshark_stop()
-
- os.system("scp "+ONOS_user+"@"+ONOS1_ip+":"+
- tshark_ofp_output+" /tmp/")
- os.system("scp "+ONOS_user+"@"+ONOS1_ip+":"+
- tshark_tcp_output+" /tmp/")
+ # Exit while loop if all devices discovered
+ break
- #TODO: Automate OFP output analysis
- #Debug mode - print out packets captured at runtime
- if debug_mode == 'on':
- ofp_file = open(tshark_ofp_output, 'r')
- main.log.info("Tshark OFP Vendor output: ")
- for line in ofp_file:
- tshark_ofp_result_list.append(line)
- main.log.info(line)
- ofp_file.close()
+ counterLoop += 1
+ # Give some time in between CLI calls
+ #( will not affect measurement )
+ time.sleep( 3 )
- tcp_file = open(tshark_tcp_output, 'r')
- main.log.info("Tshark TCP 74 output: ")
- for line in tcp_file:
- tshark_tcp_result_list.append(line)
- main.log.info(line)
- tcp_file.close()
+ main.ONOS1.tsharkStop()
- json_obj_1 = json.loads(json_str_topology_metrics_1)
- json_obj_2 = json.loads(json_str_topology_metrics_2)
- json_obj_3 = json.loads(json_str_topology_metrics_3)
+ os.system( "scp " + ONOSUser + "@" + ONOS1Ip + ":" +
+ tsharkOfpOutput + " /tmp/" )
+ os.system( "scp " + ONOSUser + "@" + ONOS1Ip + ":" +
+ tsharkTcpOutput + " /tmp/" )
- graph_timestamp_1 = \
- json_obj_1[graphTimestamp]['value']
- graph_timestamp_2 = \
- json_obj_2[graphTimestamp]['value']
- graph_timestamp_3 = \
- json_obj_3[graphTimestamp]['value']
+ # TODO: Automate OFP output analysis
+ # Debug mode - print out packets captured at runtime
+ if debugMode == 'on':
+ ofpFile = open( tsharkOfpOutput, 'r' )
+ main.log.info( "Tshark OFP Vendor output: " )
+ for line in ofpFile:
+ tsharkOfpResultList.append( line )
+ main.log.info( line )
+ ofpFile.close()
- graph_lat_1 = int(graph_timestamp_1) - int(t0_system)
- graph_lat_2 = int(graph_timestamp_2) - int(t0_system)
- graph_lat_3 = int(graph_timestamp_3) - int(t0_system)
+ tcpFile = open( tsharkTcpOutput, 'r' )
+ main.log.info( "Tshark TCP 74 output: " )
+ for line in tcpFile:
+ tsharkTcpResultList.append( line )
+ main.log.info( line )
+ tcpFile.close()
- avg_graph_lat = \
- (int(graph_lat_1) +\
- int(graph_lat_2) +\
- int(graph_lat_3)) / 3
-
- if avg_graph_lat > sw_disc_threshold_min \
- and avg_graph_lat < sw_disc_threshold_max:
- sw_discovery_lat_list.append(
- avg_graph_lat)
+ jsonObj1 = json.loads( jsonStrTopologyMetrics1 )
+ jsonObj2 = json.loads( jsonStrTopologyMetrics2 )
+ jsonObj3 = json.loads( jsonStrTopologyMetrics3 )
+
+ graphTimestamp1 = \
+ jsonObj1[ graphTimestamp ][ 'value' ]
+ graphTimestamp2 = \
+ jsonObj2[ graphTimestamp ][ 'value' ]
+ graphTimestamp3 = \
+ jsonObj3[ graphTimestamp ][ 'value' ]
+
+ graphLat1 = int( graphTimestamp1 ) - int( t0System )
+ graphLat2 = int( graphTimestamp2 ) - int( t0System )
+ graphLat3 = int( graphTimestamp3 ) - int( t0System )
+
+ avgGraphLat = \
+ ( int( graphLat1 ) +
+ int( graphLat2 ) +
+ int( graphLat3 ) ) / 3
+
+ if avgGraphLat > swDiscThresholdMin \
+ and avgGraphLat < swDiscThresholdMax:
+ swDiscoveryLatList.append(
+ avgGraphLat )
else:
- main.log.info("100 Switch discovery latency "+
- "exceeded the threshold.")
-
- #END ITERATION FOR LOOP
+ main.log.info( "100 Switch discovery latency " +
+ "exceeded the threshold." )
- sw_lat_min = min(sw_discovery_lat_list)
- sw_lat_max = max(sw_discovery_lat_list)
- sw_lat_avg = sum(sw_discovery_lat_list) /\
- len(sw_discovery_lat_list)
+ # END ITERATION FOR LOOP
- main.log.report("100 Switch discovery lat "+\
- "Min: "+str(sw_lat_min)+" ms"+\
- "Max: "+str(sw_lat_max)+" ms"+\
- "Avg: "+str(sw_lat_avg)+" ms")
+ swLatMin = min( swDiscoveryLatList )
+ swLatMax = max( swDiscoveryLatList )
+ swLatAvg = sum( swDiscoveryLatList ) /\
+ len( swDiscoveryLatList )
- def CASE6(self, main):
- '''
+ main.log.report( "100 Switch discovery lat " +
+ "Min: " + str( swLatMin ) + " ms" +
+ "Max: " + str( swLatMax ) + " ms" +
+ "Avg: " + str( swLatAvg ) + " ms" )
+
+ def CASE6( self, main ):
+ """
Increase number of nodes and initiate CLI
- '''
+ """
import time
-
- 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']
-
- global cluster_count
-
- #Cluster size increased everytime the case is defined
- cluster_count += 2
+ 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' ]
- main.log.report("Increasing cluster size to "+
- str(cluster_count))
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
- install_result = main.FALSE
- if cluster_count == 3:
- main.log.info("Installing nodes 2 and 3")
- node2_result = \
- main.ONOSbench.onos_install(node=ONOS2_ip)
- node3_result = \
- main.ONOSbench.onos_install(node=ONOS3_ip)
- install_result = node2_result and node3_result
-
- time.sleep(5)
+ global clusterCount
- main.ONOS2cli.start_onos_cli(ONOS2_ip)
- main.ONOS3cli.start_onos_cli(ONOS3_ip)
+ # Cluster size increased everytime the case is defined
+ clusterCount += 2
- 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
+ main.log.report( "Increasing cluster size to " +
+ str( clusterCount ) )
- time.sleep(5)
+ installResult = main.FALSE
+ if clusterCount == 3:
+ main.log.info( "Installing nodes 2 and 3" )
+ node2Result = \
+ main.ONOSbench.onosInstall( node=ONOS2Ip )
+ node3Result = \
+ main.ONOSbench.onosInstall( node=ONOS3Ip )
+ installResult = node2Result and node3Result
- main.ONOS4cli.start_onos_cli(ONOS4_ip)
- main.ONOS5cli.start_onos_cli(ONOS5_ip)
+ time.sleep( 5 )
- 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
+ main.ONOS2cli.startOnosCli( ONOS2Ip )
+ main.ONOS3cli.startOnosCli( ONOS3Ip )
- time.sleep(5)
+ elif clusterCount == 5:
+ main.log.info( "Installing nodes 4 and 5" )
+ node4Result = \
+ main.ONOSbench.onosInstall( node=ONOS4Ip )
+ node5Result = \
+ main.ONOSbench.onosInstall( node=ONOS5Ip )
+ installResult = node4Result and node5Result
- main.ONOS6cli.start_onos_cli(ONOS6_ip)
- main.ONOS7cli.start_onos_cli(ONOS7_ip)
+ time.sleep( 5 )
+ main.ONOS4cli.startOnosCli( ONOS4Ip )
+ main.ONOS5cli.startOnosCli( ONOS5Ip )
+ elif clusterCount == 7:
+ main.log.info( "Installing nodes 6 and 7" )
+ node6Result = \
+ main.ONOSbench.onosInstall( node=ONOS6Ip )
+ node7Result = \
+ main.ONOSbench.onosInstall( node=ONOS7Ip )
+ installResult = node6Result and node7Result
+ time.sleep( 5 )
+
+ main.ONOS6cli.startOnosCli( ONOS6Ip )
+ main.ONOS7cli.startOnosCli( ONOS7Ip )
diff --git a/TestON/tests/TopoPerfNext/TopoPerfNext.topo b/TestON/tests/TopoPerfNext/TopoPerfNext.topo
index fc70784..f12d192 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.topo
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.topo
@@ -24,7 +24,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
- <connect_order>2</connect_order>
+ <connect_order>3</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS2cli>
@@ -33,7 +33,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
- <connect_order>2</connect_order>
+ <connect_order>4</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS3cli>
@@ -42,7 +42,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
- <connect_order>2</connect_order>
+ <connect_order>5</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS4cli>
@@ -51,7 +51,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
- <connect_order>2</connect_order>
+ <connect_order>6</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS5cli>
@@ -60,7 +60,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
- <connect_order>2</connect_order>
+ <connect_order>7</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS6cli>
@@ -69,7 +69,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosCliDriver</type>
- <connect_order>2</connect_order>
+ <connect_order>8</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS7cli>
@@ -78,7 +78,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosDriver</type>
- <connect_order>3</connect_order>
+ <connect_order>9</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS1>
@@ -87,7 +87,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosDriver</type>
- <connect_order>3</connect_order>
+ <connect_order>10</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS2>
@@ -96,7 +96,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosDriver</type>
- <connect_order>3</connect_order>
+ <connect_order>11</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS3>
@@ -105,7 +105,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosDriver</type>
- <connect_order>3</connect_order>
+ <connect_order>12</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS4>
@@ -114,7 +114,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosDriver</type>
- <connect_order>3</connect_order>
+ <connect_order>13</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS5>
@@ -123,7 +123,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosDriver</type>
- <connect_order>3</connect_order>
+ <connect_order>14</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS6>
@@ -132,7 +132,7 @@
<user>admin</user>
<password>onos_test</password>
<type>OnosDriver</type>
- <connect_order>3</connect_order>
+ <connect_order>15</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS7>
@@ -141,7 +141,7 @@
<user>admin</user>
<password>onos_test</password>
<type>MininetCliDriver</type>
- <connect_order>4</connect_order>
+ <connect_order>16</connect_order>
<COMPONENTS>
<arg1> --custom topo-perf-2sw.py </arg1>
<arg2> --arp --mac --topo mytopo</arg2>
@@ -155,7 +155,7 @@
<user>admin</user>
<password>onos_test</password>
<type>RemoteMininetDriver</type>
- <connect_order>5</connect_order>
+ <connect_order>17</connect_order>
<COMPONENTS> </COMPONENTS>
</Mininet2>
diff --git a/TestON/tests/prevFuncNext/FuncNext.params b/TestON/tests/prevFuncNext/FuncNext.params
new file mode 100755
index 0000000..13a4691
--- /dev/null
+++ b/TestON/tests/prevFuncNext/FuncNext.params
@@ -0,0 +1,37 @@
+<PARAMS>
+
+ <testcases>1,4,5,3</testcases>
+
+ #Environment variables
+ <ENV>
+ <cellName>driver_test</cellName>
+ </ENV>
+
+ <CTRL>
+ <ip1>10.128.20.11</ip1>
+ <port1>6633</port1>
+ </CTRL>
+
+ <PING>
+ <source1>h8</source1>
+ <source2>h9</source2>
+ <source3>h10</source3>
+ <source4>h11</source4>
+ <source5>h12</source5>
+ <source6>h13</source6>
+ <source7>h14</source7>
+ <source8>h15</source8>
+ <source9>h16</source9>
+ <source10>h17</source10>
+ <target1>10.0.0.18</target1>
+ <target2>10.0.0.19</target2>
+ <target3>10.0.0.20</target3>
+ <target4>10.0.0.21</target4>
+ <target5>10.0.0.22</target5>
+ <target6>10.0.0.23</target6>
+ <target7>10.0.0.24</target7>
+ <target8>10.0.0.25</target8>
+ <target9>10.0.0.26</target9>
+ <target10>10.0.0.27</target10>
+ </PING>
+</PARAMS>
diff --git a/TestON/tests/prevFuncNext/FuncNext.py b/TestON/tests/prevFuncNext/FuncNext.py
new file mode 100755
index 0000000..e556fa4
--- /dev/null
+++ b/TestON/tests/prevFuncNext/FuncNext.py
@@ -0,0 +1,311 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import sys
+import os
+import re
+import time
+
+time.sleep(1)
+class FuncNext:
+ def __init__(self):
+ self.default = ''
+
+ def CASE1(self, main):
+ '''
+ Startup sequence:
+ git pull
+ mvn clean install
+ onos-package
+ cell <name>
+ onos-verify-cell
+ onos-install -f
+ onos-wait-for-start
+ '''
+
+ cell_name = main.params['ENV']['cellName']
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS1_port = main.params['CTRL']['port1']
+
+ main.case("Setting up test environment")
+
+ main.step("Git checkout and pull master and get version")
+ main.ONOSbench.git_checkout("master")
+ git_pull_result = main.ONOSbench.git_pull()
+ version_result = main.ONOSbench.get_version()
+
+ main.step("Using mvn clean & install")
+ #clean_install_result = main.ONOSbench.clean_install()
+ #clean_install_result = main.TRUE
+
+ main.step("Applying cell variable to environment")
+ cell_result = main.ONOSbench.set_cell(cell_name)
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result = main.ONOS2.set_cell(cell_name)
+ #verify_result = main.ONOS2.verify_cell()
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ main.step("Creating ONOS package")
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step("Creating a cell")
+ #cell_create_result = main.ONOSbench.create_cell_file(**************)
+
+ main.step("Installing ONOS package")
+ onos_install_result = main.ONOSbench.onos_install()
+ onos1_isup = main.ONOSbench.isup()
+
+ main.step("Starting ONOS service")
+ start_result = main.ONOSbench.onos_start(ONOS1_ip)
+
+ case1_result = (package_result and\
+ cell_result and verify_result and onos_install_result and\
+ onos1_isup and start_result )
+ utilities.assert_equals(expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful")
+
+ def CASE11(self, main):
+ '''
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Cleaning up test environment")
+
+ main.step("Testing ONOS kill function")
+ kill_result = main.ONOSbench.onos_kill(ONOS1_ip)
+
+ main.step("Stopping ONOS service")
+ stop_result = main.ONOSbench.onos_stop(ONOS1_ip)
+
+ main.step("Uninstalling ONOS service")
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ def CASE3(self, main):
+ '''
+ Test 'onos' command and its functionality in driver
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Testing 'onos' command")
+
+ main.step("Sending command 'onos -w <onos-ip> system:name'")
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result1)
+
+ main.step("Sending command 'onos -w <onos-ip> onos:topology'")
+ cmdstr2 = "onos:topology"
+ cmd_result2 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result2)
+
+
+
+ def CASE4(self, main):
+ import re
+ import time
+ main.case("Pingall Test")
+ main.step("Assigning switches to controllers")
+ for i in range(1,29):
+ if i ==1:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=2 and i<5:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=5 and i<8:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=8 and i<18:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=18 and i<28:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ else:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ Switch_Mastership = main.TRUE
+ for i in range (1,29):
+ if i==1:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=2 and i<5:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=5 and i<8:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=8 and i<18:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=18 and i<28:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ else:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is" + str(response))
+ if re.search("tcp:" +ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+
+ if Switch_Mastership == main.TRUE:
+ main.log.report("MasterControllers assigned correctly")
+ utilities.assert_equals(expect = main.TRUE,actual=Switch_Mastership,
+ onpass="MasterControllers assigned correctly")
+ '''
+ for i in range (1,29):
+ main.Mininet1.assign_sw_controller(sw=str(i),count=5,
+ ip1=ONOS1_ip,port1=ONOS1_port,
+ ip2=ONOS2_ip,port2=ONOS2_port,
+ ip3=ONOS3_ip,port3=ONOS3_port,
+ ip4=ONOS4_ip,port4=ONOS4_port,
+ ip5=ONOS5_ip,port5=ONOS5_port)
+ '''
+ #REACTIVE FWD test
+
+ main.step("Get list of hosts from Mininet")
+ host_list = main.Mininet1.get_hosts()
+ main.log.info(host_list)
+
+ main.step("Get host list in ONOS format")
+ host_onos_list = main.ONOS2.get_hosts_id(host_list)
+ main.log.info(host_onos_list)
+ #time.sleep(5)
+
+ #We must use ping from hosts we want to add intents from
+ #to make the hosts talk
+ #main.Mininet2.handle.sendline("\r")
+ #main.Mininet2.handle.sendline("h4 ping 10.1.1.1 -c 1 -W 1")
+ #time.sleep(3)
+ #main.Mininet2.handle.sendline("h5 ping 10.1.1.1 -c 1 -W 1")
+ #time.sleep(5)
+
+ main.step("Pingall")
+ ping_result = main.FALSE
+ while ping_result == main.FALSE:
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % (time2 - time1)
+
+ #Start onos cli again because u might have dropped out of onos prompt to the shell prompt
+ #if there was no activity
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ main.step("Get hosts")
+ main.ONOS2.handle.sendline("hosts")
+ main.ONOS2.handle.expect("onos>")
+ hosts = main.ONOS2.handle.before
+ main.log.info(hosts)
+
+ main.step("Get all devices id")
+ devices_id_list = main.ONOS2.get_all_devices_id()
+ main.log.info(devices_id_list)
+ '''
+ main.step("Add point-to-point intents")
+ ptp_intent_result = main.ONOS2.add_point_intent(
+ devices_id_list[0], 1, devices_id_list[1], 2)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+ '''
+
+ case4_result = Switch_Mastership and ping_result
+ utilities.assert_equals(expect=main.TRUE, actual=case4_result,
+ onpass="Pingall Test successful",
+ onfail="Pingall Test NOT successful")
+
+ def CASE5(self,main) :
+ import time
+ from subprocess import Popen, PIPE
+ from sts.topology.teston_topology import TestONTopology # assumes that sts is already in you PYTHONPATH
+ #main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+ deviceResult = main.ONOS2.devices()
+ linksResult = main.ONOS2.links()
+ portsResult = main.ONOS2.ports()
+ print "**************"
+ main.step("Start continuous pings")
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+ main.step("Create TestONTopology object")
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ('ip' + str(count)) in main.params['CTRL']:
+ temp = temp + (getattr(main,('ONOS' + str(count))),)
+ temp = temp + ("ONOS"+str(count),)
+ temp = temp + (main.params['CTRL']['ip'+str(count)],)
+ temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
+ ctrls.append(temp)
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step("Compare ONOS Topology to MN Topology")
+ '''for n in range(1,6):
+ result = main.Mininet1.compare_topo(MNTopo,
+ main.ONOS1.get_json(main.params['CTRL']['ip'+str(n)]+":"+ \
+ main.params['CTRL']['restPort'+str(n)]+main.params['TopoRest']))
+ if result == main.TRUE:
+ main.log.report("ONOS"+str(n) + " Topology matches MN Topology")
+ utilities.assert_equals(expect=main.TRUE,actual=result,
+ onpass="ONOS" + str(n) + " Topology matches MN Topology",
+ onfail="ONOS" + str(n) + " Topology does not match MN Topology")
+ Topology_Check = Topology_Check and result
+ utilities.assert_equals(expect=main.TRUE,actual=Topology_Check,
+ onpass="Topology checks passed", onfail="Topology checks failed")
+ '''
+
+
diff --git a/TestON/tests/prevFuncNext/FuncNext.topo b/TestON/tests/prevFuncNext/FuncNext.topo
new file mode 100755
index 0000000..5d453a6
--- /dev/null
+++ b/TestON/tests/prevFuncNext/FuncNext.topo
@@ -0,0 +1,61 @@
+<TOPOLOGY>
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1>
+ <host>10.128.10.11</host>
+ <user>sdn</user>
+ <password>sdn</password>
+ <type>OnosDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <Mininet1>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>MininetCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow10 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet1>
+
+ <Mininet2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow10 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet2>
+ </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/prevFuncNext/__init__.py b/TestON/tests/prevFuncNext/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/prevFuncNext/__init__.py