def setup_module(module): tgen = Topogen(BGPECMPTopo1, module.__name__) tgen.start_topology() # Starting Routers router_list = tgen.routers() for rname, router in router_list.iteritems(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)) ) router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, '{}/bgpd.conf'.format(rname)) ) router.start() # Starting Hosts and init ExaBGP on each of them topotest.sleep(10, 'starting BGP on all {} peers'.format(total_ebgp_peers)) peer_list = tgen.exabgp_peers() for pname, peer in peer_list.iteritems(): peer_dir = os.path.join(CWD, pname) env_file = os.path.join(CWD, 'exabgp.env') peer.start(peer_dir, env_file) logger.info(pname)
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(BFDTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in router_list.iteritems(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)), ) router.load_config( TopoRouter.RD_BFD, os.path.join(CWD, '{}/bfdd.conf'.format(rname)) ) router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, '{}/bgpd.conf'.format(rname)) ) # Initialize all routers. tgen.start_router() # Verify that we are using the proper version and that the BFD # daemon exists. for router in router_list.values(): # Check for Version if router.has_version('<', '5.1'): tgen.set_error('Unsupported FRR version') break
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(TemplateTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() # For all registered routers, load the zebra configuration file for rname, router in router_list.iteritems(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)) ) # Don't start ospfd and ldpd in the CE nodes if router.name[0] == 'r': router.load_config( TopoRouter.RD_OSPF, os.path.join(CWD, '{}/ospfd.conf'.format(rname)) ) router.load_config( TopoRouter.RD_LDP, os.path.join(CWD, '{}/ldpd.conf'.format(rname)) ) tgen.start_router() for router in router_list.values(): if router.has_version('<', '3'): tgen.set_error('unsupported version')
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(ISISTopo1, mod.__name__) tgen.start_topology() # For all registered routers, load the zebra configuration file for rname, router in tgen.routers().iteritems(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)) ) router.load_config( TopoRouter.RD_ISIS, os.path.join(CWD, '{}/isisd.conf'.format(rname)) ) # After loading the configurations, this function loads configured daemons. tgen.start_router() has_version_20 = False for router in tgen.routers().values(): if router.has_version('<', '3'): has_version_20 = True if has_version_20: logger.info('Skipping ISIS tests for FRR 2.0') tgen.set_error('ISIS has convergence problems with IPv6')
def setup_module(mod): "Sets up the pytest environment" logger.info('\n\n---- Starting OSPF Segment Routing tests ----\n') tgen = Topogen(OspfSrTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in router_list.iteritems(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)) ) router.load_config( TopoRouter.RD_OSPF, os.path.join(CWD, '{}/ospfd.conf'.format(rname)) ) # Initialize all routers. tgen.start_router() # Verify that version, MPLS and Segment Routing are OK for router in router_list.values(): # Check for Version if router.has_version('<', '4'): tgen.set_error('Unsupported FRR version') break # Check that Segment Routing is available output = tgen.gears[router.name].vtysh_cmd( "show ip ospf database segment-routing json") if output.find("Unknown") != -1: tgen.set_error('Segment Routing is not available')
def setup_module(module): tgen = Topogen(BGPVRFNETNSTopo1, module.__name__) tgen.start_topology() # Get r1 reference router = tgen.gears['r1'] # check for zebra capability if CustomizeVrfWithNetns == True: if router.check_capability( TopoRouter.RD_ZEBRA, '--vrfwnetns' ) == False: return pytest.skip('Skipping BGP VRF NETNS Test. VRF NETNS backend not available on FRR') if os.system('ip netns list') != 0: return pytest.skip('Skipping BGP VRF NETNS Test. NETNS not available on System') # retrieve VRF backend kind if CustomizeVrfWithNetns == True: logger.info('Testing with VRF Namespace support') # create VRF r1-cust1 # move r1-eth0 to VRF r1-cust1 cmds = ['if [ -e /var/run/netns/{0}-cust1 ] ; then ip netns del {0}-cust1 ; fi', 'ip netns add {0}-cust1', 'ip link set dev {0}-eth0 netns {0}-cust1', 'ip netns exec {0}-cust1 ifconfig {0}-eth0 up'] for cmd in cmds: cmd = cmd.format('r1') logger.info('cmd: '+cmd); output = router.run(cmd.format('r1')) if output != None and len(output) > 0: logger.info('Aborting due to unexpected output: cmd="{}" output=\n{}'.format(cmd, output)) return pytest.skip('Skipping BGP VRF NETNS Test. Unexpected output to command: '+cmd) #run daemons router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format('r1')), '--vrfwnetns' ) router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, '{}/bgpd.conf'.format('r1')) ) logger.info('Launching BGP and ZEBRA') # BGP and ZEBRA start without underlying VRF router.start() # Starting Hosts and init ExaBGP on each of them logger.info('starting exaBGP on peer1') peer_list = tgen.exabgp_peers() for pname, peer in peer_list.iteritems(): peer_dir = os.path.join(CWD, pname) env_file = os.path.join(CWD, 'exabgp.env') logger.info('Running ExaBGP peer') peer.start(peer_dir, env_file) logger.info(pname)
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(PIMTopo, mod.__name__) tgen.start_topology() # For all registered routers, load the zebra configuration file for rname, router in tgen.routers().iteritems(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname))) router.load_config(TopoRouter.RD_PIM, os.path.join(CWD, '{}/pimd.conf'.format(rname))) # After loading the configurations, this function loads configured daemons. tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" # Required linux kernel version for this suite to run. result = required_linux_kernel_version("5.0") if result is not True: pytest.skip("Kernel requirements are not met") tgen = Topogen(NetworkTopo, mod.__name__) tgen.start_topology() logger.info("** %s: Setup Topology" % mod.__name__) logger.info("******************************************") # For debugging after starting net, but before starting FRR, # uncomment the next line # tgen.mininet_cli() logger.info("Testing with VRF Lite support") cmds = [ "ip link add {0}-cust1 type vrf table 1001", "ip link add loop1 type dummy", "ip link set {0}-stubnet master {0}-cust1", ] cmds1 = ["ip link set {0}-sw5 master {0}-cust1"] cmds2 = ["ip link set {0}-sw6 master {0}-cust1"] # For all registered routers, load the zebra configuration file for rname, router in tgen.routers().items(): # create VRF rx-cust1 and link rx-eth0 to rx-cust1 for cmd in cmds: output = tgen.net[rname].cmd(cmd.format(rname)) if rname == "r1" or rname == "r2" or rname == "r3": for cmd in cmds1: output = tgen.net[rname].cmd(cmd.format(rname)) if rname == "r3" or rname == "r4": for cmd in cmds2: output = tgen.net[rname].cmd(cmd.format(rname)) for rname, router in tgen.routers().items(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_OSPF6, os.path.join(CWD, "{}/ospf6d.conf".format(rname))) # Initialize all routers. tgen.start_router()
def setup_module(mod): topodef = {"s1": ("r1", "r2")} tgen = Topogen(topodef, mod.__name__) tgen.start_topology() router_list = tgen.routers() for i, (rname, router) in enumerate(router_list.items(), 1): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))) tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(OSPFTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() # check for zebra capability for rname, router in router_list.items(): if router.check_capability(TopoRouter.RD_ZEBRA, "--vrfwnetns") == False: return pytest.skip( "Skipping OSPF VRF NETNS feature. VRF NETNS backend not available on FRR" ) if os.system("ip netns list") != 0: return pytest.skip( "Skipping OSPF VRF NETNS Test. NETNS not available on System" ) logger.info("Testing with VRF Namespace support") cmds = [ "if [ -e /var/run/netns/{0}-cust1 ] ; then ip netns del {0}-cust1 ; fi", "ip netns add {0}-cust1", "ip link set dev {0}-eth0 netns {0}-cust1", "ip netns exec {0}-cust1 ifconfig {0}-eth0 up", "ip link set dev {0}-eth1 netns {0}-cust1", "ip netns exec {0}-cust1 ifconfig {0}-eth1 up", ] for rname, router in router_list.items(): # create VRF rx-cust1 and link rx-eth0 to rx-cust1 for cmd in cmds: output = tgen.net[rname].cmd(cmd.format(rname)) router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname)), "--vrfwnetns", ) router.load_config( TopoRouter.RD_OSPF, os.path.join(CWD, "{}/ospfd.conf".format(rname)) ) # Initialize all routers. tgen.start_router() for router in router_list.values(): if router.has_version("<", "4.0"): tgen.set_error("unsupported version")
def setup_module(mod): tgen = Topogen(build_topo, mod.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in router_list.items(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname)), ) router.load_config(TopoRouter.RD_STATIC, os.path.join(CWD, "{}/staticd.conf".format(rname))) tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(BgpLinkBwTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in router_list.items(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))) # Initialize all routers. tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" # This function initiates the topology build with Topogen... tgen = Topogen(build_topo, mod.__name__) # ... and here it calls Mininet initialization functions. tgen.start_topology() pe1 = tgen.gears["PE1"] pe2 = tgen.gears["PE2"] p1 = tgen.gears["P1"] # set up PE bridges with the EVPN member interfaces facing the CE hosts pe1.run("ip link add name br101 type bridge stp_state 0") pe1.run("ip addr add 10.10.1.1/24 dev br101") pe1.run("ip link set dev br101 up") pe1.run( "ip link add vxlan101 type vxlan id 101 dstport 4789 local 10.10.10.10 nolearning" ) pe1.run("ip link set dev vxlan101 master br101") pe1.run("ip link set up dev vxlan101") pe1.run("ip link set dev PE1-eth0 master br101") pe2.run("ip link add name br101 type bridge stp_state 0") pe2.run("ip addr add 10.10.1.3/24 dev br101") pe2.run("ip link set dev br101 up") pe2.run( "ip link add vxlan101 type vxlan id 101 dstport 4789 local 10.30.30.30 nolearning" ) pe2.run("ip link set dev vxlan101 master br101") pe2.run("ip link set up dev vxlan101") pe2.run("ip link set dev PE2-eth1 master br101") p1.run("sysctl -w net.ipv4.ip_forward=1") # This is a sample of configuration loading. router_list = tgen.routers() # For all registred routers, load the zebra configuration file for rname, router in router_list.items(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname)) ) router.load_config( TopoRouter.RD_OSPF, os.path.join(CWD, "{}/ospfd.conf".format(rname)) ) router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname)) ) # After loading the configurations, this function loads configured daemons. tgen.start_router()
def setup_module(module): "Setup topology" tgen = Topogen(NetworkTopo, module.__name__) tgen.start_topology() # This is a sample of configuration loading. router_list = tgen.routers() for rname, router in router_list.items(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))) tgen.start_router()
def setup_module(self, mod): "Sets up the pytest environment" # This function initiates the topology build with Topogen... tgen = Topogen(customize.ThisTestTopo, mod.__name__) # ... and here it calls Mininet initialization functions. tgen.start_topology() logger.info("Topology started") try: self.prestarthooksuccess = customize.ltemplatePreRouterStartHook() except AttributeError: # not defined logger.debug("ltemplatePreRouterStartHook() not defined") if self.prestarthooksuccess != True: logger.info("ltemplatePreRouterStartHook() failed, skipping test") return # This is a sample of configuration loading. router_list = tgen.routers() # For all registred routers, load the zebra configuration file for rname, router in router_list.items(): logger.info("Setting up %s" % rname) for rd_val in TopoRouter.RD: config = os.path.join( self.testdir, "{}/{}.conf".format(rname, TopoRouter.RD[rd_val])) prog = os.path.join(tgen.net[rname].daemondir, TopoRouter.RD[rd_val]) if os.path.exists(config): if os.path.exists(prog): router.load_config(rd_val, config) else: logger.warning( "{} not found, but have {}.conf file".format( prog, TopoRouter.RD[rd_val])) # After loading the configurations, this function loads configured daemons. logger.info("Starting routers") tgen.start_router() try: self.poststarthooksuccess = customize.ltemplatePostRouterStartHook( ) except AttributeError: # not defined logger.debug("ltemplatePostRouterStartHook() not defined") luStart(baseScriptDir=self.scriptdir, baseLogDir=self.logdir, net=tgen.net)
def setup_module(module): tgen = Topogen(build_topo, module.__name__) tgen.start_topology() # Get r1 reference router = tgen.gears["r1"] # check for zebra capability if CustomizeVrfWithNetns == True: if router.check_capability(TopoRouter.RD_ZEBRA, "--vrfwnetns") == False: return pytest.skip( "Skipping BGP VRF NETNS Test. VRF NETNS backend not available on FRR" ) if os.system("ip netns list") != 0: return pytest.skip( "Skipping BGP VRF NETNS Test. NETNS not available on System") # retrieve VRF backend kind if CustomizeVrfWithNetns == True: logger.info("Testing with VRF Namespace support") # create VRF r1-bgp-cust1 # move r1-eth0 to VRF r1-bgp-cust1 ns = "{}-bgp-cust1".format("r1") router.net.add_netns(ns) router.net.set_intf_netns("r1-eth0", ns, up=True) # run daemons router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format("r1")), "--vrfwnetns", ) router.load_config(TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format("r1"))) logger.info("Launching BGP and ZEBRA") # BGP and ZEBRA start without underlying VRF router.start() # Starting Hosts and init ExaBGP on each of them logger.info("starting exaBGP on peer1") peer_list = tgen.exabgp_peers() for pname, peer in peer_list.items(): peer_dir = os.path.join(CWD, pname) env_file = os.path.join(CWD, "exabgp.env") logger.info("Running ExaBGP peer") peer.start(peer_dir, env_file) logger.info(pname)
def setup_module(mod): tgen = Topogen({None: "r1"}, mod.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in tgen.routers().items(): router.run( "/bin/bash {}".format(os.path.join(CWD, "{}/setup.sh".format(rname))) ) router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname)) ) router.load_config( TopoRouter.RD_SHARP, os.path.join(CWD, "{}/sharpd.conf".format(rname)) ) tgen.start_router()
def setup_module(module): "Setup topology" tgen = Topogen(NetworkTopo, module.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in router_list.items(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname)) ) router.load_config( TopoRouter.RD_SHARP, os.path.join(CWD, "{}/sharpd.conf".format(rname)) ) tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" topodef = {"s1": ("r1", "r1", "r1", "r1", "r1", "r1", "r1", "r1")} tgen = Topogen(topodef, mod.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in router_list.items(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_SHARP, os.path.join(CWD, "{}/sharpd.conf".format(rname))) # Initialize all routers. tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(build_topo, mod.__name__) tgen.start_topology() # For all registered routers, load the zebra configuration file for rname, router in tgen.routers().items(): router.run("/bin/bash {}/setup_vrfs".format(CWD)) router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))) # After loading the configurations, this function loads configured daemons. tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(TemplateTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() # For all registered routers, load the zebra configuration file for rname, router in router_list.items(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_OSPF, os.path.join(CWD, "{}/ospfd.conf".format(rname))) tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(OSPFTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() # check for zebra capability for rname, router in router_list.iteritems(): if router.check_capability( TopoRouter.RD_ZEBRA, '--vrfwnetns' ) == False: return pytest.skip('Skipping OSPF VRF NETNS feature. VRF NETNS backend not available on FRR') if os.system('ip netns list') != 0: return pytest.skip('Skipping OSPF VRF NETNS Test. NETNS not available on System') logger.info('Testing with VRF Namespace support') cmds = ['if [ -e /var/run/netns/{0}-cust1 ] ; then ip netns del {0}-cust1 ; fi', 'ip netns add {0}-cust1', 'ip link set dev {0}-eth0 netns {0}-cust1', 'ip netns exec {0}-cust1 ifconfig {0}-eth0 up', 'ip link set dev {0}-eth1 netns {0}-cust1', 'ip netns exec {0}-cust1 ifconfig {0}-eth1 up'] for rname, router in router_list.iteritems(): # create VRF rx-cust1 and link rx-eth0 to rx-cust1 for cmd in cmds: output = tgen.net[rname].cmd(cmd.format(rname)) router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)), '--vrfwnetns' ) router.load_config( TopoRouter.RD_OSPF, os.path.join(CWD, '{}/ospfd.conf'.format(rname)) ) # Initialize all routers. tgen.start_router() for router in router_list.values(): if router.has_version('<', '4.0'): tgen.set_error('unsupported version')
def setup_module(self, mod): "Sets up the pytest environment" # This function initiates the topology build with Topogen... tgen = Topogen(customize.ThisTestTopo, mod.__name__) # ... and here it calls Mininet initialization functions. tgen.start_topology() logger.info('Topology started') try: self.prestarthooksuccess = customize.ltemplatePreRouterStartHook() except AttributeError: #not defined logger.debug("ltemplatePreRouterStartHook() not defined") # This is a sample of configuration loading. router_list = tgen.routers() # For all registred routers, load the zebra configuration file for rname, router in router_list.iteritems(): print("Setting up %s" % rname) config = os.path.join(self.testdir, '{}/zebra.conf'.format(rname)) if os.path.exists(config): router.load_config(TopoRouter.RD_ZEBRA, config) config = os.path.join(self.testdir, '{}/ospfd.conf'.format(rname)) if os.path.exists(config): router.load_config(TopoRouter.RD_OSPF, config) config = os.path.join(self.testdir, '{}/ldpd.conf'.format(rname)) if os.path.exists(config): router.load_config(TopoRouter.RD_LDP, config) config = os.path.join(self.testdir, '{}/bgpd.conf'.format(rname)) if os.path.exists(config): router.load_config(TopoRouter.RD_BGP, config) config = os.path.join(self.testdir, '{}/isisd.conf'.format(rname)) if os.path.exists(config): router.load_config(TopoRouter.RD_ISIS, config) # After loading the configurations, this function loads configured daemons. logger.info('Starting routers') tgen.start_router() try: self.poststarthooksuccess = customize.ltemplatePostRouterStartHook( ) except AttributeError: #not defined logger.debug("ltemplatePostRouterStartHook() not defined") luStart(baseScriptDir=self.scriptdir, baseLogDir=self.logdir, net=tgen.net)
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(ISISTopo1, mod.__name__) tgen.start_topology() logger.info("Testing with VRF Lite support") krel = platform.release() # May need to adjust handling of vrf traffic depending on kernel version l3mdev_accept = 0 if (topotest.version_cmp(krel, "4.15") >= 0 and topotest.version_cmp(krel, "4.18") <= 0): l3mdev_accept = 1 if topotest.version_cmp(krel, "5.0") >= 0: l3mdev_accept = 1 logger.info("krel '{0}' setting net.ipv4.tcp_l3mdev_accept={1}".format( krel, l3mdev_accept)) cmds = [ "ip link add {0}-cust1 type vrf table 1001", "ip link add loop1 type dummy", "ip link set {0}-eth0 master {0}-cust1", "ip link set {0}-eth1 master {0}-cust1", ] # For all registered routers, load the zebra configuration file for rname, router in tgen.routers().items(): # create VRF rx-cust1 and link rx-eth0 to rx-cust1 for cmd in cmds: output = tgen.net[rname].cmd(cmd.format(rname)) output = tgen.net[rname].cmd("sysctl -n net.ipv4.tcp_l3mdev_accept") logger.info("router {0}: existing tcp_l3mdev_accept was {1}".format( rname, output)) if l3mdev_accept: output = tgen.net[rname].cmd( "sysctl -w net.ipv4.tcp_l3mdev_accept={}".format( l3mdev_accept)) for rname, router in tgen.routers().items(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_ISIS, os.path.join(CWD, "{}/isisd.conf".format(rname))) # After loading the configurations, this function loads configured daemons. tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(OSPFTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in router_list.iteritems(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname))) router.load_config(TopoRouter.RD_OSPF, os.path.join(CWD, '{}/ospfd.conf'.format(rname))) router.load_config(TopoRouter.RD_OSPF6, os.path.join(CWD, '{}/ospf6d.conf'.format(rname))) # Initialize all routers. tgen.start_router()
def setup_module(module): print("\n\n** %s: Setup Topology" % module.__name__) print("******************************************\n") thisDir = os.path.dirname(os.path.realpath(__file__)) tgen = Topogen(build_topo, module.__name__) tgen.start_topology() net = tgen.net # Starting Routers # for i in range(1, 4): net["r%s" % i].loadConf("zebra", "%s/r%s/zebra.conf" % (thisDir, i)) net["r%s" % i].loadConf("ripngd", "%s/r%s/ripngd.conf" % (thisDir, i)) tgen.gears["r%s" % i].start()
def tgen(request): "Sets up the pytest environment" topodef = {"s1": ("r1")} tgen = Topogen(topodef, request.module.__name__) tgen.start_topology() # Initialize all routers. router_list = tgen.routers() for rname, router in router_list.items(): router.load_config(TopoRouter.RD_ZEBRA, "zebra.conf") router.load_config(TopoRouter.RD_SHARP) tgen.start_router() yield tgen tgen.stop_topology()
def setup_module(mod): tgen = Topogen(BgpAggregateAddressTopo1, mod.__name__) tgen.start_topology() router = tgen.gears["r1"] router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "r1/zebra.conf")) router.load_config(TopoRouter.RD_BGP, os.path.join(CWD, "r1/bgpd.conf")) router.start() router = tgen.gears["r2"] router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "r2/zebra.conf")) router.load_config(TopoRouter.RD_BGP, os.path.join(CWD, "r2/bgpd.conf")) router.start() peer = tgen.gears["peer1"] peer.start(os.path.join(CWD, "peer1"), os.path.join(CWD, "exabgp.env"))
def setup_module(mod): tgen = Topogen(TemplateTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() for i, (rname, router) in enumerate(router_list.iteritems(), 1): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)) ) router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, '{}/bgpd.conf'.format(rname)) ) tgen.start_router()
def setup_module(mod): tgen = Topogen(TemplateTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() for i, (rname, router) in enumerate(router_list.iteritems(), 1): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)) ) router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, '{}/bgpd.conf'.format(rname)) ) tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" # skip tests is SNMP not installed if not os.path.isfile("/usr/sbin/snmpd"): error_msg = "SNMP not installed - skipping" pytest.skip(error_msg) # This function initiates the topology build with Topogen... topodef = {"s1": "r1", "s2": "r1", "s3": "r1"} tgen = Topogen(topodef, mod.__name__) # ... and here it calls Mininet initialization functions. tgen.start_topology() r1 = tgen.gears["r1"] r1.run("ip addr add 192.168.12.12/24 dev r1-eth0") r1.run("ip -6 addr add 2000:1:1:12::12/64 dev r1-eth0") r1.run("ip addr add 192.168.13.13/24 dev r1-eth1") r1.run("ip -6 addr add 2000:1:1:13::13/64 dev r1-eth1") r1.run("ip addr add 192.168.14.14/24 dev r1-eth2") r1.run("ip -6 addr add 2000:1:1:14::14/64 dev r1-eth2") r1.run("ip addr add 1.1.1.1/32 dev lo") r1.run("ip -6 addr add 2000:1:1:1::1/128 dev lo") r1.run("ip addr show") router_list = tgen.routers() # For all registred routers, load the zebra configuration file for rname, router in router_list.items(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_ISIS, os.path.join(CWD, "{}/isisd.conf".format(rname))) router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname)), "-M snmp", ) router.load_config( TopoRouter.RD_SNMP, os.path.join(CWD, "{}/snmpd.conf".format(rname)), "-Le -Ivacm_conf,usmConf,iquery -V -DAgentX,trap", ) # After loading the configurations, this function loads configured daemons. tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(build_topo, mod.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in router_list.items(): daemon_file = "{}/{}/zebra.conf".format(CWD, rname) if os.path.isfile(daemon_file): router.load_config(TopoRouter.RD_ZEBRA, daemon_file) daemon_file = "{}/{}/ospf6d.conf".format(CWD, rname) if os.path.isfile(daemon_file): router.load_config(TopoRouter.RD_OSPF6, daemon_file) # Initialize all routers. tgen.start_router()
def setup_module(mod): return pytest.skip("OSPF GR helper mode is currently broken") "Sets up the pytest environment" tgen = Topogen(build_topo, mod.__name__) tgen.start_topology() router_list = tgen.routers() # For all registered routers, load the zebra configuration file for rname, router in router_list.items(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_OSPF, os.path.join(CWD, "{}/ospfd.conf".format(rname))) tgen.start_router()
def setup_module(module): tgen = Topogen(TemplateTopo, module.__name__) tgen.start_topology() router = tgen.gears['r1'] router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format('r1'))) router.load_config(TopoRouter.RD_BGP, os.path.join(CWD, '{}/bgpd.conf'.format('r1'))) router.start() logger.info('starting exaBGP on peer1') peer_list = tgen.exabgp_peers() for pname, peer in peer_list.iteritems(): peer_dir = os.path.join(CWD, pname) env_file = os.path.join(CWD, 'exabgp.env') logger.info('Running ExaBGP peer') peer.start(peer_dir, env_file) logger.info(pname)
def setup_module(module): thisDir = os.path.dirname(os.path.realpath(__file__)) tgen = Topogen(build_topo, module.__name__) tgen.start_topology() # Starting Routers router = tgen.net["r1"] router.loadConf("zebra", "%s/r1/zebra.conf" % thisDir) router.loadConf("bgpd", "%s/r1/bgpd.conf" % thisDir) tgen.gears["r1"].start() # Starting PE Hosts and init ExaBGP on each of them peer_list = tgen.exabgp_peers() for pname, peer in peer_list.items(): peer_dir = os.path.join(thisDir, pname) env_file = os.path.join(thisDir, "exabgp.env") peer.start(peer_dir, env_file)
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(OSPFTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() # check for zebra capability for rname, router in router_list.iteritems(): if router.check_capability( TopoRouter.RD_ZEBRA, '--vrfwnetns' ) == False: return pytest.skip('Skipping OSPF VRF NETNS feature. VRF NETNS backend not available on FRR') if os.system('ip netns list') != 0: return pytest.skip('Skipping OSPF VRF NETNS Test. NETNS not available on System') logger.info('Testing with VRF Namespace support') cmds = ['if [ -e /var/run/netns/{0}-cust1 ] ; then ip netns del {0}-cust1 ; fi', 'ip netns add {0}-cust1', 'ip link set dev {0}-eth0 netns {0}-cust1', 'ip netns exec {0}-cust1 ifconfig {0}-eth0 up', 'ip link set dev {0}-eth1 netns {0}-cust1', 'ip netns exec {0}-cust1 ifconfig {0}-eth1 up'] for rname, router in router_list.iteritems(): # create VRF rx-cust1 and link rx-eth0 to rx-cust1 for cmd in cmds: output = tgen.net[rname].cmd(cmd.format(rname)) router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)), '--vrfwnetns' ) router.load_config( TopoRouter.RD_OSPF, os.path.join(CWD, '{}/ospfd.conf'.format(rname)) ) # Initialize all routers. tgen.start_router()
def setup_module(mod): """ Sets up the pytest environment * `mod`: module name """ testsuite_run_time = time.asctime(time.localtime(time.time())) logger.info("Testsuite start time: {}".format(testsuite_run_time)) logger.info("="*40) logger.info("Running setup_module to create topology") # This function initiates the topology build with Topogen... tgen = Topogen(BGPBasicTopo, mod.__name__) # ... and here it calls Mininet initialization functions. tgen.start_topology() # Uncomment following line to enable debug logs and comment - tgen.start_topology() #tgen.start_topology(log_level='debug') router_list = tgen.routers() for rname, router in router_list.iteritems(): try: os.chdir(CWD) # Deleting router named dirs if exists if os.path.exists('{}'.format(rname)): os.system("rm -rf {}".format(rname)) # Creating rouer named dir and emoty zebra.conf bgpd.conf files inside the current directory os.mkdir('{}'.format(rname)) os.chdir("{}/{}".format(CWD, rname)) os.system('touch zebra.conf bgpd.conf') except IOError as (errno, strerror): logger.error("I/O error({0}): {1}".format(errno, strerror)) router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)) ) router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, '{}/bgpd.conf'.format(rname)) )
def setup_module(mod): "Sets up the pytest environment" logger.info("\n\n---- Starting OSPF Segment Routing tests ----\n") tgen = Topogen(OspfSrTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() for rname, router in router_list.items(): router.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))) router.load_config(TopoRouter.RD_OSPF, os.path.join(CWD, "{}/ospfd.conf".format(rname))) # Initialize all routers. tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(PIMTopo, mod.__name__) tgen.start_topology() # For all registered routers, load the zebra configuration file for rname, router in tgen.routers().iteritems(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)) ) router.load_config( TopoRouter.RD_PIM, os.path.join(CWD, '{}/pimd.conf'.format(rname)) ) # After loading the configurations, this function loads configured daemons. tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" # This function initiates the topology build with Topogen... tgen = Topogen(TemplateTopo, mod.__name__) # ... and here it calls Mininet initialization functions. tgen.start_topology() # This is a sample of configuration loading. router_list = tgen.routers() # For all registred routers, load the zebra configuration file for rname, router in router_list.iteritems(): router.load_config( TopoRouter.RD_ZEBRA, # Uncomment next line to load configuration from ./router/zebra.conf #os.path.join(CWD, '{}/zebra.conf'.format(rname)) ) # After loading the configurations, this function loads configured daemons. tgen.start_router()
def setup_module(mod): "Sets up the pytest environment" tgen = Topogen(BFDTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() # check for zebra capability for rname, router in router_list.iteritems(): if router.check_capability( TopoRouter.RD_ZEBRA, '--vrfwnetns' ) == False: return pytest.skip('Skipping BFD Topo1 VRF NETNS feature. VRF NETNS backend not available on FRR') if os.system('ip netns list') != 0: return pytest.skip('Skipping BFD Topo1 VRF NETNS Test. NETNS not available on System') logger.info('Testing with VRF Namespace support') cmds = ['if [ -e /var/run/netns/{0}-cust1 ] ; then ip netns del {0}-cust1 ; fi', 'ip netns add {0}-cust1', 'ip link set dev {0}-eth0 netns {0}-cust1', 'ip netns exec {0}-cust1 ifconfig {0}-eth0 up'] cmds2 = ['ip link set dev {0}-eth1 netns {0}-cust1', 'ip netns exec {0}-cust1 ifconfig {0}-eth1 up', 'ip link set dev {0}-eth2 netns {0}-cust1', 'ip netns exec {0}-cust1 ifconfig {0}-eth2 up'] for rname, router in router_list.iteritems(): # create VRF rx-cust1 and link rx-eth0 to rx-cust1 for cmd in cmds: output = tgen.net[rname].cmd(cmd.format(rname)) if rname == 'r2': for cmd in cmds2: output = tgen.net[rname].cmd(cmd.format(rname)) for rname, router in router_list.iteritems(): router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)), '--vrfwnetns' ) router.load_config( TopoRouter.RD_BFD, os.path.join(CWD, '{}/bfdd.conf'.format(rname)) ) router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, '{}/bgpd.conf'.format(rname)) ) # Initialize all routers. tgen.start_router() # Verify that we are using the proper version and that the BFD # daemon exists. for router in router_list.values(): # Check for Version if router.has_version('<', '5.1'): tgen.set_error('Unsupported FRR version') break
def setup_module(mod): "pytest environment setup" tgen = Topogen(NetworkTopo, mod.__name__) tgen.start_topology() router_list = tgen.routers() # Load router configuration ldp_id = 1 bgp_id = 101 lm_sock = '../lm/label_mgr.sock' for rname, router in router_list.iteritems(): if rname == 'lm' : router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)), '-z ' + lm_sock ) continue rtype = ''.join([i for i in rname if not i.isdigit()]) router.load_config( TopoRouter.RD_ZEBRA, os.path.join(CWD, '{}/zebra.conf'.format(rname)), '-l ' + lm_sock ) if router.check_capability(TopoRouter.RD_ZEBRA, '--vrfwnetns') == False: return pytest.skip('Skipping test: no VRF support') if rtype == 'ce' or rtype == 'pe': if router.check_capability(TopoRouter.RD_BGP, '--int_num') == False: return pytest.skip('Skipping test: no BGP LM support') router.load_config( TopoRouter.RD_BGP, os.path.join(CWD, '{}/bgpd.conf'.format(rname)), '-I %d' % bgp_id ) bgp_id += 1 if rtype == 'pe' or rtype == 'p': router.load_config( TopoRouter.RD_OSPF, os.path.join(CWD, '{}/ospfd.conf'.format(rname)) ) router.load_config( TopoRouter.RD_LDP, os.path.join(CWD, '{}/ldpd.conf'.format(rname)), '-n %d' % ldp_id ) ldp_id += 1 # Prepare VRF's router = tgen.gears['pe1'] out = router.run('ip -h 2>&1 | grep vrf | wc -l') if int(out) == 0: return pytest.skip('Skipping test: ip/iproute2 has no VRF support') vrf_setup(tgen.gears['pe1'], 'pe1-eth0', vrf_name, '1') vrf_setup(tgen.gears['pe2'], 'pe2-eth0', vrf_name, '1') # Start routers tgen.start_router(tgen.gears['lm']) for rname, router in router_list.iteritems(): if rname != 'lm': tgen.start_router(router)