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(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(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(BGPIPV6RTADVTopo, 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_BGP,
os.path.join(CWD, "{}/bgpd.conf".format(rname)))
# Initialize all routers.
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):
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({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(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)))
router.load_config(TopoRouter.RD_ISIS,
os.path.join(CWD, "{}/isisd.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(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()
# 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 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):
"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):
"Setup topology"
tgen = Topogen(build_topo, 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(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().items():
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)))
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"
# This function initiates the topology build with Topogen...
tgen = Topogen(TemplateTopo, 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(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(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(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"
tgen = Topogen(build_topo, mod.__name__)
tgen.start_topology()
# This is a sample of configuration loading.
router_list = tgen.routers()
# For all registred routers, load the zebra and ospf 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"
# 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):
"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(module):
"Setup topology"
tgen = Topogen(NetworkTopo, module.__name__)
tgen.start_topology()
router_list = tgen.routers()
for rname, router in router_list.iteritems():
# Install vrf into the kernel and slave eth3
router.run("ip link add vrf-chiyoda type vrf table 1000")
router.run("ip link set dev {}-eth3 master vrf-chiyoda".format(rname))
router.run("ip link set vrf-chiyoda up")
router.load_config(TopoRouter.RD_ZEBRA,
os.path.join(CWD, "{}/zebra.conf".format(rname)))
router.load_config(TopoRouter.RD_PBRD,
os.path.join(CWD, "{}/pbrd.conf".format(rname)))
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"
tgen = Topogen(build_topo, 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 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")
for rname, router in router_list.items():
# create VRF rx-bfd-cust1 and link rx-eth0 to rx-bfd-cust1
ns = "{}-bfd-cust1".format(rname)
router.net.add_netns(ns)
router.net.set_intf_netns(rname + "-eth0", ns, up=True)
if rname == "r2":
router.net.set_intf_netns(rname + "-eth1", ns, up=True)
router.net.set_intf_netns(rname + "-eth2", ns, up=True)
for rname, router in router_list.items():
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()
def _tgen(request):
"Setup/Teardown the environment and provide tgen argument to tests"
nrouters = request.param
topodef = {f"sw{i}": (f"r{i}", f"r{i+1}") for i in range(1, nrouters)}
tgen = Topogen(topodef, request.module.__name__)
tgen.start_topology()
router_list = tgen.routers()
for _, router in router_list.items():
router.load_config(TopoRouter.RD_ZEBRA, "zebra.conf")
router.load_config(TopoRouter.RD_OSPF, "ospfd.conf")
router.net.daemons_options["ospfd"] = "--apiserver"
tgen.start_router()
yield tgen
tgen.stop_topology()
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()
# This is a sample of configuration loading.
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_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.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()
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(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.iteritems():
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(mod):
"Sets up the pytest environment"
topodef = {
"s1": ("r1", "r2"),
"s2": ("r2", "r3"),
"s3": ("r3", "r4"),
"s4": ("r4", "r5"),
"s5": ("r1", "r6"),
}
tgen = Topogen(topodef, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
for rname, router in router_list.items():
daemon_file = "{}/{}/bfdd.conf".format(CWD, rname)
if os.path.isfile(daemon_file):
router.load_config(TopoRouter.RD_BFD, daemon_file)
daemon_file = "{}/{}/bgpd.conf".format(CWD, rname)
if os.path.isfile(daemon_file):
router.load_config(TopoRouter.RD_BGP, daemon_file)
daemon_file = "{}/{}/isisd.conf".format(CWD, rname)
if os.path.isfile(daemon_file):
router.load_config(TopoRouter.RD_ISIS, daemon_file)
daemon_file = "{}/{}/ospfd.conf".format(CWD, rname)
if os.path.isfile(daemon_file):
router.load_config(TopoRouter.RD_OSPF, daemon_file)
daemon_file = "{}/{}/ospf6d.conf".format(CWD, rname)
if os.path.isfile(daemon_file):
router.load_config(TopoRouter.RD_OSPF6, daemon_file)
daemon_file = "{}/{}/zebra.conf".format(CWD, rname)
if os.path.isfile(daemon_file):
router.load_config(TopoRouter.RD_ZEBRA, daemon_file)
# Initialize all routers.
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()
# 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")
for rname, router in router_list.items():
# create VRF rx-ospf-cust1 and link rx-eth{0,1} to rx-ospf-cust1
ns = "{}-ospf-cust1".format(rname)
router.net.add_netns(ns)
router.net.set_intf_netns(rname + "-eth0", ns, up=True)
router.net.set_intf_netns(rname + "-eth1", ns, up=True)
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(_m):
"Sets up the pytest environment"
# This function initiates the topology build with Topogen...
tgen = Topogen(TemplateTopo)
# ... and here it calls Mininet initialization functions.
# When deploying tests, please remove the debug logging level.
tgen.start_topology('debug')
# 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):
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")
tgen = Topogen(build_topo, 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()
logger.info("Running setup_module() done")
def setup_module(mod):
"Sets up the pytest environment"
tgen = Topogen(OSPFTopo, mod.__name__)
tgen.start_topology()
ospf6_config = "ospf6d.conf"
if tgen.gears["r1"].has_version("<", "4.0"):
ospf6_config = "ospf6d.conf-pre-v4"
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)))
router.load_config(
TopoRouter.RD_OSPF6,
os.path.join(CWD, "{}/{}".format(rname, ospf6_config)))
# Initialize all routers.
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)
