blob: b7fa855bce0388d7926072c308ebbce96772479b [file] [log] [blame]
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001import time
2import sys
3import os
4import re
5import time
6import json
7import itertools
8
kelvin8ec71442015-01-15 16:57:00 -08009
Hari Krishnaa43d4e92014-12-19 13:22:40 -080010class OnosCHO:
kelvin8ec71442015-01-15 16:57:00 -080011
kelvin-onlab8a832582015-01-16 17:06:11 -080012 def __init__( self ):
Hari Krishnaa43d4e92014-12-19 13:22:40 -080013 self.default = ''
kelvin8ec71442015-01-15 16:57:00 -080014
kelvin-onlab8a832582015-01-16 17:06:11 -080015 def CASE1( self, main ):
16 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -080017 Startup sequence:
18 git pull
19 mvn clean install
20 onos-package
21 cell <name>
22 onos-verify-cell
23 onos-install -f
24 onos-wait-for-start
kelvin-onlab8a832582015-01-16 17:06:11 -080025 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -080026 import time
kelvin-onlab54400a92015-02-26 18:05:51 -080027
28 main.threadID = 0
29 main.pingTimeout = 300
Hari Krishna22c3d412015-02-17 16:48:12 -080030 main.numCtrls = main.params[ 'CTRL' ][ 'numCtrl' ]
31 main.ONOS1_ip = main.params[ 'CTRL' ][ 'ip1' ]
32 main.ONOS2_ip = main.params[ 'CTRL' ][ 'ip2' ]
33 main.ONOS3_ip = main.params[ 'CTRL' ][ 'ip3' ]
34 main.ONOS4_ip = main.params[ 'CTRL' ][ 'ip4' ]
35 main.ONOS5_ip = main.params[ 'CTRL' ][ 'ip5' ]
36 main.ONOS1_port = main.params[ 'CTRL' ][ 'port1' ]
37 main.ONOS2_port = main.params[ 'CTRL' ][ 'port2' ]
38 main.ONOS3_port = main.params[ 'CTRL' ][ 'port3' ]
39 main.ONOS4_port = main.params[ 'CTRL' ][ 'port4' ]
40 main.ONOS5_port = main.params[ 'CTRL' ][ 'port5' ]
kelvin-onlab8a832582015-01-16 17:06:11 -080041 cell_name = main.params[ 'ENV' ][ 'cellName' ]
42 git_pull = main.params[ 'GIT' ][ 'autoPull' ]
kelvin-onlab8a832582015-01-16 17:06:11 -080043 git_branch = main.params[ 'GIT' ][ 'branch' ]
Hari Krishnaa43d4e92014-12-19 13:22:40 -080044
kelvin-onlab8a832582015-01-16 17:06:11 -080045 main.case( "Set up test environment" )
46 main.log.report( "Set up test environment" )
47 main.log.report( "_______________________" )
48
49 main.step( "Git checkout and pull " + git_branch )
Hari Krishnaa43d4e92014-12-19 13:22:40 -080050 if git_pull == 'on':
Hari Krishnad97213e2015-01-24 19:30:14 -080051 checkout_result = main.ONOSbench.gitCheckout( git_branch )
52 pull_result = main.ONOSbench.gitPull()
kelvin-onlab8a832582015-01-16 17:06:11 -080053 cp_result = ( checkout_result and pull_result )
Hari Krishnaa43d4e92014-12-19 13:22:40 -080054 else:
55 checkout_result = main.TRUE
56 pull_result = main.TRUE
kelvin-onlab8a832582015-01-16 17:06:11 -080057 main.log.info( "Skipped git checkout and pull" )
58 cp_result = ( checkout_result and pull_result )
59 utilities.assert_equals( expect=main.TRUE, actual=cp_result,
60 onpass="Test step PASS",
61 onfail="Test step FAIL" )
62
63 main.step( "mvn clean & install" )
Hari Krishna22c3d412015-02-17 16:48:12 -080064 if git_pull == 'on':
65 mvn_result = main.ONOSbench.cleanInstall()
66 utilities.assert_equals( expect=main.TRUE, actual=mvn_result,
kelvin-onlab8a832582015-01-16 17:06:11 -080067 onpass="Test step PASS",
68 onfail="Test step FAIL" )
Hari Krishna22c3d412015-02-17 16:48:12 -080069 else:
70 mvn_result = main.TRUE
71 main.log.info("Skipped mvn clean install as git pull is disabled in params file")
Hari Krishnaa43d4e92014-12-19 13:22:40 -080072
Hari Krishnad97213e2015-01-24 19:30:14 -080073 main.ONOSbench.getVersion( report=True )
Hari Krishnaa43d4e92014-12-19 13:22:40 -080074
kelvin-onlab8a832582015-01-16 17:06:11 -080075 main.step( "Apply Cell environment for ONOS" )
Hari Krishnad97213e2015-01-24 19:30:14 -080076 cell_result = main.ONOSbench.setCell( cell_name )
kelvin-onlab8a832582015-01-16 17:06:11 -080077 utilities.assert_equals( expect=main.TRUE, actual=cell_result,
78 onpass="Test step PASS",
79 onfail="Test step FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -080080
kelvin-onlab8a832582015-01-16 17:06:11 -080081 main.step( "Create ONOS package" )
Hari Krishnad97213e2015-01-24 19:30:14 -080082 packageResult = main.ONOSbench.onosPackage()
kelvin-onlab8a832582015-01-16 17:06:11 -080083 utilities.assert_equals( expect=main.TRUE, actual=packageResult,
84 onpass="Test step PASS",
85 onfail="Test step FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -080086
kelvin-onlab8a832582015-01-16 17:06:11 -080087 main.step( "Uninstall ONOS package on all Nodes" )
88 uninstallResult = main.TRUE
Hari Krishna22c3d412015-02-17 16:48:12 -080089 for i in range( 1, int( main.numCtrls ) + 1 ):
kelvin-onlab8a832582015-01-16 17:06:11 -080090 ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
kelvin-onlab54400a92015-02-26 18:05:51 -080091 main.log.info( "Uninstalling package on ONOS Node IP: " + ONOS_ip )
Hari Krishnad97213e2015-01-24 19:30:14 -080092 u_result = main.ONOSbench.onosUninstall( ONOS_ip )
kelvin-onlab8a832582015-01-16 17:06:11 -080093 utilities.assert_equals( expect=main.TRUE, actual=u_result,
94 onpass="Test step PASS",
95 onfail="Test step FAIL" )
96 uninstallResult = ( uninstallResult and u_result )
Hari Krishnaa43d4e92014-12-19 13:22:40 -080097
kelvin-onlab8a832582015-01-16 17:06:11 -080098 main.step( "Removing copy-cat logs from ONOS nodes" )
Hari Krishnad97213e2015-01-24 19:30:14 -080099 main.ONOSbench.onosRemoveRaftLogs()
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800100
kelvin-onlab8a832582015-01-16 17:06:11 -0800101 main.step( "Install ONOS package on all Nodes" )
102 installResult = main.TRUE
Hari Krishna22c3d412015-02-17 16:48:12 -0800103 for i in range( 1, int( main.numCtrls ) + 1 ):
kelvin-onlab8a832582015-01-16 17:06:11 -0800104 ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
105 main.log.info( "Intsalling package on ONOS Node IP: " + ONOS_ip )
Hari Krishnad97213e2015-01-24 19:30:14 -0800106 i_result = main.ONOSbench.onosInstall( node=ONOS_ip )
kelvin-onlab8a832582015-01-16 17:06:11 -0800107 utilities.assert_equals( expect=main.TRUE, actual=i_result,
108 onpass="Test step PASS",
109 onfail="Test step FAIL" )
110 installResult = ( installResult and i_result )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800111
kelvin-onlab8a832582015-01-16 17:06:11 -0800112 main.step( "Verify ONOS nodes UP status" )
113 statusResult = main.TRUE
Hari Krishna22c3d412015-02-17 16:48:12 -0800114 for i in range( 1, int( main.numCtrls ) + 1 ):
kelvin-onlab8a832582015-01-16 17:06:11 -0800115 ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
116 main.log.info( "ONOS Node " + ONOS_ip + " status:" )
Hari Krishnad97213e2015-01-24 19:30:14 -0800117 onos_status = main.ONOSbench.onosStatus( node=ONOS_ip )
kelvin-onlab8a832582015-01-16 17:06:11 -0800118 utilities.assert_equals( expect=main.TRUE, actual=onos_status,
119 onpass="Test step PASS",
120 onfail="Test step FAIL" )
121 statusResult = ( statusResult and onos_status )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800122
kelvin-onlab8a832582015-01-16 17:06:11 -0800123 main.step( "Start ONOS CLI on all nodes" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800124 cliResult = main.TRUE
kelvin8ec71442015-01-15 16:57:00 -0800125 karafTimeout = "3600000"
kelvin-onlab8a832582015-01-16 17:06:11 -0800126 # need to wait here for sometime. This will be removed once ONOS is
127 # stable enough
kelvin-onlab54400a92015-02-26 18:05:51 -0800128 time.sleep( 25 )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800129
kelvin-onlab54400a92015-02-26 18:05:51 -0800130 main.log.step(" Start ONOS cli using thread ")
131 startCliResult = main.FALSE
132
133 CLI1 = (main.ONOScli1.startOnosCli,main.ONOS1_ip)
134 CLI2 = (main.ONOScli2.startOnosCli,main.ONOS2_ip)
135 CLI3 = (main.ONOScli3.startOnosCli,main.ONOS3_ip)
136 CLI4 = (main.ONOScli4.startOnosCli,main.ONOS4_ip)
137 CLI5 = (main.ONOScli5.startOnosCli,main.ONOS5_ip)
138 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
139 pool = []
140 time1 = time.time()
141 for cli,ip in ONOSCLI:
142 t = main.Thread(target=cli,threadID=main.threadID,
143 name="startOnosCli",args=[ip])
144 pool.append(t)
145 t.start()
146 main.threadID = main.threadID + 1
147
148 results = []
149 for thread in pool:
150 thread.join()
151 results.append(thread.result)
152 time2 = time.time()
153
154 if( all(result == main.TRUE for result in results) == False):
155 main.log.info("ONOS CLI did not start up properly")
156 main.cleanup()
157 main.exit()
158 else:
159 main.log.info("Successful CLI startup")
160 startCliResult = main.TRUE
161 case1Result = installResult and uninstallResult and statusResult and startCliResult
162
163 main.log.info("Time for connecting to CLI: %2f seconds" %(time2-time1))
kelvin-onlab8a832582015-01-16 17:06:11 -0800164 utilities.assert_equals( expect=main.TRUE, actual=case1Result,
165 onpass="Set up test environment PASS",
166 onfail="Set up test environment FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800167
kelvin-onlab8a832582015-01-16 17:06:11 -0800168 def CASE2( self, main ):
169 """
Hari Krishna22c3d412015-02-17 16:48:12 -0800170 This test loads a Topology (ATT) on Mininet and balances all switches.
kelvin-onlab8a832582015-01-16 17:06:11 -0800171 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800172 import re
173 import time
174 import copy
Hari Krishna22c3d412015-02-17 16:48:12 -0800175 main.numMNswitches = int ( main.params[ 'TOPO1' ][ 'numSwitches' ] )
176 main.numMNlinks = int ( main.params[ 'TOPO1' ][ 'numLinks' ] )
177 main.numMNhosts = int ( main.params[ 'TOPO1' ][ 'numHosts' ] )
kelvin-onlab54400a92015-02-26 18:05:51 -0800178 main.pingTimeout = 60
kelvin-onlab8a832582015-01-16 17:06:11 -0800179 main.log.report(
180 "Assign and Balance all Mininet switches across controllers" )
181 main.log.report(
182 "_________________________________________________________" )
183 # need to wait here for sometime. This will be removed once ONOS is
184 # stable enough
185 time.sleep( 15 )
186 main.case(
187 "Assign and Balance all Mininet switches across controllers" )
188 main.step( "Assign switches to controllers" )
Hari Krishna22c3d412015-02-17 16:48:12 -0800189 netStatus = main.Mininet1.startNet()
190 for i in range( 1, ( main.numMNswitches + 1 ) ): # 1 to ( num of switches +1 )
Hari Krishnad97213e2015-01-24 19:30:14 -0800191 main.Mininet1.assignSwController(
kelvin-onlab8a832582015-01-16 17:06:11 -0800192 sw=str( i ),
Hari Krishna22c3d412015-02-17 16:48:12 -0800193 count=int( main.numCtrls ),
194 ip1=main.ONOS1_ip,
195 port1=main.ONOS1_port,
196 ip2=main.ONOS2_ip,
197 port2=main.ONOS2_port,
198 ip3=main.ONOS3_ip,
199 port3=main.ONOS3_port,
200 ip4=main.ONOS4_ip,
201 port4=main.ONOS4_port,
202 ip5=main.ONOS5_ip,
203 port5=main.ONOS5_port )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800204
205 switch_mastership = main.TRUE
Hari Krishna22c3d412015-02-17 16:48:12 -0800206 for i in range( 1, ( main.numMNswitches + 1 ) ):
Hari Krishnad97213e2015-01-24 19:30:14 -0800207 response = main.Mininet1.getSwController( "s" + str( i ) )
kelvin-onlab8a832582015-01-16 17:06:11 -0800208 print( "Response is " + str( response ) )
Hari Krishna22c3d412015-02-17 16:48:12 -0800209 if re.search( "tcp:" + main.ONOS1_ip, response ):
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800210 switch_mastership = switch_mastership and main.TRUE
211 else:
212 switch_mastership = main.FALSE
213
214 if switch_mastership == main.TRUE:
kelvin-onlab8a832582015-01-16 17:06:11 -0800215 main.log.report( "Controller assignment successfull" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800216 else:
kelvin-onlab8a832582015-01-16 17:06:11 -0800217 main.log.report( "Controller assignment failed" )
Hari Krishna22c3d412015-02-17 16:48:12 -0800218 time.sleep( 15 )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800219
Hari Krishna22c3d412015-02-17 16:48:12 -0800220 #main.step( "Balance devices across controllers" )
221 #for i in range( int( main.numCtrls ) ):
222 # balanceResult = main.ONOScli1.balanceMasters()
kelvin-onlab8a832582015-01-16 17:06:11 -0800223 # giving some breathing time for ONOS to complete re-balance
Hari Krishna22c3d412015-02-17 16:48:12 -0800224 # time.sleep( 3 )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800225
Hari Krishna22c3d412015-02-17 16:48:12 -0800226 #utilities.assert_equals(
227 # expect=main.TRUE,
228 # actual=balanceResult,
229 # onpass="Assign and Balance devices test PASS",
230 #onfail="Assign and Balance devices test FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800231
kelvin-onlab8a832582015-01-16 17:06:11 -0800232 def CASE3( self, main ):
233 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800234 This Test case will be extended to collect and store more data related
235 ONOS state.
kelvin-onlab8a832582015-01-16 17:06:11 -0800236 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800237 import re
238 import copy
Hari Krishna22c3d412015-02-17 16:48:12 -0800239 main.deviceDPIDs = []
240 main.hostMACs = []
241 main.deviceLinks = []
242 main.deviceActiveLinksCount = []
243 main.devicePortsEnabledCount = []
kelvin-onlab54400a92015-02-26 18:05:51 -0800244
kelvin-onlab8a832582015-01-16 17:06:11 -0800245 main.log.report(
246 "Collect and Store topology details from ONOS before running any Tests" )
247 main.log.report(
248 "____________________________________________________________________" )
249 main.case( "Collect and Store Topology Deatils from ONOS" )
kelvin-onlab8a832582015-01-16 17:06:11 -0800250 main.step( "Collect and store current number of switches and links" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800251 topology_output = main.ONOScli1.topology()
Hari Krishnad97213e2015-01-24 19:30:14 -0800252 topology_result = main.ONOSbench.getTopology( topology_output )
Hari Krishna22c3d412015-02-17 16:48:12 -0800253 numOnosDevices = topology_result[ 'devices' ]
254 numOnosLinks = topology_result[ 'links' ]
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800255
kelvin-onlab54400a92015-02-26 18:05:51 -0800256 if ( ( main.numMNswitches == int(numOnosDevices) ) and ( main.numMNlinks >= int(numOnosLinks) ) ):
Hari Krishna22c3d412015-02-17 16:48:12 -0800257 main.step( "Store Device DPIDs" )
258 for i in range( 1, (main.numMNswitches+1) ):
259 main.deviceDPIDs.append( "of:00000000000000" + format( i, '02x' ) )
260 print "Device DPIDs in Store: \n", str( main.deviceDPIDs )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800261
Hari Krishna22c3d412015-02-17 16:48:12 -0800262 main.step( "Store Host MACs" )
263 for i in range( 1, ( main.numMNhosts + 1 ) ):
264 main.hostMACs.append( "00:00:00:00:00:" + format( i, '02x' ) + "/-1" )
265 print "Host MACs in Store: \n", str( main.hostMACs )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800266
Hari Krishna22c3d412015-02-17 16:48:12 -0800267 main.step( "Collect and store all Devices Links" )
268 linksResult = main.ONOScli1.links( jsonFormat=False )
269 ansi_escape = re.compile( r'\x1b[^m]*m' )
270 linksResult = ansi_escape.sub( '', linksResult )
271 linksResult = linksResult.replace( " links", "" ).replace( "\r\r", "" )
272 linksResult = linksResult.splitlines()
273 linksResult = linksResult[ 1: ]
274 main.deviceLinks = copy.copy( linksResult )
275 print "Device Links Stored: \n", str( main.deviceLinks )
276 # this will be asserted to check with the params provided count of
277 # links
278 print "Length of Links Store", len( main.deviceLinks )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800279
Hari Krishna22c3d412015-02-17 16:48:12 -0800280 main.step( "Collect and store each Device ports enabled Count" )
kelvin-onlab54400a92015-02-26 18:05:51 -0800281
282 CLI1 = (main.ONOScli1)
283 CLI2 = (main.ONOScli2)
284 CLI3 = (main.ONOScli3)
285 CLI4 = (main.ONOScli4)
286 CLI5 = (main.ONOScli5)
287 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
288 time1 = time.time()
289
290 for i in xrange(1,(main.numMNswitches + 1),5):
291 pool = []
292 for cli in ONOSCLI:
293 dpid = "of:00000000000000" + format( i,'02x' )
294 t = main.Thread(target = cli.getDevicePortsEnabledCount,threadID = main.threadID, name = "getDevicePortsEnabledCount",args = [dpid])
295 t.start()
296 pool.append(t)
297 i = i + 1
298 main.threadID = main.threadID + 1
299 for thread in pool:
300 thread.join()
301 portResult = thread.result
302 portTemp = re.split( r'\t+', portResult )
303 portCount = portTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
304 main.devicePortsEnabledCount.append( portCount )
Hari Krishna22c3d412015-02-17 16:48:12 -0800305 print "Device Enabled Port Counts Stored: \n", str( main.devicePortsEnabledCount )
kelvin-onlab54400a92015-02-26 18:05:51 -0800306 time2 = time.time()
307 main.log.info("Time for counting enabled ports of the switches: %2f seconds" %(time2-time1))
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800308
Hari Krishna22c3d412015-02-17 16:48:12 -0800309 main.step( "Collect and store each Device active links Count" )
kelvin-onlab54400a92015-02-26 18:05:51 -0800310 time1 = time.time()
311
312 for i in xrange(1,(main.numMNswitches + 1),5):
313 pool = []
314 for cli in ONOSCLI:
315 dpid = "of:00000000000000" + format( i,'02x' )
316 t = main.Thread(target = cli.getDeviceLinksActiveCount,threadID = main.threadID, name = "getDevicePortsEnabledCount",args = [dpid])
317 t.start()
318 pool.append(t)
319 i = i + 1
320 main.threadID = main.threadID + 1
321 for thread in pool:
322 thread.join()
323 linkCountResult = thread.result
324 linkCountTemp = re.split( r'\t+', linkCountResult )
325 linkCount = linkCountTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
326 main.deviceActiveLinksCount.append( linkCount )
327 print "Device Active Links Count Stored: \n", str( main.deviceActiveLinksCount )
328 time2 = time.time()
329 main.log.info("Time for counting all enabled links of the switches: %2f seconds" %(time2-time1))
Hari Krishna22c3d412015-02-17 16:48:12 -0800330
331 else:
332 main.log.info("Devices (expected): %s, Links (expected): %s" %
333 ( str( main.numMNswitches ), str( main.numMNlinks ) ) )
334 main.log.info("Devices (actual): %s, Links (actual): %s" %
335 ( numOnosDevices , numOnosLinks ) )
336 main.log.info("Topology does not match, exiting CHO test...")
kelvin-onlab54400a92015-02-26 18:05:51 -0800337 #time.sleep(300)
338 main.cleanup()
339 main.exit()
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800340
kelvin-onlab8a832582015-01-16 17:06:11 -0800341 # just returning TRUE for now as this one just collects data
Hari Krishna22c3d412015-02-17 16:48:12 -0800342 case3Result = main.TRUE
343 utilities.assert_equals( expect=main.TRUE, actual=case3Result,
kelvin-onlab8a832582015-01-16 17:06:11 -0800344 onpass="Saving ONOS topology data test PASS",
345 onfail="Saving ONOS topology data test FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800346
kelvin-onlab8a832582015-01-16 17:06:11 -0800347 def CASE4( self, main ):
348 """
349 Enable onos-app-fwd, Verify Reactive forwarding through ping all and Disable it
350 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800351 import re
352 import copy
353 import time
kelvin-onlab8a832582015-01-16 17:06:11 -0800354 main.log.report( "Enable Reactive forwarding and Verify ping all" )
355 main.log.report( "______________________________________________" )
356 main.case( "Enable Reactive forwarding and Verify ping all" )
357 main.step( "Enable Reactive forwarding" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800358 installResult = main.TRUE
kelvin-onlab54400a92015-02-26 18:05:51 -0800359 feature = "onos-app-fwd"
360 CLI1 = (main.ONOScli1.featureInstall,feature)
361 CLI2 = (main.ONOScli2.featureInstall,feature)
362 CLI3 = (main.ONOScli3.featureInstall,feature)
363 CLI4 = (main.ONOScli4.featureInstall,feature)
364 CLI5 = (main.ONOScli5.featureInstall,feature)
365 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
366 pool = []
367 time1 = time.time()
368 for cli,feature in ONOSCLI:
369 t = main.Thread(target=cli,threadID=main.threadID,
370 name="featureInstall",args=[feature])
371 pool.append(t)
372 t.start()
373 main.threadID = main.threadID + 1
374
375 results = []
376 for thread in pool:
377 thread.join()
378 results.append(thread.result)
379 time2 = time.time()
380
381 if( all(result == main.TRUE for result in results) == False):
382 main.log.info("Did not install onos-app-fwd feature properly")
383 main.cleanup()
384 main.exit()
385 else:
386 main.log.info("Successful feature:install onos-app-fwd")
387 installResult = main.TRUE
388 main.log.info("Time for feature:install onos-app-fwd: %2f seconds" %(time2-time1))
389
kelvin-onlab8a832582015-01-16 17:06:11 -0800390 time.sleep( 5 )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800391
kelvin-onlab8a832582015-01-16 17:06:11 -0800392 main.step( "Verify Pingall" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800393 ping_result = main.FALSE
394 time1 = time.time()
kelvin-onlab54400a92015-02-26 18:05:51 -0800395 ping_result = main.Mininet1.pingall(timeout=main.pingTimeout)
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800396 time2 = time.time()
kelvin-onlab8a832582015-01-16 17:06:11 -0800397 timeDiff = round( ( time2 - time1 ), 2 )
398 main.log.report(
399 "Time taken for Ping All: " +
400 str( timeDiff ) +
401 " seconds" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800402
403 if ping_result == main.TRUE:
kelvin-onlab8a832582015-01-16 17:06:11 -0800404 main.log.report( "Pingall Test in Reactive mode successful" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800405 else:
kelvin-onlab8a832582015-01-16 17:06:11 -0800406 main.log.report( "Pingall Test in Reactive mode failed" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800407
kelvin-onlab8a832582015-01-16 17:06:11 -0800408 main.step( "Disable Reactive forwarding" )
kelvin-onlab54400a92015-02-26 18:05:51 -0800409 uninstallResult = main.FALSE
410 CLI1 = (main.ONOScli1.featureUninstall,"onos-app-fwd")
411 CLI2 = (main.ONOScli2.featureUninstall,"onos-app-fwd")
412 CLI3 = (main.ONOScli3.featureUninstall,"onos-app-fwd")
413 CLI4 = (main.ONOScli4.featureUninstall,"onos-app-fwd")
414 CLI5 = (main.ONOScli5.featureUninstall,"onos-app-fwd")
415 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
416 pool = []
417 time1 = time.time()
418 for cli,feature in ONOSCLI:
419 t = main.Thread(target=cli,threadID=main.threadID,
420 name="featureUninstall",args=[feature])
421 pool.append(t)
422 t.start()
423 main.threadID = main.threadID + 1
424
425 results = []
426 for thread in pool:
427 thread.join()
428 results.append(thread.result)
429 time2 = time.time()
430
431 if( all(result == main.TRUE for result in results) == False):
432 main.log.info("Did not uninstall onos-app-fwd feature properly")
433 main.cleanup()
434 main.exit()
435 else:
436 main.log.info("Successful feature:uninstall onos-app-fwd")
437 uninstallResult = main.TRUE
438 main.log.info("Time for feature:uninstall onos-app-fwd: %2f seconds" %(time2-time1))
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800439
kelvin-onlab8a832582015-01-16 17:06:11 -0800440 # Waiting for reative flows to be cleared.
kelvin-onlab54400a92015-02-26 18:05:51 -0800441 time.sleep( 5 )
442 case4Result = installResult and uninstallResult and ping_result
443 utilities.assert_equals( expect=main.TRUE, actual=case4Result,
kelvin-onlab8a832582015-01-16 17:06:11 -0800444 onpass="Reactive Mode Pingall test PASS",
445 onfail="Reactive Mode Pingall test FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800446
kelvin-onlab8a832582015-01-16 17:06:11 -0800447 def CASE5( self, main ):
448 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800449 Compare current ONOS topology with reference data
kelvin-onlab8a832582015-01-16 17:06:11 -0800450 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800451 import re
kelvin-onlab54400a92015-02-26 18:05:51 -0800452
Hari Krishna22c3d412015-02-17 16:48:12 -0800453 devicesDPIDTemp = []
454 hostMACsTemp = []
455 deviceLinksTemp = []
456 deviceActiveLinksCountTemp = []
457 devicePortsEnabledCountTemp = []
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800458
kelvin-onlab8a832582015-01-16 17:06:11 -0800459 main.log.report(
460 "Compare ONOS topology with reference data in Stores" )
461 main.log.report( "__________________________________________________" )
462 main.case( "Compare ONOS topology with reference data" )
463
464 main.step( "Compare current Device ports enabled with reference" )
kelvin-onlab54400a92015-02-26 18:05:51 -0800465
466 CLI1 = (main.ONOScli1)
467 CLI2 = (main.ONOScli2)
468 CLI3 = (main.ONOScli3)
469 CLI4 = (main.ONOScli4)
470 CLI5 = (main.ONOScli5)
471 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
472 time1 = time.time()
473
474 for i in xrange(1,(main.numMNswitches + 1),5):
475 pool = []
476 for cli in ONOSCLI:
477 dpid = "of:00000000000000" + format( i,'02x' )
478 t = main.Thread(target = cli.getDevicePortsEnabledCount,threadID = main.threadID, name = "getDevicePortsEnabledCount",args = [dpid])
479 t.start()
480 pool.append(t)
481 i = i + 1
482 main.threadID = main.threadID + 1
483 for thread in pool:
484 thread.join()
485 portResult = thread.result
486 portTemp = re.split( r'\t+', portResult )
487 portCount = portTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
488 devicePortsEnabledCountTemp.append( portCount )
489 print "Device Enabled Port Counts Stored: \n", str( main.devicePortsEnabledCount )
490 time2 = time.time()
491 main.log.info("Time for counting enabled ports of the switches: %2f seconds" %(time2-time1))
492
493
494 """
kelvin-onlab8a832582015-01-16 17:06:11 -0800495 for i in range( 1, 26 ):
496 portResult = main.ONOScli1.getDevicePortsEnabledCount(
497 "of:00000000000000" +
498 format(
499 i,
500 '02x' ) )
501 portTemp = re.split( r'\t+', portResult )
502 portCount = portTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
Hari Krishna22c3d412015-02-17 16:48:12 -0800503 devicePortsEnabledCountTemp.append( portCount )
kelvin-onlab8a832582015-01-16 17:06:11 -0800504 time.sleep( 2 )
kelvin-onlab54400a92015-02-26 18:05:51 -0800505 """
Hari Krishna22c3d412015-02-17 16:48:12 -0800506 main.log.info (
507 "Device Enabled ports EXPECTED: %s" %
508 str( main.devicePortsEnabledCount ) )
509 main.log.info (
510 "Device Enabled ports ACTUAL: %s" %
511 str( devicePortsEnabledCountTemp ) )
kelvin-onlab54400a92015-02-26 18:05:51 -0800512
Hari Krishna22c3d412015-02-17 16:48:12 -0800513 if ( cmp( main.devicePortsEnabledCount,
514 devicePortsEnabledCountTemp ) == 0 ):
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800515 stepResult1 = main.TRUE
516 else:
517 stepResult1 = main.FALSE
518
kelvin-onlab8a832582015-01-16 17:06:11 -0800519 main.step( "Compare Device active links with reference" )
kelvin-onlab54400a92015-02-26 18:05:51 -0800520 time1 = time.time()
521 for i in xrange(1,(main.numMNswitches + 1),5):
522 pool = []
523 for cli in ONOSCLI:
524 dpid = "of:00000000000000" + format( i,'02x' )
525 t = main.Thread(target = cli.getDeviceLinksActiveCount,threadID = main.threadID, name = "getDevicePortsEnabledCount",args = [dpid])
526 t.start()
527 pool.append(t)
528 i = i + 1
529 main.threadID = main.threadID + 1
530 for thread in pool:
531 thread.join()
532 linkCountResult = thread.result
533 linkCountTemp = re.split( r'\t+', linkCountResult )
534 linkCount = linkCountTemp[ 1 ].replace( "\r\r\n\x1b[32m", "" )
535 deviceActiveLinksCountTemp.append( linkCount )
536 print "Device Active Links Count Stored: \n", str( main.deviceActiveLinksCount )
537 time2 = time.time()
538 main.log.info("Time for counting all enabled links of the switches: %2f seconds" %(time2-time1))
Hari Krishna22c3d412015-02-17 16:48:12 -0800539 main.log.info (
540 "Device Active links EXPECTED: %s" %
541 str( main.deviceActiveLinksCount ) )
542 main.log.info (
543 "Device Active links ACTUAL: %s" % str( deviceActiveLinksCountTemp ) )
544 if ( cmp( main.deviceActiveLinksCount, deviceActiveLinksCountTemp ) == 0 ):
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800545 stepResult2 = main.TRUE
546 else:
547 stepResult2 = main.FALSE
548
kelvin-onlab8a832582015-01-16 17:06:11 -0800549 """
Hari Krishna22c3d412015-02-17 16:48:12 -0800550 place holder for comparing devices, hosts, paths and intents if required.
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800551 Links and ports data would be incorrect with out devices anyways.
kelvin-onlab8a832582015-01-16 17:06:11 -0800552 """
Hari Krishna22c3d412015-02-17 16:48:12 -0800553 case5Result = ( stepResult1 and stepResult2 )
554 utilities.assert_equals( expect=main.TRUE, actual=case5Result,
kelvin-onlab8a832582015-01-16 17:06:11 -0800555 onpass="Compare Topology test PASS",
556 onfail="Compare Topology test FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800557
kelvin-onlab8a832582015-01-16 17:06:11 -0800558 def CASE6( self ):
559 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800560 Install 300 host intents and verify ping all
kelvin-onlab8a832582015-01-16 17:06:11 -0800561 """
562 main.log.report( "Add 300 host intents and verify pingall" )
563 main.log.report( "_______________________________________" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800564 import itertools
kelvin-onlab54400a92015-02-26 18:05:51 -0800565
kelvin-onlab8a832582015-01-16 17:06:11 -0800566 main.case( "Install 300 host intents" )
567 main.step( "Add host Intents" )
568 intentResult = main.TRUE
kelvin-onlab54400a92015-02-26 18:05:51 -0800569 hostCombos = list( itertools.combinations( main.hostMACs, 2 ) )
570
571 CLI1 = (main.ONOScli1.addHostIntent)
572 CLI2 = (main.ONOScli2.addHostIntent)
573 CLI3 = (main.ONOScli3.addHostIntent)
574 CLI4 = (main.ONOScli4.addHostIntent)
575 CLI5 = (main.ONOScli5.addHostIntent)
576 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
577 results = main.TRUE
578 intentIdList = []
579 time1 = time.time()
580 for i in xrange(0,len(hostCombos),5):
581 pool = []
582 for cli in ONOSCLI:
583 if i >= len(hostCombos):
584 break
585 t = main.Thread(target=cli,threadID=main.threadID,
586 name="addHostIntent",
587 args=[hostCombos[i][0],hostCombos[i][1]])
588 pool.append(t)
589 t.start()
590 i = i + 1
591 main.threadID = main.threadID + 1
592 for thread in pool:
593 thread.join()
594 intentIdList.append(thread.result)
595 time2 = time.time()
596 main.log.info("Time for adding host intents: %2f seconds" %(time2-time1))
597 intentResult = main.TRUE
598 intentsJson = main.ONOScli2.intents()
599 getIntentResult = main.ONOScli1.getIntentState(intentsId = intentIdList,
600 intentsJson = intentsJson)
601 print getIntentResult
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800602
kelvin-onlab8a832582015-01-16 17:06:11 -0800603 main.step( "Verify Ping across all hosts" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800604 pingResult = main.FALSE
605 time1 = time.time()
kelvin-onlab54400a92015-02-26 18:05:51 -0800606 pingResult = main.Mininet1.pingall(timeout=main.pingTimeout)
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800607 time2 = time.time()
kelvin-onlab8a832582015-01-16 17:06:11 -0800608 timeDiff = round( ( time2 - time1 ), 2 )
609 main.log.report(
610 "Time taken for Ping All: " +
611 str( timeDiff ) +
612 " seconds" )
613 utilities.assert_equals( expect=main.TRUE, actual=pingResult,
614 onpass="PING ALL PASS",
615 onfail="PING ALL FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800616
kelvin-onlab8a832582015-01-16 17:06:11 -0800617 case4Result = ( intentResult and pingResult )
kelvin-onlab54400a92015-02-26 18:05:51 -0800618
Hari Krishna46997e02015-01-27 11:23:07 -0800619 #case4Result = pingResult
kelvin-onlab8a832582015-01-16 17:06:11 -0800620 utilities.assert_equals(
621 expect=main.TRUE,
622 actual=case4Result,
623 onpass="Install 300 Host Intents and Ping All test PASS",
624 onfail="Install 300 Host Intents and Ping All test FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800625
kelvin-onlab8a832582015-01-16 17:06:11 -0800626 def CASE70( self, main ):
627 """
628 Randomly bring some core links down and verify ping all ( Host Intents Scenario )
629 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800630 import random
Hari Krishna22c3d412015-02-17 16:48:12 -0800631 main.randomLink1 = []
632 main.randomLink2 = []
633 main.randomLink3 = []
kelvin-onlab8a832582015-01-16 17:06:11 -0800634 link1End1 = main.params[ 'CORELINKS' ][ 'linkS3a' ]
635 link1End2 = main.params[ 'CORELINKS' ][ 'linkS3b' ].split( ',' )
636 link2End1 = main.params[ 'CORELINKS' ][ 'linkS14a' ]
637 link2End2 = main.params[ 'CORELINKS' ][ 'linkS14b' ].split( ',' )
638 link3End1 = main.params[ 'CORELINKS' ][ 'linkS18a' ]
639 link3End2 = main.params[ 'CORELINKS' ][ 'linkS18b' ].split( ',' )
640 switchLinksToToggle = main.params[ 'CORELINKS' ][ 'toggleLinks' ]
641 link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800642
Hari Krishnad97213e2015-01-24 19:30:14 -0800643 main.log.report( "Host intents - Randomly bring some core links down and verify ping all" )
644 main.log.report( "_________________________________________________________________" )
645 main.case( "Host intents - Randomly bring some core links down and verify ping all" )
646 main.step( "Verify number of Switch links to toggle on each Core Switch are between 1 - 5" )
kelvin-onlab8a832582015-01-16 17:06:11 -0800647 if ( int( switchLinksToToggle ) ==
648 0 or int( switchLinksToToggle ) > 5 ):
Hari Krishna46997e02015-01-27 11:23:07 -0800649 main.log.info( "Please check your PARAMS file. Valid range for number of switch links to toggle is between 1 to 5" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800650 main.cleanup()
651 main.exit()
652 else:
Hari Krishnad97213e2015-01-24 19:30:14 -0800653 main.log.info( "User provided Core switch links range to toggle is correct, proceeding to run the test" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800654
kelvin-onlab8a832582015-01-16 17:06:11 -0800655 main.step( "Cut links on Core devices using user provided range" )
Hari Krishna22c3d412015-02-17 16:48:12 -0800656 main.randomLink1 = random.sample( link1End2, int( switchLinksToToggle ) )
657 main.randomLink2 = random.sample( link2End2, int( switchLinksToToggle ) )
658 main.randomLink3 = random.sample( link3End2, int( switchLinksToToggle ) )
kelvin-onlab8a832582015-01-16 17:06:11 -0800659 for i in range( int( switchLinksToToggle ) ):
660 main.Mininet1.link(
661 END1=link1End1,
Hari Krishna22c3d412015-02-17 16:48:12 -0800662 END2=main.randomLink1[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800663 OPTION="down" )
664 main.Mininet1.link(
665 END1=link2End1,
Hari Krishna22c3d412015-02-17 16:48:12 -0800666 END2=main.randomLink2[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800667 OPTION="down" )
668 main.Mininet1.link(
669 END1=link3End1,
Hari Krishna22c3d412015-02-17 16:48:12 -0800670 END2=main.randomLink3[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800671 OPTION="down" )
672 time.sleep( link_sleep )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800673
674 topology_output = main.ONOScli2.topology()
Hari Krishnad97213e2015-01-24 19:30:14 -0800675 linkDown = main.ONOSbench.checkStatus(
Hari Krishna22c3d412015-02-17 16:48:12 -0800676 topology_output, main.numMNswitches, str(
677 int( main.numMNlinks ) - int( switchLinksToToggle ) * 6 ) )
kelvin-onlab8a832582015-01-16 17:06:11 -0800678 utilities.assert_equals(
679 expect=main.TRUE,
680 actual=linkDown,
681 onpass="Link Down discovered properly",
682 onfail="Link down was not discovered in " +
683 str( link_sleep ) +
684 " seconds" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800685
kelvin-onlab8a832582015-01-16 17:06:11 -0800686 main.step( "Verify Ping across all hosts" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800687 pingResultLinkDown = main.FALSE
688 time1 = time.time()
kelvin-onlab54400a92015-02-26 18:05:51 -0800689 pingResultLinkDown = main.Mininet1.pingall(timeout=main.pingTimeout)
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800690 time2 = time.time()
kelvin-onlab8a832582015-01-16 17:06:11 -0800691 timeDiff = round( ( time2 - time1 ), 2 )
692 main.log.report(
693 "Time taken for Ping All: " +
694 str( timeDiff ) +
695 " seconds" )
696 utilities.assert_equals( expect=main.TRUE, actual=pingResultLinkDown,
697 onpass="PING ALL PASS",
698 onfail="PING ALL FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800699
Hari Krishna22c3d412015-02-17 16:48:12 -0800700 caseResult70 = linkDown and pingResultLinkDown
701 utilities.assert_equals( expect=main.TRUE, actual=caseResult70,
kelvin-onlab8a832582015-01-16 17:06:11 -0800702 onpass="Random Link cut Test PASS",
703 onfail="Random Link cut Test FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800704
kelvin-onlab8a832582015-01-16 17:06:11 -0800705 def CASE80( self, main ):
706 """
707 Bring the core links up that are down and verify ping all ( Host Intents Scenario )
708 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800709 import random
kelvin-onlab8a832582015-01-16 17:06:11 -0800710 link1End1 = main.params[ 'CORELINKS' ][ 'linkS3a' ]
711 link2End1 = main.params[ 'CORELINKS' ][ 'linkS14a' ]
712 link3End1 = main.params[ 'CORELINKS' ][ 'linkS18a' ]
713 link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
714 switchLinksToToggle = main.params[ 'CORELINKS' ][ 'toggleLinks' ]
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800715
kelvin-onlab8a832582015-01-16 17:06:11 -0800716 main.log.report(
717 "Host intents - Bring the core links up that are down and verify ping all" )
718 main.log.report(
719 "__________________________________________________________________" )
720 main.case(
721 "Host intents - Bring the core links up that are down and verify ping all" )
722 main.step( "Bring randomly cut links on Core devices up" )
723 for i in range( int( switchLinksToToggle ) ):
724 main.Mininet1.link(
725 END1=link1End1,
kelvin-onlab54400a92015-02-26 18:05:51 -0800726 END2=main.randomLink1[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800727 OPTION="up" )
728 main.Mininet1.link(
729 END1=link2End1,
kelvin-onlab54400a92015-02-26 18:05:51 -0800730 END2=main.randomLink2[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800731 OPTION="up" )
732 main.Mininet1.link(
733 END1=link3End1,
kelvin-onlab54400a92015-02-26 18:05:51 -0800734 END2=main.randomLink3[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800735 OPTION="up" )
736 time.sleep( link_sleep )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800737
738 topology_output = main.ONOScli2.topology()
Hari Krishnad97213e2015-01-24 19:30:14 -0800739 linkUp = main.ONOSbench.checkStatus(
kelvin-onlab8a832582015-01-16 17:06:11 -0800740 topology_output,
Hari Krishna22c3d412015-02-17 16:48:12 -0800741 main.numMNswitches,
742 str( main.numMNlinks ) )
kelvin-onlab8a832582015-01-16 17:06:11 -0800743 utilities.assert_equals(
744 expect=main.TRUE,
745 actual=linkUp,
746 onpass="Link up discovered properly",
747 onfail="Link up was not discovered in " +
748 str( link_sleep ) +
749 " seconds" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800750
kelvin-onlab8a832582015-01-16 17:06:11 -0800751 main.step( "Verify Ping across all hosts" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800752 pingResultLinkUp = main.FALSE
753 time1 = time.time()
754 pingResultLinkUp = main.Mininet1.pingall()
755 time2 = time.time()
kelvin-onlab8a832582015-01-16 17:06:11 -0800756 timeDiff = round( ( time2 - time1 ), 2 )
757 main.log.report(
758 "Time taken for Ping All: " +
759 str( timeDiff ) +
760 " seconds" )
761 utilities.assert_equals( expect=main.TRUE, actual=pingResultLinkUp,
762 onpass="PING ALL PASS",
763 onfail="PING ALL FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800764
Hari Krishna22c3d412015-02-17 16:48:12 -0800765 caseResult80 = linkUp and pingResultLinkUp
766 utilities.assert_equals( expect=main.TRUE, actual=caseResult80,
kelvin-onlab8a832582015-01-16 17:06:11 -0800767 onpass="Link Up Test PASS",
768 onfail="Link Up Test FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800769
kelvin-onlab8a832582015-01-16 17:06:11 -0800770 def CASE71( self, main ):
771 """
772 Randomly bring some core links down and verify ping all ( Point Intents Scenario )
773 """
kelvin8ec71442015-01-15 16:57:00 -0800774 import random
Hari Krishna22c3d412015-02-17 16:48:12 -0800775 main.randomLink1 = []
776 main.randomLink2 = []
777 main.randomLink3 = []
kelvin-onlab8a832582015-01-16 17:06:11 -0800778 link1End1 = main.params[ 'CORELINKS' ][ 'linkS3a' ]
779 link1End2 = main.params[ 'CORELINKS' ][ 'linkS3b' ].split( ',' )
780 link2End1 = main.params[ 'CORELINKS' ][ 'linkS14a' ]
781 link2End2 = main.params[ 'CORELINKS' ][ 'linkS14b' ].split( ',' )
782 link3End1 = main.params[ 'CORELINKS' ][ 'linkS18a' ]
783 link3End2 = main.params[ 'CORELINKS' ][ 'linkS18b' ].split( ',' )
784 switchLinksToToggle = main.params[ 'CORELINKS' ][ 'toggleLinks' ]
785 link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
kelvin8ec71442015-01-15 16:57:00 -0800786
Hari Krishnad97213e2015-01-24 19:30:14 -0800787 main.log.report( "Point Intents - Randomly bring some core links down and verify ping all" )
788 main.log.report( "__________________________________________________________________" )
789 main.case( "Point Intents - Randomly bring some core links down and verify ping all" )
790 main.step( "Verify number of Switch links to toggle on each Core Switch are between 1 - 5" )
kelvin-onlab8a832582015-01-16 17:06:11 -0800791 if ( int( switchLinksToToggle ) ==
792 0 or int( switchLinksToToggle ) > 5 ):
793 main.log.info(
794 "Please check you PARAMS file. Valid range for number of switch links to toggle is between 1 to 5" )
kelvin8ec71442015-01-15 16:57:00 -0800795 main.cleanup()
796 main.exit()
797 else:
kelvin-onlab8a832582015-01-16 17:06:11 -0800798 main.log.info(
799 "User provided Core switch links range to toggle is correct, proceeding to run the test" )
kelvin8ec71442015-01-15 16:57:00 -0800800
kelvin-onlab8a832582015-01-16 17:06:11 -0800801 main.step( "Cut links on Core devices using user provided range" )
802 randomLink1 = random.sample( link1End2, int( switchLinksToToggle ) )
803 randomLink2 = random.sample( link2End2, int( switchLinksToToggle ) )
804 randomLink3 = random.sample( link3End2, int( switchLinksToToggle ) )
805 for i in range( int( switchLinksToToggle ) ):
806 main.Mininet1.link(
807 END1=link1End1,
Hari Krishna22c3d412015-02-17 16:48:12 -0800808 END2=main.randomLink1[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800809 OPTION="down" )
810 main.Mininet1.link(
811 END1=link2End1,
Hari Krishna22c3d412015-02-17 16:48:12 -0800812 END2=main.randomLink2[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800813 OPTION="down" )
814 main.Mininet1.link(
815 END1=link3End1,
Hari Krishna22c3d412015-02-17 16:48:12 -0800816 END2=main.randomLink3[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800817 OPTION="down" )
818 time.sleep( link_sleep )
kelvin8ec71442015-01-15 16:57:00 -0800819
820 topology_output = main.ONOScli2.topology()
Hari Krishnad97213e2015-01-24 19:30:14 -0800821 linkDown = main.ONOSbench.checkStatus(
Hari Krishna22c3d412015-02-17 16:48:12 -0800822 topology_output, main.numSwitches, str(
823 int( main.numLinks ) - int( switchLinksToToggle ) * 6 ) )
kelvin-onlab8a832582015-01-16 17:06:11 -0800824 utilities.assert_equals(
825 expect=main.TRUE,
826 actual=linkDown,
827 onpass="Link Down discovered properly",
828 onfail="Link down was not discovered in " +
829 str( link_sleep ) +
830 " seconds" )
kelvin8ec71442015-01-15 16:57:00 -0800831
kelvin-onlab8a832582015-01-16 17:06:11 -0800832 main.step( "Verify Ping across all hosts" )
kelvin8ec71442015-01-15 16:57:00 -0800833 pingResultLinkDown = main.FALSE
834 time1 = time.time()
835 pingResultLinkDown = main.Mininet1.pingall()
836 time2 = time.time()
kelvin-onlab8a832582015-01-16 17:06:11 -0800837 timeDiff = round( ( time2 - time1 ), 2 )
838 main.log.report(
839 "Time taken for Ping All: " +
840 str( timeDiff ) +
841 " seconds" )
842 utilities.assert_equals( expect=main.TRUE, actual=pingResultLinkDown,
843 onpass="PING ALL PASS",
844 onfail="PING ALL FAIL" )
kelvin8ec71442015-01-15 16:57:00 -0800845
846 caseResult7 = linkDown and pingResultLinkDown
kelvin-onlab8a832582015-01-16 17:06:11 -0800847 utilities.assert_equals( expect=main.TRUE, actual=caseResult7,
848 onpass="Random Link cut Test PASS",
849 onfail="Random Link cut Test FAIL" )
kelvin8ec71442015-01-15 16:57:00 -0800850
kelvin-onlab8a832582015-01-16 17:06:11 -0800851 def CASE81( self, main ):
852 """
853 Bring the core links up that are down and verify ping all ( Point Intents Scenario )
854 """
kelvin8ec71442015-01-15 16:57:00 -0800855 import random
kelvin-onlab8a832582015-01-16 17:06:11 -0800856 link1End1 = main.params[ 'CORELINKS' ][ 'linkS3a' ]
857 link2End1 = main.params[ 'CORELINKS' ][ 'linkS14a' ]
858 link3End1 = main.params[ 'CORELINKS' ][ 'linkS18a' ]
859 link_sleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
860 switchLinksToToggle = main.params[ 'CORELINKS' ][ 'toggleLinks' ]
kelvin8ec71442015-01-15 16:57:00 -0800861
kelvin-onlab8a832582015-01-16 17:06:11 -0800862 main.log.report(
863 "Point intents - Bring the core links up that are down and verify ping all" )
864 main.log.report(
865 "___________________________________________________________________" )
866 main.case(
867 "Point intents - Bring the core links up that are down and verify ping all" )
868 main.step( "Bring randomly cut links on Core devices up" )
869 for i in range( int( switchLinksToToggle ) ):
870 main.Mininet1.link(
871 END1=link1End1,
Hari Krishna22c3d412015-02-17 16:48:12 -0800872 END2=main.randomLink1[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800873 OPTION="up" )
874 main.Mininet1.link(
875 END1=link2End1,
Hari Krishna22c3d412015-02-17 16:48:12 -0800876 END2=main.randomLink2[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800877 OPTION="up" )
878 main.Mininet1.link(
879 END1=link3End1,
Hari Krishna22c3d412015-02-17 16:48:12 -0800880 END2=main.randomLink3[ i ],
kelvin-onlab8a832582015-01-16 17:06:11 -0800881 OPTION="up" )
882 time.sleep( link_sleep )
kelvin8ec71442015-01-15 16:57:00 -0800883
884 topology_output = main.ONOScli2.topology()
Hari Krishnad97213e2015-01-24 19:30:14 -0800885 linkUp = main.ONOSbench.checkStatus(
kelvin-onlab8a832582015-01-16 17:06:11 -0800886 topology_output,
Hari Krishna22c3d412015-02-17 16:48:12 -0800887 main.numMNswitches,
888 str( main.numMNlinks ) )
kelvin-onlab8a832582015-01-16 17:06:11 -0800889 utilities.assert_equals(
890 expect=main.TRUE,
891 actual=linkUp,
892 onpass="Link up discovered properly",
893 onfail="Link up was not discovered in " +
894 str( link_sleep ) +
895 " seconds" )
kelvin8ec71442015-01-15 16:57:00 -0800896
kelvin-onlab8a832582015-01-16 17:06:11 -0800897 main.step( "Verify Ping across all hosts" )
kelvin8ec71442015-01-15 16:57:00 -0800898 pingResultLinkUp = main.FALSE
899 time1 = time.time()
900 pingResultLinkUp = main.Mininet1.pingall()
901 time2 = time.time()
kelvin-onlab8a832582015-01-16 17:06:11 -0800902 timeDiff = round( ( time2 - time1 ), 2 )
903 main.log.report(
904 "Time taken for Ping All: " +
905 str( timeDiff ) +
906 " seconds" )
907 utilities.assert_equals( expect=main.TRUE, actual=pingResultLinkUp,
908 onpass="PING ALL PASS",
909 onfail="PING ALL FAIL" )
kelvin8ec71442015-01-15 16:57:00 -0800910
Hari Krishna22c3d412015-02-17 16:48:12 -0800911 caseResult81 = linkUp and pingResultLinkUp
912 utilities.assert_equals( expect=main.TRUE, actual=caseResult81,
kelvin-onlab8a832582015-01-16 17:06:11 -0800913 onpass="Link Up Test PASS",
914 onfail="Link Up Test FAIL" )
kelvin8ec71442015-01-15 16:57:00 -0800915
kelvin-onlab8a832582015-01-16 17:06:11 -0800916 def CASE9( self ):
917 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800918 Install 114 point intents and verify Ping all works
kelvin-onlab8a832582015-01-16 17:06:11 -0800919 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800920 import copy
kelvin-onlab8a832582015-01-16 17:06:11 -0800921 main.log.report( "Install 114 point intents and verify Ping all" )
922 main.log.report( "___________________________________________" )
923 main.case( "Install 114 point intents and Ping all" )
Hari Krishna22c3d412015-02-17 16:48:12 -0800924 deviceLinksCopy = copy.copy( main.deviceLinks )
kelvin-onlab8a832582015-01-16 17:06:11 -0800925 main.step( "Install 114 point intents" )
Hari Krishna22c3d412015-02-17 16:48:12 -0800926 for i in range( len( deviceLinksCopy ) ):
kelvin-onlab8a832582015-01-16 17:06:11 -0800927 pointLink = str(
Hari Krishna22c3d412015-02-17 16:48:12 -0800928 deviceLinksCopy[ i ] ).replace(
kelvin-onlab8a832582015-01-16 17:06:11 -0800929 "src=",
930 "" ).replace(
931 "dst=",
932 "" ).split( ',' )
933 point1 = pointLink[ 0 ].split( '/' )
934 point2 = pointLink[ 1 ].split( '/' )
Hari Krishnad97213e2015-01-24 19:30:14 -0800935 installResult = main.ONOScli1.addPointIntent(
kelvin-onlab8a832582015-01-16 17:06:11 -0800936 point1[ 0 ], point2[ 0 ], int(
937 point1[ 1 ] ), int(
938 point2[ 1 ] ) )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800939 if installResult == main.TRUE:
kelvin-onlab8a832582015-01-16 17:06:11 -0800940 print "Installed Point intent between :", point1[ 0 ], int( point1[ 1 ] ), point2[ 0 ], int( point2[ 1 ] )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800941
kelvin-onlab8a832582015-01-16 17:06:11 -0800942 main.step( "Obtain the intent id's" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800943 intentsList = main.ONOScli1.getAllIntentIds()
kelvin-onlab8a832582015-01-16 17:06:11 -0800944 ansi_escape = re.compile( r'\x1b[^m]*m' )
945 intentsList = ansi_escape.sub( '', intentsList )
946 intentsList = intentsList.replace(
947 " onos:intents | grep id=",
948 "" ).replace(
949 "id=",
950 "" ).replace(
951 "\r\r",
952 "" )
953 intentsList = intentsList.splitlines()
954 intentsList = intentsList[ 1: ]
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800955 intentIdList = []
kelvin-onlab8a832582015-01-16 17:06:11 -0800956 for i in range( len( intentsList ) ):
957 intentsTemp = intentsList[ i ].split( ',' )
958 intentIdList.append( intentsTemp[ 0 ] )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800959 print "Intent IDs: ", intentIdList
kelvin-onlab8a832582015-01-16 17:06:11 -0800960 print "Total Intents installed: ", len( intentIdList )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800961
kelvin-onlab8a832582015-01-16 17:06:11 -0800962 main.step( "Verify Ping across all hosts" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800963 pingResult = main.FALSE
964 time1 = time.time()
965 pingResult = main.Mininet1.pingall()
966 time2 = time.time()
kelvin-onlab8a832582015-01-16 17:06:11 -0800967 timeDiff = round( ( time2 - time1 ), 2 )
968 main.log.report(
969 "Time taken for Ping All: " +
970 str( timeDiff ) +
971 " seconds" )
972 utilities.assert_equals( expect=main.TRUE, actual=pingResult,
973 onpass="PING ALL PASS",
974 onfail="PING ALL FAIL" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800975
976 case8_result = installResult and pingResult
kelvin-onlab8a832582015-01-16 17:06:11 -0800977 utilities.assert_equals(
978 expect=main.TRUE,
979 actual=case8_result,
980 onpass="Ping all test after Point intents addition successful",
981 onfail="Ping all test after Point intents addition failed" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800982
kelvin-onlab8a832582015-01-16 17:06:11 -0800983 def CASE10( self ):
984 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800985 Remove all Intents
kelvin-onlab8a832582015-01-16 17:06:11 -0800986 """
987 main.log.report( "Remove all intents that were installed previously" )
988 main.log.report( "______________________________________________" )
989 main.log.info( "Remove all intents" )
990 main.case( "Removing intents" )
991 main.step( "Obtain the intent id's first" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -0800992 intentsList = main.ONOScli1.getAllIntentIds()
kelvin-onlab8a832582015-01-16 17:06:11 -0800993 ansi_escape = re.compile( r'\x1b[^m]*m' )
994 intentsList = ansi_escape.sub( '', intentsList )
995 intentsList = intentsList.replace(
996 " onos:intents | grep id=",
997 "" ).replace(
998 "id=",
999 "" ).replace(
1000 "\r\r",
1001 "" )
1002 intentsList = intentsList.splitlines()
1003 intentsList = intentsList[ 1: ]
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001004 intentIdList = []
1005 step1Result = main.TRUE
kelvin-onlab8a832582015-01-16 17:06:11 -08001006 if ( len( intentsList ) > 1 ):
1007 for i in range( len( intentsList ) ):
1008 intentsTemp = intentsList[ i ].split( ',' )
1009 intentIdList.append( intentsTemp[ 0 ] )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001010 print "Intent IDs: ", intentIdList
kelvin-onlab54400a92015-02-26 18:05:51 -08001011
1012
1013 CLI1 = (main.ONOScli1.removeIntent)
1014 CLI2 = (main.ONOScli2.removeIntent)
1015 CLI3 = (main.ONOScli3.removeIntent)
1016 CLI4 = (main.ONOScli4.removeIntent)
1017 CLI5 = (main.ONOScli5.removeIntent)
1018 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
1019 results = main.TRUE
1020 time1 = time.time()
1021
1022 for i in xrange(0,len(intentIdList),5):
1023 pool = []
1024 for cli in ONOSCLI:
1025 if i >= len(intentIdList):
1026 break
1027 print "Removing intent id (round 1) :", intentIdList[ i ]
1028 t = main.Thread(target=cli,threadID=main.threadID,
1029 name="removeIntent",
kelvin-onlabfb521662015-02-27 09:52:40 -08001030 args=[intentIdList[i],'org.onosproject.cli',True,False])
kelvin-onlab54400a92015-02-26 18:05:51 -08001031 pool.append(t)
1032 t.start()
1033 i = i + 1
1034 main.threadID = main.threadID + 1
1035
1036 for thread in pool:
1037 thread.join()
1038 results = results and thread.result
1039
1040 time2 = time.time()
1041 main.log.info("Time for feature:install onos-app-fwd: %2f seconds" %(time2-time1))
1042 """
1043 for id in range( len( intentIdList ) ):
kelvin-onlab8a832582015-01-16 17:06:11 -08001044 print "Removing intent id (round 1) :", intentIdList[ id ]
Hari Krishna46997e02015-01-27 11:23:07 -08001045 main.ONOScli1.removeIntent( intentId=intentIdList[ id ] )
Hari Krishna22c3d412015-02-17 16:48:12 -08001046 #time.sleep( 1 )
kelvin-onlab54400a92015-02-26 18:05:51 -08001047 """
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001048
kelvin-onlab8a832582015-01-16 17:06:11 -08001049 main.log.info(
1050 "Verify all intents are removed and if any leftovers try remove one more time" )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001051 intentsList1 = main.ONOScli1.getAllIntentIds()
kelvin-onlab8a832582015-01-16 17:06:11 -08001052 ansi_escape = re.compile( r'\x1b[^m]*m' )
1053 intentsList1 = ansi_escape.sub( '', intentsList1 )
1054 intentsList1 = intentsList1.replace(
1055 " onos:intents | grep id=",
1056 "" ).replace(
1057 " state=",
1058 "" ).replace(
1059 "\r\r",
1060 "" )
1061 intentsList1 = intentsList1.splitlines()
1062 intentsList1 = intentsList1[ 1: ]
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001063 print "Round 2 (leftover) intents to remove: ", intentsList1
1064 intentIdList1 = []
kelvin-onlab8a832582015-01-16 17:06:11 -08001065 if ( len( intentsList1 ) > 1 ):
1066 for i in range( len( intentsList1 ) ):
kelvin-onlab54400a92015-02-26 18:05:51 -08001067 intentsTemp1 = intentsList1[ i ].split( ',' )
kelvin-onlab8a832582015-01-16 17:06:11 -08001068 intentIdList1.append( intentsTemp1[ 0 ] )
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001069 print "Leftover Intent IDs: ", intentIdList1
kelvin-onlab54400a92015-02-26 18:05:51 -08001070
1071 for i in xrange(0,len(intentIdList1),5):
1072 pool = []
1073 for cli in ONOSCLI:
1074 if i >= len(intentIdList):
1075 break
1076 print "Removing intent id (round 2) :", intentIdList1[ i ]
1077 t = main.Thread(target=cli,threadID=main.threadID,
1078 name="removeIntent",
1079 args=[intentIdList1[i]])
1080 pool.append(t)
1081 t.start()
1082 i = i + 1
1083 main.threadID = main.threadID + 1
1084
1085 for thread in pool:
1086 thread.join()
1087 results = results and thread.result
1088 step1Result = results
Hari Krishnaa43d4e92014-12-19 13:22:40 -08001089 else:
1090 print "There are no more intents that need to be removed"
1091 step1Result = main.TRUE
1092 else:
1093 print "No Intent IDs found in Intents list: ", intentsList
1094 step1Result = main.FALSE
1095
1096 caseResult7 = step1Result
kelvin-onlab8a832582015-01-16 17:06:11 -08001097 utilities.assert_equals( expect=main.TRUE, actual=caseResult7,
1098 onpass="Intent removal test successful",
1099 onfail="Intent removal test failed" )
Hari Krishna22c3d412015-02-17 16:48:12 -08001100
1101 def CASE11( self, main ):
1102 """
1103 Enable onos-app-ifwd, Verify Intent based Reactive forwarding through ping all and Disable it
1104 """
1105 import re
1106 import copy
1107 import time
1108
kelvin-onlab54400a92015-02-26 18:05:51 -08001109 Thread = imp.load_source('Thread','/home/admin/ONLabTest/TestON/tests/OnosCHO/Thread.py')
1110 threadID = 0
1111
Hari Krishna22c3d412015-02-17 16:48:12 -08001112 main.log.report( "Enable Intent based Reactive forwarding and Verify ping all" )
1113 main.log.report( "_____________________________________________________" )
1114 main.case( "Enable Intent based Reactive forwarding and Verify ping all" )
1115 main.step( "Enable intent based Reactive forwarding" )
kelvin-onlab54400a92015-02-26 18:05:51 -08001116 installResult = main.FALSE
1117 feature = "onos-app-ifwd"
1118 CLI1 = (main.ONOScli1.featureInstall,feature)
1119 CLI2 = (main.ONOScli2.featureInstall,feature)
1120 CLI3 = (main.ONOScli3.featureInstall,feature)
1121 CLI4 = (main.ONOScli4.featureInstall,feature)
1122 CLI5 = (main.ONOScli5.featureInstall,feature)
1123 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
1124 pool = []
1125 time1 = time.time()
1126 for cli,feature in ONOSCLI:
1127 t = main.Thread(target=cli,threadID=threadID,
1128 name="featureInstall",args=[feature])
1129 pool.append(t)
1130 t.start()
1131 threadID = threadID + 1
1132
1133 results = []
1134 for thread in pool:
1135 thread.join()
1136 results.append(thread.result)
1137 time2 = time.time()
1138
1139 if( all(result == main.TRUE for result in results) == False):
1140 main.log.info("Did not install onos-app-ifwd feature properly")
1141 main.cleanup()
1142 main.exit()
1143 else:
1144 main.log.info("Successful feature:install onos-app-ifwd")
1145 installResult = main.TRUE
1146 main.log.info("Time for feature:install onos-app-ifwd: %2f seconds" %(time2-time1))
1147
Hari Krishna22c3d412015-02-17 16:48:12 -08001148 main.step( "Verify Pingall" )
1149 ping_result = main.FALSE
1150 time1 = time.time()
kelvin-onlab54400a92015-02-26 18:05:51 -08001151 ping_result = main.Mininet1.pingall(timeout=600)
Hari Krishna22c3d412015-02-17 16:48:12 -08001152 time2 = time.time()
1153 timeDiff = round( ( time2 - time1 ), 2 )
1154 main.log.report(
1155 "Time taken for Ping All: " +
1156 str( timeDiff ) +
1157 " seconds" )
kelvin-onlab54400a92015-02-26 18:05:51 -08001158
Hari Krishna22c3d412015-02-17 16:48:12 -08001159 if ping_result == main.TRUE:
1160 main.log.report( "Pingall Test in Reactive mode successful" )
1161 else:
1162 main.log.report( "Pingall Test in Reactive mode failed" )
1163
1164 main.step( "Disable Intent based Reactive forwarding" )
kelvin-onlab54400a92015-02-26 18:05:51 -08001165 uninstallResult = main.FALSE
1166
1167 CLI1 = (main.ONOScli1.featureUninstall,feature)
1168 CLI2 = (main.ONOScli2.featureUninstall,feature)
1169 CLI3 = (main.ONOScli3.featureUninstall,feature)
1170 CLI4 = (main.ONOScli4.featureUninstall,feature)
1171 CLI5 = (main.ONOScli5.featureUninstall,feature)
1172 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
1173 pool = []
1174 time1 = time.time()
1175 for cli,feature in ONOSCLI:
1176 t = main.Thread(target=cli,threadID=threadID,
1177 name="featureUninstall",args=[feature])
1178 pool.append(t)
1179 t.start()
1180 threadID = threadID + 1
1181
1182 results = []
1183 for thread in pool:
1184 thread.join()
1185 results.append(thread.result)
1186 time2 = time.time()
1187
1188 if( all(result == main.TRUE for result in results) == False):
1189 main.log.info("Did not uninstall onos-app-ifwd feature properly")
1190 main.cleanup()
1191 main.exit()
1192 else:
1193 main.log.info("Successful feature:uninstall onos-app-ifwd")
1194 uninstallResult = main.TRUE
1195 main.log.info("Time for feature:uninstall onos-app-ifwd: %2f seconds" %(time2-time1))
Hari Krishna22c3d412015-02-17 16:48:12 -08001196
1197 # Waiting for reative flows to be cleared.
1198 time.sleep( 10 )
1199
1200 case11Result = installResult and ping_result and uninstallResult
1201 utilities.assert_equals( expect=main.TRUE, actual=case11Result,
1202 onpass="Intent based Reactive forwarding Pingall test PASS",
1203 onfail="Intent based Reactive forwarding Pingall test FAIL" )
1204
1205 def CASE12( self, main ):
1206 """
1207 This test script Loads a new Topology (Chordal) on CHO setup and balances all switches
1208 """
1209 import re
1210 import time
1211 import copy
kelvin-onlab54400a92015-02-26 18:05:51 -08001212
Hari Krishna22c3d412015-02-17 16:48:12 -08001213
kelvin-onlab54400a92015-02-26 18:05:51 -08001214 Thread = imp.load_source('Thread','/home/admin/ONLabTest/TestON/tests/OnosCHO/Thread.py')
Hari Krishna22c3d412015-02-17 16:48:12 -08001215 newTopo = main.params['TOPO2']['topo']
1216 main.numMNswitches = int ( main.params[ 'TOPO2' ][ 'numSwitches' ] )
1217 main.numMNlinks = int ( main.params[ 'TOPO2' ][ 'numLinks' ] )
1218 main.numMNhosts = int ( main.params[ 'TOPO2' ][ 'numHosts' ] )
kelvin-onlab54400a92015-02-26 18:05:51 -08001219 main.pingTimeout = 60
Hari Krishna22c3d412015-02-17 16:48:12 -08001220 main.log.report(
1221 "Load Chordal topology and Balance all Mininet switches across controllers" )
1222 main.log.report(
1223 "________________________________________________________________________" )
1224 # need to wait here for sometime until ONOS bootup
1225 time.sleep( 15 )
1226 main.case(
1227 "Assign and Balance all Mininet switches across controllers" )
1228 main.step( "Stop any previous Mininet network topology" )
1229 stopStatus = main.Mininet1.stopNet()
1230
1231 # WORK AROUND FOR ONOS-581. STOP ONOS BEFORE ASSIGNING CONTROLLERS AT MININET & START ONCE DONE
1232 main.step( "Stop ONOS on all Nodes" )
1233 stopResult = main.TRUE
1234 for i in range( 1, int( main.numCtrls ) + 1 ):
1235 ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
1236 main.log.info( "Stopping ONOS Node IP: " + ONOS_ip )
1237 sresult = main.ONOSbench.onosStop( ONOS_ip )
1238 utilities.assert_equals( expect=main.TRUE, actual=sresult,
1239 onpass="Test step PASS",
1240 onfail="Test step FAIL" )
1241 stopResult = ( stopResult and sresult )
1242
1243 main.step( "Start Mininet with Chordal topology" )
1244 startStatus = main.Mininet1.startNet(topoFile = newTopo)
1245
1246 main.step( "Assign switches to controllers" )
1247 for i in range( 1, ( main.numMNswitches + 1 ) ): # 1 to ( num of switches +1 )
1248 main.Mininet1.assignSwController(
1249 sw=str( i ),
1250 count=int( main.numCtrls ),
1251 ip1=main.ONOS1_ip,
1252 port1=main.ONOS1_port,
1253 ip2=main.ONOS2_ip,
1254 port2=main.ONOS2_port,
1255 ip3=main.ONOS3_ip,
1256 port3=main.ONOS3_port,
1257 ip4=main.ONOS4_ip,
1258 port4=main.ONOS4_port,
1259 ip5=main.ONOS5_ip,
1260 port5=main.ONOS5_port )
1261
1262 switch_mastership = main.TRUE
1263 for i in range( 1, ( main.numMNswitches + 1 ) ):
1264 response = main.Mininet1.getSwController( "s" + str( i ) )
1265 print( "Response is " + str( response ) )
1266 if re.search( "tcp:" + main.ONOS1_ip, response ):
1267 switch_mastership = switch_mastership and main.TRUE
1268 else:
1269 switch_mastership = main.FALSE
1270
1271 if switch_mastership == main.TRUE:
1272 main.log.report( "Controller assignment successfull" )
1273 else:
1274 main.log.report( "Controller assignment failed" )
1275 time.sleep( 5 )
1276
1277 main.step( "Start ONOS on all Nodes" )
1278 startResult = main.TRUE
1279 for i in range( 1, int( main.numCtrls ) + 1 ):
1280 ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
1281 main.log.info( "Starting ONOS Node IP: " + ONOS_ip )
1282 sresult = main.ONOSbench.onosStart( ONOS_ip )
1283 utilities.assert_equals( expect=main.TRUE, actual=sresult,
1284 onpass="Test step PASS",
1285 onfail="Test step FAIL" )
1286 startResult = ( startResult and sresult )
1287
1288 main.step( "Start ONOS CLI on all nodes" )
1289 cliResult = main.TRUE
1290 #karafTimeout = "3600000" # This is not needed here as it is already set before.
1291 # need to wait here sometime for ONOS to bootup.
1292 time.sleep( 30 )
kelvin-onlab54400a92015-02-26 18:05:51 -08001293
1294 main.log.step(" Start ONOS cli using thread ")
1295
1296 CLI1 = (main.ONOScli1.startOnosCli,main.ONOS1_ip)
1297 CLI2 = (main.ONOScli2.startOnosCli,main.ONOS2_ip)
1298 CLI3 = (main.ONOScli3.startOnosCli,main.ONOS3_ip)
1299 CLI4 = (main.ONOScli4.startOnosCli,main.ONOS4_ip)
1300 CLI5 = (main.ONOScli5.startOnosCli,main.ONOS5_ip)
1301 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
1302 pool = []
1303 time1 = time.time()
1304 for cli,ip in ONOSCLI:
1305 t = main.Thread(target=cli,threadID=main.threadID,
1306 name="startOnosCli",args=[ip])
1307 pool.append(t)
1308 t.start()
1309 main.threadID = main.threadID + 1
1310
1311 cliResult = main.FALSE
1312 results = []
1313 for thread in pool:
1314 thread.join()
1315 results.append(thread.result)
1316 time2 = time.time()
1317
1318 if( all(result == main.TRUE for result in results) == False):
1319 main.log.info("ONOS CLI did not start up properly")
1320 main.cleanup()
1321 main.exit()
1322 else:
1323 main.log.info("Successful CLI startup")
1324 cliResult = main.TRUE
1325 main.log.info("Time for connecting to CLI: %2f seconds" %(time2-time1))
Hari Krishna22c3d412015-02-17 16:48:12 -08001326
1327 main.step( "Balance devices across controllers" )
1328 for i in range( int( main.numCtrls ) ):
1329 balanceResult = main.ONOScli1.balanceMasters()
1330 # giving some breathing time for ONOS to complete re-balance
1331 time.sleep( 3 )
1332
1333 case12Result = ( startResult and cliResult )
1334 utilities.assert_equals(
1335 expect=main.TRUE,
1336 actual=case12Result,
1337 onpass="Starting new Chordal topology test PASS",
1338 onfail="Starting new Chordal topology test FAIL" )
1339
1340 def CASE13( self, main ):
1341 """
1342 This test script Loads a new Topology (Spine) on CHO setup and balances all switches
1343 """
1344 import re
1345 import time
1346 import copy
1347
1348 newTopo = main.params['TOPO3']['topo']
1349 main.numMNswitches = int ( main.params[ 'TOPO3' ][ 'numSwitches' ] )
1350 main.numMNlinks = int ( main.params[ 'TOPO3' ][ 'numLinks' ] )
1351 main.numMNhosts = int ( main.params[ 'TOPO3' ][ 'numHosts' ] )
kelvin-onlab54400a92015-02-26 18:05:51 -08001352 main.pingTimeout = 600
Hari Krishna22c3d412015-02-17 16:48:12 -08001353 main.log.report(
1354 "Load Spine and Leaf topology and Balance all Mininet switches across controllers" )
1355 main.log.report(
1356 "________________________________________________________________________" )
1357 # need to wait here for sometime until ONOS bootup
1358 time.sleep( 15 )
1359 main.case(
1360 "Assign and Balance all Mininet switches across controllers" )
1361 main.step( "Stop any previous Mininet network topology" )
1362 stopStatus = main.Mininet1.stopNet()
1363
1364 # WORK AROUND FOR ONOS-581. STOP ONOS BEFORE ASSIGNING CONTROLLERS AT MININET & START ONCE DONE
1365 main.step( "Stop ONOS on all Nodes" )
1366 stopResult = main.TRUE
1367 for i in range( 1, int( main.numCtrls ) + 1 ):
1368 ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
1369 main.log.info( "Stopping ONOS Node IP: " + ONOS_ip )
1370 sresult = main.ONOSbench.onosStop( ONOS_ip )
1371 utilities.assert_equals( expect=main.TRUE, actual=sresult,
1372 onpass="Test step PASS",
1373 onfail="Test step FAIL" )
1374 stopResult = ( stopResult and sresult )
1375
1376 main.step( "Start Mininet with Spine topology" )
1377 startStatus = main.Mininet1.startNet(topoFile = newTopo)
1378
1379 main.step( "Assign switches to controllers" )
1380 for i in range( 1, ( main.numMNswitches + 1 ) ): # 1 to ( num of switches +1 )
1381 main.Mininet1.assignSwController(
1382 sw=str( i ),
1383 count=int( main.numCtrls ),
1384 ip1=main.ONOS1_ip,
1385 port1=main.ONOS1_port,
1386 ip2=main.ONOS2_ip,
1387 port2=main.ONOS2_port,
1388 ip3=main.ONOS3_ip,
1389 port3=main.ONOS3_port,
1390 ip4=main.ONOS4_ip,
1391 port4=main.ONOS4_port,
1392 ip5=main.ONOS5_ip,
1393 port5=main.ONOS5_port )
1394
1395 switch_mastership = main.TRUE
1396 for i in range( 1, ( main.numMNswitches + 1 ) ):
1397 response = main.Mininet1.getSwController( "s" + str( i ) )
1398 print( "Response is " + str( response ) )
1399 if re.search( "tcp:" + main.ONOS1_ip, response ):
1400 switch_mastership = switch_mastership and main.TRUE
1401 else:
1402 switch_mastership = main.FALSE
1403
1404 if switch_mastership == main.TRUE:
1405 main.log.report( "Controller assignment successfull" )
1406 else:
1407 main.log.report( "Controller assignment failed" )
1408 time.sleep( 5 )
1409
1410 main.step( "Start ONOS on all Nodes" )
1411 startResult = main.TRUE
1412 for i in range( 1, int( main.numCtrls ) + 1 ):
1413 ONOS_ip = main.params[ 'CTRL' ][ 'ip' + str( i ) ]
1414 main.log.info( "Starting ONOS Node IP: " + ONOS_ip )
1415 sresult = main.ONOSbench.onosStart( ONOS_ip )
1416 utilities.assert_equals( expect=main.TRUE, actual=sresult,
1417 onpass="Test step PASS",
1418 onfail="Test step FAIL" )
1419 startResult = ( startResult and sresult )
1420
1421 main.step( "Start ONOS CLI on all nodes" )
1422 cliResult = main.TRUE
1423 #karafTimeout = "3600000" # This is not needed here as it is already set before.
1424 # need to wait here sometime for ONOS to bootup.
1425 time.sleep( 30 )
kelvin-onlab54400a92015-02-26 18:05:51 -08001426
1427 main.log.step(" Start ONOS cli using thread ")
1428
1429 CLI1 = (main.ONOScli1.startOnosCli,main.ONOS1_ip)
1430 CLI2 = (main.ONOScli2.startOnosCli,main.ONOS2_ip)
1431 CLI3 = (main.ONOScli3.startOnosCli,main.ONOS3_ip)
1432 CLI4 = (main.ONOScli4.startOnosCli,main.ONOS4_ip)
1433 CLI5 = (main.ONOScli5.startOnosCli,main.ONOS5_ip)
1434 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
1435 pool = []
1436 time1 = time.time()
1437 for cli,ip in ONOSCLI:
1438 t = main.Thread(target=cli,threadID=main.threadID,
1439 name="startOnosCli",args=[ip])
1440 pool.append(t)
1441 t.start()
1442 main.threadID = main.threadID + 1
1443
1444 cliResult = main.FALSE
1445 results = []
1446 for thread in pool:
1447 thread.join()
1448 results.append(thread.result)
1449 time2 = time.time()
1450
1451 if( all(result == main.TRUE for result in results) == False):
1452 main.log.info("ONOS CLI did not start up properly")
1453 main.cleanup()
1454 main.exit()
1455 else:
1456 main.log.info("Successful CLI startup")
1457 cliResult = main.TRUE
1458 main.log.info("Time for connecting to CLI: %2f seconds" %(time2-time1))
1459
1460 main.step( "Balance devices across controllers" )
1461 for i in range( int( main.numCtrls ) ):
1462 balanceResult = main.ONOScli1.balanceMasters()
1463 # giving some breathing time for ONOS to complete re-balance
1464 time.sleep( 3 )
Hari Krishna22c3d412015-02-17 16:48:12 -08001465
1466 main.step( "Balance devices across controllers" )
1467 for i in range( int( main.numCtrls ) ):
1468 balanceResult = main.ONOScli1.balanceMasters()
1469 # giving some breathing time for ONOS to complete re-balance
1470 time.sleep( 3 )
1471
1472 case13Result = ( startResult and cliResult )
1473 utilities.assert_equals(
1474 expect=main.TRUE,
1475 actual=case13Result,
1476 onpass="Starting new Spine topology test PASS",
1477 onfail="Starting new Spine topology test FAIL" )
kelvin-onlab54400a92015-02-26 18:05:51 -08001478
1479 def CASE14(self,main):
1480 """
1481 Install 300 host intents and verify ping all
1482 """
1483 main.log.report( "Add 300 host intents and verify pingall" )
1484 main.log.report( "_______________________________________" )
1485 import itertools
1486
1487 main.case( "Install 300 host intents" )
1488 main.step( "Add host Intents" )
1489 intentResult = main.TRUE
1490 hostCombos = list( itertools.combinations( main.hostMACs, 2 ) )
1491
1492 CLI1 = (main.ONOScli1.addHostIntent)
1493 CLI2 = (main.ONOScli2.addHostIntent)
1494 CLI3 = (main.ONOScli3.addHostIntent)
1495 CLI4 = (main.ONOScli4.addHostIntent)
1496 CLI5 = (main.ONOScli5.addHostIntent)
1497 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
1498 results = main.TRUE
1499 time1 = time.time()
1500 for i in xrange(0,len(hostCombos),5):
1501 pool = []
1502 for cli in ONOSCLI:
1503 if i >= len(hostCombos):
1504 break
1505 t = main.Thread(target=cli,threadID=main.threadID,
1506 name="addHostIntent",
1507 args=[hostCombos[i][0],hostCombos[i][1]])
1508 pool.append(t)
1509 t.start()
1510 i = i + 1
1511 main.threadID = main.threadID + 1
1512
1513 for thread in pool:
1514 thread.join()
1515 results = results and thread.result
1516
1517 time2 = time.time()
1518
1519 main.log.info("Time for adding host intents: %2f seconds" %(time2-time1))
1520 intentResult = results
1521 """
1522 for i in range( len( hostCombos ) ):
1523 iResult = main.ONOScli1.addHostIntent(
1524 hostCombos[ i ][ 0 ],
1525 hostCombos[ i ][ 1 ] )
1526 intentResult = ( intentResult and iResult )
1527 """
1528
1529 main.step( "Verify Ping across all hosts" )
1530 pingResult = main.FALSE
1531 time1 = time.time()
1532 pingResult = main.Mininet1.pingall(timeout=main.pingTimeout)
1533 time2 = time.time()
1534 timeDiff = round( ( time2 - time1 ), 2 )
1535 main.log.report(
1536 "Time taken for Ping All: " +
1537 str( timeDiff ) +
1538 " seconds" )
1539 utilities.assert_equals( expect=main.TRUE, actual=pingResult,
1540 onpass="PING ALL PASS",
1541 onfail="PING ALL FAIL" )
1542
1543 case4Result = ( intentResult and pingResult )
1544
1545 #case4Result = pingResult
1546 utilities.assert_equals(
1547 expect=main.TRUE,
1548 actual=case4Result,
1549 onpass="Install 300 Host Intents and Ping All test PASS",
1550 onfail="Install 300 Host Intents and Ping All test FAIL" )
1551
1552 def CASE15( self,main):
1553 """
1554 Install 300 host intents and verify ping all
1555 """
1556 main.log.report( "Add 300 host intents and verify pingall" )
1557 main.log.report( "_______________________________________" )
1558 import itertools
1559
1560 main.case( "Install 300 host intents" )
1561 main.step( "Add host Intents" )
1562 intentResult = main.TRUE
1563 hostCombos = list( itertools.combinations( main.hostMACs, 2 ) )
1564
1565 CLI1 = (main.ONOScli1.addHostIntent)
1566 CLI2 = (main.ONOScli2.addHostIntent)
1567 CLI3 = (main.ONOScli3.addHostIntent)
1568 CLI4 = (main.ONOScli4.addHostIntent)
1569 CLI5 = (main.ONOScli5.addHostIntent)
1570 ONOSCLI = [CLI1,CLI2,CLI3,CLI4,CLI5]
1571 results = main.TRUE
1572 time1 = time.time()
1573 for i in xrange(0,len(hostCombos),5):
1574 pool = []
1575 for cli in ONOSCLI:
1576 if i >= len(hostCombos):
1577 break
1578 t = main.Thread(target=cli,threadID=main.threadID,
1579 name="addHostIntent",
1580 args=[hostCombos[i][0],hostCombos[i][1]])
1581 pool.append(t)
1582 t.start()
1583 i = i + 1
1584 main.threadID = main.threadID + 1
1585
1586 for thread in pool:
1587 thread.join()
1588 results = results and thread.result
1589
1590 time2 = time.time()
1591
1592 main.log.info("Time for adding host intents: %2f seconds" %(time2-time1))
1593 intentResult = results
1594 """
1595 for i in range( len( hostCombos ) ):
1596 iResult = main.ONOScli1.addHostIntent(
1597 hostCombos[ i ][ 0 ],
1598 hostCombos[ i ][ 1 ] )
1599 intentResult = ( intentResult and iResult )
1600 """
1601
1602 main.step( "Verify Ping across all hosts" )
1603 pingResult = main.FALSE
1604 time1 = time.time()
1605 pingResult = main.Mininet1.pingall(timeout=main.pingTimeout)
1606 time2 = time.time()
1607 timeDiff = round( ( time2 - time1 ), 2 )
1608 main.log.report(
1609 "Time taken for Ping All: " +
1610 str( timeDiff ) +
1611 " seconds" )
1612 utilities.assert_equals( expect=main.TRUE, actual=pingResult,
1613 onpass="PING ALL PASS",
1614 onfail="PING ALL FAIL" )
1615
1616 case4Result = ( intentResult and pingResult )
1617
1618 #case4Result = pingResult
1619 utilities.assert_equals(
1620 expect=main.TRUE,
1621 actual=case4Result,
1622 onpass="Install 300 Host Intents and Ping All test PASS",
1623 onfail="Install 300 Host Intents and Ping All test FAIL" )