| class SRMulticast: | |
| def __init__( self ): | |
| self.default = '' | |
| def CASE1( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Create a Multicast flow between a source and sink on the same dual-tor leaf | |
| Verify flows and groups | |
| Verify traffic | |
| Remove sink | |
| Verify flows and groups | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Create a Multicast flow between a source and sink on the same dual-tor leaf" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=1, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyMcastSinkRemoval( main, "ipv4", 0, False ) | |
| verifyMcastSourceRemoval( main, "ipv4", 0, False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE2( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Create a Multicast flow between a source and sink on different dual-tor leaves | |
| Verify flows and groups | |
| Verify traffic | |
| Remove sink | |
| Verify flows and groups | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Create a Multicast flow between a source and sink on different dual-tor leaves" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 1 ] } } | |
| setupTest( main, test_idx=2, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyMcastSinkRemoval( main, "ipv4", 1, False ) | |
| verifyMcastSourceRemoval( main, "ipv4", 0, False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE3( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Create a Multicast flow between a source and sink on different leaves (sink on single-tor) | |
| Verify flows and groups | |
| Verify traffic | |
| Remove sink | |
| Verify flows and groups | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Create a Multicast flow between a source and sink on different leaves (sink on single-tor)" ) | |
| main.mcastRoutes = { "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=3, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyMcastRouteRemoval( main, "ipv6" ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE4( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE1 and CASE2 | |
| Verify flows and groups | |
| Verify traffic | |
| Remove sinks | |
| Verify flows and groups | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE1 and CASE2" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1 ] } } | |
| setupTest( main, test_idx=4, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyMcastSinkRemoval( main, "ipv4", 0, [ False, True ] ) | |
| verifyMcastSinkRemoval( main, "ipv4", 1, False ) | |
| verifyMcastSourceRemoval( main, "ipv4", 0, False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE5( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE2 and CASE3 | |
| Verify flows and groups | |
| Verify traffic | |
| Remove sinks | |
| Verify flows and groups | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE2 and CASE3" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 1 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=5, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyMcastRouteRemoval( main, "ipv6" ) | |
| verifyMcastSinkRemoval( main, "ipv4", 1, False ) | |
| verifyMcastSourceRemoval( main, "ipv4", 0, False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE6( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE1 and CASE3 | |
| Verify flows and groups | |
| Verify traffic | |
| Remove sinks | |
| Verify flows and groups | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE1 and CASE3" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=6, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyMcastRouteRemoval( main, "ipv6" ) | |
| verifyMcastSinkRemoval( main, "ipv4", 0, False ) | |
| verifyMcastSourceRemoval( main, "ipv4", 0, False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE7( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE1, CASE2 and CASE3 | |
| Verify flows and groups | |
| Verify traffic | |
| Remove sinks | |
| Verify flows and groups | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE1, CASE2 and CASE3" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=7, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyMcastRouteRemoval( main, "ipv6" ) | |
| verifyMcastSinkRemoval( main, "ipv4", 0, [ False, True ] ) | |
| verifyMcastSinkRemoval( main, "ipv4", 1, False ) | |
| verifyMcastSourceRemoval( main, "ipv4", 0, False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE8( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Use all of the four sinks | |
| Verify flows and groups | |
| Verify traffic | |
| Remove sinks | |
| Verify flows and groups | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Use all of the four sinks" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=8, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyMcastRemoval( main ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE101( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with a link failure (link ingress-spine) | |
| Verify flows and groups | |
| Verify traffic | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with a link failure (link ingress-spine)" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=101, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyLinkDown( main, [ "leaf2", "spine101" ], 4 ) | |
| verifyMcastRemoval( main ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE102( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with a link failure (link spine-egress-dt-leaf) | |
| Verify flows and groups | |
| Verify traffic | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with a link failure (link spine-engress-dt-leaf)" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=102, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyLinkDown( main, [ "leaf5", "spine101" ], 4 ) | |
| verifyMcastRemoval( main ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE103( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with a link failure (link spine-egress-st-leaf) | |
| Verify flows and groups | |
| Verify traffic | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with a link failure (link spine-engress-st-leaf)" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=103, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyLinkDown( main, [ "spine103", "spine101" ], 2 ) | |
| verifyMcastRemoval( main ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE104( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with a link failure (link spine-egress-st-leaf-2) | |
| Verify flows and groups | |
| Verify traffic | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with a link failure (link spine-engress-st-leaf-2)" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=104, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyLinkDown( main, [ "leaf4", "spine101" ], 4 ) | |
| verifyMcastRemoval( main ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE105( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with a link failure (link dt-leaf-sink) | |
| Verify flows and groups | |
| Verify traffic | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with a link failure (link dt-leaf-sink)" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=105, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyLinkDown( main, [ "leaf2", "h4v4" ], 0 ) | |
| verifyMcastRemoval( main ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE106( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with a link failure (link dt-leaf-sink-2) | |
| Verify flows and groups | |
| Verify traffic | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with a link failure (link dt-leaf-sink-2)" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=106, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyLinkDown( main, [ "leaf5", "h10v4" ], 0 ) | |
| verifyMcastRemoval( main ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE201( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with spine failure | |
| Verify flows and groups | |
| Verify traffic | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with spine failure" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=201, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifySwitchDown( main, "spine101", 18 ) | |
| verifySwitchDown( main, "spine102", 18 ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE202( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with ingress failure and recovery | |
| Verify flows and groups are removed (failure) | |
| Verify flows and groups (recovery) | |
| Verify traffic (recovery) | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with ingress failure and recovery" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=202, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifySwitchDown( main, "leaf2", 10, | |
| { "ipv4": False, "ipv6": False }, | |
| [ "h3v4", "h3v6", "h4v4" ], | |
| { "h3v4": "of:0000000000000002/9", | |
| "h3v6": "of:0000000000000002/6", | |
| "h4v4": ["of:0000000000000002/10", "of:0000000000000003/10"] } ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE203( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with egress-dt-leaf failure and recovery | |
| Verify flows and groups are removed for the failing sink (failure) | |
| Verify traffic on remaining sinks (failure) | |
| Verify flows and groups (recovery) | |
| Verify traffic (recovery) | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with egress-dt-leaf failure and recovery" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=203, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifySwitchDown( main, "leaf5", 10, | |
| hostsToDiscover=[ "h10v4" ], | |
| hostLocations={ "h10v4": ["of:0000000000000004/11", "of:0000000000000005/10"] } ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE204( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with egress-st-leaf failure and recovery | |
| Verify flows and groups are removed for the failing sink (failure) | |
| Verify traffic on remaining sinks (failure) | |
| Verify flows and groups (recovery) | |
| Verify traffic (recovery) | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with egress-st-leaf failure and recovery" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=204, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifySwitchDown( main, "leaf4", 10, | |
| { "ipv4": [ True, False, True ], "ipv6": True }, | |
| [ "h8v4", "h10v4" ], | |
| { "h8v4": ["of:0000000000000004/9"], | |
| "h10v4": ["of:0000000000000004/11", "of:0000000000000005/10"] } ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE205( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with egress leaves failure and recovery | |
| Verify flows and groups are removed for the failing sinks (failure) | |
| Verify traffic on remaining sink (failure) | |
| Verify flows and groups (recovery) | |
| Verify traffic (recovery) | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with leaves failure and recovery" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=205, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifySwitchDown( main, [ "leaf1", "leaf3", "leaf4", "leaf5" ], 32, | |
| { "ipv4": [ True, False, False ], "ipv6": False }, | |
| [ "h4v4", "h8v4", "h10v4", "h1v6"], | |
| { "h4v4": ["of:0000000000000002/10", "of:0000000000000003/10"], | |
| "h8v4": ["of:0000000000000004/9"], | |
| "h10v4": ["of:0000000000000004/11", "of:0000000000000005/10"], | |
| "h1v6": ["of:0000000000000001/3"] } ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE301( self, main ): | |
| """ | |
| Sets up 3 ONOS instances, start H-AGG topology | |
| Combines CASE8 with ONOS failure and recovery | |
| Verify flows and groups (failure) | |
| Verify traffic (failure) | |
| Verify flows and groups (recovery) | |
| Verify traffic (recovery) | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Combines CASE8 with leaves failure and recovery" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=205, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyOnosDown( main ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE401( self, main ): | |
| """ | |
| Extends MCAST105 | |
| Create sinks and verify traffic is working | |
| Bring down host port and verify traffic is still working for all sinks | |
| Bring up host port again and start ping from DTH1 to STS | |
| Verify host has both location and stop the ping | |
| Kill LEAFA and verify traffic is still working for all sinks | |
| Remove IPv6 route | |
| Remove DTH2 sink | |
| Remove STH2 sink | |
| Remove STS | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Extends MCAST105" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=401, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| # Verify killing one link of dual-homed host h4 | |
| verifyPortDown( main, "of:0000000000000002", 10, hostsToDiscover=[ "h4v4" ], hostLocations={ "h4v4": ["of:0000000000000002/10", "of:0000000000000003/10"] } ) | |
| verifyPortDown( main, "of:0000000000000003", 10, hostsToDiscover=[ "h4v4" ], hostLocations={ "h4v4": ["of:0000000000000002/10", "of:0000000000000003/10"] } ) | |
| # Verify killing one link of dual-homed host h10 | |
| verifyPortDown( main, "of:0000000000000004", 11, hostsToDiscover=[ "h10v4" ], hostLocations={ "h10v4": ["of:0000000000000004/11", "of:0000000000000005/10"] } ) | |
| verifyPortDown( main, "of:0000000000000005", 10, hostsToDiscover=[ "h10v4" ], hostLocations={ "h10v4": ["of:0000000000000004/11", "of:0000000000000005/10"] } ) | |
| verifySwitchDown( main, "leaf3", 10, | |
| hostsToDiscover=[ "h4v4" ], | |
| hostLocations={ "h4v4": ["of:0000000000000002/10", "of:0000000000000003/10"] } ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE402( self, main ): | |
| """ | |
| No downstream path for DTH2 | |
| Create sinks and verify traffic is working | |
| Kill all up-links of the LEAFB and verify traffic is still working | |
| Remove IPv6 route | |
| Remove DTH2 sink | |
| Remove STH2 sink | |
| Remove STS | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "No downstream path for DTH2" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=402, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| verifyLinkDown( main, [ [ "leaf5", "spine101" ], [ "leaf5", "spine102" ] ], 8 ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE403( self, main ): | |
| """ | |
| No downstream path for DTH1 | |
| Create sinks and verify traffic is working | |
| Bring down host port and verify traffic is still working for all sinks | |
| Bring up host port again and start ping from DTH1 to STS | |
| Verify host has both location and stop the ping | |
| Kill all up-links of the LEAFA and verify traffic is still working | |
| Remove IPv6 route | |
| Remove DTH2 sink | |
| Remove STH2 sink | |
| Remove STS | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "No downstream path for DTH1" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=403, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| # Verify killing one link of dual-homed host h4 | |
| verifyPortDown( main, "of:0000000000000002", 10, hostsToDiscover=[ "h4v4" ], hostLocations={ "h4v4": ["of:0000000000000002/10", "of:0000000000000003/10"] } ) | |
| verifyPortDown( main, "of:0000000000000003", 10, hostsToDiscover=[ "h4v4" ], hostLocations={ "h4v4": ["of:0000000000000002/10", "of:0000000000000003/10"] } ) | |
| # Verify killing one link of dual-homed host h10 | |
| verifyPortDown( main, "of:0000000000000004", 11, hostsToDiscover=[ "h10v4" ], hostLocations={ "h10v4": ["of:0000000000000004/11", "of:0000000000000005/10"] } ) | |
| verifyPortDown( main, "of:0000000000000005", 10, hostsToDiscover=[ "h10v4" ], hostLocations={ "h10v4": ["of:0000000000000004/11", "of:0000000000000005/10"] } ) | |
| verifyLinkDown( main, [ [ "leaf3", "spine101" ], [ "leaf3", "spine102" ] ], 8 ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) | |
| def CASE404( self, main ): | |
| """ | |
| Extends MCAST 403 | |
| Create sinks and verify traffic is working | |
| Bring down host port and verify traffic is still working for all sinks | |
| Bring up host port again and start ping from DTH1 to STS | |
| Verify host has both location and stop the ping | |
| Kill up-links of the LEAFA towards SPINEA, kill up-links of the SOURCE LEAF towards SPINEC and verify traffic is still working for all sinks | |
| Remove IPv6 route | |
| Remove DTH2 sink | |
| Remove STH2 sink | |
| Remove STS | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRMulticast.dependencies.SRMulticastTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Extends MCASR 403" ) | |
| main.mcastRoutes = { "ipv4": { "src": [ 0 ], "dst": [ 0, 1, 2 ] }, "ipv6": { "src": [ 0 ], "dst": [ 0 ] } } | |
| setupTest( main, test_idx=404, onosNodes=3 ) | |
| verifyMcastRoutes( main ) | |
| # Verify killing one link of dual-homed host h4 | |
| verifyPortDown( main, "of:0000000000000002", 10, hostsToDiscover=[ "h4v4" ], hostLocations={ "h4v4": ["of:0000000000000002/10", "of:0000000000000003/10"] } ) | |
| verifyPortDown( main, "of:0000000000000003", 10, hostsToDiscover=[ "h4v4" ], hostLocations={ "h4v4": ["of:0000000000000002/10", "of:0000000000000003/10"] } ) | |
| # Verify killing one link of dual-homed host h10 | |
| verifyPortDown( main, "of:0000000000000004", 11, hostsToDiscover=[ "h10v4" ], hostLocations={ "h10v4": ["of:0000000000000004/11", "of:0000000000000005/10"] } ) | |
| verifyPortDown( main, "of:0000000000000005", 10, hostsToDiscover=[ "h10v4" ], hostLocations={ "h10v4": ["of:0000000000000004/11", "of:0000000000000005/10"] } ) | |
| verifyLinkDown( main, [ [ "leaf3", "spine101" ], [ "leaf2", "spine102" ] ], 8 ) | |
| verifyMcastRemoval( main, removeDHT1=False ) | |
| lib.cleanup( main, copyKarafLog=False ) |