import glob
from time import sleep
-from mininet.topo import Topo
-from mininet.net import Mininet
-from mininet.node import Node, OVSSwitch, Host
-from mininet.log import setLogLevel, info
-from mininet.cli import CLI
-from mininet.link import Intf
+from lib.micronet_compat import Mininet, Topo
from functools import partial
switch = {}
#
for i in range(0, 10):
- switch[i] = self.addSwitch("sw%s" % i, cls=topotest.LegacySwitch)
+ switch[i] = self.addSwitch("sw%s" % i)
self.addLink(switch[i], router[1], intfName2="r1-eth%s" % i)
)
# Mask out Bandwidth portion. They may change..
actual = re.sub(r"BW [0-9]+ Mbit", "BW XX Mbit", actual)
- actual = re.sub(r"ifindex [0-9]", "ifindex X", actual)
+ actual = re.sub(r"ifindex [0-9]+", "ifindex X", actual)
# Drop time in next due
actual = re.sub(r"Hello due in [0-9\.]+s", "Hello due in XX.XXXs", actual)
expected = ("\n".join(expected.splitlines()) + "\n").splitlines(1)
actual = net["r%s" % i].cmd('vtysh -c "show ip nht" 2> /dev/null').rstrip()
- actual = re.sub(r"fd [0-9][0-9]", "fd XX", actual)
+ actual = re.sub(r"fd [0-9]+", "fd XX", actual)
actual = ("\n".join(actual.splitlines()) + "\n").splitlines(1)
diff = topotest.get_textdiff(
expected = ("\n".join(expected.splitlines()) + "\n").splitlines(1)
actual = net["r%s" % i].cmd('vtysh -c "show ipv6 nht" 2> /dev/null').rstrip()
- actual = re.sub(r"fd [0-9][0-9]", "fd XX", actual)
+ actual = re.sub(r"fd [0-9]+", "fd XX", actual)
actual = ("\n".join(actual.splitlines()) + "\n").splitlines(1)
diff = topotest.get_textdiff(
net["r1"].cmd('vtysh -c "sharp remove routes %s 1"' % route_str)
net["r1"].cmd('vtysh -c "c t" -c "no ip protocol sharp route-map NH-SRC"')
net["r1"].cmd(
- 'vtysh -c "c t" -c "no route-map NH-SRC permit 111" -c "set src %s"' % src_str
+ 'vtysh -c "c t" -c "no route-map NH-SRC permit 111" # -c "set src %s"' % src_str
)
net["r1"].cmd('vtysh -c "c t" -c "no route-map NH-SRC"')
if __name__ == "__main__":
-
- setLogLevel("info")
# To suppress tracebacks, either use the following pytest call or add "--tb=no" to cli
# retval = pytest.main(["-s", "--tb=no"])
retval = pytest.main(["-s"])
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
-
pytestmark = [pytest.mark.bgpd, pytest.mark.bfdd]
-class BFDTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- # Create 4 routers.
- for routern in range(1, 4):
- tgen.add_router("r{}".format(routern))
-
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r2"])
-
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["r2"])
- switch.add_link(tgen.gears["r3"])
-
-
def setup_module(mod):
"Sets up the pytest environment"
- tgen = Topogen(BFDTopo, mod.__name__)
+ from collections import OrderedDict
+ topodef = {
+ "s1": ("r1", "r2"),
+ "s2": ("r2", "r3"),
+ }
+ tgen = Topogen(topodef, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
-
pytestmark = [pytest.mark.bfdd, pytest.mark.isisd]
-
-class TemplateTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- #
- # Define FRR Routers
- #
- for router in ["rt1", "rt2", "rt3", "rt4", "rt5"]:
- tgen.add_router(router)
-
- #
- # Define connections
- #
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt2")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt1")
-
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt3")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt1")
-
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt5")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt2")
-
- switch = tgen.add_switch("s4")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt4")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt3")
-
- switch = tgen.add_switch("s5")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt5")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt4")
-
-
def setup_module(mod):
"Sets up the pytest environment"
- tgen = Topogen(TemplateTopo, mod.__name__)
+ topodef = {
+ "s1": ("rt1:eth-rt2", "rt2:eth-rt1"),
+ "s2": ("rt1:eth-rt3", "rt3:eth-rt1"),
+ "s3": ("rt2:eth-rt5", "rt5:eth-rt2"),
+ "s4": ("rt3:eth-rt4", "rt4:eth-rt3"),
+ "s5": ("rt4:eth-rt5", "rt5:eth-rt4"),
+ }
+ tgen = Topogen(topodef, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib import topotest
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
-
pytestmark = [pytest.mark.bfdd, pytest.mark.ospfd]
-class TemplateTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- #
- # Define FRR Routers
- #
- for router in ["rt1", "rt2", "rt3", "rt4", "rt5"]:
- tgen.add_router(router)
-
- #
- # Define connections
- #
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt2")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt1")
-
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt3")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt1")
-
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt5")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt2")
-
- switch = tgen.add_switch("s4")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt4")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt3")
-
- switch = tgen.add_switch("s5")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt5")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt4")
-
-
def setup_module(mod):
"Sets up the pytest environment"
- tgen = Topogen(TemplateTopo, mod.__name__)
+ topodef = {
+ "s1": ("rt1:eth-rt2", "rt2:eth-rt1"),
+ "s2": ("rt1:eth-rt3", "rt3:eth-rt1"),
+ "s3": ("rt2:eth-rt5", "rt5:eth-rt2"),
+ "s4": ("rt3:eth-rt4", "rt4:eth-rt3"),
+ "s5": ("rt4:eth-rt5", "rt5:eth-rt4"),
+ }
+ tgen = Topogen(topodef, 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():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
-
pytestmark = [pytest.mark.bfdd, pytest.mark.bgpd, pytest.mark.isisd, pytest.mark.ospfd]
-
-class BFDProfTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- # Create 6 routers
- for routern in range(1, 7):
- tgen.add_router("r{}".format(routern))
-
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r2"])
-
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["r2"])
- switch.add_link(tgen.gears["r3"])
-
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["r3"])
- switch.add_link(tgen.gears["r4"])
-
- switch = tgen.add_switch("s4")
- switch.add_link(tgen.gears["r4"])
- switch.add_link(tgen.gears["r5"])
-
- switch = tgen.add_switch("s5")
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r6"])
-
-
def setup_module(mod):
"Sets up the pytest environment"
- tgen = Topogen(BFDProfTopo, mod.__name__)
+
+ 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()
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
-
pytestmark = [pytest.mark.bfdd, pytest.mark.bgpd]
-class BFDTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- # Create 4 routers
- for routern in range(1, 5):
- tgen.add_router("r{}".format(routern))
-
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r2"])
-
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["r2"])
- switch.add_link(tgen.gears["r3"])
-
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["r2"])
- switch.add_link(tgen.gears["r4"])
-
-
def setup_module(mod):
"Sets up the pytest environment"
- tgen = Topogen(BFDTopo, mod.__name__)
+ topodef = {
+ "s1": ("r1", "r2"),
+ "s2": ("r2", "r3"),
+ "s3": ("r2", "r4"),
+ }
+ tgen = Topogen(topodef, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
-
pytestmark = [pytest.mark.bfdd, pytest.mark.bgpd, pytest.mark.ospfd]
-class BFDTopo(Topo):
- "Test topology builder"
+def build(self, *_args, **_opts):
+ "Build function"
+ tgen = get_topogen(self)
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
+ # Create 4 routers.
+ for routern in range(1, 5):
+ tgen.add_router("r{}".format(routern))
- # Create 4 routers.
- for routern in range(1, 5):
- tgen.add_router("r{}".format(routern))
+ switch = tgen.add_switch("s1")
+ switch.add_link(tgen.gears["r1"])
+ switch.add_link(tgen.gears["r2"])
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r2"])
+ switch = tgen.add_switch("s2")
+ switch.add_link(tgen.gears["r2"])
+ switch.add_link(tgen.gears["r3"])
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["r2"])
- switch.add_link(tgen.gears["r3"])
+ switch = tgen.add_switch("s3")
+ switch.add_link(tgen.gears["r2"])
+ switch.add_link(tgen.gears["r4"])
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["r2"])
- switch.add_link(tgen.gears["r4"])
def setup_module(mod):
"Sets up the pytest environment"
- tgen = Topogen(BFDTopo, mod.__name__)
+ topodef = {
+ "s1": ("r1", "r2"),
+ "s2": ("r2", "r3"),
+ "s3": ("r2", "r4"),
+ }
+ tgen = Topogen(topodef, mod.__name__)
+ # tgen = Topogen(build, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib import topotest
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
-
pytestmark = [pytest.mark.bfdd, pytest.mark.bgpd]
-class BFDTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- # Create 4 routers
- for routern in range(1, 5):
- tgen.add_router("r{}".format(routern))
-
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r2"])
-
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["r2"])
- switch.add_link(tgen.gears["r3"])
-
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["r3"])
- switch.add_link(tgen.gears["r4"])
-
-
def setup_module(mod):
"Sets up the pytest environment"
- tgen = Topogen(BFDTopo, mod.__name__)
+ topodef = {
+ "s1": ("r1", "r2"),
+ "s2": ("r2", "r3"),
+ "s3": ("r3", "r4"),
+ }
+ tgen = Topogen(topodef, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bfdd, pytest.mark.bgpd]
logger.info("Testing with VRF Namespace support")
- cmds = [
- "if [ -e /var/run/netns/{0}-bfd-cust1 ] ; then ip netns del {0}-bfd-cust1 ; fi",
- "ip netns add {0}-bfd-cust1",
- "ip link set dev {0}-eth0 netns {0}-bfd-cust1 up",
- ]
- cmds2 = [
- "ip link set dev {0}-eth1 netns {0}-bfd-cust1",
- "ip netns exec {0}-bfd-cust1 ip link set {0}-eth1 up",
- "ip link set dev {0}-eth2 netns {0}-bfd-cust1 up",
- ]
-
for rname, router in router_list.items():
# create VRF rx-bfd-cust1 and link rx-eth0 to rx-bfd-cust1
- for cmd in cmds:
- output = tgen.net[rname].cmd_raises(cmd.format(rname))
+ ns = "{}-bfd-cust1".format(rname)
+ router.net.add_netns(ns)
+ router.net.set_intf_netns(rname + "-eth0", ns, up=True)
if rname == "r2":
- for cmd in cmds2:
- output = tgen.net[rname].cmd_raises(cmd.format(rname))
+ 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(
def teardown_module(_mod):
"Teardown the pytest environment"
tgen = get_topogen()
- # move back rx-eth0 to default VRF
- # delete rx-vrf
- cmds = [
- "ip netns exec {0}-bfd-cust1 ip link set {0}-eth0 netns 1",
- "ip netns delete {0}-bfd-cust1",
- ]
- cmds2 = [
- "ip netns exec {0}-bfd-cust1 ip link set {0}-eth1 netns 1",
- "ip netns exec {0}-cust2 ip link set {0}-eth1 netns 1",
- ]
+ # Move interfaces out of vrf namespace and delete the namespace
router_list = tgen.routers()
for rname, router in router_list.items():
if rname == "r2":
- for cmd in cmds2:
- tgen.net[rname].cmd(cmd.format(rname))
- for cmd in cmds:
- tgen.net[rname].cmd(cmd.format(rname))
+ router.net.reset_intf_netns(rname + "-eth2")
+ router.net.reset_intf_netns(rname + "-eth1")
+ router.net.reset_intf_netns(rname + "-eth0")
+ router.net.delete_netns("{}-bfd-cust1".format(rname))
tgen.stop_topology()
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
protocol=protocol,
expected=False,
)
- assert result is not True, "Testcase {} : Failed \n"
- "Expected behavior: routes should not present in rib \n"
- "Error: {}".format(tc_name, result)
+ assert result is not True, (
+ "Testcase {} : Failed \n".format(tc_name) +
+ "Expected behavior: routes should not present in rib \n" +
+ "Error: {}".format(result)
+ )
step("Configure allowas-in on R3 for R2.")
step("We should see the prefix advertised from R1 in R3's BGP table.")
result = verify_rib(
tgen, "ipv6", dut, static_route_ipv6, protocol=protocol, expected=False
)
- assert result is not True, "Testcase {} : Failed \n"
- "Expected behavior: routes are should not be present in ipv6 rib\n"
- " Error: {}".format(tc_name, result)
+ assert result is not True, (
+ "Testcase {} : Failed \n".format(tc_name) +
+ "Expected behavior: routes are should not be present in ipv6 rib\n" +
+ " Error: {}".format(result)
+ )
step("Repeat the same test for IPv6 AFI.")
step("Configure allowas-in on R3 for R2 under IPv6 addr-family only")
result = verify_rib(
tgen, "ipv4", dut, static_route_ipv4, protocol=protocol, expected=False
)
- assert result is not True, "Testcase {} : Failed \n"
- "Expected behavior: routes should not be present in ipv4 rib\n"
- " Error: {}".format(tc_name, result)
+ assert result is not True, (
+ "Testcase {} : Failed \n".format(tc_name) +
+ "Expected behavior: routes should not be present in ipv4 rib\n" +
+ " Error: {}".format(result)
+ )
result = verify_rib(tgen, "ipv6", dut, static_route_ipv6, protocol=protocol)
assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
result = verify_rib(
tgen, addr_type, dut, static_routes, protocol=protocol, expected=False
)
- assert result is not True, "Testcase {} : Failed \n "
- "Expected behavior: routes are should not be present in rib\n"
- "Error: {}".format(tc_name, result)
+ assert result is not True, (
+ "Testcase {} : Failed \n ".format(tc_name) +
+ "Expected behavior: routes are should not be present in rib\n" +
+ "Error: {}".format(result)
+ )
for addr_type in ADDR_TYPES:
step('Configure "allowas-in 5" on R3 for R2.')
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import apply_raw_config
# Required to instantiate the topology builder class.
+from lib.bgp import (clear_bgp_and_verify, create_router_bgp, modify_as_number,
+ verify_as_numbers, verify_bgp_convergence, verify_bgp_rib,
+ verify_bgp_timers_and_functionality, verify_router_id)
+from lib.common_config import (addKernelRoute, apply_raw_config,
+ check_address_types, create_prefix_lists,
+ create_route_maps, create_static_routes,
+ required_linux_kernel_version,
+ reset_config_on_routers, start_topology, step,
+ verify_admin_distance_for_static_routes,
+ verify_bgp_community, verify_fib_routes,
+ verify_rib, write_test_footer,
+ write_test_header)
+from lib.micronet_compat import Topo
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
-
-from lib.common_config import (
- step,
- start_topology,
- write_test_header,
- write_test_footer,
- reset_config_on_routers,
- create_static_routes,
- verify_rib,
- verify_admin_distance_for_static_routes,
- check_address_types,
- apply_raw_config,
- addKernelRoute,
- verify_fib_routes,
- create_prefix_lists,
- create_route_maps,
- verify_bgp_community,
- required_linux_kernel_version,
-)
+from lib.topojson import build_config_from_json, build_topo_from_json
from lib.topolog import logger
-from lib.bgp import (
- verify_bgp_convergence,
- create_router_bgp,
- verify_router_id,
- modify_as_number,
- verify_as_numbers,
- clear_bgp_and_verify,
- verify_bgp_timers_and_functionality,
- verify_bgp_rib,
-)
-from lib.topojson import build_topo_from_json, build_config_from_json
pytestmark = [pytest.mark.bgpd, pytest.mark.staticd]
dut = "r1"
protocol = "bgp"
for addr_type in ADDR_TYPES:
- result = verify_fib_routes(tgen, addr_type, dut, input_dict_r1)
- assert result is not True, "Testcase {} : Failed \n"
- "Expected behavior: routes should not present in fib \n"
- "Error: {}".format(tc_name, result)
+ result = verify_fib_routes(tgen, addr_type, dut, input_dict_r1, expected=False) # pylint: disable=E1123
+ assert result is not True, (
+ "Testcase {} : Failed \n".format(tc_name) +
+ "Expected behavior: routes should not present in fib \n" +
+ "Error: {}".format(result)
+ )
step("Verify Ipv4 and Ipv6 network installed in r3 RIB but not in FIB")
input_dict_r3 = {
dut = "r3"
protocol = "bgp"
for addr_type in ADDR_TYPES:
- result = verify_fib_routes(tgen, addr_type, dut, input_dict_r1)
- assert result is not True, "Testcase {} : Failed \n"
- "Expected behavior: routes should not present in fib \n"
- "Error: {}".format(tc_name, result)
+ result = verify_fib_routes(tgen, addr_type, dut, input_dict_r1, expected=False) # pylint: disable=E1123
+ assert result is not True, (
+ "Testcase {} : Failed \n".format(tc_name) +
+ "Expected behavior: routes should not present in fib \n" +
+ "Error: {}".format(result)
+ )
write_test_footer(tc_name)
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import step
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import step
from time import sleep
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import step
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import step
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
pytestmark = [pytest.mark.bgpd]
-class TemplateTopo(Topo):
- def build(self, *_args, **_opts):
- tgen = get_topogen(self)
-
- for routern in range(1, 3):
- tgen.add_router("r{}".format(routern))
-
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r2"])
-
-
def setup_module(mod):
- tgen = Topogen(TemplateTopo, mod.__name__)
+ topodef = { "s1": ("r1", "r2") }
+ tgen = Topogen(topodef, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib import topotest
+# Required to instantiate the topology builder class.
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
-
pytestmark = [pytest.mark.bgpd, pytest.mark.pimd]
-
#####################################################
##
## Network Topology Definition
)
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
tgen.start_topology()
# Configure MAC address for hosts as these MACs are advertised with EVPN type-2 routes
- for (name, host) in tgen.gears.items():
+ for name in tgen.gears:
if name not in HOSTS:
continue
+ host = tgen.net[name]
host_mac = "1a:2b:3c:4d:5e:6{}".format(HOST_SUFFIX[name])
- host.run("ip link set dev {}-eth0 down").format(name)
- host.run("ip link set dev {0}-eth0 address {1}".format(name, host_mac))
- host.run("ip link set dev {}-eth0 up").format(name)
+ host.cmd_raises("ip link set dev {}-eth0 down".format(name))
+ host.cmd_raises("ip link set dev {0}-eth0 address {1}".format(name, host_mac))
+ host.cmd_raises("ip link set dev {}-eth0 up".format(name))
# Configure PE VxLAN and Bridge interfaces
- for (name, pe) in tgen.gears.items():
+ for name in tgen.gears:
if name not in PES:
continue
+ pe = tgen.net[name]
+
vtep_ip = "10.100.0.{}".format(PE_SUFFIX[name])
bridge_ip = "50.0.1.{}/24".format(PE_SUFFIX[name])
bridge_ipv6 = "50:0:1::{}/48".format(PE_SUFFIX[name])
- pe.run("ip link add vrf-blue type vrf table 10")
- pe.run("ip link set dev vrf-blue up")
- pe.run("ip link add vxlan100 type vxlan id 100 dstport 4789 local {}".format(vtep_ip))
- pe.run("ip link add name br100 type bridge stp_state 0")
- pe.run("ip link set dev vxlan100 master br100")
- pe.run("ip link set dev {}-eth1 master br100".format(name))
- pe.run("ip addr add {} dev br100".format(bridge_ip))
- pe.run("ip link set up dev br100")
- pe.run("ip link set up dev vxlan100")
- pe.run("ip link set up dev {}-eth1".format(name))
- pe.run("ip link set dev br100 master vrf-blue")
- pe.run("ip -6 addr add {} dev br100".format(bridge_ipv6))
-
- pe.run("ip link add vxlan1000 type vxlan id 1000 dstport 4789 local {}".format(vtep_ip))
- pe.run("ip link add name br1000 type bridge stp_state 0")
- pe.run("ip link set dev vxlan1000 master br100")
- pe.run("ip link set up dev br1000")
- pe.run("ip link set up dev vxlan1000")
- pe.run("ip link set dev br1000 master vrf-blue")
-
- pe.run("sysctl -w net.ipv4.ip_forward=1")
- pe.run("sysctl -w net.ipv6.conf.all.forwarding=1")
- pe.run("sysctl -w net.ipv4.udp_l3mdev_accept={}".format(l3mdev_accept))
- pe.run("sysctl -w net.ipv4.tcp_l3mdev_accept={}".format(l3mdev_accept))
+ pe.cmd_raises("ip link add vrf-blue type vrf table 10")
+ pe.cmd_raises("ip link set dev vrf-blue up")
+ pe.cmd_raises(
+ "ip link add vxlan100 type vxlan id 100 dstport 4789 local {}".format(
+ vtep_ip
+ )
+ )
+ pe.cmd_raises("ip link add name br100 type bridge stp_state 0")
+ pe.cmd_raises("ip link set dev vxlan100 master br100")
+ pe.cmd_raises("ip link set dev {}-eth1 master br100".format(name))
+ pe.cmd_raises("ip addr add {} dev br100".format(bridge_ip))
+ pe.cmd_raises("ip link set up dev br100")
+ pe.cmd_raises("ip link set up dev vxlan100")
+ pe.cmd_raises("ip link set up dev {}-eth1".format(name))
+ pe.cmd_raises("ip link set dev br100 master vrf-blue")
+ pe.cmd_raises("ip -6 addr add {} dev br100".format(bridge_ipv6))
+
+ pe.cmd_raises(
+ "ip link add vxlan1000 type vxlan id 1000 dstport 4789 local {}".format(
+ vtep_ip
+ )
+ )
+ pe.cmd_raises("ip link add name br1000 type bridge stp_state 0")
+ pe.cmd_raises("ip link set dev vxlan1000 master br100")
+ pe.cmd_raises("ip link set up dev br1000")
+ pe.cmd_raises("ip link set up dev vxlan1000")
+ pe.cmd_raises("ip link set dev br1000 master vrf-blue")
+
+ pe.cmd_raises("sysctl -w net.ipv4.ip_forward=1")
+ pe.cmd_raises("sysctl -w net.ipv6.conf.all.forwarding=1")
+ pe.cmd_raises("sysctl -w net.ipv4.udp_l3mdev_accept={}".format(l3mdev_accept))
+ pe.cmd_raises("sysctl -w net.ipv4.tcp_l3mdev_accept={}".format(l3mdev_accept))
# For all registred routers, load the zebra configuration file
for (name, router) in tgen.routers().items():
step("Shut down VxLAN interface at PE1 which results in withdraw of type-2 routes")
- pe1 = tgen.gears['PE1']
+ pe1 = tgen.net["PE1"]
- pe1.run('ip link set dev vxlan100 down')
+ pe1.cmd_raises("ip link set dev vxlan100 down")
result, assertmsg = evpn_gateway_ip_show_op_check("no_rt2")
if result is not None:
step("Bring up VxLAN interface at PE1 and advertise type-2 routes again")
- pe1.run('ip link set dev vxlan100 up')
+ pe1.cmd_raises("ip link set dev vxlan100 up")
result, assertmsg = evpn_gateway_ip_show_op_check("base")
if result is not None:
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
"ip link set dev loop101 master {}-vrf-101",
"ip link set dev loop101 up",
]
- cmds_netns = [
- "ip netns add {}-vrf-101",
- "ip link add loop101 type dummy",
- "ip link set dev loop101 netns {}-vrf-101",
- "ip netns exec {}-vrf-101 ip link set dev loop101 up",
- ]
cmds_r2 = [ # config routing 101
"ip link add name bridge-101 up type bridge stp_state 0",
"ip link set vxlan-101 up type bridge_slave learning off flood off mcast_flood off",
]
- cmds_r1_netns_method3 = [
- "ip link add name vxlan-{1} type vxlan id {1} dstport 4789 dev {0}-eth0 local 192.168.100.21",
- "ip link set dev vxlan-{1} netns {0}-vrf-{1}",
- "ip netns exec {0}-vrf-{1} ip li set dev lo up",
- "ip netns exec {0}-vrf-{1} ip link add name bridge-{1} up type bridge stp_state 0",
- "ip netns exec {0}-vrf-{1} ip link set dev vxlan-{1} master bridge-{1}",
- "ip netns exec {0}-vrf-{1} ip link set bridge-{1} up",
- "ip netns exec {0}-vrf-{1} ip link set vxlan-{1} up",
- ]
+ # cmds_r1_netns_method3 = [
+ # "ip link add name vxlan-{1} type vxlan id {1} dstport 4789 dev {0}-eth0 local 192.168.100.21",
+ # "ip link set dev vxlan-{1} netns {0}-vrf-{1}",
+ # "ip netns exec {0}-vrf-{1} ip li set dev lo up",
+ # "ip netns exec {0}-vrf-{1} ip link add name bridge-{1} up type bridge stp_state 0",
+ # "ip netns exec {0}-vrf-{1} ip link set dev vxlan-{1} master bridge-{1}",
+ # "ip netns exec {0}-vrf-{1} ip link set bridge-{1} up",
+ # "ip netns exec {0}-vrf-{1} ip link set vxlan-{1} up",
+ # ]
router = tgen.gears["r1"]
- for cmd in cmds_netns:
- logger.info("cmd to r1: " + cmd)
- output = router.run(cmd.format("r1"))
- logger.info("result: " + output)
+
+ ns = "r1-vrf-101"
+ tgen.net["r1"].add_netns(ns)
+ tgen.net["r1"].cmd_raises("ip link add loop101 type dummy")
+ tgen.net["r1"].set_intf_netns("loop101", ns, up=True)
router = tgen.gears["r2"]
for cmd in cmds_vrflite:
logger.info("cmd to r2: " + cmd.format("r2"))
- output = router.run(cmd.format("r2"))
+ output = router.cmd_raises(cmd.format("r2"))
logger.info("result: " + output)
for cmd in cmds_r2:
logger.info("cmd to r2: " + cmd.format("r2"))
- output = router.run(cmd.format("r2"))
+ output = router.cmd_raises(cmd.format("r2"))
logger.info("result: " + output)
- router = tgen.gears["r1"]
- bridge_id = "101"
- for cmd in cmds_r1_netns_method3:
- logger.info("cmd to r1: " + cmd.format("r1", bridge_id))
- output = router.run(cmd.format("r1", bridge_id))
- logger.info("result: " + output)
- router = tgen.gears["r1"]
+ tgen.net["r1"].cmd_raises("ip link add name vxlan-101 type vxlan id 101 dstport 4789 dev r1-eth0 local 192.168.100.21")
+ tgen.net["r1"].set_intf_netns("vxlan-101", "r1-vrf-101", up=True)
+ tgen.net["r1"].cmd_raises("ip -n r1-vrf-101 link set lo up")
+ tgen.net["r1"].cmd_raises("ip -n r1-vrf-101 link add name bridge-101 up type bridge stp_state 0")
+ tgen.net["r1"].cmd_raises("ip -n r1-vrf-101 link set dev vxlan-101 master bridge-101")
+ tgen.net["r1"].cmd_raises("ip -n r1-vrf-101 link set bridge-101 up")
+ tgen.net["r1"].cmd_raises("ip -n r1-vrf-101 link set vxlan-101 up")
for rname, router in router_list.items():
if rname == "r1":
def teardown_module(_mod):
"Teardown the pytest environment"
tgen = get_topogen()
- cmds_rx_netns = ["ip netns del {}-vrf-101"]
- router = tgen.gears["r1"]
- for cmd in cmds_rx_netns:
- logger.info("cmd to r1: " + cmd.format("r1"))
- output = router.run(cmd.format("r1"))
+ tgen.net["r1"].delete_netns("r1-vrf-101")
tgen.stop_topology()
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.ospfd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.ospfd]
from lib.lutil import luCommand
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Import topoJson from lib, to create topology and initial configuration
from lib.topojson import build_topo_from_json, build_config_from_json
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Import topoJson from lib, to create topology and initial configuration
from lib.topojson import build_topo_from_json, build_config_from_json
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from time import sleep
from lib.common_config import (
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from time import sleep
from lib.common_config import (
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib.ltemplate import ltemplateRtrCmd
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
import shutil
if tgen.hasmpls != True:
logger.info("MPLS not available, skipping setup")
return False
- # check for normal init
- if len(tgen.net) == 1:
- logger.info("Topology not configured, skipping setup")
- return False
# configure r2 mpls interfaces
intfs = ["lo", "r2-eth0", "r2-eth1", "r2-eth2"]
for intf in intfs:
from lib.ltemplate import ltemplateRtrCmd
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
import shutil
if tgen.hasmpls != True:
logger.info("MPLS not available, skipping setup")
return False
- # check for normal init
- if len(tgen.net) == 1:
- logger.info("Topology not configured, skipping setup")
- return False
# trace errors/unexpected output
cc.resetCounts()
# configure r2 mpls interfaces
"lo_prefix": {
"ipv4": "1.0.",
"v4mask": 32,
- "ipv6": "2001:DB8:F::",
+ "ipv6": "2001:db8:f::",
"v6mask": 128
},
"routers": {
# Required to instantiate the topology builder class.
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
# Import topogen and topotest helpers
# Import topoJson from lib, to create topology and initial configuration
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib.topojson import linux_intf_config_from_json
from lib.common_config import start_topology
from lib.topotest import router_json_cmp, run_and_expect
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from functools import partial
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topotest import iproute2_is_vrf_capable
from lib.common_config import (
step,
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topotest import iproute2_is_vrf_capable
from lib.common_config import (
step,
import json
from time import sleep
-from mininet.topo import Topo
-from mininet.net import Mininet
-from mininet.node import Node, OVSSwitch, Host
-from mininet.log import setLogLevel, info
-from mininet.cli import CLI
-from mininet.link import Intf
-
from functools import partial
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from lib import topotest
+from lib.micronet_compat import Mininet
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# Setup Switches
switch = {}
# First switch is for a dummy interface (for local network)
- switch[0] = self.addSwitch("sw0", cls=topotest.LegacySwitch)
+ switch[0] = self.addSwitch("sw0")
self.addLink(switch[0], router[1], intfName2="r1-stub")
# Second switch is for connection to all peering routers
- switch[1] = self.addSwitch("sw1", cls=topotest.LegacySwitch)
+ switch[1] = self.addSwitch("sw1")
self.addLink(switch[1], router[1], intfName2="r1-eth0")
for j in range(1, 9):
self.addLink(switch[1], peer[j], intfName2="peer%s-eth0" % j)
if __name__ == "__main__":
-
- setLogLevel("info")
# To suppress tracebacks, either use the following pytest call or add "--tb=no" to cli
# retval = pytest.main(["-s", "--tb=no"])
retval = pytest.main(["-s"])
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.staticd]
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib import topotest
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib.ltemplate import ltemplateRtrCmd
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
import shutil
cc = ltemplateRtrCmd()
tgen = get_topogen()
logger.info("pre router-start hook")
- # check for normal init
- if len(tgen.net) == 1:
- logger.info("Topology not configured, skipping setup")
- return False
return True
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib import topotest
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
# Import topogen and topotest helpers
from lib import topotest
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Required to instantiate the topology builder class.
from lib.topojson import *
# Import topogen and topotest helpers
from lib import topotest
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Required to instantiate the topology builder class.
from lib.common_config import (
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
master agentx
-noRangeCheck yes
\ No newline at end of file
+noRangeCheck yes
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
from lib.snmptest import SnmpTester
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.isisd, pytest.mark.snmp]
"Wait for protocol convergence"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "10.1.1.1", "public", "2c")
assertmsg = "BGP SNMP does not seem to be running"
def test_r1_mplsvpn_scalars():
"check scalar values"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "10.1.1.1", "public", "2c")
for item in interfaces_up_test.keys():
def test_r1_mplsvpn_scalars_interface():
"check scalar interface changing values"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
- r1_cmd = tgen.gears["r1"]
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "10.1.1.1", "public", "2c")
- r1_cmd.vtysh_cmd("conf t\ninterface r1-eth3\nshutdown")
- r1_cmd.vtysh_cmd("conf t\ninterface r1-eth4\nshutdown")
+ r1.vtysh_cmd("conf t\ninterface r1-eth3\nshutdown")
+ r1.vtysh_cmd("conf t\ninterface r1-eth4\nshutdown")
for item in interfaces_up_test.keys():
assertmsg = "{} should be {}: value {}".format(
)
assert r1_snmp.test_oid(item, interfaces_down_test[item]), assertmsg
- r1_cmd.vtysh_cmd("conf t\ninterface r1-eth3\nno shutdown")
- r1_cmd.vtysh_cmd("conf t\ninterface r1-eth4\nno shutdown")
+ r1.vtysh_cmd("conf t\ninterface r1-eth3\nno shutdown")
+ r1.vtysh_cmd("conf t\ninterface r1-eth4\nno shutdown")
for item in interfaces_up_test.keys():
assertmsg = "{} should be {}: value {}".format(
"mplsL3VpnIf table values"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
- r1r = tgen.gears["r1"]
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "10.1.1.1", "public", "2c")
# tgen.mininet_cli()
- eth3_ifindex = router_interface_get_ifindex(r1r, "eth3")
- eth4_ifindex = router_interface_get_ifindex(r1r, "eth4")
- eth5_ifindex = router_interface_get_ifindex(r1r, "eth5")
+ eth3_ifindex = router_interface_get_ifindex(r1, "eth3")
+ eth4_ifindex = router_interface_get_ifindex(r1, "eth4")
+ eth5_ifindex = router_interface_get_ifindex(r1, "eth5")
# get ifindex and make sure the oid is correct
def test_r1_mplsvpn_VrfTable():
tgen = get_topogen()
- r1 = tgen.net.get("r1")
- r1r = tgen.gears["r1"]
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "10.1.1.1", "public", "2c")
"mplsL3VpnVrfConfLastChanged.{}".format(snmp_str_to_oid("VRF-a"))
)
ts_val_last_1 = get_timetick_val(ts_last)
- r1r.vtysh_cmd("conf t\ninterface r1-eth3\nshutdown")
+ r1.vtysh_cmd("conf t\ninterface r1-eth3\nshutdown")
active_int = r1_snmp.get(
"mplsL3VpnVrfActiveInterfaces.{}".format(snmp_str_to_oid("VRF-a"))
)
ts_val_last_2 = get_timetick_val(ts_last)
assertmsg = "mplsL3VpnVrfConfLastChanged does not update on interface change"
assert ts_val_last_2 > ts_val_last_1, assertmsg
- r1r.vtysh_cmd("conf t\ninterface r1-eth3\nno shutdown")
+ r1.vtysh_cmd("conf t\ninterface r1-eth3\nno shutdown")
# take Last changed time, fiddle with associated interfaces, ensure
# time changes and active interfaces change
def test_r1_mplsvpn_VrfRT_table():
tgen = get_topogen()
- r1 = tgen.net.get("r1")
- r1r = tgen.gears["r1"]
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "10.1.1.1", "public", "2c")
def test_r1_mplsvpn_perf_table():
tgen = get_topogen()
- r1 = tgen.net.get("r1")
- r1r = tgen.gears["r1"]
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "10.1.1.1", "public", "2c")
def test_r1_mplsvpn_rte_table():
tgen = get_topogen()
- r1 = tgen.net.get("r1")
- r1r = tgen.gears["r1"]
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "10.1.1.1", "public", "2c")
# generate ifindex row grabbing ifindices from vtysh
if passed:
ifindex_row = [
- router_interface_get_ifindex(r1r, "eth3"),
- router_interface_get_ifindex(r1r, "eth4"),
- router_interface_get_ifindex(r1r, "eth2"),
- router_interface_get_ifindex(r1r, "eth3"),
+ router_interface_get_ifindex(r1, "eth3"),
+ router_interface_get_ifindex(r1, "eth4"),
+ router_interface_get_ifindex(r1, "eth2"),
+ router_interface_get_ifindex(r1, "eth3"),
"0",
- router_interface_get_ifindex(r1r, "eth4"),
+ router_interface_get_ifindex(r1, "eth4"),
"0",
]
if not r1_snmp.test_oid_walk(
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
from lib.common_config import required_linux_kernel_version
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
from lib.topotest import version_cmp
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
from lib.topotest import version_cmp
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
from lib.common_config import required_linux_kernel_version
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# create VRF r1-bgp-cust1
# move r1-eth0 to VRF r1-bgp-cust1
- cmds = [
- "if [ -e /var/run/netns/{0}-bgp-cust1 ] ; then ip netns del {0}-bgp-cust1 ; fi",
- "ip netns add {0}-bgp-cust1",
- "ip link set {0}-eth0 netns {0}-bgp-cust1 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
- )
+
+ 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,
def teardown_module(module):
tgen = get_topogen()
- # move back r1-eth0 to default VRF
- # delete VRF r1-bgp-cust1
- cmds = [
- "ip netns exec {0}-bgp-cust1 ip link set {0}-eth0 netns 1",
- "ip netns delete {0}-bgp-cust1",
- ]
- for cmd in cmds:
- tgen.net["r1"].cmd(cmd.format("r1"))
+
+ # Move interfaces out of vrf namespace and delete the namespace
+ tgen.net["r1"].reset_intf_netns("r1-eth0")
+ tgen.net["r1"].delete_netns("r1-bgp-cust1")
tgen.stop_topology()
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd]
# pylint: disable=C0413
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.staticd]
do_config(prefix_count, bad_indices, base_delta, 2, True, ipv6, prefix_base[ipv6][0])
# Remove 1/2 of duplicate
- do_config(prefix_count / 2, bad_indices, base_delta, 2, False, ipv6, prefix_base[ipv6][0])
+ do_config(prefix_count // 2, bad_indices, base_delta, 2, False, ipv6, prefix_base[ipv6][0])
# Add all back in so 1/2 replicate 1/2 new
do_config(prefix_count, bad_indices, base_delta, 2, True, ipv6, prefix_base[ipv6][0])
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
#####################################################
##
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.bgpd]
# Import topogen and topotest helpers
from lib.topotest import version_cmp
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
# Reading the data from JSON File for topology creation
# Global variables
TCPDUMP_FILE = "evpn_log.txt"
-LOGDIR = "/tmp/topotests/"
NETWORK1_1 = {"ipv4": "10.1.1.1/32", "ipv6": "10::1/128"}
NETWORK1_2 = {"ipv4": "40.1.1.1/32", "ipv6": "40::1/128"}
NETWORK1_3 = {"ipv4": "40.1.1.2/32", "ipv6": "40::2/128"}
# Import topogen and topotest helpers
from lib.topotest import version_cmp
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# TODO: select markers based on daemons used during test
"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.
+ # ... and here it calls initialization functions.
tgen.start_topology()
# This is a sample of configuration loading.
tgen.stop_topology()
-def test_call_mininet_cli():
- "Dummy test that just calls mininet CLI so we can interact with the build."
+def test_call_cli():
+ "Dummy test that just calls tgen.cli() so we can interact with the build."
tgen = get_topogen()
# Don't run this test if we have any failure.
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
- logger.info("calling mininet CLI")
- tgen.mininet_cli()
+ # logger.info("calling CLI")
+ # tgen.cli()
# Memory leak test template
from lib.topogen import Topogen, get_topogen
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Import topoJson from lib, to create topology and initial configuration
from lib.common_config import (
from lib.topogen import Topogen, get_topogen
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Import topoJson from lib, to create topology and initial configuration
from lib.common_config import (
from lib.topogen import Topogen, get_topogen
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Import topoJson from lib, to create topology and initial configuration
from lib.common_config import (
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.isisd]
outputs = {}
-class TemplateTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- #
- # Define FRR Routers
- #
- for router in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6", "rt7"]:
- tgen.add_router(router)
-
- #
- # Define connections
- #
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt2")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt1")
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt3")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt2")
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt3")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt1")
- switch = tgen.add_switch("s4")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt4")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt1")
- switch = tgen.add_switch("s5")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt5")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt1")
- switch = tgen.add_switch("s6")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt6")
- switch.add_link(tgen.gears["rt6"], nodeif="eth-rt1")
- switch = tgen.add_switch("s7")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt7")
- switch.add_link(tgen.gears["rt7"], nodeif="eth-rt2")
- switch = tgen.add_switch("s8")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt7")
- switch.add_link(tgen.gears["rt7"], nodeif="eth-rt3")
- switch = tgen.add_switch("s9")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt7")
- switch.add_link(tgen.gears["rt7"], nodeif="eth-rt4")
- switch = tgen.add_switch("s10")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt7")
- switch.add_link(tgen.gears["rt7"], nodeif="eth-rt5")
- switch = tgen.add_switch("s11")
- switch.add_link(tgen.gears["rt6"], nodeif="eth-rt7")
- switch.add_link(tgen.gears["rt7"], nodeif="eth-rt6")
-
- #
- # Populate multi-dimensional dictionary containing all expected outputs
- #
- files = ["show_ipv6_route.ref", "show_yang_interface_isis_adjacencies.ref"]
- for rname in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6", "rt7"]:
- outputs[rname] = {}
- for step in range(1, 13 + 1):
- outputs[rname][step] = {}
- for file in files:
- if step == 1:
- # Get snapshots relative to the expected initial network convergence
- filename = "{}/{}/step{}/{}".format(CWD, rname, step, file)
- outputs[rname][step][file] = open(filename).read()
- else:
- if rname != "rt1":
- continue
- if file == "show_yang_interface_isis_adjacencies.ref":
- continue
-
- # Get diff relative to the previous step
- filename = "{}/{}/step{}/{}.diff".format(CWD, rname, step, file)
-
- # Create temporary files in order to apply the diff
- f_in = tempfile.NamedTemporaryFile()
- f_in.write(outputs[rname][step - 1][file])
- f_in.flush()
- f_out = tempfile.NamedTemporaryFile()
- os.system(
- "patch -s -o %s %s %s" % (f_out.name, f_in.name, filename)
- )
-
- # Store the updated snapshot and remove the temporary files
- outputs[rname][step][file] = open(f_out.name).read()
- f_in.close()
- f_out.close()
+def build_topo(tgen):
+ "Build function"
+
+ #
+ # Define FRR Routers
+ #
+ for router in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6", "rt7"]:
+ tgen.add_router(router)
+
+ #
+ # Define connections
+ #
+ switch = tgen.add_switch("s1")
+ switch.add_link(tgen.gears["rt1"], nodeif="eth-rt2")
+ switch.add_link(tgen.gears["rt2"], nodeif="eth-rt1")
+ switch = tgen.add_switch("s2")
+ switch.add_link(tgen.gears["rt2"], nodeif="eth-rt3")
+ switch.add_link(tgen.gears["rt3"], nodeif="eth-rt2")
+ switch = tgen.add_switch("s3")
+ switch.add_link(tgen.gears["rt1"], nodeif="eth-rt3")
+ switch.add_link(tgen.gears["rt3"], nodeif="eth-rt1")
+ switch = tgen.add_switch("s4")
+ switch.add_link(tgen.gears["rt1"], nodeif="eth-rt4")
+ switch.add_link(tgen.gears["rt4"], nodeif="eth-rt1")
+ switch = tgen.add_switch("s5")
+ switch.add_link(tgen.gears["rt1"], nodeif="eth-rt5")
+ switch.add_link(tgen.gears["rt5"], nodeif="eth-rt1")
+ switch = tgen.add_switch("s6")
+ switch.add_link(tgen.gears["rt1"], nodeif="eth-rt6")
+ switch.add_link(tgen.gears["rt6"], nodeif="eth-rt1")
+ switch = tgen.add_switch("s7")
+ switch.add_link(tgen.gears["rt2"], nodeif="eth-rt7")
+ switch.add_link(tgen.gears["rt7"], nodeif="eth-rt2")
+ switch = tgen.add_switch("s8")
+ switch.add_link(tgen.gears["rt3"], nodeif="eth-rt7")
+ switch.add_link(tgen.gears["rt7"], nodeif="eth-rt3")
+ switch = tgen.add_switch("s9")
+ switch.add_link(tgen.gears["rt4"], nodeif="eth-rt7")
+ switch.add_link(tgen.gears["rt7"], nodeif="eth-rt4")
+ switch = tgen.add_switch("s10")
+ switch.add_link(tgen.gears["rt5"], nodeif="eth-rt7")
+ switch.add_link(tgen.gears["rt7"], nodeif="eth-rt5")
+ switch = tgen.add_switch("s11")
+ switch.add_link(tgen.gears["rt6"], nodeif="eth-rt7")
+ switch.add_link(tgen.gears["rt7"], nodeif="eth-rt6")
+
+ #
+ # Populate multi-dimensional dictionary containing all expected outputs
+ #
+ files = ["show_ipv6_route.ref", "show_yang_interface_isis_adjacencies.ref"]
+ for rname in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6", "rt7"]:
+ outputs[rname] = {}
+ for step in range(1, 13 + 1):
+ outputs[rname][step] = {}
+ for file in files:
+ if step == 1:
+ # Get snapshots relative to the expected initial network convergence
+ filename = "{}/{}/step{}/{}".format(CWD, rname, step, file)
+ outputs[rname][step][file] = open(filename).read()
+ else:
+ if rname != "rt1":
+ continue
+ if file == "show_yang_interface_isis_adjacencies.ref":
+ continue
+
+ # Get diff relative to the previous step
+ filename = "{}/{}/step{}/{}.diff".format(CWD, rname, step, file)
+
+ # Create temporary files in order to apply the diff
+ f_in = tempfile.NamedTemporaryFile(mode="w")
+ f_in.write(outputs[rname][step - 1][file])
+ f_in.flush()
+ f_out = tempfile.NamedTemporaryFile(mode="r")
+ os.system(
+ "patch -s -o %s %s %s" % (f_out.name, f_in.name, filename)
+ )
+
+ # Store the updated snapshot and remove the temporary files
+ outputs[rname][step][file] = open(f_out.name).read()
+ f_in.close()
+ f_out.close()
def setup_module(mod):
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.isisd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.isisd, pytest.mark.ldpd]
outputs = {}
-class TemplateTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- #
- # Define FRR Routers
- #
- for router in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6", "rt7", "rt8"]:
- tgen.add_router(router)
-
- #
- # Define connections
- #
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt2")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt1")
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-rt3")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt1")
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt4")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt2")
- switch = tgen.add_switch("s4")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt5")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt3")
- switch = tgen.add_switch("s5")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt6")
- switch.add_link(tgen.gears["rt6"], nodeif="eth-rt4")
- switch = tgen.add_switch("s6")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt7")
- switch.add_link(tgen.gears["rt7"], nodeif="eth-rt5")
- switch = tgen.add_switch("s7")
- switch.add_link(tgen.gears["rt6"], nodeif="eth-rt8")
- switch.add_link(tgen.gears["rt8"], nodeif="eth-rt6")
- switch = tgen.add_switch("s8")
- switch.add_link(tgen.gears["rt7"], nodeif="eth-rt8")
- switch.add_link(tgen.gears["rt8"], nodeif="eth-rt7")
-
- #
- # Populate multi-dimensional dictionary containing all expected outputs
- #
- files = [
- "show_ip_route.ref",
- "show_ipv6_route.ref",
- "show_yang_interface_isis_adjacencies.ref",
- ]
- for rname in ["rt1"]:
- outputs[rname] = {}
- for step in range(1, 10 + 1):
- outputs[rname][step] = {}
- for file in files:
- if step == 1:
- # Get snapshots relative to the expected initial network convergence
- filename = "{}/{}/step{}/{}".format(CWD, rname, step, file)
- outputs[rname][step][file] = open(filename).read()
- else:
- if file == "show_yang_interface_isis_adjacencies.ref":
- continue
-
- # Get diff relative to the previous step
- filename = "{}/{}/step{}/{}.diff".format(CWD, rname, step, file)
-
- # Create temporary files in order to apply the diff
- f_in = tempfile.NamedTemporaryFile()
- f_in.write(outputs[rname][step - 1][file])
- f_in.flush()
- f_out = tempfile.NamedTemporaryFile()
- os.system(
- "patch -s -o %s %s %s" % (f_out.name, f_in.name, filename)
- )
-
- # Store the updated snapshot and remove the temporary files
- outputs[rname][step][file] = open(f_out.name).read()
- f_in.close()
- f_out.close()
+def build_topo(tgen):
+ "Build function"
+
+ #
+ # Define FRR Routers
+ #
+ for router in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6", "rt7", "rt8"]:
+ tgen.add_router(router)
+
+ #
+ # Define connections
+ #
+ switch = tgen.add_switch("s1")
+ switch.add_link(tgen.gears["rt1"], nodeif="eth-rt2")
+ switch.add_link(tgen.gears["rt2"], nodeif="eth-rt1")
+ switch = tgen.add_switch("s2")
+ switch.add_link(tgen.gears["rt1"], nodeif="eth-rt3")
+ switch.add_link(tgen.gears["rt3"], nodeif="eth-rt1")
+ switch = tgen.add_switch("s3")
+ switch.add_link(tgen.gears["rt2"], nodeif="eth-rt4")
+ switch.add_link(tgen.gears["rt4"], nodeif="eth-rt2")
+ switch = tgen.add_switch("s4")
+ switch.add_link(tgen.gears["rt3"], nodeif="eth-rt5")
+ switch.add_link(tgen.gears["rt5"], nodeif="eth-rt3")
+ switch = tgen.add_switch("s5")
+ switch.add_link(tgen.gears["rt4"], nodeif="eth-rt6")
+ switch.add_link(tgen.gears["rt6"], nodeif="eth-rt4")
+ switch = tgen.add_switch("s6")
+ switch.add_link(tgen.gears["rt5"], nodeif="eth-rt7")
+ switch.add_link(tgen.gears["rt7"], nodeif="eth-rt5")
+ switch = tgen.add_switch("s7")
+ switch.add_link(tgen.gears["rt6"], nodeif="eth-rt8")
+ switch.add_link(tgen.gears["rt8"], nodeif="eth-rt6")
+ switch = tgen.add_switch("s8")
+ switch.add_link(tgen.gears["rt7"], nodeif="eth-rt8")
+ switch.add_link(tgen.gears["rt8"], nodeif="eth-rt7")
+
+ #
+ # Populate multi-dimensional dictionary containing all expected outputs
+ #
+ files = [
+ "show_ip_route.ref",
+ "show_ipv6_route.ref",
+ "show_yang_interface_isis_adjacencies.ref",
+ ]
+ for rname in ["rt1"]:
+ outputs[rname] = {}
+ for step in range(1, 10 + 1):
+ outputs[rname][step] = {}
+ for file in files:
+ if step == 1:
+ # Get snapshots relative to the expected initial network convergence
+ filename = "{}/{}/step{}/{}".format(CWD, rname, step, file)
+ outputs[rname][step][file] = open(filename).read()
+ else:
+ if file == "show_yang_interface_isis_adjacencies.ref":
+ continue
+
+ # Get diff relative to the previous step
+ filename = "{}/{}/step{}/{}.diff".format(CWD, rname, step, file)
+
+ # Create temporary files in order to apply the diff
+ f_in = tempfile.NamedTemporaryFile(mode="w")
+ f_in.write(outputs[rname][step - 1][file])
+ f_in.flush()
+ f_out = tempfile.NamedTemporaryFile(mode="r")
+ os.system(
+ "patch -s -o %s %s %s" % (f_out.name, f_in.name, filename)
+ )
+
+ # Store the updated snapshot and remove the temporary files
+ outputs[rname][step][file] = open(f_out.name).read()
+ f_in.close()
+ f_out.close()
def setup_module(mod):
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
from lib.snmptest import SnmpTester
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.isisd, pytest.mark.ldpd, pytest.mark.snmp]
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
assert r1_snmp.test_oid("isisSysVersion", "one(1)")
assert r1_snmp.test_oid("isisSysMaxAge", "1200 seconds")
assert r1_snmp.test_oid("isisSysProtSupported", "07 5 6 7")
- r2 = tgen.net.get("r2")
+ r2 = tgen.gears["r2"]
r2_snmp = SnmpTester(r2, "2.2.2.2", "public", "2c")
assert r2_snmp.test_oid("isisSysVersion", "one(1)")
def test_r1_isisCircTable():
tgen = get_topogen()
- r1 = tgen.net.get("r1")
- r1r = tgen.gears["r1"]
-
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
oids = []
def test_r1_isislevelCircTable():
tgen = get_topogen()
- r1 = tgen.net.get("r1")
- r1r = tgen.gears["r1"]
-
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
oids = []
def test_r1_isisAdjTable():
"check ISIS Adjacency Table"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
- r1_cmd = tgen.gears["r1"]
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
oids = []
# shutdown interface and one adjacency should be removed
"check ISIS adjacency is removed when interface is shutdown"
- r1_cmd.vtysh_cmd("conf t\ninterface r1-eth1\nshutdown")
+ r1.vtysh_cmd("conf t\ninterface r1-eth1\nshutdown")
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
for item in adjtable_down_test.keys():
), assertmsg
# no shutdown interface and adjacency should be restored
- r1_cmd.vtysh_cmd("conf t\ninterface r1-eth1\nno shutdown")
+ r1.vtysh_cmd("conf t\ninterface r1-eth1\nno shutdown")
# Memory leak test template
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.isisd, pytest.mark.pathd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.isisd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.isisd]
outputs = {}
-class TemplateTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- #
- # Define FRR Routers
- #
- for router in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6"]:
- tgen.add_router(router)
-
- #
- # Define connections
- #
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["rt1"], nodeif="eth-sw1")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-sw1")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-sw1")
-
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt4-1")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt2-1")
-
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["rt2"], nodeif="eth-rt4-2")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt2-2")
-
- switch = tgen.add_switch("s4")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt5-1")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt3-1")
-
- switch = tgen.add_switch("s5")
- switch.add_link(tgen.gears["rt3"], nodeif="eth-rt5-2")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt3-2")
-
- switch = tgen.add_switch("s6")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt5")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt4")
-
- switch = tgen.add_switch("s7")
- switch.add_link(tgen.gears["rt4"], nodeif="eth-rt6")
- switch.add_link(tgen.gears["rt6"], nodeif="eth-rt4")
-
- switch = tgen.add_switch("s8")
- switch.add_link(tgen.gears["rt5"], nodeif="eth-rt6")
- switch.add_link(tgen.gears["rt6"], nodeif="eth-rt5")
-
- #
- # Populate multi-dimensional dictionary containing all expected outputs
- #
- files = [
- "show_ip_route.ref",
- "show_ipv6_route.ref",
- "show_mpls_table.ref",
- "show_yang_interface_isis_adjacencies.ref",
- ]
- for rname in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6"]:
- outputs[rname] = {}
- for step in range(1, 9 + 1):
- outputs[rname][step] = {}
- for file in files:
- if step == 1:
- # Get snapshots relative to the expected initial network convergence
- filename = "{}/{}/step{}/{}".format(CWD, rname, step, file)
- outputs[rname][step][file] = open(filename).read()
- else:
- if file == "show_yang_interface_isis_adjacencies.ref":
- continue
-
- # Get diff relative to the previous step
- filename = "{}/{}/step{}/{}.diff".format(CWD, rname, step, file)
-
- # Create temporary files in order to apply the diff
- f_in = tempfile.NamedTemporaryFile()
- f_in.write(outputs[rname][step - 1][file])
- f_in.flush()
- f_out = tempfile.NamedTemporaryFile()
- os.system(
- "patch -s -o %s %s %s" % (f_out.name, f_in.name, filename)
- )
-
- # Store the updated snapshot and remove the temporary files
- outputs[rname][step][file] = open(f_out.name).read()
- f_in.close()
- f_out.close()
+def build_topo(tgen):
+ "Build function"
+
+ #
+ # Define FRR Routers
+ #
+ for router in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6"]:
+ tgen.add_router(router)
+
+ #
+ # Define connections
+ #
+ switch = tgen.add_switch("s1")
+ switch.add_link(tgen.gears["rt1"], nodeif="eth-sw1")
+ switch.add_link(tgen.gears["rt2"], nodeif="eth-sw1")
+ switch.add_link(tgen.gears["rt3"], nodeif="eth-sw1")
+
+ switch = tgen.add_switch("s2")
+ switch.add_link(tgen.gears["rt2"], nodeif="eth-rt4-1")
+ switch.add_link(tgen.gears["rt4"], nodeif="eth-rt2-1")
+
+ switch = tgen.add_switch("s3")
+ switch.add_link(tgen.gears["rt2"], nodeif="eth-rt4-2")
+ switch.add_link(tgen.gears["rt4"], nodeif="eth-rt2-2")
+
+ switch = tgen.add_switch("s4")
+ switch.add_link(tgen.gears["rt3"], nodeif="eth-rt5-1")
+ switch.add_link(tgen.gears["rt5"], nodeif="eth-rt3-1")
+
+ switch = tgen.add_switch("s5")
+ switch.add_link(tgen.gears["rt3"], nodeif="eth-rt5-2")
+ switch.add_link(tgen.gears["rt5"], nodeif="eth-rt3-2")
+
+ switch = tgen.add_switch("s6")
+ switch.add_link(tgen.gears["rt4"], nodeif="eth-rt5")
+ switch.add_link(tgen.gears["rt5"], nodeif="eth-rt4")
+
+ switch = tgen.add_switch("s7")
+ switch.add_link(tgen.gears["rt4"], nodeif="eth-rt6")
+ switch.add_link(tgen.gears["rt6"], nodeif="eth-rt4")
+
+ switch = tgen.add_switch("s8")
+ switch.add_link(tgen.gears["rt5"], nodeif="eth-rt6")
+ switch.add_link(tgen.gears["rt6"], nodeif="eth-rt5")
+
+ #
+ # Populate multi-dimensional dictionary containing all expected outputs
+ #
+ files = [
+ "show_ip_route.ref",
+ "show_ipv6_route.ref",
+ "show_mpls_table.ref",
+ "show_yang_interface_isis_adjacencies.ref",
+ ]
+ for rname in ["rt1", "rt2", "rt3", "rt4", "rt5", "rt6"]:
+ outputs[rname] = {}
+ for step in range(1, 9 + 1):
+ outputs[rname][step] = {}
+ for file in files:
+ if step == 1:
+ # Get snapshots relative to the expected initial network convergence
+ filename = "{}/{}/step{}/{}".format(CWD, rname, step, file)
+ outputs[rname][step][file] = open(filename).read()
+ else:
+ if file == "show_yang_interface_isis_adjacencies.ref":
+ continue
+
+ # Get diff relative to the previous step
+ filename = "{}/{}/step{}/{}.diff".format(CWD, rname, step, file)
+
+ # Create temporary files in order to apply the diff
+ f_in = tempfile.NamedTemporaryFile(mode="w")
+ f_in.write(outputs[rname][step - 1][file])
+ f_in.flush()
+ f_out = tempfile.NamedTemporaryFile(mode="r")
+ os.system(
+ "patch -s -o %s %s %s" % (f_out.name, f_in.name, filename)
+ )
+
+ # Store the updated snapshot and remove the temporary files
+ outputs[rname][step][file] = open(f_out.name).read()
+ f_in.close()
+ f_out.close()
def setup_module(mod):
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.isisd]
from lib.topotest import iproute2_is_vrf_capable
from lib.common_config import required_linux_kernel_version
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.isisd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ldpd, pytest.mark.ospfd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ldpd, pytest.mark.ospfd]
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
\ No newline at end of file
from lib.snmptest import SnmpTester
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ldpd, pytest.mark.isisd, pytest.mark.snmp]
"Test mplsLdpLsrObjects objects"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
assert r1_snmp.test_oid("mplsLdpLsrId", "01 01 01 01")
"Test mplsLdpEntityTable"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
assert r1_snmp.test_oid_walk("mplsLdpEntityLdpId", ["1.1.1.1:0"])
"Test mplsLdpEntityStatsTable"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
assert r1_snmp.test_oid_walk("mplsLdpEntityStatsSessionAttempts", ["0"])
"Test mplsLdpPeerTable"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
assert r1_snmp.test_oid_walk("mplsLdpPeerLdpId", ["2.2.2.2:0", "3.3.3.3:0"])
"Test mplsLdpSessionTable"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
assert r1_snmp.test_oid_walk(
"Test mplsLdpSessionStatsTable"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
assert r1_snmp.test_oid_walk("mplsLdpSessionStatsUnknownMesTypeErrors", ["0", "0"])
"Test mplsLdpHelloAdjacencyTable"
tgen = get_topogen()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
assert r1_snmp.test_oid_walk("mplsLdpHelloAdjacencyIndex", ["1", "2", "1"])
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.isisd, pytest.mark.ldpd]
interface = {}
interface_name = None
- line = it.next()
+ line = next(it)
if line.startswith(rname + "-eth"):
interface_name = line
- line = it.next()
+ line = next(it)
if line.startswith(" LDP-IGP Synchronization enabled: "):
interface["ldpIgpSyncEnabled"] = line.endswith("yes")
- line = it.next()
+ line = next(it)
if line.startswith(" holddown timer in seconds: "):
interface["holdDownTimeInSec"] = int(line.split(": ")[-1])
- line = it.next()
+ line = next(it)
if line.startswith(" State: "):
interface["ldpIgpSyncState"] = line.split(": ")[-1]
while True:
try:
- line = it.next()
+ line = next(it)
area_match = re.match(r"Area (.+):", line)
if not area_match:
area_id = area_match.group(1)
area = {}
- line = it.next()
+ line = next(it)
while line.startswith(" Interface: "):
interface_name = re.split(":|,", line)[1].lstrip()
# Look for keyword: Level-1 or Level-2
while not line.startswith(" Level-"):
- line = it.next()
+ line = next(it)
while line.startswith(" Level-"):
level_name = line.split()[0]
level["level"] = level_name
- line = it.next()
+ line = next(it)
if line.startswith(" Metric:"):
level["metric"] = re.split(":|,", line)[1].lstrip()
while not line.startswith(" Level-") and not line.startswith(
" Interface: "
):
- line = it.next()
+ line = next(it)
if line.startswith(" Level-"):
continue
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ldpd, pytest.mark.ospfd]
import pytest
from time import sleep
-from mininet.topo import Topo
-from mininet.net import Mininet
-from mininet.node import Node, OVSSwitch, Host
-from mininet.log import setLogLevel, info
-from mininet.cli import CLI
-from mininet.link import Intf
-
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from lib import topotest
+from lib.micronet_compat import Topo
+from lib.micronet_compat import Mininet
fatal_error = ""
# Setup Switches, add Interfaces and Connections
switch = {}
# First switch
- switch[0] = self.addSwitch("sw0", cls=topotest.LegacySwitch)
+ switch[0] = self.addSwitch("sw0")
self.addLink(
switch[0],
router[1],
addr2="00:11:00:02:00:00",
)
# Second switch
- switch[1] = self.addSwitch("sw1", cls=topotest.LegacySwitch)
+ switch[1] = self.addSwitch("sw1")
self.addLink(
switch[1],
router[2],
addr2="00:11:00:04:00:00",
)
# Third switch
- switch[2] = self.addSwitch("sw2", cls=topotest.LegacySwitch)
+ switch[2] = self.addSwitch("sw2")
self.addLink(
switch[2],
router[2],
if __name__ == "__main__":
- setLogLevel("info")
# To suppress tracebacks, either use the following pytest call or add "--tb=no" to cli
# retval = pytest.main(["-s", "--tb=no"])
retval = pytest.main(["-s"])
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ldpd, pytest.mark.ospfd]
from lib.lutil import *
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
customize = None
import time
from lib.topolog import logger
from lib.topotest import json_cmp
-from mininet.net import Mininet
+from lib.micronet_compat import Mininet
# L utility functions
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib import topotest
+# Required to instantiate the topology builder class.
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.ospfd, pytest.mark.pimd]
# Test global variables:
# They are used to handle communicating with external application.
#
-APP_SOCK_PATH = '/tmp/topotests/apps.sock'
HELPER_APP_PATH = os.path.join(CWD, "../lib/mcast-tester.py")
app_listener = None
app_clients = {}
+app_procs = []
+
+
+def get_app_sock_path():
+ tgen = get_topogen()
+ return os.path.join(tgen.logdir, "apps.sock")
+
def listen_to_applications():
"Start listening socket to connect with applications."
# Remove old socket.
+ app_sock_path = get_app_sock_path()
try:
- os.unlink(APP_SOCK_PATH)
+ os.unlink(app_sock_path)
except OSError:
pass
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, 0)
- sock.bind(APP_SOCK_PATH)
+ sock.bind(app_sock_path)
sock.listen(10)
global app_listener
app_listener = sock
# Close listening socket.
app_listener.close()
+ app_sock_path = get_app_sock_path()
+
# Remove old socket.
try:
- os.unlink(APP_SOCK_PATH)
+ os.unlink(app_sock_path)
except OSError:
pass
continue
app_clients["h1"]["fd"].close()
+ for p in app_procs:
+ p.terminate()
+ p.wait()
+
class MSDPMeshTopo1(Topo):
"Test topology builder"
switch.add_link(tgen.gears["r3"])
# Create stub networks for multicast traffic.
- tgen.add_host("h1", "192.168.10.2/24", "192.168.10.1")
+ tgen.add_host("h1", "192.168.10.2/24", "via 192.168.10.1")
switch = tgen.add_switch("s3")
switch.add_link(tgen.gears["r1"])
switch.add_link(tgen.gears["h1"])
- tgen.add_host("h2", "192.168.30.2/24", "192.168.30.1")
+ tgen.add_host("h2", "192.168.30.2/24", "via 192.168.30.1")
switch = tgen.add_switch("s4")
switch.add_link(tgen.gears["r3"])
switch.add_link(tgen.gears["h2"])
logger.info("test MSDP convergence")
- tgen.gears["h1"].run("{} --send='0.7' '{}' '{}' '{}' &".format(
- HELPER_APP_PATH, APP_SOCK_PATH, '229.0.1.10', 'h1-eth0'))
- accept_host("h1")
-
- tgen.gears["h2"].run("{} '{}' '{}' '{}' &".format(
- HELPER_APP_PATH, APP_SOCK_PATH, '229.0.1.10', 'h2-eth0'))
- accept_host("h2")
-
def expect_msdp_peer(router, peer, sa_count=0):
"Expect MSDP peer connection to be established with SA amount."
logger.info("waiting MSDP connection from peer {} on router {}".format(peer, router))
assertmsg = '"{}" MSDP connection failure'.format(router)
assert result is None, assertmsg
+ app_sock_path = get_app_sock_path()
+
+
+ python3_path = tgen.net.get_exec_path(["python3", "python"])
+ ph_base = [python3_path, HELPER_APP_PATH, app_sock_path]
+
+ ph1_cmd = ph_base + ["--send=0.7", "229.0.1.10", "h1-eth0"]
+ ph1 = tgen.gears["h1"].popen(ph1_cmd)
+ app_procs.append(ph1)
+ accept_host("h1")
+
+ ph2_cmd = ph_base + ["229.0.1.10", "h2-eth0"]
+ ph2 = tgen.gears["h2"].popen(ph2_cmd)
+ app_procs.append(ph2)
+ accept_host("h2")
+
# R1 peers.
expect_msdp_peer("r1", "10.254.254.2")
expect_msdp_peer("r1", "10.254.254.3")
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib import topotest
+# Required to instantiate the topology builder class.
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.pimd]
# Test global variables:
# They are used to handle communicating with external application.
#
-APP_SOCK_PATH = '/tmp/topotests/apps.sock'
HELPER_APP_PATH = os.path.join(CWD, "../lib/mcast-tester.py")
app_listener = None
app_clients = {}
+def get_app_sock_path():
+ tgen = get_topogen()
+ return os.path.join(tgen.logdir, "apps.sock")
+
+
def listen_to_applications():
"Start listening socket to connect with applications."
+
+ app_sock_path = get_app_sock_path()
# Remove old socket.
try:
- os.unlink(APP_SOCK_PATH)
+ os.unlink(app_sock_path)
except OSError:
pass
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, 0)
- sock.bind(APP_SOCK_PATH)
+ # Do not block forever
+ sock.settimeout(10)
+ sock.bind(app_sock_path)
sock.listen(10)
global app_listener
app_listener = sock
# Close listening socket.
app_listener.close()
+ app_sock_path = get_app_sock_path()
# Remove old socket.
try:
- os.unlink(APP_SOCK_PATH)
+ os.unlink(app_sock_path)
except OSError:
pass
switch.add_link(tgen.gears["r4"])
# Create a host connected and direct at r4:
- tgen.add_host("h1", "192.168.4.100/24", "192.168.4.1")
+ tgen.add_host("h1", "192.168.4.100/24", "via 192.168.4.1")
switch.add_link(tgen.gears["h1"])
# Create a host connected and direct at r1:
switch = tgen.add_switch("s6")
- tgen.add_host("h2", "192.168.10.100/24", "192.168.10.1")
+ tgen.add_host("h2", "192.168.10.100/24", "via 192.168.10.1")
switch.add_link(tgen.gears["r1"])
switch.add_link(tgen.gears["h2"])
expect_loopback_route("r4", "ip", "10.254.254.2/32", "bgp")
expect_loopback_route("r4", "ip", "10.254.254.3/32", "bgp")
-
-def test_mroute_install():
+def _test_mroute_install():
"Test that multicast routes propagated and installed"
tgen = get_topogen()
if tgen.routers_have_failure():
pytest.skip(tgen.errors)
- tgen.gears["h1"].run("{} '{}' '{}' '{}' &".format(
- HELPER_APP_PATH, APP_SOCK_PATH, '229.1.2.3', 'h1-eth0'))
- accept_host("h1")
-
- tgen.gears["h2"].run("{} --send='0.7' '{}' '{}' '{}' &".format(
- HELPER_APP_PATH, APP_SOCK_PATH, '229.1.2.3', 'h2-eth0'))
- accept_host("h2")
-
#
# Test R1 mroute
#
_, val = topotest.run_and_expect(test_func, None, count=55, wait=2)
assert val is None, 'multicast route convergence failure'
+def test_mroute_install():
+ tgen = get_topogen()
+ # pytest.skip("FOO")
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
+ ph1 = ph2 = None
+
+ app_sock_path = get_app_sock_path()
+ try:
+ logger.info("Starting helper1")
+ ph1 = tgen.gears["h1"].popen(
+ "{} '{}' '{}' '{}'".format(
+ HELPER_APP_PATH, app_sock_path, "229.1.2.3", "h1-eth0"
+ )
+ )
+ logger.info("Accepting helper1")
+ accept_host("h1")
+
+ logger.info("Starting helper2")
+ ph2 = tgen.gears["h2"].popen(
+ "{} --send='0.7' '{}' '{}' '{}'".format(
+ HELPER_APP_PATH, app_sock_path, "229.1.2.3", "h2-eth0"
+ )
+ )
+ accept_host("h2")
+
+ _test_mroute_install()
+ finally:
+ if ph1:
+ ph1.terminate()
+ ph1.wait()
+ ph2.terminate()
+ ph2.wait()
def test_msdp():
"""
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
tgen = get_topogen()
+ # Kill any iperfs we left running.
+ kill_iperf(tgen)
+
# Stop toplogy and Remove tmp files
tgen.stop_topology()
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
step("pre-configure BSM packet")
step("Configure cisco-1 as BSR1 1.1.2.7")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
step("pre-configure BSM packet")
step("Configure cisco-1 as BSR1 1.1.2.7")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
result = pre_config_to_bsm(
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
result = pre_config_to_bsm(
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
result = pre_config_to_bsm(
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
result = pre_config_to_bsm(
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
result = pre_config_to_bsm(
tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
)
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
result = pre_config_to_bsm(
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
tgen = get_topogen()
+ # Kill any iperfs we left running.
+ kill_iperf(tgen)
+
# Stop toplogy and Remove tmp files
tgen.stop_topology()
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
result = pre_config_to_bsm(
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
result = pre_config_to_bsm(
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
result = pre_config_to_bsm(
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
reset_config_on_routers(tgen)
result = pre_config_to_bsm(
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
reset_config_on_routers(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
result = pre_config_to_bsm(
tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
)
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
step("pre-configure BSM packet")
result = pre_config_to_bsm(
tgen, topo, tc_name, "b1", "s1", "r1", "f1", "i1", "l1", "packet1"
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
Description:
i1, i2, i3. i4, i5, i6, i7, i8 - FRR running iperf to send IGMP
join and traffic
- l1 - LHR
- f1 - FHR
+ l1 - LHR (last hop router)
+ f1 - FHR (first hop router)
r2 - FRR router
c1 - FRR router
c2 - FRR router
pytest.skip(tgen.errors)
# Creating configuration from JSON
- build_config_from_json(tgen, topo)
+ build_config_from_json(tgen, tgen.json_topo)
logger.info("Running setup_module() done")
tgen = get_topogen()
+ # Kill any iperfs we left running.
+ kill_iperf(tgen)
+
# Stop toplogy and Remove tmp files
tgen.stop_topology()
result = addKernelRoute(tgen, iperf, iperf_intf, GROUP_RANGE)
assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
- router_list = tgen.routers()
- for router in router_list.keys():
- if router == iperf:
- continue
-
- rnode = router_list[router]
- rnode.run("echo 2 > /proc/sys/net/ipv4/conf/all/rp_filter")
+ rnode = tgen.gears[iperf]
+ rnode.run("echo 2 > /proc/sys/net/ipv4/conf/all/rp_filter")
return True
"""
tgen = get_topogen()
+ topo = tgen.json_topo
tc_name = request.node.name
write_test_header(tc_name)
step("Enable IGMP on FRR1 interface and send IGMP join (225.1.1.1)")
intf_i1_l1 = topo["routers"]["i1"]["links"]["l1"]["interface"]
- result = config_to_send_igmp_join_and_traffic(
- tgen, topo, tc_name, "i1", intf_i1_l1, GROUP_RANGE, join=True
- )
- assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
step("joinRx value before join sent")
intf_r2_l1 = topo["routers"]["r2"]["links"]["l1"]["interface"]
), "Testcase {} : Failed \n state_before is not dictionary \n "
"Error: {}".format(tc_name, result)
- result = iperfSendIGMPJoin(tgen, "i1", IGMP_JOIN, join_interval=1)
+ result = iperfSendIGMPJoin(tgen, "i1", ["{}%{}".format(IGMP_JOIN, intf_i1_l1)], join_interval=1)
assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
step("Send the IGMP join first and then start the traffic")
assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
step("Send multicast traffic from FRR3 to 225.1.1.1 receiver")
- intf_i2_f1 = topo["routers"]["i2"]["links"]["f1"]["interface"]
- result = config_to_send_igmp_join_and_traffic(
- tgen, topo, tc_name, "i2", intf_i2_f1, GROUP_RANGE, traffic=True
- )
- assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
-
- result = iperfSendTraffic(tgen, "i2", IGMP_JOIN, 32, 2500)
+ result = iperfSendTraffic(tgen, "i2", IGMP_JOIN, 32, 2500, bindToIntf="f1")
assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
step(
"""
tgen = get_topogen()
+ topo = tgen.json_topo
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure RP on R2 (loopback interface) for the" " group range 225.0.0.0/8")
input_dict = {
"""
tgen = get_topogen()
+ topo = tgen.json_topo
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP on c1 for group (225.1.1.1-5)")
input_dict = {
"c1": {
"""
tgen = get_topogen()
+ topo = tgen.json_topo
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure RP on R2 (loopback interface) for the" " group range 225.0.0.0/8")
input_dict = {
step("IGMP is received on FRR1 , FRR2 , FRR3, using " "'show ip igmp groups'")
igmp_groups = {"l1": "l1-i1-eth1", "r2": "r2-i3-eth1", "f1": "f1-i8-eth2"}
for dut, interface in igmp_groups.items():
- result = verify_igmp_groups(tgen, dut, interface, IGMP_JOIN)
+ result = verify_igmp_groups(tgen, dut, interface, IGMP_JOIN, retry_timeout=80)
assert result is True, "Testcase {} : Failed Error: {}".format(tc_name, result)
step("(*,G) present on all the node with correct OIL" " using 'show ip mroute'")
"""
tgen = get_topogen()
+ topo = tgen.json_topo
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP for (226.1.1.1-5) and (232.1.1.1-5)" " in c1")
_GROUP_RANGE = GROUP_RANGE_2 + GROUP_RANGE_3
"""
tgen = get_topogen()
+ topo = tgen.json_topo
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP for (226.1.1.1-5) in c2")
input_dict = {
"c2": {
"""
tgen = get_topogen()
+ topo = tgen.json_topo
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure RP on FRR2 (loopback interface) for " "the group range 225.0.0.0/8")
input_dict = {
"""
tgen = get_topogen()
+ topo = tgen.json_topo
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Enable IGMP on FRR1 interface and send IGMP join (225.1.1.1)")
result = config_to_send_igmp_join_and_traffic(
tgen, topo, tc_name, "i1", "i1-l1-eth0", GROUP_RANGE, join=True
"""
tgen = get_topogen()
+ topo = tgen.json_topo
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Enable IGMP on FRR1 interface and send IGMP join (225.1.1.1)")
result = config_to_send_igmp_join_and_traffic(
tgen, topo, tc_name, "i1", "i1-l1-eth0", GROUP_RANGE, join=True
result = iperfSendIGMPJoin(tgen, "i1", IGMP_JOIN, join_interval=1)
assert result is True, "Testcase {}: Failed Error: {}".format(tc_name, result)
- step("Configure IGMP query response time to 10 sec on FRR1")
+ step("Configure IGMP query response time to 10 deci-sec on FRR1")
input_dict_1 = {
"l1": {
"igmp": {
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
tgen = get_topogen()
+ # Kill any iperfs we left running.
+ kill_iperf(tgen)
+
# Stop toplogy and Remove tmp files
tgen.stop_topology()
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP for (226.1.1.1-5) in c1")
step("Configure static RP for (232.1.1.1-5) in c2")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP for (226.1.1.1-5) in c1")
step("Configure static RP for (232.1.1.1-5) in c2")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP for (226.1.1.1-5) and " "(232.1.1.1-5) in c2")
_GROUP_RANGE = GROUP_RANGE_2 + GROUP_RANGE_3
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP for (226.1.1.1-5) in c1")
step("Configure static RP for (232.1.1.1-5) in c2")
intf_l1_c1 = "l1-c1-eth0"
shutdown_bringup_interface(tgen, dut, intf_l1_c1, False)
- done_flag = False
- for retry in range(1, 11):
- result = verify_upstream_iif(
- tgen, "l1", "Unknown", source, IGMP_JOIN_RANGE_2, expected=False
- )
- if result is not True:
- done_flag = True
- else:
- continue
- if done_flag:
- logger.info("Expected Behavior: {}".format(result))
- break
-
- assert done_flag is True, (
+ result = verify_upstream_iif(
+ tgen, "l1", "Unknown", source, IGMP_JOIN_RANGE_2, expected=False
+ )
+ assert result is not True, (
"Testcase {} : Failed Error: \n "
"mroutes are still present, after waiting for 10 mins".format(tc_name)
)
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP on c1 for group range " "(226.1.1.1-5) and (232.1.1.1-5)")
_GROUP_RANGE = GROUP_RANGE_2 + GROUP_RANGE_3
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP for group range (226.1.1.1-5) and " "(232.1.1.1-5) on c1")
_GROUP_RANGE = GROUP_RANGE_2 + GROUP_RANGE_3
_IGMP_JOIN_RANGE = IGMP_JOIN_RANGE_2 + IGMP_JOIN_RANGE_3
{"dut": "f1", "src_address": "*", "iif": "f1-c2-eth0", "oil": "f1-i8-eth2"},
{"dut": "l1", "src_address": "*", "iif": "l1-c1-eth0", "oil": "l1-i1-eth1"},
]
-
- done_flag = False
- for retry in range(1, 11):
- for data in input_dict:
- result = verify_ip_mroutes(
- tgen,
- data["dut"],
- data["src_address"],
- _IGMP_JOIN_RANGE,
- data["iif"],
- data["oil"],
- )
-
- if result is True:
- done_flag = True
- else:
- continue
-
- if done_flag:
- break
-
- assert done_flag is True, (
- "Testcase {} : Failed Error: \n "
- "mroutes are still present, after waiting for 10 mins".format(tc_name)
- )
+ for data in input_dict:
+ result = verify_ip_mroutes(
+ tgen,
+ data["dut"],
+ data["src_address"],
+ _IGMP_JOIN_RANGE,
+ data["iif"],
+ data["oil"],
+ )
+ assert result is True, (
+ "Testcase {} : Failed Error mroutes were flushed.".format(tc_name)
+ )
step(
"After traffic stopped , verify (S,G) entries are flushed out"
{"dut": "f1", "src_address": source, "iif": "i2-f1-eth0", "oil": "f1-r2-eth3"},
]
- done_flag = False
- for retry in range(1, 11):
- for data in input_dict:
- result = verify_ip_mroutes(
- tgen,
- data["dut"],
- data["src_address"],
- _IGMP_JOIN_RANGE,
- data["iif"],
- data["oil"],
- expected=False,
- )
- if result is not True:
- done_flag = True
- else:
- continue
-
- if done_flag:
- logger.info("Expected Behavior: {}".format(result))
- break
-
- assert done_flag is True, (
- "Testcase {} : Failed Error: \n "
- "mroutes are still present, after waiting for 10 mins".format(tc_name)
- )
+ for data in input_dict:
+ result = verify_ip_mroutes(
+ tgen,
+ data["dut"],
+ data["src_address"],
+ _IGMP_JOIN_RANGE,
+ data["iif"],
+ data["oil"],
+ expected=False,
+ )
+ assert result is not True, (
+ "Testcase {} : Failed Error: \nmroutes are still present".format(tc_name)
+ )
write_test_footer(tc_name)
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP for (226.1.1.1-5) in c1")
step("Configure static RP for (232.1.1.1-5) in c2")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure static RP for (226.1.1.1-5) in c1")
step("Configure static RP for (232.1.1.1-5) in c2")
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
from lib.common_config import (
start_topology,
SAME_VLAN_IP_2 = {"ip": "10.1.1.2", "subnet": "255.255.255.0", "cidr": "24"}
SAME_VLAN_IP_3 = {"ip": "10.1.1.3", "subnet": "255.255.255.0", "cidr": "24"}
SAME_VLAN_IP_4 = {"ip": "10.1.1.4", "subnet": "255.255.255.0", "cidr": "24"}
-TCPDUMP_FILE = "{}/{}".format(LOGDIR, "v2query.txt")
class CreateTopo(Topo):
tgen = get_topogen()
+ # Kill any iperfs we left running.
+ kill_iperf(tgen)
+
# Stop toplogy and Remove tmp files
tgen.stop_topology()
* `state_after` : State dictionary for any particular instance
"""
- for router, state_data in state_before.items():
- for state, value in state_data.items():
- if state_before[router][state] >= state_after[router][state]:
- errormsg = (
- "[DUT: %s]: state %s value has not"
- " incremented, Initial value: %s, "
- "Current value: %s [FAILED!!]"
- % (
- router,
- state,
- state_before[router][state],
- state_after[router][state],
+ for ttype, v1 in state_before.items():
+ for intf, v2 in v1.items():
+ for state, value in v2.items():
+ if value >= state_after[ttype][intf][state]:
+ errormsg = (
+ "[DUT: %s]: state %s value has not incremented, Initial value: %s, Current value: %s [FAILED!!]" % (
+ intf,
+ state,
+ value,
+ state_after[ttype][intf][state],
+ )
)
+ return errormsg
+
+ logger.info(
+ "[DUT: %s]: State %s value is incremented, Initial value: %s, Current value: %s [PASSED!!]",
+ intf,
+ state,
+ value,
+ state_after[ttype][intf][state],
)
- return errormsg
-
- logger.info(
- "[DUT: %s]: State %s value is "
- "incremented, Initial value: %s, Current value: %s"
- " [PASSED!!]",
- router,
- state,
- state_before[router][state],
- state_after[router][state],
- )
return True
"""
- filepath = os.path.join(LOGDIR, tgen.modname, router, cap_file)
+ filepath = os.path.join(tgen.logdir, router, cap_file)
with open(filepath) as f:
if len(re.findall("{}".format(message), f.read())) < count:
errormsg = "[DUT: %s]: Verify Message: %s in tcpdump" " [FAILED!!]" % (
"""
- filepath = os.path.join(LOGDIR, tgen.modname, router, cap_file)
+ filepath = os.path.join(tgen.logdir, router, cap_file)
with open(filepath) as f:
if len(re.findall(message, f.read())) < 1:
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Enable the PIM on all the interfaces of FRR1, FRR2, FRR3")
step(
"Enable IGMP of FRR1 interface and send IGMP joins "
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Removing FRR3 to simulate topo " "FHR(FRR1)---LHR(FRR2)")
intf_l1_c1 = topo["routers"]["l1"]["links"]["c1"]["interface"]
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Enable the PIM on all the interfaces of FRR1, R2 and FRR3" " routers")
step("Enable IGMP on FRR1 interface and send IGMP join " "(225.1.1.1-225.1.1.10)")
" 'show ip pim upstream' 'show ip mroute' "
)
- done_flag = False
- for retry in range(1, 11):
- result = verify_upstream_iif(
- tgen, "l1", "Unknown", source_i2, IGMP_JOIN_RANGE_1, expected=False
- )
- if result is not True:
- done_flag = True
- else:
- continue
- if done_flag:
- logger.info("Expected Behavior: {}".format(result))
- break
-
- assert done_flag is True, (
- "Testcase {} : Failed Error: \n "
- "mroutes are still present, after waiting for 10 mins".format(tc_name)
+ result = verify_upstream_iif(
+ tgen, "l1", "Unknown", source_i2, IGMP_JOIN_RANGE_1, expected=False
+ )
+ assert result is not True, (
+ "Testcase {} : Failed Error: \n mroutes are still present".format(tc_name)
)
step("No shut the Source interface just after the upstream is expired" " from FRR1")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Enable the PIM on all the interfaces of FRR1, R2 and FRR3" " routers")
step("Enable IGMP on FRR1 interface and send IGMP join " "(225.1.1.1-225.1.1.10)")
" 'show ip pim upstream' 'show ip mroute' "
)
- done_flag = False
- for retry in range(1, 11):
- result = verify_upstream_iif(
- tgen, "l1", "Unknown", source_i2, IGMP_JOIN_RANGE_1, expected=False
- )
- if result is not True:
- done_flag = True
- else:
- continue
- if done_flag:
- logger.info("Expected Behavior: {}".format(result))
- break
-
- assert done_flag is True, (
- "Testcase {} : Failed Error: \n "
- "mroutes are still present, after waiting for 10 mins".format(tc_name)
+ result = verify_upstream_iif(
+ tgen, "l1", "Unknown", source_i2, IGMP_JOIN_RANGE_1, expected=False
+ )
+ assert result is not True, (
+ "Testcase {} : Failed Error: \nmroutes are still present".format(tc_name)
)
step("No shut the Source interface just after the upstream is expired" " from FRR1")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Enable PIM on all routers")
step("Enable IGMP on FRR1 interface and send IGMP join " "(225.1.1.1-225.1.1.10)")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Enable PIM on all routers")
step("Enable IGMP on FRR1 interface and send IGMP join " "(225.1.1.1-225.1.1.10)")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure 'ip pim' on receiver interface on FRR1")
step("Enable PIM on all routers")
step("Enable IGMP on FRR1 interface and send IGMP join " "(225.1.1.1-225.1.1.10)")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure 'ip pim' on receiver interface on FRR1")
step("Enable PIM on all routers")
step("Enable IGMP on FRR1 interface and send IGMP join " "(225.1.1.1-225.1.1.10)")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step("Configure 'ip pim' on receiver interface on FRR1")
step("Enable PIM on all routers")
step("Enable IGMP on FRR1 interface and send IGMP join " "(225.1.1.1-225.1.1.10)")
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
step(
"Remove cisco connected link to simulate topo "
"LHR(FRR1(f1))----RP(cisco(f1)---FHR(FRR3(l1))"
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
step(
"Remove cisco connected link to simulate topo "
"LHR(FRR1(f1))----RP(cisco(f1)---FHR(FRR3(l1))"
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
step(
"Remove cisco connected link to simulate topo "
"LHR(FRR1(f1))----RP(cisco(f1)---FHR(FRR3(l1))"
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step(
"Remove FRR3 to cisco connected link to simulate topo "
"FHR(FRR3(l1))---LHR(FRR1(r2)----RP(FRR2(f1))"
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
check_router_status(tgen)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
-
step(
"Remove FRR3 to FRR2 connected link to simulate topo "
"FHR(FRR3)---LHR(FRR1)----RP(FFR2)"
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.common_config import (
start_topology,
tgen = get_topogen()
+ # Kill any iperfs we left running.
+ kill_iperf(tgen)
+
# Stop toplogy and Remove tmp files
tgen.stop_topology()
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
step(
"Remove c1-c2 connected link to simulate topo "
"c1(FHR)---l1(RP)----r2---f1-----c2(LHR)"
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
step(
"Remove c1-c2 connected link to simulate topo "
"c1(LHR)---l1(RP)----r2---f1-----c2(FHR)"
tc_name = request.node.name
write_test_header(tc_name)
+ # Don"t run this test if we have any failure.
+ if tgen.routers_have_failure():
+ pytest.skip(tgen.errors)
+
# Creating configuration from JSON
kill_iperf(tgen)
clear_ip_mroute(tgen)
reset_config_on_routers(tgen)
clear_ip_pim_interface_traffic(tgen, topo)
- # Don"t run this test if we have any failure.
- if tgen.routers_have_failure():
- pytest.skip(tgen.errors)
step(
"Remove c1-c2 connected link to simulate topo "
"c1(LHR)---l1(RP)----r2---f1-----c2(FHR)"
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
from lib.topolog import logger
tgen = get_topogen()
+ # Kill any iperfs we left running.
+ kill_iperf(tgen)
+
# Stop toplogy and Remove tmp files
tgen.stop_topology()
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.nhrpd]
from functools import partial
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Save the Current Working Directory to find configuration files later.
CWD = os.path.dirname(os.path.realpath(__file__))
from functools import partial
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Save the Current Working Directory to find configuration files later.
CWD = os.path.dirname(os.path.realpath(__file__))
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ospf6d]
def dont_expect_route(unexpected_route):
"Specialized test function to expect route go missing"
output = tgen.gears["r4"].vtysh_cmd("show ipv6 ospf6 route json", isjson=True)
- if output["routes"].has_key(unexpected_route):
+ if unexpected_route in output["routes"]:
return output["routes"][unexpected_route]
return None
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
import ipaddress
from time import sleep
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
import ipaddress
from time import sleep
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
from ipaddress import IPv4Address
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
)
from ipaddress import IPv4Address
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
import os
import sys
import time
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
import ipaddress
)
from lib.topolog import logger
from lib.topojson import build_topo_from_json, build_config_from_json
+from lib.topotest import frr_unicode
from lib.ospf import (
verify_ospf_neighbor,
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
import ipaddress
sys.path.append(os.path.join(CWD, "../"))
sys.path.append(os.path.join(CWD, "../lib/"))
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
from lib.common_config import (
)
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ospfd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.ospfd, pytest.mark.pathd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ospfd]
from lib.topogen import Topogen, TopoRouter, get_topogen
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ospfd]
# pylint: disable=C0413
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
# Import topogen and topotest helpers
from lib import topotest
class OspfTeTopo(Topo):
"Test topology builder"
- def build(self):
+ def build(self, *args, **kwargs):
"Build function"
tgen = get_topogen(self)
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ospfd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ospfd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ospfd]
logger.info("Testing with VRF Namespace support")
- cmds = [
- "if [ -e /var/run/netns/{0}-ospf-cust1 ] ; then ip netns del {0}-ospf-cust1 ; fi",
- "ip netns add {0}-ospf-cust1",
- "ip link set dev {0}-eth0 netns {0}-ospf-cust1",
- "ip netns exec {0}-ospf-cust1 ip link set {0}-eth0 up",
- "ip link set dev {0}-eth1 netns {0}-ospf-cust1",
- "ip netns exec {0}-ospf-cust1 ip link set {0}-eth1 up",
- ]
-
for rname, router in router_list.items():
-
- # create VRF rx-ospf-cust1 and link rx-eth0 to rx-ospf-cust1
- for cmd in cmds:
- output = tgen.net[rname].cmd(cmd.format(rname))
+ # 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,
"Teardown the pytest environment"
tgen = get_topogen()
- # move back rx-eth0 to default VRF
- # delete rx-vrf
- cmds = [
- "ip netns exec {0}-ospf-cust1 ip link set {0}-eth0 netns 1",
- "ip netns exec {0}-ospf-cust1 ip link set {0}-eth1 netns 1",
- "ip netns delete {0}-ospf-cust1",
- ]
-
+ # Move interfaces out of vrf namespace and delete the namespace
router_list = tgen.routers()
for rname, router in router_list.items():
- for cmd in cmds:
- tgen.net[rname].cmd(cmd.format(rname))
+ tgen.net[rname].reset_intf_netns(rname + "-eth0")
+ tgen.net[rname].reset_intf_netns(rname + "-eth1")
+ tgen.net[rname].delete_netns(rname + "-ospf-cust1")
tgen.stop_topology()
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.ospfd]
# the rp_filter. Setting it to '0' allows the OS to pass
# up the mcast packet not destined for the local routers
# network.
- topotest.set_sysctl(tgen.net["r1"], "net.ipv4.conf.r1-eth1.rp_filter", 0)
- topotest.set_sysctl(tgen.net["r1"], "net.ipv4.conf.all.rp_filter", 0)
- topotest.set_sysctl(tgen.net["r2"], "net.ipv4.conf.r2-eth1.rp_filter", 0)
- topotest.set_sysctl(tgen.net["r2"], "net.ipv4.conf.all.rp_filter", 0)
+ topotest.sysctl_assure(tgen.net["r1"], "net.ipv4.conf.r1-eth1.rp_filter", 0)
+ topotest.sysctl_assure(tgen.net["r1"], "net.ipv4.conf.all.rp_filter", 0)
+ topotest.sysctl_assure(tgen.net["r2"], "net.ipv4.conf.r2-eth1.rp_filter", 0)
+ topotest.sysctl_assure(tgen.net["r2"], "net.ipv4.conf.all.rp_filter", 0)
# Initialize all routers.
tgen.start_router()
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
from lib.topogen import Topogen, get_topogen
import ipaddress
from time import sleep
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
from lib.topogen import Topogen, get_topogen
import ipaddress
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
from lib.topogen import Topogen, get_topogen
import ipaddress
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
import ipaddress
from lib.bgp import verify_bgp_convergence, create_router_bgp
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
import ipaddress
from lib.common_config import shutdown_bringup_interface
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.pbrd]
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.pim import McastTesterHelper
pytestmark = [pytest.mark.pimd, pytest.mark.ospfd]
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.pimd]
r1 = tgen.gears["r1"]
# Let's send a igmp report from r2->r1
- CWD = os.path.dirname(os.path.realpath(__file__))
- r2.run("{}/mcast-rx.py 229.1.1.2 r2-eth0 &".format(CWD))
-
- out = r1.vtysh_cmd("show ip pim upstream json", isjson=True)
- expected = {
- "229.1.1.2": {
- "*": {
- "sourceIgmp": 1,
- "joinState": "Joined",
- "regState": "RegNoInfo",
- "sptBit": 0,
+ cmd = [ os.path.join(CWD, "mcast-rx.py"), "229.1.1.2", "r2-eth0" ]
+ p = r2.popen(cmd)
+ try:
+ expected = {
+ "229.1.1.2": {
+ "*": {
+ "sourceIgmp": 1,
+ "joinState": "Joined",
+ "regState": "RegNoInfo",
+ "sptBit": 0,
+ }
}
}
- }
-
- assert topotest.json_cmp(out, expected) is None, "failed to converge pim"
+ test_func = partial(
+ topotest.router_json_cmp, r1, "show ip pim upstream json", expected
+ )
+ _, result = topotest.run_and_expect(test_func, None, count=5, wait=.5)
+ assertmsg = '"{}" JSON output mismatches'.format(r1.name)
+ assert result is None, assertmsg
+ finally:
+ if p:
+ p.terminate()
+ p.wait()
def test_memory_leak():
from lib.topolog import logger
# Required to instantiate the topology builder class.
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
pytestmark = [pytest.mark.bfdd, pytest.mark.pimd]
import pytest
from time import sleep
-from mininet.topo import Topo
-from mininet.net import Mininet
-from mininet.node import Node, OVSSwitch, Host
-from mininet.log import setLogLevel, info
-from mininet.cli import CLI
-from mininet.link import Intf
from functools import partial
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from lib import topotest
+from lib.micronet_compat import Topo
+from lib.micronet_compat import Mininet
fatal_error = ""
#
# On main router
# First switch is for a dummy interface (for local network)
- switch[1] = self.addSwitch("sw1", cls=topotest.LegacySwitch)
+ switch[1] = self.addSwitch("sw1")
self.addLink(switch[1], router[1], intfName2="r1-eth0")
#
# Switches for RIP
# switch 2 switch is for connection to RIP router
- switch[2] = self.addSwitch("sw2", cls=topotest.LegacySwitch)
+ switch[2] = self.addSwitch("sw2")
self.addLink(switch[2], router[1], intfName2="r1-eth1")
self.addLink(switch[2], router[2], intfName2="r2-eth0")
# switch 3 is between RIP routers
- switch[3] = self.addSwitch("sw3", cls=topotest.LegacySwitch)
+ switch[3] = self.addSwitch("sw3")
self.addLink(switch[3], router[2], intfName2="r2-eth1")
self.addLink(switch[3], router[3], intfName2="r3-eth1")
# switch 4 is stub on remote RIP router
- switch[4] = self.addSwitch("sw4", cls=topotest.LegacySwitch)
+ switch[4] = self.addSwitch("sw4")
self.addLink(switch[4], router[3], intfName2="r3-eth0")
- switch[5] = self.addSwitch("sw5", cls=topotest.LegacySwitch)
+ switch[5] = self.addSwitch("sw5")
self.addLink(switch[5], router[1], intfName2="r1-eth2")
- switch[6] = self.addSwitch("sw6", cls=topotest.LegacySwitch)
+ switch[6] = self.addSwitch("sw6")
self.addLink(switch[6], router[1], intfName2="r1-eth3")
if __name__ == "__main__":
- setLogLevel("info")
# To suppress tracebacks, either use the following pytest call or add "--tb=no" to cli
# retval = pytest.main(["-s", "--tb=no"])
retval = pytest.main(["-s"])
import unicodedata
from time import sleep
-from mininet.topo import Topo
-from mininet.net import Mininet
-from mininet.node import Node, OVSSwitch, Host
-from mininet.log import setLogLevel, info
-from mininet.cli import CLI
-from mininet.link import Intf
-
from functools import partial
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from lib import topotest
+from lib.micronet_compat import Topo
+from lib.micronet_compat import Mininet
fatal_error = ""
#
# On main router
# First switch is for a dummy interface (for local network)
- switch[1] = self.addSwitch("sw1", cls=topotest.LegacySwitch)
+ switch[1] = self.addSwitch("sw1")
self.addLink(switch[1], router[1], intfName2="r1-eth0")
#
# Switches for RIPng
# switch 2 switch is for connection to RIP router
- switch[2] = self.addSwitch("sw2", cls=topotest.LegacySwitch)
+ switch[2] = self.addSwitch("sw2")
self.addLink(switch[2], router[1], intfName2="r1-eth1")
self.addLink(switch[2], router[2], intfName2="r2-eth0")
# switch 3 is between RIP routers
- switch[3] = self.addSwitch("sw3", cls=topotest.LegacySwitch)
+ switch[3] = self.addSwitch("sw3")
self.addLink(switch[3], router[2], intfName2="r2-eth1")
self.addLink(switch[3], router[3], intfName2="r3-eth1")
# switch 4 is stub on remote RIP router
- switch[4] = self.addSwitch("sw4", cls=topotest.LegacySwitch)
+ switch[4] = self.addSwitch("sw4")
self.addLink(switch[4], router[3], intfName2="r3-eth0")
- switch[5] = self.addSwitch("sw5", cls=topotest.LegacySwitch)
+ switch[5] = self.addSwitch("sw5")
self.addLink(switch[5], router[1], intfName2="r1-eth2")
- switch[6] = self.addSwitch("sw6", cls=topotest.LegacySwitch)
+ switch[6] = self.addSwitch("sw6")
self.addLink(switch[6], router[1], intfName2="r1-eth3")
if __name__ == "__main__":
- setLogLevel("info")
# To suppress tracebacks, either use the following pytest call or add "--tb=no" to cli
# retval = pytest.main(["-s", "--tb=no"])
retval = pytest.main(["-s"])
from lib.topolog import logger
from lib.common_config import shutdown_bringup_interface
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
pytestmark = [pytest.mark.sharpd]
#####################################################
-class NetworkTopo(Topo):
- "Route Scale Topology"
+def build(tgen):
+ "Build function"
- def build(self, **_opts):
- "Build function"
+ # Populate routers
+ for routern in range(1, 2):
+ tgen.add_router("r{}".format(routern))
- tgen = get_topogen(self)
-
- # Populate routers
- for routern in range(1, 2):
- tgen.add_router("r{}".format(routern))
-
- # Populate switches
- for switchn in range(1, 33):
- switch = tgen.add_switch("sw{}".format(switchn))
- switch.add_link(tgen.gears["r1"])
+ # Populate switches
+ for switchn in range(1, 33):
+ switch = tgen.add_switch("sw{}".format(switchn))
+ switch.add_link(tgen.gears["r1"])
#####################################################
def setup_module(module):
"Setup topology"
- tgen = Topogen(NetworkTopo, module.__name__)
+ tgen = Topogen(build, module.__name__)
tgen.start_topology()
router_list = tgen.routers()
scale_setups.append(d)
# Avoid top ecmp case for runs with < 4G memory
- p = os.popen("free")
- l = p.readlines()[1].split()
- mem = int(l[1])
- if mem < 4000000:
- logger.info("Limited memory available: {}, skipping x32 testcase".format(mem))
+ output = tgen.net.cmd_raises("free")
+ m = re.search("Mem:\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)", output)
+ total_mem = int(m.group(2))
+ if total_mem < 4000000:
+ logger.info("Limited memory available: {}, skipping x32 testcase".format(total_mem))
scale_setups = scale_setups[0:-1]
# Run each step using the dicts we've built
rouser frr
master agentx
+
+agentXSocket /etc/frr/agentx
+agentXPerms 777 755 root frr
from lib.topolog import logger
from lib.snmptest import SnmpTester
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.isisd, pytest.mark.snmp]
-class TemplateTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- # This function only purpose is to define allocation and relationship
- # between routers, switches and hosts.
- #
- #
- # Create routers
- tgen.add_router("r1")
-
- # r1-eth0
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
-
- # r1-eth1
- switch = tgen.add_switch("s2")
- switch.add_link(tgen.gears["r1"])
-
- # r1-eth2
- switch = tgen.add_switch("s3")
- switch.add_link(tgen.gears["r1"])
-
-
def setup_module(mod):
"Sets up the pytest environment"
error_msg = "SNMP not installed - skipping"
pytest.skip(error_msg)
# This function initiates the topology build with Topogen...
- tgen = Topogen(TemplateTopo, mod.__name__)
+ topodef = {
+ "s1": "r1",
+ "s2": "r1",
+ "s3": "r1"
+ }
+ tgen = Topogen(topodef, mod.__name__)
# ... and here it calls Mininet initialization functions.
tgen.start_topology()
pytest.skip(tgen.errors)
# tgen.mininet_cli()
- r1 = tgen.net.get("r1")
+ r1 = tgen.gears["r1"]
r1_snmp = SnmpTester(r1, "1.1.1.1", "public", "2c")
assert r1_snmp.test_oid("bgpVersin", None)
assert r1_snmp.test_oid("bgpVersion", "10")
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
pytestmark = [pytest.mark.bgpd, pytest.mark.sharpd]
assert False, "Could not read file {}".format(filename)
-class TemplateTopo(Topo):
- def build(self, *_args, **_opts):
- tgen = get_topogen(self)
- tgen.add_router('r1')
def setup_module(mod):
- tgen = Topogen(TemplateTopo, mod.__name__)
+ tgen = Topogen({None: "r1"}, 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)))
# pylint: disable=C0413
# Import topogen and topotest helpers
from lib.topogen import Topogen, get_topogen
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topotest import version_cmp
# Import topoJson from lib, to create topology and initial configuration
sys.path.append(os.path.join(CWD, "../lib/"))
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
sys.path.append(os.path.join(CWD, "../lib/"))
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
from lib.common_config import (
sys.path.append(os.path.join(CWD, "../lib/"))
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
from lib.topotest import version_cmp
sys.path.append(os.path.join(CWD, "../lib/"))
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
from lib.topotest import version_cmp
sys.path.append(os.path.join(CWD, "../lib/"))
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
# Import topoJson from lib, to create topology and initial configuration
sys.path.append(os.path.join(CWD, "../lib/"))
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
from lib.topotest import version_cmp
sys.path.append(os.path.join(CWD, "../lib/"))
# pylint: disable=C0413
# Import topogen and topotest helpers
-from mininet.topo import Topo
+from lib.micronet_compat import Topo
from lib.topogen import Topogen, get_topogen
from lib.common_config import (
from lib.topolog import logger
from lib.common_config import shutdown_bringup_interface
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
pytestmark = [pytest.mark.sharpd]
-#####################################################
-##
-## Network Topology Definition
-##
-#####################################################
-
-
-class ZebraTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- tgen.add_router("r1")
-
- # Create a empty network for router 1
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
-
-
#####################################################
##
## Tests starting
def setup_module(mod):
"Sets up the pytest environment"
- tgen = Topogen(ZebraTopo, mod.__name__)
+
+ topodef = { "s1": ("r1") }
+ tgen = Topogen(topodef, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
from lib import topotest
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
-from mininet.topo import Topo
pytestmark = [pytest.mark.bgpd]
-class TemplateTopo(Topo):
- def build(self, *_args, **_opts):
- tgen = get_topogen(self)
-
- for routern in range(1, 3):
- tgen.add_router("r{}".format(routern))
-
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r2"])
-
-
def setup_module(mod):
- tgen = Topogen(TemplateTopo, mod.__name__)
+ topodef = {
+ "s1": ("r1", "r2")
+ }
+ tgen = Topogen(topodef, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
from lib.topolog import logger
from time import sleep
-# Required to instantiate the topology builder class.
-from mininet.topo import Topo
pytestmark = [pytest.mark.sharpd]
-class ZebraTopo(Topo):
- "Test topology builder"
-
- def build(self, *_args, **_opts):
- "Build function"
- tgen = get_topogen(self)
-
- tgen.add_router("r1")
-
- # Create a empty network for router 1
- switch = tgen.add_switch("s1")
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r1"])
- switch.add_link(tgen.gears["r1"])
-
def setup_module(mod):
"Sets up the pytest environment"
- tgen = Topogen(ZebraTopo, mod.__name__)
+ topodef = {
+ "s1": ("r1", "r1", "r1", "r1", "r1", "r1", "r1", "r1")
+ }
+ tgen = Topogen(topodef, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
from lib.common_config import shutdown_bringup_interface
-from mininet.topo import Topo
pytestmark = [pytest.mark.sharpd]
assert False, "Could not read file {}".format(filename)
-class TemplateTopo(Topo):
- def build(self, **_opts):
- tgen = get_topogen(self)
- tgen.add_router("r1")
-
-
def setup_module(mod):
- tgen = Topogen(TemplateTopo, mod.__name__)
+ tgen = Topogen({None: "r1"}, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
for rname, router in tgen.routers().items():
from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger
from lib.common_config import shutdown_bringup_interface
-from mininet.topo import Topo
pytestmark = [pytest.mark.sharpd]
assert False, "Could not read file {}".format(filename)
-class TemplateTopo(Topo):
- def build(self, **_opts):
- tgen = get_topogen(self)
- tgen.add_router("r1")
-
-
def setup_module(mod):
- tgen = Topogen(TemplateTopo, mod.__name__)
+ tgen = Topogen({None: "r1"}, mod.__name__)
tgen.start_topology()
router_list = tgen.routers()
for rname, router in tgen.routers().items():
projects / mirror / frr.git / commitdiff