blob: 2cd04c1aab02e19b9dca3509aac65231175ac31e [file] [log] [blame]
shahshreyaa47ebf42015-05-20 13:29:18 -07001
2# Testing the basic functionality of ONOS Next
3# For sanity and driver functionality excercises only.
4
5import time
6# import sys
7# import os
8# import re
9import json
10
11time.sleep( 1 )
12
13
14class ProdFunc:
15
16 def __init__( self ):
17 self.default = ''
18
19 def CASE1( self, main ):
20 import time
21 """
22 Startup sequence:
23 cell <name>
24 onos-verify-cell
25 onos-remove-raft-log
26 git pull
27 mvn clean install
28 onos-package
29 onos-install -f
30 onos-wait-for-start
31 """
32 cellName = main.params[ 'ENV' ][ 'cellName' ]
33 ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
34
35 main.case( "Setting up test environment" )
36 main.log.report(
37 "This testcase is testing setting up test environment" )
38 main.log.report( "__________________________________" )
39
40 main.step( "Applying cell variable to environment" )
41 cellResult = main.ONOSbench.setCell( cellName )
42 verifyResult = main.ONOSbench.verifyCell()
43
44 main.step( "Removing raft logs before a clen installation of ONOS" )
45 main.ONOSbench.onosRemoveRaftLogs()
46
47 main.step( "Git checkout and get version" )
48 #main.ONOSbench.gitCheckout( "master" )
49 gitPullResult = main.ONOSbench.gitPull()
50 main.log.info( "git_pull_result = " + str( gitPullResult ))
51 main.ONOSbench.getVersion( report=True )
52
53 if gitPullResult == 1:
54 main.step( "Using mvn clean & install" )
55 main.ONOSbench.cleanInstall()
56 elif gitPullResult == 0:
57 main.log.report(
58 "Git Pull Failed, look into logs for detailed reason" )
59 main.cleanup()
60 main.exit()
61
62 main.step( "Creating ONOS package" )
63 packageResult = main.ONOSbench.onosPackage()
64
65 main.step( "Installing ONOS package" )
66 onosInstallResult = main.ONOSbench.onosInstall()
67 if onosInstallResult == main.TRUE:
68 main.log.report( "Installing ONOS package successful" )
69 else:
70 main.log.report( "Installing ONOS package failed" )
71
72 onos1Isup = main.ONOSbench.isup()
73 if onos1Isup == main.TRUE:
74 main.log.report( "ONOS instance is up and ready" )
75 else:
76 main.log.report( "ONOS instance may not be up" )
77
78 main.step( "Starting ONOS service" )
79 startResult = main.ONOSbench.onosStart( ONOS1Ip )
80
81 main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
82 main.step( "Starting Mininet CLI..." )
83
84 # Starting the mininet using the old way
85 main.step( "Starting Mininet ..." )
86 netIsUp = main.Mininet1.startNet()
87 if netIsUp:
88 main.log.info("Mininet CLI is up")
89
90 case1Result = ( packageResult and
91 cellResult and verifyResult
92 and onosInstallResult and
93 onos1Isup and startResult )
94 utilities.assert_equals( expect=main.TRUE, actual=case1Result,
95 onpass="Test startup successful",
96 onfail="Test startup NOT successful" )
97
98 def CASE2( self, main ):
99 """
100 Switch Down
101 """
102 # NOTE: You should probably run a topology check after this
103 import time
104
105 main.case( "Switch down discovery" )
106 main.log.report( "This testcase is testing a switch down discovery" )
107 main.log.report( "__________________________________" )
108
109 switchSleep = int( main.params[ 'timers' ][ 'SwitchDiscovery' ] )
110
111 description = "Killing a switch to ensure it is discovered correctly"
112 main.log.report( description )
113 main.case( description )
114
115 # TODO: Make this switch parameterizable
116 main.step( "Kill s28 " )
117 main.log.report( "Deleting s28" )
118 # FIXME: use new dynamic topo functions
119 main.Mininet1.delSwitch( "s28" )
120 main.log.info(
121 "Waiting " +
122 str( switchSleep ) +
123 " seconds for switch down to be discovered" )
124 time.sleep( switchSleep )
125 # Peek at the deleted switch
126 device = main.ONOS2.getDevice( dpid="0028" )
127 print "device = ", device
128 if device[ u'available' ] == 'False':
129 case2Result = main.FALSE
130 else:
131 case2Result = main.TRUE
132 utilities.assert_equals( expect=main.TRUE, actual=case2Result,
133 onpass="Switch down discovery successful",
134 onfail="Switch down discovery failed" )
135
136 def CASE101( self, main ):
137 """
138 Cleanup sequence:
139 onos-service <nodeIp> stop
140 onos-uninstall
141
142 TODO: Define rest of cleanup
143
144 """
145 ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
146
147 main.case( "Cleaning up test environment" )
148
149 main.step( "Testing ONOS kill function" )
150 killResult = main.ONOSbench.onosKill( ONOS1Ip )
151
152 main.step( "Stopping ONOS service" )
153 stopResult = main.ONOSbench.onosStop( ONOS1Ip )
154
155 main.step( "Uninstalling ONOS service" )
156 uninstallResult = main.ONOSbench.onosUninstall()
157
158 case11Result = killResult and stopResult and uninstallResult
159 utilities.assert_equals( expect=main.TRUE, actual=case11Result,
160 onpass="Cleanup successful",
161 onfail="Cleanup failed" )
162
163 def CASE3( self, main ):
164 """
165 Test 'onos' command and its functionality in driver
166 """
167 ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
168
169 main.case( "Testing 'onos' command" )
170
171 main.step( "Sending command 'onos -w <onos-ip> system:name'" )
172 cmdstr1 = "system:name"
173 cmdResult1 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr1 )
174 main.log.info( "onos command returned: " + cmdResult1 )
175
176 main.step( "Sending command 'onos -w <onos-ip> onos:topology'" )
177 cmdstr2 = "onos:topology"
178 cmdResult2 = main.ONOSbench.onosCli( ONOS1Ip, cmdstr2 )
179 main.log.info( "onos command returned: " + cmdResult2 )
180
181 def CASE20( self ):
182 """
183 Exit from mininet cli
184 reinstall ONOS
185 """
186 cellName = main.params[ 'ENV' ][ 'cellName' ]
187 ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
188
189 main.log.report( "This testcase exits the mininet cli and reinstalls" +
190 "ONOS to switch over to Packet Optical topology" )
191 main.log.report( "_____________________________________________" )
192 main.case( "Disconnecting mininet and restarting ONOS" )
193 main.step( "Disconnecting mininet and restarting ONOS" )
194 mininetDisconnect = main.Mininet1.disconnect()
195 print "mininetDisconnect = ", mininetDisconnect
196
197 main.step( "Removing raft logs before a clen installation of ONOS" )
198 main.ONOSbench.onosRemoveRaftLogs()
199
200 main.step( "Applying cell variable to environment" )
201 cellResult = main.ONOSbench.setCell( cellName )
202 verifyResult = main.ONOSbench.verifyCell()
203
204 onosInstallResult = main.ONOSbench.onosInstall()
205 if onosInstallResult == main.TRUE:
206 main.log.report( "Installing ONOS package successful" )
207 else:
208 main.log.report( "Installing ONOS package failed" )
209
210 onos1Isup = main.ONOSbench.isup()
211 if onos1Isup == main.TRUE:
212 main.log.report( "ONOS instance is up and ready" )
213 else:
214 main.log.report( "ONOS instance may not be up" )
215
216 main.step( "Starting ONOS service" )
217 startResult = main.ONOSbench.onosStart( ONOS1Ip )
218
219 main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
220 case20Result = mininetDisconnect and cellResult and verifyResult \
221 and onosInstallResult and onos1Isup and \
222 startResult
223 utilities.assert_equals(
224 expect=main.TRUE,
225 actual=case20Result,
226 onpass= "Exiting functionality mininet topology and reinstalling" +
227 " ONOS successful",
228 onfail= "Exiting functionality mininet topology and reinstalling" +
229 " ONOS failed" )
230
231 def CASE21( self, main ):
232 """
233 On ONOS bench, run this command:
234 sudo -E python ~/onos/tools/test/topos/opticalTest.py -OC1
235 which spawns packet optical topology and copies the links
236 json file to the onos instance.
237 Note that in case of Packet Optical, the links are not learnt
238 from the topology, instead the links are learnt
239 from the json config file
240 """
241 main.log.report(
242 "This testcase starts the packet layer topology and REST" )
243 main.log.report( "_____________________________________________" )
244 main.case( "Starting LINC-OE and other components" )
245 main.step( "Starting LINC-OE and other components" )
246 appInstallResult = main.ONOS2.featureInstall( "onos-app-optical" )
247 opticalMnScript = main.LincOE2.runOpticalMnScript()
248
249 case21Result = opticalMnScript and appInstallResult
250 utilities.assert_equals(
251 expect=main.TRUE,
252 actual=case21Result,
253 onpass="Packet optical topology spawned successsfully",
254 onfail="Packet optical topology spawning failed" )
255
256 def CASE22( self, main ):
257 """
258 Curretly we use, 10 optical switches(ROADM's) and
259 6 packet layer mininet switches each with one host.
260 Therefore, the roadmCount variable = 10,
261 packetLayerSWCount variable = 6, hostCount=6 and
262 links=42.
263 All this is hardcoded in the testcase. If the topology changes,
264 these hardcoded values need to be changed
265 """
266 main.log.report(
267 "This testcase compares the optical+packet topology against what" +
268 " is expected" )
269 main.case( "Topology comparision" )
270 main.step( "Topology comparision" )
271 main.ONOS3.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
272 devicesResult = main.ONOS3.devices( jsonFormat=False )
273
274 print "devices_result = ", devicesResult
275 devicesLinewise = devicesResult.split( "\n" )
276 devicesLinewise = devicesLinewise[ 1: ]
277 roadmCount = 0
278 packetLayerSWCount = 0
279 for line in devicesLinewise:
280 components = line.split( "," )
281 availability = components[ 1 ].split( "=" )[ 1 ]
282 type = components[ 3 ].split( "=" )[ 1 ]
283 if availability == 'true' and type == 'ROADM':
284 roadmCount += 1
285 elif availability == 'true' and type == 'SWITCH':
286 packetLayerSWCount += 1
287 if roadmCount == 10:
288 print "Number of Optical Switches = %d and is" % roadmCount +\
289 " correctly detected"
290 main.log.info(
291 "Number of Optical Switches = " +
292 str( roadmCount ) +
293 " and is correctly detected" )
294 opticalSWResult = main.TRUE
295 else:
296 print "Number of Optical Switches = %d and is wrong" % roadmCount
297 main.log.info(
298 "Number of Optical Switches = " +
299 str( roadmCount ) +
300 " and is wrong" )
301 opticalSWResult = main.FALSE
302
303 if packetLayerSWCount == 6:
304 print "Number of Packet layer or mininet Switches = %d "\
305 % packetLayerSWCount + "and is correctly detected"
306 main.log.info(
307 "Number of Packet layer or mininet Switches = " +
308 str( packetLayerSWCount ) +
309 " and is correctly detected" )
310 packetSWResult = main.TRUE
311 else:
312 print "Number of Packet layer or mininet Switches = %d and"\
313 % packetLayerSWCount + " is wrong"
314 main.log.info(
315 "Number of Packet layer or mininet Switches = " +
316 str( packetLayerSWCount ) +
317 " and is wrong" )
318 packetSWResult = main.FALSE
319 print "_________________________________"
320
321 linksResult = main.ONOS3.links( jsonFormat=False )
322 print "links_result = ", linksResult
323 print "_________________________________"
324 linkActiveCount = linksResult.count("state=ACTIVE")
325 main.log.info( "linkActiveCount = " + str( linkActiveCount ))
326 if linkActiveCount == 42:
327 linkActiveResult = main.TRUE
328 main.log.info(
329 "Number of links in ACTIVE state are correct")
330 else:
331 linkActiveResult = main.FALSE
332 main.log.info(
333 "Number of links in ACTIVE state are wrong")
334
335 # NOTE:Since only point intents are added, there is no
336 # requirement to discover the hosts
337 # Therfore, the below portion of the code is commented.
338 """
339 #Discover hosts using pingall
340 pingallResult = main.LincOE2.pingall()
341
342 hostsResult = main.ONOS3.hosts( jsonFormat=False )
343 main.log.info( "hosts_result = "+hostsResult )
344 main.log.info( "_________________________________" )
345 hostsLinewise = hostsResult.split( "\n" )
346 hostsLinewise = hostsLinewise[ 1:-1 ]
347 hostCount = 0
348 for line in hostsLinewise:
349 hostid = line.split( "," )[ 0 ].split( "=" )[ 1 ]
350 hostCount +=1
351 if hostCount ==2:
352 print "Number of hosts = %d and is correctly detected" %hostCount
353 main.log.info( "Number of hosts = " + str( hostCount ) +" and \
354 is correctly detected" )
355 hostDiscovery = main.TRUE
356 else:
357 print "Number of hosts = %d and is wrong" %hostCount
358 main.log.info( "Number of hosts = " + str( hostCount ) +" and \
359 is wrong" )
360 hostDiscovery = main.FALSE
361 """
362 case22Result = opticalSWResult and packetSWResult and \
363 linkActiveResult
364 utilities.assert_equals(
365 expect=main.TRUE,
366 actual=case22Result,
367 onpass="Packet optical topology discovery successful",
368 onfail="Packet optical topology discovery failed" )
369
370 def CASE23( self, main ):
371 import time
372 """
373 Add bidirectional point intents between 2 packet layer( mininet )
374 devices and
375 ping mininet hosts
376 """
377 main.log.report(
378 "This testcase adds bidirectional point intents between 2 " +
379 "packet layer( mininet ) devices and ping mininet hosts" )
380 main.case( "Topology comparision" )
381 main.step( "Adding point intents" )
382 ptpIntentResult = main.ONOS3.addPointIntent(
383 "of:0000ffffffff0001/1",
384 "of:0000ffffffff0005/1" )
385 if ptpIntentResult == main.TRUE:
386 main.ONOS3.intents( jsonFormat=False )
387 main.log.info( "Point to point intent install successful" )
388
389 ptpIntentResult = main.ONOS3.addPointIntent(
390 "of:0000ffffffff0005/1",
391 "of:0000ffffffff0001/1" )
392 if ptpIntentResult == main.TRUE:
393 main.ONOS3.intents( jsonFormat=False )
394 main.log.info( "Point to point intent install successful" )
395
396 time.sleep( 30 )
397 flowHandle = main.ONOS3.flows()
398 main.log.info( "flows :" + flowHandle )
399
400 # Sleep for 30 seconds to provide time for the intent state to change
401 time.sleep( 60 )
402 intentHandle = main.ONOS3.intents( jsonFormat=False )
403 main.log.info( "intents :" + intentHandle )
404
405 PingResult = main.TRUE
406 count = 1
407 main.log.info( "\n\nh1 is Pinging h5" )
408 ping = main.LincOE2.pingHostOptical( src="h1", target="h5" )
409 # ping = main.LincOE2.pinghost()
410 if ping == main.FALSE and count < 5:
411 count += 1
412 PingResult = main.FALSE
413 main.log.info(
414 "Ping between h1 and h5 failed. Making attempt number " +
415 str( count ) +
416 " in 2 seconds" )
417 time.sleep( 2 )
418 elif ping == main.FALSE:
419 main.log.info( "All ping attempts between h1 and h5 have failed" )
420 PingResult = main.FALSE
421 elif ping == main.TRUE:
422 main.log.info( "Ping test between h1 and h5 passed!" )
423 PingResult = main.TRUE
424 else:
425 main.log.info( "Unknown error" )
426 PingResult = main.ERROR
427
428 if PingResult == main.FALSE:
429 main.log.report(
430 "Point intents for packet optical have not ben installed" +
431 " correctly. Cleaning up" )
432 if PingResult == main.TRUE:
433 main.log.report(
434 "Point Intents for packet optical have been " +
435 "installed correctly" )
436
437 case23Result = PingResult
438 utilities.assert_equals(
439 expect=main.TRUE,
440 actual=case23Result,
441 onpass= "Point intents addition for packet optical and" +
442 "Pingall Test successful",
443 onfail= "Point intents addition for packet optical and" +
444 "Pingall Test NOT successful" )
445
446 def CASE24( self, main ):
447 import time
448 import json
449 """
450 LINC uses its own switch IDs. You can use the following
451 command on the LINC console to find the mapping between
452 DPIDs and LINC IDs.
453 rp(application:get_all_key(linc)).
454
455 Test Rerouting of Packet Optical by bringing a port down
456 ( port 20 ) of a switch( switchID=1, or LincOE switchID =9 ),
457 so that link
458 ( between switch1 port20 - switch5 port50 ) is inactive
459 and do a ping test. If rerouting is successful,
460 ping should pass. also check the flows
461 """
462 main.log.report(
463 "This testcase tests rerouting and pings mininet hosts" )
464 main.case( "Test rerouting and pings mininet hosts" )
465 main.step( "Attach to the Linc-OE session" )
466 attachConsole = main.LincOE1.attachLincOESession()
467 print "attachConsole = ", attachConsole
468
469 main.step( "Bring a port down and verify the link state" )
470 main.LincOE1.portDown( swId="9", ptId="20" )
471 linksNonjson = main.ONOS3.links( jsonFormat=False )
472 main.log.info( "links = " + linksNonjson )
473
474 linkInactiveCount = linksNonjson.count("state=INACTIVE")
475 main.log.info( "linkInactiveCount = " + str( linkInactiveCount ))
476 if linkInactiveCount == 2:
477 main.log.info(
478 "Number of links in INACTIVE state are correct")
479 else:
480 main.log.info(
481 "Number of links in INACTIVE state are wrong")
482
483 links = main.ONOS3.links()
484 main.log.info( "links = " + links )
485
486 linksResult = json.loads( links )
487 linksStateResult = main.FALSE
488 for item in linksResult:
489 if item[ 'src' ][ 'device' ] == "of:0000ffffffffff01" and item[
490 'src' ][ 'port' ] == "20":
491 if item[ 'dst' ][ 'device' ] == "of:0000ffffffffff05" and item[
492 'dst' ][ 'port' ] == "50":
493 linksState = item[ 'state' ]
494 if linksState == "INACTIVE":
495 main.log.info(
496 "Links state is inactive as expected due to one" +
497 " of the ports being down" )
498 main.log.report(
499 "Links state is inactive as expected due to one" +
500 " of the ports being down" )
501 linksStateResult = main.TRUE
502 break
503 else:
504 main.log.info(
505 "Links state is not inactive as expected" )
506 main.log.report(
507 "Links state is not inactive as expected" )
508 linksStateResult = main.FALSE
509
510 print "links_state_result = ", linksStateResult
511 time.sleep( 10 )
512 flowHandle = main.ONOS3.flows()
513 main.log.info( "flows :" + flowHandle )
514
515 main.step( "Verify Rerouting by a ping test" )
516 PingResult = main.TRUE
517 count = 1
518 main.log.info( "\n\nh1 is Pinging h5" )
519 ping = main.LincOE2.pingHostOptical( src="h1", target="h5" )
520 # ping = main.LincOE2.pinghost()
521 if ping == main.FALSE and count < 5:
522 count += 1
523 PingResult = main.FALSE
524 main.log.info(
525 "Ping between h1 and h5 failed. Making attempt number " +
526 str( count ) +
527 " in 2 seconds" )
528 time.sleep( 2 )
529 elif ping == main.FALSE:
530 main.log.info( "All ping attempts between h1 and h5 have failed" )
531 PingResult = main.FALSE
532 elif ping == main.TRUE:
533 main.log.info( "Ping test between h1 and h5 passed!" )
534 PingResult = main.TRUE
535 else:
536 main.log.info( "Unknown error" )
537 PingResult = main.ERROR
538
539 if PingResult == main.TRUE:
540 main.log.report( "Ping test successful " )
541 if PingResult == main.FALSE:
542 main.log.report( "Ping test failed" )
543
544 case24Result = PingResult and linksStateResult
545 utilities.assert_equals( expect=main.TRUE, actual=case24Result,
546 onpass="Packet optical rerouting successful",
547 onfail="Packet optical rerouting failed" )
548
549 def CASE4( self, main ):
550 import re
551 import time
552 main.log.report( "This testcase is testing the assignment of" +
553 " all the switches to all the controllers and" +
554 " discovering the hosts in reactive mode" )
555 main.log.report( "__________________________________" )
556 main.case( "Pingall Test" )
557 main.step( "Assigning switches to controllers" )
558 ONOS1Ip = main.params[ 'CTRL' ][ 'ip1' ]
559 ONOS1Port = main.params[ 'CTRL' ][ 'port1' ]
560 for i in range( 1, 29 ):
561 if i == 1:
562 main.Mininet1.assignSwController(
563 sw=str( i ),
564 ip1=ONOS1Ip,
565 port1=ONOS1Port )
566 elif i >= 2 and i < 5:
567 main.Mininet1.assignSwController(
568 sw=str( i ),
569 ip1=ONOS1Ip,
570 port1=ONOS1Port )
571 elif i >= 5 and i < 8:
572 main.Mininet1.assignSwController(
573 sw=str( i ),
574 ip1=ONOS1Ip,
575 port1=ONOS1Port )
576 elif i >= 8 and i < 18:
577 main.Mininet1.assignSwController(
578 sw=str( i ),
579 ip1=ONOS1Ip,
580 port1=ONOS1Port )
581 elif i >= 18 and i < 28:
582 main.Mininet1.assignSwController(
583 sw=str( i ),
584 ip1=ONOS1Ip,
585 port1=ONOS1Port )
586 else:
587 main.Mininet1.assignSwController(
588 sw=str( i ),
589 ip1=ONOS1Ip,
590 port1=ONOS1Port )
591 SwitchMastership = main.TRUE
592 for i in range( 1, 29 ):
593 if i == 1:
594 response = main.Mininet1.getSwController( "s" + str( i ) )
595 print( "Response is " + str( response ) )
596 if re.search( "tcp:" + ONOS1Ip, response ):
597 SwitchMastership = SwitchMastership and main.TRUE
598 else:
599 SwitchMastership = main.FALSE
600 elif i >= 2 and i < 5:
601 response = main.Mininet1.getSwController( "s" + str( i ) )
602 print( "Response is " + str( response ) )
603 if re.search( "tcp:" + ONOS1Ip, response ):
604 SwitchMastership = SwitchMastership and main.TRUE
605 else:
606 SwitchMastership = main.FALSE
607 elif i >= 5 and i < 8:
608 response = main.Mininet1.getSwController( "s" + str( i ) )
609 print( "Response is " + str( response ) )
610 if re.search( "tcp:" + ONOS1Ip, response ):
611 SwitchMastership = SwitchMastership and main.TRUE
612 else:
613 SwitchMastership = main.FALSE
614 elif i >= 8 and i < 18:
615 response = main.Mininet1.getSwController( "s" + str( i ) )
616 print( "Response is " + str( response ) )
617 if re.search( "tcp:" + ONOS1Ip, response ):
618 SwitchMastership = SwitchMastership and main.TRUE
619 else:
620 SwitchMastership = main.FALSE
621 elif i >= 18 and i < 28:
622 response = main.Mininet1.getSwController( "s" + str( i ) )
623 print( "Response is " + str( response ) )
624 if re.search( "tcp:" + ONOS1Ip, response ):
625 SwitchMastership = SwitchMastership and main.TRUE
626 else:
627 SwitchMastership = main.FALSE
628 else:
629 response = main.Mininet1.getSwController( "s" + str( i ) )
630 print( "Response is" + str( response ) )
631 if re.search( "tcp:" + ONOS1Ip, response ):
632 SwitchMastership = SwitchMastership and main.TRUE
633 else:
634 SwitchMastership = main.FALSE
635
636 if SwitchMastership == main.TRUE:
637 main.log.report( "Controller assignmnet successful" )
638 else:
639 main.log.report( "Controller assignmnet failed" )
640 utilities.assert_equals(
641 expect=main.TRUE,
642 actual=SwitchMastership,
643 onpass="MasterControllers assigned correctly" )
644 """
645 for i in range ( 1,29 ):
646 main.Mininet1.assignSwController( sw=str( i ),count=5,
647 ip1=ONOS1Ip,port1=ONOS1Port,
648 ip2=ONOS2Ip,port2=ONOS2Port,
649 ip3=ONOS3Ip,port3=ONOS3Port,
650 ip4=ONOS4Ip,port4=ONOS4Port,
651 ip5=ONOS5Ip,port5=ONOS5Port )
652 """
653 # REACTIVE FWD test
654
655 main.step( "Get list of hosts from Mininet" )
656 hostList = main.Mininet1.getHosts()
657 main.log.info( hostList )
658
659 main.step( "Get host list in ONOS format" )
660 hostOnosList = main.ONOS2.getHostsId( hostList )
661 main.log.info( hostOnosList )
662 # time.sleep( 5 )
663
664 main.step( "Pingall" )
665 pingResult = main.FALSE
666 time1 = time.time()
667 pingResult = main.Mininet1.pingall()
668 time2 = time.time()
669 print "Time for pingall: %2f seconds" % ( time2 - time1 )
670
671 # Start onos cli again because u might have dropped out of
672 # onos prompt to the shell prompt
673 # if there was no activity
674 main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
675
676 case4Result = SwitchMastership and pingResult
677 if pingResult == main.TRUE:
678 main.log.report( "Pingall Test in reactive mode to" +
679 " discover the hosts successful" )
680 else:
681 main.log.report( "Pingall Test in reactive mode to" +
682 " discover the hosts failed" )
683
684 utilities.assert_equals(
685 expect=main.TRUE,
686 actual=case4Result,
687 onpass="Controller assignment and Pingall Test successful",
688 onfail="Controller assignment and Pingall Test NOT successful" )
689
690 def CASE10( self ):
691 main.log.report(
692 "This testcase uninstalls the reactive forwarding app" )
693 main.log.report( "__________________________________" )
694 main.case( "Uninstalling reactive forwarding app" )
695 # Unistall onos-app-fwd app to disable reactive forwarding
696 appUninstallResult = main.ONOS2.featureUninstall( "onos-app-fwd" )
697 main.log.info( "onos-app-fwd uninstalled" )
698
699 # After reactive forwarding is disabled, the reactive flows on
700 # switches timeout in 10-15s
701 # So sleep for 15s
702 time.sleep( 15 )
703
704 flows = main.ONOS2.flows()
705 main.log.info( flows )
706
707 case10Result = appUninstallResult
708 utilities.assert_equals(
709 expect=main.TRUE,
710 actual=case10Result,
711 onpass="Reactive forwarding app uninstallation successful",
712 onfail="Reactive forwarding app uninstallation failed" )
713
714
715 def CASE11( self ):
716 # NOTE: This testcase require reactive forwarding mode enabled
717 # NOTE: in the beginning and then uninstall it before adding
718 # NOTE: point intents. Again the app is installed so that
719 # NOTE: testcase 10 can be ran successively
720 import time
721 main.log.report(
722 "This testcase moves a host from one switch to another to add" +
723 "point intents between them and then perform ping" )
724 main.log.report( "__________________________________" )
725 main.log.info( "Moving host from one switch to another" )
726 main.case( "Moving host from a device and attach it to another device" )
727 main.step( "Moving host h9 from device s9 and attach it to s8" )
728 main.Mininet1.moveHost(host = 'h9', oldSw = 's9', newSw = 's8')
729
730 time.sleep(15) #Time delay to have all the flows ready
731 main.step( "Pingall" )
732 pingResult = main.FALSE
733 time1 = time.time()
734 pingResult = main.Mininet1.pingall()
735 time2 = time.time()
736 print "Time for pingall: %2f seconds" % ( time2 - time1 )
737
738 hosts = main.ONOS2.hosts( jsonFormat = False )
739 main.log.info( hosts )
740
741 main.case( "Uninstalling reactive forwarding app" )
742 # Unistall onos-app-fwd app to disable reactive forwarding
743 appUninstallResult = main.ONOS2.featureUninstall( "onos-app-fwd" )
744 main.log.info( "onos-app-fwd uninstalled" )
745
746 main.step( "Add point intents between hosts on the same device")
747 ptpIntentResult = main.ONOS2.addPointIntent(
748 "of:0000000000003008/1",
749 "of:0000000000003008/3" )
750 if ptpIntentResult == main.TRUE:
751 getIntentResult = main.ONOS2.intents()
752 main.log.info( "Point to point intent install successful" )
753 # main.log.info( getIntentResult )
754
755 ptpIntentResult = main.ONOS2.addPointIntent(
756 "of:0000000000003008/3",
757 "of:0000000000003008/1" )
758 if ptpIntentResult == main.TRUE:
759 getIntentResult = main.ONOS2.intents()
760 main.log.info( "Point to point intent install successful" )
761 # main.log.info( getIntentResult )
762
763 main.case( "Ping hosts on the same devices" )
764 ping = main.Mininet1.pingHost( src = 'h8', target = 'h9' )
765
766 '''
767 main.case( "Installing reactive forwarding app" )
768 # Install onos-app-fwd app to enable reactive forwarding
769 appUninstallResult = main.ONOS2.featureInstall( "onos-app-fwd" )
770 main.log.info( "onos-app-fwd installed" )
771 '''
772
773 if ping == main.FALSE:
774 main.log.report(
775 "Point intents for hosts on same devices haven't" +
776 " been installed correctly. Cleaning up" )
777 if ping == main.TRUE:
778 main.log.report(
779 "Point intents for hosts on same devices" +
780 "installed correctly. Cleaning up" )
781
782 case11Result = ping and pingResult
783 utilities.assert_equals(
784 expect = main.TRUE,
785 actual = case11Result,
786 onpass = "Point intents for hosts on same devices" +
787 "Ping Test successful",
788 onfail = "Point intents for hosts on same devices" +
789 "Ping Test NOT successful" )
790
791
792 def CASE12( self ):
793 """
794 Verify the default flows on each switch in proactive mode
795 """
796 main.log.report( "This testcase is verifying num of default" +
797 " flows on each switch" )
798 main.log.report( "__________________________________" )
799 main.case( "Verify num of default flows on each switch" )
800 main.step( "Obtaining the device id's and flowrule count on them" )
801
802 case12Result = main.TRUE
803 idList = main.ONOS2.getAllDevicesId()
804 for id in idList:
805 count = main.ONOS2.FlowAddedCount( id )
806 main.log.info("count = " +count)
807 if int(count) != 3:
808 case12Result = main.FALSE
809 break
810 utilities.assert_equals(
811 expect=main.TRUE,
812 actual=case12Result,
813 onpass = "Expected default num of flows exist",
814 onfail = "Expected default num of flows do not exist")
815
816
817
818
819 def CASE6( self ):
820 import time
821 main.log.report( "This testcase is testing the addition of" +
822 " host intents and then does pingall" )
823 main.log.report( "__________________________________" )
824 main.case( "Obtaining host id's" )
825 main.step( "Get hosts" )
826 hosts = main.ONOS2.hosts()
827 main.log.info( hosts )
828
829 main.step( "Get all devices id" )
830 devicesIdList = main.ONOS2.getAllDevicesId()
831 main.log.info( devicesIdList )
832
833 # ONOS displays the hosts in hex format unlike mininet which does
834 # in decimal format
835 # So take care while adding intents
836 """
837 main.step( "Add host-to-host intents for mininet hosts h8 and h18 or
838 ONOS hosts h8 and h12" )
839 hthIntentResult = main.ONOS2.addHostIntent(
840 "00:00:00:00:00:08/-1", "00:00:00:00:00:12/-1" )
841 hthIntentResult = main.ONOS2.addHostIntent(
842 "00:00:00:00:00:09/-1", "00:00:00:00:00:13/-1" )
843 hthIntentResult = main.ONOS2.addHostIntent(
844 "00:00:00:00:00:0A/-1", "00:00:00:00:00:14/-1" )
845 hthIntentResult = main.ONOS2.addHostIntent(
846 "00:00:00:00:00:0B/-1", "00:00:00:00:00:15/-1" )
847 hthIntentResult = main.ONOS2.addHostIntent(
848 "00:00:00:00:00:0C/-1", "00:00:00:00:00:16/-1" )
849 hthIntentResult = main.ONOS2.addHostIntent(
850 "00:00:00:00:00:0D/-1", "00:00:00:00:00:17/-1" )
851 hthIntentResult = main.ONOS2.addHostIntent(
852 "00:00:00:00:00:0E/-1", "00:00:00:00:00:18/-1" )
853 hthIntentResult = main.ONOS2.addHostIntent(
854 "00:00:00:00:00:0F/-1", "00:00:00:00:00:19/-1" )
855 hthIntentResult = main.ONOS2.addHostIntent(
856 "00:00:00:00:00:10/-1", "00:00:00:00:00:1A/-1" )
857 hthIntentResult = main.ONOS2.addHostIntent(
858 "00:00:00:00:00:11/-1", "00:00:00:00:00:1B/-1" )
859 print "______________________________________________________"
860 """
861 for i in range( 8, 18 ):
862 main.log.info(
863 "Adding host intent between h" + str( i ) +
864 " and h" + str( i + 10 ) )
865 host1 = "00:00:00:00:00:" + \
866 str( hex( i )[ 2: ] ).zfill( 2 ).upper()
867 host2 = "00:00:00:00:00:" + \
868 str( hex( i + 10 )[ 2: ] ).zfill( 2 ).upper()
869 # NOTE: get host can return None
870 if host1:
871 host1Id = main.ONOS2.getHost( host1 )[ 'id' ]
872 if host2:
873 host2Id = main.ONOS2.getHost( host2 )[ 'id' ]
874 if host1Id and host2Id:
875 main.ONOS2.addHostIntent( host1Id, host2Id )
876
877 time.sleep( 10 )
878 hIntents = main.ONOS2.intents( jsonFormat=False )
879 main.log.info( "intents:" + hIntents )
880 flows = main.ONOS2.flows()
881 main.log.info( "flows:" + flows )
882
883 count = 1
884 i = 8
885 PingResult = main.TRUE
886 # while i<10:
887 while i < 18:
888 main.log.info(
889 "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
890 ping = main.Mininet1.pingHost(
891 src="h" + str( i ), target="h" + str( i + 10 ) )
892 if ping == main.FALSE and count < 5:
893 count += 1
894 # i = 8
895 PingResult = main.FALSE
896 main.log.report( "Ping between h" +
897 str( i ) +
898 " and h" +
899 str( i +
900 10 ) +
901 " failed. Making attempt number " +
902 str( count ) +
903 " in 2 seconds" )
904 time.sleep( 2 )
905 elif ping == main.FALSE:
906 main.log.report( "All ping attempts between h" +
907 str( i ) +
908 " and h" +
909 str( i +
910 10 ) +
911 "have failed" )
912 i = 19
913 PingResult = main.FALSE
914 elif ping == main.TRUE:
915 main.log.info( "Ping test between h" +
916 str( i ) +
917 " and h" +
918 str( i +
919 10 ) +
920 "passed!" )
921 i += 1
922 PingResult = main.TRUE
923 else:
924 main.log.info( "Unknown error" )
925 PingResult = main.ERROR
926 if PingResult == main.FALSE:
927 main.log.report(
928 "Ping all test after Host intent addition failed.Cleaning up" )
929 # main.cleanup()
930 # main.exit()
931 if PingResult == main.TRUE:
932 main.log.report(
933 "Ping all test after Host intent addition successful" )
934
935 case6Result = PingResult
936 utilities.assert_equals(
937 expect=main.TRUE,
938 actual=case6Result,
939 onpass="Pingall Test after Host intents addition successful",
940 onfail="Pingall Test after Host intents addition failed" )
941
942 def CASE5( self, main ):
943 import json
944 # assumes that sts is already in you PYTHONPATH
945 from sts.topology.teston_topology import TestONTopology
946 # main.ONOS2.startOnosCli( ONOSIp=main.params[ 'CTRL' ][ 'ip1' ] )
947 main.log.report( "This testcase is testing if all ONOS nodes" +
948 " are in topology sync with mininet" )
949 main.log.report( "__________________________________" )
950 main.case( "Comparing Mininet topology with the topology of ONOS" )
951 main.step( "Start continuous pings" )
952 main.Mininet2.pingLong(
953 src=main.params[ 'PING' ][ 'source1' ],
954 target=main.params[ 'PING' ][ 'target1' ],
955 pingTime=500 )
956 main.Mininet2.pingLong(
957 src=main.params[ 'PING' ][ 'source2' ],
958 target=main.params[ 'PING' ][ 'target2' ],
959 pingTime=500 )
960 main.Mininet2.pingLong(
961 src=main.params[ 'PING' ][ 'source3' ],
962 target=main.params[ 'PING' ][ 'target3' ],
963 pingTime=500 )
964 main.Mininet2.pingLong(
965 src=main.params[ 'PING' ][ 'source4' ],
966 target=main.params[ 'PING' ][ 'target4' ],
967 pingTime=500 )
968 main.Mininet2.pingLong(
969 src=main.params[ 'PING' ][ 'source5' ],
970 target=main.params[ 'PING' ][ 'target5' ],
971 pingTime=500 )
972 main.Mininet2.pingLong(
973 src=main.params[ 'PING' ][ 'source6' ],
974 target=main.params[ 'PING' ][ 'target6' ],
975 pingTime=500 )
976 main.Mininet2.pingLong(
977 src=main.params[ 'PING' ][ 'source7' ],
978 target=main.params[ 'PING' ][ 'target7' ],
979 pingTime=500 )
980 main.Mininet2.pingLong(
981 src=main.params[ 'PING' ][ 'source8' ],
982 target=main.params[ 'PING' ][ 'target8' ],
983 pingTime=500 )
984 main.Mininet2.pingLong(
985 src=main.params[ 'PING' ][ 'source9' ],
986 target=main.params[ 'PING' ][ 'target9' ],
987 pingTime=500 )
988 main.Mininet2.pingLong(
989 src=main.params[ 'PING' ][ 'source10' ],
990 target=main.params[ 'PING' ][ 'target10' ],
991 pingTime=500 )
992
993 main.step( "Create TestONTopology object" )
994 global ctrls
995 ctrls = []
996 count = 1
997 while True:
998 temp = ()
999 if ( 'ip' + str( count ) ) in main.params[ 'CTRL' ]:
1000 temp = temp + ( getattr( main, ( 'ONOS' + str( count ) ) ), )
1001 temp = temp + ( "ONOS" + str( count ), )
1002 temp = temp + ( main.params[ 'CTRL' ][ 'ip' + str( count ) ], )
1003 temp = temp + \
1004 ( eval( main.params[ 'CTRL' ][ 'port' + str( count ) ] ), )
1005 ctrls.append( temp )
1006 count = count + 1
1007 else:
1008 break
1009 global MNTopo
1010 Topo = TestONTopology(
1011 main.Mininet1,
1012 ctrls ) # can also add Intent API info for intent operations
1013 MNTopo = Topo
1014
1015 TopologyCheck = main.TRUE
1016 main.step( "Compare ONOS Topology to MN Topology" )
1017 devicesJson = main.ONOS2.devices()
1018 linksJson = main.ONOS2.links()
1019 # portsJson = main.ONOS2.ports()
1020
1021 result1 = main.Mininet1.compareSwitches(
1022 MNTopo,
1023 json.loads( devicesJson ) )
1024 result2 = main.Mininet1.compareLinks(
1025 MNTopo,
1026 json.loads( linksJson ) )
1027 # result3 = main.Mininet1.comparePorts(
1028 # MNTopo, json.loads( portsJson ) )
1029
1030 # result = result1 and result2 and result3
1031 result = result1 and result2
1032
1033 print "***********************"
1034 if result == main.TRUE:
1035 main.log.report( "ONOS" + " Topology matches MN Topology" )
1036 else:
1037 main.log.report( "ONOS" + " Topology does not match MN Topology" )
1038
1039 utilities.assert_equals(
1040 expect=main.TRUE,
1041 actual=result,
1042 onpass="ONOS" +
1043 " Topology matches MN Topology",
1044 onfail="ONOS" +
1045 " Topology does not match MN Topology" )
1046
1047 TopologyCheck = TopologyCheck and result
1048 utilities.assert_equals(
1049 expect=main.TRUE,
1050 actual=TopologyCheck,
1051 onpass="Topology checks passed",
1052 onfail="Topology checks failed" )
1053
1054 def CASE7( self, main ):
1055 from sts.topology.teston_topology import TestONTopology
1056
1057 linkSleep = int( main.params[ 'timers' ][ 'LinkDiscovery' ] )
1058
1059 main.log.report( "This testscase is killing a link to ensure that" +
1060 " link discovery is consistent" )
1061 main.log.report( "__________________________________" )
1062 main.log.report( "Killing a link to ensure that link discovery" +
1063 " is consistent" )
1064 main.case( "Killing a link to Ensure that Link Discovery" +
1065 "is Working Properly" )
1066 """
1067 main.step( "Start continuous pings" )
1068
1069 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source1' ],
1070 target=main.params[ 'PING' ][ 'target1' ],
1071 pingTime=500 )
1072 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source2' ],
1073 target=main.params[ 'PING' ][ 'target2' ],
1074 pingTime=500 )
1075 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source3' ],
1076 target=main.params[ 'PING' ][ 'target3' ],
1077 pingTime=500 )
1078 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source4' ],
1079 target=main.params[ 'PING' ][ 'target4' ],
1080 pingTime=500 )
1081 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source5' ],
1082 target=main.params[ 'PING' ][ 'target5' ],
1083 pingTime=500 )
1084 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source6' ],
1085 target=main.params[ 'PING' ][ 'target6' ],
1086 pingTime=500 )
1087 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source7' ],
1088 target=main.params[ 'PING' ][ 'target7' ],
1089 pingTime=500 )
1090 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source8' ],
1091 target=main.params[ 'PING' ][ 'target8' ],
1092 pingTime=500 )
1093 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source9' ],
1094 target=main.params[ 'PING' ][ 'target9' ],
1095 pingTime=500 )
1096 main.Mininet2.pingLong( src=main.params[ 'PING' ][ 'source10' ],
1097 target=main.params[ 'PING' ][ 'target10' ],
1098 pingTime=500 )
1099 """
1100 main.step( "Determine the current number of switches and links" )
1101 topologyOutput = main.ONOS2.topology()
1102 topologyResult = main.ONOS1.getTopology( topologyOutput )
1103 activeSwitches = topologyResult[ 'deviceCount' ]
1104 links = topologyResult[ 'linkCount' ]
1105 print "activeSwitches = ", type( activeSwitches )
1106 print "links = ", type( links )
1107 main.log.info(
1108 "Currently there are %s switches and %s links" %
1109 ( str( activeSwitches ), str( links ) ) )
1110
1111 main.step( "Kill Link between s3 and s28" )
1112 main.Mininet1.link( END1="s3", END2="s28", OPTION="down" )
1113 time.sleep( linkSleep )
1114 topologyOutput = main.ONOS2.topology()
1115 LinkDown = main.ONOS1.checkStatus(
1116 topologyOutput, activeSwitches, str(
1117 int( links ) - 2 ) )
1118 if LinkDown == main.TRUE:
1119 main.log.report( "Link Down discovered properly" )
1120 utilities.assert_equals(
1121 expect=main.TRUE,
1122 actual=LinkDown,
1123 onpass="Link Down discovered properly",
1124 onfail="Link down was not discovered in " +
1125 str( linkSleep ) +
1126 " seconds" )
1127
1128 # Check ping result here..add code for it
1129
1130 main.step( "Bring link between s3 and s28 back up" )
1131 LinkUp = main.Mininet1.link( END1="s3", END2="s28", OPTION="up" )
1132 time.sleep( linkSleep )
1133 topologyOutput = main.ONOS2.topology()
1134 LinkUp = main.ONOS1.checkStatus(
1135 topologyOutput,
1136 activeSwitches,
1137 str( links ) )
1138 if LinkUp == main.TRUE:
1139 main.log.report( "Link up discovered properly" )
1140 utilities.assert_equals(
1141 expect=main.TRUE,
1142 actual=LinkUp,
1143 onpass="Link up discovered properly",
1144 onfail="Link up was not discovered in " +
1145 str( linkSleep ) +
1146 " seconds" )
1147
1148 # NOTE Check ping result here..add code for it
1149
1150 main.step( "Compare ONOS Topology to MN Topology" )
1151 Topo = TestONTopology(
1152 main.Mininet1,
1153 ctrls ) # can also add Intent API info for intent operations
1154 MNTopo = Topo
1155 TopologyCheck = main.TRUE
1156
1157 devicesJson = main.ONOS2.devices()
1158 linksJson = main.ONOS2.links()
1159 portsJson = main.ONOS2.ports()
1160
1161 result1 = main.Mininet1.compareSwitches(
1162 MNTopo,
1163 json.loads( devicesJson ) )
1164 result2 = main.Mininet1.compareLinks(
1165 MNTopo,
1166 json.loads( linksJson ) )
1167 # result3 = main.Mininet1.comparePorts(
1168 # MNTopo, json.loads( portsJson ) )
1169
1170 # result = result1 and result2 and result3
1171 result = result1 and result2
1172 print "***********************"
1173
1174 if result == main.TRUE:
1175 main.log.report( "ONOS" + " Topology matches MN Topology" )
1176 utilities.assert_equals(
1177 expect=main.TRUE,
1178 actual=result,
1179 onpass="ONOS" +
1180 " Topology matches MN Topology",
1181 onfail="ONOS" +
1182 " Topology does not match MN Topology" )
1183
1184 TopologyCheck = TopologyCheck and result
1185 utilities.assert_equals(
1186 expect=main.TRUE,
1187 actual=TopologyCheck,
1188 onpass="Topology checks passed",
1189 onfail="Topology checks failed" )
1190
1191 result = LinkDown and LinkUp and TopologyCheck
1192 utilities.assert_equals( expect=main.TRUE, actual=result,
1193 onpass="Link failure is discovered correctly",
1194 onfail="Link Discovery failed" )
1195
1196 def CASE8( self ):
1197 """
1198 Intent removal
1199 """
1200 import time
1201 main.log.report( "This testcase removes any previously added intents" +
1202 " before adding any new set of intents" )
1203 main.log.report( "__________________________________" )
1204 main.log.info( "intent removal" )
1205 main.case( "Removing installed intents" )
1206 main.step( "Obtain the intent id's" )
1207 intentResult = main.ONOS2.intents( jsonFormat=False )
1208 main.log.info( "intent_result = " + intentResult )
1209 intentLinewise = intentResult.split( "\n" )
1210
1211 intentList = [line for line in intentLinewise \
1212 if line.startswith( "id=")]
1213 intentids = [line.split( "," )[ 0 ].split( "=" )[ 1 ] for line in \
1214 intentList]
1215 for id in intentids:
1216 print "id = ", id
1217
1218 main.step(
1219 "Iterate through the intentids list and remove each intent" )
1220 for id in intentids:
1221 main.ONOS2.removeIntent( intentId=id )
1222
1223 intentResult = main.ONOS2.intents( jsonFormat=False )
1224 main.log.info( "intent_result = " + intentResult )
1225
1226 intentList = [line for line in intentResult.split( "\n" ) \
1227 if line.startswith( "id=")]
1228 intentState = [line.split( "," )[ 1 ].split( "=" )[ 1 ] for line in \
1229 intentList]
1230 for state in intentState:
1231 print state
1232
1233 case8Result = main.TRUE
1234 for state in intentState:
1235 if state != 'WITHDRAWN':
1236 case8Result = main.FALSE
1237 break
1238
1239 if case8Result == main.TRUE:
1240 main.log.report( "Intent removal successful" )
1241 else:
1242 main.log.report( "Intent removal failed" )
1243
1244 PingResult = main.TRUE
1245 if case8Result == main.TRUE:
1246 i = 8
1247 while i < 18:
1248 main.log.info(
1249 "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
1250 ping = main.Mininet1.pingHost(
1251 src="h" + str( i ), target="h" + str( i + 10 ) )
1252 if ping == main.TRUE:
1253 i = 19
1254 PingResult = PingResult and main.TRUE
1255 elif ping == main.FALSE:
1256 i += 1
1257 PingResult = PingResult and main.FALSE
1258 else:
1259 main.log.info( "Unknown error" )
1260 PingResult = main.ERROR
1261
1262 # Note: If the ping result failed, that means the intents have been
1263 # withdrawn correctly.
1264 if PingResult == main.TRUE:
1265 main.log.report( "Installed intents have not been withdrawn correctly" )
1266 # main.cleanup()
1267 # main.exit()
1268 if PingResult == main.FALSE:
1269 main.log.report( "Installed intents have been withdrawn correctly" )
1270
1271 case8Result = case8Result and PingResult
1272
1273 if case8Result == main.FALSE:
1274 main.log.report( "Intent removal successful" )
1275 else:
1276 main.log.report( "Intent removal failed" )
1277
1278 utilities.assert_equals( expect=main.FALSE, actual=case8Result,
1279 onpass="Intent removal test passed",
1280 onfail="Intent removal test failed" )
1281
1282 def CASE9( self ):
1283 main.log.report(
1284 "This testcase adds point intents and then does pingall" )
1285 main.log.report( "__________________________________" )
1286 main.log.info( "Adding point intents" )
1287 main.case(
1288 "Adding bidirectional point for mn hosts" +
1289 "( h8-h18, h9-h19, h10-h20, h11-h21, h12-h22, " +
1290 "h13-h23, h14-h24, h15-h25, h16-h26, h17-h27 )" )
1291
1292 main.step( "Add point intents for mn hosts h8 and h18 or" +
1293 "ONOS hosts h8 and h12" )
1294 # main.step(var1)
1295 ptpIntentResult = main.ONOS2.addPointIntent(
1296 "of:0000000000003008/1",
1297 "of:0000000000006018/1" )
1298 if ptpIntentResult == main.TRUE:
1299 getIntentResult = main.ONOS2.intents()
1300 main.log.info( "Point to point intent install successful" )
1301 # main.log.info( getIntentResult )
1302
1303 ptpIntentResult = main.ONOS2.addPointIntent(
1304 "of:0000000000006018/1",
1305 "of:0000000000003008/1" )
1306 if ptpIntentResult == main.TRUE:
1307 getIntentResult = main.ONOS2.intents()
1308 main.log.info( "Point to point intent install successful" )
1309 # main.log.info( getIntentResult )
1310
1311 var2 = "Add point intents for mn hosts h9&h19 or ONOS hosts h9&h13"
1312 main.step(var2)
1313 ptpIntentResult = main.ONOS2.addPointIntent(
1314 "of:0000000000003009/1",
1315 "of:0000000000006019/1" )
1316 if ptpIntentResult == main.TRUE:
1317 getIntentResult = main.ONOS2.intents()
1318 main.log.info( "Point to point intent install successful" )
1319 # main.log.info( getIntentResult )
1320
1321 ptpIntentResult = main.ONOS2.addPointIntent(
1322 "of:0000000000006019/1",
1323 "of:0000000000003009/1" )
1324 if ptpIntentResult == main.TRUE:
1325 getIntentResult = main.ONOS2.intents()
1326 main.log.info( "Point to point intent install successful" )
1327 # main.log.info( getIntentResult )
1328
1329 var3 = "Add point intents for MN hosts h10&h20 or ONOS hosts hA&h14"
1330 main.step(var3)
1331 ptpIntentResult = main.ONOS2.addPointIntent(
1332 "of:0000000000003010/1",
1333 "of:0000000000006020/1" )
1334 if ptpIntentResult == main.TRUE:
1335 getIntentResult = main.ONOS2.intents()
1336 main.log.info( "Point to point intent install successful" )
1337 # main.log.info( getIntentResult )
1338
1339 ptpIntentResult = main.ONOS2.addPointIntent(
1340 "of:0000000000006020/1",
1341 "of:0000000000003010/1" )
1342 if ptpIntentResult == main.TRUE:
1343 getIntentResult = main.ONOS2.intents()
1344 main.log.info( "Point to point intent install successful" )
1345 # main.log.info( getIntentResult )
1346
1347 var4 = "Add point intents for mininet hosts h11 and h21 or" +\
1348 " ONOS hosts hB and h15"
1349 main.case(var4)
1350 ptpIntentResult = main.ONOS2.addPointIntent(
1351 "of:0000000000003011/1",
1352 "of:0000000000006021/1" )
1353 if ptpIntentResult == main.TRUE:
1354 getIntentResult = main.ONOS2.intents()
1355 main.log.info( "Point to point intent install successful" )
1356 # main.log.info( getIntentResult )
1357
1358 ptpIntentResult = main.ONOS2.addPointIntent(
1359 "of:0000000000006021/1",
1360 "of:0000000000003011/1" )
1361 if ptpIntentResult == main.TRUE:
1362 getIntentResult = main.ONOS2.intents()
1363 main.log.info( "Point to point intent install successful" )
1364 # main.log.info( getIntentResult )
1365
1366 var5 = "Add point intents for mininet hosts h12 and h22 " +\
1367 "ONOS hosts hC and h16"
1368 main.case(var5)
1369 ptpIntentResult = main.ONOS2.addPointIntent(
1370 "of:0000000000003012/1",
1371 "of:0000000000006022/1" )
1372 if ptpIntentResult == main.TRUE:
1373 getIntentResult = main.ONOS2.intents()
1374 main.log.info( "Point to point intent install successful" )
1375 # main.log.info( getIntentResult )
1376
1377 ptpIntentResult = main.ONOS2.addPointIntent(
1378 "of:0000000000006022/1",
1379 "of:0000000000003012/1" )
1380 if ptpIntentResult == main.TRUE:
1381 getIntentResult = main.ONOS2.intents()
1382 main.log.info( "Point to point intent install successful" )
1383 # main.log.info( getIntentResult )
1384
1385 var6 = "Add point intents for mininet hosts h13 and h23 or" +\
1386 " ONOS hosts hD and h17"
1387 main.case(var6)
1388 ptpIntentResult = main.ONOS2.addPointIntent(
1389 "of:0000000000003013/1",
1390 "of:0000000000006023/1" )
1391 if ptpIntentResult == main.TRUE:
1392 getIntentResult = main.ONOS2.intents()
1393 main.log.info( "Point to point intent install successful" )
1394 # main.log.info( getIntentResult )
1395
1396 ptpIntentResult = main.ONOS2.addPointIntent(
1397 "of:0000000000006023/1",
1398 "of:0000000000003013/1" )
1399 if ptpIntentResult == main.TRUE:
1400 getIntentResult = main.ONOS2.intents()
1401 main.log.info( "Point to point intent install successful" )
1402 # main.log.info( getIntentResult )
1403
1404 var7 = "Add point intents for mininet hosts h14 and h24 or" +\
1405 " ONOS hosts hE and h18"
1406 main.case(var7)
1407 ptpIntentResult = main.ONOS2.addPointIntent(
1408 "of:0000000000003014/1",
1409 "of:0000000000006024/1" )
1410 if ptpIntentResult == main.TRUE:
1411 getIntentResult = main.ONOS2.intents()
1412 main.log.info( "Point to point intent install successful" )
1413 # main.log.info( getIntentResult )
1414
1415 ptpIntentResult = main.ONOS2.addPointIntent(
1416 "of:0000000000006024/1",
1417 "of:0000000000003014/1" )
1418 if ptpIntentResult == main.TRUE:
1419 getIntentResult = main.ONOS2.intents()
1420 main.log.info( "Point to point intent install successful" )
1421 # main.log.info( getIntentResult )
1422
1423 var8 = "Add point intents for mininet hosts h15 and h25 or" +\
1424 " ONOS hosts hF and h19"
1425 main.case(var8)
1426 ptpIntentResult = main.ONOS2.addPointIntent(
1427 "of:0000000000003015/1",
1428 "of:0000000000006025/1" )
1429 if ptpIntentResult == main.TRUE:
1430 getIntentResult = main.ONOS2.intents()
1431 main.log.info( "Point to point intent install successful" )
1432 # main.log.info( getIntentResult )
1433
1434 ptpIntentResult = main.ONOS2.addPointIntent(
1435 "of:0000000000006025/1",
1436 "of:0000000000003015/1" )
1437 if ptpIntentResult == main.TRUE:
1438 getIntentResult = main.ONOS2.intents()
1439 main.log.info( "Point to point intent install successful" )
1440 # main.log.info( getIntentResult )
1441
1442 var9 = "Add intents for mininet hosts h16 and h26 or" +\
1443 " ONOS hosts h10 and h1A"
1444 main.case(var9)
1445 ptpIntentResult = main.ONOS2.addPointIntent(
1446 "of:0000000000003016/1",
1447 "of:0000000000006026/1" )
1448 if ptpIntentResult == main.TRUE:
1449 getIntentResult = main.ONOS2.intents()
1450 main.log.info( "Point to point intent install successful" )
1451 # main.log.info( getIntentResult )
1452
1453 ptpIntentResult = main.ONOS2.addPointIntent(
1454 "of:0000000000006026/1",
1455 "of:0000000000003016/1" )
1456 if ptpIntentResult == main.TRUE:
1457 getIntentResult = main.ONOS2.intents()
1458 main.log.info( "Point to point intent install successful" )
1459 # main.log.info( getIntentResult )
1460
1461 var10 = "Add point intents for mininet hosts h17 and h27 or" +\
1462 " ONOS hosts h11 and h1B"
1463 main.case(var10)
1464 ptpIntentResult = main.ONOS2.addPointIntent(
1465 "of:0000000000003017/1",
1466 "of:0000000000006027/1" )
1467 if ptpIntentResult == main.TRUE:
1468 getIntentResult = main.ONOS2.intents()
1469 main.log.info( "Point to point intent install successful" )
1470 #main.log.info( getIntentResult )
1471
1472 ptpIntentResult = main.ONOS2.addPointIntent(
1473 "of:0000000000006027/1",
1474 "of:0000000000003017/1" )
1475 if ptpIntentResult == main.TRUE:
1476 getIntentResult = main.ONOS2.intents()
1477 main.log.info( "Point to point intent install successful" )
1478 #main.log.info( getIntentResult )
1479
1480 print(
1481 "___________________________________________________________" )
1482
1483 flowHandle = main.ONOS2.flows()
1484 #main.log.info( "flows :" + flowHandle )
1485
1486 count = 1
1487 i = 8
1488 PingResult = main.TRUE
1489 while i < 18:
1490 main.log.info(
1491 "\n\nh" + str( i ) + " is Pinging h" + str( i + 10 ) )
1492 ping = main.Mininet1.pingHost(
1493 src="h" + str( i ), target="h" + str( i + 10 ) )
1494 if ping == main.FALSE and count < 5:
1495 count += 1
1496 # i = 8
1497 PingResult = main.FALSE
1498 main.log.report( "Ping between h" +
1499 str( i ) +
1500 " and h" +
1501 str( i +
1502 10 ) +
1503 " failed. Making attempt number " +
1504 str( count ) +
1505 " in 2 seconds" )
1506 time.sleep( 2 )
1507 elif ping == main.FALSE:
1508 main.log.report( "All ping attempts between h" +
1509 str( i ) +
1510 " and h" +
1511 str( i +
1512 10 ) +
1513 "have failed" )
1514 i = 19
1515 PingResult = main.FALSE
1516 elif ping == main.TRUE:
1517 main.log.info( "Ping test between h" +
1518 str( i ) +
1519 " and h" +
1520 str( i +
1521 10 ) +
1522 "passed!" )
1523 i += 1
1524 PingResult = main.TRUE
1525 else:
1526 main.log.info( "Unknown error" )
1527 PingResult = main.ERROR
1528
1529 if PingResult == main.FALSE:
1530 main.log.report(
1531 "Point intents have not ben installed correctly. Cleaning up" )
1532 # main.cleanup()
1533 # main.exit()
1534 if PingResult == main.TRUE:
1535 main.log.report( "Point Intents have been installed correctly" )
1536
1537 case9Result = PingResult
1538 utilities.assert_equals(
1539 expect=main.TRUE,
1540 actual=case9Result,
1541 onpass="Point intents addition and Pingall Test successful",
1542 onfail="Point intents addition and Pingall Test NOT successful" )