def setup_module(mod):
"Sets up the pytest environment"
tgen = Topogen(ZebraTopo, 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)))
# Initialize all routers.
tgen.start_router()
def setup_module(mod):
"Sets up the pytest environment"
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))
# adjust handling of vrf traffic
adjust_router_l3mdev(tgen, 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):
"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(build_topo, 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):
"Sets up the pytest environment"
tgen = Topogen(BGPIPV6RTADVVRFTopo, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
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 loop1 master {0}-cust1',
'ip link set {0}-eth0 master {0}-cust1']
for rname, router in router_list.iteritems():
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 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(mod):
"Sets up the test environment."
tgen = Topogen(TemplateTopo, mod.__name__)
# Adds extra parameters to bgpd so they listen for connections on specific
# multiple addresses.
for router_name in tgen.routers().keys():
tgen.net[router_name].daemons_options["bgpd"] = "-l " + " -l ".join(
LISTEN_ADDRESSES[router_name]
)
start_topology(tgen)
build_config_from_json(tgen, topo)
def setup_module(mod):
tgen = Topogen(TemplateTopo, 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(module):
"Setup topology"
tgen = Topogen(build_topo, module.__name__)
tgen.start_topology()
# This is a sample of configuration loading.
r1 = tgen.gears["r1"]
r1.load_config(TopoRouter.RD_ZEBRA, os.path.join(CWD, "r1/zebra.conf"))
r1.load_config(TopoRouter.RD_OSPF, os.path.join(CWD, "r1/ospfd-3.conf"),
"-n 3")
r1.load_config(TopoRouter.RD_SHARP, os.path.join(CWD, "r1/sharpd.conf"))
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():
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 rname, router in tgen.routers().items():
router.run("/bin/bash {}/{}/setup.sh".format(CWD, rname))
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.load_config(TopoRouter.RD_SHARP,
os.path.join(CWD, '{}/sharpd.conf'.format(rname)))
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))
)
tgen.start_router()
def setup_module(self, mod):
"Sets up the pytest environment"
# This function initiates the topology build with Topogen...
tgen = Topogen(customize.build_topo, mod.__name__)
# ... and here it calls Mininet initialization functions.
tgen.start_topology()
self.logdir = tgen.logdir
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 registered 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(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.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):
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
* `mod`: module name
"""
# Required linux kernel version for this suite to run.
result = required_linux_kernel_version("4.15")
if result is not True:
pytest.skip("Kernel requirements are not met")
testsuite_run_time = time.asctime(time.localtime(time.time()))
logger.info("Testsuite start time: {}".format(testsuite_run_time))
logger.info("=" * 40)
logger.info("Master Topology: \n {}".format(TOPOLOGY))
logger.info("Running setup_module to create topology")
# This function initiates the topology build with Topogen...
json_file = "{}/mcast_pim_bsmp_02.json".format(CWD)
tgen = Topogen(json_file, mod.__name__)
global topo
topo = tgen.json_topo
# ... and here it calls Mininet initialization functions.
# get list of daemons needs to be started for this suite.
daemons = topo_daemons(tgen, topo)
# Starting topology, create tmp files which are loaded to routers
# to start daemons and then start routers
start_topology(tgen, daemons)
# Don"t run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
# Creating configuration from JSON
build_config_from_json(tgen, topo)
# Verify PIM neighbors
result = verify_pim_neighbors(tgen, topo)
assert result is True, " Verify PIM neighbor: Failed Error: {}".format(
result)
# XXX Replace this using "with McastTesterHelper()... " in each test if possible.
global app_helper
app_helper = McastTesterHelper(tgen)
logger.info("Running setup_module() done")
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):
"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):
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):
"Sets up the pytest environment"
tgen = Topogen(BGPVRFTopo, mod.__name__)
tgen.start_topology()
# For all registered routers, load the zebra configuration file
for rname, router in tgen.routers().iteritems():
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"
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):
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.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(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
* `mod`: module name
"""
# Required linux kernel version for this suite to run.
result = required_linux_kernel_version("4.15")
if result is not True:
pytest.skip("Kernel requirements are not met")
global ADDR_TYPES
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...
json_file = "{}/bgp_large_community_topo_1.json".format(CWD)
tgen = Topogen(json_file, mod.__name__)
global topo
topo = tgen.json_topo
# ... and here it calls Mininet initialization functions.
# Starting topology, create tmp files which are loaded to routers
# to start deamons and then start routers
start_topology(tgen)
# Creating configuration from JSON
build_config_from_json(tgen, topo)
# Checking BGP convergence
global bgp_convergence
# Don"t run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
##tgen.mininet_cli()
# Api call verify whether BGP is converged
bgp_convergence = verify_bgp_convergence(tgen, topo)
assert bgp_convergence is True, "setup_module :Failed \n Error:" " {}".format(
bgp_convergence
)
ADDR_TYPES = check_address_types()
logger.info("Running setup_module() done")
def setup_module(mod):
"""
Set 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...
json_file = "{}/static_routes_topo3_ibgp.json".format(CWD)
tgen = Topogen(json_file, mod.__name__)
global topo
topo = tgen.json_topo
# ... and here it calls Mininet initialization functions.
# Starting topology, create tmp files which are loaded to routers
# to start deamons and then start routers
start_topology(tgen)
# Creating configuration from JSON
build_config_from_json(tgen, topo)
if version_cmp(platform.release(), "4.19") < 0:
error_msg = (
'These tests will not run. (have kernel "{}", '
"requires kernel >= 4.19)".format(platform.release())
)
pytest.skip(error_msg)
# Checking BGP convergence
global BGP_CONVERGENCE
global ADDR_TYPES
# Don't run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
# Api call verify whether BGP is converged
BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo)
assert BGP_CONVERGENCE is True, "setup_module :Failed \n Error: {}".format(
BGP_CONVERGENCE
)
logger.info("Running setup_module() done")
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 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(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 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...
json_file = "{}/evpn_type5_chaos_topo1.json".format(CWD)
tgen = Topogen(json_file, mod.__name__)
global topo
topo = tgen.json_topo
# ... and here it calls Mininet initialization functions.
# Starting topology, create tmp files which are loaded to routers
# to start deamons and then start routers
start_topology(tgen)
# Creating configuration from JSON
build_config_from_json(tgen, topo)
if version_cmp(platform.release(), "4.19") < 0:
error_msg = (
'EVPN tests will not run (have kernel "{}", '
"but it requires >= 4.19)".format(platform.release())
)
pytest.skip(error_msg)
global BGP_CONVERGENCE
global ADDR_TYPES
ADDR_TYPES = check_address_types()
BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo)
assert BGP_CONVERGENCE is True, "setup_module :Failed \n Error: {}".format(
BGP_CONVERGENCE
)
logger.info("Pre-requisite config for testsuite")
prerequisite_config_for_test_suite(tgen)
logger.info("Running setup_module() done")
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()
