| class SRRouting: | |
| def __init__( self ): | |
| self.default = '' | |
| def CASE1( self, main ): | |
| """ | |
| Ping between all ipv4 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Ping between all ipv4 hosts in the topology" ) | |
| setupTest( main, test_idx=1, onosNodes=3, ipv6=False, external=False ) | |
| verify( main, ipv6=False, disconnected=False, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE2( self, main ): | |
| """ | |
| Ping between all ipv6 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Ping between all ipv6 hosts in the topology" ) | |
| setupTest( main, test_idx=2, onosNodes=3, ipv4=False, external=False ) | |
| verify( main, ipv4=False, disconnected=False, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE3( self, main ): | |
| """ | |
| Ping between all ipv4 and ipv6 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Ping between all ipv4 and ipv6 hosts in the topology" ) | |
| setupTest( main, test_idx=3, onosNodes=3, external=False ) | |
| verify( main, disconnected=False, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE4( self, main ): | |
| """ | |
| Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts" ) | |
| setupTest( main, test_idx=4, onosNodes=3, ipv6=False ) | |
| verify( main, ipv6=False, disconnected=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE5( self, main ): | |
| """ | |
| Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts" ) | |
| setupTest( main, test_idx=5, onosNodes=3, ipv4=False ) | |
| verify( main, ipv4=False, disconnected=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE6( self, main ): | |
| """ | |
| Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external ipv4 and ipv6 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external hosts" ) | |
| setupTest( main, test_idx=6, onosNodes=3 ) | |
| verify( main, disconnected=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE7( self, main ): | |
| """ | |
| Ping between ipv4 hosts and an external host that is not configured in | |
| external router config, but reachable through the use of route-add | |
| command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Ping between from ipv4 hosts to external host configured with route-add command" ) | |
| setupTest( main, test_idx=7, onosNodes=3, ipv6=False, external=False ) | |
| verify( main, ipv6=False, internal=False, disconnected=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE8( self, main ): | |
| """ | |
| Ping between ipv6 hosts and an external host that is not configured in | |
| external router config, but reachable through the use of route-add | |
| command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Ping between from ipv6 hosts to external host configured with route-add command" ) | |
| setupTest( main, test_idx=8, onosNodes=3, ipv4=False, external=False ) | |
| verify( main, ipv6=False, internal=False, disconnected=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE9( self, main ): | |
| """ | |
| Ping between ipv4 and pv6 hosts and external hosts that is not configured in | |
| external router config, but reachable through the use of route-add | |
| command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Ping between from ipv4 and ipv6 hosts to external host configured with route-add command" ) | |
| setupTest( main, test_idx=9, onosNodes=3, external=False ) | |
| verify( main, internal=False, disconnected=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE101( self, main ): | |
| """ | |
| Kill and recover links | |
| Ping between all ipv4 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test link failures with IPv4 hosts" ) | |
| setupTest( main, test_idx=101, onosNodes=3, ipv6=False, external=False ) | |
| verify( main, ipv6=False, external=False, disconnected=False ) | |
| verifyLinkFailure( main, ipv6=False, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE102( self, main ): | |
| """ | |
| Kill and recover links | |
| Ping between all ipv6 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test link failures with IPv6 hosts" ) | |
| setupTest( main, test_idx=102, onosNodes=3, ipv4=False, external=False ) | |
| verify( main, ipv4=False, external=False, disconnected=False ) | |
| verifyLinkFailure( main, ipv4=False, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE103( self, main ): | |
| """ | |
| Kill and recover links | |
| Ping between all ipv4 and ipv6 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test link failures with IPv4 and IPv6 hosts" ) | |
| setupTest( main, test_idx=103, onosNodes=3, external=False ) | |
| verify( main, external=False, disconnected=False ) | |
| verifyLinkFailure( main, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE104( self, main ): | |
| """ | |
| Kill and recover links | |
| Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test link failures with IPv4 hosts including external hosts" ) | |
| setupTest( main, test_idx=104, onosNodes=3, ipv6=False ) | |
| verify( main, ipv6=False, disconnected=False ) | |
| verifyLinkFailure( main, ipv6=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE105( self, main ): | |
| """ | |
| Kill and recover links | |
| Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test link failures with IPv6 hosts including external hosts" ) | |
| setupTest( main, test_idx=105, onosNodes=3, ipv4=False ) | |
| verify( main, ipv4=False, disconnected=False ) | |
| verifyLinkFailure( main, ipv4=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE106( self, main ): | |
| """ | |
| Kill and recover links | |
| Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external ipv4 and ipv6 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test link failures with IPv4 and IPv6 hosts including external hosts" ) | |
| setupTest( main, test_idx=106, onosNodes=3 ) | |
| verify( main, disconnected=False ) | |
| verifyLinkFailure( main ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE107( self, main ): | |
| """ | |
| Kill and recover links | |
| Ping between ipv4 hosts and an external host that is not configured in | |
| external router config, but reachable through the use of route-add command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test link failures with IPv4 hosts including external hosts configured with route-add command" ) | |
| setupTest( main, test_idx=107, onosNodes=3, ipv6=False, external=False ) | |
| verify( main, ipv6=False, disconnected=False ) | |
| verifyLinkFailure( main, ipv6=False, internal=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE108( self, main ): | |
| """ | |
| Kill and recover links | |
| Ping between ipv6 hosts and an external host that is not configured in | |
| external router config, but reachable through the use of route-add command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test link failures with IPv6 hosts including external hosts configured with route-add command" ) | |
| setupTest( main, test_idx=108, onosNodes=3, ipv4=False, external=False ) | |
| verify( main, ipv4=False, disconnected=False ) | |
| verifyLinkFailure( main, ipv4=False, internal=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE109( self, main ): | |
| """ | |
| Kill and recover links | |
| Ping between ipv4 and pv6 hosts and external hosts that is not configured in | |
| external router config, but reachable through the use of route-add command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test link failures with IPv4 and IPv6 hosts including external hosts configured with route-add command" ) | |
| setupTest( main, test_idx=109, onosNodes=3, external=False ) | |
| verify( main, disconnected=False ) | |
| verifyLinkFailure( main, internal=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE201( self, main ): | |
| """ | |
| Kill and recover spine switches | |
| Ping between all ipv4 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test switch failures with IPv4 hosts" ) | |
| setupTest( main, test_idx=201, onosNodes=3, ipv6=False, external=False ) | |
| verify( main, ipv6=False, external=False, disconnected=False ) | |
| verifySwitchFailure( main, ipv6=False, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE202( self, main ): | |
| """ | |
| Kill and recover spine switches | |
| Ping between all ipv6 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test switch failures with IPv6 hosts" ) | |
| setupTest( main, test_idx=202, onosNodes=3, ipv4=False, external=False ) | |
| verify( main, ipv4=False, external=False, disconnected=False ) | |
| verifySwitchFailure( main, ipv4=False, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE203( self, main ): | |
| """ | |
| Kill and recover spine switches | |
| Ping between all ipv4 and ipv6 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test switch failures with IPv4 and IPv6 hosts" ) | |
| setupTest( main, test_idx=203, onosNodes=3, external=False ) | |
| verify( main, external=False, disconnected=False ) | |
| verifySwitchFailure( main, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE204( self, main ): | |
| """ | |
| Kill and recover spine switches | |
| Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test switch failures with IPv4 hosts including external hosts" ) | |
| setupTest( main, test_idx=204, onosNodes=3, ipv6=False ) | |
| verify( main, ipv6=False, disconnected=False ) | |
| verifySwitchFailure( main, ipv6=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE205( self, main ): | |
| """ | |
| Kill and recover spine switches | |
| Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test switch failures with IPv6 hosts including external hosts" ) | |
| setupTest( main, test_idx=205, onosNodes=3, ipv4=False ) | |
| verify( main, ipv4=False, disconnected=False ) | |
| verifySwitchFailure( main, ipv4=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE206( self, main ): | |
| """ | |
| Kill and recover spine switches | |
| Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external ipv4 and ipv6 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test switch failures with IPv4 and IPv6 hosts including external hosts" ) | |
| setupTest( main, test_idx=206, onosNodes=3 ) | |
| verify( main, disconnected=False ) | |
| verifySwitchFailure( main ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE207( self, main ): | |
| """ | |
| Kill and recover spine switches | |
| Ping between ipv4 hosts and an external host that is not configured in | |
| external router config, but reachable through the use of route-add command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test switch failures with IPv4 hosts including external hosts configured with route-add command" ) | |
| setupTest( main, test_idx=207, onosNodes=3, ipv6=False, external=False ) | |
| verify( main, ipv6=False, disconnected=False ) | |
| verifySwitchFailure( main, ipv6=False, internal=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE208( self, main ): | |
| """ | |
| Kill and recover spine switches | |
| Ping between ipv6 hosts and an external host that is not configured in | |
| external router config, but reachable through the use of route-add command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test switch failures with IPv6 hosts including external hosts configured with route-add command" ) | |
| setupTest( main, test_idx=208, onosNodes=3, ipv4=False, external=False ) | |
| verify( main, ipv4=False, disconnected=False ) | |
| verifySwitchFailure( main, ipv4=False, internal=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE209( self, main ): | |
| """ | |
| Kill and recover spine switches | |
| Ping between ipv4 and pv6 hosts and external hosts that is not configured in | |
| external router config, but reachable through the use of route-add command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test switch failures with IPv4 and IPv6 hosts including external hosts configured with route-add command" ) | |
| setupTest( main, test_idx=209, onosNodes=3, external=False ) | |
| verify( main, disconnected=False ) | |
| verifySwitchFailure( main, internal=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE301( self, main ): | |
| """ | |
| Kill and recover onos nodes | |
| Ping between all ipv4 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test onos failures with IPv4 hosts" ) | |
| setupTest( main, test_idx=301, onosNodes=3, ipv6=False, external=False ) | |
| verify( main, ipv6=False, external=False, disconnected=False ) | |
| verifyOnosFailure( main, ipv6=False, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE302( self, main ): | |
| """ | |
| Kill and recover onos nodes | |
| Ping between all ipv6 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test onos failures with IPv6 hosts" ) | |
| setupTest( main, test_idx=302, onosNodes=3, ipv4=False, external=False ) | |
| verify( main, ipv4=False, external=False, disconnected=False ) | |
| verifyOnosFailure( main, ipv4=False, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE303( self, main ): | |
| """ | |
| Kill and recover onos nodes | |
| Ping between all ipv4 and ipv6 hosts in the topology. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test onos failures with IPv4 and IPv6 hosts" ) | |
| setupTest( main, test_idx=303, onosNodes=3, external=False ) | |
| verify( main, external=False, disconnected=False ) | |
| verifyOnosFailure( main, external=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE304( self, main ): | |
| """ | |
| Kill and recover onos nodes | |
| Ping between all ipv4 hosts in the topology and check connectivity to external ipv4 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test onos failures with IPv4 hosts including external hosts" ) | |
| setupTest( main, test_idx=304, onosNodes=3, ipv6=False ) | |
| verify( main, ipv6=False, disconnected=False ) | |
| verifyOnosFailure( main, ipv6=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE305( self, main ): | |
| """ | |
| Kill and recover onos nodes | |
| Ping between all ipv6 hosts in the topology and check connectivity to external ipv6 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test onos failures with IPv6 hosts including external hosts" ) | |
| setupTest( main, test_idx=305, onosNodes=3, ipv4=False ) | |
| verify( main, ipv4=False, disconnected=False ) | |
| verifyOnosFailure( main, ipv4=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE306( self, main ): | |
| """ | |
| Kill and recover onos nodes | |
| Ping between all ipv4 and ipv6 hosts in the topology and check connectivity to external ipv4 and ipv6 hosts | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test onos failures with IPv4 and IPv6 hosts including external hosts" ) | |
| setupTest( main, test_idx=306, onosNodes=3 ) | |
| verify( main, disconnected=False ) | |
| verifyOnosFailure( main ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE307( self, main ): | |
| """ | |
| Kill and recover onos nodes | |
| Ping between ipv4 hosts and an external host that is not configured in | |
| external router config, but reachable through the use of route-add command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test onos failures with IPv4 hosts including external hosts configured with route-add command" ) | |
| setupTest( main, test_idx=307, onosNodes=3, ipv6=False, external=False ) | |
| verify( main, ipv6=False, disconnected=False ) | |
| verifyOnosFailure( main, ipv6=False, internal=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE308( self, main ): | |
| """ | |
| Kill and recover onos nodes | |
| Ping between ipv6 hosts and an external host that is not configured in | |
| external router config, but reachable through the use of route-add command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test onos failures with IPv6 hosts including external hosts configured with route-add command" ) | |
| setupTest( main, test_idx=308, onosNodes=3, ipv4=False, external=False ) | |
| verify( main, ipv4=False, disconnected=False ) | |
| verifyOnosFailure( main, ipv4=False, internal=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE309( self, main ): | |
| """ | |
| Kill and recover onos nodes | |
| Ping between ipv4 and pv6 hosts and external hosts that is not configured in | |
| external router config, but reachable through the use of route-add command. | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Test onos failures with IPv4 and IPv6 hosts including external hosts configured with route-add command" ) | |
| setupTest( main, test_idx=309, onosNodes=3, external=False ) | |
| verify( main, disconnected=False ) | |
| verifyOnosFailure( main, internal=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE603( self, main ): | |
| """" | |
| Drop HAGG-1 device and test connectivity. | |
| Drop DAAS-1 device and test connectivity (some hosts lost it) | |
| Bring up DAAS-1 and test connectivity (all hosts gained it again) | |
| Repeat the same with HAGG-2 and DAAS-2. | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Drop hagg spine switch along with dass leaf switch." ) | |
| setupTest( main, test_idx=603, onosNodes=3 ) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| verify( main ) | |
| lib.killSwitch( main, "spine103", int( main.params[ "TOPO" ]["switchNum" ] ) - 1, int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 ) | |
| verify( main ) | |
| lib.killSwitch( main, "leaf6", int( main.params[ "TOPO" ]["switchNum" ] ) - 2, int( main.params[ "TOPO" ][ "linkNum" ] ) - 8 ) | |
| main.disconnectedIpv4Hosts = [ 'h12v4', 'h13v4'] | |
| main.disconnectedIpv6Hosts = [ 'h12v6', 'h13v6'] | |
| verify( main ) | |
| lib.recoverSwitch( main, "leaf6", int( main.params[ "TOPO" ]["switchNum" ] ) - 1, int( main.params[ "TOPO" ][ "linkNum" ] ) - 6, rediscoverHosts=True) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| verify( main ) | |
| lib.recoverSwitch( main, "spine103", int( main.params[ "TOPO" ][ "switchNum" ] ), int( main.params[ "TOPO" ][ "linkNum" ] )) | |
| verify( main ) | |
| lib.killSwitch( main, "spine104", int( main.params[ "TOPO" ]["switchNum" ] ) - 1, int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 ) | |
| verify( main ) | |
| lib.killSwitch( main, "leaf1", int( main.params[ "TOPO" ]["switchNum" ] ) - 2, int( main.params[ "TOPO" ][ "linkNum" ] ) - 8 ) | |
| main.disconnectedIpv4Hosts = [ 'h1v4', 'h2v4'] | |
| main.disconnectedIpv6Hosts = [ 'h1v6', 'h2v6'] | |
| verify( main ) | |
| lib.recoverSwitch( main, "leaf1", int( main.params[ "TOPO" ]["switchNum" ] ) - 1, int( main.params[ "TOPO" ][ "linkNum" ] ) - 6, rediscoverHosts=True) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| verify( main ) | |
| lib.recoverSwitch( main, "spine104", int( main.params[ "TOPO" ][ "switchNum" ] ), int( main.params[ "TOPO" ][ "linkNum" ] )) | |
| verify( main ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE604( self, main ): | |
| """" | |
| Drop HAGG-1 device and test connectivity. | |
| Bring up HAGG-1 and test connectivity. | |
| Drop HAGG-2 device and test connectivity. | |
| Bring up HAGG-2 device and test connectivity | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Drop hagg spine switches." ) | |
| setupTest( main, test_idx=604, onosNodes=3 ) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| verify( main ) | |
| lib.killSwitch( main, "spine103", int( main.params[ "TOPO" ]["switchNum" ] ) - 1, int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 ) | |
| verify( main ) | |
| lib.recoverSwitch( main, "spine103", int( main.params[ "TOPO" ][ "switchNum" ] ), int( main.params[ "TOPO" ][ "linkNum" ] )) | |
| verify( main ) | |
| lib.killSwitch( main, "spine104", int( main.params[ "TOPO" ]["switchNum" ] ) - 1, int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 ) | |
| verify( main ) | |
| lib.recoverSwitch( main, "spine104", int( main.params[ "TOPO" ][ "switchNum" ] ), int( main.params[ "TOPO" ][ "linkNum" ] )) | |
| verify( main ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE605( self, main ): | |
| """ | |
| Drop HAGG-1 and test connectivity (expect no failure) | |
| Drop all leafs in big fabric and test connectivity (expect some failures) | |
| Bring up HAGG-1 and test connectivity (still expect some failures) | |
| Bring up all leafs in big fabric and test connectivity (expect no failure) | |
| Repeat above with HAGG-2 | |
| """ | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Drop one hagg and all leafs in big fabric" ) | |
| setupTest( main, test_idx=605, onosNodes=3 ) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| verify( main ) | |
| lib.killSwitch( main, "spine103", int( main.params[ "TOPO" ][ "switchNum" ] ) - 1, int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 ) | |
| verify( main ) | |
| lib.killSwitch( main, [ "leaf2", "leaf3", "leaf4", "leaf5" ], int( main.params[ "TOPO" ][ "switchNum" ] ) - 5, | |
| int( main.params[ "TOPO" ][ "linkNum" ] ) - 42 ) | |
| main.disconnectedIpv4Hosts = [ "h3v4", "h4v4", "h5v4", "h6v4", "h7v4", "h8v4", "h9v4", "h10v4", "h11v4" ] | |
| main.disconnectedIpv6Hosts = [ "h3v6", "h4v6", "h5v6", "h6v6", "h7v6", "h8v6", "h9v6", "h10v6", "h11v6" ] | |
| main.disconnectedExternalIpv4Hosts = [ "rh1v4", "rh2v4", "rh5v4" ] | |
| main.disconnectedExternalIpv6Hosts = [ "rh1v6", "rh11v6", "rh5v6", "rh2v6", "rh22v6" ] | |
| verify( main, disconnected=True ) | |
| lib.recoverSwitch( main, "spine103", int( main.params[ "TOPO" ][ "switchNum" ] ) - 4, int( main.params[ "TOPO" ][ "linkNum" ] ) - 36 ) | |
| verify( main, disconnected=True ) | |
| lib.recoverSwitch( main, [ "leaf2", "leaf3", "leaf4", "leaf5" ], int( main.params[ "TOPO" ][ "switchNum" ] ), | |
| int( main.params[ "TOPO" ][ "linkNum" ] ) ) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| main.disconnectedExternalIpv4Hosts = [ ] | |
| main.disconnectedExternalIpv6Hosts = [ ] | |
| verify( main ) | |
| lib.killSwitch( main, "spine104", int( main.params[ "TOPO" ][ "switchNum" ] ) - 1, int( main.params[ "TOPO" ][ "linkNum" ] ) - 6 ) | |
| verify( main ) | |
| lib.killSwitch( main, [ "leaf2", "leaf3", "leaf4", "leaf5" ], int( main.params[ "TOPO" ][ "switchNum" ] ) - 5, | |
| int( main.params[ "TOPO" ][ "linkNum" ] ) - 42 ) | |
| main.disconnectedIpv4Hosts = [ "h3v4", "h4v4", "h5v4", "h6v4", "h7v4", "h8v4", "h9v4", "h10v4", "h11v4" ] | |
| main.disconnectedIpv6Hosts = [ "h3v6", "h4v6", "h5v6", "h6v6", "h7v6", "h8v6", "h9v6", "h10v6", "h11v6" ] | |
| main.disconnectedExternalIpv4Hosts = [ "rh1v4", "rh2v4", "rh5v4" ] | |
| main.disconnectedExternalIpv6Hosts = [ "rh1v6", "rh11v6", "rh5v6", "rh2v6", "rh22v6" ] | |
| verify( main, disconnected=True ) | |
| lib.recoverSwitch( main, "spine104", int( main.params[ "TOPO" ][ "switchNum" ] ) - 4, int( main.params[ "TOPO" ][ "linkNum" ] ) - 36 ) | |
| verify( main, disconnected=True ) | |
| lib.recoverSwitch( main, [ "leaf2", "leaf3", "leaf4", "leaf5" ], int( main.params[ "TOPO" ][ "switchNum" ] ), | |
| int( main.params[ "TOPO" ][ "linkNum" ] ) ) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| main.disconnectedExternalIpv4Hosts = [ ] | |
| main.disconnectedExternalIpv6Hosts = [ ] | |
| verify( main ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE606( self, main ): | |
| """ | |
| Drop SPINE-1 and test connectivity | |
| Drop paired leaf and test connectivity (expect some failures) | |
| Bring up SPINE-1 and test connectivity (still expect some failures) | |
| Bring up the paired leaf and test connectivity | |
| Repeat above with SPINE-2 and a different paired leaf | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Drop spine and paired leaf" ) | |
| setupTest( main, test_idx=606, onosNodes=3 ) | |
| verify( main, disconnected=False ) | |
| # Drop spine101 and leaf-2/3 | |
| lib.killSwitch( main, "spine101", 9, 30 ) | |
| verify( main, disconnected=False ) | |
| lib.killSwitch( main, "leaf2", 8, 24 ) | |
| lib.killSwitch( main, "leaf3", 7, 20 ) | |
| main.disconnectedIpv4Hosts = [ "h3v4", "h4v4", "h5v4", "h6v4", "h7v4" ] | |
| main.disconnectedIpv6Hosts = [ "h3v6", "h4v6", "h5v6", "h6v6", "h7v6" ] | |
| verify( main ) | |
| lib.recoverSwitch( main, "spine101", 8, 30 ) | |
| verify( main ) | |
| lib.recoverSwitch( main, "leaf3", 9, 38 ) | |
| lib.recoverSwitch( main, "leaf2", 10, 48, rediscoverHosts=True, | |
| hostsToDiscover=main.disconnectedIpv4Hosts + main.disconnectedIpv6Hosts ) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| verify( main, disconnected=False ) | |
| # Drop spine102 and leaf-4/5 | |
| lib.killSwitch( main, "spine102", 9, 30 ) | |
| verify( main, disconnected=False ) | |
| lib.killSwitch( main, "leaf4", 8, 24 ) | |
| lib.killSwitch( main, "leaf5", 7, 20 ) | |
| main.disconnectedIpv4Hosts = [ "h8v4", "h9v4", "h10v4", "h11v4" ] | |
| main.disconnectedIpv6Hosts = [ "h8v6", "h9v6", "h10v6", "h11v6" ] | |
| verify( main, external=False ) | |
| lib.recoverSwitch( main, "spine102", 8, 30 ) | |
| verify( main, external=False ) | |
| lib.recoverSwitch( main, "leaf5", 9, 38 ) | |
| lib.recoverSwitch( main, "leaf4", 10, 48, rediscoverHosts=True, | |
| hostsToDiscover=main.disconnectedIpv4Hosts + main.disconnectedIpv6Hosts ) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| verify( main, disconnected=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE620( self, main ): | |
| """ | |
| Take down one of double links towards the spine from all leaf switches and | |
| check that buckets in select groups change accordingly | |
| Bring up links again and check that buckets in select groups change accordingly | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Take down one of double links towards the spine" ) | |
| setupTest( main, test_idx=620, onosNodes=3 ) | |
| verify( main, disconnected=False ) | |
| portsToDisable = [ [ "of:0000000000000002", 1 ], [ "of:0000000000000002", 3 ], | |
| [ "of:0000000000000003", 1 ], [ "of:0000000000000003", 3 ], | |
| [ "of:0000000000000004", 1 ], [ "of:0000000000000004", 3 ], | |
| [ "of:0000000000000005", 1 ], [ "of:0000000000000005", 3 ] ] | |
| for dpid, port in portsToDisable: | |
| main.Cluster.active( 0 ).CLI.portstate( dpid=dpid, port=port, state="disable" ) | |
| # TODO: check buckets in groups | |
| verify( main, disconnected=False ) | |
| for dpid, port in portsToDisable: | |
| main.Cluster.active( 0 ).CLI.portstate( dpid=dpid, port=port, state="enable" ) | |
| # TODO: check buckets in groups | |
| verify( main, disconnected=False ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE621( self, main ): | |
| """ | |
| Remove all the links in the network and restore all Links (repeat x3) | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Remove all the links in the network and restore all Links" ) | |
| setupTest( main, test_idx=621, onosNodes=3 ) | |
| verify( main, disconnected=False ) | |
| linksToRemove = [ ["spine101", "spine103"], ["spine102", "spine104"], | |
| ["spine103", "leaf6"], ["spine103", "leaf1"], | |
| ["spine104", "leaf6"], ["spine104", "leaf1"], | |
| ["spine101", "leaf2"], ["spine101", "leaf3"], ["spine101", "leaf4"], ["spine101", "leaf5"], | |
| ["spine102", "leaf2"], ["spine102", "leaf3"], ["spine102", "leaf4"], ["spine102", "leaf5"], | |
| ["leaf2", "leaf3"], ["leaf4", "leaf5"] ] | |
| portsToDisable = [ [ "of:0000000000000001", 3 ], [ "of:0000000000000001", 4 ], | |
| [ "of:0000000000000001", 5 ], [ "of:0000000000000001", 6 ], | |
| [ "of:0000000000000002", 6 ], [ "of:0000000000000002", 7 ], | |
| [ "of:0000000000000002", 8 ], [ "of:0000000000000002", 9 ], | |
| [ "of:0000000000000002", 10 ], [ "of:0000000000000002", 11 ], | |
| [ "of:0000000000000003", 6 ], [ "of:0000000000000003", 7 ], | |
| [ "of:0000000000000003", 8 ], [ "of:0000000000000003", 9 ], | |
| [ "of:0000000000000003", 10 ], [ "of:0000000000000003", 11 ], | |
| [ "of:0000000000000003", 12 ], [ "of:0000000000000003", 13 ], | |
| [ "of:0000000000000004", 6 ], [ "of:0000000000000004", 7 ], | |
| [ "of:0000000000000004", 8 ], [ "of:0000000000000004", 9 ], | |
| [ "of:0000000000000004", 10 ], [ "of:0000000000000004", 11 ], | |
| [ "of:0000000000000004", 12 ], [ "of:0000000000000004", 13 ], [ "of:0000000000000004", 14 ], | |
| [ "of:0000000000000005", 6 ], [ "of:0000000000000005", 7 ], | |
| [ "of:0000000000000005", 8 ], [ "of:0000000000000005", 9 ], | |
| [ "of:0000000000000005", 10 ], [ "of:0000000000000005", 11 ], | |
| [ "of:0000000000000005", 12 ], [ "of:0000000000000005", 13 ], | |
| [ "of:0000000000000005", 14 ], [ "of:0000000000000005", 15 ], | |
| [ "of:0000000000000006", 3 ], [ "of:0000000000000006", 4 ], | |
| [ "of:0000000000000006", 5 ], [ "of:0000000000000006", 6 ] ] | |
| for i in range( 0, 3 ): | |
| lib.killLinkBatch( main, linksToRemove, 0, 10 ) | |
| for dpid, port in portsToDisable: | |
| main.Cluster.active( 0 ).CLI.portstate( dpid=dpid, port=port, state="disable" ) | |
| time.sleep( 10 ) | |
| main.disconnectedIpv4Hosts = main.internalIpv4Hosts | |
| main.disconnectedIpv6Hosts = main.internalIpv6Hosts | |
| verify( main ) | |
| lib.restoreLinkBatch( main, linksToRemove, 48, 10 ) | |
| for dpid, port in portsToDisable: | |
| main.Cluster.active( 0 ).CLI.portstate( dpid=dpid, port=port, state="enable" ) | |
| time.sleep( 30 ) | |
| main.Network.discoverHosts( hostList=main.disconnectedIpv4Hosts + main.disconnectedIpv6Hosts ) | |
| time.sleep( 10 ) | |
| main.disconnectedIpv4Hosts = [] | |
| main.disconnectedIpv6Hosts = [] | |
| verify( main ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE622( self, main ): | |
| """ | |
| Take down all uplinks from a paired leaf switch | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| from core import utilities | |
| main.case( "Take down all uplinks from a paired leaf switch" ) | |
| setupTest( main, test_idx=622, onosNodes=3 ) | |
| verify( main, disconnected=False ) | |
| ctrl = main.Cluster.active( 0 ) | |
| result1 = ctrl.CLI.verifyHostLocation( "1003::3fe", | |
| [ "of:0000000000000002/7", "of:0000000000000003/6" ] ) | |
| result2 = ctrl.CLI.verifyHostLocation( "1004::3fe", | |
| [ "of:0000000000000002/8", "of:0000000000000003/7" ] ) | |
| result3 = ctrl.CLI.verifyHostLocation( "10.2.30.1", | |
| [ "of:0000000000000002/10", "of:0000000000000003/10" ] ) | |
| result4 = ctrl.CLI.verifyHostLocation( "10.2.20.1", | |
| [ "of:0000000000000002/11", "of:0000000000000003/11" ] ) | |
| utilities.assert_equals( expect=main.TRUE, actual=result1 and result2 and result3 and result4, | |
| onpass="Host locations are correct", | |
| onfail="Not all host locations are correct" ) | |
| linksToRemove = [ ["spine101", "leaf2"], ["spine102", "leaf2"] ] | |
| lib.killLinkBatch( main, linksToRemove, 40, 10 ) | |
| # TODO: more verifications are required | |
| verify( main ) | |
| main.step( "Verify some dual-homed hosts become single-homed" ) | |
| result1 = ctrl.CLI.verifyHostLocation( "1003::3fe", "of:0000000000000003/6" ) | |
| result2 = ctrl.CLI.verifyHostLocation( "1004::3fe", "of:0000000000000003/7" ) | |
| result3 = ctrl.CLI.verifyHostLocation( "10.2.30.1", "of:0000000000000003/10" ) | |
| result4 = ctrl.CLI.verifyHostLocation( "10.2.20.1", "of:0000000000000003/11" ) | |
| utilities.assert_equals( expect=main.TRUE, actual=result1 and result2 and result3 and result4, | |
| onpass="Host locations are correct", | |
| onfail="Not all host locations are correct" ) | |
| lib.restoreLinkBatch( main, linksToRemove, 48, 10 ) | |
| verify( main ) | |
| main.step( "Verify the hosts changed back to be dual-homed" ) | |
| result1 = ctrl.CLI.verifyHostLocation( "1003::3fe", | |
| [ "of:0000000000000002/7", "of:0000000000000003/6" ] ) | |
| result2 = ctrl.CLI.verifyHostLocation( "1004::3fe", | |
| [ "of:0000000000000002/8", "of:0000000000000003/7" ] ) | |
| result3 = ctrl.CLI.verifyHostLocation( "10.2.30.1", | |
| [ "of:0000000000000002/10", "of:0000000000000003/10" ] ) | |
| result4 = ctrl.CLI.verifyHostLocation( "10.2.20.1", | |
| [ "of:0000000000000002/11", "of:0000000000000003/11" ] ) | |
| utilities.assert_equals( expect=main.TRUE, actual=result1 and result2 and result3 and result4, | |
| onpass="Host locations are correct", | |
| onfail="Not all host locations are correct" ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE630( self, main ): | |
| """ | |
| Bring an instance down | |
| Drop a device | |
| Bring that same instance up again and observe that this specific instance sees that the device is down. | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| from core import utilities | |
| main.case( "Bring an instance down and drop a device" ) | |
| setupTest( main, test_idx=630, onosNodes=3 ) | |
| onosToKill = 0 | |
| deviceToDrop = "spine101" | |
| lib.killOnos( main, [ onosToKill ], 10, 48, 2 ) | |
| lib.killSwitch( main, deviceToDrop, 9, 30 ) | |
| lib.recoverOnos( main, [ onosToKill ], 9, 30, 3 ) | |
| result = main.Cluster.runningNodes[ onosToKill ].CLI.checkStatus( 9, 30, 3 ) | |
| utilities.assert_equals( expect=main.TRUE, actual=result, | |
| onpass="ONOS instance {} sees correct device numbers".format( onosToKill ), | |
| onfail="ONOS instance {} doesn't see correct device numbers".format( onosToKill ) ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE642( self, main ): | |
| """ | |
| Drop one link from each double link | |
| Drop a link between DAAS-1 and HAAG-1 | |
| Drop a link between HAGG-2 and SPINE-2 | |
| Drop one ONOS instance | |
| Test connectivity (expect no failure) | |
| Bring up all links and ONOS instance | |
| Test connectivity (expect no failure) | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Drop ONOS instance and links at the same time" ) | |
| setupTest( main, test_idx=642, onosNodes=3 ) | |
| main.Cluster.active( 0 ).CLI.balanceMasters() | |
| time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) ) | |
| verify( main ) | |
| portsToDisable = [ [ "of:0000000000000001", 1 ], [ "of:0000000000000103", 1 ], | |
| [ "of:0000000000000006", 1 ], [ "of:0000000000000103", 2 ], | |
| [ "of:0000000000000101", 9 ], [ "of:0000000000000103", 3 ], | |
| [ "of:0000000000000002", 1 ], [ "of:0000000000000101", 1 ], | |
| [ "of:0000000000000003", 1 ], [ "of:0000000000000101", 3 ], | |
| [ "of:0000000000000004", 1 ], [ "of:0000000000000101", 5 ], | |
| [ "of:0000000000000005", 1 ], [ "of:0000000000000101", 7 ], | |
| [ "of:0000000000000002", 3 ], [ "of:0000000000000102", 1 ], | |
| [ "of:0000000000000003", 3 ], [ "of:0000000000000102", 3 ], | |
| [ "of:0000000000000004", 3 ], [ "of:0000000000000102", 5 ], | |
| [ "of:0000000000000005", 3 ], [ "of:0000000000000102", 7 ] ] | |
| for dpid, port in portsToDisable: | |
| main.Cluster.active( 0 ).CLI.portstate( dpid=dpid, port=port, state="disable" ) | |
| lib.killOnos( main, [ 2, ], int( main.params[ "TOPO" ][ "switchNum" ] ), | |
| int( main.params[ "TOPO" ][ "linkNum" ] ) - len( portsToDisable ), 2 ) | |
| verify( main ) | |
| for dpid, port in portsToDisable: | |
| main.Cluster.active( 0 ).CLI.portstate( dpid=dpid, port=port, state="enable" ) | |
| lib.recoverOnos( main, [ 2, ], int( main.params[ "TOPO" ][ "switchNum" ] ), | |
| int( main.params[ "TOPO" ][ "linkNum" ] ), 3 ) | |
| verify( main ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) | |
| def CASE643( self, main ): | |
| """ | |
| Drop one link from each double link | |
| Drop a link between DAAS-1 and HAAG-1 | |
| Drop a link between HAGG-2 and SPINE-2 | |
| Test connectivity (expect no failure) | |
| Bring up all links | |
| Drop one ONOS instance | |
| Test connectivity (expect no failure) | |
| Bring up ONOS instance | |
| Test connectivity (expect no failure) | |
| """ | |
| import time | |
| from tests.USECASE.SegmentRouting.SRRouting.dependencies.SRRoutingTest import * | |
| from tests.USECASE.SegmentRouting.dependencies.Testcaselib import Testcaselib as lib | |
| main.case( "Drop ONOS instances and bring up links at the same time" ) | |
| setupTest( main, test_idx=643, onosNodes=3 ) | |
| main.Cluster.active( 0 ).CLI.balanceMasters() | |
| time.sleep( float( main.params[ 'timers' ][ 'balanceMasterSleep' ] ) ) | |
| verify( main ) | |
| portsToDisable = [ [ "of:0000000000000001", 1 ], [ "of:0000000000000103", 1 ], | |
| [ "of:0000000000000006", 1 ], [ "of:0000000000000103", 2 ], | |
| [ "of:0000000000000101", 9 ], [ "of:0000000000000103", 3 ], | |
| [ "of:0000000000000002", 1 ], [ "of:0000000000000101", 1 ], | |
| [ "of:0000000000000003", 1 ], [ "of:0000000000000101", 3 ], | |
| [ "of:0000000000000004", 1 ], [ "of:0000000000000101", 5 ], | |
| [ "of:0000000000000005", 1 ], [ "of:0000000000000101", 7 ], | |
| [ "of:0000000000000002", 3 ], [ "of:0000000000000102", 1 ], | |
| [ "of:0000000000000003", 3 ], [ "of:0000000000000102", 3 ], | |
| [ "of:0000000000000004", 3 ], [ "of:0000000000000102", 5 ], | |
| [ "of:0000000000000005", 3 ], [ "of:0000000000000102", 7 ] ] | |
| for dpid, port in portsToDisable[ : -1 ]: | |
| main.Cluster.active( 0 ).CLI.portstate( dpid=dpid, port=port, state="disable" ) | |
| # To trigger sleep for link down discovery and topology check | |
| lib.portstate( main, portsToDisable[ -1 ][ 0 ], portsToDisable[ -1 ][ 1 ], "disable", | |
| int( main.params[ "TOPO" ][ "switchNum" ] ), | |
| int( main.params[ "TOPO" ][ "linkNum" ] ) - len( portsToDisable ) ) | |
| verify( main ) | |
| for dpid, port in portsToDisable[ : -1 ]: | |
| main.Cluster.active( 0 ).CLI.portstate( dpid=dpid, port=port, state="enable" ) | |
| # To trigger sleep for link up discovery and topology check | |
| lib.portstate( main, portsToDisable[ -1 ][ 0 ], portsToDisable[ -1 ][ 1 ], "enable", | |
| int( main.params[ "TOPO" ][ "switchNum" ] ), | |
| int( main.params[ "TOPO" ][ "linkNum" ] ) ) | |
| lib.killOnos( main, [ 2, ], int( main.params[ "TOPO" ][ "switchNum" ] ), | |
| int( main.params[ "TOPO" ][ "linkNum" ] ), 2 ) | |
| verify( main ) | |
| lib.recoverOnos( main, [ 2, ], int( main.params[ "TOPO" ][ "switchNum" ] ), | |
| int( main.params[ "TOPO" ][ "linkNum" ] ), 3 ) | |
| verify( main ) | |
| lib.cleanup( main, copyKarafLog=False, removeHostComponent=True ) |