Merge pull request #62 from opennetworkinglab/devl/control_strings
Devl/control strings
diff --git a/README.md b/README.md
index 5986719..ef2c912 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,12 @@
TestON is the testing platform that all the ONOS tests are being run on currently.
-Setup
+Code Style
+-------------
+At ON.Lab, we have adopted the [Mininet Python style](https://github.com/mininet/mininet/wiki/Mininet-Python-Style) for our drivers and testcases. The one exception is that TestON does not correctly parse multiline comments in testcases when the ending triple double quotes are on the same line as the comment. Therefore, in the testcases, the ending triple double quotes must be on it's own line.
+
+
+Setup
-------------
0. Pull the git repo from https://github.com/OPENNETWORKINGLAB/ONLabTest.git
diff --git a/TestON/tests/IntentPerfNext/Dependency/IntentClass.py b/TestON/tests/IntentPerfNext/Dependency/IntentClass.py
new file mode 100644
index 0000000..f5b17c2
--- /dev/null
+++ b/TestON/tests/IntentPerfNext/Dependency/IntentClass.py
@@ -0,0 +1,56 @@
+
+def __init__(self):
+ self_ = self
+
+def printLog(main):
+ main.log.info("Print log success")
+
+def iptablesDropAllNodes(main, MN_ip, sw_port):
+ #INPUT RULES
+ main.ONOS1.handle.sendline(
+ "sudo iptables -A INPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS2.handle.sendline(
+ "sudo iptables -A INPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS3.handle.sendline(
+ "sudo iptables -A INPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS4.handle.sendline(
+ "sudo iptables -A INPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS5.handle.sendline(
+ "sudo iptables -A INPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS6.handle.sendline(
+ "sudo iptables -A INPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS7.handle.sendline(
+ "sudo iptables -A INPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+
+ main.ONOS1.handle.sendline(
+ "sudo iptables -A OUTPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS2.handle.sendline(
+ "sudo iptables -A OUTPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS3.handle.sendline(
+ "sudo iptables -A OUTPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS4.handle.sendline(
+ "sudo iptables -A OUTPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS5.handle.sendline(
+ "sudo iptables -A OUTPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS6.handle.sendline(
+ "sudo iptables -A OUTPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+ main.ONOS7.handle.sendline(
+ "sudo iptables -A OUTPUT -p tcp -s "+
+ MN_ip+" --dport "+sw_port+" -j DROP")
+
+def uninstallAllNodes(main, node_ip_list):
+ for node in node_ip_list:
+ main.ONOSbench.onos_uninstall(node_ip = node)
diff --git a/TestON/tests/IntentPerfNext/Dependency/__init__.py b/TestON/tests/IntentPerfNext/Dependency/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/IntentPerfNext/Dependency/__init__.py
diff --git a/TestON/tests/IntentPerfNext/IntentPerfNext.params b/TestON/tests/IntentPerfNext/IntentPerfNext.params
index edba27b..dbcd05c 100644
--- a/TestON/tests/IntentPerfNext/IntentPerfNext.params
+++ b/TestON/tests/IntentPerfNext/IntentPerfNext.params
@@ -1,5 +1,5 @@
<PARAMS>
- <testcases>1,5,7,2,3</testcases>
+ <testcases>1,4,5,2,3,4,5,2,3,4,5,2,3,4</testcases>
<ENV>
<cellName>intent_perf_test</cellName>
@@ -36,13 +36,15 @@
<TEST>
#Number of times to iterate each case
- <numIter>15</numIter>
- <numIgnore>3</numIgnore>
- <numSwitch>9</numSwitch>
+ <numIter>12</numIter>
+ <numIgnore>2</numIgnore>
+ <numSwitch>8</numSwitch>
<batchThresholdMin>0</batchThresholdMin>
<batchThresholdMax>1000</batchThresholdMax>
- <batchIntentSize>200</batchIntentSize>
+ <batchIntentSize>1</batchIntentSize>
<numMult>1</numMult>
+ #Interface to bring down for intent reroute case
+ <intfs>s3-eth2</intfs>
</TEST>
<JSON>
diff --git a/TestON/tests/IntentPerfNext/IntentPerfNext.py b/TestON/tests/IntentPerfNext/IntentPerfNext.py
index daa1ae2..74ce298 100644
--- a/TestON/tests/IntentPerfNext/IntentPerfNext.py
+++ b/TestON/tests/IntentPerfNext/IntentPerfNext.py
@@ -1,832 +1,1089 @@
-# 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
+ cluster_count = 1
- cell_name = main.params[ 'ENV' ][ 'cellName' ]
+ cell_name = main.params['ENV']['cellName']
- git_pull = main.params[ 'GIT' ][ 'autoPull' ]
- checkout_branch = main.params[ 'GIT' ][ 'checkout' ]
+ git_pull = main.params['GIT']['autoPull']
+ checkout_branch = 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' ]
+ 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']
- 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.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)
- MN1_ip = main.params[ 'MN' ][ 'ip1' ]
- BENCH_ip = main.params[ 'BENCH' ][ 'ip' ]
+ MN1_ip = main.params['MN']['ip1']
+ BENCH_ip = main.params['BENCH']['ip']
+
+ main.case("Setting up test environment")
- main.case( "Setting up test environment" )
-
- main.step( "Creating cell file" )
+ 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, ONOS2_ip, ONOS3_ip )
- ONOS1_ip )
+ BENCH_ip, cell_name, MN1_ip,
+ "onos-core,onos-app-metrics,onos-gui",
+ ONOS1_ip)
- main.step( "Applying cell file to environment" )
- cell_apply_result = main.ONOSbench.set_cell( cell_name )
+ 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( "Removing raft logs" )
+ main.step("Removing raft logs")
main.ONOSbench.onos_remove_raft_logs()
- main.step( "Git checkout and pull " + checkout_branch )
+ main.step("Git checkout and pull "+checkout_branch)
if git_pull == 'on':
checkout_result = \
- main.ONOSbench.git_checkout( checkout_branch )
+ 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" )
+
+ #If you used git pull, auto compile
+ main.step("Using onos-build to compile ONOS")
build_result = main.ONOSbench.onos_build()
else:
checkout_result = main.TRUE
pull_result = main.TRUE
build_result = main.TRUE
- main.log.info( "Git pull skipped by configuration" )
+ 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.get_version(report=True)
- main.step( "Creating ONOS package" )
+ main.step("Creating ONOS package")
package_result = main.ONOSbench.onos_package()
- 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")
+ 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( "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.set_cell(cell_name)
+ #main.ONOS2cli.set_cell(cell_name)
+ #main.ONOS3cli.set_cell(cell_name)
- 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.start_onos_cli(ONOS1_ip)
+ #cli2 = main.ONOS2cli.start_onos_cli(ONOS2_ip)
+ #cli3 = main.ONOS3cli.start_onos_cli(ONOS3_ip)
- 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 = 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")
- 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
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
- ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
- ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
- ONOS_user = main.params[ 'CTRL' ][ 'user' ]
+ 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']
- default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
+ default_sw_port = 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
+ num_iter = main.params['TEST']['numIter']
+ num_ignore = int(main.params['TEST']['numIgnore'])
- # 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
+ submit_time = main.params['JSON']['submittedTime']
+ install_time = main.params['JSON']['installedTime']
+ wdRequest_time = main.params['JSON']['wdRequestTime']
+ withdrawn_time = 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:
+ 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:
+ if i < 3:
+ index = 0
+ elif i < 5 and i >= 3:
+ index = 1
+ elif i < 7 and i >= 5:
+ index = 2
+ elif i == 7:
+ 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:
+ 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
+ )
- # Assign 'linear' switch format for basic intent testing
- main.Mininet1.assign_sw_controller(
- sw="1", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(
- sw="2", ip1=ONOS2_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(
- sw="3", ip1=ONOS2_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(
- sw="4", ip1=ONOS2_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(
- sw="5", ip1=ONOS3_ip, port1=default_sw_port )
+ 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 )
+ devices_json_obj = json.loads(devices_json_str)
+
+ if not devices_json_obj:
+ main.log.report("Devices not discovered")
+ main.log.report("Aborting test")
+ main.exit()
+ else:
+ main.log.info("Devices discovered successfully")
+
device_id_list = []
- # Obtain device id list in ONOS format.
- # They should already be in order ( 1,2,3,10,11,12,13, etc )
+ #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' ] )
+ device_id_list.append(device['id'])
- for i in range( 0, int( num_iter ) ):
- # add_point_intent( ingr_device, egr_device,
- # ingr_port, egr_port )
+ 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 ] + "/1", device_id_list[ 4 ] + "/1" )
+ 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))
+ else:
+ #TODO: Add error handling
+ main.log.info("Intent installation failed")
+ intent_id = ""
- # Allow some time for intents to propagate
- time.sleep( 5 )
-
- # Obtain metrics from ONOS 1, 2, 3
+ #Obtain metrics from ONOS 1, 2, 3
intents_json_str_1 = main.ONOS1cli.intents_events_metrics()
- intents_json_str_2 = main.ONOS2cli.intents_events_metrics()
- intents_json_str_3 = main.ONOS3cli.intents_events_metrics()
-
- intents_json_obj_1 = json.loads( intents_json_str_1 )
- intents_json_obj_2 = json.loads( intents_json_str_2 )
- intents_json_obj_3 = json.loads( intents_json_str_3 )
-
- # Parse values from the json object
+ 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_submit_2 = \
- intents_json_obj_2[ submit_time ][ 'value' ]
- intent_submit_3 = \
- intents_json_obj_3[ submit_time ][ 'value' ]
-
+ intents_json_obj_1[submit_time]['value']
intent_install_1 = \
- intents_json_obj_1[ install_time ][ 'value' ]
- intent_install_2 = \
- intents_json_obj_2[ install_time ][ 'value' ]
- intent_install_3 = \
- intents_json_obj_3[ install_time ][ 'value' ]
-
+ intents_json_obj_1[install_time]['value']
intent_install_lat_1 = \
- int( intent_install_1 ) - int( intent_submit_1 )
- intent_install_lat_2 = \
- int( intent_install_2 ) - int( intent_submit_2 )
- intent_install_lat_3 = \
- int( intent_install_3 ) - int( intent_submit_3 )
+ 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)
+ else:
+ intent_install_lat_2 = 0
+ intent_install_lat_3 = 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)
+ else:
+ intent_install_lat_4 = 0
+ intent_install_lat_5 = 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)
+ else:
+ intent_install_lat_6 = 0
+ intent_install_lat_7 = 0
intent_install_lat_avg = \
- ( intent_install_lat_1 +
- intent_install_lat_2 +
- intent_install_lat_3 ) / 3
+ (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
- 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(intent_install_lat_avg)+" 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 )
+ intent_add_lat_list.append(intent_install_lat_avg)
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: Possibly put this in the driver function
- main.log.info( "Removing intents for next iteration" )
+ 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 )
+ 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 )
+ 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)
else:
- main.log.info( "Intents were not installed correctly" )
+ main.log.info("Intents were not installed correctly")
- time.sleep( 5 )
+ time.sleep(5)
- intent_add_lat_avg = sum( intent_add_lat_list ) /\
- len( intent_add_lat_list )
+ if intent_add_lat_list:
+ intent_add_lat_avg = sum(intent_add_lat_list) /\
+ len(intent_add_lat_list)
+ else:
+ main.log.report("Intent installation latency test failed")
+ intent_add_lat_avg = "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" )
+ 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,
+ onpass="Single intent install latency test successful",
+ 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
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
- ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
- ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
- ONOS_user = main.params[ 'CTRL' ][ 'user' ]
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+ ONOS_user = main.params['CTRL']['user']
- default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
+ default_sw_port = 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
+ num_iter = main.params['TEST']['numIter']
+ num_ignore = 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
+ submit_time = main.params['JSON']['submittedTime']
+ install_time = main.params['JSON']['installedTime']
+ wdRequest_time = main.params['JSON']['wdRequestTime']
+ withdrawn_time = main.params['JSON']['withdrawnTime']
+
+ #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 )
+ devices_json_obj = json.loads(devices_json_str)
device_id_list = []
- # Obtain device id list in ONOS format.
- # They should already be in order ( 1,2,3,10,11,12,13, etc )
+ #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' ] )
+ device_id_list.append(device['id'])
intent_reroute_lat_list = []
- 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:
+ 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[ 4 ] + "/1" )
+ device_id_list[0]+"/2", device_id_list[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 )
+ 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' ]
+ if intent['state'] == "INSTALLED":
+ main.log.info("Intent installed successfully")
+ intent_id = intent['id']
+ main.log.info("Intent id: "+str(intent_id))
else:
- # TODO: Add error handling
- main.log.info( "Intent installation failed" )
+ #TODO: Add error handling
+ main.log.info("Intent installation failed")
intent_id = ""
-
- # NOTE: this interface is specific to
- # topo-intentFlower.py topology
- # reroute case.
- main.log.info( "Disabling interface s2-eth3" )
+
+ main.log.info("Disabling interface "+intfs)
+ t0_system = time.time()*1000
main.Mininet1.handle.sendline(
- "sh ifconfig s2-eth3 down" )
- t0_system = time.time() * 1000
+ "sh ifconfig "+intfs+" down")
+ main.Mininet1.handle.expect("mininet>")
- # TODO: Check for correct intent reroute
- time.sleep( 5 )
+ #TODO: Check for correct intent reroute
+ time.sleep(1)
- # Obtain metrics from ONOS 1, 2, 3
+ #Obtain metrics from ONOS 1, 2, 3
intents_json_str_1 = main.ONOS1cli.intents_events_metrics()
- intents_json_str_2 = main.ONOS2cli.intents_events_metrics()
- intents_json_str_3 = main.ONOS3cli.intents_events_metrics()
-
- intents_json_obj_1 = json.loads( intents_json_str_1 )
- intents_json_obj_2 = json.loads( intents_json_str_2 )
- intents_json_obj_3 = json.loads( intents_json_str_3 )
-
- # Parse values from the json object
+ 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_install_2 = \
- intents_json_obj_2[ install_time ][ 'value' ]
- intent_install_3 = \
- intents_json_obj_3[ install_time ][ 'value' ]
-
+ intents_json_obj_1[install_time]['value']
intent_reroute_lat_1 = \
- int( intent_install_1 ) - int( t0_system )
- intent_reroute_lat_2 = \
- int( intent_install_2 ) - int( t0_system )
- intent_reroute_lat_3 = \
- int( intent_install_3 ) - int( t0_system )
+ 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)
+ else:
+ intent_reroute_lat_2 = 0
+ intent_reroute_lat_3 = 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)
+ else:
+ intent_reroute_lat_4 = 0
+ intent_reroute_lat_5 = 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)
+ else:
+ intent_reroute_lat_6 = 0
+ intent_reroute_lat_7 = 0
intent_reroute_lat_avg = \
- ( intent_reroute_lat_1 +
- intent_reroute_lat_2 +
- intent_reroute_lat_3 ) / 3
-
- main.log.info( "Intent reroute latency avg for iteration " +
- str( i ) + ": " + str( 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))
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 )
+ intent_reroute_lat_list.append(intent_reroute_lat_avg)
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.remove_intent(intent_id)
- 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 s2-eth3 up" )
+ "sh ifconfig "+intfs+" up")
+ main.Mininet1.handle.expect("mininet>")
- intent_reroute_lat_avg = sum( intent_reroute_lat_list ) /\
- len( intent_reroute_lat_list )
+ if intent_reroute_lat_list:
+ intent_reroute_lat_avg = sum(intent_reroute_lat_list) /\
+ len(intent_reroute_lat_list)
+ else:
+ main.log.report("Intent reroute test failed. Results NA")
+ intent_reroute_lat_avg = "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" )
-
- def CASE7( self, main ):
- """
- Batch intent reroute latency
- """
- import time
- import json
- import requests
- import os
- import numpy
-
- 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' ]
- 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' ] )
- install_time = main.params[ 'JSON' ][ 'installedTime' ]
-
- # 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' ]
-
- main.log.report( "Batch intent installation test of " +
- batch_intent_size + " intents" )
-
- batch_result_list = []
-
- # Assign 'linear' switch format for basic intent testing
- main.Mininet1.assign_sw_controller(
- sw="1", ip1=ONOS1_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(
- sw="2", ip1=ONOS2_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(
- sw="3", ip1=ONOS2_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(
- sw="4", ip1=ONOS2_ip, port1=default_sw_port )
- main.Mininet1.assign_sw_controller(
- sw="5", ip1=ONOS3_ip, port1=default_sw_port )
-
- time.sleep( 10 )
-
- 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' ] )
-
- batch_install_lat = []
- batch_withdraw_lat = []
- sleep_time = 10
-
- base_dir = "/tmp/"
- max_install_lat = []
-
- for i in range( 0, int( num_iter ) ):
- main.log.info( "Pushing " +
- str( int( batch_intent_size ) * int( n_thread ) ) +
- " intents. Iteration " + str( i ) )
-
- main.ONOS1cli.push_test_intents(
- "of:0000000000000001/1",
- "of:0000000000000005/1",
- 1000, num_mult="1", app_id="1" )
-
- # 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 s2-eth3" )
- main.Mininet1.handle.sendline(
- "sh ifconfig s2-eth3 down" )
- t0_system = time.time() * 1000
-
- # 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_str_2 = main.ONOS2cli.intents_events_metrics()
- intents_json_str_3 = main.ONOS3cli.intents_events_metrics()
-
- intents_json_obj_1 = json.loads( intents_json_str_1 )
- intents_json_obj_2 = json.loads( intents_json_str_2 )
- intents_json_obj_3 = json.loads( intents_json_str_3 )
-
- # Parse values from the json object
- intent_install_1 = \
- intents_json_obj_1[ install_time ][ 'value' ]
- intent_install_2 = \
- intents_json_obj_2[ install_time ][ 'value' ]
- intent_install_3 = \
- intents_json_obj_3[ install_time ][ 'value' ]
-
- intent_reroute_lat_1 = \
- int( intent_install_1 ) - int( t0_system )
- intent_reroute_lat_2 = \
- int( intent_install_2 ) - int( t0_system )
- intent_reroute_lat_3 = \
- int( intent_install_3 ) - int( t0_system )
-
- intent_reroute_lat_avg = \
- ( intent_reroute_lat_1 +
- intent_reroute_lat_2 +
- intent_reroute_lat_3 ) / 3
-
- 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 )
-
- intents_str = main.ONOS1cli.intents()
- intents_json = json.loads( intents_str )
- for intents in intents_json:
- intent_id = intents[ 'id' ]
- if intent_id:
- main.ONOS1cli.remove_intent( intent_id )
-
- main.Mininet1.handle.sendline(
- "sh ifconfig s2-eth3 up" )
-
- main.log.info( "Intents removed and port back up" )
-
- def CASE4( self, main ):
- """
+ 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,
+ onpass="Single intent reroute latency test successful",
+ 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
- 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' ]
+ 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']
+
+ assertion = main.TRUE
ONOS_ip_list = []
- for i in range( 1, 8 ):
- ONOS_ip_list.append( main.params[ 'CTRL' ][ 'ip' + str( i ) ] )
+ for i in range(1, 8):
+ ONOS_ip_list.append(main.params['CTRL']['ip'+str(i)])
- ONOS_user = main.params[ 'CTRL' ][ 'user' ]
+ ONOS_user = main.params['CTRL']['user']
- default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
+ 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'])
- batch_intent_size = main.params[ 'TEST' ][ 'batchIntentSize' ]
- batch_thresh_min = int( main.params[ 'TEST' ][ 'batchThresholdMin' ] )
- batch_thresh_max = int( main.params[ 'TEST' ][ 'batchThresholdMax' ] )
-
- # 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' ]
+ #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
- #*****
- global cluster_count
- #*****
-
- # Switch assignment NOTE: hardcoded
+ #Switch assignment NOTE: hardcoded
if cluster_count == 1:
- for i in range( 1, num_switch + 1 ):
+ for i in range(1, num_switch+1):
main.Mininet1.assign_sw_controller(
- sw=str( i ),
+ sw=str(i),
ip1=ONOS1_ip,
- port1=default_sw_port )
+ port1=default_sw_port)
if cluster_count == 3:
- for i in range( 1, 3 ):
+ for i in range(1, 3):
main.Mininet1.assign_sw_controller(
- sw=str( i ),
+ sw=str(i),
ip1=ONOS1_ip,
- port1=default_sw_port )
- for i in range( 3, 6 ):
+ port1=default_sw_port)
+ for i in range(3, 6):
main.Mininet1.assign_sw_controller(
- sw=str( i ),
+ sw=str(i),
ip1=ONOS2_ip,
- port1=default_sw_port )
- for i in range( 6, 9 ):
+ port1=default_sw_port)
+ for i in range(6, 9):
main.Mininet1.assign_sw_controller(
- sw=str( i ),
+ sw=str(i),
ip1=ONOS3_ip,
- port1=default_sw_port )
+ port1=default_sw_port)
if cluster_count == 5:
main.Mininet1.assign_sw_controller(
- sw="1",
- ip1=ONOS1_ip,
- port1=default_sw_port )
+ 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 ):
+ sw="2",
+ ip1=ONOS2_ip,
+ port1=default_sw_port)
+ for i in range(3, 6):
main.Mininet1.assign_sw_controller(
- sw=str( i ),
+ sw=str(i),
ip1=ONOS3_ip,
- port1=default_sw_port )
+ port1=default_sw_port)
main.Mininet1.assign_sw_controller(
- sw="6",
- ip1=ONOS4_ip,
- port1=default_sw_port )
+ sw="6",
+ ip1=ONOS4_ip,
+ port1=default_sw_port)
main.Mininet1.assign_sw_controller(
- sw="7",
- ip1=ONOS5_ip,
- port1=default_sw_port )
+ sw="7",
+ ip1=ONOS5_ip,
+ port1=default_sw_port)
main.Mininet1.assign_sw_controller(
- sw="8",
- ip1=ONOS5_ip,
- port1=default_sw_port )
-
+ sw="8",
+ ip1=ONOS5_ip,
+ port1=default_sw_port)
+
if cluster_count == 7:
- for i in range( 1, 9 ):
+ 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:
+ 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 )
+ sw=str(i),
+ ip1=ONOS_ip_list[6],
+ port1=default_sw_port)
- time.sleep( 30 )
+ time.sleep(20)
- main.log.report( "Batch intent installation test of " +
- batch_intent_size + " intents" )
+ main.log.report("Batch intent installation test of "+
+ batch_intent_size +" intent(s)")
batch_result_list = []
- main.log.info( "Getting list of available devices" )
+ main.log.info("Getting list of available devices")
device_id_list = []
json_str = main.ONOS1cli.devices()
- json_obj = json.loads( json_str )
+ json_obj = json.loads(json_str)
for device in json_obj:
- device_id_list.append( device[ 'id' ] )
+ device_id_list.append(device['id'])
batch_install_lat = []
batch_withdraw_lat = []
- sleep_time = 10
-
- base_dir = "/tmp/"
+
+ #Max intent install measurement of all nodes
max_install_lat = []
+ max_withdraw_lat = []
+ sleep_time = 10
+
+ base_dir = "/tmp/"
- 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 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)
- for node in range( 1, cluster_count + 1 ):
- save_dir = base_dir + "batch_intent_" + str( node ) + ".txt"
- main.ONOSbench.push_test_intents_shell(
- "of:0000000000000001/" + str( node ),
- "of:0000000000000008/" + str( node ),
- int( batch_intent_size ),
- save_dir, ONOS_ip_list[ node - 1 ],
- num_mult=n_thread, app_id=node )
+ intent = ""
+ counter = 300
+ while len(intent) > 0 and counter > 0:
+ main.ONOS1cli.handle.sendline(
+ "intents | wc -l")
+ main.ONOS1cli.handle.expect(
+ "intents | wc -l")
+ main.ONOS1cli.handle.expect(
+ "onos>")
+ intent_temp = main.ONOS1cli.handle.before()
+ intent = main.ONOS1cli.intents()
+ intent = json.loads(intent)
+ counter = counter-1
+ time.sleep(1)
- # Wait sufficient time for intents to start
- # installing
+ time.sleep(5)
- time.sleep( sleep_time )
- print sleep_time
+ 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")
- intent = ""
- counter = 300
- while len( intent ) > 0 and counter > 0:
- main.ONOS1cli.handle.sendline(
- "intents | wc -l" )
- main.ONOS1cli.handle.expect(
- "intents | wc -l" )
- main.ONOS1cli.handle.expect(
- "onos>" )
- intent_temp = main.ONOS1cli.handle.before()
- print intent_temp
+ 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))
+ else:
+ avg_install_lat = "NA"
+ main.log.report("Batch installation failed")
+ assertion = main.FALSE
- intent = main.ONOS1cli.intents()
- intent = json.loads( intent )
- counter = counter - 1
- time.sleep( 1 )
+ if max_withdraw_lat:
+ avg_withdraw_lat = str(sum(max_withdraw_lat) /\
+ len(max_withdraw_lat))
+ else:
+ avg_withdraw_lat = "NA"
+ main.log.report("Batch withdraw failed")
+ assertion = main.FALSE
- time.sleep( 5 )
+ 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")
- 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( ": " )
- result = line[ 1 ].split( " " )[ 0 ]
- # TODO: add parameters before appending latency
- if line_count == 0:
- batch_install_lat.append( int( result ) )
- elif line_count == 1:
- batch_withdraw_lat.append( int( result ) )
- line_count += 1
- main.log.info( "Batch install latency for ONOS" +
- str( node ) + " with " +
- str( batch_intent_size ) + "intents: " +
- str( batch_install_lat ) )
+ 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,
+ onpass="Batch intent install/withdraw test successful",
+ onfail="Batch intent install/withdraw test failed")
- 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
- batch_install_lat = []
-
- # Sleep in between iterations
- time.sleep( 5 )
-
- main.log.report( "Avg of batch installation latency " +
- ": " +
- str( sum( max_install_lat ) /
- len( max_install_lat ) ) )
- main.log.report( "Std Deviation of batch installation latency " +
- ": " +
- str( numpy.std( max_install_lat ) ) )
-
- 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' ]
+ 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']
global cluster_count
cluster_count += 2
- main.log.report( "Increasing cluster size to " +
- str( cluster_count ) )
+ main.log.report("Increasing cluster size to "+
+ str(cluster_count))
install_result = main.FALSE
if cluster_count == 3:
install_result1 = \
- main.ONOSbench.onos_install( node=ONOS2_ip )
+ main.ONOSbench.onos_install(node=ONOS2_ip)
install_result2 = \
- main.ONOSbench.onos_install( node=ONOS3_ip )
- time.sleep( 5 )
+ main.ONOSbench.onos_install(node=ONOS3_ip)
+ 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.start_onos_cli(ONOS2_ip)
+ main.ONOS3cli.start_onos_cli(ONOS3_ip)
install_result = install_result1 and install_result2
if cluster_count == 5:
- main.log.info( "Installing ONOS on node 4 and 5" )
+ main.log.info("Installing ONOS on node 4 and 5")
install_result1 = \
- main.ONOSbench.onos_install( node=ONOS4_ip )
+ main.ONOSbench.onos_install(node=ONOS4_ip)
install_result2 = \
- main.ONOSbench.onos_install( node=ONOS5_ip )
+ main.ONOSbench.onos_install(node=ONOS5_ip)
- 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.start_onos_cli(ONOS4_ip)
+ main.ONOS5cli.start_onos_cli(ONOS5_ip)
install_result = install_result1 and install_result2
if cluster_count == 7:
- main.log.info( "Installing ONOS on node 6 and 7" )
+ main.log.info("Installing ONOS on node 6 and 7")
install_result1 = \
- main.ONOSbench.onos_install( node=ONOS6_ip )
+ main.ONOSbench.onos_install(node=ONOS6_ip)
install_result2 = \
- main.ONOSbench.onos_install( node=ONOS7_ip )
+ main.ONOSbench.onos_install(node=ONOS7_ip)
- 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.start_onos_cli(ONOS6_ip)
+ main.ONOS7cli.start_onos_cli(ONOS7_ip)
install_result = install_result1 and install_result2
- time.sleep( 5 )
+ time.sleep(5)
if install_result == 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" )
+ 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
- def CASE9( self, main ):
+ '''
+ Batch intent reroute latency
+ '''
+ import time
+ import json
+ import requests
+ import os
+ import numpy
+ global cluster_count
+
+ 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']
+ 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']
+
+ #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']
+
+ main.log.report("Batch intent installation test of "+
+ batch_intent_size +" intents")
+
+ batch_result_list = []
+
+ time.sleep(10)
+
+ 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'])
+
+ batch_install_lat = []
+ batch_withdraw_lat = []
+ sleep_time = 10
+
+ base_dir = "/tmp/"
+ max_install_lat = []
+
+ for i in range(0, int(num_iter)):
+ main.log.info("Pushing "+
+ str(int(batch_intent_size)*int(n_thread))+
+ " intents. Iteration "+str(i))
+
+ 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(
+ # "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
+ # topo-intentFlower.py topology
+ # reroute case.
+ main.log.info("Disabling interface "+intfs)
+ main.Mininet1.handle.sendline(
+ "sh ifconfig "+intfs+" down")
+ t0_system = time.time()*1000
+
+ #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)
+ else:
+ intent_reroute_lat_2 = 0
+ intent_reroute_lat_3 = 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)
+ else:
+ intent_reroute_lat_4 = 0
+ intent_reroute_lat_5 = 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)
+ else:
+ intent_reroute_lat_6 = 0
+ intent_reroute_lat_7 = 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)
+
+ 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.Mininet1.handle.sendline(
+ "sh ifconfig "+intfs+" up")
+
+ main.log.info("Intents removed and port back up")
+
+ def CASE9(self, main):
count = 0
- sw_num1 = 1
+ sw_num1 = 1
sw_num2 = 1
appid = 0
port_num1 = 1
port_num2 = 1
-
- time.sleep( 30 )
+
+ time.sleep(30)
while True:
- # main.ONOS1cli.push_test_intents(
+ #main.ONOS1cli.push_test_intents(
#"of:0000000000001001/1",
#"of:0000000000002001/1",
- # 100, num_mult="10", app_id="1" )
- # main.ONOS2cli.push_test_intents(
+ # 100, num_mult="10", app_id="1")
+ #main.ONOS2cli.push_test_intents(
# "of:0000000000001002/1",
# "of:0000000000002002/1",
- # 100, num_mult="10", app_id="2" )
- # main.ONOS2cli.push_test_intents(
+ # 100, num_mult="10", app_id="2")
+ #main.ONOS2cli.push_test_intents(
# "of:0000000000001003/1",
# "of:0000000000002003/1",
- # 100, num_mult="10", app_id="3" )
+ # 100, num_mult="10", app_id="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 )
-
+ arg1 = "of:000000000000100"+str(sw_num1)+"/"+str(port_num1)
+ arg2 = "of:000000000000200"+str(sw_num2)+"/"+str(port_num2)
+
sw_num1 += 1
if sw_num1 > 7:
@@ -837,21 +1094,22 @@
if sw_num2 > 7:
sw_num2 = 1
-
+
main.ONOSbench.push_test_intents_shell(
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(
+ num_mult="10", app_id=appid,report=False)
+ #main.ONOSbench.push_test_intents_shell(
# "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(
+ # num_mult="6", app_id="2",report=False)
+ #main.ONOSbench.push_test_intents_shell(
# "of:0000000000001003/1",
# "of:0000000000002003/1",
# 133, "/tmp/temp3.txt", "10.128.174.3",
- # num_mult="6", app_id="3",report=False )
+ # num_mult="6", app_id="3",report=False)
+
+ time.sleep(0.2)
- time.sleep( 0.2 )
diff --git a/TestON/tests/IntentPerfNext/IntentPerfNext.topo b/TestON/tests/IntentPerfNext/IntentPerfNext.topo
index 048695d..9de0291 100644
--- a/TestON/tests/IntentPerfNext/IntentPerfNext.topo
+++ b/TestON/tests/IntentPerfNext/IntentPerfNext.topo
@@ -89,7 +89,7 @@
<type>MininetCliDriver</type>
<connect_order>4</connect_order>
<COMPONENTS>
- <arg1> --custom topo-intentFlower.py </arg1>
+ <arg1> --custom topo-intent-8sw.py </arg1>
<arg2> --arp --mac --topo mytopo </arg2>
<arg3> </arg3>
<controller> remote </controller>
diff --git a/TestON/tests/MultiProd/MultiProd.params b/TestON/tests/MultiProd/MultiProd.params
index 8bf1600..d0c7a10 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,31,32,8,33</testcases>
#Environment variables
<ENV>
diff --git a/TestON/tests/MultiProd/MultiProd.py b/TestON/tests/MultiProd/MultiProd.py
index 6b67f63..4d342ca 100644
--- a/TestON/tests/MultiProd/MultiProd.py
+++ b/TestON/tests/MultiProd/MultiProd.py
@@ -29,13 +29,13 @@
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' ]
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS2Port = main.params[ 'CTRL' ][ 'port2' ]
+ ONOS3Port = main.params[ 'CTRL' ][ 'port3' ]
main.case( "Setting up test environment" )
main.log.report(
@@ -43,141 +43,141 @@
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
+ cellResult1 = main.ONOSbench.setCell( cellName )
+ #cellResult2 = main.ONOScli1.setCell( cellName )
+ #cellResult3 = main.ONOScli2.setCell( cellName )
+ #cellResult4 = main.ONOScli3.setCell( cellName )
+ verifyResult = main.ONOSbench.verifyCell()
+ cellResult = cellResult1
main.step( "Removing raft logs before a clen installation of ONOS" )
- remove_log_Result = main.ONOSbench.onos_remove_raft_logs()
+ removeLogResult = main.ONOSbench.onosRemoveRaftLogs()
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 )
+ main.ONOSbench.gitCheckout( "master" )
+ gitPullResult = main.ONOSbench.gitPull()
+ print "git_pull_result = ", gitPullResult
+ versionResult = main.ONOSbench.getVersion( report=True )
- if git_pull_result == 1:
+ if gitPullResult == 1:
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( "Creating a cell" )
- # cell_create_result = main.ONOSbench.create_cell_file( **************
+ # cellCreateResult = main.ONOSbench.createCellFile( **************
# )
main.step( "Installing ONOS package" )
- onos1_install_result = main.ONOSbench.onos_install(
+ onos1InstallResult = main.ONOSbench.onosInstall(
options="-f",
- node=ONOS1_ip )
- onos2_install_result = main.ONOSbench.onos_install(
+ node=ONOS1Ip )
+ onos2InstallResult = main.ONOSbench.onosInstall(
options="-f",
- node=ONOS2_ip )
- onos3_install_result = main.ONOSbench.onos_install(
+ node=ONOS2Ip )
+ onos3InstallResult = main.ONOSbench.onosInstall(
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:
+ node=ONOS3Ip )
+ onosInstallResult = onos1InstallResult and onos2InstallResult and onos3InstallResult
+ if onosInstallResult == 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:
+ onos1Isup = main.ONOSbench.isup( ONOS1Ip )
+ onos2Isup = main.ONOSbench.isup( ONOS2Ip )
+ onos3Isup = main.ONOSbench.isup( ONOS3Ip )
+ onosIsup = onos1Isup and onos2Isup and onos3Isup
+ if onosIsup == 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 )
+ startResult = main.TRUE
+ #startResult = main.ONOSbench.onosStart( ONOS1Ip )
+ startcli1 = main.ONOScli1.startOnosCli( ONOSIp=ONOS1Ip )
+ startcli2 = main.ONOScli2.startOnosCli( ONOSIp=ONOS2Ip )
+ startcli3 = main.ONOScli3.startOnosCli( ONOSIp=ONOS3Ip )
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" )
+ case1Result = ( packageResult and
+ cellResult and verifyResult and onosInstallResult and
+ onosIsup and startResult )
+ utilities.assertEquals( expect=main.TRUE, actual=case1Result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful" )
def CASE11( self, main ):
"""
Cleanup sequence:
- onos-service <node_ip> stop
+ onos-service <nodeIp> 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' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = 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 )
+ killResult1 = main.ONOSbench.onosKill( ONOS1Ip )
+ killResult2 = main.ONOSbench.onosKill( ONOS2Ip )
+ killResult3 = main.ONOSbench.onosKill( ONOS3Ip )
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 )
+ stopResult1 = main.ONOSbench.onosStop( ONOS1Ip )
+ stopResult2 = main.ONOSbench.onosStop( ONOS2Ip )
+ stopResult3 = main.ONOSbench.onosStop( ONOS3Ip )
main.step( "Uninstalling ONOS service" )
- uninstall_result = main.ONOSbench.onos_uninstall()
+ uninstallResult = main.ONOSbench.onosUninstall()
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' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = 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 )
+ cmdResult1 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmdResult1 )
+ cmdResult2 = main.ONOSbench.onosCli( ONOS2Ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmdResult2 )
+ cmdResult3 = main.ONOSbench.onosCli( ONOS3Ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmdResult3 )
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 )
+ cmdResult4 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmdResult4 )
+ cmdResult5 = main.ONOSbench.onosCli( ONOS2Ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmdResult5 )
+ cmdResult6 = main.ONOSbench.onosCli( ONOS6Ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmdResult6 )
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' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS2Port = main.params[ 'CTRL' ][ 'port2' ]
+ ONOS3Port = 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" )
@@ -185,48 +185,48 @@
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(
+ main.Mininet1.assignSwController(
sw=str( i ),
count=3,
- ip1=ONOS1_ip,
- port1=ONOS1_port,
- ip2=ONOS2_ip,
- port2=ONOS2_port,
- ip3=ONOS3_ip,
- port3=ONOS3_port )
+ ip1=ONOS1Ip,
+ port1=ONOS1Port,
+ ip2=ONOS2Ip,
+ port2=ONOS2Port,
+ ip3=ONOS3Ip,
+ port3=ONOS3Port )
- switch_mastership = main.TRUE
+ switchMastership = main.TRUE
for i in range( 1, 29 ):
- response = main.Mininet1.get_sw_controller( "s" + str( i ) )
+ response = main.Mininet1.getSwController( "s" + str( i ) )
print( "Response is " + str( response ) )
- if re.search( "tcp:" + ONOS1_ip, response ):
- switch_mastership = switch_mastership and main.TRUE
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ switchMastership = switchMastership and main.TRUE
else:
- switch_mastership = main.FALSE
+ switchMastership = main.FALSE
- if switch_mastership == main.TRUE:
+ if switchMastership == 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
+ pingResult = main.FALSE
time1 = time.time()
- ping_result = main.Mininet1.pingall()
+ pingResult = 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:
+ 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(
+ utilities.assertEquals(
expect=main.TRUE,
- actual=case4_result,
+ actual=case4Result,
onpass="Controller assignment and Pingall Test successful",
onfail="Controller assignment and Pingall Test NOT successful" )
@@ -235,9 +235,9 @@
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' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2Ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3Ip = 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" )
@@ -336,85 +336,85 @@
ctrls ) # can also add Intent API info for intent operations
MNTopo = Topo
- Topology_Check = main.TRUE
+ TopologyCheck = main.TRUE
main.step( "Compare ONOS Topology to MN Topology" )
- switches_results1 = main.Mininet1.compare_switches(
+ switchesResults1 = main.Mininet1.compareSwitches(
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" )
+ print "switches_Result1 = ", switchesResults1
+ utilities.assertEquals( expect=main.TRUE, actual=switchesResults1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
- switches_results2 = main.Mininet1.compare_switches(
+ switchesResults2 = main.Mininet1.compareSwitches(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=switchesResults2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
- switches_results3 = main.Mininet1.compare_switches(
+ switchesResults3 = main.Mininet1.compareSwitches(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=switchesResults3,
+ 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,
+ portsResults1 = main.Mininet1.comparePorts( MNTopo, json.loads( ports1 ) )
+ utilities.assertEquals( expect=main.TRUE, actual=portsResults1,
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,
+ portsResults2 = main.Mininet1.comparePorts( MNTopo, json.loads( ports2 ) )
+ utilities.assertEquals( expect=main.TRUE, actual=portsResults2,
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,
+ portsResults3 = main.Mininet1.comparePorts( MNTopo, json.loads( ports3 ) )
+ utilities.assertEquals( expect=main.TRUE, actual=portsResults3,
onpass="ONOS3 Ports view is correct",
onfail="ONOS3 Ports view is incorrect" )
"""
- links_results1 = main.Mininet1.compare_links(
+ linksResults1 = main.Mininet1.compareLinks(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=linksResults1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
- links_results2 = main.Mininet1.compare_links(
+ linksResults2 = main.Mininet1.compareLinks(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=linksResults2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
- links_results3 = main.Mininet1.compare_links(
+ linksResults3 = main.Mininet1.compareLinks(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=linksResults3,
+ 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
+ #topoResult = switchesResults1 and switchesResults2 and switchesResults3\
+ # and portsResults1 and portsResults2 and portsResults3\
+ # and linksResults1 and linksResults2 and linksResults3
- topo_result = switches_results1 and switches_results2 and switches_results3\
- and links_results1 and links_results2 and links_results3
+ topoResult = switchesResults1 and switchesResults2 and switchesResults3\
+ and linksResults1 and linksResults2 and linksResults3
- if topo_result == main.TRUE:
+ if topoResult == 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" )
+ utilities.assertEquals( expect=main.TRUE, actual=topoResult,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
def CASE10( self ):
main.log.report(
@@ -422,11 +422,11 @@
main.log.report( "__________________________________" )
main.case( "Uninstalling reactive forwarding app" )
# Unistall onos-app-fwd app to disable reactive forwarding
- appUninstall_result1 = main.ONOScli1.feature_uninstall(
+ appUninstallResult1 = main.ONOScli1.featureUninstall(
"onos-app-fwd" )
- appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ appUninstallResult2 = main.ONOScli2.featureUninstall(
"onos-app-fwd" )
- appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ appUninstallResult3 = main.ONOScli3.featureUninstall(
"onos-app-fwd" )
main.log.info( "onos-app-fwd uninstalled" )
@@ -437,10 +437,10 @@
hosts = main.ONOScli1.hosts()
main.log.info( hosts )
- case10_result = appUninstall_result1 and appUninstall_result2 and appUninstall_result3
- utilities.assert_equals(
+ case10Result = appUninstallResult1 and appUninstallResult2 and appUninstallResult3
+ utilities.assertEquals(
expect=main.TRUE,
- actual=case10_result,
+ actual=case10Result,
onpass="Reactive forwarding app uninstallation successful",
onfail="Reactive forwarding app uninstallation failed" )
@@ -454,24 +454,24 @@
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 )
+ devicesIdList = main.ONOScli1.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 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" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+ hthIntentResult = main.ONOScli1.addHostIntent( "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
"""
for i in range( 8, 18 ):
main.log.info(
@@ -482,9 +482,9 @@
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 )
+ host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
+ host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
+ tmpResult = main.ONOScli1.addHostIntent( host1Id, host2Id )
flowHandle = main.ONOScli1.flows()
# print "flowHandle = ", flowHandle
@@ -492,7 +492,7 @@
count = 1
i = 8
- Ping_Result = main.TRUE
+ PingResult = main.TRUE
while i < 18:
main.log.info(
"\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
@@ -501,7 +501,7 @@
if ping == main.FALSE and count < 5:
count += 1
#i = 8
- Ping_Result = main.FALSE
+ PingResult = main.FALSE
main.log.report( "Ping between h" +
str( i ) +
" and h" +
@@ -519,7 +519,7 @@
10 ) +
"have failed" )
i = 19
- Ping_Result = main.FALSE
+ PingResult = main.FALSE
elif ping == main.TRUE:
main.log.info( "Ping test between h" +
str( i ) +
@@ -528,30 +528,30 @@
10 ) +
"passed!" )
i += 1
- Ping_Result = main.TRUE
+ PingResult = main.TRUE
else:
main.log.info( "Unknown error" )
- Ping_Result = main.ERROR
- if Ping_Result == main.FALSE:
+ PingResult = main.ERROR
+ if PingResult == main.FALSE:
main.log.report(
"Host intents have not ben installed correctly. Cleaning up" )
# main.cleanup()
# main.exit()
- if Ping_Result == main.TRUE:
+ if PingResult == main.TRUE:
main.log.report( "Host intents have been installed correctly" )
- case6_result = Ping_Result
- utilities.assert_equals(
+ case6Result = PingResult
+ utilities.assertEquals(
expect=main.TRUE,
- actual=case6_result,
+ actual=case6Result,
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' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
- link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+ linkSleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
main.log.report(
"This testscase is killing a link to ensure that link discovery is consistent" )
@@ -602,10 +602,10 @@
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' ]
+ topologyOutput = main.ONOScli1.topology()
+ topologyResult = main.ONOSbench.getTopology( topologyOutput )
+ activeSwitches = topologyResult[ 'devices' ]
+ links = topologyResult[ 'links' ]
print "activeSwitches = ", type( activeSwitches )
print "links = ", type( links )
main.log.info(
@@ -614,37 +614,37 @@
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(
+ time.sleep( linkSleep )
+ topologyOutput = main.ONOScli2.topology()
+ LinkDown = main.ONOSbench.checkStatus(
+ topologyOutput, activeSwitches, str(
int( links ) - 2 ) )
- if Link_Down == main.TRUE:
+ if LinkDown == main.TRUE:
main.log.report( "Link Down discovered properly" )
- utilities.assert_equals(
+ utilities.assertEquals(
expect=main.TRUE,
- actual=Link_Down,
+ actual=LinkDown,
onpass="Link Down discovered properly",
onfail="Link down was not discovered in " +
- str( link_sleep ) +
+ str( linkSleep ) +
" 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,
+ LinkUp = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
+ time.sleep( linkSleep )
+ topologyOutput = main.ONOScli2.topology()
+ LinkUp = main.ONOSbench.checkStatus(
+ topologyOutput,
activeSwitches,
str( links ) )
- if Link_Up == main.TRUE:
+ if LinkUp == main.TRUE:
main.log.report( "Link up discovered properly" )
- utilities.assert_equals(
+ utilities.assertEquals(
expect=main.TRUE,
- actual=Link_Up,
+ actual=LinkUp,
onpass="Link up discovered properly",
onfail="Link up was not discovered in " +
- str( link_sleep ) +
+ str( linkSleep ) +
" seconds" )
main.step( "Compare ONOS Topology to MN Topology" )
@@ -742,78 +742,78 @@
ctrls ) # can also add Intent API info for intent operations
MNTopo = Topo
- Topology_Check = main.TRUE
+ TopologyCheck = main.TRUE
main.step( "Compare ONOS Topology to MN Topology" )
- switches_results1 = main.Mininet1.compare_switches(
+ switchesResults1 = main.Mininet1.compareSwitches(
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" )
+ print "switches_Result1 = ", switchesResults1
+ utilities.assertEquals( expect=main.TRUE, actual=switchesResults1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
- switches_results2 = main.Mininet1.compare_switches(
+ switchesResults2 = main.Mininet1.compareSwitches(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=switchesResults2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
- switches_results3 = main.Mininet1.compare_switches(
+ switchesResults3 = main.Mininet1.compareSwitches(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=switchesResults3,
+ 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,
+ portsResults1 = main.Mininet1.comparePorts( MNTopo, json.loads( ports1 ) )
+ utilities.assertEquals( expect=main.TRUE, actual=portsResults1,
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,
+ portsResults2 = main.Mininet1.comparePorts( MNTopo, json.loads( ports2 ) )
+ utilities.assertEquals( expect=main.TRUE, actual=portsResults2,
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,
+ portsResults3 = main.Mininet1.comparePorts( MNTopo, json.loads( ports3 ) )
+ utilities.assertEquals( expect=main.TRUE, actual=portsResults3,
onpass="ONOS3 Ports view is correct",
onfail="ONOS3 Ports view is incorrect" )
"""
- links_results1 = main.Mininet1.compare_links(
+ linksResults1 = main.Mininet1.compareLinks(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=linksResults1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
- links_results2 = main.Mininet1.compare_links(
+ linksResults2 = main.Mininet1.compareLinks(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=linksResults2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
- links_results3 = main.Mininet1.compare_links(
+ linksResults3 = main.Mininet1.compareLinks(
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" )
+ utilities.assertEquals( expect=main.TRUE, actual=linksResults3,
+ 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
+ #topoResult = switchesResults1 and switchesResults2 and switchesResults3\
+ # and portsResults1 and portsResults2 and portsResults3\
+ # and linksResults1 and linksResults2 and linksResults3
- topo_result = switches_results1 and switches_results2 and switches_results3\
- and links_results1 and links_results2 and links_results3
+ topoResult = switchesResults1 and switchesResults2 and switchesResults3\
+ and linksResults1 and linksResults2 and linksResults3
- utilities.assert_equals(
+ utilities.assertEquals(
expect=main.TRUE,
- actual=topo_result and Link_Up and Link_Down,
+ actual=topoResult and LinkUp and LinkDown,
onpass="Topology Check Test successful",
onfail="Topology Check Test NOT successful" )
@@ -827,11 +827,11 @@
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 )
+ intentResult = main.ONOScli1.intents( jsonFormat=False )
- intent_linewise = intent_result.split( "\n" )
+ intentLinewise = intentResult.split( "\n" )
intentList = []
- for line in intent_linewise:
+ for line in intentLinewise:
if line.startswith( "id=" ):
intentList.append( line )
@@ -844,14 +844,14 @@
main.step(
"Iterate through the intentids list and remove each intent" )
for id in intentids:
- main.ONOScli1.remove_intent( intent_id=id )
+ main.ONOScli1.removeIntent( intentId=id )
- intent_result = main.ONOScli1.intents( json_format=False )
- main.log.info( "intent_result = " + intent_result )
- case8_result = main.TRUE
+ intentResult = main.ONOScli1.intents( jsonFormat=False )
+ main.log.info( "intent_result = " + intentResult )
+ case8Result = main.TRUE
i = 8
- Ping_Result = main.TRUE
+ PingResult = main.TRUE
while i < 18:
main.log.info(
"\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
@@ -859,33 +859,33 @@
src="h" + str( i ), target="h" + str( i + 10 ) )
if ping == main.TRUE:
i = 19
- Ping_Result = main.TRUE
+ PingResult = main.TRUE
elif ping == main.FALSE:
i += 1
- Ping_Result = main.FALSE
+ PingResult = main.FALSE
else:
main.log.info( "Unknown error" )
- Ping_Result = main.ERROR
+ PingResult = main.ERROR
# Note: If the ping result failed, that means the intents have been
# withdrawn correctly.
- if Ping_Result == main.TRUE:
+ if PingResult == main.TRUE:
main.log.report( "Host intents have not been withdrawn correctly" )
# main.cleanup()
# main.exit()
- if Ping_Result == main.FALSE:
+ if PingResult == main.FALSE:
main.log.report( "Host intents have been withdrawn correctly" )
- case8_result = case8_result and Ping_Result
+ case8Result = case8Result and PingResult
- if case8_result == main.FALSE:
+ if case8Result == 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" )
+ utilities.assertEquals( expect=main.FALSE, actual=case8Result,
+ onpass="Intent removal test failed",
+ onfail="Intent removal test successful" )
def CASE9( self ):
"""
@@ -900,183 +900,183 @@
"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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003008/1",
"of:0000000000006018/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006018/1",
"of:0000000000003008/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003009/1",
"of:0000000000006019/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006019/1",
"of:0000000000003009/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003010/1",
"of:0000000000006020/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006020/1",
"of:0000000000003010/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003011/1",
"of:0000000000006021/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006021/1",
"of:0000000000003011/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003012/1",
"of:0000000000006022/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006022/1",
"of:0000000000003012/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003013/1",
"of:0000000000006023/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006023/1",
"of:0000000000003013/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003014/1",
"of:0000000000006024/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006024/1",
"of:0000000000003014/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003015/1",
"of:0000000000006025/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006025/1",
"of:0000000000003015/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003016/1",
"of:0000000000006026/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006026/1",
"of:0000000000003016/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
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(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000003017/1",
"of:0000000000006027/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
- ptp_intent_result = main.ONOScli1.add_point_intent(
+ ptpIntentResult = main.ONOScli1.addPointIntent(
"of:0000000000006027/1",
"of:0000000000003017/1" )
- if ptp_intent_result == main.TRUE:
- get_intent_result = main.ONOScli1.intents()
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents()
main.log.info( "Point to point intent install successful" )
- # main.log.info( get_intent_result )
+ # main.log.info( getIntentResult )
print(
"_______________________________________________________________________________________" )
@@ -1087,7 +1087,7 @@
count = 1
i = 8
- Ping_Result = main.TRUE
+ PingResult = main.TRUE
while i < 18:
main.log.info(
"\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
@@ -1096,7 +1096,7 @@
if ping == main.FALSE and count < 5:
count += 1
#i = 8
- Ping_Result = main.FALSE
+ PingResult = main.FALSE
main.log.report( "Ping between h" +
str( i ) +
" and h" +
@@ -1114,7 +1114,7 @@
10 ) +
"have failed" )
i = 19
- Ping_Result = main.FALSE
+ PingResult = main.FALSE
elif ping == main.TRUE:
main.log.info( "Ping test between h" +
str( i ) +
@@ -1123,23 +1123,23 @@
10 ) +
"passed!" )
i += 1
- Ping_Result = main.TRUE
+ PingResult = main.TRUE
else:
main.log.info( "Unknown error" )
- Ping_Result = main.ERROR
- if Ping_Result == main.FALSE:
+ PingResult = main.ERROR
+ if PingResult == main.FALSE:
main.log.report(
"Ping all test after Point intents addition failed. Cleaning up" )
# main.cleanup()
# main.exit()
- if Ping_Result == main.TRUE:
+ if PingResult == main.TRUE:
main.log.report(
"Ping all test after Point intents addition successful" )
- case8_result = Ping_Result
- utilities.assert_equals(
+ case8Result = PingResult
+ utilities.assertEquals(
expect=main.TRUE,
- actual=case8_result,
+ actual=case8Result,
onpass="Ping all test after Point intents addition successful",
onfail="Ping all test after Point intents addition failed" )
@@ -1158,7 +1158,7 @@
# --ethType=IPV4 --ipProto=1 of:0000000000003008/1
# of:0000000000006018/1
- hosts_json = json.loads( main.ONOScli1.hosts() )
+ hostsJson = 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 ) )
@@ -1166,55 +1166,55 @@
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:
+ host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
+ host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
+ for host in hostsJson:
+ if host[ 'id' ] == host1Id:
ip1 = host[ 'ips' ][ 0 ]
ip1 = str( ip1 + "/32" )
device1 = host[ 'location' ][ 'device' ]
device1 = str( device1 + "/1" )
- elif host[ 'id' ] == host2_id:
+ elif host[ 'id' ] == host2Id:
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,
+ pIntentResult1 = main.ONOScli1.addPointIntent(
+ ingressDevice=device1,
+ egressDevice=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 )
+ getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+ main.log.info( getIntentResult )
- p_intent_result2 = main.ONOScli1.add_point_intent(
- ingress_device=device2,
- egress_device=device1,
+ pIntentResult2 = main.ONOScli1.addPointIntent(
+ ingressDevice=device2,
+ egressDevice=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 )
+ getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+ main.log.info( getIntentResult )
+ if ( pIntentResult1 and pIntentResult2 ) == main.TRUE:
+ #getIntentResult = main.ONOScli1.intents()
+ # main.log.info( getIntentResult )
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 )
+ getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+ main.log.info( "intents = " + getIntentResult )
+ getFlowsResult = main.ONOScli1.flows()
+ main.log.info( "flows = " + getFlowsResult )
count = 1
i = 8
- Ping_Result = main.TRUE
+ PingResult = main.TRUE
while i < 11:
main.log.info(
"\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
@@ -1223,7 +1223,7 @@
if ping == main.FALSE and count < 3:
count += 1
#i = 8
- Ping_Result = main.FALSE
+ PingResult = main.FALSE
main.log.report( "Ping between h" +
str( i ) +
" and h" +
@@ -1241,7 +1241,7 @@
10 ) +
"have failed" )
i = 19
- Ping_Result = main.FALSE
+ PingResult = main.FALSE
elif ping == main.TRUE:
main.log.info( "Ping test between h" +
str( i ) +
@@ -1250,23 +1250,23 @@
10 ) +
"passed!" )
i += 1
- Ping_Result = main.TRUE
+ PingResult = main.TRUE
else:
main.log.info( "Unknown error" )
- Ping_Result = main.ERROR
- if Ping_Result == main.FALSE:
+ PingResult = main.ERROR
+ if PingResult == 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:
+ if PingResult == 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(
+ case31Result = PingResult and pIntentResult1 and pIntentResult2
+ utilities.assertEquals(
expect=main.TRUE,
- actual=case31_result,
+ actual=case31Result,
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" )
@@ -1292,7 +1292,7 @@
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() )
+ hostsJson = 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 ) )
@@ -1300,70 +1300,70 @@
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:
+ host1Id = main.ONOScli1.getHost( host1 )[ 'id' ]
+ host2Id = main.ONOScli1.getHost( host2 )[ 'id' ]
+ for host in hostsJson:
+ if host[ 'id' ] == host1Id:
ip1 = host[ 'ips' ][ 0 ]
ip1 = str( ip1 + "/32" )
device1 = host[ 'location' ][ 'device' ]
device1 = str( device1 + "/1" )
- elif host[ 'id' ] == host2_id:
+ elif host[ 'id' ] == host2Id:
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,
+ pIntentResult1 = main.ONOScli1.addPointIntent(
+ ingressDevice=device1,
+ egressDevice=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,
+ pIntentResult2 = main.ONOScli1.addPointIntent(
+ ingressDevice=device2,
+ egressDevice=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,
+ pIntentResult3 = main.ONOScli1.addPointIntent(
+ ingressDevice=device1,
+ egressDevice=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,
+ pIntentResult4 = main.ONOScli1.addPointIntent(
+ ingressDevice=device2,
+ egressDevice=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 )
+ pIntentResult = pIntentResult1 and pIntentResult2 and pIntentResult3 and pIntentResult4
+ if pIntentResult == main.TRUE:
+ getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+ main.log.info( getIntentResult )
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:
+ iperfResult = main.Mininet1.iperf( 'h8', 'h18' )
+ if iperfResult == 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(
+ case32Result = pIntentResult and iperfResult
+ utilities.assertEquals(
expect=main.TRUE,
- actual=case32_result,
+ actual=case32Result,
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" )
@@ -1389,11 +1389,11 @@
"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(
+ appUninstallResult1 = main.ONOScli1.featureUninstall(
"onos-app-proxyarp" )
- appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ appUninstallResult2 = main.ONOScli2.featureUninstall(
"onos-app-proxyarp" )
- appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ appUninstallResult3 = main.ONOScli3.featureUninstall(
"onos-app-proxyarp" )
main.log.info( "onos-app-proxyarp uninstalled" )
@@ -1440,37 +1440,37 @@
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' ],
+ pIntentResult1 = main.ONOScli1.addMultipointToSinglepointIntent(
+ ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+ ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egressDevice=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' ],
+ pIntentResult2 = main.ONOScli1.addMultipointToSinglepointIntent(
+ ingressDevice1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+ ingressDevice2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egressDevice=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 )
+ getIntentResult = main.ONOScli1.intents( jsonFormat=False )
+ main.log.info( "intents = " + getIntentResult )
time.sleep( 10 )
- get_flows_result = main.ONOScli1.flows( json_format=False )
- main.log.info( "flows = " + get_flows_result )
+ getFlowsResult = main.ONOScli1.flows( jsonFormat=False )
+ main.log.info( "flows = " + getFlowsResult )
count = 1
i = 8
- Ping_Result = main.TRUE
+ PingResult = 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
+ PingResult = main.FALSE
main.log.report( "Ping between h" +
str( i ) +
" and h" +
@@ -1487,7 +1487,7 @@
str( i +
10 ) +
"have failed" )
- Ping_Result = main.FALSE
+ PingResult = main.FALSE
elif ping == main.TRUE:
main.log.info( "Ping test between h" +
str( i ) +
@@ -1495,29 +1495,29 @@
str( i +
2 ) +
"passed!" )
- Ping_Result = main.TRUE
+ PingResult = main.TRUE
else:
main.log.info( "Unknown error" )
- Ping_Result = main.ERROR
+ PingResult = main.ERROR
- if Ping_Result == main.FALSE:
+ if PingResult == main.FALSE:
main.log.report( "Ping test failed." )
# main.cleanup()
# main.exit()
- if Ping_Result == main.TRUE:
+ if PingResult == main.TRUE:
main.log.report( "Ping all successful" )
- p_intent_result = p_intent_result1 and p_intent_result2
- if p_intent_result == main.TRUE:
+ pIntentResult = pIntentResult1 and pIntentResult2
+ if pIntentResult == main.TRUE:
main.log.info(
"Multi point intent with rewrite mac address installation successful" )
else:
main.log.info(
"Multi point intent with rewrite mac address installation failed" )
- case33_result = p_intent_result and Ping_Result
- utilities.assert_equals(
+ case33Result = pIntentResult and PingResult
+ utilities.assertEquals(
expect=main.TRUE,
- actual=case33_result,
+ actual=case33Result,
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/TopoPerfNext/Backup/TopoPerfNext.py b/TestON/tests/TopoPerfNext/Backup/TopoPerfNext.py
new file mode 100644
index 0000000..cc40b94
--- /dev/null
+++ b/TestON/tests/TopoPerfNext/Backup/TopoPerfNext.py
@@ -0,0 +1,1710 @@
+#TopoPerfNext
+#
+#Topology Performance test for ONOS-next
+#
+#andrew@onlab.us
+#
+#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):
+ self.default = ''
+
+ 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
+ ##
+
+ cell_name = main.params['ENV']['cellName']
+
+ git_pull = main.params['GIT']['autoPull']
+ checkout_branch = main.params['GIT']['checkout']
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
+ #### 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"
+ #### ####
+
+ MN1_ip = main.params['MN']['ip1']
+ BENCH_ip = main.params['BENCH']['ip']
+
+ 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.log.report("Setting up test environment")
+
+ 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("Creating cell file")
+ cell_file_result = main.ONOSbench.create_cell_file(
+ BENCH_ip, cell_name, MN1_ip, "onos-core,onos-app-metrics",
+ 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
+ # 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("Git checkout and pull "+checkout_branch)
+ if git_pull == 'on':
+ checkout_result = \
+ main.ONOSbench.git_checkout(checkout_branch)
+ pull_result = main.ONOSbench.git_pull()
+ else:
+ checkout_result = main.TRUE
+ pull_result = main.TRUE
+ main.log.info("Skipped git checkout and pull")
+
+ main.log.report("Commit information - ")
+ main.ONOSbench.get_version(report=True)
+
+ main.step("Using mvn clean & install")
+ mvn_result = main.ONOSbench.clean_install()
+ mvn_result = 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("Creating ONOS package")
+ package_result = main.ONOSbench.onos_package()
+
+ 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)
+
+ 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)
+
+ 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")
+
+ def CASE2(self, main):
+ '''
+ Assign s1 to ONOS1 and measure latency
+
+ There are 4 levels of latency measurements to this test:
+ 1) End-to-end measurement: Complete end-to-end measurement
+ from TCP (SYN/ACK) handshake to Graph change
+ 2) OFP-to-graph measurement: 'ONOS processing' snippet of
+ measurement from OFP Vendor message to Graph change
+ 3) OFP-to-device measurement: 'ONOS processing without
+ graph change' snippet of measurement from OFP vendor
+ message to Device change timestamp
+ 4) T0-to-device measurement: Measurement that includes
+ the switch handshake to devices timestamp without
+ the graph view change. (TCP handshake -> Device
+ change)
+ '''
+ import time
+ import subprocess
+ import json
+ import requests
+ import os
+ import numpy
+ global cluster_count
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+ ONOS4_ip = main.params['CTRL']['ip4']
+ ONOS5_ip = main.params['CTRL']['ip5']
+ ONOS6_ip = main.params['CTRL']['ip6']
+ ONOS7_ip = main.params['CTRL']['ip7']
+
+ ONOS_user = 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'])
+
+ #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']
+ onos_log = main.params['TEST']['onosLogFile']
+
+ #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])
+
+ #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 = []
+
+ #Directory/file to store tshark results
+ tshark_of_output = "/tmp/tshark_of_topo.txt"
+ tshark_tcp_output = "/tmp/tshark_tcp_topo.txt"
+
+ #String to grep in tshark output
+ tshark_tcp_string = "TCP 74 "+default_sw_port
+ tshark_of_string = "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")
+
+ 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))
+
+ for i in range(0, int(num_iter)):
+ main.log.info("Starting tshark capture")
+
+ #* TCP [ACK, SYN] is used as t0_a, the
+ # very first "exchange" between ONOS and
+ # the switch for end-to-end measurement
+ #* OFP [Stats Reply] is used for t0_b
+ # 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)
+
+ #Wait and ensure tshark is started and
+ #capturing
+ time.sleep(10)
+
+ main.log.info("Assigning s1 to controller")
+
+ main.Mininet1.assign_sw_controller(sw="1",
+ ip1=ONOS1_ip, port1=default_sw_port)
+
+ #Wait and ensure switch is assigned
+ #before stopping tshark
+ time.sleep(30)
+
+ main.log.info("Stopping all Tshark processes")
+ main.ONOS1.stop_tshark()
+
+ #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("Object read in from TCP capture: "+
+ str(temp_text))
+ if len(temp_text) > 1:
+ t0_tcp = float(temp_text[1])*1000.0
+ else:
+ main.log.error("Tshark output file for TCP"+
+ " returned unexpected results")
+ t0_tcp = 0
+ assertion = main.FALSE
+
+ tcp_file.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
+ while True:
+ temp_text = of_file.readline()
+ if temp_text !='':
+ line_ofp = temp_text
+ 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
+ else:
+ main.log.error("Tshark output file for OFP"+
+ " returned unexpected results")
+ t0_ofp = 0
+ assertion = main.FALSE
+
+ of_file.close()
+ #****************
+
+ 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)
+ json_obj_2 = json.loads(json_str_2)
+ json_obj_3 = json.loads(json_str_3)
+ #Initialize scale-out variables
+ json_obj_4 = ""
+ json_obj_5 = ""
+ json_obj_6 = ""
+ json_obj_7 = ""
+
+ #Include scale-out measurements when applicable
+ 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)
+ elif cluster_count == 6:
+ main.log.info("TODO: create even number cluster events")
+ elif 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)
+
+ #Obtain graph timestamp. This timestsamp captures
+ #the epoch time at which the topology graph was updated.
+ graph_timestamp_1 = \
+ json_obj_1[graphTimestamp]['value']
+ graph_timestamp_2 = \
+ json_obj_2[graphTimestamp]['value']
+ graph_timestamp_3 = \
+ json_obj_3[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']
+ device_timestamp_2 = \
+ json_obj_2[deviceTimestamp]['value']
+ device_timestamp_3 = \
+ json_obj_3[deviceTimestamp]['value']
+
+ #t0 to device processing latency
+ delta_device_1 = int(device_timestamp_1) - int(t0_tcp)
+ delta_device_2 = int(device_timestamp_2) - int(t0_tcp)
+ delta_device_3 = int(device_timestamp_3) - int(t0_tcp)
+
+ #Get average of delta from all instances
+ avg_delta_device = \
+ (int(delta_device_1)+\
+ int(delta_device_2)+\
+ int(delta_device_3)) / 3
+
+ #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.")
+
+ #t0 to graph processing latency (end-to-end)
+ delta_graph_1 = int(graph_timestamp_1) - int(t0_tcp)
+ delta_graph_2 = int(graph_timestamp_2) - int(t0_tcp)
+ delta_graph_3 = int(graph_timestamp_3) - int(t0_tcp)
+
+ #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)) / 3
+
+ #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")
+
+ #ofp to graph processing latency (ONOS processing)
+ delta_ofp_graph_1 = int(graph_timestamp_1) - int(t0_ofp)
+ delta_ofp_graph_2 = int(graph_timestamp_2) - int(t0_ofp)
+ delta_ofp_graph_3 = int(graph_timestamp_3) - int(t0_ofp)
+
+ avg_delta_ofp_graph = \
+ (int(delta_ofp_graph_1)+\
+ int(delta_ofp_graph_2)+\
+ int(delta_ofp_graph_3)) / 3
+
+ 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")
+
+ #ofp to device processing latency (ONOS processing)
+ delta_ofp_device_1 = float(device_timestamp_1) - float(t0_ofp)
+ delta_ofp_device_2 = float(device_timestamp_2) - float(t0_ofp)
+ delta_ofp_device_3 = float(device_timestamp_3) - float(t0_ofp)
+
+ avg_delta_ofp_device = \
+ (float(delta_ofp_device_1)+\
+ float(delta_ofp_device_2)+\
+ float(delta_ofp_device_3)) / 3
+
+ #NOTE: ofp - delta measurements are occasionally negative
+ # due to system time misalignment.
+ latency_ofp_to_device_list.append(avg_delta_ofp_device)
+
+ 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")
+
+ #TODO:
+ #Fetch logs upon threshold excess
+
+ main.log.info("ONOS1 delta end-to-end: "+
+ str(delta_graph_1) + " ms")
+ main.log.info("ONOS2 delta end-to-end: "+
+ str(delta_graph_2) + " ms")
+ main.log.info("ONOS3 delta end-to-end: "+
+ str(delta_graph_3) + " ms")
+
+ main.log.info("ONOS1 delta OFP - graph: "+
+ str(delta_ofp_graph_1) + " ms")
+ main.log.info("ONOS2 delta OFP - graph: "+
+ str(delta_ofp_graph_2) + " ms")
+ main.log.info("ONOS3 delta OFP - graph: "+
+ str(delta_ofp_graph_3) + " ms")
+
+ main.log.info("ONOS1 delta device - t0: "+
+ str(delta_device_1) + " ms")
+ main.log.info("ONOS2 delta device - t0: "+
+ str(delta_device_2) + " ms")
+ main.log.info("ONOS3 delta device - t0: "+
+ str(delta_device_3) + " ms")
+
+ main.log.info("TCP to OFP delta: "+
+ str(delta_ofp_tcp) + " ms")
+ #main.log.info("ONOS1 delta OFP - device: "+
+ # str(delta_ofp_device_1) + " ms")
+ #main.log.info("ONOS2 delta OFP - device: "+
+ # str(delta_ofp_device_2) + " ms")
+ #main.log.info("ONOS3 delta OFP - device: "+
+ # str(delta_ofp_device_3) + " ms")
+
+ main.step("Remove switch from controller")
+ main.Mininet1.delete_sw_controller("s1")
+
+ time.sleep(5)
+
+ #END of for loop iteration
+
+ #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
+
+ #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))
+
+ 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))
+
+ 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))
+
+ 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("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):
+ '''
+ Bring port up / down and measure latency.
+ Port enable / disable is simulated by ifconfig up / down
+
+ In ONOS-next, we must ensure that the port we are
+ manipulating is connected to another switch with a valid
+ connection. Otherwise, graph view will not be updated.
+ '''
+ import time
+ import subprocess
+ import os
+ import requests
+ import json
+ import numpy
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+ ONOS_user = main.params['CTRL']['user']
+
+ default_sw_port = 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']
+
+ 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)
+
+ #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(",")
+
+ up_threshold_min = int(up_threshold_obj[0])
+ up_threshold_max = int(up_threshold_obj[1])
+
+ down_threshold_min = int(down_threshold_obj[0])
+ down_threshold_max = int(down_threshold_obj[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"
+
+ 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))
+
+ 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)
+
+ #Give enough time for metrics to propagate the
+ #assign controller event. Otherwise, these events may
+ #carry over to our measurements
+ time.sleep(15)
+
+ port_up_device_to_ofp_list = []
+ port_up_graph_to_ofp_list = []
+ port_down_device_to_ofp_list = []
+ port_down_graph_to_ofp_list = []
+
+ 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)
+
+ #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>")
+
+ time.sleep(3)
+ main.ONOS1.tshark_stop()
+
+ main.step("Obtain t1 by metrics call")
+ json_str_up_1 = main.ONOS1cli.topology_events_metrics()
+ json_str_up_2 = main.ONOS2cli.topology_events_metrics()
+ json_str_up_3 = main.ONOS3cli.topology_events_metrics()
+
+ json_obj_1 = json.loads(json_str_up_1)
+ json_obj_2 = json.loads(json_str_up_2)
+ json_obj_3 = json.loads(json_str_up_3)
+
+ #Copy tshark output file from ONOS to TestON instance
+ #/tmp directory
+ os.system("scp "+ONOS_user+"@"+ONOS1_ip+":"+
+ tshark_port_down+" /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:
+ timestamp_begin_pt_down = int(float(obj_down[1])*1000)
+ main.log.info("Port down begin timestamp: "+
+ str(timestamp_begin_pt_down))
+ 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("TEST tshark obj: "+str(obj_down))
+
+ time.sleep(3)
+
+ #Obtain graph timestamp. This timestsamp captures
+ #the epoch time at which the topology graph was updated.
+ graph_timestamp_1 = \
+ json_obj_1[graphTimestamp]['value']
+ graph_timestamp_2 = \
+ json_obj_2[graphTimestamp]['value']
+ graph_timestamp_3 = \
+ json_obj_3[graphTimestamp]['value']
+
+ main.log.info("TEST graph timestamp ONOS1: "+
+ str(graph_timestamp_1))
+
+ #Obtain device timestamp. This timestamp captures
+ #the epoch time at which the device event happened
+ device_timestamp_1 = \
+ json_obj_1[deviceTimestamp]['value']
+ device_timestamp_2 = \
+ json_obj_2[deviceTimestamp]['value']
+ device_timestamp_3 = \
+ json_obj_3[deviceTimestamp]['value']
+
+ #Get delta between graph event and OFP
+ pt_down_graph_to_ofp_1 = int(graph_timestamp_1) -\
+ int(timestamp_begin_pt_down)
+ 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)
+
+ #Get delta between device event and OFP
+ pt_down_device_to_ofp_1 = int(device_timestamp_1) -\
+ 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)
+
+ #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)) / 3
+ 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)) / 3
+
+ 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>")
+
+ #Allow time for tshark to capture event
+ time.sleep(3)
+ main.ONOS1.tshark_stop()
+
+ #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_str_up_2 = main.ONOS2cli.topology_events_metrics()
+ json_str_up_3 = main.ONOS3cli.topology_events_metrics()
+
+ json_obj_1 = json.loads(json_str_up_1)
+ json_obj_2 = json.loads(json_str_up_2)
+ json_obj_3 = json.loads(json_str_up_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)
+ 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()
+
+ graph_timestamp_1 = \
+ json_obj_1[graphTimestamp]['value']
+ graph_timestamp_2 = \
+ json_obj_2[graphTimestamp]['value']
+ graph_timestamp_3 = \
+ json_obj_3[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']
+ device_timestamp_2 = \
+ json_obj_2[deviceTimestamp]['value']
+ device_timestamp_3 = \
+ json_obj_3[deviceTimestamp]['value']
+
+ #Get delta between graph event and OFP
+ pt_up_graph_to_ofp_1 = int(graph_timestamp_1) -\
+ int(timestamp_begin_pt_up)
+ 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)
+
+ #Get delta between device event and OFP
+ pt_up_device_to_ofp_1 = int(device_timestamp_1) -\
+ 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)
+
+ main.log.info("ONOS1 delta G2O: "+str(pt_up_graph_to_ofp_1))
+ main.log.info("ONOS2 delta G2O: "+str(pt_up_graph_to_ofp_2))
+ main.log.info("ONOS3 delta G2O: "+str(pt_up_graph_to_ofp_3))
+
+ main.log.info("ONOS1 delta D2O: "+str(pt_up_device_to_ofp_1))
+ main.log.info("ONOS2 delta D2O: "+str(pt_up_device_to_ofp_2))
+ main.log.info("ONOS3 delta D2O: "+str(pt_up_device_to_ofp_3))
+
+ 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)) / 3
+
+ 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)) / 3
+
+ 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 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))
+
+ #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
+
+ #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")
+
+ 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
+ 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']
+
+ 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']
+
+ 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)
+
+ #Threshold for this test case
+ up_threshold_str = main.params['TEST']['linkUpThreshold']
+ down_threshold_str = main.params['TEST']['linkDownThreshold']
+
+ up_threshold_obj = up_threshold_str.split(",")
+ down_threshold_obj = down_threshold_str.split(",")
+
+ up_threshold_min = int(up_threshold_obj[0])
+ up_threshold_max = int(up_threshold_obj[1])
+
+ down_threshold_min = int(down_threshold_obj[0])
+ down_threshold_max = int(down_threshold_obj[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 = []
+
+ 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.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("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)
+
+ 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
+ main.Mininet1.handle.sendline(
+ "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)
+ # 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 ")
+ 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
+
+ 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)
+
+ 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']
+
+ 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']
+
+ 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)
+ 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
+
+ #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")
+
+ #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 ")
+ 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
+
+ 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)
+
+ 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']
+
+ 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']
+
+ 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)
+ 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
+
+ #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)
+ 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)
+ else:
+ 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))
+
+ 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")
+
+ utilities.assert_equals(expect=main.TRUE, actual=assertion,
+ onpass="Link discovery latency calculation successful",
+ onfail="Link discovery latency case failed")
+
+ def CASE5(self, main):
+ '''
+ 100 Switch discovery latency
+
+ Important:
+ 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
+ params file to adjust the switch discovery size
+ (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']
+
+ default_sw_port = main.params['CTRL']['port1']
+
+ #Number of iterations of case
+ num_iter = main.params['TEST']['numIter']
+ num_sw = main.params['TEST']['numSwitch']
+
+ #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']
+
+ 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])
+
+ tshark_ofp_output = "/tmp/tshark_ofp_"+num_sw+"sw.txt"
+ tshark_tcp_output = "/tmp/tshark_tcp_"+num_sw+"sw.txt"
+
+ tshark_ofp_result_list = []
+ tshark_tcp_result_list = []
+
+ sw_discovery_lat_list = []
+
+ 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)
+
+ 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:
+ # Append to INPUT rule,
+ # behavior DROP that matches following:
+ # * packet type: tcp
+ # * source IP: MN1_ip
+ # * 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,
+ # behavior DROP that matches following:
+ # * packet type: tcp
+ # * source IP: MN1_ip
+ # * 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
+ # 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)
+
+ #NOTE: Remove all iptables rule quickly (flush)
+ # Before removal, obtain TestON timestamp at which
+ # removal took place
+ # (ensuring nodes are configured via ptp)
+ # sudo iptables -F
+
+ t0_system = time.time() * 1000
+ main.ONOS1.handle.sendline(
+ "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()
+
+ 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")
+ 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")
+ 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")
+ else:
+ counter_avail3 = 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)
+
+ 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/")
+
+ #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()
+
+ 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()
+
+ 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)
+
+ graph_timestamp_1 = \
+ json_obj_1[graphTimestamp]['value']
+ graph_timestamp_2 = \
+ json_obj_2[graphTimestamp]['value']
+ graph_timestamp_3 = \
+ json_obj_3[graphTimestamp]['value']
+
+ 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)
+
+ 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)
+ else:
+ main.log.info("100 Switch discovery latency "+
+ "exceeded the threshold.")
+
+ #END ITERATION FOR LOOP
+
+ 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)
+
+ 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")
+
+ 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
+
+ main.log.report("Increasing cluster size to "+
+ str(cluster_count))
+
+ install_result = main.FALSE
+ if cluster_count == 5:
+ main.log.info("Installing nodes 4 and 5")
+ node4_result = \
+ main.ONOSbench.onos_install(node=ONOS4_ip)
+ node5_result = \
+ main.ONOSbench.onos_install(node=ONOS5_ip)
+ install_result = node4_result and node5_result
+
+ time.sleep(5)
+
+ main.ONOS4cli.start_onos_cli(ONOS4_ip)
+ main.ONOS5cli.start_onos_cli(ONOS5_ip)
+
+ elif cluster_count == 7:
+ main.log.info("Installing nodes 4 and 5")
+ node6_result = \
+ main.ONOSbench.onos_install(node=ONOS6_ip)
+ node7_result = \
+ main.ONOSbench.onos_install(node=ONOS7_ip)
+ install_result = node6_result and node7_result
+
+ time.sleep(5)
+
+ main.ONOS6cli.start_onos_cli(ONOS6_ip)
+ main.ONOS7cli.start_onos_cli(ONOS7_ip)
+
+
+
+
diff --git a/TestON/tests/TopoPerfNext/TopoPerfNext.params b/TestON/tests/TopoPerfNext/TopoPerfNext.params
index 851522c..8e31e62 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.params
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.params
@@ -1,5 +1,5 @@
<PARAMS>
- <testcases>1,2,3</testcases>
+ <testcases>1,2,3,6,2,3,6,2,3,6,2,3</testcases>
<ENV>
<cellName>topo_perf_test</cellName>
@@ -19,6 +19,11 @@
<port2>6633</port2>
<ip3>10.128.174.3</ip3>
<port3>6633</port3>
+ <ip4>10.128.174.4</ip4>
+
+ <ip5>10.128.174.5</ip5>
+ <ip6>10.128.174.6</ip6>
+ <ip7>10.128.174.7</ip7>
</CTRL>
<MN>
@@ -46,7 +51,7 @@
</topo_config_name>
#Number of times to iterate each case
- <numIter>20</numIter>
+ <numIter>12</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 87d7378..b737f4c 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.py
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.py
@@ -1,39 +1,43 @@
-# 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
+ ##
- cell_name = main.params[ 'ENV' ][ 'cellName' ]
+ cell_name = main.params['ENV']['cellName']
- git_pull = main.params[ 'GIT' ][ 'autoPull' ]
- checkout_branch = main.params[ 'GIT' ][ 'checkout' ]
+ git_pull = main.params['GIT']['autoPull']
+ checkout_branch = main.params['GIT']['checkout']
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
- ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
- ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
-
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
#### Hardcoded ONOS nodes particular to my env ####
ONOS4_ip = "10.128.174.4"
ONOS5_ip = "10.128.174.5"
@@ -41,1507 +45,1694 @@
ONOS7_ip = "10.128.174.7"
#### ####
- MN1_ip = main.params[ 'MN' ][ 'ip1' ]
- BENCH_ip = main.params[ 'BENCH' ][ 'ip' ]
+ MN1_ip = main.params['MN']['ip1']
+ BENCH_ip = main.params['BENCH']['ip']
- topo_cfg_file = main.params[ 'TEST' ][ 'topo_config_file' ]
- topo_cfg_name = main.params[ 'TEST' ][ 'topo_config_name' ]
+ 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.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.log.report("Setting up test environment")
- main.log.report( "Setting up test environment" )
+ 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( "Cleaning previously installed ONOS if any" )
- 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( "Creating cell file" )
+ main.step("Creating cell file")
cell_file_result = main.ONOSbench.create_cell_file(
- BENCH_ip, cell_name, MN1_ip, "onos-core,onos-app-metrics",
- ONOS1_ip, ONOS2_ip, ONOS3_ip )
+ 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 )
+ 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.step("Removing raft/copy-cat logs from ONOS nodes")
main.ONOSbench.onos_remove_raft_logs()
- time.sleep( 30 )
+ time.sleep(30)
- main.step( "Git checkout and pull " + checkout_branch )
+ main.step("Git checkout and pull "+checkout_branch)
if git_pull == 'on':
- checkout_result = \
- main.ONOSbench.git_checkout( checkout_branch )
+ #checkout_result = \
+ # main.ONOSbench.git_checkout(checkout_branch)
+ checkout_result = main.TRUE
pull_result = main.ONOSbench.git_pull()
else:
checkout_result = main.TRUE
pull_result = main.TRUE
- main.log.info( "Skipped git checkout and pull" )
+ main.log.info("Skipped git checkout and pull")
- # TODO: Uncomment when wiki posting works
- #main.log.report( "Commit information - " )
- # main.ONOSbench.get_version( report=True )
+ main.log.report("Commit information - ")
+ main.ONOSbench.get_version(report=True)
- main.step( "Using mvn clean & install" )
- #mvn_result = main.ONOSbench.clean_install()
+ main.step("Using mvn clean & install")
+ mvn_result = main.ONOSbench.clean_install()
mvn_result = 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.set_cell(cell_name)
+ #main.ONOS2cli.set_cell(cell_name)
+ #main.ONOS3cli.set_cell(cell_name)
- main.step( "Creating ONOS package" )
+ main.step("Creating ONOS package")
package_result = main.ONOSbench.onos_package()
- 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")
+ 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)
- 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.start_onos_cli(ONOS1_ip)
+ #cli2 = main.ONOS2cli.start_onos_cli(ONOS2_ip)
+ #cli3 = main.ONOS3cli.start_onos_cli(ONOS3_ip)
- 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= 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")
- 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
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
- ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
- ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
- ONOS_user = main.params[ 'CTRL' ][ 'user' ]
+ 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']
- default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS_user = main.params['CTRL']['user']
- # 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' ] )
+ 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'])
- # 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' ]
+ #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' ]
- onos_log = main.params[ 'TEST' ][ 'onosLogFile' ]
+ debug_mode = main.params['TEST']['debugMode']
+ onos_log = main.params['TEST']['onosLogFile']
- # 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 ] )
+ #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])
- # List of switch add latency collected from
- # all iterations
+ #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 = []
- # Directory/file to store tshark results
+ #Directory/file to store tshark results
tshark_of_output = "/tmp/tshark_of_topo.txt"
tshark_tcp_output = "/tmp/tshark_tcp_topo.txt"
- # String to grep in tshark output
- tshark_tcp_string = "TCP 74 " + default_sw_port
+ #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 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( ":", "" )
+
+ 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.ONOS1.tshark_pcap("eth0",
+ "/tmp/single_sw_lat_pcap_"+local_time)
- main.log.info( "TEST" )
+ main.log.info("Debug mode is on")
- 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.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))
- for i in range( 0, int( num_iter ) ):
- main.log.info( "Starting tshark capture" )
+ for i in range(0, int(num_iter)):
+ main.log.info("Starting tshark capture")
- #* TCP [ ACK, SYN ] is used as t0_a, the
- # very first "exchange" between ONOS and
+ #* TCP [ACK, SYN] is used as t0_a, 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 t0_b
# 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.tshark_grep(tshark_tcp_string,
+ tshark_tcp_output)
+ main.ONOS1.tshark_grep(tshark_of_string,
+ tshark_of_output)
- # 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.assign_sw_controller(sw="1",
+ ip1=ONOS1_ip, port1=default_sw_port)
- # Wait and ensure switch is assigned
- # before stopping tshark
- time.sleep( 30 )
-
- main.log.info( "Stopping all Tshark processes" )
+ #Wait and ensure switch is assigned
+ #before stopping tshark
+ time.sleep(30)
+
+ main.log.info("Stopping all Tshark processes")
main.ONOS1.stop_tshark()
- # 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' )
+ #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( " " )
+ temp_text = temp_text.split(" ")
- 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
+ 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
else:
- main.log.error( "Tshark output file for TCP" +
- " returned unexpected results" )
+ main.log.error("Tshark output file for TCP"+
+ " returned unexpected results")
t0_tcp = 0
assertion = main.FALSE
-
+
tcp_file.close()
#****************
- # OF CAPTURE ****
- os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" +
- tshark_of_output + " /tmp/" )
- of_file = open( tshark_of_output, 'r' )
-
+ #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
+ #Read until last line of file
while True:
temp_text = of_file.readline()
- if temp_text != '':
+ if temp_text !='':
line_ofp = temp_text
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 = 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
else:
- main.log.error( "Tshark output file for OFP" +
- " returned unexpected results" )
+ main.log.error("Tshark output file for OFP"+
+ " returned unexpected results")
t0_ofp = 0
assertion = main.FALSE
-
+
of_file.close()
#****************
-
+
json_str_1 = main.ONOS1cli.topology_events_metrics()
- json_str_2 = main.ONOS2cli.topology_events_metrics()
- json_str_3 = main.ONOS3cli.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 )
- json_obj_2 = json.loads( json_str_2 )
- json_obj_3 = json.loads( json_str_3 )
-
- # Obtain graph timestamp. This timestsamp captures
- # the epoch time at which the topology graph was updated.
+ 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' ]
- graph_timestamp_2 = \
- json_obj_2[ graphTimestamp ][ 'value' ]
- graph_timestamp_3 = \
- json_obj_3[ graphTimestamp ][ 'value' ]
-
- # Obtain device timestamp. This timestamp captures
- # the epoch time at which the device event happened
+ 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' ]
- device_timestamp_2 = \
- json_obj_2[ deviceTimestamp ][ 'value' ]
- device_timestamp_3 = \
- json_obj_3[ deviceTimestamp ][ 'value' ]
+ 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)
- # t0 to device processing latency
- delta_device_1 = int( device_timestamp_1 ) - int( t0_tcp )
- delta_device_2 = int( device_timestamp_2 ) - int( t0_tcp )
- delta_device_3 = int( device_timestamp_3 ) - int( t0_tcp )
+ #TODO: Create even cluster number events
- # Get average of delta from all instances
+ #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)
+ 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
+
+ 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
+
+ #Get average of delta from all instances
avg_delta_device = \
- ( int( delta_device_1 ) +
- int( delta_device_2 ) +
- int( delta_device_3 ) ) / 3
+ (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
- # Ensure avg delta meets the threshold before appending
+ #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 )
+ 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." )
+ main.log.info("Results for t0-to-device ignored"+\
+ "due to excess in threshold / warmup iteration.")
- # t0 to graph processing latency ( end-to-end )
- delta_graph_1 = int( graph_timestamp_1 ) - int( t0_tcp )
- delta_graph_2 = int( graph_timestamp_2 ) - int( t0_tcp )
- delta_graph_3 = int( graph_timestamp_3 ) - int( t0_tcp )
-
- # Get average of delta from all instances
+ #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 ) ) / 3
+ (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
- # Ensure avg delta meets the threshold before appending
+ #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 )
+ 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" )
+ main.log.info("Results for end-to-end ignored"+\
+ "due to excess in threshold")
- # ofp to graph processing latency ( ONOS processing )
- delta_ofp_graph_1 = int( graph_timestamp_1 ) - int( t0_ofp )
- delta_ofp_graph_2 = int( graph_timestamp_2 ) - int( t0_ofp )
- delta_ofp_graph_3 = int( graph_timestamp_3 ) - int( t0_ofp )
-
+
avg_delta_ofp_graph = \
- ( int( delta_ofp_graph_1 ) +
- int( delta_ofp_graph_2 ) +
- int( delta_ofp_graph_3 ) ) / 3
-
+ (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 \
+ 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 )
+ 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" )
+ main.log.info("Results for ofp-to-graph "+\
+ "ignored due to excess in threshold")
- # ofp to device processing latency ( ONOS processing )
- delta_ofp_device_1 = float( device_timestamp_1 ) - float( t0_ofp )
- delta_ofp_device_2 = float( device_timestamp_2 ) - float( t0_ofp )
- delta_ofp_device_3 = float( device_timestamp_3 ) - float( t0_ofp )
-
+
avg_delta_ofp_device = \
- ( float( delta_ofp_device_1 ) +
- float( delta_ofp_device_2 ) +
- float( delta_ofp_device_3 ) ) / 3
-
- # NOTE: ofp - delta measurements are occasionally negative
+ (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 )
+ latency_ofp_to_device_list.append(avg_delta_ofp_device)
- delta_ofp_tcp = int( t0_ofp ) - int( t0_tcp )
+ 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 )
+ 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.log.info("Results fo tcp-to-ofp "+\
+ "ignored due to excess in threshold")
- # TODO:
- # Fetch logs upon threshold excess
+ #TODO:
+ #Fetch logs upon threshold excess
- main.log.info( "ONOS1 delta end-to-end: " +
- str( delta_graph_1 ) + " ms" )
- main.log.info( "ONOS2 delta end-to-end: " +
- str( delta_graph_2 ) + " ms" )
- main.log.info( "ONOS3 delta end-to-end: " +
- str( delta_graph_3 ) + " ms" )
+ main.log.info("ONOS1 delta end-to-end: "+
+ str(delta_graph_1) + " ms")
- main.log.info( "ONOS1 delta OFP - graph: " +
- str( delta_ofp_graph_1 ) + " ms" )
- main.log.info( "ONOS2 delta OFP - graph: " +
- str( delta_ofp_graph_2 ) + " ms" )
- main.log.info( "ONOS3 delta OFP - graph: " +
- str( delta_ofp_graph_3 ) + " ms" )
+ 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")
- main.log.info( "ONOS1 delta device - t0: " +
- str( delta_device_1 ) + " ms" )
- main.log.info( "ONOS2 delta device - t0: " +
- str( delta_device_2 ) + " ms" )
- main.log.info( "ONOS3 delta device - t0: " +
- str( delta_device_3 ) + " ms" )
+ main.step("Remove switch from controller")
+ main.Mininet1.delete_sw_controller("s1")
- main.log.info( "TCP to OFP delta: " +
- str( delta_ofp_tcp ) + " ms" )
- # main.log.info( "ONOS1 delta OFP - device: "+
- # str( delta_ofp_device_1 ) + " ms" )
- # main.log.info( "ONOS2 delta OFP - device: "+
- # str( delta_ofp_device_2 ) + " ms" )
- # main.log.info( "ONOS3 delta OFP - device: "+
- # str( delta_ofp_device_3 ) + " ms" )
+ time.sleep(5)
- main.step( "Remove switch from controller" )
- main.Mininet1.delete_sw_controller( "s1" )
+ #END of for loop iteration
- time.sleep( 5 )
-
- # END of for loop iteration
-
- # 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:
+ #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 )
+ 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 )
+ 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 )
+ 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 )
+ 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 )
+ elif len(latency_tcp_to_ofp_list) == 0:
+ latency_tcp_to_ofp_list.append(0)
assertion = main.FALSE
- # Calculate min, max, avg of latency lists
+ #Calculate min, max, avg of latency lists
latency_end_to_end_max = \
- int( max( latency_end_to_end_list ) )
+ int(max(latency_end_to_end_list))
latency_end_to_end_min = \
- int( min( latency_end_to_end_list ) )
+ 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 ) )
+ (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 ) )
+ str(round(numpy.std(latency_end_to_end_list),1))
latency_ofp_to_graph_max = \
- int( max( latency_ofp_to_graph_list ) )
+ int(max(latency_ofp_to_graph_list))
latency_ofp_to_graph_min = \
- int( min( latency_ofp_to_graph_list ) )
+ 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 ) )
+ (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 ) )
+ str(round(numpy.std(latency_ofp_to_graph_list),1))
latency_ofp_to_device_max = \
- int( max( latency_ofp_to_device_list ) )
+ int(max(latency_ofp_to_device_list))
latency_ofp_to_device_min = \
- int( min( latency_ofp_to_device_list ) )
+ 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 ) )
+ (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 ) )
+ str(round(numpy.std(latency_ofp_to_device_list),1))
latency_t0_to_device_max = \
- int( max( latency_t0_to_device_list ) )
+ int(max(latency_t0_to_device_list))
latency_t0_to_device_min = \
- int( min( latency_t0_to_device_list ) )
+ 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 ) )
+ (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 ) )
+ str(round(numpy.std(latency_t0_to_device_list),1))
latency_tcp_to_ofp_max = \
- int( max( latency_tcp_to_ofp_list ) )
+ int(max(latency_tcp_to_ofp_list))
latency_tcp_to_ofp_min = \
- int( min( latency_tcp_to_ofp_list ) )
+ 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 ) )
+ (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 ) )
+ str(round(numpy.std(latency_tcp_to_ofp_list),1))
- 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" )
+ 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" )
+ 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" )
+ 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
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
- ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
- ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
- ONOS_user = main.params[ 'CTRL' ][ 'user' ]
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+ ONOS_user = main.params['CTRL']['user']
- default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
-
+ default_sw_port = main.params['CTRL']['port1']
+
assertion = main.TRUE
- # Number of iterations of case
- num_iter = main.params[ 'TEST' ][ 'numIter' ]
+ #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']
- # 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' ]
-
- local_time = time.strftime( '%x %X' )
- local_time = local_time.replace( "/", "" )
- local_time = local_time.replace( " ", "_" )
- local_time = local_time.replace( ":", "" )
+ 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 )
+ main.ONOS1.tshark_pcap("eth0",
+ "/tmp/port_lat_pcap_"+local_time)
- # Threshold for this test case
- up_threshold_str = main.params[ 'TEST' ][ 'portUpThreshold' ]
- down_threshold_str = main.params[ 'TEST' ][ 'portDownThreshold' ]
+ #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(",")
- up_threshold_obj = up_threshold_str.split( "," )
- down_threshold_obj = down_threshold_str.split( "," )
+ up_threshold_min = int(up_threshold_obj[0])
+ up_threshold_max = int(up_threshold_obj[1])
- up_threshold_min = int( up_threshold_obj[ 0 ] )
- up_threshold_max = int( up_threshold_obj[ 1 ] )
+ down_threshold_min = int(down_threshold_obj[0])
+ down_threshold_max = int(down_threshold_obj[1])
- down_threshold_min = int( down_threshold_obj[ 0 ] )
- down_threshold_max = int( down_threshold_obj[ 1 ] )
-
- # NOTE: Some hardcoded variables you may need to configure
+ #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"
- 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 ) )
+ 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))
- 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.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)
- # Give enough time for metrics to propagate the
- # assign controller event. Otherwise, these events may
- # carry over to our measurements
- time.sleep( 15 )
+ #Give enough time for metrics to propagate the
+ #assign controller event. Otherwise, these events may
+ #carry over to our measurements
+ time.sleep(15)
port_up_device_to_ofp_list = []
port_up_graph_to_ofp_list = []
port_down_device_to_ofp_list = []
port_down_graph_to_ofp_list = []
- 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 )
+ 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)
- time.sleep( 5 )
+ #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>")
- # 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>" )
-
- time.sleep( 3 )
+ time.sleep(3)
main.ONOS1.tshark_stop()
-
- main.step( "Obtain t1 by metrics call" )
- json_str_up_1 = main.ONOS1cli.topology_events_metrics()
- json_str_up_2 = main.ONOS2cli.topology_events_metrics()
- json_str_up_3 = main.ONOS3cli.topology_events_metrics()
-
- json_obj_1 = json.loads( json_str_up_1 )
- json_obj_2 = json.loads( json_str_up_2 )
- json_obj_3 = json.loads( json_str_up_3 )
-
- # Copy tshark output file from ONOS to TestON instance
+
+ #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 "+ONOS_user+"@"+ONOS1_ip+":"+
+ tshark_port_down+" /tmp/")
- f_port_down = open( tshark_port_down, 'r' )
- # Get first line of port down event from tshark
+ 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:
- timestamp_begin_pt_down = int( float( obj_down[ 1 ] ) * 1000 )
- main.log.info( "Port down begin timestamp: " +
- str( timestamp_begin_pt_down ) )
+ 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
+ # itself by printing it out
+ timestamp_begin_pt_down = int(float(obj_down[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
+ # 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)
+
+ main.log.info("Port down begin timestamp: "+
+ str(timestamp_begin_pt_down))
else:
- main.log.info( "Tshark output file returned unexpected" +
- " results: " + str( obj_down ) )
+ main.log.info("Tshark output file returned unexpected"+
+ " results: "+str(obj_down))
timestamp_begin_pt_down = 0
-
f_port_down.close()
-
- main.log.info( "TEST tshark obj: " + str( obj_down ) )
-
- time.sleep( 3 )
-
- # Obtain graph timestamp. This timestsamp captures
- # the epoch time at which the topology graph was updated.
+
+ 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' ]
- graph_timestamp_2 = \
- json_obj_2[ graphTimestamp ][ 'value' ]
- graph_timestamp_3 = \
- json_obj_3[ graphTimestamp ][ 'value' ]
-
- main.log.info( "TEST graph timestamp ONOS1: " +
- str( graph_timestamp_1 ) )
-
- # Obtain device timestamp. This timestamp captures
- # the epoch time at which the device event happened
+ 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' ]
- device_timestamp_2 = \
- json_obj_2[ deviceTimestamp ][ 'value' ]
- device_timestamp_3 = \
- json_obj_3[ deviceTimestamp ][ 'value' ]
+ 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 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)
+ 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
- # Get delta between graph event and OFP
- pt_down_graph_to_ofp_1 = int( graph_timestamp_1 ) -\
- int( timestamp_begin_pt_down )
- 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 )
+ 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
- # Get delta between device event and OFP
- pt_down_device_to_ofp_1 = int( device_timestamp_1 ) -\
- 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 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
- # Caluclate average across clusters
+ 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 ) ) / 3
+ (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 ) ) / 3
+ (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" )
+ 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 ) )
+ 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" )
+ 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 ) )
+ 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 )
+ #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>" )
-
- # Allow time for tshark to capture event
- time.sleep( 3 )
+ main.Mininet1.handle.sendline("sh ifconfig "+
+ interface_config+" up")
+ main.Mininet1.handle.expect("mininet>")
+
+ #Allow time for tshark to capture event
+ time.sleep(5)
main.ONOS1.tshark_stop()
-
- # 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_str_up_2 = main.ONOS2cli.topology_events_metrics()
- json_str_up_3 = main.ONOS3cli.topology_events_metrics()
-
- json_obj_1 = json.loads( json_str_up_1 )
- json_obj_2 = json.loads( json_str_up_2 )
- json_obj_3 = json.loads( json_str_up_3 )
-
- os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" +
- tshark_port_up + " /tmp/" )
-
- f_port_up = open( tshark_port_up, 'r' )
+
+ 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 )
- main.log.info( "Port up begin timestamp: " +
- str( timestamp_begin_pt_up ) )
+ 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." )
+ 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' ]
- graph_timestamp_2 = \
- json_obj_2[ graphTimestamp ][ 'value' ]
- graph_timestamp_3 = \
- json_obj_3[ graphTimestamp ][ 'value' ]
-
- # Obtain device timestamp. This timestamp captures
- # the epoch time at which the device event happened
+ 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' ]
- device_timestamp_2 = \
- json_obj_2[ deviceTimestamp ][ 'value' ]
- device_timestamp_3 = \
- json_obj_3[ deviceTimestamp ][ 'value' ]
+ 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 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 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
- # Get delta between graph event and OFP
- pt_up_graph_to_ofp_1 = int( graph_timestamp_1 ) -\
- int( timestamp_begin_pt_up )
- 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 )
-
- # Get delta between device event and OFP
- pt_up_device_to_ofp_1 = int( device_timestamp_1 ) -\
- 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 )
-
- main.log.info( "ONOS1 delta G2O: " + str( pt_up_graph_to_ofp_1 ) )
- main.log.info( "ONOS2 delta G2O: " + str( pt_up_graph_to_ofp_2 ) )
- main.log.info( "ONOS3 delta G2O: " + str( pt_up_graph_to_ofp_3 ) )
-
- main.log.info( "ONOS1 delta D2O: " + str( pt_up_device_to_ofp_1 ) )
- main.log.info( "ONOS2 delta D2O: " + str( pt_up_device_to_ofp_2 ) )
- main.log.info( "ONOS3 delta D2O: " + str( pt_up_device_to_ofp_3 ) )
+ 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 ) ) / 3
+ (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 ) ) / 3
+ (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:
+ 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" )
+ 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 ) )
-
+ main.log.info("Average port up graph-to-ofp result"+
+ " exceeded the threshold: "+
+ str(pt_up_graph_to_ofp_avg))
+
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" )
+ 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 ) )
-
- # 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 ):
+ main.log.info("Average port up device-to-ofp result"+
+ " exceeded the threshold: "+
+ str(pt_up_device_to_ofp_avg))
+
+ #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
-
- # 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 )
+
+ 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 ) )
+ (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 )
+ 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 ) )
+ (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 )
+ 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 ) )
+ (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 )
+ 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 ) )
+ (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 ) )
+ 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")
- 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" )
+ #Remove switches from controller for next test
+ main.Mininet1.delete_sw_controller("s1")
+ main.Mininet1.delete_sw_controller("s2")
+
+ utilities.assert_equals(expect=main.TRUE, actual=assertion,
+ onpass="Port discovery latency calculation successful",
+ onfail="Port discovery test failed")
- utilities.assert_equals(
- expect=main.TRUE,
- actual=assertion,
- onpass="Port discovery latency calculation successful",
- onfail="Port discovery test failed" )
-
- def CASE4( self, main ):
- """
+ 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
+ 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']
- ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
- ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
- ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
- ONOS_user = main.params[ 'CTRL' ][ 'user' ]
+ 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']
- 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' ]
-
- local_time = time.strftime( '%x %X' )
- local_time = local_time.replace( "/", "" )
- local_time = local_time.replace( " ", "_" )
- local_time = local_time.replace( ":", "" )
+ 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 )
+ main.ONOS1.tshark_pcap("eth0",
+ "/tmp/link_lat_pcap_"+local_time)
- # Threshold for this test case
- up_threshold_str = main.params[ 'TEST' ][ 'linkUpThreshold' ]
- down_threshold_str = main.params[ 'TEST' ][ 'linkDownThreshold' ]
+ #Threshold for this test case
+ up_threshold_str = main.params['TEST']['linkUpThreshold']
+ down_threshold_str = main.params['TEST']['linkDownThreshold']
- up_threshold_obj = up_threshold_str.split( "," )
- down_threshold_obj = down_threshold_str.split( "," )
+ up_threshold_obj = up_threshold_str.split(",")
+ down_threshold_obj = down_threshold_str.split(",")
- up_threshold_min = int( up_threshold_obj[ 0 ] )
- up_threshold_max = int( up_threshold_obj[ 1 ] )
+ up_threshold_min = int(up_threshold_obj[0])
+ up_threshold_max = int(up_threshold_obj[1])
- down_threshold_min = int( down_threshold_obj[ 0 ] )
- down_threshold_max = int( down_threshold_obj[ 1 ] )
+ down_threshold_min = int(down_threshold_obj[0])
+ down_threshold_max = int(down_threshold_obj[1])
assertion = main.TRUE
- # Link event timestamp to system time list
+ #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
+ #Graph event timestamp to system time list
link_down_graph_to_system_list = []
- link_up_graph_to_system_list = []
+ link_up_graph_to_system_list = []
- 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(num_iter))
- 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.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( "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")
+ 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)
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" )
-
+ #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
+ #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" )
+ main.log.info("Checking ONOS for link update")
loop_count = 0
- while( not ( link_down1 and link_down2 and link_down3 )
+ 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 " )
+
+ if not (json_str1 and json_str2 and json_str3):
+ 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 )
+ 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' ]:
+ if '01' not in obj1['src']['device']:
link_down1 = True
- main.log.info( "Link down from " +
- "s1 -> s2 on ONOS1 detected" )
+ main.log.info("Link down from "+
+ "s1 -> s2 on ONOS1 detected")
for obj2 in json_obj2:
- if '01' not in obj2[ 'src' ][ 'device' ]:
+ if '01' not in obj2['src']['device']:
link_down2 = True
- main.log.info( "Link down from " +
- "s1 -> s2 on ONOS2 detected" )
+ main.log.info("Link down from "+
+ "s1 -> s2 on ONOS2 detected")
for obj3 in json_obj3:
- if '01' not in obj3[ 'src' ][ 'device' ]:
+ if '01' not in obj3['src']['device']:
link_down3 = True
- main.log.info( "Link down from " +
- "s1 -> s2 on ONOS3 detected" )
-
+ 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" )
-
+ #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
-
+
assertion = main.FALSE
else:
json_topo_metrics_1 =\
- main.ONOS1cli.topology_events_metrics()
+ main.ONOS1cli.topology_events_metrics()
json_topo_metrics_2 =\
- main.ONOS2cli.topology_events_metrics()
+ 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 )
+ 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)
- main.log.info( "Obtaining graph and device timestamp" )
+ main.log.info("Obtaining graph and device timestamp")
graph_timestamp_1 = \
- json_topo_metrics_1[ graphTimestamp ][ 'value' ]
+ json_topo_metrics_1[graphTimestamp]['value']
graph_timestamp_2 = \
- json_topo_metrics_2[ graphTimestamp ][ 'value' ]
+ json_topo_metrics_2[graphTimestamp]['value']
graph_timestamp_3 = \
- json_topo_metrics_3[ graphTimestamp ][ 'value' ]
+ json_topo_metrics_3[graphTimestamp]['value']
link_timestamp_1 = \
- json_topo_metrics_1[ linkTimestamp ][ 'value' ]
+ json_topo_metrics_1[linkTimestamp]['value']
link_timestamp_2 = \
- json_topo_metrics_2[ linkTimestamp ][ 'value' ]
+ json_topo_metrics_2[linkTimestamp]['value']
link_timestamp_3 = \
- json_topo_metrics_3[ linkTimestamp ][ 'value' ]
+ json_topo_metrics_3[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 )
+ 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)
else:
- main.log.error( "There was an error calculating" +
- " the delta for link down event" )
+ 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
+
+ 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_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
+ (link_down_lat_link1 +
+ link_down_lat_link2 +
+ link_down_lat_link3) / 3
- # Set threshold and append latency to list
+ #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 )
+ 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" )
+ 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 )
+ 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" )
+ 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:
+ #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" )
-
+ 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 )
+ 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 " )
+ if not (json_str1 and json_str2 and json_str3):
+ 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 )
-
+ 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" )
+ 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" )
+ 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" )
-
+ 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" )
-
+ 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
-
+
assertion = main.FALSE
else:
json_topo_metrics_1 =\
- main.ONOS1cli.topology_events_metrics()
+ main.ONOS1cli.topology_events_metrics()
json_topo_metrics_2 =\
- main.ONOS2cli.topology_events_metrics()
+ 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 )
+ 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)
- main.log.info( "Obtaining graph and device timestamp" )
+ main.log.info("Obtaining graph and device timestamp")
graph_timestamp_1 = \
- json_topo_metrics_1[ graphTimestamp ][ 'value' ]
+ json_topo_metrics_1[graphTimestamp]['value']
graph_timestamp_2 = \
- json_topo_metrics_2[ graphTimestamp ][ 'value' ]
+ json_topo_metrics_2[graphTimestamp]['value']
graph_timestamp_3 = \
- json_topo_metrics_3[ graphTimestamp ][ 'value' ]
+ json_topo_metrics_3[graphTimestamp]['value']
link_timestamp_1 = \
- json_topo_metrics_1[ linkTimestamp ][ 'value' ]
+ json_topo_metrics_1[linkTimestamp]['value']
link_timestamp_2 = \
- json_topo_metrics_2[ linkTimestamp ][ 'value' ]
+ json_topo_metrics_2[linkTimestamp]['value']
link_timestamp_3 = \
- json_topo_metrics_3[ linkTimestamp ][ 'value' ]
+ json_topo_metrics_3[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 )
+ 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)
else:
- main.log.error( "There was an error calculating" +
- " the delta for link down event" )
+ 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
+ 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_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
+ (link_up_lat_link1 +
+ link_up_lat_link2 +
+ link_up_lat_link3) / 3
- # Set threshold and append latency to list
+ #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 )
+ link_up_lat_graph_avg)
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")
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 )
+ link_up_lat_link_avg)
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 )
+ #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 ) )
+ 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 ) )
+ str(round(numpy.std(link_up_graph_to_system_list),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(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")
- 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' ]
+ 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']
- default_sw_port = main.params[ 'CTRL' ][ 'port1' ]
+ default_sw_port = main.params['CTRL']['port1']
+
+ #Number of iterations of case
+ num_iter = main.params['TEST']['numIter']
+ num_sw = main.params['TEST']['numSwitch']
- # Number of iterations of case
- num_iter = main.params[ 'TEST' ][ 'numIter' ]
- num_sw = main.params[ 'TEST' ][ 'numSwitch' ]
+ #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']
- # 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' ]
-
- local_time = time.strftime( '%X' )
- local_time = local_time.replace( "/", "" )
- local_time = local_time.replace( " ", "_" )
- local_time = local_time.replace( ":", "" )
+ 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 )
+ 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])
- # 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 ] )
-
- tshark_ofp_output = "/tmp/tshark_ofp_" + num_sw + "sw.txt"
- tshark_tcp_output = "/tmp/tshark_tcp_" + num_sw + "sw.txt"
+ tshark_ofp_output = "/tmp/tshark_ofp_"+num_sw+"sw.txt"
+ tshark_tcp_output = "/tmp/tshark_tcp_"+num_sw+"sw.txt"
tshark_ofp_result_list = []
tshark_tcp_result_list = []
sw_discovery_lat_list = []
- main.case( num_sw + " Switch discovery latency" )
- main.step( "Assigning all switches to ONOS1" )
- for i in range( 1, int( num_sw ) + 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 )
+ 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)
- # 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( 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:
+ 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:
# Append to INPUT rule,
# behavior DROP that matches following:
# * packet type: tcp
# * source IP: MN1_ip
# * 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 "+MN1_ip+
+ " --dport "+default_sw_port+" -j DROP")
+ main.ONOS1.handle.expect("\$")
+ # Append to OUTPUT rule,
# behavior DROP that matches following:
# * packet type: tcp
# * source IP: MN1_ip
# * 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 "+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
# based on the number of switches in the topology
- main.log.info( "Please wait for switch connection to " +
- "time out" )
- time.sleep( 60 )
+ 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)
- # Gather vendor OFP with tshark
- main.ONOS1.tshark_grep( "OFP 86 Vendor",
- tshark_ofp_output )
- main.ONOS1.tshark_grep( "TCP 74 ",
- tshark_tcp_output )
-
- # NOTE: Remove all iptables rule quickly ( flush )
- # Before removal, obtain TestON timestamp at which
+ #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
main.ONOS1.handle.sendline(
- "sudo iptables -F" )
+ "sudo iptables -F")
- # Counter to track loop count
+ #Counter to track loop count
counter_loop = 0
counter_avail1 = 0
counter_avail2 = 0
@@ -1550,124 +1741,191 @@
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.
+ #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()
- device_json1 = json.loads( device_str_obj1 )
- device_json2 = json.loads( device_str_obj2 )
- device_json3 = json.loads( device_str_obj3 )
-
+ 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' ]:
+ if device1['available'] == True:
counter_avail1 += 1
- if counter_avail1 == int( num_sw ):
+ if counter_avail1 == int(num_sw):
onos1_dev = True
- main.log.info( "All devices have been " +
- "discovered on ONOS1" )
+ main.log.info("All devices have been "+
+ "discovered on ONOS1")
else:
counter_avail1 = 0
for device2 in device_json2:
- if device2[ 'available' ]:
+ if device2['available'] == True:
counter_avail2 += 1
- if counter_avail2 == int( num_sw ):
+ if counter_avail2 == int(num_sw):
onos2_dev = True
- main.log.info( "All devices have been " +
- "discovered on ONOS2" )
+ main.log.info("All devices have been "+
+ "discovered on ONOS2")
else:
counter_avail2 = 0
for device3 in device_json3:
- if device3[ 'available' ]:
+ if device3['available'] == True:
counter_avail3 += 1
- if counter_avail3 == int( num_sw ):
+ if counter_avail3 == int(num_sw):
onos3_dev = True
- main.log.info( "All devices have been " +
- "discovered on ONOS3" )
+ main.log.info("All devices have been "+
+ "discovered on ONOS3")
else:
counter_avail3 = 0
if onos1_dev and onos2_dev and onos3_dev:
- main.log.info( "All devices have been discovered " +
- "on all ONOS instances" )
+ 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
-
+
+ #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 )
+ #Give some time in between CLI calls
+ #(will not affect measurement)
+ time.sleep(3)
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/")
- os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" +
- tshark_ofp_output + " /tmp/" )
- os.system( "scp " + ONOS_user + "@" + ONOS1_ip + ":" +
- tshark_tcp_output + " /tmp/" )
-
- # 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: " )
+ #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 )
+ tshark_ofp_result_list.append(line)
+ main.log.info(line)
ofp_file.close()
- tcp_file = open( tshark_tcp_output, 'r' )
- main.log.info( "Tshark TCP 74 output: " )
+ 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 )
+ tshark_tcp_result_list.append(line)
+ main.log.info(line)
tcp_file.close()
- 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 )
+ 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)
graph_timestamp_1 = \
- json_obj_1[ graphTimestamp ][ 'value' ]
+ json_obj_1[graphTimestamp]['value']
graph_timestamp_2 = \
- json_obj_2[ graphTimestamp ][ 'value' ]
+ json_obj_2[graphTimestamp]['value']
graph_timestamp_3 = \
- json_obj_3[ graphTimestamp ][ 'value' ]
+ json_obj_3[graphTimestamp]['value']
- 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 )
+ 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)
avg_graph_lat = \
- ( int( graph_lat_1 ) +
- int( graph_lat_2 ) +
- int( graph_lat_3 ) ) / 3
-
+ (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 )
+ avg_graph_lat)
else:
- main.log.info( "100 Switch discovery latency " +
- "exceeded the threshold." )
+ main.log.info("100 Switch discovery latency "+
+ "exceeded the threshold.")
+
+ #END ITERATION FOR LOOP
- # END ITERATION FOR LOOP
+ 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)
- 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 )
+ 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")
- 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" )
+ 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
+
+ main.log.report("Increasing cluster size to "+
+ str(cluster_count))
+
+ 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)
+
+ main.ONOS2cli.start_onos_cli(ONOS2_ip)
+ main.ONOS3cli.start_onos_cli(ONOS3_ip)
+
+ elif cluster_count == 5:
+ main.log.info("Installing nodes 4 and 5")
+ node4_result = \
+ main.ONOSbench.onos_install(node=ONOS4_ip)
+ node5_result = \
+ main.ONOSbench.onos_install(node=ONOS5_ip)
+ install_result = node4_result and node5_result
+
+ time.sleep(5)
+
+ main.ONOS4cli.start_onos_cli(ONOS4_ip)
+ main.ONOS5cli.start_onos_cli(ONOS5_ip)
+
+ elif cluster_count == 7:
+ main.log.info("Installing nodes 4 and 5")
+ node6_result = \
+ main.ONOSbench.onos_install(node=ONOS6_ip)
+ node7_result = \
+ main.ONOSbench.onos_install(node=ONOS7_ip)
+ install_result = node6_result and node7_result
+
+ time.sleep(5)
+
+ main.ONOS6cli.start_onos_cli(ONOS6_ip)
+ main.ONOS7cli.start_onos_cli(ONOS7_ip)
+
+
+
diff --git a/TestON/tests/TopoPerfNext/TopoPerfNext.topo b/TestON/tests/TopoPerfNext/TopoPerfNext.topo
index 4ee44e2..fc70784 100644
--- a/TestON/tests/TopoPerfNext/TopoPerfNext.topo
+++ b/TestON/tests/TopoPerfNext/TopoPerfNext.topo
@@ -36,6 +36,42 @@
<connect_order>2</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS3cli>
+
+ <ONOS4cli>
+ <host>10.128.174.10</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4cli>
+
+ <ONOS5cli>
+ <host>10.128.174.10</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5cli>
+
+ <ONOS6cli>
+ <host>10.128.174.10</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6cli>
+
+ <ONOS7cli>
+ <host>10.128.174.10</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7cli>
<ONOS1>
<host>10.128.174.1</host>
@@ -63,6 +99,42 @@
<connect_order>3</connect_order>
<COMPONENTS> </COMPONENTS>
</ONOS3>
+
+ <ONOS4>
+ <host>10.128.174.4</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS4>
+
+ <ONOS5>
+ <host>10.128.174.5</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS5>
+
+ <ONOS6>
+ <host>10.128.174.6</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS6>
+
+ <ONOS7>
+ <host>10.128.174.7</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS7>
<Mininet1>
<host>10.128.10.90</host>