Changed the testcases selection in the params file and class name in MultiProd.py file
diff --git a/TestON/tests/FuncNext13/FuncNext13.params b/TestON/tests/FuncNext13/FuncNext13.params
new file mode 100755
index 0000000..13a4691
--- /dev/null
+++ b/TestON/tests/FuncNext13/FuncNext13.params
@@ -0,0 +1,37 @@
+<PARAMS>
+
+ <testcases>1,4,5,3</testcases>
+
+ #Environment variables
+ <ENV>
+ <cellName>driver_test</cellName>
+ </ENV>
+
+ <CTRL>
+ <ip1>10.128.20.11</ip1>
+ <port1>6633</port1>
+ </CTRL>
+
+ <PING>
+ <source1>h8</source1>
+ <source2>h9</source2>
+ <source3>h10</source3>
+ <source4>h11</source4>
+ <source5>h12</source5>
+ <source6>h13</source6>
+ <source7>h14</source7>
+ <source8>h15</source8>
+ <source9>h16</source9>
+ <source10>h17</source10>
+ <target1>10.0.0.18</target1>
+ <target2>10.0.0.19</target2>
+ <target3>10.0.0.20</target3>
+ <target4>10.0.0.21</target4>
+ <target5>10.0.0.22</target5>
+ <target6>10.0.0.23</target6>
+ <target7>10.0.0.24</target7>
+ <target8>10.0.0.25</target8>
+ <target9>10.0.0.26</target9>
+ <target10>10.0.0.27</target10>
+ </PING>
+</PARAMS>
diff --git a/TestON/tests/FuncNext13/FuncNext13.py b/TestON/tests/FuncNext13/FuncNext13.py
new file mode 100755
index 0000000..6b24695
--- /dev/null
+++ b/TestON/tests/FuncNext13/FuncNext13.py
@@ -0,0 +1,608 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import sys
+import os
+import re
+import time
+import json
+
+time.sleep(1)
+class FuncNext13:
+ def __init__(self):
+ self.default = ''
+
+ def CASE1(self, main):
+ '''
+ Startup sequence:
+ git pull
+ mvn clean install
+ onos-package
+ cell <name>
+ onos-verify-cell
+ onos-install -f
+ onos-wait-for-start
+ '''
+
+ cell_name = main.params['ENV']['cellName']
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS1_port = main.params['CTRL']['port1']
+
+ main.case("Setting up test environment")
+
+ main.step("Git checkout and pull master and get version")
+ main.ONOSbench.git_checkout("master")
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ version_result = main.ONOSbench.get_version()
+
+ if git_pull_result == 1:
+ main.step("Using mvn clean & install")
+ clean_install_result = main.ONOSbench.clean_install()
+ #clean_install_result = main.TRUE
+
+ main.step("Applying cell variable to environment")
+ cell_result1 = main.ONOSbench.set_cell(cell_name)
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result2 = main.ONOS2.set_cell(cell_name)
+ #verify_result = main.ONOS2.verify_cell()
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ cell_result = cell_result1 and cell_result2
+
+ main.step("Creating ONOS package")
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step("Creating a cell")
+ #cell_create_result = main.ONOSbench.create_cell_file(**************)
+
+ main.step("Installing ONOS package")
+ onos_install_result = main.ONOSbench.onos_install()
+ onos1_isup = main.ONOSbench.isup()
+
+ main.step("Starting ONOS service")
+ start_result = main.ONOSbench.onos_start(ONOS1_ip)
+
+ case1_result = (package_result and\
+ cell_result and verify_result and onos_install_result and\
+ onos1_isup and start_result )
+ utilities.assert_equals(expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful")
+
+ def CASE11(self, main):
+ '''
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Cleaning up test environment")
+
+ main.step("Testing ONOS kill function")
+ kill_result = main.ONOSbench.onos_kill(ONOS1_ip)
+
+ main.step("Stopping ONOS service")
+ stop_result = main.ONOSbench.onos_stop(ONOS1_ip)
+
+ main.step("Uninstalling ONOS service")
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ def CASE3(self, main):
+ '''
+ Test 'onos' command and its functionality in driver
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Testing 'onos' command")
+
+ main.step("Sending command 'onos -w <onos-ip> system:name'")
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result1)
+
+ main.step("Sending command 'onos -w <onos-ip> onos:topology'")
+ cmdstr2 = "onos:topology"
+ cmd_result2 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result2)
+
+
+
+ def CASE4(self, main):
+ import re
+ import time
+ main.case("Pingall Test")
+ main.step("Assigning switches to controllers")
+ for i in range(1,29):
+ if i ==1:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=2 and i<5:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=5 and i<8:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=8 and i<18:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=18 and i<28:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ else:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ Switch_Mastership = main.TRUE
+ for i in range (1,29):
+ if i==1:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=2 and i<5:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=5 and i<8:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=8 and i<18:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=18 and i<28:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ else:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is" + str(response))
+ if re.search("tcp:" +ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+
+ if Switch_Mastership == main.TRUE:
+ main.log.report("MasterControllers assigned correctly")
+ utilities.assert_equals(expect = main.TRUE,actual=Switch_Mastership,
+ onpass="MasterControllers assigned correctly")
+ '''
+ for i in range (1,29):
+ main.Mininet1.assign_sw_controller(sw=str(i),count=5,
+ ip1=ONOS1_ip,port1=ONOS1_port,
+ ip2=ONOS2_ip,port2=ONOS2_port,
+ ip3=ONOS3_ip,port3=ONOS3_port,
+ ip4=ONOS4_ip,port4=ONOS4_port,
+ ip5=ONOS5_ip,port5=ONOS5_port)
+ '''
+ #REACTIVE FWD test
+
+ main.step("Get list of hosts from Mininet")
+ host_list = main.Mininet1.get_hosts()
+ main.log.info(host_list)
+
+ main.step("Get host list in ONOS format")
+ host_onos_list = main.ONOS2.get_hosts_id(host_list)
+ main.log.info(host_onos_list)
+ #time.sleep(5)
+
+ #We must use ping from hosts we want to add intents from
+ #to make the hosts talk
+ #main.Mininet2.handle.sendline("\r")
+ #main.Mininet2.handle.sendline("h4 ping 10.1.1.1 -c 1 -W 1")
+ #time.sleep(3)
+ #main.Mininet2.handle.sendline("h5 ping 10.1.1.1 -c 1 -W 1")
+ #time.sleep(5)
+
+ main.step("Pingall")
+ ping_result = main.FALSE
+ while ping_result == main.FALSE:
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % (time2 - time1)
+
+ #Start onos cli again because u might have dropped out of onos prompt to the shell prompt
+ #if there was no activity
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ main.step("Get hosts")
+ main.ONOS2.handle.sendline("hosts")
+ main.ONOS2.handle.expect("onos>")
+ hosts = main.ONOS2.handle.before
+ main.log.info(hosts)
+
+ main.step("Get all devices id")
+ devices_id_list = main.ONOS2.get_all_devices_id()
+ main.log.info(devices_id_list)
+
+ #ONOS displays the hosts in hex format unlike mininet which does in decimal format
+ #So take care while adding intents
+
+ main.step("Add host-to-host intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1")
+ hth_intent_result = main.ONOS2.add_host_intent("00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1")
+
+
+
+ print "_____________________________________________________________________________________"
+ '''
+ main.step("Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003008", 1, "of:0000000000006018", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006018", 1, "of:0000000000003008", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h9 and h19 or ONOS hosts h9 and h13")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003009", 1, "of:0000000000006019", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006019", 1, "of:0000000000003009", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h10 and h20 or ONOS hosts hA and h14")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003010", 1, "of:0000000000006020", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006020", 1, "of:0000000000003010", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h11 and h21 or ONOS hosts hB and h15")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003011", 1, "of:0000000000006021", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006021", 1, "of:0000000000003011", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h12 and h22 or ONOS hosts hC and h16")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003012", 1, "of:0000000000006022", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006022", 1, "of:0000000000003012", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h13 and h23 or ONOS hosts hD and h17")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003013", 1, "of:0000000000006023", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006023", 1, "of:0000000000003013", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h14 and h24 or ONOS hosts hE and h18")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003014", 1, "of:0000000000006024", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006024", 1, "of:0000000000003014", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h15 and h25 or ONOS hosts hF and h19")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003015", 1, "of:0000000000006025", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006025", 1, "of:0000000000003015", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h16 and h26 or ONOS hosts h10 and h1A")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003016", 1, "of:0000000000006026", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006026", 1, "of:0000000000003016", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h17 and h27 or ONOS hosts h11 and h1B")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000003017", 1, "of:0000000000006027", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000000000006027", 1, "of:0000000000003017", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ print("_______________________________________________________________________________________")
+ '''
+
+ #Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstall_result = main.ONOS2.feature_uninstall("onos-app-fwd")
+ main.log.info("onos-app-fwd uninstalled")
+
+ #After reactive forwarding is disabled, the reactive flows on switches timeout in 10-15s
+ #So sleep for 15s
+ time.sleep(15)
+
+ flowHandle = main.ONOS2.flows()
+ print "flowHandle = ", flowHandle
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ #while i<10:
+ while i <18 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping == main.FALSE and count <5:
+ count+=1
+ i = 8
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+10) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts have failed")
+ i=19
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test passed!")
+ i+=1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+ if Ping_Result==main.FALSE:
+ main.log.report("Intents have not ben installed correctly. Cleaning up")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Intents have been installed correctly")
+
+ case4_result = Switch_Mastership and Ping_Result
+ utilities.assert_equals(expect=main.TRUE, actual=case4_result,
+ onpass="Pingall Test successful",
+ onfail="Pingall Test NOT successful")
+
+ def CASE5(self,main) :
+ import json
+ from subprocess import Popen, PIPE
+ from sts.topology.teston_topology import TestONTopology # assumes that sts is already in you PYTHONPATH
+ #main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+ deviceResult = main.ONOS2.devices()
+ linksResult = main.ONOS2.links()
+ portsResult = main.ONOS2.ports()
+ print "**************"
+ main.step("Start continuous pings")
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+ main.step("Create TestONTopology object")
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ('ip' + str(count)) in main.params['CTRL']:
+ temp = temp + (getattr(main,('ONOS' + str(count))),)
+ temp = temp + ("ONOS"+str(count),)
+ temp = temp + (main.params['CTRL']['ip'+str(count)],)
+ temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
+ ctrls.append(temp)
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step("Compare ONOS Topology to MN Topology")
+ devices_json = main.ONOS2.devices()
+ links_json = main.ONOS2.links()
+ ports_json = main.ONOS2.ports()
+ print "devices_json= ", devices_json
+
+ result1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices_json))
+ print "***********************"
+ result2 = main.Mininet1.compare_links(MNTopo, json.loads(links_json))
+ print "***********************"
+ result3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports_json))
+
+ result = result1 and result2 and result3
+ print "***********************"
+ if result == main.TRUE:
+ main.log.report("ONOS"+ " Topology matches MN Topology")
+ utilities.assert_equals(expect=main.TRUE,actual=result,
+ onpass="ONOS" + " Topology matches MN Topology",
+ onfail="ONOS" + " Topology does not match MN Topology")
+ Topology_Check = Topology_Check and result
+ utilities.assert_equals(expect=main.TRUE,actual=Topology_Check,
+ onpass="Topology checks passed", onfail="Topology checks failed")
+
+
+ def CASE7 (self,main):
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ link_sleep = int(main.params['timers']['LinkDiscovery'])
+
+ main.log.report("Killing a link to ensure that link discovery is consistent")
+ main.case("Killing a link to Ensure that Link Discovery is Working Properly")
+ main.step("Start continuous pings")
+
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+
+ main.step("Determine the current number of switches and links")
+ topology_output = main.ONOS2.topology()
+ topology_result = main.ONOS1.get_topology(topology_output)
+ activeSwitches = topology_result['devices']
+ links = topology_result['links']
+ print "activeSwitches = ", type(activeSwitches)
+ print "links = ", type(links)
+ main.log.info("Currently there are %s switches and %s links" %(str(activeSwitches), str(links)))
+
+ main.step("Kill Link between s3 and s28")
+ main.Mininet1.link(END1="s3",END2="s28",OPTION="down")
+ time.sleep(link_sleep)
+ topology_output = main.ONOS2.topology()
+ Link_Down = main.ONOS1.check_status(topology_output,activeSwitches,str(int(links)-2))
+ if Link_Down == main.TRUE:
+ main.log.report("Link Down discovered properly")
+ utilities.assert_equals(expect=main.TRUE,actual=Link_Down,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in "+ str(link_sleep) + " seconds")
+
+ main.step("Bring link between s3 and s28 back up")
+ Link_Up = main.Mininet1.link(END1="s3",END2="s28",OPTION="up")
+ time.sleep(link_sleep)
+ topology_output = main.ONOS2.topology()
+ Link_Up = main.ONOS1.check_status(topology_output,activeSwitches,str(links))
+ if Link_Up == main.TRUE:
+ main.log.report("Link up discovered properly")
+ utilities.assert_equals(expect=main.TRUE,actual=Link_Up,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in "+ str(link_sleep) + " seconds")
+
+
+
+
+ main.step("Compare ONOS Topology to MN Topology")
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+ Topology_Check = main.TRUE
+ devices_json = main.ONOS2.devices()
+ links_json = main.ONOS2.links()
+ ports_json = main.ONOS2.ports()
+ print "devices_json= ", devices_json
+
+ result1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices_json))
+ print "***********************"
+ result2 = main.Mininet1.compare_links(MNTopo, json.loads(links_json))
+ print "***********************"
+ result3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports_json))
+
+ result = result1 and result2 and result3
+ print "***********************"
+ if result == main.TRUE:
+ main.log.report("ONOS"+ " Topology matches MN Topology")
+ utilities.assert_equals(expect=main.TRUE,actual=result,
+ onpass="ONOS" + " Topology matches MN Topology",
+ onfail="ONOS" + " Topology does not match MN Topology")
+ Topology_Check = Topology_Check and result
+ utilities.assert_equals(expect=main.TRUE,actual=Topology_Check,
+ onpass="Topology checks passed", onfail="Topology checks failed")
+
+ result = Link_Down and Link_Up and Topology_Check
+ utilities.assert_equals(expect=main.TRUE,actual=result,
+ onpass="Link failure is discovered correctly",
+ onfail="Link Discovery failed")
+
+
+
diff --git a/TestON/tests/FuncNext13/FuncNext13.topo b/TestON/tests/FuncNext13/FuncNext13.topo
new file mode 100755
index 0000000..85b6cab
--- /dev/null
+++ b/TestON/tests/FuncNext13/FuncNext13.topo
@@ -0,0 +1,61 @@
+<TOPOLOGY>
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1>
+ <host>10.128.10.11</host>
+ <user>sdn</user>
+ <password>sdn</password>
+ <type>OnosDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <Mininet1>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>MininetCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow13</arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet1>
+
+ <Mininet2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow13 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet2>
+ </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/FuncNext13/__init__.py b/TestON/tests/FuncNext13/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/FuncNext13/__init__.py
diff --git a/TestON/tests/MultiProd/MultiProd.bak b/TestON/tests/MultiProd/MultiProd.bak
new file mode 100755
index 0000000..11af10b
--- /dev/null
+++ b/TestON/tests/MultiProd/MultiProd.bak
@@ -0,0 +1,1156 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import time
+import json
+
+time.sleep(1)
+class MultiProd:
+ def __init__(self):
+ self.default = ''
+
+ def CASE1(self, main):
+ '''
+ Startup sequence:
+ cell <name>
+ onos-verify-cell
+ onos-remove-raft-logs
+ git pull
+ mvn clean install
+ onos-package
+ onos-install -f
+ onos-wait-for-start
+ '''
+
+ cell_name = main.params['ENV']['cellName']
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
+ main.case("Setting up test environment")
+ main.log.report("This testcase is testing setting up test environment")
+ main.log.report("__________________________________")
+
+ main.step("Applying cell variable to environment")
+ cell_result1 = main.ONOSbench.set_cell(cell_name)
+ #cell_result2 = main.ONOScli1.set_cell(cell_name)
+ #cell_result3 = main.ONOScli2.set_cell(cell_name)
+ #cell_result4 = main.ONOScli3.set_cell(cell_name)
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result = cell_result1
+
+ main.step("Removing raft logs before a clen installation of ONOS")
+ remove_log_Result = main.ONOSbench.onos_remove_raft_logs()
+
+ main.step("Git checkout and pull master and get version")
+ main.ONOSbench.git_checkout("master")
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ main.ONOSbench.get_version(report=True)
+
+ if git_pull_result == 1:
+ main.step("Using mvn clean & install")
+ main.ONOSbench.clean_install()
+
+ main.step("Creating ONOS package")
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step("Creating a cell")
+ #cell_create_result = main.ONOSbench.create_cell_file(**************)
+
+ main.step("Installing ONOS package")
+ onos1_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS1_ip)
+ onos2_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS2_ip)
+ onos3_install_result = main.ONOSbench.onos_install(options="-f", node=ONOS3_ip)
+ onos_install_result = onos1_install_result and onos2_install_result and onos3_install_result
+ if onos_install_result == main.TRUE:
+ main.log.report("Installing ONOS package successful")
+ else:
+ main.log.report("Installing ONOS package failed")
+
+ onos1_isup = main.ONOSbench.isup(ONOS1_ip)
+ onos2_isup = main.ONOSbench.isup(ONOS2_ip)
+ onos3_isup = main.ONOSbench.isup(ONOS3_ip)
+ onos_isup = onos1_isup and onos2_isup and onos3_isup
+ if onos_isup == main.TRUE:
+ main.log.report("ONOS instances are up and ready")
+ else:
+ main.log.report("ONOS instances may not be up")
+
+ main.step("Starting ONOS service")
+ start_result = main.TRUE
+ #start_result = main.ONOSbench.onos_start(ONOS1_ip)
+ startcli1 = main.ONOScli1.start_onos_cli(ONOS_ip = ONOS1_ip)
+ startcli2 = main.ONOScli2.start_onos_cli(ONOS_ip = ONOS2_ip)
+ startcli3 = main.ONOScli3.start_onos_cli(ONOS_ip = ONOS3_ip)
+ print startcli1
+ print startcli2
+ print startcli3
+
+ case1_result = (package_result and\
+ cell_result and verify_result and onos_install_result and\
+ onos_isup and start_result )
+ utilities.assert_equals(expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful")
+
+ def CASE11(self, main):
+ '''
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
+ main.case("Cleaning up test environment")
+
+ main.step("Testing ONOS kill function")
+ kill_result1 = main.ONOSbench.onos_kill(ONOS1_ip)
+ kill_result2 = main.ONOSbench.onos_kill(ONOS2_ip)
+ kill_result3 = main.ONOSbench.onos_kill(ONOS3_ip)
+
+ main.step("Stopping ONOS service")
+ stop_result1 = main.ONOSbench.onos_stop(ONOS1_ip)
+ stop_result2 = main.ONOSbench.onos_stop(ONOS2_ip)
+ stop_result3 = main.ONOSbench.onos_stop(ONOS3_ip)
+
+ main.step("Uninstalling ONOS service")
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ def CASE3(self, main):
+ '''
+ Test 'onos' command and its functionality in driver
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
+ main.case("Testing 'onos' command")
+
+ main.step("Sending command 'onos -w <onos-ip> system:name'")
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result1)
+ cmd_result2 = main.ONOSbench.onos_cli(ONOS2_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result2)
+ cmd_result3 = main.ONOSbench.onos_cli(ONOS3_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result3)
+
+ main.step("Sending command 'onos -w <onos-ip> onos:topology'")
+ cmdstr2 = "onos:topology"
+ cmd_result4 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result4)
+ cmd_result5 = main.ONOSbench.onos_cli(ONOS2_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result5)
+ cmd_result6 = main.ONOSbench.onos_cli(ONOS6_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result6)
+
+
+ def CASE4(self, main):
+ import re
+ import time
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+ ONOS1_port = main.params['CTRL']['port1']
+ ONOS2_port = main.params['CTRL']['port2']
+ ONOS3_port = main.params['CTRL']['port3']
+
+ main.log.report("This testcase is testing the assignment of all the switches to all controllers and discovering the hosts in reactive mode")
+ main.log.report("__________________________________")
+ main.case("Pingall Test(No intents are added)")
+ main.step("Assigning switches to controllers")
+ for i in range(1,29): #1 to (num of switches +1)
+ main.Mininet1.assign_sw_controller(sw=str(i),count=3,
+ ip1=ONOS1_ip, port1=ONOS1_port,
+ ip2=ONOS2_ip, port2=ONOS2_port,
+ ip3=ONOS3_ip, port3=ONOS3_port)
+
+ switch_mastership = main.TRUE
+ for i in range (1,29):
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ switch_mastership = switch_mastership and main.TRUE
+ else:
+ switch_mastership = main.FALSE
+
+ if switch_mastership == main.TRUE:
+ main.log.report("Controller assignment successfull")
+ else:
+ main.log.report("Controller assignment failed")
+ #REACTIVE FWD test
+ main.step("Pingall")
+ ping_result = main.FALSE
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % (time2 - time1)
+
+ case4_result = switch_mastership and ping_result
+ if ping_result == main.TRUE:
+ main.log.report("Pingall Test in reactive mode to discover the hosts successful")
+ else:
+ main.log.report("Pingall Test in reactive mode to discover the hosts failed")
+
+ utilities.assert_equals(expect=main.TRUE, actual=case4_result,onpass="Controller assignment and Pingall Test successful",onfail="Controller assignment and Pingall Test NOT successful")
+
+
+
+ def CASE5(self,main) :
+ import json
+ from subprocess import Popen, PIPE
+ from sts.topology.teston_topology import TestONTopology # assumes that sts is already in you PYTHONPATH
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS2_ip = main.params['CTRL']['ip2']
+ ONOS3_ip = main.params['CTRL']['ip3']
+
+ main.log.report("This testcase is testing if all ONOS nodes are in topology sync with mininet and its peer ONOS nodes")
+ main.log.report("__________________________________")
+ main.case ("Testing Mininet topology with the topology of multi instances ONOS")
+ main.step("Collecting topology information from ONOS")
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ #print "devices1 = ", devices1
+ #print "devices2 = ", devices2
+ #print "devices3 = ", devices3
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ #print "hosts1 = ", hosts1
+ #print "hosts2 = ", hosts2
+ #print "hosts3 = ", hosts3
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ #print "ports1 = ", ports1
+ #print "ports2 = ", ports2
+ #print "ports3 = ", ports3
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+ #print "links1 = ", links1
+ #print "links2 = ", links2
+ #print "links3 = ", links3
+
+ print "**************"
+
+ main.step("Start continuous pings")
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+ main.step("Create TestONTopology object")
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ('ip' + str(count)) in main.params['CTRL']:
+ temp = temp + (getattr(main,('ONOS' + str(count))),)
+ temp = temp + ("ONOS"+str(count),)
+ temp = temp + (main.params['CTRL']['ip'+str(count)],)
+ temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
+ ctrls.append(temp)
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step("Compare ONOS Topology to MN Topology")
+
+ switches_results1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices1))
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect")
+
+ switches_results2 = main.Mininet1.compare_switches(MNTopo, json.loads(devices2))
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect")
+
+ switches_results3 = main.Mininet1.compare_switches(MNTopo, json.loads(devices3))
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect")
+
+ '''
+ ports_results1 = main.Mininet1.compare_ports(MNTopo, json.loads(ports1))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect")
+
+ ports_results2 = main.Mininet1.compare_ports(MNTopo, json.loads(ports2))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect")
+
+ ports_results3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports3))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect")
+ '''
+
+ links_results1 = main.Mininet1.compare_links(MNTopo, json.loads(links1))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect")
+
+ links_results2 = main.Mininet1.compare_links(MNTopo, json.loads(links2))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect")
+
+ links_results3 = main.Mininet1.compare_links(MNTopo, json.loads(links3))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect")
+
+ #topo_result = switches_results1 and switches_results2 and switches_results3\
+ #and ports_results1 and ports_results2 and ports_results3\
+ #and links_results1 and links_results2 and links_results3
+
+ topo_result = switches_results1 and switches_results2 and switches_results3\
+ and links_results1 and links_results2 and links_results3
+
+ if topo_result == main.TRUE:
+ main.log.report("Topology Check Test with mininet and ONOS instances successful")
+ else:
+ main.log.report("Topology Check Test with mininet and ONOS instances failed")
+
+ utilities.assert_equals(expect=main.TRUE, actual=topo_result,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful")
+
+
+
+
+ def CASE10(self):
+ main.log.report("This testcase uninstalls the reactive forwarding app")
+ main.log.report("__________________________________")
+ main.case("Uninstalling reactive forwarding app")
+ #Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall("onos-app-fwd")
+ appUninstall_result2 = main.ONOScli2.feature_uninstall("onos-app-fwd")
+ appUninstall_result3 = main.ONOScli3.feature_uninstall("onos-app-fwd")
+ main.log.info("onos-app-fwd uninstalled")
+
+ #After reactive forwarding is disabled, the reactive flows on switches timeout in 10-15s
+ #So sleep for 15s
+ time.sleep(15)
+
+ hosts = main.ONOScli1.hosts()
+ main.log.info(hosts)
+
+ case10_result = appUninstall_result1 and appUninstall_result2 and appUninstall_result3
+ utilities.assert_equals(expect=main.TRUE, actual=case10_result,onpass="Reactive forwarding app uninstallation successful",onfail="Reactive forwarding app uninstallation failed")
+
+
+ def CASE6(self):
+ main.log.report("This testcase is testing the addition of host intents and then doing pingall")
+ main.log.report("__________________________________")
+ main.case("Obtaining hostsfor adding host intents")
+ main.step("Get hosts")
+ hosts = main.ONOScli1.hosts()
+ main.log.info(hosts)
+
+ main.step("Get all devices id")
+ devices_id_list = main.ONOScli1.get_all_devices_id()
+ main.log.info(devices_id_list)
+
+ #ONOS displays the hosts in hex format unlike mininet which does in decimal format
+ #So take care while adding intents
+
+ '''
+ main.step("Add host intents for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1")
+ hth_intent_result = main.ONOScli1.add_host_intent("00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1")
+ '''
+
+ for i in range(8,18):
+ main.log.info("Adding host intent between h"+str(i)+" and h"+str(i+10))
+ host1 = "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
+ host2 = "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
+ #NOTE: get host can return None
+ #TODO: handle this
+ host1_id = main.ONOScli1.get_host(host1)['id']
+ host2_id = main.ONOScli1.get_host(host2)['id']
+ tmp_result = main.ONOScli1.add_host_intent(host1_id, host2_id )
+
+ flowHandle = main.ONOScli1.flows()
+ #print "flowHandle = ", flowHandle
+ main.log.info("flows:" +flowHandle)
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i <18 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping == main.FALSE and count <5:
+ count+=1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+10) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h" + str(i) + " and h" + str(i+10) +"have failed")
+ i=19
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h" + str(i) + " and h" + str(i+10) + "passed!")
+ i+=1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+ if Ping_Result==main.FALSE:
+ main.log.report("Host intents have not ben installed correctly. Cleaning up")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Host intents have been installed correctly")
+
+ case6_result = Ping_Result
+ utilities.assert_equals(expect=main.TRUE, actual=case6_result,
+ onpass="Host intent addition and Pingall Test successful",
+ onfail="Host intent addition and Pingall Test NOT successful")
+
+
+ def CASE7 (self,main):
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ link_sleep = int(main.params['timers']['LinkDiscovery'])
+
+ main.log.report("This testscase is killing a link to ensure that link discovery is consistent")
+ main.log.report("__________________________________")
+ main.case("Killing a link to Ensure that Link Discovery is Working Properly")
+ main.step("Start continuous pings")
+
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+
+ main.step("Determine the current number of switches and links")
+ topology_output = main.ONOScli1.topology()
+ topology_result = main.ONOSbench.get_topology(topology_output)
+ activeSwitches = topology_result['devices']
+ links = topology_result['links']
+ print "activeSwitches = ", type(activeSwitches)
+ print "links = ", type(links)
+ main.log.info("Currently there are %s switches and %s links" %(str(activeSwitches), str(links)))
+
+ main.step("Kill Link between s3 and s28")
+ main.Mininet1.link(END1="s3",END2="s28",OPTION="down")
+ time.sleep(link_sleep)
+ topology_output = main.ONOScli2.topology()
+ Link_Down = main.ONOSbench.check_status(topology_output,activeSwitches,str(int(links)-2))
+ if Link_Down == main.TRUE:
+ main.log.report("Link Down discovered properly")
+ utilities.assert_equals(expect=main.TRUE,actual=Link_Down,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in "+ str(link_sleep) + " seconds")
+
+ main.step("Bring link between s3 and s28 back up")
+ Link_Up = main.Mininet1.link(END1="s3",END2="s28",OPTION="up")
+ time.sleep(link_sleep)
+ topology_output = main.ONOScli2.topology()
+ Link_Up = main.ONOSbench.check_status(topology_output,activeSwitches,str(links))
+ if Link_Up == main.TRUE:
+ main.log.report("Link up discovered properly")
+ utilities.assert_equals(expect=main.TRUE,actual=Link_Up,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in "+ str(link_sleep) + " seconds")
+
+ main.step("Compare ONOS Topology to MN Topology")
+ main.case ("Testing Mininet topology with the topology of multi instances ONOS")
+ main.step("Collecting topology information from ONOS")
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ print "devices1 = ", devices1
+ print "devices2 = ", devices2
+ print "devices3 = ", devices3
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ #print "hosts1 = ", hosts1
+ #print "hosts2 = ", hosts2
+ #print "hosts3 = ", hosts3
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ #print "ports1 = ", ports1
+ #print "ports2 = ", ports2
+ #print "ports3 = ", ports3
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+ #print "links1 = ", links1
+ #print "links2 = ", links2
+ #print "links3 = ", links3
+
+ print "**************"
+
+ main.step("Start continuous pings")
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+ main.step("Create TestONTopology object")
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ('ip' + str(count)) in main.params['CTRL']:
+ temp = temp + (getattr(main,('ONOS' + str(count))),)
+ temp = temp + ("ONOS"+str(count),)
+ temp = temp + (main.params['CTRL']['ip'+str(count)],)
+ temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
+ ctrls.append(temp)
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step("Compare ONOS Topology to MN Topology")
+
+ switches_results1 = main.Mininet1.compare_switches(MNTopo, json.loads(devices1))
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect")
+
+ switches_results2 = main.Mininet1.compare_switches(MNTopo, json.loads(devices2))
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect")
+
+ switches_results3 = main.Mininet1.compare_switches(MNTopo, json.loads(devices3))
+ utilities.assert_equals(expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect")
+
+ '''
+ ports_results1 = main.Mininet1.compare_ports(MNTopo, json.loads(ports1))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect")
+
+ ports_results2 = main.Mininet1.compare_ports(MNTopo, json.loads(ports2))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect")
+
+ ports_results3 = main.Mininet1.compare_ports(MNTopo, json.loads(ports3))
+ utilities.assert_equals(expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect")
+ '''
+
+ links_results1 = main.Mininet1.compare_links(MNTopo, json.loads(links1))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect")
+
+ links_results2 = main.Mininet1.compare_links(MNTopo, json.loads(links2))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect")
+
+ links_results3 = main.Mininet1.compare_links(MNTopo, json.loads(links3))
+ utilities.assert_equals(expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect")
+
+ #topo_result = switches_results1 and switches_results2 and switches_results3\
+ #and ports_results1 and ports_results2 and ports_results3\
+ #and links_results1 and links_results2 and links_results3
+
+ topo_result = switches_results1 and switches_results2 and switches_results3\
+ and links_results1 and links_results2 and links_results3
+
+ utilities.assert_equals(expect=main.TRUE, actual=topo_result and Link_Up and Link_Down,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful")
+
+
+ def CASE8(self):
+ '''
+ Intent removal
+ '''
+ main.log.report("This testcase removes host any previously added intents")
+ main.log.report("__________________________________")
+ main.log.info("Removing any previously installed intents")
+ main.case("Removing intents")
+ main.step("Obtain the intent id's")
+ intent_result = main.ONOScli1.intents(json_format = False)
+
+ intent_linewise = intent_result.split("\n")
+ intentList = []
+ for line in intent_linewise:
+ if line.startswith("id="):
+ intentList.append(line)
+
+ intentids = []
+ for line in intentList:
+ intentids.append(line.split(",")[0].split("=")[1])
+ for id in intentids:
+ main.log.info("id = " +id)
+
+ main.step("Iterate through the intentids list and remove each intent")
+ for id in intentids:
+ main.ONOScli1.remove_intent(intent_id = id)
+
+ intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info("intent_result = " +intent_result)
+ case8_result = main.TRUE
+
+ i = 8
+ Ping_Result = main.TRUE
+ while i <18 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping==main.TRUE:
+ i = 19
+ Ping_Result = main.TRUE
+ elif ping==main.FALSE:
+ i+=1
+ Ping_Result = main.FALSE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+
+ #Note: If the ping result failed, that means the intents have been withdrawn correctly.
+ if Ping_Result==main.TRUE:
+ main.log.report("Host intents have not been withdrawn correctly")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.FALSE:
+ main.log.report("Host intents have been withdrawn correctly")
+
+ case8_result = case8_result and Ping_Result
+
+ if case8_result == main.FALSE:
+ main.log.report("Intent removal successful")
+ else:
+ main.log.report("Intent removal failed")
+
+ utilities.assert_equals(expect=main.FALSE, actual=case8_result,
+ onpass="Intent removal test failed",
+ onfail="Intent removal test successful")
+
+
+ def CASE9(self):
+ '''
+ This test case adds point intents. Make sure you run test case 8 which is host intent removal before executing this test case.
+ Else the host intent's flows will persist on switches and the pings would work even if there is some issue with the point intent's flows
+ '''
+ main.log.report("This testcase adds point intents and then does pingall")
+ main.log.report("__________________________________")
+ main.log.info("Adding point intents")
+ main.case("Adding bidirectional point for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)")
+ main.step("Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003008/1", "of:0000000000006018/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006018/1", "of:0000000000003008/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h9 and h19 or ONOS hosts h9 and h13")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003009/1", "of:0000000000006019/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006019/1", "of:0000000000003009/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h10 and h20 or ONOS hosts hA and h14")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003010/1", "of:0000000000006020/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006020/1", "of:0000000000003010/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h11 and h21 or ONOS hosts hB and h15")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003011/1", "of:0000000000006021/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006021/1", "of:0000000000003011/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h12 and h22 or ONOS hosts hC and h16")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003012/1", "of:0000000000006022/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006022/1", "of:0000000000003012/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h13 and h23 or ONOS hosts hD and h17")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003013/1", "of:0000000000006023/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006023/1", "of:0000000000003013/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h14 and h24 or ONOS hosts hE and h18")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003014/1", "of:0000000000006024/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006024/1", "of:0000000000003014/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h15 and h25 or ONOS hosts hF and h19")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003015/1", "of:0000000000006025/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006025/1", "of:0000000000003015/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ main.step("Add point-to-point intents for mininet hosts h16 and h26 or ONOS hosts h10 and h1A")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003016/1", "of:0000000000006026/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006026/1", "of:0000000000003016/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+
+ main.step("Add point-to-point intents for mininet hosts h17 and h27 or ONOS hosts h11 and h1B")
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000003017/1", "of:0000000000006027/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOScli1.add_point_intent("of:0000000000006027/1", "of:0000000000003017/1")
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info("Point to point intent install successful")
+ #main.log.info(get_intent_result)
+
+ print("_______________________________________________________________________________________")
+
+ flowHandle = main.ONOScli1.flows()
+ #print "flowHandle = ", flowHandle
+ main.log.info("flows :" + flowHandle)
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i <18 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping == main.FALSE and count <5:
+ count+=1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+10) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h" + str(i) + " and h" + str(i+10) +"have failed")
+ i=19
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h" + str(i) + " and h" + str(i+10) + "passed!")
+ i+=1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+ if Ping_Result==main.FALSE:
+ main.log.report("Ping all test after Point intents addition failed. Cleaning up")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Ping all test after Point intents addition successful")
+
+ case8_result = Ping_Result
+ utilities.assert_equals(expect=main.TRUE, actual=case8_result,
+ onpass="Ping all test after Point intents addition successful",
+ onfail="Ping all test after Point intents addition failed")
+
+ def CASE31(self):
+ '''
+ This test case adds point intent related to SDN-IP matching on ICMP (ethertype=IPV4, ipProto=1)
+ '''
+ import json
+
+ main.log.report("This test case adds point intent related to SDN-IP matching on ICMP")
+ main.case("Adding bidirectional point intent related to SDN-IP matching on ICMP")
+ main.step("Adding bidirectional point intent")
+ #add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=1 of:0000000000003008/1 of:0000000000006018/1
+
+ hosts_json = json.loads(main.ONOScli1.hosts())
+ for i in range(8,11):
+ main.log.info("Adding point intent between h"+str(i)+" and h"+str(i+10))
+ host1 = "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
+ host2 = "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
+ host1_id = main.ONOScli1.get_host(host1)['id']
+ host2_id = main.ONOScli1.get_host(host2)['id']
+ for host in hosts_json:
+ if host['id'] == host1_id:
+ ip1 = host['ips'][0]
+ ip1 = str(ip1+"/32")
+ device1 = host['location']['device']
+ device1 = str(device1+"/1")
+ elif host['id'] == host2_id:
+ ip2 = str(host['ips'][0])+"/32"
+ device2 = host['location']["device"]
+ device2 = str(device2+"/1")
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(ingress_device=device1, egress_device=device2, ipSrc=ip1, ipDst=ip2,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['icmpProto'])
+
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info(get_intent_result)
+
+ p_intent_result2 = main.ONOScli1.add_point_intent(ingress_device=device2, egress_device=device1, ipSrc=ip2, ipDst=ip1,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['icmpProto'])
+
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info(get_intent_result)
+ if (p_intent_result1 and p_intent_result2) == main.TRUE:
+ #get_intent_result = main.ONOScli1.intents()
+ #main.log.info(get_intent_result)
+ main.log.info("Point intent related to SDN-IP matching on ICMP install successful")
+
+ time.sleep(15)
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info("intents = "+ get_intent_result)
+ get_flows_result = main.ONOScli1.flows()
+ main.log.info("flows = " + get_flows_result)
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i <11 :
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+10))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+10))
+ if ping == main.FALSE and count <3:
+ count+=1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+10) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h" + str(i) + " and h" + str(i+10) +"have failed")
+ i=19
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h" + str(i) + " and h" + str(i+10) + "passed!")
+ i+=1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+ if Ping_Result==main.FALSE:
+ main.log.report("Ping test after Point intents related to SDN-IP matching on ICMP failed.")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Ping all test after Point intents related to SDN-IP matching on ICMP successful")
+
+ case31_result = Ping_Result and p_intent_result1 and p_intent_result2
+ utilities.assert_equals(expect=main.TRUE, actual=case31_result,
+ onpass="Point intent related to SDN-IP matching on ICMP and ping test successful",
+ onfail="Point intent related to SDN-IP matching on ICMP and ping test failed")
+
+ def CASE32(self):
+ '''
+ This test case adds point intent related to SDN-IP matching on TCP (ethertype=IPV4, ipProto=6, DefaultPort for iperf=5001)
+ Note: Although BGP port is 179, we are using 5001 because iperf is used for verifying and iperf's default port is 5001
+ '''
+ import json
+
+ main.log.report("This test case adds point intent related to SDN-IP matching on TCP")
+ main.case("Adding bidirectional point intent related to SDN-IP matching on TCP")
+ main.step("Adding bidirectional point intent")
+ """
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001 of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001 of:0000000000006018/1 of:0000000000003008/1
+
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001 of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001 of:0000000000006018/1 of:0000000000003008/1
+
+ """
+
+ hosts_json = json.loads(main.ONOScli1.hosts())
+ for i in range(8,9):
+ main.log.info("Adding point intent between h"+str(i)+" and h"+str(i+10))
+ host1 = "00:00:00:00:00:" + str(hex(i)[2:]).zfill(2).upper()
+ host2 = "00:00:00:00:00:" + str(hex(i+10)[2:]).zfill(2).upper()
+ host1_id = main.ONOScli1.get_host(host1)['id']
+ host2_id = main.ONOScli1.get_host(host2)['id']
+ for host in hosts_json:
+ if host['id'] == host1_id:
+ ip1 = host['ips'][0]
+ ip1 = str(ip1+"/32")
+ device1 = host['location']['device']
+ device1 = str(device1+"/1")
+ elif host['id'] == host2_id:
+ ip2 = str(host['ips'][0])+"/32"
+ device2 = host['location']["device"]
+ device2 = str(device2+"/1")
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(ingress_device=device1, egress_device=device2, ipSrc=ip1, ipDst=ip2,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpDst=main.params['SDNIP']['dstPort'])
+ p_intent_result2 = main.ONOScli1.add_point_intent(ingress_device=device2, egress_device=device1, ipSrc=ip2, ipDst=ip1,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpDst=main.params['SDNIP']['dstPort'])
+
+ p_intent_result3 = main.ONOScli1.add_point_intent(ingress_device=device1, egress_device=device2, ipSrc=ip1, ipDst=ip2,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpSrc=main.params['SDNIP']['srcPort'])
+ p_intent_result4 = main.ONOScli1.add_point_intent(ingress_device=device2, egress_device=device1, ipSrc=ip2, ipDst=ip1,
+ ethType=main.params['SDNIP']['ethType'], ipProto=main.params['SDNIP']['tcpProto'], tcpSrc=main.params['SDNIP']['srcPort'])
+
+ p_intent_result = p_intent_result1 and p_intent_result2 and p_intent_result3 and p_intent_result4
+ if p_intent_result ==main.TRUE:
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info(get_intent_result)
+ main.log.info("Point intent related to SDN-IP matching on TCP install successful")
+
+ iperf_result = main.Mininet1.iperf('h8', 'h18')
+ if iperf_result == main.TRUE:
+ main.log.report("iperf test successful")
+ else:
+ main.log.report("iperf test failed")
+
+
+ case32_result = p_intent_result and iperf_result
+ utilities.assert_equals(expect=main.TRUE, actual=case32_result,
+ onpass="Ping all test after Point intents addition related to SDN-IP on TCP match successful",
+ onfail="Ping all test after Point intents addition related to SDN-IP on TCP match failed")
+
+
+ def CASE33(self):
+ '''
+ This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and the action is to rewrite the mac address
+ Here the mac address to be rewritten is the mac address of the egress device
+ '''
+ import json
+ import time
+
+ main.log.report("This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and rewrite mac address action")
+ main.case("Adding multipoint to singlepoint intent related to SDN-IP matching on destination ip")
+ main.step("Adding bidirectional multipoint to singlepoint intent")
+ """
+ add-multi-to-single-intent --ipDst=10.0.3.0/24 --setEthDst=00:00:00:00:00:12 of:0000000000003008/1 0000000000003009/1 of:0000000000006018/1
+
+ add-multi-to-single-intent --ipDst=10.0.1.0/24 --setEthDst=00:00:00:00:00:08 of:0000000000006018/1 0000000000003009/1 of:0000000000003008/1
+ """
+
+ main.case("Installing multipoint to single point intent with rewrite mac address")
+ main.step("Uninstalling proxy arp app")
+ #Unistall onos-app-proxyarp app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall("onos-app-proxyarp")
+ appUninstall_result2 = main.ONOScli2.feature_uninstall("onos-app-proxyarp")
+ appUninstall_result3 = main.ONOScli3.feature_uninstall("onos-app-proxyarp")
+ main.log.info("onos-app-proxyarp uninstalled")
+
+ main.step("Changing ipaddress of hosts h8,h9 and h18")
+ main.Mininet1.changeIP(host='h8', intf='h8-eth0', newIP='10.0.1.1', newNetmask='255.255.255.0')
+ main.Mininet1.changeIP(host='h9', intf='h9-eth0', newIP='10.0.2.1', newNetmask='255.255.255.0')
+ main.Mininet1.changeIP(host='h10', intf='h10-eth0', newIP='10.0.3.1', newNetmask='255.255.255.0')
+
+ main.step("Changing default gateway of hosts h8,h9 and h18")
+ main.Mininet1.changeDefaultGateway(host='h8', newGW='10.0.1.254')
+ main.Mininet1.changeDefaultGateway(host='h9', newGW='10.0.2.254')
+ main.Mininet1.changeDefaultGateway(host='h10', newGW='10.0.3.254')
+
+ main.step("Assigning random mac address to the default gateways since proxyarp app is uninstalled")
+ main.Mininet1.addStaticMACAddress(host='h8', GW='10.0.1.254', macaddr='00:00:00:00:11:11')
+ main.Mininet1.addStaticMACAddress(host='h9', GW='10.0.2.254', macaddr='00:00:00:00:22:22')
+ main.Mininet1.addStaticMACAddress(host='h10', GW='10.0.3.254', macaddr='00:00:00:00:33:33')
+
+ main.step("Verify static gateway and MAC address assignment")
+ main.Mininet1.verifyStaticGWandMAC(host='h8')
+ main.Mininet1.verifyStaticGWandMAC(host='h9')
+ main.Mininet1.verifyStaticGWandMAC(host='h10')
+
+ main.step("Adding multipoint to singlepoint intent")
+ p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(ingress_device1=main.params['MULTIPOINT_INTENT']['device1'], ingress_device2=main.params['MULTIPOINT_INTENT']['device2'],
+ egress_device=main.params['MULTIPOINT_INTENT']['device3'], ipDst=main.params['MULTIPOINT_INTENT']['ip1'], setEthDst=main.params['MULTIPOINT_INTENT']['mac1'])
+
+ p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(ingress_device1=main.params['MULTIPOINT_INTENT']['device3'], ingress_device2=main.params['MULTIPOINT_INTENT']['device2'],
+ egress_device=main.params['MULTIPOINT_INTENT']['device1'], ipDst=main.params['MULTIPOINT_INTENT']['ip2'], setEthDst=main.params['MULTIPOINT_INTENT']['mac2'])
+
+
+ get_intent_result = main.ONOScli1.intents(json_format = False)
+ main.log.info("intents = "+ get_intent_result)
+
+ time.sleep(10)
+ get_flows_result = main.ONOScli1.flows(json_format = False)
+ main.log.info("flows = " + get_flows_result)
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+
+ main.log.info("\n\nh"+str(i)+" is Pinging h" + str(i+2))
+ ping = main.Mininet1.pingHost(src="h"+str(i),target="h"+str(i+2))
+ if ping == main.FALSE and count <3:
+ count+=1
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h" + str(i) + " and h" + str(i+2) + " failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h" + str(i) + " and h" + str(i+10) +"have failed")
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h" + str(i) + " and h" + str(i+2) + "passed!")
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+
+ if Ping_Result==main.FALSE:
+ main.log.report("Ping test failed.")
+ #main.cleanup()
+ #main.exit()
+ if Ping_Result==main.TRUE:
+ main.log.report("Ping all successful")
+
+
+ p_intent_result = p_intent_result1 and p_intent_result2
+ if p_intent_result ==main.TRUE:
+ main.log.info("Multi point intent with rewrite mac address installation successful")
+ else:
+ main.log.info("Multi point intent with rewrite mac address installation failed")
+
+ case33_result = p_intent_result and Ping_Result
+ utilities.assert_equals(expect=main.TRUE, actual=case33_result,
+ onpass="Ping all test after multipoint to single point intent addition with rewrite mac address successful",
+ onfail="Ping all test after multipoint to single point intent addition with rewrite mac address failed")
diff --git a/TestON/tests/MultiProd/MultiProd.bak1 b/TestON/tests/MultiProd/MultiProd.bak1
new file mode 100644
index 0000000..6b67f63
--- /dev/null
+++ b/TestON/tests/MultiProd/MultiProd.bak1
@@ -0,0 +1,1523 @@
+
+# Testing the basic functionality of ONOS Next
+# For sanity and driver functionality excercises only.
+
+import time
+import sys
+import os
+import re
+import time
+import json
+
+time.sleep( 1 )
+
+
+class MultiProd:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE1( self, main ):
+ """
+ Startup sequence:
+ cell <name>
+ onos-verify-cell
+ onos-remove-raft-logs
+ git pull
+ mvn clean install
+ onos-package
+ onos-install -f
+ onos-wait-for-start
+ """
+ cell_name = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+ ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+
+ main.case( "Setting up test environment" )
+ main.log.report(
+ "This testcase is testing setting up test environment" )
+ main.log.report( "__________________________________" )
+
+ main.step( "Applying cell variable to environment" )
+ cell_result1 = main.ONOSbench.set_cell( cell_name )
+ #cell_result2 = main.ONOScli1.set_cell( cell_name )
+ #cell_result3 = main.ONOScli2.set_cell( cell_name )
+ #cell_result4 = main.ONOScli3.set_cell( cell_name )
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result = cell_result1
+
+ main.step( "Removing raft logs before a clen installation of ONOS" )
+ remove_log_Result = main.ONOSbench.onos_remove_raft_logs()
+
+ main.step( "Git checkout and pull master and get version" )
+ main.ONOSbench.git_checkout( "master" )
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ version_result = main.ONOSbench.get_version( report=True )
+
+ if git_pull_result == 1:
+ main.step( "Using mvn clean & install" )
+ clean_install_result = main.ONOSbench.clean_install()
+ #clean_install_result = main.TRUE
+
+ main.step( "Creating ONOS package" )
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step( "Creating a cell" )
+ # cell_create_result = main.ONOSbench.create_cell_file( **************
+ # )
+
+ main.step( "Installing ONOS package" )
+ onos1_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS1_ip )
+ onos2_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS2_ip )
+ onos3_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS3_ip )
+ onos_install_result = onos1_install_result and onos2_install_result and onos3_install_result
+ if onos_install_result == main.TRUE:
+ main.log.report( "Installing ONOS package successful" )
+ else:
+ main.log.report( "Installing ONOS package failed" )
+
+ onos1_isup = main.ONOSbench.isup( ONOS1_ip )
+ onos2_isup = main.ONOSbench.isup( ONOS2_ip )
+ onos3_isup = main.ONOSbench.isup( ONOS3_ip )
+ onos_isup = onos1_isup and onos2_isup and onos3_isup
+ if onos_isup == main.TRUE:
+ main.log.report( "ONOS instances are up and ready" )
+ else:
+ main.log.report( "ONOS instances may not be up" )
+
+ main.step( "Starting ONOS service" )
+ start_result = main.TRUE
+ #start_result = main.ONOSbench.onos_start( ONOS1_ip )
+ startcli1 = main.ONOScli1.start_onos_cli( ONOS_ip=ONOS1_ip )
+ startcli2 = main.ONOScli2.start_onos_cli( ONOS_ip=ONOS2_ip )
+ startcli3 = main.ONOScli3.start_onos_cli( ONOS_ip=ONOS3_ip )
+ print startcli1
+ print startcli2
+ print startcli3
+
+ case1_result = ( package_result and
+ cell_result and verify_result and onos_install_result and
+ onos_isup and start_result )
+ utilities.assert_equals( expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful" )
+
+ def CASE11( self, main ):
+ """
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ """
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Cleaning up test environment" )
+
+ main.step( "Testing ONOS kill function" )
+ kill_result1 = main.ONOSbench.onos_kill( ONOS1_ip )
+ kill_result2 = main.ONOSbench.onos_kill( ONOS2_ip )
+ kill_result3 = main.ONOSbench.onos_kill( ONOS3_ip )
+
+ main.step( "Stopping ONOS service" )
+ stop_result1 = main.ONOSbench.onos_stop( ONOS1_ip )
+ stop_result2 = main.ONOSbench.onos_stop( ONOS2_ip )
+ stop_result3 = main.ONOSbench.onos_stop( ONOS3_ip )
+
+ main.step( "Uninstalling ONOS service" )
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ def CASE3( self, main ):
+ """
+ Test 'onos' command and its functionality in driver
+ """
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Testing 'onos' command" )
+
+ main.step( "Sending command 'onos -w <onos-ip> system:name'" )
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result1 )
+ cmd_result2 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result2 )
+ cmd_result3 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result3 )
+
+ main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
+ cmdstr2 = "onos:topology"
+ cmd_result4 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result4 )
+ cmd_result5 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result5 )
+ cmd_result6 = main.ONOSbench.onos_cli( ONOS6_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result6 )
+
+ def CASE4( self, main ):
+ import re
+ import time
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+ ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+
+ main.log.report(
+ "This testcase is testing the assignment of all the switches to all controllers and discovering the hosts in reactive mode" )
+ main.log.report( "__________________________________" )
+ main.case( "Pingall Test(No intents are added)" )
+ main.step( "Assigning switches to controllers" )
+ for i in range( 1, 29 ): # 1 to ( num of switches +1 )
+ main.Mininet1.assign_sw_controller(
+ sw=str( i ),
+ count=3,
+ ip1=ONOS1_ip,
+ port1=ONOS1_port,
+ ip2=ONOS2_ip,
+ port2=ONOS2_port,
+ ip3=ONOS3_ip,
+ port3=ONOS3_port )
+
+ switch_mastership = main.TRUE
+ for i in range( 1, 29 ):
+ response = main.Mininet1.get_sw_controller( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1_ip, response ):
+ switch_mastership = switch_mastership and main.TRUE
+ else:
+ switch_mastership = main.FALSE
+
+ if switch_mastership == main.TRUE:
+ main.log.report( "Controller assignment successfull" )
+ else:
+ main.log.report( "Controller assignment failed" )
+ # REACTIVE FWD test
+ main.step( "Pingall" )
+ ping_result = main.FALSE
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % ( time2 - time1 )
+
+ case4_result = switch_mastership and ping_result
+ if ping_result == main.TRUE:
+ main.log.report(
+ "Pingall Test in reactive mode to discover the hosts successful" )
+ else:
+ main.log.report(
+ "Pingall Test in reactive mode to discover the hosts failed" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case4_result,
+ onpass="Controller assignment and Pingall Test successful",
+ onfail="Controller assignment and Pingall Test NOT successful" )
+
+ def CASE5( self, main ):
+ import json
+ from subprocess import Popen, PIPE
+ # assumes that sts is already in you PYTHONPATH
+ from sts.topology.teston_topology import TestONTopology
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.log.report(
+ "This testcase is testing if all ONOS nodes are in topology sync with mininet and its peer ONOS nodes" )
+ main.log.report( "__________________________________" )
+ main.case(
+ "Testing Mininet topology with the topology of multi instances ONOS" )
+ main.step( "Collecting topology information from ONOS" )
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ # print "devices1 = ", devices1
+ # print "devices2 = ", devices2
+ # print "devices3 = ", devices3
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ # print "hosts1 = ", hosts1
+ # print "hosts2 = ", hosts2
+ # print "hosts3 = ", hosts3
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ # print "ports1 = ", ports1
+ # print "ports2 = ", ports2
+ # print "ports3 = ", ports3
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+ # print "links1 = ", links1
+ # print "links2 = ", links2
+ # print "links3 = ", links3
+
+ print "**************"
+
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+
+ switches_results1 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices1 ) )
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
+
+ switches_results2 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
+
+ switches_results3 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect" )
+
+ """
+ ports_results1 = main.Mininet1.compare_ports( MNTopo, json.loads( ports1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect" )
+
+ ports_results2 = main.Mininet1.compare_ports( MNTopo, json.loads( ports2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect" )
+
+ ports_results3 = main.Mininet1.compare_ports( MNTopo, json.loads( ports3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect" )
+ """
+ links_results1 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
+
+ links_results2 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ links_results3 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ #topo_result = switches_results1 and switches_results2 and switches_results3\
+ # and ports_results1 and ports_results2 and ports_results3\
+ # and links_results1 and links_results2 and links_results3
+
+ topo_result = switches_results1 and switches_results2 and switches_results3\
+ and links_results1 and links_results2 and links_results3
+
+ if topo_result == main.TRUE:
+ main.log.report(
+ "Topology Check Test with mininet and ONOS instances successful" )
+ else:
+ main.log.report(
+ "Topology Check Test with mininet and ONOS instances failed" )
+
+ utilities.assert_equals( expect=main.TRUE, actual=topo_result,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
+
+ def CASE10( self ):
+ main.log.report(
+ "This testcase uninstalls the reactive forwarding app" )
+ main.log.report( "__________________________________" )
+ main.case( "Uninstalling reactive forwarding app" )
+ # Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall(
+ "onos-app-fwd" )
+ appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ "onos-app-fwd" )
+ appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ "onos-app-fwd" )
+ main.log.info( "onos-app-fwd uninstalled" )
+
+ # After reactive forwarding is disabled, the reactive flows on switches timeout in 10-15s
+ # So sleep for 15s
+ time.sleep( 15 )
+
+ hosts = main.ONOScli1.hosts()
+ main.log.info( hosts )
+
+ case10_result = appUninstall_result1 and appUninstall_result2 and appUninstall_result3
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case10_result,
+ onpass="Reactive forwarding app uninstallation successful",
+ onfail="Reactive forwarding app uninstallation failed" )
+
+ def CASE6( self ):
+ main.log.report(
+ "This testcase is testing the addition of host intents and then doing pingall" )
+ main.log.report( "__________________________________" )
+ main.case( "Obtaining hostsfor adding host intents" )
+ main.step( "Get hosts" )
+ hosts = main.ONOScli1.hosts()
+ main.log.info( hosts )
+
+ main.step( "Get all devices id" )
+ devices_id_list = main.ONOScli1.get_all_devices_id()
+ main.log.info( devices_id_list )
+
+ # ONOS displays the hosts in hex format unlike mininet which does in decimal format
+ # So take care while adding intents
+
+ """
+ main.step( "Add host intents for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent( "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+ """
+ for i in range( 8, 18 ):
+ main.log.info(
+ "Adding host intent between h" + str( i ) + " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ # NOTE: get host can return None
+ # TODO: handle this
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ tmp_result = main.ONOScli1.add_host_intent( host1_id, host2_id )
+
+ flowHandle = main.ONOScli1.flows()
+ # print "flowHandle = ", flowHandle
+ main.log.info( "flows:" + flowHandle )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Host intents have not ben installed correctly. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report( "Host intents have been installed correctly" )
+
+ case6_result = Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case6_result,
+ onpass="Host intent addition and Pingall Test successful",
+ onfail="Host intent addition and Pingall Test NOT successful" )
+
+ def CASE7( self, main ):
+
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+
+ main.log.report(
+ "This testscase is killing a link to ensure that link discovery is consistent" )
+ main.log.report( "__________________________________" )
+ main.case(
+ "Killing a link to Ensure that Link Discovery is Working Properly" )
+ main.step( "Start continuous pings" )
+
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Determine the current number of switches and links" )
+ topology_output = main.ONOScli1.topology()
+ topology_result = main.ONOSbench.get_topology( topology_output )
+ activeSwitches = topology_result[ 'devices' ]
+ links = topology_result[ 'links' ]
+ print "activeSwitches = ", type( activeSwitches )
+ print "links = ", type( links )
+ main.log.info(
+ "Currently there are %s switches and %s links" %
+ ( str( activeSwitches ), str( links ) ) )
+
+ main.step( "Kill Link between s3 and s28" )
+ main.Mininet1.link( END1="s3", END2="s28", OPTION="down" )
+ time.sleep( link_sleep )
+ topology_output = main.ONOScli2.topology()
+ Link_Down = main.ONOSbench.check_status(
+ topology_output, activeSwitches, str(
+ int( links ) - 2 ) )
+ if Link_Down == main.TRUE:
+ main.log.report( "Link Down discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=Link_Down,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in " +
+ str( link_sleep ) +
+ " seconds" )
+
+ main.step( "Bring link between s3 and s28 back up" )
+ Link_Up = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
+ time.sleep( link_sleep )
+ topology_output = main.ONOScli2.topology()
+ Link_Up = main.ONOSbench.check_status(
+ topology_output,
+ activeSwitches,
+ str( links ) )
+ if Link_Up == main.TRUE:
+ main.log.report( "Link up discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=Link_Up,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in " +
+ str( link_sleep ) +
+ " seconds" )
+
+ main.step( "Compare ONOS Topology to MN Topology" )
+ main.case(
+ "Testing Mininet topology with the topology of multi instances ONOS" )
+ main.step( "Collecting topology information from ONOS" )
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ print "devices1 = ", devices1
+ print "devices2 = ", devices2
+ print "devices3 = ", devices3
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ # print "hosts1 = ", hosts1
+ # print "hosts2 = ", hosts2
+ # print "hosts3 = ", hosts3
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ # print "ports1 = ", ports1
+ # print "ports2 = ", ports2
+ # print "ports3 = ", ports3
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+ # print "links1 = ", links1
+ # print "links2 = ", links2
+ # print "links3 = ", links3
+
+ print "**************"
+
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+
+ switches_results1 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices1 ) )
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
+
+ switches_results2 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
+
+ switches_results3 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect" )
+
+ """
+ ports_results1 = main.Mininet1.compare_ports( MNTopo, json.loads( ports1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect" )
+
+ ports_results2 = main.Mininet1.compare_ports( MNTopo, json.loads( ports2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect" )
+
+ ports_results3 = main.Mininet1.compare_ports( MNTopo, json.loads( ports3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect" )
+ """
+ links_results1 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
+
+ links_results2 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ links_results3 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ #topo_result = switches_results1 and switches_results2 and switches_results3\
+ # and ports_results1 and ports_results2 and ports_results3\
+ # and links_results1 and links_results2 and links_results3
+
+ topo_result = switches_results1 and switches_results2 and switches_results3\
+ and links_results1 and links_results2 and links_results3
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=topo_result and Link_Up and Link_Down,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
+
+ def CASE8( self ):
+ """
+ Intent removal
+ """
+ main.log.report(
+ "This testcase removes host any previously added intents" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Removing any previously installed intents" )
+ main.case( "Removing intents" )
+ main.step( "Obtain the intent id's" )
+ intent_result = main.ONOScli1.intents( json_format=False )
+
+ intent_linewise = intent_result.split( "\n" )
+ intentList = []
+ for line in intent_linewise:
+ if line.startswith( "id=" ):
+ intentList.append( line )
+
+ intentids = []
+ for line in intentList:
+ intentids.append( line.split( "," )[ 0 ].split( "=" )[ 1 ] )
+ for id in intentids:
+ main.log.info( "id = " + id )
+
+ main.step(
+ "Iterate through the intentids list and remove each intent" )
+ for id in intentids:
+ main.ONOScli1.remove_intent( intent_id=id )
+
+ intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intent_result = " + intent_result )
+ case8_result = main.TRUE
+
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.TRUE:
+ i = 19
+ Ping_Result = main.TRUE
+ elif ping == main.FALSE:
+ i += 1
+ Ping_Result = main.FALSE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ # Note: If the ping result failed, that means the intents have been
+ # withdrawn correctly.
+ if Ping_Result == main.TRUE:
+ main.log.report( "Host intents have not been withdrawn correctly" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.FALSE:
+ main.log.report( "Host intents have been withdrawn correctly" )
+
+ case8_result = case8_result and Ping_Result
+
+ if case8_result == main.FALSE:
+ main.log.report( "Intent removal successful" )
+ else:
+ main.log.report( "Intent removal failed" )
+
+ utilities.assert_equals( expect=main.FALSE, actual=case8_result,
+ onpass="Intent removal test failed",
+ onfail="Intent removal test successful" )
+
+ def CASE9( self ):
+ """
+ This test case adds point intents. Make sure you run test case 8 which is host intent removal before executing this test case.
+ Else the host intent's flows will persist on switches and the pings would work even if there is some issue with the point intent's flows
+ """
+ main.log.report(
+ "This testcase adds point intents and then does pingall" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Adding point intents" )
+ main.case(
+ "Adding bidirectional point for mn hosts(h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,h15-h25,h16-h26,h17-h27)" )
+ main.step(
+ "Add point-to-point intents for mininet hosts h8 and h18 or ONOS hosts h8 and h12" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003008/1",
+ "of:0000000000006018/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006018/1",
+ "of:0000000000003008/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h9 and h19 or ONOS hosts h9 and h13" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003009/1",
+ "of:0000000000006019/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006019/1",
+ "of:0000000000003009/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h10 and h20 or ONOS hosts hA and h14" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003010/1",
+ "of:0000000000006020/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006020/1",
+ "of:0000000000003010/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h11 and h21 or ONOS hosts hB and h15" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003011/1",
+ "of:0000000000006021/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006021/1",
+ "of:0000000000003011/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h12 and h22 or ONOS hosts hC and h16" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003012/1",
+ "of:0000000000006022/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006022/1",
+ "of:0000000000003012/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h13 and h23 or ONOS hosts hD and h17" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003013/1",
+ "of:0000000000006023/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006023/1",
+ "of:0000000000003013/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h14 and h24 or ONOS hosts hE and h18" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003014/1",
+ "of:0000000000006024/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006024/1",
+ "of:0000000000003014/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h15 and h25 or ONOS hosts hF and h19" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003015/1",
+ "of:0000000000006025/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006025/1",
+ "of:0000000000003015/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h16 and h26 or ONOS hosts h10 and h1A" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003016/1",
+ "of:0000000000006026/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006026/1",
+ "of:0000000000003016/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step(
+ "Add point-to-point intents for mininet hosts h17 and h27 or ONOS hosts h11 and h1B" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003017/1",
+ "of:0000000000006027/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006027/1",
+ "of:0000000000003017/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ print(
+ "_______________________________________________________________________________________" )
+
+ flowHandle = main.ONOScli1.flows()
+ # print "flowHandle = ", flowHandle
+ main.log.info( "flows :" + flowHandle )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Ping all test after Point intents addition failed. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report(
+ "Ping all test after Point intents addition successful" )
+
+ case8_result = Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case8_result,
+ onpass="Ping all test after Point intents addition successful",
+ onfail="Ping all test after Point intents addition failed" )
+
+ def CASE31( self ):
+ """
+ This test case adds point intent related to SDN-IP matching on ICMP ( ethertype=IPV4, ipProto=1 )
+ """
+ import json
+
+ main.log.report(
+ "This test case adds point intent related to SDN-IP matching on ICMP" )
+ main.case(
+ "Adding bidirectional point intent related to SDN-IP matching on ICMP" )
+ main.step( "Adding bidirectional point intent" )
+ # add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+ # --ethType=IPV4 --ipProto=1 of:0000000000003008/1
+ # of:0000000000006018/1
+
+ hosts_json = json.loads( main.ONOScli1.hosts() )
+ for i in range( 8, 11 ):
+ main.log.info(
+ "Adding point intent between h" + str( i ) + " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ for host in hosts_json:
+ if host[ 'id' ] == host1_id:
+ ip1 = host[ 'ips' ][ 0 ]
+ ip1 = str( ip1 + "/32" )
+ device1 = host[ 'location' ][ 'device' ]
+ device1 = str( device1 + "/1" )
+ elif host[ 'id' ] == host2_id:
+ ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+ device2 = host[ 'location' ][ "device" ]
+ device2 = str( device2 + "/1" )
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+
+ p_intent_result2 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+ if ( p_intent_result1 and p_intent_result2 ) == main.TRUE:
+ #get_intent_result = main.ONOScli1.intents()
+ # main.log.info( get_intent_result )
+ main.log.info(
+ "Point intent related to SDN-IP matching on ICMP install successful" )
+
+ time.sleep( 15 )
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intents = " + get_intent_result )
+ get_flows_result = main.ONOScli1.flows()
+ main.log.info( "flows = " + get_flows_result )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 11:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 3:
+ count += 1
+ #i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Ping test after Point intents related to SDN-IP matching on ICMP failed." )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report(
+ "Ping all test after Point intents related to SDN-IP matching on ICMP successful" )
+
+ case31_result = Ping_Result and p_intent_result1 and p_intent_result2
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case31_result,
+ onpass="Point intent related to SDN-IP matching on ICMP and ping test successful",
+ onfail="Point intent related to SDN-IP matching on ICMP and ping test failed" )
+
+ def CASE32( self ):
+ """
+ This test case adds point intent related to SDN-IP matching on TCP ( ethertype=IPV4, ipProto=6, DefaultPort for iperf=5001 )
+ Note: Although BGP port is 179, we are using 5001 because iperf is used for verifying and iperf's default port is 5001
+ """
+ import json
+
+ main.log.report(
+ "This test case adds point intent related to SDN-IP matching on TCP" )
+ main.case(
+ "Adding bidirectional point intent related to SDN-IP matching on TCP" )
+ main.step( "Adding bidirectional point intent" )
+ """
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001 of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpDst=5001 of:0000000000006018/1 of:0000000000003008/1
+
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001 of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32 --ethType=IPV4 --ipProto=6 --tcpSrc=5001 of:0000000000006018/1 of:0000000000003008/1
+
+ """
+ hosts_json = json.loads( main.ONOScli1.hosts() )
+ for i in range( 8, 9 ):
+ main.log.info(
+ "Adding point intent between h" + str( i ) + " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ for host in hosts_json:
+ if host[ 'id' ] == host1_id:
+ ip1 = host[ 'ips' ][ 0 ]
+ ip1 = str( ip1 + "/32" )
+ device1 = host[ 'location' ][ 'device' ]
+ device1 = str( device1 + "/1" )
+ elif host[ 'id' ] == host2_id:
+ ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+ device2 = host[ 'location' ][ "device" ]
+ device2 = str( device2 + "/1" )
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+ p_intent_result2 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+
+ p_intent_result3 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+ p_intent_result4 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+
+ p_intent_result = p_intent_result1 and p_intent_result2 and p_intent_result3 and p_intent_result4
+ if p_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+ main.log.info(
+ "Point intent related to SDN-IP matching on TCP install successful" )
+
+ iperf_result = main.Mininet1.iperf( 'h8', 'h18' )
+ if iperf_result == main.TRUE:
+ main.log.report( "iperf test successful" )
+ else:
+ main.log.report( "iperf test failed" )
+
+ case32_result = p_intent_result and iperf_result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case32_result,
+ onpass="Ping all test after Point intents addition related to SDN-IP on TCP match successful",
+ onfail="Ping all test after Point intents addition related to SDN-IP on TCP match failed" )
+
+ def CASE33( self ):
+ """
+ This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and the action is to rewrite the mac address
+ Here the mac address to be rewritten is the mac address of the egress device
+ """
+ import json
+ import time
+
+ main.log.report(
+ "This test case adds multipoint to singlepoint intent related to SDN-IP matching on destination ip and rewrite mac address action" )
+ main.case(
+ "Adding multipoint to singlepoint intent related to SDN-IP matching on destination ip" )
+ main.step( "Adding bidirectional multipoint to singlepoint intent" )
+ """
+ add-multi-to-single-intent --ipDst=10.0.3.0/24 --setEthDst=00:00:00:00:00:12 of:0000000000003008/1 0000000000003009/1 of:0000000000006018/1
+
+ add-multi-to-single-intent --ipDst=10.0.1.0/24 --setEthDst=00:00:00:00:00:08 of:0000000000006018/1 0000000000003009/1 of:0000000000003008/1
+ """
+ main.case(
+ "Installing multipoint to single point intent with rewrite mac address" )
+ main.step( "Uninstalling proxy arp app" )
+ # Unistall onos-app-proxyarp app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall(
+ "onos-app-proxyarp" )
+ appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ "onos-app-proxyarp" )
+ appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ "onos-app-proxyarp" )
+ main.log.info( "onos-app-proxyarp uninstalled" )
+
+ main.step( "Changing ipaddress of hosts h8,h9 and h18" )
+ main.Mininet1.changeIP(
+ host='h8',
+ intf='h8-eth0',
+ newIP='10.0.1.1',
+ newNetmask='255.255.255.0' )
+ main.Mininet1.changeIP(
+ host='h9',
+ intf='h9-eth0',
+ newIP='10.0.2.1',
+ newNetmask='255.255.255.0' )
+ main.Mininet1.changeIP(
+ host='h10',
+ intf='h10-eth0',
+ newIP='10.0.3.1',
+ newNetmask='255.255.255.0' )
+
+ main.step( "Changing default gateway of hosts h8,h9 and h18" )
+ main.Mininet1.changeDefaultGateway( host='h8', newGW='10.0.1.254' )
+ main.Mininet1.changeDefaultGateway( host='h9', newGW='10.0.2.254' )
+ main.Mininet1.changeDefaultGateway( host='h10', newGW='10.0.3.254' )
+
+ main.step(
+ "Assigning random mac address to the default gateways since proxyarp app is uninstalled" )
+ main.Mininet1.addStaticMACAddress(
+ host='h8',
+ GW='10.0.1.254',
+ macaddr='00:00:00:00:11:11' )
+ main.Mininet1.addStaticMACAddress(
+ host='h9',
+ GW='10.0.2.254',
+ macaddr='00:00:00:00:22:22' )
+ main.Mininet1.addStaticMACAddress(
+ host='h10',
+ GW='10.0.3.254',
+ macaddr='00:00:00:00:33:33' )
+
+ main.step( "Verify static gateway and MAC address assignment" )
+ main.Mininet1.verifyStaticGWandMAC( host='h8' )
+ main.Mininet1.verifyStaticGWandMAC( host='h9' )
+ main.Mininet1.verifyStaticGWandMAC( host='h10' )
+
+ main.step( "Adding multipoint to singlepoint intent" )
+ p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+ ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+ ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+ ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip1' ],
+ setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac1' ] )
+
+ p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+ ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+ ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+ ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip2' ],
+ setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac2' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intents = " + get_intent_result )
+
+ time.sleep( 10 )
+ get_flows_result = main.ONOScli1.flows( json_format=False )
+ main.log.info( "flows = " + get_flows_result )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+
+ main.log.info( "\n\nh" + str( i ) + " is Pinging h" + str( i + 2 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 2 ) )
+ if ping == main.FALSE and count < 3:
+ count += 1
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 2 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 2 ) +
+ "passed!" )
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ if Ping_Result == main.FALSE:
+ main.log.report( "Ping test failed." )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report( "Ping all successful" )
+
+ p_intent_result = p_intent_result1 and p_intent_result2
+ if p_intent_result == main.TRUE:
+ main.log.info(
+ "Multi point intent with rewrite mac address installation successful" )
+ else:
+ main.log.info(
+ "Multi point intent with rewrite mac address installation failed" )
+
+ case33_result = p_intent_result and Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case33_result,
+ onpass="Ping all test after multipoint to single point intent addition with rewrite mac address successful",
+ onfail="Ping all test after multipoint to single point intent addition with rewrite mac address failed" )
diff --git a/TestON/tests/MultiProd/MultiProd.params b/TestON/tests/MultiProd/MultiProd.params
index 8bf1600..6e5c85e 100755
--- a/TestON/tests/MultiProd/MultiProd.params
+++ b/TestON/tests/MultiProd/MultiProd.params
@@ -1,6 +1,6 @@
<PARAMS>
- <testcases>1,4,10,5,6,7,8,6,8,9,31,32,8,33</testcases>
+ <testcases>1,4,10,5,6,7,8,6,8,9,8,31,32,8,33,8</testcases>
#Environment variables
<ENV>
diff --git a/TestON/tests/MultiProd/MultiProd.py b/TestON/tests/MultiProd/MultiProd.py
index ea61a25..d3ed757 100644
--- a/TestON/tests/MultiProd/MultiProd.py
+++ b/TestON/tests/MultiProd/MultiProd.py
@@ -11,7 +11,6 @@
time.sleep( 1 )
-
class MultiProd:
def __init__( self ):
@@ -53,8 +52,8 @@
main.step( "Removing raft logs before a clen installation of ONOS" )
removeLogResult = main.ONOSbench.onosRemoveRaftLogs()
- main.step( "Git checkout and pull master and get version" )
- main.ONOSbench.gitCheckout( "master" )
+ main.step( "Git checkout, pull and get version" )
+ #main.ONOSbench.gitCheckout( "master" )
gitPullResult = main.ONOSbench.gitPull()
print "git_pull_result = ", gitPullResult
versionResult = main.ONOSbench.getVersion( report=True )
@@ -514,7 +513,6 @@
tmpResult = main.ONOScli1.addHostIntent( host1Id, host2Id )
flowHandle = main.ONOScli1.flows()
- # print "flowHandle = ", flowHandle
main.log.info( "flows:" + flowHandle )
count = 1
@@ -857,7 +855,7 @@
Intent removal
"""
main.log.report(
- "This testcase removes host any previously added intents" )
+ "This testcase removes any previously added intents" )
main.log.report( "__________________________________" )
main.log.info( "Removing any previously installed intents" )
main.case( "Removing intents" )
@@ -1424,9 +1422,13 @@
if pIntentResult == main.TRUE:
getIntentResult = main.ONOScli1.intents( jsonFormat=False )
main.log.info( getIntentResult )
- main.log.info(
+ main.log.report(
"Point intent related to SDN-IP matching" +
" on TCP install successful" )
+ else:
+ main.log.report(
+ "Point intent related to SDN-IP matching" +
+ " on TCP install failed" )
iperfResult = main.Mininet1.iperf( 'h8', 'h18' )
if iperfResult == main.TRUE:
diff --git a/TestON/tests/MultiProd/MultiProd.py.fixed b/TestON/tests/MultiProd/MultiProd.py.fixed
new file mode 100644
index 0000000..e0e772a
--- /dev/null
+++ b/TestON/tests/MultiProd/MultiProd.py.fixed
@@ -0,0 +1,1566 @@
+
+# Testing the basic functionality of ONOS Next
+# For sanity and driver functionality excercises only.
+
+import time
+import json
+
+time.sleep( 1 )
+
+
+class MultiProd:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE1( self, main ):
+ """
+ Startup sequence:
+ cell <name>
+ onos-verify-cell
+ onos-remove-raft-logs
+ git pull
+ mvn clean install
+ onos-package
+ onos-install -f
+ onos-wait-for-start
+ """
+ cell_name = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Setting up test environment" )
+ main.log.report(
+ "This testcase is testing setting up test environment" )
+ main.log.report( "__________________________________" )
+
+ main.step( "Applying cell variable to environment" )
+ cell_result1 = main.ONOSbench.set_cell( cell_name )
+ # cell_result2 = main.ONOScli1.set_cell( cell_name )
+ # cell_result3 = main.ONOScli2.set_cell( cell_name )
+ # cell_result4 = main.ONOScli3.set_cell( cell_name )
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result = cell_result1
+
+ main.step( "Removing raft logs before a clen installation of ONOS" )
+ main.ONOSbench.onos_remove_raft_logs()
+
+ main.step( "Git checkout and pull master and get version" )
+ main.ONOSbench.git_checkout( "master" )
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ main.ONOSbench.get_version( report=True )
+
+ if git_pull_result == 1:
+ main.step( "Using mvn clean & install" )
+ main.ONOSbench.clean_install()
+
+ main.step( "Creating ONOS package" )
+ package_result = main.ONOSbench.onos_package()
+
+ # main.step( "Creating a cell" )
+ # cell_create_result = main.ONOSbench.create_cell_file( **************
+ # )
+
+ main.step( "Installing ONOS package" )
+ onos1_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS1_ip )
+ onos2_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS2_ip )
+ onos3_install_result = main.ONOSbench.onos_install(
+ options="-f",
+ node=ONOS3_ip )
+ onos_install_result = onos1_install_result and onos2_install_result \
+ and onos3_install_result
+ if onos_install_result == main.TRUE:
+ main.log.report( "Installing ONOS package successful" )
+ else:
+ main.log.report( "Installing ONOS package failed" )
+
+ onos1_isup = main.ONOSbench.isup( ONOS1_ip )
+ onos2_isup = main.ONOSbench.isup( ONOS2_ip )
+ onos3_isup = main.ONOSbench.isup( ONOS3_ip )
+ onos_isup = onos1_isup and onos2_isup and onos3_isup
+ if onos_isup == main.TRUE:
+ main.log.report( "ONOS instances are up and ready" )
+ else:
+ main.log.report( "ONOS instances may not be up" )
+
+ main.step( "Starting ONOS service" )
+ start_result = main.TRUE
+ # start_result = main.ONOSbench.onos_start( ONOS1_ip )
+ startcli1 = main.ONOScli1.start_onos_cli( ONOS_ip=ONOS1_ip )
+ startcli2 = main.ONOScli2.start_onos_cli( ONOS_ip=ONOS2_ip )
+ startcli3 = main.ONOScli3.start_onos_cli( ONOS_ip=ONOS3_ip )
+ print startcli1
+ print startcli2
+ print startcli3
+
+ case1_result = ( package_result and cell_result and
+ verify_result and onos_install_result
+ and onos_isup and start_result )
+ utilities.assert_equals( expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful" )
+
+ def CASE11( self, main ):
+ """
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ """
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Cleaning up test environment" )
+
+ main.step( "Testing ONOS kill function" )
+ kill_result1 = main.ONOSbench.onos_kill( ONOS1_ip )
+ kill_result2 = main.ONOSbench.onos_kill( ONOS2_ip )
+ kill_result3 = main.ONOSbench.onos_kill( ONOS3_ip )
+ kill_result = kill_result1 and kill_result2 and kill_result3
+
+ main.step( "Stopping ONOS service" )
+ stop_result1 = main.ONOSbench.onos_stop( ONOS1_ip )
+ stop_result2 = main.ONOSbench.onos_stop( ONOS2_ip )
+ stop_result3 = main.ONOSbench.onos_stop( ONOS3_ip )
+ stop_result = stop_result1 and stop_result2 and stop_result3
+
+ main.step( "Uninstalling ONOS service" )
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ case11_result = kill_result and stop_result and uninstall_result
+ utilities.assert_equals( expect=main.TRUE, actual=case11_result,
+ onpass="Cleanup successful",
+ onfail="Cleanup failed" )
+
+ def CASE3( self, main ):
+ """
+ Test 'onos' command and its functionality in driver
+ """
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+
+ main.case( "Testing 'onos' command" )
+
+ main.step( "Sending command 'onos -w <onos-ip> system:name'" )
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result1 )
+ cmd_result2 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result2 )
+ cmd_result3 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmd_result3 )
+
+ main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
+ cmdstr2 = "onos:topology"
+ cmd_result4 = main.ONOSbench.onos_cli( ONOS1_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result4 )
+ cmd_result5 = main.ONOSbench.onos_cli( ONOS2_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result5 )
+ cmd_result6 = main.ONOSbench.onos_cli( ONOS3_ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmd_result6 )
+
+ def CASE4( self, main ):
+ import re
+ import time
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
+ ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
+ ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
+ ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
+ ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
+
+ main.log.report(
+ "This testcase is testing the assignment of all the switches to \
+ all controllers and discovering the hosts in reactive mode" )
+ main.log.report( "__________________________________" )
+ main.case( "Pingall Test(No intents are added)" )
+ main.step( "Assigning switches to controllers" )
+ for i in range( 1, 29 ): # 1 to ( num of switches +1 )
+ main.Mininet1.assign_sw_controller(
+ sw=str( i ),
+ count=3,
+ ip1=ONOS1_ip,
+ port1=ONOS1_port,
+ ip2=ONOS2_ip,
+ port2=ONOS2_port,
+ ip3=ONOS3_ip,
+ port3=ONOS3_port )
+
+ switch_mastership = main.TRUE
+ for i in range( 1, 29 ):
+ response = main.Mininet1.get_sw_controller( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1_ip, response ):
+ switch_mastership = switch_mastership and main.TRUE
+ else:
+ switch_mastership = main.FALSE
+
+ if switch_mastership == main.TRUE:
+ main.log.report( "Controller assignment successfull" )
+ else:
+ main.log.report( "Controller assignment failed" )
+ # REACTIVE FWD test
+ main.step( "Pingall" )
+ ping_result = main.FALSE
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % ( time2 - time1 )
+
+ case4_result = switch_mastership and ping_result
+ if ping_result == main.TRUE:
+ main.log.report( "Pingall Test in reactive mode to discover \
+ the hosts successful" )
+ else:
+ main.log.report( "Pingall Test in reactive mode to discover \
+ the hosts failed" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case4_result,
+ onpass="Controller assignment and Pingall Test successful",
+ onfail="Controller assignment and Pingall Test NOT successful" )
+
+ def CASE5( self, main ):
+ import json
+ from subprocess import Popen, PIPE
+ # assumes that sts is already in you PYTHONPATH
+ from sts.topology.teston_topology import TestONTopology
+
+ main.log.report( "This testcase is testing if all ONOS nodes are in \
+ topology sync with mininet and its peer ONOS nodes" )
+ main.log.report( "__________________________________" )
+ main.case(
+ "Testing Mininet topology with the topology \
+ of multi instances ONOS" )
+ main.step( "Collecting topology information from ONOS" )
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+
+ switches_results1 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices1 ) )
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
+
+ switches_results2 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
+
+ switches_results3 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect" )
+
+ ports_results1 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect" )
+
+ ports_results2 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect" )
+
+ ports_results3 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect" )
+
+ links_results1 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
+
+ links_results2 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ links_results3 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ topo_result = switches_results1 and switches_results2 and \
+ switches_results3\
+ and ports_results1 and ports_results2 and ports_results3\
+ and links_results1 and links_results2 and links_results3
+
+ '''
+ topo_result = switches_results1 and switches_results2 and \
+ switches_results3 and links_results1 and \
+ links_results2 and links_results3
+ '''
+
+ if topo_result == main.TRUE:
+ main.log.report(
+ "Topology Check Test with mininet and \
+ ONOS instances successful" )
+ else:
+ main.log.report(
+ "Topology Check Test with mininet and \
+ ONOS instances failed" )
+
+ utilities.assert_equals( expect=main.TRUE, actual=topo_result,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
+
+ def CASE10( self ):
+ main.log.report(
+ "This testcase uninstalls the reactive forwarding app" )
+ main.log.report( "__________________________________" )
+ main.case( "Uninstalling reactive forwarding app" )
+ # Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall(
+ "onos-app-fwd" )
+ appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ "onos-app-fwd" )
+ appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ "onos-app-fwd" )
+ main.log.info( "onos-app-fwd uninstalled" )
+
+ # After reactive forwarding is disabled,
+ # the reactive flows on switches timeout in 10-15s
+ # So sleep for 15s
+ time.sleep( 15 )
+
+ hosts = main.ONOScli1.hosts()
+ main.log.info( hosts )
+
+ case10_result = appUninstall_result1 and appUninstall_result2 and \
+ appUninstall_result3
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case10_result,
+ onpass="Reactive forwarding app uninstallation successful",
+ onfail="Reactive forwarding app uninstallation failed" )
+
+ def CASE6( self ):
+ main.log.report(
+ "This testcase is testing the addition of host intents and \
+ then doing pingall" )
+ main.log.report( "__________________________________" )
+ main.case( "Obtaining hostsfor adding host intents" )
+ main.step( "Get hosts" )
+ hosts = main.ONOScli1.hosts()
+ main.log.info( hosts )
+
+ main.step( "Get all devices id" )
+ devices_id_list = main.ONOScli1.get_all_devices_id()
+ main.log.info( devices_id_list )
+
+ # ONOS displays the hosts in hex format unlike mininet
+ # which does in decimal format
+ # So take care while adding intents
+
+ """
+ main.step(
+ "Add host intents for mn hosts
+ (h8-h18,h9-h19,h10-h20,h11-h21,h12-h22,h13-h23,h14-h24,
+ h15-h25,h16-h26,h17-h27)" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+ hth_intent_result = main.ONOScli1.add_host_intent(
+ "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+ """
+ for i in range( 8, 18 ):
+ main.log.info(
+ "Adding host intent between h" + str( i ) +
+ " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ # NOTE: get host can return None
+ # TODO: handle this
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ tmp_result = main.ONOScli1.add_host_intent( host1_id, host2_id )
+
+ flowHandle = main.ONOScli1.flows()
+ main.log.info( "flows:" + flowHandle )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ # i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Host intents have not ben installed correctly. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report( "Host intents have been installed correctly" )
+
+ case6_result = Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case6_result,
+ onpass="Host intent addition and Pingall Test successful",
+ onfail="Host intent addition and Pingall Test NOT successful" )
+
+ def CASE7( self, main ):
+
+ from sts.topology.teston_topology import TestONTopology
+ ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+
+ main.log.report(
+ "This testscase is killing a link to ensure that \
+ link discovery is consistent" )
+ main.log.report( "__________________________________" )
+ main.case(
+ "Killing a link to ensure that \
+ Link Discovery is Working Properly" )
+ main.step( "Start continuous pings" )
+
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Determine the current number of switches and links" )
+ topology_output = main.ONOScli1.topology()
+ topology_result = main.ONOSbench.get_topology( topology_output )
+ activeSwitches = topology_result[ 'devices' ]
+ links = topology_result[ 'links' ]
+ main.log.info(
+ "Currently there are %s switches and %s links" %
+ ( str( activeSwitches ), str( links ) ) )
+
+ main.step( "Kill Link between s3 and s28" )
+ main.Mininet1.link( END1="s3", END2="s28", OPTION="down" )
+ time.sleep( link_sleep )
+ topology_output = main.ONOScli2.topology()
+ Link_Down = main.ONOSbench.check_status(
+ topology_output, activeSwitches, str(
+ int( links ) - 2 ) )
+ if Link_Down == main.TRUE:
+ main.log.report( "Link Down discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=Link_Down,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in " +
+ str( link_sleep ) +
+ " seconds" )
+
+ main.step( "Bring link between s3 and s28 back up" )
+ Link_Up = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
+ time.sleep( link_sleep )
+ topology_output = main.ONOScli2.topology()
+ Link_Up = main.ONOSbench.check_status(
+ topology_output,
+ activeSwitches,
+ str( links ) )
+ if Link_Up == main.TRUE:
+ main.log.report( "Link up discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=Link_Up,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in " +
+ str( link_sleep ) +
+ " seconds" )
+
+ main.step( "Compare ONOS Topology to MN Topology" )
+ main.case(
+ "Testing Mininet topology with the topology of \
+ multi instances ONOS" )
+ main.step( "Collecting topology information from ONOS" )
+ devices1 = main.ONOScli1.devices()
+ devices2 = main.ONOScli2.devices()
+ devices3 = main.ONOScli3.devices()
+ hosts1 = main.ONOScli1.hosts()
+ hosts2 = main.ONOScli2.hosts()
+ hosts3 = main.ONOScli3.hosts()
+ ports1 = main.ONOScli1.ports()
+ ports2 = main.ONOScli2.ports()
+ ports3 = main.ONOScli3.ports()
+ links1 = main.ONOScli1.links()
+ links2 = main.ONOScli2.links()
+ links3 = main.ONOScli3.links()
+
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+
+ switches_results1 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices1 ) )
+ print "switches_Result1 = ", switches_results1
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results1,
+ onpass="ONOS1 Switches view is correct",
+ onfail="ONOS1 Switches view is incorrect" )
+
+ switches_results2 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results2,
+ onpass="ONOS2 Switches view is correct",
+ onfail="ONOS2 Switches view is incorrect" )
+
+ switches_results3 = main.Mininet1.compare_switches(
+ MNTopo,
+ json.loads( devices3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=switches_results3,
+ onpass="ONOS3 Switches view is correct",
+ onfail="ONOS3 Switches view is incorrect" )
+
+ """
+ ports_results1 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results1,
+ onpass="ONOS1 Ports view is correct",
+ onfail="ONOS1 Ports view is incorrect" )
+
+ ports_results2 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results2,
+ onpass="ONOS2 Ports view is correct",
+ onfail="ONOS2 Ports view is incorrect" )
+
+ ports_results3 = main.Mininet1.compare_ports(
+ MNTopo, json.loads( ports3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=ports_results3,
+ onpass="ONOS3 Ports view is correct",
+ onfail="ONOS3 Ports view is incorrect" )
+ """
+ links_results1 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links1 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results1,
+ onpass="ONOS1 Links view is correct",
+ onfail="ONOS1 Links view is incorrect" )
+
+ links_results2 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links2 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results2,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ links_results3 = main.Mininet1.compare_links(
+ MNTopo,
+ json.loads( links3 ) )
+ utilities.assert_equals( expect=main.TRUE, actual=links_results3,
+ onpass="ONOS2 Links view is correct",
+ onfail="ONOS2 Links view is incorrect" )
+
+ # topo_result = switches_results1 and switches_results2 and \
+ # switches_results3 and ports_results1 and ports_results2 and \
+ # ports_results3 and links_results1 and links_results2 and \
+ # links_results3
+
+ topo_result = switches_results1 and switches_results2 \
+ and switches_results3 and links_results1 and \
+ links_results2 and links_results3
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=topo_result and Link_Up and Link_Down,
+ onpass="Topology Check Test successful",
+ onfail="Topology Check Test NOT successful" )
+
+ def CASE8( self ):
+ """
+ Intent removal
+ """
+ main.log.report(
+ "This testcase removes host any previously added intents" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Removing any previously installed intents" )
+ main.case( "Removing intents" )
+ main.step( "Obtain the intent id's" )
+ intent_result = main.ONOScli1.intents( json_format=False )
+
+ intent_linewise = intent_result.split( "\n" )
+ intentList = []
+ for line in intent_linewise:
+ if line.startswith( "id=" ):
+ intentList.append( line )
+
+ intentids = []
+ for line in intentList:
+ intentids.append( line.split( "," )[ 0 ].split( "=" )[ 1 ] )
+ for id in intentids:
+ main.log.info( "id = " + id )
+
+ main.step(
+ "Iterate through the intentids list and remove each intent" )
+ for id in intentids:
+ main.ONOScli1.remove_intent( intent_id=id )
+
+ intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intent_result = " + intent_result )
+ case8_result = main.TRUE
+
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.TRUE:
+ i = 19
+ Ping_Result = main.TRUE
+ elif ping == main.FALSE:
+ i += 1
+ Ping_Result = main.FALSE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ # Note: If the ping result failed, that means the intents have been
+ # withdrawn correctly.
+ if Ping_Result == main.TRUE:
+ main.log.report( "Host intents have not been withdrawn correctly" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.FALSE:
+ main.log.report( "Host intents have been withdrawn correctly" )
+
+ case8_result = case8_result and Ping_Result
+
+ if case8_result == main.FALSE:
+ main.log.report( "Intent removal successful" )
+ else:
+ main.log.report( "Intent removal failed" )
+
+ utilities.assert_equals( expect=main.FALSE, actual=case8_result,
+ onpass="Intent removal test failed",
+ onfail="Intent removal test successful" )
+
+ def CASE9( self ):
+ """
+ This test case adds point intents. Make sure you run test case 8
+ which is host intent removal before executing this test case.
+ Else the host intents flows will persist on switches and the ping
+ would work even if there is some issue with the point intent's flows
+ """
+ main.log.report(
+ "This testcase adds point intents and then does pingall" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Adding point intents" )
+ main.case(
+ "Adding bidirectional point for mn hosts \
+ h8-h18 h9-h19 h10-h20 h11-h21 h12-h22 h13-h23 \
+ h14-h24 h15-h25 h16-h26 h17-h27" )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h8 and h18 or ONOS hosts h8 and h12" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003008/1",
+ "of:0000000000006018/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006018/1",
+ "of:0000000000003008/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h9 and h19 or ONOS hosts h9 and h13" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003009/1",
+ "of:0000000000006019/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006019/1",
+ "of:0000000000003009/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h10 and h20 or ONOS hosts hA and h14" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003010/1",
+ "of:0000000000006020/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006020/1",
+ "of:0000000000003010/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h11 and h21 or ONOS hosts hB and h15" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003011/1",
+ "of:0000000000006021/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006021/1",
+ "of:0000000000003011/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h12 and h22 or ONOS hosts hC and h16" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003012/1",
+ "of:0000000000006022/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006022/1",
+ "of:0000000000003012/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h13 and h23 or ONOS hosts hD and h17" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003013/1",
+ "of:0000000000006023/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006023/1",
+ "of:0000000000003013/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h14 and h24 or ONOS hosts hE and h18" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003014/1",
+ "of:0000000000006024/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006024/1",
+ "of:0000000000003014/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h15 and h25 or ONOS hosts hF and h19" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003015/1",
+ "of:0000000000006025/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006025/1",
+ "of:0000000000003015/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h16 and h26 or ONOS hosts h10 and h1A" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003016/1",
+ "of:0000000000006026/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006026/1",
+ "of:0000000000003016/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ main.step( "Add point-to-point intents for mininet hosts \
+ h17 and h27 or ONOS hosts h11 and h1B" )
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000003017/1",
+ "of:0000000000006027/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ ptp_intent_result = main.ONOScli1.add_point_intent(
+ "of:0000000000006027/1",
+ "of:0000000000003017/1" )
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( get_intent_result )
+
+ print("___________________________________________________________" )
+
+ flowHandle = main.ONOScli1.flows()
+ main.log.info( "flows :" + flowHandle )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ # i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Ping all test after Point intents addition failed. \
+ Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report(
+ "Ping all test after Point intents addition successful" )
+
+ case8_result = Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case8_result,
+ onpass="Ping all test after Point intents addition successful",
+ onfail="Ping all test after Point intents addition failed" )
+
+ def CASE31( self ):
+ """
+ This test case adds point intent related to SDN-IP
+ matching on ICMP ( ethertype=IPV4, ipProto=1 )
+ """
+ import json
+
+ main.log.report(
+ '''This test case adds point intent related to SDN-IP
+ matching on ICMP''' )
+ main.case(
+ '''Adding bidirectional point intent related to SDN-IP
+ matching on ICMP''' )
+ main.step( "Adding bidirectional point intent" )
+ # add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+ # --ethType=IPV4 --ipProto=1 of:0000000000003008/1
+ # of:0000000000006018/1
+
+ hosts_json = json.loads( main.ONOScli1.hosts() )
+ for i in range( 8, 11 ):
+ main.log.info(
+ "Adding point intent between h" + str( i ) +
+ " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ for host in hosts_json:
+ if host[ 'id' ] == host1_id:
+ ip1 = host[ 'ips' ][ 0 ]
+ ip1 = str( ip1 + "/32" )
+ device1 = host[ 'location' ][ 'device' ]
+ device1 = str( device1 + "/1" )
+ elif host[ 'id' ] == host2_id:
+ ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+ device2 = host[ 'location' ][ "device" ]
+ device2 = str( device2 + "/1" )
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+
+ p_intent_result2 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'icmpProto' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+ if ( p_intent_result1 and p_intent_result2 ) == main.TRUE:
+ # get_intent_result = main.ONOScli1.intents()
+ # main.log.info( get_intent_result )
+ main.log.info(
+ '''Point intent related to SDN-IP matching on ICMP install
+ successful''' )
+
+ time.sleep( 15 )
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intents = " + get_intent_result )
+ get_flows_result = main.ONOScli1.flows()
+ main.log.info( "flows = " + get_flows_result )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+ while i < 11:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 3:
+ count += 1
+ # i = 8
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+ if Ping_Result == main.FALSE:
+ main.log.report(
+ "Ping test after Point intents related to SDN-IP \
+ matching on ICMP failed." )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report(
+ "Ping all test after Point intents related to SDN-IP \
+ matching on ICMP successful" )
+
+ case31_result = Ping_Result and p_intent_result1 and p_intent_result2
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case31_result,
+ onpass="Point intent related to SDN-IP matching on ICMP and \
+ ping test successful",
+ onfail="Point intent related to SDN-IP matching on ICMP and \
+ ping test failed" )
+
+ def CASE32( self ):
+ '''
+ This test case adds point intent related to SDN-IP matching on TCP
+ ( ethertype=IPV4, ipProto=6, DefaultPort for iperf=5001 )
+ Note: Although BGP port is 179, we are using 5001 because iperf is
+ used for verifying and iperf's default port is 5001
+ '''
+ import json
+
+ main.log.report( '''This test case adds point intent related
+ to SDN-IP matching on TCP''' )
+ main.case( '''Adding bidirectional point intent related to SDN-IP
+ matching on TCP''' )
+ main.step( "Adding bidirectional point intent" )
+
+ """
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+ --ethType=IPV4 --ipProto=6 --tcpDst=5001
+ of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32
+ --ethType=IPV4 --ipProto=6 --tcpDst=5001
+ of:0000000000006018/1 of:0000000000003008/1
+
+ add-point-intent --ipSrc=10.0.0.8/32 --ipDst=10.0.0.18/32
+ --ethType=IPV4 --ipProto=6 --tcpSrc=5001
+ of:0000000000003008/1 of:0000000000006018/1
+
+ add-point-intent --ipSrc=10.0.0.18/32 --ipDst=10.0.0.8/32
+ --ethType=IPV4 --ipProto=6 --tcpSrc=5001
+ of:0000000000006018/1 of:0000000000003008/1
+
+ """
+ hosts_json = json.loads( main.ONOScli1.hosts() )
+ for i in range( 8, 9 ):
+ main.log.info(
+ "Adding point intent between h" + str( i ) +
+ " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ host1_id = main.ONOScli1.get_host( host1 )[ 'id' ]
+ host2_id = main.ONOScli1.get_host( host2 )[ 'id' ]
+ for host in hosts_json:
+ if host[ 'id' ] == host1_id:
+ ip1 = host[ 'ips' ][ 0 ]
+ ip1 = str( ip1 + "/32" )
+ device1 = host[ 'location' ][ 'device' ]
+ device1 = str( device1 + "/1" )
+ elif host[ 'id' ] == host2_id:
+ ip2 = str( host[ 'ips' ][ 0 ] ) + "/32"
+ device2 = host[ 'location' ][ "device" ]
+ device2 = str( device2 + "/1" )
+
+ p_intent_result1 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+ p_intent_result2 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpDst=main.params[ 'SDNIP' ][ 'dstPort' ] )
+
+ p_intent_result3 = main.ONOScli1.add_point_intent(
+ ingress_device=device1,
+ egress_device=device2,
+ ipSrc=ip1,
+ ipDst=ip2,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+ p_intent_result4 = main.ONOScli1.add_point_intent(
+ ingress_device=device2,
+ egress_device=device1,
+ ipSrc=ip2,
+ ipDst=ip1,
+ ethType=main.params[ 'SDNIP' ][ 'ethType' ],
+ ipProto=main.params[ 'SDNIP' ][ 'tcpProto' ],
+ tcpSrc=main.params[ 'SDNIP' ][ 'srcPort' ] )
+
+ p_intent_result = p_intent_result1 and p_intent_result2 and \
+ p_intent_result3 and p_intent_result4
+ if p_intent_result == main.TRUE:
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( get_intent_result )
+ main.log.info( '''Point intent related to SDN-IP matching
+ on TCP install successful''' )
+
+ iperf_result = main.Mininet1.iperf( 'h8', 'h18' )
+ if iperf_result == main.TRUE:
+ main.log.report( "iperf test successful" )
+ else:
+ main.log.report( "iperf test failed" )
+
+ case32_result = p_intent_result and iperf_result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case32_result,
+ onpass="Ping all test after Point intents addition related to \
+ SDN-IP on TCP match successful",
+ onfail="Ping all test after Point intents addition related to \
+ SDN-IP on TCP match failed" )
+
+ def CASE33( self ):
+ """
+ This test case adds multipoint to singlepoint intent related
+ to SDN-IP matching on destination ip and the action is to
+ rewrite the mac address.
+ Here the mac address to be rewritten is the mac address
+ of the egress device
+ """
+ import json
+ import time
+
+ main.log.report( "This test case adds multipoint to singlepoint intent\
+ related to SDN-IP matching on destination ip and\
+ rewrite mac address action" )
+ main.case( "Adding multipoint to singlepoint intent related to SDN-IP\
+ matching on destination ip" )
+ main.step( "Adding bidirectional multipoint to singlepoint intent" )
+ """
+ add-multi-to-single-intent --ipDst=10.0.3.0/24
+ --setEthDst=00:00:00:00:00:12
+ of:0000000000003008/1 0000000000003009/1 of:0000000000006018/1
+
+ add-multi-to-single-intent --ipDst=10.0.1.0/24
+ --setEthDst=00:00:00:00:00:08
+ of:0000000000006018/1 0000000000003009/1 of:0000000000003008/1
+ """
+ main.case( "Installing multipoint to single point intent with\
+ rewrite mac address" )
+ main.step( "Uninstalling proxy arp app" )
+ # Unistall onos-app-proxyarp app to disable reactive forwarding
+ appUninstall_result1 = main.ONOScli1.feature_uninstall(
+ "onos-app-proxyarp" )
+ appUninstall_result2 = main.ONOScli2.feature_uninstall(
+ "onos-app-proxyarp" )
+ appUninstall_result3 = main.ONOScli3.feature_uninstall(
+ "onos-app-proxyarp" )
+ main.log.info( "onos-app-proxyarp uninstalled" )
+
+ main.step( "Changing ipaddress of hosts h8,h9 and h18" )
+ main.Mininet1.changeIP(
+ host='h8',
+ intf='h8-eth0',
+ newIP='10.0.1.1',
+ newNetmask='255.255.255.0' )
+ main.Mininet1.changeIP(
+ host='h9',
+ intf='h9-eth0',
+ newIP='10.0.2.1',
+ newNetmask='255.255.255.0' )
+ main.Mininet1.changeIP(
+ host='h10',
+ intf='h10-eth0',
+ newIP='10.0.3.1',
+ newNetmask='255.255.255.0' )
+
+ main.step( "Changing default gateway of hosts h8,h9 and h18" )
+ main.Mininet1.changeDefaultGateway( host='h8', newGW='10.0.1.254' )
+ main.Mininet1.changeDefaultGateway( host='h9', newGW='10.0.2.254' )
+ main.Mininet1.changeDefaultGateway( host='h10', newGW='10.0.3.254' )
+
+ main.step( "Assigning random mac address to the default gateways\
+ since proxyarp app is uninstalled" )
+ main.Mininet1.addStaticMACAddress(
+ host='h8',
+ GW='10.0.1.254',
+ macaddr='00:00:00:00:11:11' )
+ main.Mininet1.addStaticMACAddress(
+ host='h9',
+ GW='10.0.2.254',
+ macaddr='00:00:00:00:22:22' )
+ main.Mininet1.addStaticMACAddress(
+ host='h10',
+ GW='10.0.3.254',
+ macaddr='00:00:00:00:33:33' )
+
+ main.step( "Verify static gateway and MAC address assignment" )
+ main.Mininet1.verifyStaticGWandMAC( host='h8' )
+ main.Mininet1.verifyStaticGWandMAC( host='h9' )
+ main.Mininet1.verifyStaticGWandMAC( host='h10' )
+
+ main.step( "Adding multipoint to singlepoint intent" )
+ p_intent_result1 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+ ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+ ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+ ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip1' ],
+ setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac1' ] )
+
+ p_intent_result2 = main.ONOScli1.add_multipoint_to_singlepoint_intent(
+ ingress_device1=main.params[ 'MULTIPOINT_INTENT' ][ 'device3' ],
+ ingress_device2=main.params[ 'MULTIPOINT_INTENT' ][ 'device2' ],
+ egress_device=main.params[ 'MULTIPOINT_INTENT' ][ 'device1' ],
+ ipDst=main.params[ 'MULTIPOINT_INTENT' ][ 'ip2' ],
+ setEthDst=main.params[ 'MULTIPOINT_INTENT' ][ 'mac2' ] )
+
+ get_intent_result = main.ONOScli1.intents( json_format=False )
+ main.log.info( "intents = " + get_intent_result )
+
+ time.sleep( 10 )
+ get_flows_result = main.ONOScli1.flows( json_format=False )
+ main.log.info( "flows = " + get_flows_result )
+
+ count = 1
+ i = 8
+ Ping_Result = main.TRUE
+
+ main.log.info( "\n\nh" + str( i ) + " is Pinging h" + str( i + 2 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 2 ) )
+ if ping == main.FALSE and count < 3:
+ count += 1
+ Ping_Result = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 2 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ Ping_Result = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 2 ) +
+ "passed!" )
+ Ping_Result = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ Ping_Result = main.ERROR
+
+ if Ping_Result == main.FALSE:
+ main.log.report( "Ping test failed." )
+ # main.cleanup()
+ # main.exit()
+ if Ping_Result == main.TRUE:
+ main.log.report( "Ping all successful" )
+
+ p_intent_result = p_intent_result1 and p_intent_result2
+ if p_intent_result == main.TRUE:
+ main.log.info( "Multi point intent with rewrite mac address\
+ installation successful" )
+ else:
+ main.log.info( "Multi point intent with rewrite mac address\
+ installation failed" )
+
+ case33_result = p_intent_result and Ping_Result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case33_result,
+ onpass="Ping all test after multipoint to single point intent \
+ addition with rewrite mac address successful",
+ onfail="Ping all test after multipoint to single point intent \
+ addition with rewrite mac address failed" )
+
diff --git a/TestON/tests/MultiProd13/MultiProd13.params b/TestON/tests/MultiProd13/MultiProd13.params
index 8bf1600..6e5c85e 100755
--- a/TestON/tests/MultiProd13/MultiProd13.params
+++ b/TestON/tests/MultiProd13/MultiProd13.params
@@ -1,6 +1,6 @@
<PARAMS>
- <testcases>1,4,10,5,6,7,8,6,8,9,31,32,8,33</testcases>
+ <testcases>1,4,10,5,6,7,8,6,8,9,8,31,32,8,33,8</testcases>
#Environment variables
<ENV>
diff --git a/TestON/tests/MultiProd13/MultiProd13.py b/TestON/tests/MultiProd13/MultiProd13.py
index cbf27a4..d3ed757 100644
--- a/TestON/tests/MultiProd13/MultiProd13.py
+++ b/TestON/tests/MultiProd13/MultiProd13.py
@@ -11,8 +11,7 @@
time.sleep( 1 )
-
-class MultiProd13:
+class MultiProd:
def __init__( self ):
self.default = ''
@@ -53,8 +52,8 @@
main.step( "Removing raft logs before a clen installation of ONOS" )
removeLogResult = main.ONOSbench.onosRemoveRaftLogs()
- main.step( "Git checkout and pull master and get version" )
- main.ONOSbench.gitCheckout( "master" )
+ main.step( "Git checkout, pull and get version" )
+ #main.ONOSbench.gitCheckout( "master" )
gitPullResult = main.ONOSbench.gitPull()
print "git_pull_result = ", gitPullResult
versionResult = main.ONOSbench.getVersion( report=True )
@@ -514,7 +513,6 @@
tmpResult = main.ONOScli1.addHostIntent( host1Id, host2Id )
flowHandle = main.ONOScli1.flows()
- # print "flowHandle = ", flowHandle
main.log.info( "flows:" + flowHandle )
count = 1
@@ -857,7 +855,7 @@
Intent removal
"""
main.log.report(
- "This testcase removes host any previously added intents" )
+ "This testcase removes any previously added intents" )
main.log.report( "__________________________________" )
main.log.info( "Removing any previously installed intents" )
main.case( "Removing intents" )
@@ -1424,9 +1422,13 @@
if pIntentResult == main.TRUE:
getIntentResult = main.ONOScli1.intents( jsonFormat=False )
main.log.info( getIntentResult )
- main.log.info(
+ main.log.report(
"Point intent related to SDN-IP matching" +
" on TCP install successful" )
+ else:
+ main.log.report(
+ "Point intent related to SDN-IP matching" +
+ " on TCP install failed" )
iperfResult = main.Mininet1.iperf( 'h8', 'h18' )
if iperfResult == main.TRUE:
diff --git a/TestON/tests/OpticalFunc13/OpticalFunc13.params b/TestON/tests/OpticalFunc13/OpticalFunc13.params
new file mode 100755
index 0000000..173d48b
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/OpticalFunc13.params
@@ -0,0 +1,47 @@
+<PARAMS>
+
+ <testcases>1,21,22,23</testcases>
+
+ #Environment variables
+ <ENV>
+ <cellName>driver_test</cellName>
+ </ENV>
+
+ <CTRL>
+ <ip1>10.128.20.11</ip1>
+ <port1>6633</port1>
+ </CTRL>
+
+ <PING>
+ <source1>h8</source1>
+ <source2>h9</source2>
+ <source3>h10</source3>
+ <source4>h11</source4>
+ <source5>h12</source5>
+ <source6>h13</source6>
+ <source7>h14</source7>
+ <source8>h15</source8>
+ <source9>h16</source9>
+ <source10>h17</source10>
+ <target1>10.0.0.18</target1>
+ <target2>10.0.0.19</target2>
+ <target3>10.0.0.20</target3>
+ <target4>10.0.0.21</target4>
+ <target5>10.0.0.22</target5>
+ <target6>10.0.0.23</target6>
+ <target7>10.0.0.24</target7>
+ <target8>10.0.0.25</target8>
+ <target9>10.0.0.26</target9>
+ <target10>10.0.0.27</target10>
+ </PING>
+
+ <timers>
+ <LinkDiscovery>5</LinkDiscovery>
+ <SwitchDiscovery>31</SwitchDiscovery>
+ </timers>
+
+ <OPTICAL>
+ <jsonfile> /home/admin/ONOS/tools/test/topos/oe-nonlinear-4.json </jsonfile>
+ </OPTICAL>
+
+</PARAMS>
diff --git a/TestON/tests/OpticalFunc13/OpticalFunc13.py b/TestON/tests/OpticalFunc13/OpticalFunc13.py
new file mode 100755
index 0000000..7ddd532
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/OpticalFunc13.py
@@ -0,0 +1,248 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import sys
+import os
+import re
+import time
+import json
+
+time.sleep(1)
+class OpticalFunc13:
+ def __init__(self):
+ self.default = ''
+
+ def CASE1(self, main):
+ '''
+ Startup sequence:
+ git pull
+ mvn clean install
+ onos-package
+ cell <name>
+ onos-verify-cell
+ onos-install -f
+ onos-wait-for-start
+ '''
+
+ cell_name = main.params['ENV']['cellName']
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS1_port = main.params['CTRL']['port1']
+
+ main.case("Setting up test environment")
+
+ main.step("Git checkout and pull master and get version")
+ main.ONOSbench.git_checkout("master")
+ git_pull_result = main.ONOSbench.git_pull()
+ print "git_pull_result = ", git_pull_result
+ version_result = main.ONOSbench.get_version()
+ main.log.report(main.ONOSbench.get_version())
+ if git_pull_result == 1:
+ main.step("Using mvn clean & install")
+ clean_install_result = main.ONOSbench.clean_install()
+ #clean_install_result = main.TRUE
+
+ main.step("Applying cell variable to environment")
+ cell_result1 = main.ONOSbench.set_cell(cell_name)
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result2 = main.ONOS2.set_cell(cell_name)
+ #verify_result = main.ONOS2.verify_cell()
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ cell_result = cell_result1 and cell_result2
+
+ main.step("Creating ONOS package")
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step("Creating a cell")
+ #cell_create_result = main.ONOSbench.create_cell_file(**************)
+
+ main.step("Installing ONOS package")
+ onos_install_result = main.ONOSbench.onos_install()
+ onos1_isup = main.ONOSbench.isup()
+
+ main.step("Starting ONOS service")
+ start_result = main.ONOSbench.onos_start(ONOS1_ip)
+
+ case1_result = (package_result and\
+ cell_result and verify_result and onos_install_result and\
+ onos1_isup and start_result )
+ utilities.assert_equals(expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful")
+
+ def CASE11(self, main):
+ '''
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Cleaning up test environment")
+
+ main.step("Testing ONOS kill function")
+ kill_result = main.ONOSbench.onos_kill(ONOS1_ip)
+
+ main.step("Stopping ONOS service")
+ stop_result = main.ONOSbench.onos_stop(ONOS1_ip)
+
+ main.step("Uninstalling ONOS service")
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+
+ def CASE21(self, main):
+ import time
+ '''
+ On ONOS bench, run this command: ./~/ONOS/tools/test/bin/onos-topo-cfg
+ which starts the rest and copies the links json file to the onos instance
+ Note that in case of Packet Optical, the links are not learnt from the topology, instead the links are learnt
+ from the json config file
+ '''
+ main.log.report("This testcase starts the packet layer topology and REST")
+ main.log.report("_____________________________________________")
+ sart_console_result = main.LincOE1.start_console()
+ optical_mn_script = main.LincOE2.run_optical_mn_script()
+ onos_topo_cfg_result = main.ONOSbench.run_onos_topo_cfg(instance_name = main.params['CTRL']['ip1'], json_file = main.params['OPTICAL']['jsonfile'])
+
+
+
+ def CASE22(self, main):
+ '''
+ Curretly we use, 4 linear switch optical topology and 2 packet layer mininet switches each with one host.
+ Therefore, the roadmCount variable = 4, packetLayerSWCount variable = 2, hostCount =2
+ and this is hardcoded in the testcase. If the topology changes, these hardcoded values need to be changed
+ '''
+
+ main.log.report("This testcase compares the optical+packet topology against what is expected")
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+ devices_result = main.ONOS2.devices(json_format = False)
+
+ print "devices_result = ", devices_result
+ devices_linewise = devices_result.split("\n")
+ devices_linewise = devices_linewise[1:-1]
+ roadmCount = 0
+ packetLayerSWCount = 0
+ for line in devices_linewise:
+ components = line.split(",")
+ availability = components[1].split("=")[1]
+ type = components[3].split("=")[1]
+ if availability == 'true' and type == 'ROADM':
+ roadmCount += 1
+ elif availability == 'true' and type =='SWITCH':
+ packetLayerSWCount += 1
+ if roadmCount == 4:
+ print "Number of Optical Switches = %d and is correctly detected" %roadmCount
+ main.log.info ("Number of Optical Switches = " +str(roadmCount) +" and is correctly detected")
+ opticalSW_result = main.TRUE
+ else:
+ print "Number of Optical Switches = %d and is wrong" %roadCount
+ main.log.info ("Number of Optical Switches = " +str(roadmCount) +" and is wrong")
+ opticalSW_result = main.FALSE
+
+ if packetLayerSWCount == 2:
+ print "Number of Packet layer or mininet Switches = %d and is correctly detected" %packetLayerSWCount
+ main.log.info("Number of Packet layer or mininet Switches = " +str(packetLayerSWCount) + " and is correctly detected")
+ packetSW_result = main.TRUE
+ else:
+ print "Number of Packet layer or mininet Switches = %d and is wrong" %packetLayerSWCount
+ main.log.info("Number of Packet layer or mininet Switches = " +str(packetLayerSWCount) + " and is wrong")
+ packetSW_result = main.FALSE
+ print "_________________________________"
+
+ links_result = main.ONOS2.links(json_format = False)
+ print "links_result = ", links_result
+ print "_________________________________"
+
+
+
+ #Discover hosts using pingall
+ pingall_result = main.LincOE2.pingall()
+
+ hosts_result = main.ONOS2.hosts(json_format = False)
+ print "hosts_result = ", hosts_result
+ print "_________________________________"
+ hosts_linewise = hosts_result.split("\n")
+ hosts_linewise = hosts_linewise[1:-1]
+ hostCount = 0
+ for line in hosts_linewise:
+ hostid = line.split(",")[0].split("=")[1]
+ hostCount +=1
+ if hostCount ==2:
+ print "Number of hosts = %d and is correctly detected" %hostCount
+ main.log.info("Number of hosts = " + str(hostCount) +" and is correctly detected")
+ hostDiscovery = main.TRUE
+ else:
+ print "Number of hosts = %d and is wrong" %hostCount
+ main.log.info("Number of hosts = " + str(hostCount) +" and is wrong")
+ hostDiscovery = main.FALSE
+
+ case22_result = opticalSW_result and packetSW_result and hostDiscovery
+ utilities.assert_equals(expect=main.TRUE, actual=case22_result,
+ onpass="Packet optical topology discovery successful",
+ onfail="Packet optical topology discovery failed")
+
+ def CASE23(self, main):
+ import time
+ '''
+ Add bidirectional point intents between 2 packet layer(mininet) devices and
+ ping mininet hosts
+ '''
+ main.log.report("This testcase adds bidirectional point intents between 2 packet layer(mininet) devices and ping mininet hosts")
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000ffffffff0001", 1, "of:0000ffffffff0002", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ ptp_intent_result = main.ONOS2.add_point_intent("of:0000ffffffff0002", 1, "of:0000ffffffff0001", 1)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+
+ time.sleep(10)
+ flowHandle = main.ONOS2.flows()
+ #print "flowHandle = ", flowHandle
+ main.log.info("flows :" + flowHandle)
+ intentHandle = main.ONOS2.intents()
+ main.log.info("intents :" + intentHandle)
+
+ Ping_Result = main.TRUE
+ count = 1
+ main.log.info("\n\nh1 is Pinging h2")
+ ping = main.LincOE2.pingHostOptical(src="h1", target="h2")
+ #ping = main.LincOE2.pinghost()
+ if ping == main.FALSE and count<5:
+ count+=1
+ Ping_Result = main.FALSE
+ main.log.report("Ping between h1 and h2 failed. Making attempt number "+str(count) + " in 2 seconds")
+ time.sleep(2)
+ ping = main.LincOE2.pingHostOptical(src="h1", target="h2")
+ #ping = main.LincOE2.pinghost()
+ elif ping==main.FALSE:
+ main.log.report("All ping attempts between h1 and h2 have failed")
+ Ping_Result = main.FALSE
+ elif ping==main.TRUE:
+ main.log.info("Ping test between h1 and h2 passed!")
+ Ping_Result = main.TRUE
+ else:
+ main.log.info("Unknown error")
+ Ping_Result = main.ERROR
+
+ if Ping_Result==main.FALSE:
+ main.log.report("Point intents for packet optical have not ben installed correctly. Cleaning up")
+ if Ping_Result==main.TRUE:
+ main.log.report("Point Intents for packet optical have been installed correctly")
+
+ case23_result = Ping_Result
+ utilities.assert_equals(expect=main.TRUE, actual=case23_result,
+ onpass="Point intents addition for packet optical and Pingall Test successful",
+ onfail="Point intents addition for packet optical and Pingall Test NOT successful")
+
+
diff --git a/TestON/tests/OpticalFunc13/OpticalFunc13.topo b/TestON/tests/OpticalFunc13/OpticalFunc13.topo
new file mode 100755
index 0000000..a3d6cfd
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/OpticalFunc13.topo
@@ -0,0 +1,94 @@
+<TOPOLOGY>
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1>
+ <host>10.128.10.11</host>
+ <user>sdn</user>
+ <password>sdn</password>
+ <type>OnosDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <Mininet1>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>MininetCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow13 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet1>
+
+ <Mininet2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow13 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet2>
+
+ <LincOE1>
+ <host>10.128.20.30</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>LincOEDriver</type>
+ <connect_order>6</connect_order>
+ <COMPONENTS>
+ <arg1> </arg1>
+ </COMPONENTS>
+ </LincOE1>
+
+ <LincOE2>
+ <host>10.128.20.30</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>7</connect_order>
+ <COMPONENTS>
+ <arg1> sudo python /home/admin/optical.py </arg1>
+ <arg2> </arg2>
+ </COMPONENTS>
+ </LincOE2>
+
+ <LincOE3>
+ <host>10.128.20.30</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>8</connect_order>
+ </LincOE3>
+
+
+ </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/OpticalFunc13/__init__.py b/TestON/tests/OpticalFunc13/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/OpticalFunc13/__init__.py
diff --git a/TestON/tests/ProdFunc/ProdFunc.params b/TestON/tests/ProdFunc/ProdFunc.params
index 2d1f421..1189301 100755
--- a/TestON/tests/ProdFunc/ProdFunc.params
+++ b/TestON/tests/ProdFunc/ProdFunc.params
@@ -1,6 +1,6 @@
<PARAMS>
- <testcases>1,4,9</testcases>
+ <testcases>1,4,10,5,6,7,8,9,2,8,20,21,22,10,23,24</testcases>
#Environment variables
<ENV>
<cellName>driver_test</cellName>
diff --git a/TestON/tests/ProdFunc/ProdFunc.py b/TestON/tests/ProdFunc/ProdFunc.py
index b2797f3..5e31df3 100755
--- a/TestON/tests/ProdFunc/ProdFunc.py
+++ b/TestON/tests/ProdFunc/ProdFunc.py
@@ -43,8 +43,8 @@
main.step( "Removing raft logs before a clen installation of ONOS" )
main.ONOSbench.onosRemoveRaftLogs()
- main.step( "Git checkout and pull master and get version" )
- main.ONOSbench.gitCheckout( "master" )
+ main.step( "Git checkout and get version" )
+ #main.ONOSbench.gitCheckout( "master" )
gitPullResult = main.ONOSbench.gitPull()
main.log.info( "git_pull_result = " + gitPullResult )
main.ONOSbench.getVersion( report=True )
diff --git a/TestON/tests/ProdFunc/ProdFunc.py.fixed b/TestON/tests/ProdFunc/ProdFunc.py.fixed
new file mode 100644
index 0000000..6f4b72b
--- /dev/null
+++ b/TestON/tests/ProdFunc/ProdFunc.py.fixed
@@ -0,0 +1,1395 @@
+
+# Testing the basic functionality of ONOS Next
+# For sanity and driver functionality excercises only.
+
+import time
+# import sys
+# import os
+# import re
+import json
+
+time.sleep( 1 )
+
+
+class ProdFunc:
+
+ def __init__( self ):
+ self.default = ''
+
+ def CASE1( self, main ):
+ """
+ Startup sequence:
+ cell <name>
+ onos-verify-cell
+ onos-remove-raft-log
+ git pull
+ mvn clean install
+ onos-package
+ onos-install -f
+ onos-wait-for-start
+ """
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ main.case( "Setting up test environment" )
+ main.log.report(
+ "This testcase is testing setting up test environment" )
+ main.log.report( "__________________________________" )
+
+ main.step( "Applying cell variable to environment" )
+ cellResult = main.ONOSbench.setCell( cellName )
+ verifyResult = main.ONOSbench.verifyCell()
+
+ main.step( "Removing raft logs before a clen installation of ONOS" )
+ main.ONOSbench.onosRemoveRaftLogs()
+
+ main.step( "Git checkout and pull master and get version" )
+ main.ONOSbench.gitCheckout( "master" )
+ gitPullResult = main.ONOSbench.gitPull()
+ main.log.info( "git_pull_result = " + gitPullResult )
+ main.ONOSbench.getVersion( report=True )
+
+ if gitPullResult == 1:
+ main.step( "Using mvn clean & install" )
+ main.ONOSbench.cleanInstall()
+ elif gitPullResult == 0:
+ main.log.report(
+ "Git Pull Failed, look into logs for detailed reason" )
+ main.cleanup()
+ main.exit()
+
+ main.step( "Creating ONOS package" )
+ packageResult = main.ONOSbench.onosPackage()
+
+ main.step( "Installing ONOS package" )
+ onosInstallResult = main.ONOSbench.onosInstall()
+ if onosInstallResult == main.TRUE:
+ main.log.report( "Installing ONOS package successful" )
+ else:
+ main.log.report( "Installing ONOS package failed" )
+
+ onos1Isup = main.ONOSbench.isup()
+ if onos1Isup == main.TRUE:
+ main.log.report( "ONOS instance is up and ready" )
+ else:
+ main.log.report( "ONOS instance may not be up" )
+
+ main.step( "Starting ONOS service" )
+ startResult = main.ONOSbench.onosStart( ONOS1Ip )
+
+ main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+
+ case1Result = ( packageResult and
+ cellResult and verifyResult
+ and onosInstallResult and
+ onos1Isup and startResult )
+ utilities.assert_equals( expect=main.TRUE, actual=case1Result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful" )
+
+ def CASE2( self, main ):
+ """
+ Switch Down
+ """
+ # NOTE: You should probably run a topology check after this
+ import time
+
+ main.case( "Switch down discovery" )
+ main.log.report( "This testcase is testing a switch down discovery" )
+ main.log.report( "__________________________________" )
+
+ switchSleep = int( main.params[ 'timers' ][ 'SwitchDiscovery' ] )
+
+ description = "Killing a switch to ensure it is discovered correctly"
+ main.log.report( description )
+ main.case( description )
+
+ # TODO: Make this switch parameterizable
+ main.step( "Kill s28 " )
+ main.log.report( "Deleting s28" )
+ # FIXME: use new dynamic topo functions
+ main.Mininet1.delSwitch( "s28" )
+ main.log.info(
+ "Waiting " +
+ str( switchSleep ) +
+ " seconds for switch down to be discovered" )
+ time.sleep( switchSleep )
+ # Peek at the deleted switch
+ device = main.ONOS2.getDevice( dpid="0028" )
+ print "device = ", device
+ if device[ u'available' ] == 'False':
+ case2Result = main.FALSE
+ else:
+ case2Result = main.TRUE
+ utilities.assert_equals( expect=main.TRUE, actual=case2Result,
+ onpass="Switch down discovery successful",
+ onfail="Switch down discovery failed" )
+
+ def CASE11( self, main ):
+ """
+ Cleanup sequence:
+ onos-service <nodeIp> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ """
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ main.case( "Cleaning up test environment" )
+
+ main.step( "Testing ONOS kill function" )
+ killResult = main.ONOSbench.onosKill( ONOS1Ip )
+
+ main.step( "Stopping ONOS service" )
+ stopResult = main.ONOSbench.onosStop( ONOS1Ip )
+
+ main.step( "Uninstalling ONOS service" )
+ uninstallResult = main.ONOSbench.onosUninstall()
+
+ case11Result = killResult and stopResult and uninstallResult
+ utilities.assert_equals( expect=main.TRUE, actual=case11Result,
+ onpass="Cleanup successful",
+ onfail="Cleanup failed" )
+
+ def CASE3( self, main ):
+ """
+ Test 'onos' command and its functionality in driver
+ """
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ main.case( "Testing 'onos' command" )
+
+ main.step( "Sending command 'onos -w <onos-ip> system:name'" )
+ cmdstr1 = "system:name"
+ cmdResult1 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr1 )
+ main.log.info( "onos command returned: " + cmdResult1 )
+
+ main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
+ cmdstr2 = "onos:topology"
+ cmdResult2 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr2 )
+ main.log.info( "onos command returned: " + cmdResult2 )
+
+ def CASE20( self ):
+ """
+ Exit from mininet cli
+ reinstall ONOS
+ """
+ cellName = main.params[ 'ENV' ][ 'cellName' ]
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+
+ main.log.report( "This testcase exits the mininet cli and reinstalls\
+ ONOS to switch over to Packet Optical topology" )
+ main.log.report( "_____________________________________________" )
+ main.case( "Disconnecting mininet and restarting ONOS" )
+ main.step( "Disconnecting mininet and restarting ONOS" )
+ mininetDisconnect = main.Mininet1.disconnect()
+
+ main.step( "Removing raft logs before a clen installation of ONOS" )
+ main.ONOSbench.onosRemoveRaftLogs()
+
+ main.step( "Applying cell variable to environment" )
+ cellResult = main.ONOSbench.setCell( cellName )
+ verifyResult = main.ONOSbench.verifyCell()
+
+ onosInstallResult = main.ONOSbench.onosInstall()
+ if onosInstallResult == main.TRUE:
+ main.log.report( "Installing ONOS package successful" )
+ else:
+ main.log.report( "Installing ONOS package failed" )
+
+ onos1Isup = main.ONOSbench.isup()
+ if onos1Isup == main.TRUE:
+ main.log.report( "ONOS instance is up and ready" )
+ else:
+ main.log.report( "ONOS instance may not be up" )
+
+ main.step( "Starting ONOS service" )
+ startResult = main.ONOSbench.onosStart( ONOS1Ip )
+
+ main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+ case20Result = mininetDisconnect and cellResult and verifyResult \
+ and onosInstallResult and onos1Isup and \
+ startResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case20Result,
+ onpass="Exiting functionality mininet topology and reinstalling \
+ ONOS successful",
+ onfail="Exiting functionality mininet topology and reinstalling \
+ ONOS failed" )
+
+ def CASE21( self, main ):
+ """
+ On ONOS bench, run this command:
+ ./~/ONOS/tools/test/bin/onos-topo-cfg
+ which starts the rest and copies the links
+ json file to the onos instance.
+ Note that in case of Packet Optical, the links are not learnt
+ from the topology, instead the links are learnt
+ from the json config file
+ """
+ main.log.report(
+ "This testcase starts the packet layer topology and REST" )
+ main.log.report( "_____________________________________________" )
+ main.case( "Starting LINC-OE and other components" )
+ main.step( "Starting LINC-OE and other components" )
+ startConsoleResult = main.LincOE1.startConsole()
+ opticalMnScript = main.LincOE2.runOpticalMnScript()
+ onosTopoCfgResult = main.ONOSbench.runOnosTopoCfg(
+ instanceName=main.params[ 'CTRL' ][ 'ip1' ],
+ jsonFile=main.params[ 'OPTICAL' ][ 'jsonfile' ] )
+
+ print "start_console_result =", startConsoleResult
+ print "optical_mn_script = ", opticalMnScript
+ print "onos_topo_cfg_result =", onosTopoCfgResult
+
+ case21Result = startConsoleResult and opticalMnScript and \
+ onosTopoCfgResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case21Result,
+ onpass="Packet optical topology spawned successsfully",
+ onfail="Packet optical topology spawning failed" )
+
+ def CASE22( self, main ):
+ """
+ Curretly we use, 4 linear switch optical topology and
+ 2 packet layer mininet switches each with one host.
+ Therefore, the roadmCount variable = 4,
+ packetLayerSWCount variable = 2 and hostCount = 2
+ and this is hardcoded in the testcase. If the topology changes,
+ these hardcoded values need to be changed
+ """
+ main.log.report(
+ "This testcase compares the optical+packet topology against what\
+ is expected" )
+ main.case( "Topology comparision" )
+ main.step( "Topology comparision" )
+ main.ONOS3.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+ devicesResult = main.ONOS3.devices( jsonFormat=False )
+
+ print "devices_result = ", devicesResult
+ devicesLinewise = devicesResult.split( "\n" )
+ devicesLinewise = devicesLinewise[ 1:-1 ]
+ roadmCount = 0
+ packetLayerSWCount = 0
+ for line in devicesLinewise:
+ components = line.split( "," )
+ availability = components[ 1 ].split( "=" )[ 1 ]
+ type = components[ 3 ].split( "=" )[ 1 ]
+ if availability == 'true' and type == 'ROADM':
+ roadmCount += 1
+ elif availability == 'true' and type == 'SWITCH':
+ packetLayerSWCount += 1
+ if roadmCount == 4:
+ print "Number of Optical Switches = %d and is \
+ correctly detected" % roadmCount
+ main.log.info(
+ "Number of Optical Switches = " +
+ str( roadmCount ) +
+ " and is correctly detected" )
+ opticalSWResult = main.TRUE
+ else:
+ print "Number of Optical Switches = %d and is wrong" % roadmCount
+ main.log.info(
+ "Number of Optical Switches = " +
+ str( roadmCount ) +
+ " and is wrong" )
+ opticalSWResult = main.FALSE
+
+ if packetLayerSWCount == 2:
+ print "Number of Packet layer or mininet Switches = %d and \
+ is correctly detected" % packetLayerSWCount
+ main.log.info(
+ "Number of Packet layer or mininet Switches = " +
+ str( packetLayerSWCount ) +
+ " and is correctly detected" )
+ packetSWResult = main.TRUE
+ else:
+ print "Number of Packet layer or mininet Switches = %d and \
+ is wrong" % packetLayerSWCount
+ main.log.info(
+ "Number of Packet layer or mininet Switches = " +
+ str( packetLayerSWCount ) +
+ " and is wrong" )
+ packetSWResult = main.FALSE
+ print "_________________________________"
+
+ linksResult = main.ONOS3.links( jsonFormat=False )
+ print "links_result = ", linksResult
+ print "_________________________________"
+
+ # NOTE:Since only point intents are added, there is no
+ # requirement to discover the hosts
+ # Therfore, the below portion of the code is commented.
+ """
+ #Discover hosts using pingall
+ pingallResult = main.LincOE2.pingall()
+
+ hostsResult = main.ONOS3.hosts( jsonFormat=False )
+ main.log.info( "hosts_result = "+hostsResult )
+ main.log.info( "_________________________________" )
+ hostsLinewise = hostsResult.split( "\n" )
+ hostsLinewise = hostsLinewise[ 1:-1 ]
+ hostCount = 0
+ for line in hostsLinewise:
+ hostid = line.split( "," )[ 0 ].split( "=" )[ 1 ]
+ hostCount +=1
+ if hostCount ==2:
+ print "Number of hosts = %d and is correctly detected" %hostCount
+ main.log.info( "Number of hosts = " + str( hostCount ) +" and \
+ is correctly detected" )
+ hostDiscovery = main.TRUE
+ else:
+ print "Number of hosts = %d and is wrong" %hostCount
+ main.log.info( "Number of hosts = " + str( hostCount ) +" and \
+ is wrong" )
+ hostDiscovery = main.FALSE
+ """
+ case22Result = opticalSWResult and packetSWResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case22Result,
+ onpass="Packet optical topology discovery successful",
+ onfail="Packet optical topology discovery failed" )
+
+ def CASE23( self, main ):
+ import time
+ """
+ Add bidirectional point intents between 2 packet layer( mininet )
+ devices and
+ ping mininet hosts
+ """
+ main.log.report(
+ "This testcase adds bidirectional point intents between 2 \
+ packet layer( mininet ) devices and ping mininet hosts" )
+ main.case( "Topology comparision" )
+ main.step( "Adding point intents" )
+ ptpIntentResult = main.ONOS3.addPointIntent(
+ "of:0000ffffffff0001/1",
+ "of:0000ffffffff0002/1" )
+ if ptpIntentResult == main.TRUE:
+ main.ONOS3.intents( jsonFormat=False )
+ main.log.info( "Point to point intent install successful" )
+
+ ptpIntentResult = main.ONOS3.addPointIntent(
+ "of:0000ffffffff0002/1",
+ "of:0000ffffffff0001/1" )
+ if ptpIntentResult == main.TRUE:
+ main.ONOS3.intents( jsonFormat=False )
+ main.log.info( "Point to point intent install successful" )
+
+ time.sleep( 10 )
+ flowHandle = main.ONOS3.flows()
+ main.log.info( "flows :" + flowHandle )
+
+ # Sleep for 30 seconds to provide time for the intent state to change
+ time.sleep( 30 )
+ intentHandle = main.ONOS3.intents( jsonFormat=False )
+ main.log.info( "intents :" + intentHandle )
+
+ PingResult = main.TRUE
+ count = 1
+ main.log.info( "\n\nh1 is Pinging h2" )
+ ping = main.LincOE2.pingHostOptical( src="h1", target="h2" )
+ # ping = main.LincOE2.pinghost()
+ if ping == main.FALSE and count < 5:
+ count += 1
+ PingResult = main.FALSE
+ main.log.info(
+ "Ping between h1 and h2 failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.info( "All ping attempts between h1 and h2 have failed" )
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h1 and h2 passed!" )
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+
+ if PingResult == main.FALSE:
+ main.log.report(
+ "Point intents for packet optical have not ben installed\
+ correctly. Cleaning up" )
+ if PingResult == main.TRUE:
+ main.log.report(
+ "Point Intents for packet optical have been\
+ installed correctly" )
+
+ case23Result = PingResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case23Result,
+ onpass="Point intents addition for packet optical and\
+ Pingall Test successful",
+ onfail="Point intents addition for packet optical and\
+ Pingall Test NOT successful" )
+
+ def CASE24( self, main ):
+ import time
+ import json
+ """
+ Test Rerouting of Packet Optical by bringing a port down
+ ( port 22 ) of a switch( switchID=1 ), so that link
+ ( between switch1 port22 - switch4-port30 ) is inactive
+ and do a ping test. If rerouting is successful,
+ ping should pass. also check the flows
+ """
+ main.log.report(
+ "This testcase tests rerouting and pings mininet hosts" )
+ main.case( "Test rerouting and pings mininet hosts" )
+ main.step( "Bring a port down and verify the link state" )
+ main.LincOE1.portDown( swId="1", ptId="22" )
+ linksNonjson = main.ONOS3.links( jsonFormat=False )
+ main.log.info( "links = " + linksNonjson )
+
+ links = main.ONOS3.links()
+ main.log.info( "links = " + links )
+
+ linksResult = json.loads( links )
+ linksStateResult = main.FALSE
+ for item in linksResult:
+ if item[ 'src' ][ 'device' ] == "of:0000ffffffffff01" and item[
+ 'src' ][ 'port' ] == "22":
+ if item[ 'dst' ][ 'device' ] == "of:0000ffffffffff04" and item[
+ 'dst' ][ 'port' ] == "30":
+ linksState = item[ 'state' ]
+ if linksState == "INACTIVE":
+ main.log.info(
+ "Links state is inactive as expected due to one \
+ of the ports being down" )
+ main.log.report(
+ "Links state is inactive as expected due to one \
+ of the ports being down" )
+ linksStateResult = main.TRUE
+ break
+ else:
+ main.log.info(
+ "Links state is not inactive as expected" )
+ main.log.report(
+ "Links state is not inactive as expected" )
+ linksStateResult = main.FALSE
+
+ print "links_state_result = ", linksStateResult
+ time.sleep( 10 )
+ flowHandle = main.ONOS3.flows()
+ main.log.info( "flows :" + flowHandle )
+
+ main.step( "Verify Rerouting by a ping test" )
+ PingResult = main.TRUE
+ count = 1
+ main.log.info( "\n\nh1 is Pinging h2" )
+ ping = main.LincOE2.pingHostOptical( src="h1", target="h2" )
+ # ping = main.LincOE2.pinghost()
+ if ping == main.FALSE and count < 5:
+ count += 1
+ PingResult = main.FALSE
+ main.log.info(
+ "Ping between h1 and h2 failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.info( "All ping attempts between h1 and h2 have failed" )
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h1 and h2 passed!" )
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+
+ if PingResult == main.TRUE:
+ main.log.report( "Ping test successful " )
+ if PingResult == main.FALSE:
+ main.log.report( "Ping test failed" )
+
+ case24Result = PingResult and linksStateResult
+ utilities.assert_equals( expect=main.TRUE, actual=case24Result,
+ onpass="Packet optical rerouting successful",
+ onfail="Packet optical rerouting failed" )
+
+ def CASE4( self, main ):
+ import re
+ import time
+ main.log.report( "This testcase is testing the assignment of \
+ all the switches to all the controllers and \
+ discovering the hists in reactive mode" )
+ main.log.report( "__________________________________" )
+ main.case( "Pingall Test" )
+ main.step( "Assigning switches to controllers" )
+ ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
+ ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
+ for i in range( 1, 29 ):
+ if i == 1:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ elif i >= 2 and i < 5:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ elif i >= 5 and i < 8:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ elif i >= 8 and i < 18:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ elif i >= 18 and i < 28:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ else:
+ main.Mininet1.assignSwController(
+ sw=str( i ),
+ ip1=ONOS1Ip,
+ port1=ONOS1Port )
+ SwitchMastership = main.TRUE
+ for i in range( 1, 29 ):
+ if i == 1:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ elif i >= 2 and i < 5:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ elif i >= 5 and i < 8:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ elif i >= 8 and i < 18:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ elif i >= 18 and i < 28:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is " + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+ else:
+ response = main.Mininet1.getSwController( "s" + str( i ) )
+ print( "Response is" + str( response ) )
+ if re.search( "tcp:" + ONOS1Ip, response ):
+ SwitchMastership = SwitchMastership and main.TRUE
+ else:
+ SwitchMastership = main.FALSE
+
+ if SwitchMastership == main.TRUE:
+ main.log.report( "Controller assignmnet successful" )
+ else:
+ main.log.report( "Controller assignmnet failed" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=SwitchMastership,
+ onpass="MasterControllers assigned correctly" )
+ """
+ for i in range ( 1,29 ):
+ main.Mininet1.assignSwController( sw=str( i ),count=5,
+ ip1=ONOS1Ip,port1=ONOS1Port,
+ ip2=ONOS2Ip,port2=ONOS2Port,
+ ip3=ONOS3Ip,port3=ONOS3Port,
+ ip4=ONOS4Ip,port4=ONOS4Port,
+ ip5=ONOS5Ip,port5=ONOS5Port )
+ """
+ # REACTIVE FWD test
+
+ main.step( "Get list of hosts from Mininet" )
+ hostList = main.Mininet1.getHosts()
+ main.log.info( hostList )
+
+ main.step( "Get host list in ONOS format" )
+ hostOnosList = main.ONOS2.getHostsId( hostList )
+ main.log.info( hostOnosList )
+ # time.sleep( 5 )
+
+ main.step( "Pingall" )
+ pingResult = main.FALSE
+ while pingResult == main.FALSE:
+ time1 = time.time()
+ pingResult = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % ( time2 - time1 )
+
+ # Start onos cli again because u might have dropped out of
+ # onos prompt to the shell prompt
+ # if there was no activity
+ main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+
+ case4Result = SwitchMastership and pingResult
+ if pingResult == main.TRUE:
+ main.log.report( "Pingall Test in reactive mode to \
+ discover the hosts successful" )
+ else:
+ main.log.report( "Pingall Test in reactive mode to \
+ discover the hosts failed" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case4Result,
+ onpass="Controller assignment and Pingall Test successful",
+ onfail="Controller assignment and Pingall Test NOT successful" )
+
+ def CASE10( self ):
+ main.log.report(
+ "This testcase uninstalls the reactive forwarding app" )
+ main.log.report( "__________________________________" )
+ main.case( "Uninstalling reactive forwarding app" )
+ # Unistall onos-app-fwd app to disable reactive forwarding
+ appUninstallResult = main.ONOS2.featureUninstall( "onos-app-fwd" )
+ main.log.info( "onos-app-fwd uninstalled" )
+
+ # After reactive forwarding is disabled, the reactive flows on
+ # switches timeout in 10-15s
+ # So sleep for 15s
+ time.sleep( 15 )
+
+ flows = main.ONOS2.flows()
+ main.log.info( flows )
+
+ case10Result = appUninstallResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case10Result,
+ onpass="Reactive forwarding app uninstallation successful",
+ onfail="Reactive forwarding app uninstallation failed" )
+
+ def CASE6( self ):
+ main.log.report( "This testcase is testing the addition of \
+ host intents and then does pingall" )
+ main.log.report( "__________________________________" )
+ main.case( "Obtaining host id's" )
+ main.step( "Get hosts" )
+ hosts = main.ONOS2.hosts()
+ main.log.info( hosts )
+
+ main.step( "Get all devices id" )
+ devicesIdList = main.ONOS2.getAllDevicesId()
+ main.log.info( devicesIdList )
+
+ # ONOS displays the hosts in hex format unlike mininet which does
+ # in decimal format
+ # So take care while adding intents
+ """
+ main.step( "Add host-to-host intents for mininet hosts h8 and h18 or
+ ONOS hosts h8 and h12" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
+ hthIntentResult = main.ONOS2.addHostIntent(
+ "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
+ print "______________________________________________________"
+ """
+ for i in range( 8, 18 ):
+ main.log.info(
+ "Adding host intent between h" + str( i ) +
+ " and h" + str( i + 10 ) )
+ host1 = "00:00:00:00:00:" + \
+ str( hex( i )[ 2: ] ).zfill( 2 ).upper()
+ host2 = "00:00:00:00:00:" + \
+ str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
+ # NOTE: get host can return None
+ # TODO: handle this
+ host1Id = main.ONOS2.getHost( host1 )[ 'id' ]
+ host2Id = main.ONOS2.getHost( host2 )[ 'id' ]
+ main.ONOS2.addHostIntent( host1Id, host2Id )
+
+ time.sleep( 10 )
+ hIntents = main.ONOS2.intents( jsonFormat=False )
+ main.log.info( "intents:" + hIntents )
+ main.ONOS2.flows()
+
+ count = 1
+ i = 8
+ PingResult = main.TRUE
+ # while i<10:
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ # i = 8
+ PingResult = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+ if PingResult == main.FALSE:
+ main.log.report(
+ "Ping all test after Host intent addition failed. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if PingResult == main.TRUE:
+ main.log.report(
+ "Ping all test after Host intent addition successful" )
+
+ case6Result = PingResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case6Result,
+ onpass="Pingall Test after Host intents addition successful",
+ onfail="Pingall Test after Host intents addition failed" )
+
+ def CASE5( self, main ):
+ import json
+ # assumes that sts is already in you PYTHONPATH
+ from sts.topology.testonTopology import TestONTopology
+ # main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
+ main.log.report( "This testcase is testing if all ONOS nodes \
+ are in topology sync with mininet" )
+ main.log.report( "__________________________________" )
+ main.case( "Comparing Mininet topology with the topology of ONOS" )
+ main.step( "Start continuous pings" )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong(
+ src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+
+ main.step( "Create TestONTopology object" )
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
+ temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
+ temp = temp + ( "ONOS" + str( count ), )
+ temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
+ temp = temp + \
+ ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
+ ctrls.append( temp )
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ TopologyCheck = main.TRUE
+ main.step( "Compare ONOS Topology to MN Topology" )
+ devicesJson = main.ONOS2.devices()
+ linksJson = main.ONOS2.links()
+ # portsJson = main.ONOS2.ports()
+
+ result1 = main.Mininet1.compareSwitches(
+ MNTopo,
+ json.loads( devicesJson ) )
+ result2 = main.Mininet1.compareLinks(
+ MNTopo,
+ json.loads( linksJson ) )
+ # result3 = main.Mininet1.comparePorts(
+ # MNTopo, json.loads( portsJson ) )
+
+ # result = result1 and result2 and result3
+ result = result1 and result2
+
+ print "***********************"
+ if result == main.TRUE:
+ main.log.report( "ONOS" + " Topology matches MN Topology" )
+ else:
+ main.log.report( "ONOS" + " Topology does not match MN Topology" )
+
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=result,
+ onpass="ONOS" +
+ " Topology matches MN Topology",
+ onfail="ONOS" +
+ " Topology does not match MN Topology" )
+
+ TopologyCheck = TopologyCheck and result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=TopologyCheck,
+ onpass="Topology checks passed",
+ onfail="Topology checks failed" )
+
+ def CASE7( self, main ):
+ from sts.topology.testonTopology import TestONTopology
+
+ linkSleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
+
+ main.log.report( "This testscase is killing a link to ensure that \
+ link discovery is consistent" )
+ main.log.report( "__________________________________" )
+ main.log.report( "Killing a link to ensure that link discovery \
+ is consistent" )
+ main.case( "Killing a link to Ensure that Link Discovery \
+ is Working Properly" )
+ """
+ main.step( "Start continuous pings" )
+
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source1' ],
+ target=main.params[ 'PING' ][ 'target1' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source2' ],
+ target=main.params[ 'PING' ][ 'target2' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source3' ],
+ target=main.params[ 'PING' ][ 'target3' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source4' ],
+ target=main.params[ 'PING' ][ 'target4' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source5' ],
+ target=main.params[ 'PING' ][ 'target5' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source6' ],
+ target=main.params[ 'PING' ][ 'target6' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source7' ],
+ target=main.params[ 'PING' ][ 'target7' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source8' ],
+ target=main.params[ 'PING' ][ 'target8' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source9' ],
+ target=main.params[ 'PING' ][ 'target9' ],
+ pingTime=500 )
+ main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source10' ],
+ target=main.params[ 'PING' ][ 'target10' ],
+ pingTime=500 )
+ """
+ main.step( "Determine the current number of switches and links" )
+ topologyOutput = main.ONOS2.topology()
+ topologyResult = main.ONOS1.getTopology( topologyOutput )
+ activeSwitches = topologyResult[ 'devices' ]
+ links = topologyResult[ 'links' ]
+ print "activeSwitches = ", type( activeSwitches )
+ print "links = ", type( links )
+ main.log.info(
+ "Currently there are %s switches and %s links" %
+ ( str( activeSwitches ), str( links ) ) )
+
+ main.step( "Kill Link between s3 and s28" )
+ main.Mininet1.link( END1="s3", END2="s28", OPTION="down" )
+ time.sleep( linkSleep )
+ topologyOutput = main.ONOS2.topology()
+ LinkDown = main.ONOS1.checkStatus(
+ topologyOutput, activeSwitches, str(
+ int( links ) - 2 ) )
+ if LinkDown == main.TRUE:
+ main.log.report( "Link Down discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=LinkDown,
+ onpass="Link Down discovered properly",
+ onfail="Link down was not discovered in " +
+ str( linkSleep ) +
+ " seconds" )
+
+ # Check ping result here..add code for it
+
+ main.step( "Bring link between s3 and s28 back up" )
+ LinkUp = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
+ time.sleep( linkSleep )
+ topologyOutput = main.ONOS2.topology()
+ LinkUp = main.ONOS1.checkStatus(
+ topologyOutput,
+ activeSwitches,
+ str( links ) )
+ if LinkUp == main.TRUE:
+ main.log.report( "Link up discovered properly" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=LinkUp,
+ onpass="Link up discovered properly",
+ onfail="Link up was not discovered in " +
+ str( linkSleep ) +
+ " seconds" )
+
+ # NOTE Check ping result here..add code for it
+
+ main.step( "Compare ONOS Topology to MN Topology" )
+ Topo = TestONTopology(
+ main.Mininet1,
+ ctrls ) # can also add Intent API info for intent operations
+ MNTopo = Topo
+ TopologyCheck = main.TRUE
+
+ devicesJson = main.ONOS2.devices()
+ linksJson = main.ONOS2.links()
+ portsJson = main.ONOS2.ports()
+
+ result1 = main.Mininet1.compareSwitches(
+ MNTopo,
+ json.loads( devicesJson ) )
+ result2 = main.Mininet1.compareLinks(
+ MNTopo,
+ json.loads( linksJson ) )
+ # result3 = main.Mininet1.comparePorts(
+ # MNTopo, json.loads( portsJson ) )
+
+ # result = result1 and result2 and result3
+ result = result1 and result2
+ print "***********************"
+
+ if result == main.TRUE:
+ main.log.report( "ONOS" + " Topology matches MN Topology" )
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=result,
+ onpass="ONOS" +
+ " Topology matches MN Topology",
+ onfail="ONOS" +
+ " Topology does not match MN Topology" )
+
+ TopologyCheck = TopologyCheck and result
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=TopologyCheck,
+ onpass="Topology checks passed",
+ onfail="Topology checks failed" )
+
+ result = LinkDown and LinkUp and TopologyCheck
+ utilities.assert_equals( expect=main.TRUE, actual=result,
+ onpass="Link failure is discovered correctly",
+ onfail="Link Discovery failed" )
+
+ def CASE8( self ):
+ """
+ Host intents removal
+ """
+ main.log.report( "This testcase removes any previously added intents \
+ before adding the same intents or point intents" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Host intents removal" )
+ main.case( "Removing host intents" )
+ main.step( "Obtain the intent id's" )
+ intentResult = main.ONOS2.intents( jsonFormat=False )
+ main.log.info( "intent_result = " + intentResult )
+
+ intentLinewise = intentResult.split( "\n" )
+ intentList = []
+ for line in intentLinewise:
+ if line.startswith( "id=" ):
+ intentList.append( line )
+
+ intentids = []
+ for line in intentList:
+ intentids.append( line.split( "," )[ 0 ].split( "=" )[ 1 ] )
+ for id in intentids:
+ print "id = ", id
+
+ main.step(
+ "Iterate through the intentids list and remove each intent" )
+ for id in intentids:
+ main.ONOS2.removeIntent( intentId=id )
+
+ intentResult = main.ONOS2.intents( jsonFormat=False )
+ main.log.info( "intent_result = " + intentResult )
+
+ case8Result = main.TRUE
+ if case8Result == main.TRUE:
+ main.log.report( "Intent removal successful" )
+ else:
+ main.log.report( "Intent removal failed" )
+
+ PingResult = main.TRUE
+ if case8Result == main.TRUE:
+ i = 8
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.TRUE:
+ i = 19
+ PingResult = PingResult and main.TRUE
+ elif ping == main.FALSE:
+ i += 1
+ PingResult = PingResult and main.FALSE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+
+ # Note: If the ping result failed, that means the intents have been
+ # withdrawn correctly.
+ if PingResult == main.TRUE:
+ main.log.report( "Host intents have not been withdrawn correctly" )
+ # main.cleanup()
+ # main.exit()
+ if PingResult == main.FALSE:
+ main.log.report( "Host intents have been withdrawn correctly" )
+
+ case8Result = case8Result and PingResult
+
+ if case8Result == main.FALSE:
+ main.log.report( "Intent removal successful" )
+ else:
+ main.log.report( "Intent removal failed" )
+
+ utilities.assert_equals( expect=main.FALSE, actual=case8Result,
+ onpass="Intent removal test failed",
+ onfail="Intent removal test passed" )
+
+ def CASE9( self ):
+ main.log.report(
+ "This testcase adds point intents and then does pingall" )
+ main.log.report( "__________________________________" )
+ main.log.info( "Adding point intents" )
+ main.case(
+ "Adding bidirectional point for mn hosts \
+ ( h8-h18, h9-h19, h10-h20, h11-h21, h12-h22,\
+ h13-h23, h14-h24, h15-h25, h16-h26, h17-h27 )" )
+ main.step(
+ "Add point intents for mininet hosts h8 and h18 or \
+ ONOS hosts h8 and h12" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003008/1",
+ "of:0000000000006018/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006018/1",
+ "of:0000000000003008/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h9 and h19 or \
+ ONOS hosts h9 and h13" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003009/1",
+ "of:0000000000006019/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006019/1",
+ "of:0000000000003009/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h10 and h20 or \
+ ONOS hosts hA and h14" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003010/1",
+ "of:0000000000006020/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006020/1",
+ "of:0000000000003010/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h11 and h21 or \
+ ONOS hosts hB and h15" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003011/1",
+ "of:0000000000006021/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006021/1",
+ "of:0000000000003011/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h12 and h22 \
+ ONOS hosts hC and h16" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003012/1",
+ "of:0000000000006022/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006022/1",
+ "of:0000000000003012/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h13 and h23 or \
+ ONOS hosts hD and h17" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003013/1",
+ "of:0000000000006023/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006023/1",
+ "of:0000000000003013/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h14 and h24 or \
+ ONOS hosts hE and h18" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003014/1",
+ "of:0000000000006024/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006024/1",
+ "of:0000000000003014/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h15 and h25 or \
+ ONOS hosts hF and h19" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003015/1",
+ "of:0000000000006025/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006025/1",
+ "of:0000000000003015/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add intents for mininet hosts h16 and h26 or \
+ ONOS hosts h10 and h1A" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003016/1",
+ "of:0000000000006026/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006026/1",
+ "of:0000000000003016/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ # main.log.info( getIntentResult )
+
+ main.step(
+ "Add point intents for mininet hosts h17 and h27 or \
+ ONOS hosts h11 and h1B" )
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000003017/1",
+ "of:0000000000006027/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ main.log.info( getIntentResult )
+
+ ptpIntentResult = main.ONOS2.addPointIntent(
+ "of:0000000000006027/1",
+ "of:0000000000003017/1" )
+ if ptpIntentResult == main.TRUE:
+ getIntentResult = main.ONOS2.intents()
+ main.log.info( "Point to point intent install successful" )
+ main.log.info( getIntentResult )
+
+ print(
+ "___________________________________________________________" )
+
+ flowHandle = main.ONOS2.flows()
+ # print "flowHandle = ", flowHandle
+ main.log.info( "flows :" + flowHandle )
+
+ count = 1
+ i = 8
+ PingResult = main.TRUE
+ while i < 18:
+ main.log.info(
+ "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
+ ping = main.Mininet1.pingHost(
+ src="h" + str( i ), target="h" + str( i + 10 ) )
+ if ping == main.FALSE and count < 5:
+ count += 1
+ # i = 8
+ PingResult = main.FALSE
+ main.log.report( "Ping between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ " failed. Making attempt number " +
+ str( count ) +
+ " in 2 seconds" )
+ time.sleep( 2 )
+ elif ping == main.FALSE:
+ main.log.report( "All ping attempts between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "have failed" )
+ i = 19
+ PingResult = main.FALSE
+ elif ping == main.TRUE:
+ main.log.info( "Ping test between h" +
+ str( i ) +
+ " and h" +
+ str( i +
+ 10 ) +
+ "passed!" )
+ i += 1
+ PingResult = main.TRUE
+ else:
+ main.log.info( "Unknown error" )
+ PingResult = main.ERROR
+
+ if PingResult == main.FALSE:
+ main.log.report(
+ "Point intents have not ben installed correctly. Cleaning up" )
+ # main.cleanup()
+ # main.exit()
+ if PingResult == main.TRUE:
+ main.log.report( "Point Intents have been installed correctly" )
+
+ case9Result = PingResult
+ utilities.assert_equals(
+ expect=main.TRUE,
+ actual=case9Result,
+ onpass="Point intents addition and Pingall Test successful",
+ onfail="Point intents addition and Pingall Test NOT successful" )
diff --git a/TestON/tests/ProdFunc13/ProdFunc13.py b/TestON/tests/ProdFunc13/ProdFunc13.py
index f6f60ee..b1246c2 100644
--- a/TestON/tests/ProdFunc13/ProdFunc13.py
+++ b/TestON/tests/ProdFunc13/ProdFunc13.py
@@ -43,8 +43,8 @@
main.step( "Removing raft logs before a clen installation of ONOS" )
main.ONOSbench.onosRemoveRaftLogs()
- main.step( "Git checkout and pull master and get version" )
- main.ONOSbench.gitCheckout( "master" )
+ main.step( "Git checkout, pull and get version" )
+ #main.ONOSbench.gitCheckout( "master" )
gitPullResult = main.ONOSbench.gitPull()
main.log.info( "git_pull_result = " + gitPullResult )
main.ONOSbench.getVersion( report=True )
diff --git a/TestON/tests/prevFuncNext/FuncNext.params b/TestON/tests/prevFuncNext/FuncNext.params
new file mode 100755
index 0000000..13a4691
--- /dev/null
+++ b/TestON/tests/prevFuncNext/FuncNext.params
@@ -0,0 +1,37 @@
+<PARAMS>
+
+ <testcases>1,4,5,3</testcases>
+
+ #Environment variables
+ <ENV>
+ <cellName>driver_test</cellName>
+ </ENV>
+
+ <CTRL>
+ <ip1>10.128.20.11</ip1>
+ <port1>6633</port1>
+ </CTRL>
+
+ <PING>
+ <source1>h8</source1>
+ <source2>h9</source2>
+ <source3>h10</source3>
+ <source4>h11</source4>
+ <source5>h12</source5>
+ <source6>h13</source6>
+ <source7>h14</source7>
+ <source8>h15</source8>
+ <source9>h16</source9>
+ <source10>h17</source10>
+ <target1>10.0.0.18</target1>
+ <target2>10.0.0.19</target2>
+ <target3>10.0.0.20</target3>
+ <target4>10.0.0.21</target4>
+ <target5>10.0.0.22</target5>
+ <target6>10.0.0.23</target6>
+ <target7>10.0.0.24</target7>
+ <target8>10.0.0.25</target8>
+ <target9>10.0.0.26</target9>
+ <target10>10.0.0.27</target10>
+ </PING>
+</PARAMS>
diff --git a/TestON/tests/prevFuncNext/FuncNext.py b/TestON/tests/prevFuncNext/FuncNext.py
new file mode 100755
index 0000000..e556fa4
--- /dev/null
+++ b/TestON/tests/prevFuncNext/FuncNext.py
@@ -0,0 +1,311 @@
+
+#Testing the basic functionality of ONOS Next
+#For sanity and driver functionality excercises only.
+
+import time
+import sys
+import os
+import re
+import time
+
+time.sleep(1)
+class FuncNext:
+ def __init__(self):
+ self.default = ''
+
+ def CASE1(self, main):
+ '''
+ Startup sequence:
+ git pull
+ mvn clean install
+ onos-package
+ cell <name>
+ onos-verify-cell
+ onos-install -f
+ onos-wait-for-start
+ '''
+
+ cell_name = main.params['ENV']['cellName']
+ ONOS1_ip = main.params['CTRL']['ip1']
+ ONOS1_port = main.params['CTRL']['port1']
+
+ main.case("Setting up test environment")
+
+ main.step("Git checkout and pull master and get version")
+ main.ONOSbench.git_checkout("master")
+ git_pull_result = main.ONOSbench.git_pull()
+ version_result = main.ONOSbench.get_version()
+
+ main.step("Using mvn clean & install")
+ #clean_install_result = main.ONOSbench.clean_install()
+ #clean_install_result = main.TRUE
+
+ main.step("Applying cell variable to environment")
+ cell_result = main.ONOSbench.set_cell(cell_name)
+ verify_result = main.ONOSbench.verify_cell()
+ cell_result = main.ONOS2.set_cell(cell_name)
+ #verify_result = main.ONOS2.verify_cell()
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ main.step("Creating ONOS package")
+ package_result = main.ONOSbench.onos_package()
+
+ #main.step("Creating a cell")
+ #cell_create_result = main.ONOSbench.create_cell_file(**************)
+
+ main.step("Installing ONOS package")
+ onos_install_result = main.ONOSbench.onos_install()
+ onos1_isup = main.ONOSbench.isup()
+
+ main.step("Starting ONOS service")
+ start_result = main.ONOSbench.onos_start(ONOS1_ip)
+
+ case1_result = (package_result and\
+ cell_result and verify_result and onos_install_result and\
+ onos1_isup and start_result )
+ utilities.assert_equals(expect=main.TRUE, actual=case1_result,
+ onpass="Test startup successful",
+ onfail="Test startup NOT successful")
+
+ def CASE11(self, main):
+ '''
+ Cleanup sequence:
+ onos-service <node_ip> stop
+ onos-uninstall
+
+ TODO: Define rest of cleanup
+
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Cleaning up test environment")
+
+ main.step("Testing ONOS kill function")
+ kill_result = main.ONOSbench.onos_kill(ONOS1_ip)
+
+ main.step("Stopping ONOS service")
+ stop_result = main.ONOSbench.onos_stop(ONOS1_ip)
+
+ main.step("Uninstalling ONOS service")
+ uninstall_result = main.ONOSbench.onos_uninstall()
+
+ def CASE3(self, main):
+ '''
+ Test 'onos' command and its functionality in driver
+ '''
+
+ ONOS1_ip = main.params['CTRL']['ip1']
+
+ main.case("Testing 'onos' command")
+
+ main.step("Sending command 'onos -w <onos-ip> system:name'")
+ cmdstr1 = "system:name"
+ cmd_result1 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr1)
+ main.log.info("onos command returned: "+cmd_result1)
+
+ main.step("Sending command 'onos -w <onos-ip> onos:topology'")
+ cmdstr2 = "onos:topology"
+ cmd_result2 = main.ONOSbench.onos_cli(ONOS1_ip, cmdstr2)
+ main.log.info("onos command returned: "+cmd_result2)
+
+
+
+ def CASE4(self, main):
+ import re
+ import time
+ main.case("Pingall Test")
+ main.step("Assigning switches to controllers")
+ for i in range(1,29):
+ if i ==1:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=2 and i<5:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=5 and i<8:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=8 and i<18:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ elif i>=18 and i<28:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ else:
+ main.Mininet1.assign_sw_controller(sw=str(i),ip1=ONOS1_ip,port1=ONOS1_port)
+ Switch_Mastership = main.TRUE
+ for i in range (1,29):
+ if i==1:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=2 and i<5:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=5 and i<8:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=8 and i<18:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ elif i>=18 and i<28:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is " + str(response))
+ if re.search("tcp:"+ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+ else:
+ response = main.Mininet1.get_sw_controller("s"+str(i))
+ print("Response is" + str(response))
+ if re.search("tcp:" +ONOS1_ip,response):
+ Switch_Mastership = Switch_Mastership and main.TRUE
+ else:
+ Switch_Mastership = main.FALSE
+
+ if Switch_Mastership == main.TRUE:
+ main.log.report("MasterControllers assigned correctly")
+ utilities.assert_equals(expect = main.TRUE,actual=Switch_Mastership,
+ onpass="MasterControllers assigned correctly")
+ '''
+ for i in range (1,29):
+ main.Mininet1.assign_sw_controller(sw=str(i),count=5,
+ ip1=ONOS1_ip,port1=ONOS1_port,
+ ip2=ONOS2_ip,port2=ONOS2_port,
+ ip3=ONOS3_ip,port3=ONOS3_port,
+ ip4=ONOS4_ip,port4=ONOS4_port,
+ ip5=ONOS5_ip,port5=ONOS5_port)
+ '''
+ #REACTIVE FWD test
+
+ main.step("Get list of hosts from Mininet")
+ host_list = main.Mininet1.get_hosts()
+ main.log.info(host_list)
+
+ main.step("Get host list in ONOS format")
+ host_onos_list = main.ONOS2.get_hosts_id(host_list)
+ main.log.info(host_onos_list)
+ #time.sleep(5)
+
+ #We must use ping from hosts we want to add intents from
+ #to make the hosts talk
+ #main.Mininet2.handle.sendline("\r")
+ #main.Mininet2.handle.sendline("h4 ping 10.1.1.1 -c 1 -W 1")
+ #time.sleep(3)
+ #main.Mininet2.handle.sendline("h5 ping 10.1.1.1 -c 1 -W 1")
+ #time.sleep(5)
+
+ main.step("Pingall")
+ ping_result = main.FALSE
+ while ping_result == main.FALSE:
+ time1 = time.time()
+ ping_result = main.Mininet1.pingall()
+ time2 = time.time()
+ print "Time for pingall: %2f seconds" % (time2 - time1)
+
+ #Start onos cli again because u might have dropped out of onos prompt to the shell prompt
+ #if there was no activity
+ main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+
+ main.step("Get hosts")
+ main.ONOS2.handle.sendline("hosts")
+ main.ONOS2.handle.expect("onos>")
+ hosts = main.ONOS2.handle.before
+ main.log.info(hosts)
+
+ main.step("Get all devices id")
+ devices_id_list = main.ONOS2.get_all_devices_id()
+ main.log.info(devices_id_list)
+ '''
+ main.step("Add point-to-point intents")
+ ptp_intent_result = main.ONOS2.add_point_intent(
+ devices_id_list[0], 1, devices_id_list[1], 2)
+ if ptp_intent_result == main.TRUE:
+ get_intent_result = main.ONOS2.intents()
+ main.log.info("Point to point intent install successful")
+ main.log.info(get_intent_result)
+ '''
+
+ case4_result = Switch_Mastership and ping_result
+ utilities.assert_equals(expect=main.TRUE, actual=case4_result,
+ onpass="Pingall Test successful",
+ onfail="Pingall Test NOT successful")
+
+ def CASE5(self,main) :
+ import time
+ from subprocess import Popen, PIPE
+ from sts.topology.teston_topology import TestONTopology # assumes that sts is already in you PYTHONPATH
+ #main.ONOS2.start_onos_cli(ONOS_ip=main.params['CTRL']['ip1'])
+ deviceResult = main.ONOS2.devices()
+ linksResult = main.ONOS2.links()
+ portsResult = main.ONOS2.ports()
+ print "**************"
+ main.step("Start continuous pings")
+ main.Mininet2.pingLong(src=main.params['PING']['source1'],
+ target=main.params['PING']['target1'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source2'],
+ target=main.params['PING']['target2'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source3'],
+ target=main.params['PING']['target3'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source4'],
+ target=main.params['PING']['target4'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source5'],
+ target=main.params['PING']['target5'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source6'],
+ target=main.params['PING']['target6'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source7'],
+ target=main.params['PING']['target7'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source8'],
+ target=main.params['PING']['target8'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source9'],
+ target=main.params['PING']['target9'],pingTime=500)
+ main.Mininet2.pingLong(src=main.params['PING']['source10'],
+ target=main.params['PING']['target10'],pingTime=500)
+
+ main.step("Create TestONTopology object")
+ global ctrls
+ ctrls = []
+ count = 1
+ while True:
+ temp = ()
+ if ('ip' + str(count)) in main.params['CTRL']:
+ temp = temp + (getattr(main,('ONOS' + str(count))),)
+ temp = temp + ("ONOS"+str(count),)
+ temp = temp + (main.params['CTRL']['ip'+str(count)],)
+ temp = temp + (eval(main.params['CTRL']['port'+str(count)]),)
+ ctrls.append(temp)
+ count = count + 1
+ else:
+ break
+ global MNTopo
+ Topo = TestONTopology(main.Mininet1, ctrls) # can also add Intent API info for intent operations
+ MNTopo = Topo
+
+ Topology_Check = main.TRUE
+ main.step("Compare ONOS Topology to MN Topology")
+ '''for n in range(1,6):
+ result = main.Mininet1.compare_topo(MNTopo,
+ main.ONOS1.get_json(main.params['CTRL']['ip'+str(n)]+":"+ \
+ main.params['CTRL']['restPort'+str(n)]+main.params['TopoRest']))
+ if result == main.TRUE:
+ main.log.report("ONOS"+str(n) + " Topology matches MN Topology")
+ utilities.assert_equals(expect=main.TRUE,actual=result,
+ onpass="ONOS" + str(n) + " Topology matches MN Topology",
+ onfail="ONOS" + str(n) + " Topology does not match MN Topology")
+ Topology_Check = Topology_Check and result
+ utilities.assert_equals(expect=main.TRUE,actual=Topology_Check,
+ onpass="Topology checks passed", onfail="Topology checks failed")
+ '''
+
+
diff --git a/TestON/tests/prevFuncNext/FuncNext.topo b/TestON/tests/prevFuncNext/FuncNext.topo
new file mode 100755
index 0000000..5d453a6
--- /dev/null
+++ b/TestON/tests/prevFuncNext/FuncNext.topo
@@ -0,0 +1,61 @@
+<TOPOLOGY>
+ <COMPONENT>
+
+ <ONOSbench>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosDriver</type>
+ <connect_order>1</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOSbench>
+
+ <ONOS1>
+ <host>10.128.10.11</host>
+ <user>sdn</user>
+ <password>sdn</password>
+ <type>OnosDriver</type>
+ <connect_order>2</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS1>
+
+ <ONOS2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>OnosCliDriver</type>
+ <connect_order>3</connect_order>
+ <COMPONENTS> </COMPONENTS>
+ </ONOS2>
+
+ <Mininet1>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>MininetCliDriver</type>
+ <connect_order>4</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow10 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet1>
+
+ <Mininet2>
+ <host>10.128.10.11</host>
+ <user>admin</user>
+ <password>onos_test</password>
+ <type>RemoteMininetDriver</type>
+ <connect_order>5</connect_order>
+ <COMPONENTS>
+ #Specify the Option for mininet
+ <arg1> --custom ~/mininet/custom/topo-HA.py </arg1>
+ <arg2> --topo mytopo </arg2>
+ <arg3> --switch ovs,protocols=OpenFlow10 </arg3>
+ <controller> remote </controller>
+ </COMPONENTS>
+ </Mininet2>
+ </COMPONENT>
+</TOPOLOGY>
diff --git a/TestON/tests/prevFuncNext/__init__.py b/TestON/tests/prevFuncNext/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/TestON/tests/prevFuncNext/__init__.py