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)
