proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-08-07 13:33:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #6144 from ton31337/fix/python_formatter

Browse Source 
tests: Run python formatter (black) for topotests
This commit is contained in:
Quentin Young 2020-04-05 13:20:30 -04:00 committed by GitHub
commit a5ba758e61
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
154 changed files with 12198 additions and 10130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
tests/topotests/bfd-bgp-cbit-topo3/test_bfd_bgp_cbit_topo3.py
View File

@ -33,7 +33,7 @@ import pytest
# Save the Current Working Directory to find configuration files. # Save the Current Working Directory to find configuration files.
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
# Import topogen and topotest helpers # Import topogen and topotest helpers
@ -44,23 +44,26 @@ from lib.topolog import logger
# Required to instantiate the topology builder class. # Required to instantiate the topology builder class.
from mininet.topo import Topo from mininet.topo import Topo
class BFDTopo(Topo): class BFDTopo(Topo):
"Test topology builder" "Test topology builder"
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
"Build function" "Build function"
tgen = get_topogen(self) tgen = get_topogen(self)
# Create 4 routers. # Create 4 routers.
for routern in range(1, 4): for routern in range(1, 4):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
switch = tgen.add_switch('s1') switch = tgen.add_switch("s1")
switch.add_link(tgen.gears['r1']) switch.add_link(tgen.gears["r1"])
switch.add_link(tgen.gears['r2']) 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'])
def setup_module(mod): def setup_module(mod):
"Sets up the pytest environment" "Sets up the pytest environment"
@ -71,16 +74,13 @@ def setup_module(mod):
for rname, router in router_list.iteritems(): for rname, router in router_list.iteritems():
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname)),
os.path.join(CWD, '{}/zebra.conf'.format(rname)),
) )
router.load_config( router.load_config(
TopoRouter.RD_BFD, TopoRouter.RD_BFD, os.path.join(CWD, "{}/bfdd.conf".format(rname))
os.path.join(CWD, '{}/bfdd.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
# Initialize all routers. # Initialize all routers.
@ -90,10 +90,11 @@ def setup_module(mod):
# daemon exists. # daemon exists.
for router in router_list.values(): for router in router_list.values():
# Check for Version # Check for Version
if router.has_version('<', '5.1'): if router.has_version("<", "5.1"):
tgen.set_error('Unsupported FRR version') tgen.set_error("Unsupported FRR version")
break break
def teardown_module(_mod): def teardown_module(_mod):
"Teardown the pytest environment" "Teardown the pytest environment"
tgen = get_topogen() tgen = get_topogen()
@ -112,17 +113,17 @@ def test_protocols_convergence():
# Check IPv6 routing tables. # Check IPv6 routing tables.
logger.info("Checking IPv6 routes for convergence") logger.info("Checking IPv6 routes for convergence")
for router in tgen.routers().values(): for router in tgen.routers().values():
if router.name == 'r2': if router.name == "r2":
continue continue
json_file = '{}/{}/ipv6_routes.json'.format(CWD, router.name) json_file = "{}/{}/ipv6_routes.json".format(CWD, router.name)
if not os.path.isfile(json_file): if not os.path.isfile(json_file):
logger.info('skipping file {}'.format(json_file)) logger.info("skipping file {}".format(json_file))
continue continue
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ipv6 route json', expected) topotest.router_json_cmp, router, "show ipv6 route json", expected
_, result = topotest.run_and_expect(test_func, None, count=40, )
wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=40, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
@ -133,19 +134,21 @@ def test_bfd_connection():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for bfd peers to go up') logger.info("waiting for bfd peers to go up")
for router in tgen.routers().values(): for router in tgen.routers().values():
if router.name == 'r2': if router.name == "r2":
continue continue
json_file = '{}/{}/peers.json'.format(CWD, router.name) json_file = "{}/{}/peers.json".format(CWD, router.name)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show bfd peers json', expected) topotest.router_json_cmp, router, "show bfd peers json", expected
)
_, result = topotest.run_and_expect(test_func, None, count=32, wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=32, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
def test_bfd_loss_intermediate(): def test_bfd_loss_intermediate():
""" """
Assert that BFD notices the bfd link down failure. Assert that BFD notices the bfd link down failure.
@ -155,94 +158,98 @@ def test_bfd_loss_intermediate():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('removing IPv6 address from r2 to simulate loss of connectivity') logger.info("removing IPv6 address from r2 to simulate loss of connectivity")
# Disable r2-eth0 ipv6 address # Disable r2-eth0 ipv6 address
cmd = 'vtysh -c \"configure terminal\" -c \"interface r2-eth1\" -c "no ipv6 address 2001:db8:4::2/64\"' cmd = 'vtysh -c "configure terminal" -c "interface r2-eth1" -c "no ipv6 address 2001:db8:4::2/64"'
tgen.net['r2'].cmd(cmd) tgen.net["r2"].cmd(cmd)
# Wait the minimum time we can before checking that BGP/BFD # Wait the minimum time we can before checking that BGP/BFD
# converged. # converged.
logger.info('waiting for BFD converge down') logger.info("waiting for BFD converge down")
# Check that BGP converged quickly. # Check that BGP converged quickly.
for router in tgen.routers().values(): for router in tgen.routers().values():
if router.name == 'r2': if router.name == "r2":
continue continue
json_file = '{}/{}/peers_down.json'.format(CWD, router.name) json_file = "{}/{}/peers_down.json".format(CWD, router.name)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show bfd peers json', expected) topotest.router_json_cmp, router, "show bfd peers json", expected
)
_, result = topotest.run_and_expect(test_func, None, count=32, wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=32, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
logger.info('waiting for BGP entries to become stale') logger.info("waiting for BGP entries to become stale")
for router in tgen.routers().values(): for router in tgen.routers().values():
if router.name == 'r2': if router.name == "r2":
continue continue
json_file = '{}/{}/bgp_ipv6_routes_down.json'.format(CWD, router.name) json_file = "{}/{}/bgp_ipv6_routes_down.json".format(CWD, router.name)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show bgp ipv6 json', expected) topotest.router_json_cmp, router, "show bgp ipv6 json", expected
)
_, result = topotest.run_and_expect(test_func, None, count=50, wait=1) _, result = topotest.run_and_expect(test_func, None, count=50, wait=1)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
logger.info("Checking IPv6 routes on r1 should still be present") logger.info("Checking IPv6 routes on r1 should still be present")
for router in tgen.routers().values(): for router in tgen.routers().values():
if router.name == 'r2': if router.name == "r2":
continue continue
if router.name == 'r3': if router.name == "r3":
continue continue
json_file = '{}/r1/ipv6_routes.json'.format(CWD) json_file = "{}/r1/ipv6_routes.json".format(CWD)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ipv6 route json', expected) topotest.router_json_cmp, router, "show ipv6 route json", expected
_, result = topotest.run_and_expect(test_func, None, count=30, )
wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=30, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
def test_bfd_comes_back_again(): def test_bfd_comes_back_again():
""" """
Assert that BFD notices the bfd link up Assert that BFD notices the bfd link up
and that ipv6 entries appear back and that ipv6 entries appear back
""" """
tgen = get_topogen() tgen = get_topogen()
logger.info('re-adding IPv6 address from r2 to simulate connectivity is back') logger.info("re-adding IPv6 address from r2 to simulate connectivity is back")
# adds back r2-eth0 ipv6 address # adds back r2-eth0 ipv6 address
cmd = 'vtysh -c \"configure terminal\" -c \"interface r2-eth1\" -c "ipv6 address 2001:db8:4::2/64\"' cmd = 'vtysh -c "configure terminal" -c "interface r2-eth1" -c "ipv6 address 2001:db8:4::2/64"'
tgen.net['r2'].cmd(cmd) tgen.net["r2"].cmd(cmd)
# Wait the minimum time we can before checking that BGP/BFD # Wait the minimum time we can before checking that BGP/BFD
# converged. # converged.
logger.info('waiting for BFD to converge up') logger.info("waiting for BFD to converge up")
# Check that BGP converged quickly. # Check that BGP converged quickly.
for router in tgen.routers().values(): for router in tgen.routers().values():
if router.name == 'r2': if router.name == "r2":
continue continue
json_file = '{}/{}/peers.json'.format(CWD, router.name) json_file = "{}/{}/peers.json".format(CWD, router.name)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show bfd peers json', expected) topotest.router_json_cmp, router, "show bfd peers json", expected
)
_, result = topotest.run_and_expect(test_func, None, count=16, wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=16, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
def test_memory_leak(): def test_memory_leak():
"Run the memory leak test and report results." "Run the memory leak test and report results."
tgen = get_topogen() tgen = get_topogen()
if not tgen.is_memleak_enabled(): if not tgen.is_memleak_enabled():
pytest.skip('Memory leak test/report is disabled') pytest.skip("Memory leak test/report is disabled")
tgen.report_memory_leaks() tgen.report_memory_leaks()
if __name__ == '__main__': if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

119
tests/topotests/bfd-topo1/test_bfd_topo1.py
View File

@ -34,7 +34,7 @@ import pytest
# Save the Current Working Directory to find configuration files. # Save the Current Working Directory to find configuration files.
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
# Import topogen and topotest helpers # Import topogen and topotest helpers
@ -45,27 +45,29 @@ from lib.topolog import logger
# Required to instantiate the topology builder class. # Required to instantiate the topology builder class.
from mininet.topo import Topo from mininet.topo import Topo
class BFDTopo(Topo): class BFDTopo(Topo):
"Test topology builder" "Test topology builder"
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
"Build function" "Build function"
tgen = get_topogen(self) tgen = get_topogen(self)
# Create 4 routers # Create 4 routers
for routern in range(1, 5): for routern in range(1, 5):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
switch = tgen.add_switch('s1') switch = tgen.add_switch("s1")
switch.add_link(tgen.gears['r1']) switch.add_link(tgen.gears["r1"])
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch = tgen.add_switch('s2') switch = tgen.add_switch("s2")
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch.add_link(tgen.gears['r3']) switch.add_link(tgen.gears["r3"])
switch = tgen.add_switch('s3') switch = tgen.add_switch("s3")
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch.add_link(tgen.gears['r4']) switch.add_link(tgen.gears["r4"])
def setup_module(mod): def setup_module(mod):
@ -76,16 +78,13 @@ def setup_module(mod):
router_list = tgen.routers() router_list = tgen.routers()
for rname, router in router_list.iteritems(): for rname, router in router_list.iteritems():
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BFD, TopoRouter.RD_BFD, os.path.join(CWD, "{}/bfdd.conf".format(rname))
os.path.join(CWD, '{}/bfdd.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
# Initialize all routers. # Initialize all routers.
@ -95,8 +94,8 @@ def setup_module(mod):
# daemon exists. # daemon exists.
for router in router_list.values(): for router in router_list.values():
# Check for Version # Check for Version
if router.has_version('<', '5.1'): if router.has_version("<", "5.1"):
tgen.set_error('Unsupported FRR version') tgen.set_error("Unsupported FRR version")
break break
@ -112,14 +111,15 @@ def test_bfd_connection():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for bfd peers to go up') logger.info("waiting for bfd peers to go up")
for router in tgen.routers().values(): for router in tgen.routers().values():
json_file = '{}/{}/peers.json'.format(CWD, router.name) json_file = "{}/{}/peers.json".format(CWD, router.name)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show bfd peers json', expected) topotest.router_json_cmp, router, "show bfd peers json", expected
)
_, result = topotest.run_and_expect(test_func, None, count=8, wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=8, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
@ -131,15 +131,16 @@ def test_bgp_convergence():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for bgp peers to go up') logger.info("waiting for bgp peers to go up")
for router in tgen.routers().values(): for router in tgen.routers().values():
ref_file = '{}/{}/bgp_summary.json'.format(CWD, router.name) ref_file = "{}/{}/bgp_summary.json".format(CWD, router.name)
expected = json.loads(open(ref_file).read()) expected = json.loads(open(ref_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ip bgp summary json', expected) topotest.router_json_cmp, router, "show ip bgp summary json", expected
)
_, res = topotest.run_and_expect(test_func, None, count=125, wait=1.0) _, res = topotest.run_and_expect(test_func, None, count=125, wait=1.0)
assertmsg = '{}: bgp did not converge'.format(router.name) assertmsg = "{}: bgp did not converge".format(router.name)
assert res is None, assertmsg assert res is None, assertmsg
@ -149,15 +150,16 @@ def test_bgp_fast_convergence():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for bgp peers converge') logger.info("waiting for bgp peers converge")
for router in tgen.routers().values(): for router in tgen.routers().values():
ref_file = '{}/{}/bgp_prefixes.json'.format(CWD, router.name) ref_file = "{}/{}/bgp_prefixes.json".format(CWD, router.name)
expected = json.loads(open(ref_file).read()) expected = json.loads(open(ref_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ip bgp json', expected) topotest.router_json_cmp, router, "show ip bgp json", expected
)
_, res = topotest.run_and_expect(test_func, None, count=40, wait=0.5) _, res = topotest.run_and_expect(test_func, None, count=40, wait=0.5)
assertmsg = '{}: bgp did not converge'.format(router.name) assertmsg = "{}: bgp did not converge".format(router.name)
assert res is None, assertmsg assert res is None, assertmsg
@ -171,29 +173,30 @@ def test_bfd_fast_convergence():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
# Disable r1-eth0 link. # Disable r1-eth0 link.
tgen.gears['r1'].link_enable('r1-eth0', enabled=False) tgen.gears["r1"].link_enable("r1-eth0", enabled=False)
# Wait the minimum time we can before checking that BGP/BFD # Wait the minimum time we can before checking that BGP/BFD
# converged. # converged.
logger.info('waiting for BFD converge') logger.info("waiting for BFD converge")
# Check that BGP converged quickly. # Check that BGP converged quickly.
for router in tgen.routers().values(): for router in tgen.routers().values():
json_file = '{}/{}/peers.json'.format(CWD, router.name) json_file = "{}/{}/peers.json".format(CWD, router.name)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
# Load the same file as previous test, but expect R1 to be down. # Load the same file as previous test, but expect R1 to be down.
if router.name == 'r1': if router.name == "r1":
for peer in expected: for peer in expected:
if peer['peer'] == '192.168.0.2': if peer["peer"] == "192.168.0.2":
peer['status'] = 'down' peer["status"] = "down"
else: else:
for peer in expected: for peer in expected:
if peer['peer'] == '192.168.0.1': if peer["peer"] == "192.168.0.1":
peer['status'] = 'down' peer["status"] = "down"
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show bfd peers json', expected) topotest.router_json_cmp, router, "show bfd peers json", expected
)
_, res = topotest.run_and_expect(test_func, None, count=20, wait=0.5) _, res = topotest.run_and_expect(test_func, None, count=20, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert res is None, assertmsg assert res is None, assertmsg
@ -205,31 +208,27 @@ def test_bgp_fast_reconvergence():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for BGP re convergence') logger.info("waiting for BGP re convergence")
# Check that BGP converged quickly. # Check that BGP converged quickly.
for router in tgen.routers().values(): for router in tgen.routers().values():
ref_file = '{}/{}/bgp_prefixes.json'.format(CWD, router.name) ref_file = "{}/{}/bgp_prefixes.json".format(CWD, router.name)
expected = json.loads(open(ref_file).read()) expected = json.loads(open(ref_file).read())
# Load the same file as previous test, but set networks to None # Load the same file as previous test, but set networks to None
# to test absence. # to test absence.
if router.name == 'r1': if router.name == "r1":
expected['routes']['10.254.254.2/32'] = None expected["routes"]["10.254.254.2/32"] = None
expected['routes']['10.254.254.3/32'] = None expected["routes"]["10.254.254.3/32"] = None
expected['routes']['10.254.254.4/32'] = None expected["routes"]["10.254.254.4/32"] = None
else: else:
expected['routes']['10.254.254.1/32'] = None expected["routes"]["10.254.254.1/32"] = None
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ip bgp json', expected) topotest.router_json_cmp, router, "show ip bgp json", expected
_, res = topotest.run_and_expect(
test_func,
None,
count=3,
wait=1
) )
assertmsg = '{}: bgp did not converge'.format(router.name) _, res = topotest.run_and_expect(test_func, None, count=3, wait=1)
assertmsg = "{}: bgp did not converge".format(router.name)
assert res is None, assertmsg assert res is None, assertmsg
@ -237,11 +236,11 @@ def test_memory_leak():
"Run the memory leak test and report results." "Run the memory leak test and report results."
tgen = get_topogen() tgen = get_topogen()
if not tgen.is_memleak_enabled(): if not tgen.is_memleak_enabled():
pytest.skip('Memory leak test/report is disabled') pytest.skip("Memory leak test/report is disabled")
tgen.report_memory_leaks() tgen.report_memory_leaks()
if __name__ == '__main__': if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

79
tests/topotests/bfd-topo2/test_bfd_topo2.py
View File

@ -35,7 +35,7 @@ import pytest
# Save the Current Working Directory to find configuration files. # Save the Current Working Directory to find configuration files.
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
# Import topogen and topotest helpers # Import topogen and topotest helpers
@ -49,25 +49,26 @@ from mininet.topo import Topo
class BFDTopo(Topo): class BFDTopo(Topo):
"Test topology builder" "Test topology builder"
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
"Build function" "Build function"
tgen = get_topogen(self) tgen = get_topogen(self)
# Create 4 routers. # Create 4 routers.
for routern in range(1, 5): for routern in range(1, 5):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
switch = tgen.add_switch('s1') switch = tgen.add_switch("s1")
switch.add_link(tgen.gears['r1']) switch.add_link(tgen.gears["r1"])
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch = tgen.add_switch('s2') switch = tgen.add_switch("s2")
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch.add_link(tgen.gears['r3']) switch.add_link(tgen.gears["r3"])
switch = tgen.add_switch('s3') switch = tgen.add_switch("s3")
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch.add_link(tgen.gears['r4']) switch.add_link(tgen.gears["r4"])
def setup_module(mod): def setup_module(mod):
@ -78,24 +79,19 @@ def setup_module(mod):
router_list = tgen.routers() router_list = tgen.routers()
for rname, router in router_list.iteritems(): for rname, router in router_list.iteritems():
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BFD, TopoRouter.RD_BFD, os.path.join(CWD, "{}/bfdd.conf".format(rname))
os.path.join(CWD, '{}/bfdd.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_OSPF, TopoRouter.RD_OSPF, os.path.join(CWD, "{}/ospfd.conf".format(rname))
os.path.join(CWD, '{}/ospfd.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_OSPF6, TopoRouter.RD_OSPF6, os.path.join(CWD, "{}/ospf6d.conf".format(rname))
os.path.join(CWD, '{}/ospf6d.conf'.format(rname))
) )
# Initialize all routers. # Initialize all routers.
@ -105,8 +101,8 @@ def setup_module(mod):
# daemon exists. # daemon exists.
for router in router_list.values(): for router in router_list.values():
# Check for Version # Check for Version
if router.has_version('<', '5.1'): if router.has_version("<", "5.1"):
tgen.set_error('Unsupported FRR version') tgen.set_error("Unsupported FRR version")
break break
@ -128,32 +124,32 @@ def test_protocols_convergence():
# Check IPv4 routing tables. # Check IPv4 routing tables.
logger.info("Checking IPv4 routes for convergence") logger.info("Checking IPv4 routes for convergence")
for router in tgen.routers().values(): for router in tgen.routers().values():
json_file = '{}/{}/ipv4_routes.json'.format(CWD, router.name) json_file = "{}/{}/ipv4_routes.json".format(CWD, router.name)
if not os.path.isfile(json_file): if not os.path.isfile(json_file):
logger.info('skipping file {}'.format(json_file)) logger.info("skipping file {}".format(json_file))
continue continue
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ip route json', expected) topotest.router_json_cmp, router, "show ip route json", expected
_, result = topotest.run_and_expect(test_func, None, count=160, )
wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=160, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
# Check IPv6 routing tables. # Check IPv6 routing tables.
logger.info("Checking IPv6 routes for convergence") logger.info("Checking IPv6 routes for convergence")
for router in tgen.routers().values(): for router in tgen.routers().values():
json_file = '{}/{}/ipv6_routes.json'.format(CWD, router.name) json_file = "{}/{}/ipv6_routes.json".format(CWD, router.name)
if not os.path.isfile(json_file): if not os.path.isfile(json_file):
logger.info('skipping file {}'.format(json_file)) logger.info("skipping file {}".format(json_file))
continue continue
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ipv6 route json', expected) topotest.router_json_cmp, router, "show ipv6 route json", expected
_, result = topotest.run_and_expect(test_func, None, count=160, )
wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=160, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
@ -164,14 +160,15 @@ def test_bfd_connection():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for bfd peers to go up') logger.info("waiting for bfd peers to go up")
for router in tgen.routers().values(): for router in tgen.routers().values():
json_file = '{}/{}/peers.json'.format(CWD, router.name) json_file = "{}/{}/peers.json".format(CWD, router.name)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show bfd peers json', expected) topotest.router_json_cmp, router, "show bfd peers json", expected
)
_, result = topotest.run_and_expect(test_func, None, count=8, wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=8, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
@ -181,11 +178,11 @@ def test_memory_leak():
"Run the memory leak test and report results." "Run the memory leak test and report results."
tgen = get_topogen() tgen = get_topogen()
if not tgen.is_memleak_enabled(): if not tgen.is_memleak_enabled():
pytest.skip('Memory leak test/report is disabled') pytest.skip("Memory leak test/report is disabled")
tgen.report_memory_leaks() tgen.report_memory_leaks()
if __name__ == '__main__': if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

188
tests/topotests/bfd-vrf-topo1/test_bfd_vrf_topo1.py
View File

@ -35,7 +35,7 @@ import pytest
# Save the Current Working Directory to find configuration files. # Save the Current Working Directory to find configuration files.
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
# Import topogen and topotest helpers # Import topogen and topotest helpers
@ -46,27 +46,29 @@ from lib.topolog import logger
# Required to instantiate the topology builder class. # Required to instantiate the topology builder class.
from mininet.topo import Topo from mininet.topo import Topo
class BFDTopo(Topo): class BFDTopo(Topo):
"Test topology builder" "Test topology builder"
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
"Build function" "Build function"
tgen = get_topogen(self) tgen = get_topogen(self)
# Create 4 routers # Create 4 routers
for routern in range(1, 5): for routern in range(1, 5):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
switch = tgen.add_switch('s1') switch = tgen.add_switch("s1")
switch.add_link(tgen.gears['r1']) switch.add_link(tgen.gears["r1"])
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch = tgen.add_switch('s2') switch = tgen.add_switch("s2")
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch.add_link(tgen.gears['r3']) switch.add_link(tgen.gears["r3"])
switch = tgen.add_switch('s3') switch = tgen.add_switch("s3")
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch.add_link(tgen.gears['r4']) switch.add_link(tgen.gears["r4"])
def setup_module(mod): def setup_module(mod):
@ -78,47 +80,50 @@ def setup_module(mod):
# check for zebra capability # check for zebra capability
for rname, router in router_list.iteritems(): for rname, router in router_list.iteritems():
if router.check_capability( if router.check_capability(TopoRouter.RD_ZEBRA, "--vrfwnetns") == False:
TopoRouter.RD_ZEBRA, return pytest.skip(
'--vrfwnetns' "Skipping BFD Topo1 VRF NETNS feature. VRF NETNS backend not available on FRR"
) == False: )
return pytest.skip('Skipping BFD Topo1 VRF NETNS feature. VRF NETNS backend not available on FRR')
if os.system('ip netns list') != 0: if os.system("ip netns list") != 0:
return pytest.skip('Skipping BFD Topo1 VRF NETNS Test. NETNS not available on System') return pytest.skip(
"Skipping BFD Topo1 VRF NETNS Test. NETNS not available on System"
)
logger.info('Testing with VRF Namespace support') logger.info("Testing with VRF Namespace support")
cmds = ['if [ -e /var/run/netns/{0}-cust1 ] ; then ip netns del {0}-cust1 ; fi', cmds = [
'ip netns add {0}-cust1', "if [ -e /var/run/netns/{0}-cust1 ] ; then ip netns del {0}-cust1 ; fi",
'ip link set dev {0}-eth0 netns {0}-cust1', "ip netns add {0}-cust1",
'ip netns exec {0}-cust1 ifconfig {0}-eth0 up'] "ip link set dev {0}-eth0 netns {0}-cust1",
cmds2 = ['ip link set dev {0}-eth1 netns {0}-cust1', "ip netns exec {0}-cust1 ifconfig {0}-eth0 up",
'ip netns exec {0}-cust1 ifconfig {0}-eth1 up', ]
'ip link set dev {0}-eth2 netns {0}-cust1', cmds2 = [
'ip netns exec {0}-cust1 ifconfig {0}-eth2 up'] "ip link set dev {0}-eth1 netns {0}-cust1",
"ip netns exec {0}-cust1 ifconfig {0}-eth1 up",
"ip link set dev {0}-eth2 netns {0}-cust1",
"ip netns exec {0}-cust1 ifconfig {0}-eth2 up",
]
for rname, router in router_list.iteritems(): for rname, router in router_list.iteritems():
# create VRF rx-cust1 and link rx-eth0 to rx-cust1 # create VRF rx-cust1 and link rx-eth0 to rx-cust1
for cmd in cmds: for cmd in cmds:
output = tgen.net[rname].cmd(cmd.format(rname)) output = tgen.net[rname].cmd(cmd.format(rname))
if rname == 'r2': if rname == "r2":
for cmd in cmds2: for cmd in cmds2:
output = tgen.net[rname].cmd(cmd.format(rname)) output = tgen.net[rname].cmd(cmd.format(rname))
for rname, router in router_list.iteritems(): for rname, router in router_list.iteritems():
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA,
os.path.join(CWD, '{}/zebra.conf'.format(rname)), os.path.join(CWD, "{}/zebra.conf".format(rname)),
'--vrfwnetns' "--vrfwnetns",
) )
router.load_config( router.load_config(
TopoRouter.RD_BFD, TopoRouter.RD_BFD, os.path.join(CWD, "{}/bfdd.conf".format(rname))
os.path.join(CWD, '{}/bfdd.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
# Initialize all routers. # Initialize all routers.
@ -128,42 +133,49 @@ def setup_module(mod):
# daemon exists. # daemon exists.
for router in router_list.values(): for router in router_list.values():
# Check for Version # Check for Version
if router.has_version('<', '5.1'): if router.has_version("<", "5.1"):
tgen.set_error('Unsupported FRR version') tgen.set_error("Unsupported FRR version")
break break
def teardown_module(_mod): def teardown_module(_mod):
"Teardown the pytest environment" "Teardown the pytest environment"
tgen = get_topogen() tgen = get_topogen()
# move back rx-eth0 to default VRF # move back rx-eth0 to default VRF
# delete rx-vrf # delete rx-vrf
cmds = ['ip netns exec {0}-cust1 ip link set {0}-eth0 netns 1', cmds = [
'ip netns delete {0}-cust1'] "ip netns exec {0}-cust1 ip link set {0}-eth0 netns 1",
cmds2 = ['ip netns exec {0}-cust1 ip link set {0}-eth1 netns 1', "ip netns delete {0}-cust1",
'ip netns exec {0}-cust2 ip link set {0}-eth1 netns 1'] ]
cmds2 = [
"ip netns exec {0}-cust1 ip link set {0}-eth1 netns 1",
"ip netns exec {0}-cust2 ip link set {0}-eth1 netns 1",
]
router_list = tgen.routers() router_list = tgen.routers()
for rname, router in router_list.iteritems(): for rname, router in router_list.iteritems():
if rname == 'r2': if rname == "r2":
for cmd in cmds2: for cmd in cmds2:
tgen.net[rname].cmd(cmd.format(rname)) tgen.net[rname].cmd(cmd.format(rname))
for cmd in cmds: for cmd in cmds:
tgen.net[rname].cmd(cmd.format(rname)) tgen.net[rname].cmd(cmd.format(rname))
tgen.stop_topology() tgen.stop_topology()
def test_bfd_connection(): def test_bfd_connection():
"Assert that the BFD peers can find themselves." "Assert that the BFD peers can find themselves."
tgen = get_topogen() tgen = get_topogen()
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for bfd peers to go up') logger.info("waiting for bfd peers to go up")
for router in tgen.routers().values(): for router in tgen.routers().values():
json_file = '{}/{}/peers.json'.format(CWD, router.name) json_file = "{}/{}/peers.json".format(CWD, router.name)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show bfd peers json', expected) topotest.router_json_cmp, router, "show bfd peers json", expected
)
_, result = topotest.run_and_expect(test_func, None, count=8, wait=0.5) _, result = topotest.run_and_expect(test_func, None, count=8, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
@ -175,15 +187,19 @@ def test_bgp_convergence():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for bgp peers to go up') logger.info("waiting for bgp peers to go up")
for router in tgen.routers().values(): for router in tgen.routers().values():
ref_file = '{}/{}/bgp_summary.json'.format(CWD, router.name) ref_file = "{}/{}/bgp_summary.json".format(CWD, router.name)
expected = json.loads(open(ref_file).read()) expected = json.loads(open(ref_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ip bgp vrf {}-cust1 summary json'.format(router.name), expected) topotest.router_json_cmp,
router,
"show ip bgp vrf {}-cust1 summary json".format(router.name),
expected,
)
_, res = topotest.run_and_expect(test_func, None, count=125, wait=1.0) _, res = topotest.run_and_expect(test_func, None, count=125, wait=1.0)
assertmsg = '{}: bgp did not converge'.format(router.name) assertmsg = "{}: bgp did not converge".format(router.name)
assert res is None, assertmsg assert res is None, assertmsg
@ -193,15 +209,19 @@ def test_bgp_fast_convergence():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for bgp peers converge') logger.info("waiting for bgp peers converge")
for router in tgen.routers().values(): for router in tgen.routers().values():
ref_file = '{}/{}/bgp_prefixes.json'.format(CWD, router.name) ref_file = "{}/{}/bgp_prefixes.json".format(CWD, router.name)
expected = json.loads(open(ref_file).read()) expected = json.loads(open(ref_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ip bgp vrf {}-cust1 json'.format(router.name), expected) topotest.router_json_cmp,
router,
"show ip bgp vrf {}-cust1 json".format(router.name),
expected,
)
_, res = topotest.run_and_expect(test_func, None, count=40, wait=0.5) _, res = topotest.run_and_expect(test_func, None, count=40, wait=0.5)
assertmsg = '{}: bgp did not converge'.format(router.name) assertmsg = "{}: bgp did not converge".format(router.name)
assert res is None, assertmsg assert res is None, assertmsg
@ -215,30 +235,33 @@ def test_bfd_fast_convergence():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
# Disable r2-eth0 link # Disable r2-eth0 link
router2 = tgen.gears['r2'] router2 = tgen.gears["r2"]
topotest.interface_set_status(router2, 'r2-eth0', ifaceaction=False, vrf_name='r2-cust1') topotest.interface_set_status(
router2, "r2-eth0", ifaceaction=False, vrf_name="r2-cust1"
)
# Wait the minimum time we can before checking that BGP/BFD # Wait the minimum time we can before checking that BGP/BFD
# converged. # converged.
logger.info('waiting for BFD converge') logger.info("waiting for BFD converge")
# Check that BGP converged quickly. # Check that BGP converged quickly.
for router in tgen.routers().values(): for router in tgen.routers().values():
json_file = '{}/{}/peers.json'.format(CWD, router.name) json_file = "{}/{}/peers.json".format(CWD, router.name)
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
# Load the same file as previous test, but expect R1 to be down. # Load the same file as previous test, but expect R1 to be down.
if router.name == 'r1': if router.name == "r1":
for peer in expected: for peer in expected:
if peer['peer'] == '192.168.0.2': if peer["peer"] == "192.168.0.2":
peer['status'] = 'down' peer["status"] = "down"
else: else:
for peer in expected: for peer in expected:
if peer['peer'] == '192.168.0.1': if peer["peer"] == "192.168.0.1":
peer['status'] = 'down' peer["status"] = "down"
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show bfd peers json', expected) topotest.router_json_cmp, router, "show bfd peers json", expected
)
_, res = topotest.run_and_expect(test_func, None, count=20, wait=0.5) _, res = topotest.run_and_expect(test_func, None, count=20, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert res is None, assertmsg assert res is None, assertmsg
@ -250,31 +273,30 @@ def test_bgp_fast_reconvergence():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
logger.info('waiting for BGP re convergence') logger.info("waiting for BGP re convergence")
# Check that BGP converged quickly. # Check that BGP converged quickly.
for router in tgen.routers().values(): for router in tgen.routers().values():
ref_file = '{}/{}/bgp_prefixes.json'.format(CWD, router.name) ref_file = "{}/{}/bgp_prefixes.json".format(CWD, router.name)
expected = json.loads(open(ref_file).read()) expected = json.loads(open(ref_file).read())
# Load the same file as previous test, but set networks to None # Load the same file as previous test, but set networks to None
# to test absence. # to test absence.
if router.name == 'r1': if router.name == "r1":
expected['routes']['10.254.254.2/32'] = None expected["routes"]["10.254.254.2/32"] = None
expected['routes']['10.254.254.3/32'] = None expected["routes"]["10.254.254.3/32"] = None
expected['routes']['10.254.254.4/32'] = None expected["routes"]["10.254.254.4/32"] = None
else: else:
expected['routes']['10.254.254.1/32'] = None expected["routes"]["10.254.254.1/32"] = None
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ip bgp vrf {}-cust1 json'.format(router.name), expected) topotest.router_json_cmp,
_, res = topotest.run_and_expect( router,
test_func, "show ip bgp vrf {}-cust1 json".format(router.name),
None, expected,
count=3,
wait=1
) )
assertmsg = '{}: bgp did not converge'.format(router.name) _, res = topotest.run_and_expect(test_func, None, count=3, wait=1)
assertmsg = "{}: bgp did not converge".format(router.name)
assert res is None, assertmsg assert res is None, assertmsg
@ -282,11 +304,11 @@ def test_memory_leak():
"Run the memory leak test and report results." "Run the memory leak test and report results."
tgen = get_topogen() tgen = get_topogen()
if not tgen.is_memleak_enabled(): if not tgen.is_memleak_enabled():
pytest.skip('Memory leak test/report is disabled') pytest.skip("Memory leak test/report is disabled")
tgen.report_memory_leaks() tgen.report_memory_leaks()
if __name__ == '__main__': if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

294
tests/topotests/bgp-basic-functionality-topo1/test_bgp_basic_functionality.py
View File

@ -48,8 +48,8 @@ from copy import deepcopy
# Save the Current Working Directory to find configuration files. # Save the Current Working Directory to find configuration files.
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
sys.path.append(os.path.join(CWD, '../lib/')) sys.path.append(os.path.join(CWD, "../lib/"))
# Required to instantiate the topology builder class. # Required to instantiate the topology builder class.
@ -59,30 +59,39 @@ from lib.topogen import Topogen, get_topogen
from mininet.topo import Topo from mininet.topo import Topo
from lib.common_config import ( from lib.common_config import (
start_topology, write_test_header, start_topology,
write_test_footer, reset_config_on_routers, create_static_routes, write_test_header,
verify_rib, verify_admin_distance_for_static_routes write_test_footer,
reset_config_on_routers,
create_static_routes,
verify_rib,
verify_admin_distance_for_static_routes,
) )
from lib.topolog import logger from lib.topolog import logger
from lib.bgp import ( from lib.bgp import (
verify_bgp_convergence, create_router_bgp, verify_router_id, verify_bgp_convergence,
modify_as_number, verify_as_numbers, clear_bgp_and_verify, create_router_bgp,
verify_bgp_timers_and_functionality verify_router_id,
modify_as_number,
verify_as_numbers,
clear_bgp_and_verify,
verify_bgp_timers_and_functionality,
) )
from lib.topojson import build_topo_from_json, build_config_from_json from lib.topojson import build_topo_from_json, build_config_from_json
# Reading the data from JSON File for topology creation # Reading the data from JSON File for topology creation
jsonFile = "{}/bgp_basic_functionality.json".format(CWD) jsonFile = "{}/bgp_basic_functionality.json".format(CWD)
try: try:
with open(jsonFile, 'r') as topoJson: with open(jsonFile, "r") as topoJson:
topo = json.load(topoJson) topo = json.load(topoJson)
except IOError: except IOError:
assert False, "Could not read file {}".format(jsonFile) assert False, "Could not read file {}".format(jsonFile)
#Global Variable # Global Variable
KEEPALIVETIMER = 2 KEEPALIVETIMER = 2
HOLDDOWNTIMER = 6 HOLDDOWNTIMER = 6
class CreateTopo(Topo): class CreateTopo(Topo):
""" """
Test BasicTopo - topology 1 Test BasicTopo - topology 1
@ -124,8 +133,9 @@ def setup_module(mod):
global BGP_CONVERGENCE global BGP_CONVERGENCE
BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo) BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo)
assert BGP_CONVERGENCE is True, "setup_module :Failed \n Error: {}". \ assert BGP_CONVERGENCE is True, "setup_module :Failed \n Error: {}".format(
format(BGP_CONVERGENCE) BGP_CONVERGENCE
)
logger.info("Running setup_module() done") logger.info("Running setup_module() done")
@ -140,8 +150,9 @@ def teardown_module():
# Stop toplogy and Remove tmp files # Stop toplogy and Remove tmp files
tgen.stop_topology() tgen.stop_topology()
logger.info("Testsuite end time: {}". logger.info(
format(time.asctime(time.localtime(time.time())))) "Testsuite end time: {}".format(time.asctime(time.localtime(time.time())))
)
logger.info("=" * 40) logger.info("=" * 40)
@ -157,7 +168,7 @@ def test_modify_and_delete_router_id(request):
tgen = get_topogen() tgen = get_topogen()
if BGP_CONVERGENCE is not True: if BGP_CONVERGENCE is not True:
pytest.skip('skipped because of BGP Convergence failure') pytest.skip("skipped because of BGP Convergence failure")
# test case name # test case name
tc_name = request.node.name tc_name = request.node.name
@ -165,59 +176,31 @@ def test_modify_and_delete_router_id(request):
# Modify router id # Modify router id
input_dict = { input_dict = {
'r1': { "r1": {"bgp": {"router_id": "12.12.12.12"}},
"bgp": { "r2": {"bgp": {"router_id": "22.22.22.22"}},
'router_id': '12.12.12.12' "r3": {"bgp": {"router_id": "33.33.33.33"}},
}
},
'r2': {
"bgp": {
'router_id': '22.22.22.22'
}
},
'r3': {
"bgp": {
'router_id': '33.33.33.33'
}
},
} }
result = create_router_bgp(tgen, topo, input_dict) result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".\ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
# Verifying router id once modified # Verifying router id once modified
result = verify_router_id(tgen, topo, input_dict) result = verify_router_id(tgen, topo, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}".\ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
# Delete router id # Delete router id
input_dict = { input_dict = {
'r1': { "r1": {"bgp": {"del_router_id": True}},
"bgp": { "r2": {"bgp": {"del_router_id": True}},
'del_router_id': True "r3": {"bgp": {"del_router_id": True}},
}
},
'r2': {
"bgp": {
'del_router_id': True
}
},
'r3': {
"bgp": {
'del_router_id': True
}
},
} }
result = create_router_bgp(tgen, topo, input_dict) result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
# Verifying router id once deleted # Verifying router id once deleted
# Once router-id is deleted, highest interface ip should become # Once router-id is deleted, highest interface ip should become
# router-id # router-id
result = verify_router_id(tgen, topo, input_dict) result = verify_router_id(tgen, topo, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -229,41 +212,23 @@ def test_bgp_config_with_4byte_as_number(request):
tgen = get_topogen() tgen = get_topogen()
if BGP_CONVERGENCE is not True: if BGP_CONVERGENCE is not True:
pytest.skip('skipped because of BGP Convergence failure') pytest.skip("skipped because of BGP Convergence failure")
# test case name # test case name
tc_name = request.node.name tc_name = request.node.name
write_test_header(tc_name) write_test_header(tc_name)
input_dict = { input_dict = {
"r1": { "r1": {"bgp": {"local_as": 131079}},
"bgp": { "r2": {"bgp": {"local_as": 131079}},
"local_as": 131079 "r3": {"bgp": {"local_as": 131079}},
} "r4": {"bgp": {"local_as": 131080}},
},
"r2": {
"bgp": {
"local_as": 131079
}
},
"r3": {
"bgp": {
"local_as": 131079
}
},
"r4": {
"bgp": {
"local_as": 131080
}
}
} }
result = modify_as_number(tgen, topo, input_dict) result = modify_as_number(tgen, topo, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
result = verify_as_numbers(tgen, topo, input_dict) result = verify_as_numbers(tgen, topo, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -275,7 +240,7 @@ def test_bgp_timers_functionality(request):
tgen = get_topogen() tgen = get_topogen()
if BGP_CONVERGENCE is not True: if BGP_CONVERGENCE is not True:
pytest.skip('skipped because of BGP Convergence failure') pytest.skip("skipped because of BGP Convergence failure")
# test case name # test case name
tc_name = request.node.name tc_name = request.node.name
@ -293,10 +258,10 @@ def test_bgp_timers_functionality(request):
"unicast": { "unicast": {
"neighbor": { "neighbor": {
"r2": { "r2": {
"dest_link":{ "dest_link": {
"r1": { "r1": {
"keepalivetimer": KEEPALIVETIMER, "keepalivetimer": KEEPALIVETIMER,
"holddowntimer": HOLDDOWNTIMER "holddowntimer": HOLDDOWNTIMER,
} }
} }
} }
@ -308,16 +273,14 @@ def test_bgp_timers_functionality(request):
} }
} }
result = create_router_bgp(tgen, topo, deepcopy(input_dict)) result = create_router_bgp(tgen, topo, deepcopy(input_dict))
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
# Api call to clear bgp, so timer modification would take place # Api call to clear bgp, so timer modification would take place
clear_bgp_and_verify(tgen, topo, 'r1') clear_bgp_and_verify(tgen, topo, "r1")
# Verifying bgp timers functionality # Verifying bgp timers functionality
result = verify_bgp_timers_and_functionality(tgen, topo, input_dict) result = verify_bgp_timers_and_functionality(tgen, topo, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -327,7 +290,7 @@ def test_static_routes(request):
tgen = get_topogen() tgen = get_topogen()
if BGP_CONVERGENCE is not True: if BGP_CONVERGENCE is not True:
pytest.skip('skipped because of BGP Convergence failure') pytest.skip("skipped because of BGP Convergence failure")
# test case name # test case name
tc_name = request.node.name tc_name = request.node.name
@ -339,17 +302,18 @@ def test_static_routes(request):
# Api call to create static routes # Api call to create static routes
input_dict = { input_dict = {
"r1": { "r1": {
"static_routes": [{ "static_routes": [
"network": "10.0.20.1/32", {
"no_of_ip": 9, "network": "10.0.20.1/32",
"admin_distance": 100, "no_of_ip": 9,
"next_hop": "10.0.0.2" "admin_distance": 100,
}] "next_hop": "10.0.0.2",
}
]
} }
} }
result = create_static_routes(tgen, input_dict) result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
# Api call to redistribute static routes # Api call to redistribute static routes
input_dict_1 = { input_dict_1 = {
@ -360,7 +324,7 @@ def test_static_routes(request):
"unicast": { "unicast": {
"redistribute": [ "redistribute": [
{"redist_type": "static"}, {"redist_type": "static"},
{"redist_type": "connected"} {"redist_type": "connected"},
] ]
} }
} }
@ -370,17 +334,16 @@ def test_static_routes(request):
} }
result = create_router_bgp(tgen, topo, input_dict_1) result = create_router_bgp(tgen, topo, input_dict_1)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
# Verifying RIB routes # Verifying RIB routes
dut = 'r3' dut = "r3"
protocol = 'bgp' protocol = "bgp"
next_hop = ['10.0.0.2', '10.0.0.5'] next_hop = ["10.0.0.2", "10.0.0.5"]
result = verify_rib(tgen, 'ipv4', dut, input_dict, next_hop=next_hop, result = verify_rib(
protocol=protocol) tgen, "ipv4", dut, input_dict, next_hop=next_hop, protocol=protocol
assert result is True, "Testcase {} :Failed \n Error: {}". \ )
format(tc_name, result) assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -390,7 +353,7 @@ def test_admin_distance_for_existing_static_routes(request):
tgen = get_topogen() tgen = get_topogen()
if BGP_CONVERGENCE is not True: if BGP_CONVERGENCE is not True:
pytest.skip('skipped because of BGP Convergence failure') pytest.skip("skipped because of BGP Convergence failure")
# test case name # test case name
tc_name = request.node.name tc_name = request.node.name
@ -401,21 +364,21 @@ def test_admin_distance_for_existing_static_routes(request):
input_dict = { input_dict = {
"r1": { "r1": {
"static_routes": [{ "static_routes": [
"network": "10.0.20.1/32", {
"admin_distance": 10, "network": "10.0.20.1/32",
"next_hop": "10.0.0.2" "admin_distance": 10,
}] "next_hop": "10.0.0.2",
}
]
} }
} }
result = create_static_routes(tgen, input_dict) result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
# Verifying admin distance once modified # Verifying admin distance once modified
result = verify_admin_distance_for_static_routes(tgen, input_dict) result = verify_admin_distance_for_static_routes(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -425,7 +388,7 @@ def test_advertise_network_using_network_command(request):
tgen = get_topogen() tgen = get_topogen()
if BGP_CONVERGENCE is not True: if BGP_CONVERGENCE is not True:
pytest.skip('skipped because of BGP Convergence failure') pytest.skip("skipped because of BGP Convergence failure")
# test case name # test case name
tc_name = request.node.name tc_name = request.node.name
@ -442,14 +405,8 @@ def test_advertise_network_using_network_command(request):
"ipv4": { "ipv4": {
"unicast": { "unicast": {
"advertise_networks": [ "advertise_networks": [
{ {"network": "20.0.0.0/32", "no_of_network": 10},
"network": "20.0.0.0/32", {"network": "30.0.0.0/32", "no_of_network": 10},
"no_of_network": 10
},
{
"network": "30.0.0.0/32",
"no_of_network": 10
}
] ]
} }
} }
@ -459,15 +416,13 @@ def test_advertise_network_using_network_command(request):
} }
result = create_router_bgp(tgen, topo, input_dict) result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
# Verifying RIB routes # Verifying RIB routes
dut = 'r2' dut = "r2"
protocol = "bgp" protocol = "bgp"
result = verify_rib(tgen, 'ipv4', dut, input_dict, protocol=protocol) result = verify_rib(tgen, "ipv4", dut, input_dict, protocol=protocol)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -480,7 +435,7 @@ def test_clear_bgp_and_verify(request):
tgen = get_topogen() tgen = get_topogen()
if BGP_CONVERGENCE is not True: if BGP_CONVERGENCE is not True:
pytest.skip('skipped because of BGP Convergence failure') pytest.skip("skipped because of BGP Convergence failure")
# test case name # test case name
tc_name = request.node.name tc_name = request.node.name
@ -490,9 +445,8 @@ def test_clear_bgp_and_verify(request):
reset_config_on_routers(tgen) reset_config_on_routers(tgen)
# clear ip bgp # clear ip bgp
result = clear_bgp_and_verify(tgen, topo, 'r1') result = clear_bgp_and_verify(tgen, topo, "r1")
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -509,7 +463,7 @@ def test_bgp_with_loopback_interface(request):
tgen = get_topogen() tgen = get_topogen()
if BGP_CONVERGENCE is not True: if BGP_CONVERGENCE is not True:
pytest.skip('skipped because of BGP Convergence failure') pytest.skip("skipped because of BGP Convergence failure")
# test case name # test case name
tc_name = request.node.name tc_name = request.node.name
@ -518,79 +472,51 @@ def test_bgp_with_loopback_interface(request):
# Creating configuration from JSON # Creating configuration from JSON
reset_config_on_routers(tgen) reset_config_on_routers(tgen)
for routerN in sorted(topo['routers'].keys()): for routerN in sorted(topo["routers"].keys()):
for bgp_neighbor in \ for bgp_neighbor in topo["routers"][routerN]["bgp"]["address_family"]["ipv4"][
topo['routers'][routerN]['bgp']['address_family']['ipv4'][ "unicast"
'unicast']['neighbor'].keys(): ]["neighbor"].keys():
# Adding ['source_link'] = 'lo' key:value pair # Adding ['source_link'] = 'lo' key:value pair
topo['routers'][routerN]['bgp']['address_family']['ipv4'][ topo["routers"][routerN]["bgp"]["address_family"]["ipv4"]["unicast"][
'unicast']['neighbor'][bgp_neighbor]["dest_link"] = { "neighbor"
'lo': { ][bgp_neighbor]["dest_link"] = {"lo": {"source_link": "lo",}}
"source_link": "lo",
}
}
# Creating configuration from JSON # Creating configuration from JSON
build_config_from_json(tgen, topo) build_config_from_json(tgen, topo)
input_dict = { input_dict = {
"r1": { "r1": {
"static_routes": [{ "static_routes": [
"network": "1.0.2.17/32", {"network": "1.0.2.17/32", "next_hop": "10.0.0.2"},
"next_hop": "10.0.0.2" {"network": "1.0.3.17/32", "next_hop": "10.0.0.6"},
},
{
"network": "1.0.3.17/32",
"next_hop": "10.0.0.6"
}
] ]
}, },
"r2": { "r2": {
"static_routes": [{ "static_routes": [
"network": "1.0.1.17/32", {"network": "1.0.1.17/32", "next_hop": "10.0.0.1"},
"next_hop": "10.0.0.1" {"network": "1.0.3.17/32", "next_hop": "10.0.0.10"},
},
{
"network": "1.0.3.17/32",
"next_hop": "10.0.0.10"
}
] ]
}, },
"r3": { "r3": {
"static_routes": [{ "static_routes": [
"network": "1.0.1.17/32", {"network": "1.0.1.17/32", "next_hop": "10.0.0.5"},
"next_hop": "10.0.0.5" {"network": "1.0.2.17/32", "next_hop": "10.0.0.9"},
}, {"network": "1.0.4.17/32", "next_hop": "10.0.0.14"},
{
"network": "1.0.2.17/32",
"next_hop": "10.0.0.9"
},
{
"network": "1.0.4.17/32",
"next_hop": "10.0.0.14"
}
] ]
}, },
"r4": { "r4": {"static_routes": [{"network": "1.0.3.17/32", "next_hop": "10.0.0.13"}]},
"static_routes": [{
"network": "1.0.3.17/32",
"next_hop": "10.0.0.13"
}]
}
} }
result = create_static_routes(tgen, input_dict) result = create_static_routes(tgen, input_dict)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
# Api call verify whether BGP is converged # Api call verify whether BGP is converged
result = verify_bgp_convergence(tgen, topo) result = verify_bgp_convergence(tgen, topo)
assert result is True, "Testcase {} :Failed \n Error: {}". \ assert result is True, "Testcase {} :Failed \n Error: {}".format(tc_name, result)
format(tc_name, result)
write_test_footer(tc_name) write_test_footer(tc_name)
if __name__ == '__main__': if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

6
tests/topotests/bgp-ecmp-topo1/peer1/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer1/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer10/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer10/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer11/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer11/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer12/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer12/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer13/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer13/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer14/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer14/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer15/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer15/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer16/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer16/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer17/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer17/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer18/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer18/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer19/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer19/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer2/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer2/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer20/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer20/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer3/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer3/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer4/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer4/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer5/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer5/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer6/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer6/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer7/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer7/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer8/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer8/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp-ecmp-topo1/peer9/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

39
tests/topotests/bgp-ecmp-topo1/peer9/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -13,37 +13,54 @@ sleep(5)
# 2nd arg is number of routes to send # 2nd arg is number of routes to send
peer = int(argv[1]) peer = int(argv[1])
numRoutes = int(argv[2]) numRoutes = int(argv[2])
if (peer <= 10): if peer <= 10:
asnum = 99 asnum = 99
else: else:
asnum = peer+100 asnum = peer + 100
# Announce numRoutes equal routes per PE - different neighbor AS # Announce numRoutes equal routes per PE - different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n' % (i, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.201.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp\n"
% (i, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes per PE - different neighbor AS, but same source AS # Announce numRoutes equal routes per PE - different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.202.%s.0/24 med 100 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS # Announce numRoutes equal routes with different med per PE and different neighbor AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n' % (i, peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
"announce route 10.203.%s.0/24 med %i next-hop 10.0.%i.%i origin igp\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.flush() stdout.flush()
# Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS # Announce numRoutes equal routes with different med per PE and different neighbor AS, but same source AS
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (i, peer, (((peer-1) / 5) + 1), peer+100, asnum)) stdout.write(
"announce route 10.204.%s.0/24 med %i next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (i, peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
# Announce 2 different route per peer # Announce 2 different route per peer
stdout.write('announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n' % (peer, (((peer-1) / 5) + 1), peer+100)) stdout.write(
stdout.write('announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n' % (peer, (((peer-1) / 5) + 1), peer+100, asnum)) "announce route 10.205.%i.0/24 next-hop 10.0.%i.%i origin igp\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100)
)
stdout.write(
"announce route 10.206.%i.0/24 next-hop 10.0.%i.%i origin igp as-path [ %i 200 ]\n"
% (peer, (((peer - 1) / 5) + 1), peer + 100, asnum)
)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

77
tests/topotests/bgp-ecmp-topo1/test_bgp_ecmp_topo1.py
View File

@ -34,7 +34,7 @@ import pytest
# Save the Current Working Directory to find configuration files. # Save the Current Working Directory to find configuration files.
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
# Import topogen and topotest helpers # Import topogen and topotest helpers
@ -61,23 +61,24 @@ class BGPECMPTopo1(Topo):
tgen = get_topogen(self) tgen = get_topogen(self)
# Create the BGP router # Create the BGP router
router = tgen.add_router('r1') router = tgen.add_router("r1")
# Setup Switches - 1 switch per 5 peering routers # Setup Switches - 1 switch per 5 peering routers
for swNum in range(1, (total_ebgp_peers + 4) / 5 + 1): for swNum in range(1, (total_ebgp_peers + 4) / 5 + 1):
switch = tgen.add_switch('s{}'.format(swNum)) switch = tgen.add_switch("s{}".format(swNum))
switch.add_link(router) switch.add_link(router)
# Add 'total_ebgp_peers' number of eBGP ExaBGP neighbors # Add 'total_ebgp_peers' number of eBGP ExaBGP neighbors
for peerNum in range(1, total_ebgp_peers+1): for peerNum in range(1, total_ebgp_peers + 1):
swNum = ((peerNum - 1) / 5 + 1) swNum = (peerNum - 1) / 5 + 1
peer_ip = '10.0.{}.{}'.format(swNum, peerNum + 100) peer_ip = "10.0.{}.{}".format(swNum, peerNum + 100)
peer_route = 'via 10.0.{}.1'.format(swNum) peer_route = "via 10.0.{}.1".format(swNum)
peer = tgen.add_exabgp_peer('peer{}'.format(peerNum), peer = tgen.add_exabgp_peer(
ip=peer_ip, defaultRoute=peer_route) "peer{}".format(peerNum), ip=peer_ip, defaultRoute=peer_route
)
switch = tgen.gears['s{}'.format(swNum)] switch = tgen.gears["s{}".format(swNum)]
switch.add_link(peer) switch.add_link(peer)
@ -87,6 +88,7 @@ class BGPECMPTopo1(Topo):
# #
##################################################### #####################################################
def setup_module(module): def setup_module(module):
tgen = Topogen(BGPECMPTopo1, module.__name__) tgen = Topogen(BGPECMPTopo1, module.__name__)
tgen.start_topology() tgen.start_topology()
@ -95,21 +97,19 @@ def setup_module(module):
router_list = tgen.routers() router_list = tgen.routers()
for rname, router in router_list.iteritems(): for rname, router in router_list.iteritems():
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
router.start() router.start()
# Starting Hosts and init ExaBGP on each of them # Starting Hosts and init ExaBGP on each of them
topotest.sleep(10, 'starting BGP on all {} peers'.format(total_ebgp_peers)) topotest.sleep(10, "starting BGP on all {} peers".format(total_ebgp_peers))
peer_list = tgen.exabgp_peers() peer_list = tgen.exabgp_peers()
for pname, peer in peer_list.iteritems(): for pname, peer in peer_list.iteritems():
peer_dir = os.path.join(CWD, pname) peer_dir = os.path.join(CWD, pname)
env_file = os.path.join(CWD, 'exabgp.env') env_file = os.path.join(CWD, "exabgp.env")
peer.start(peer_dir, env_file) peer.start(peer_dir, env_file)
logger.info(pname) logger.info(pname)
@ -128,11 +128,11 @@ def test_bgp_convergence():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
# Expected result # Expected result
router = tgen.gears['r1'] router = tgen.gears["r1"]
if router.has_version('<', '3.0'): if router.has_version("<", "3.0"):
reffile = os.path.join(CWD, 'r1/summary20.txt') reffile = os.path.join(CWD, "r1/summary20.txt")
else: else:
reffile = os.path.join(CWD, 'r1/summary.txt') reffile = os.path.join(CWD, "r1/summary.txt")
expected = json.loads(open(reffile).read()) expected = json.loads(open(reffile).read())
@ -142,18 +142,19 @@ def test_bgp_convergence():
with 'json') and compare with `data` contents. with 'json') and compare with `data` contents.
""" """
output = router.vtysh_cmd(cmd, isjson=True) output = router.vtysh_cmd(cmd, isjson=True)
if 'ipv4Unicast' in output: if "ipv4Unicast" in output:
output['ipv4Unicast']['vrfName'] = \ output["ipv4Unicast"]["vrfName"] = output["ipv4Unicast"]["vrfName"].replace(
output['ipv4Unicast']['vrfName'].replace( "default", "Default"
'default', 'Default') )
elif 'vrfName' in output: elif "vrfName" in output:
output['vrfName'] = output['vrfName'].replace('default', 'Default') output["vrfName"] = output["vrfName"].replace("default", "Default")
return topotest.json_cmp(output, data) return topotest.json_cmp(output, data)
test_func = functools.partial( test_func = functools.partial(
_output_summary_cmp, router, 'show ip bgp summary json', expected) _output_summary_cmp, router, "show ip bgp summary json", expected
)
_, res = topotest.run_and_expect(test_func, None, count=60, wait=0.5) _, res = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assertmsg = 'BGP router network did not converge' assertmsg = "BGP router network did not converge"
assert res is None, assertmsg assert res is None, assertmsg
@ -165,26 +166,26 @@ def test_bgp_ecmp():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
expect = { expect = {
'routerId': '10.0.255.1', "routerId": "10.0.255.1",
'routes': { "routes": {},
},
} }
for net in range(1, 5): for net in range(1, 5):
for subnet in range(0, 10): for subnet in range(0, 10):
netkey = '10.20{}.{}.0/24'.format(net, subnet) netkey = "10.20{}.{}.0/24".format(net, subnet)
expect['routes'][netkey] = [] expect["routes"][netkey] = []
for _ in range(0, 10): for _ in range(0, 10):
peer = {'multipath': True, 'valid': True} peer = {"multipath": True, "valid": True}
expect['routes'][netkey].append(peer) expect["routes"][netkey].append(peer)
test_func = functools.partial(topotest.router_json_cmp, test_func = functools.partial(
tgen.gears['r1'], 'show ip bgp json', expect) topotest.router_json_cmp, tgen.gears["r1"], "show ip bgp json", expect
)
_, res = topotest.run_and_expect(test_func, None, count=10, wait=0.5) _, res = topotest.run_and_expect(test_func, None, count=10, wait=0.5)
assertmsg = 'expected multipath routes in "show ip bgp" output' assertmsg = 'expected multipath routes in "show ip bgp" output'
assert res is None, assertmsg assert res is None, assertmsg
if __name__ == '__main__': if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

559
tests/topotests/bgp-ecmp-topo2/test_ebgp_ecmp_topo2.py
View File

@ -41,10 +41,11 @@ import sys
import time import time
import json import json
import pytest import pytest
# Save the Current Working Directory to find configuration files. # Save the Current Working Directory to find configuration files.
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
sys.path.append(os.path.join(CWD, '../../')) sys.path.append(os.path.join(CWD, "../../"))
# pylint: disable=C0413 # pylint: disable=C0413
# Import topogen and topotest helpers # Import topogen and topotest helpers
@ -52,15 +53,17 @@ from lib.topogen import Topogen, get_topogen
from mininet.topo import Topo from mininet.topo import Topo
from lib.common_config import ( from lib.common_config import (
start_topology, write_test_header, start_topology,
write_test_header,
write_test_footer, write_test_footer,
verify_rib, create_static_routes, check_address_types, verify_rib,
interface_status, reset_config_on_routers create_static_routes,
check_address_types,
interface_status,
reset_config_on_routers,
) )
from lib.topolog import logger from lib.topolog import logger
from lib.bgp import ( from lib.bgp import verify_bgp_convergence, create_router_bgp, clear_bgp_and_verify
verify_bgp_convergence, create_router_bgp,
clear_bgp_and_verify)
from lib.topojson import build_topo_from_json, build_config_from_json from lib.topojson import build_topo_from_json, build_config_from_json
# Reading the data from JSON File for topology and configuration creation # Reading the data from JSON File for topology and configuration creation
@ -130,27 +133,32 @@ def setup_module(mod):
ADDR_TYPES = check_address_types() ADDR_TYPES = check_address_types()
BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo) BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo)
assert BGP_CONVERGENCE is True, ("setup_module :Failed \n Error:" assert BGP_CONVERGENCE is True, "setup_module :Failed \n Error:" " {}".format(
" {}".format(BGP_CONVERGENCE)) BGP_CONVERGENCE
)
link_data = [val for links, val in link_data = [
topo["routers"]["r2"]["links"].iteritems() val
if "r3" in links] for links, val in topo["routers"]["r2"]["links"].iteritems()
if "r3" in links
]
for adt in ADDR_TYPES: for adt in ADDR_TYPES:
NEXT_HOPS[adt] = [val[adt].split("/")[0] for val in link_data] NEXT_HOPS[adt] = [val[adt].split("/")[0] for val in link_data]
if adt == "ipv4": if adt == "ipv4":
NEXT_HOPS[adt] = sorted( NEXT_HOPS[adt] = sorted(NEXT_HOPS[adt], key=lambda x: int(x.split(".")[2]))
NEXT_HOPS[adt], key=lambda x: int(x.split(".")[2]))
elif adt == "ipv6": elif adt == "ipv6":
NEXT_HOPS[adt] = sorted( NEXT_HOPS[adt] = sorted(
NEXT_HOPS[adt], key=lambda x: int(x.split(':')[-3], 16)) NEXT_HOPS[adt], key=lambda x: int(x.split(":")[-3], 16)
)
INTF_LIST_R2 = [val["interface"].split("/")[0] for val in link_data] INTF_LIST_R2 = [val["interface"].split("/")[0] for val in link_data]
INTF_LIST_R2 = sorted(INTF_LIST_R2, key=lambda x: int(x.split("eth")[1])) INTF_LIST_R2 = sorted(INTF_LIST_R2, key=lambda x: int(x.split("eth")[1]))
link_data = [val for links, val in link_data = [
topo["routers"]["r3"]["links"].iteritems() val
if "r2" in links] for links, val in topo["routers"]["r3"]["links"].iteritems()
if "r2" in links
]
INTF_LIST_R3 = [val["interface"].split("/")[0] for val in link_data] INTF_LIST_R3 = [val["interface"].split("/")[0] for val in link_data]
INTF_LIST_R3 = sorted(INTF_LIST_R3, key=lambda x: int(x.split("eth")[1])) INTF_LIST_R3 = sorted(INTF_LIST_R3, key=lambda x: int(x.split("eth")[1]))
@ -179,40 +187,27 @@ def static_or_nw(tgen, topo, tc_name, test_type, dut):
input_dict_static = { input_dict_static = {
dut: { dut: {
"static_routes": [ "static_routes": [
{ {"network": NETWORK["ipv4"], "next_hop": NEXT_HOP_IP["ipv4"]},
"network": NETWORK["ipv4"], {"network": NETWORK["ipv6"], "next_hop": NEXT_HOP_IP["ipv6"]},
"next_hop": NEXT_HOP_IP["ipv4"]
},
{
"network": NETWORK["ipv6"],
"next_hop": NEXT_HOP_IP["ipv6"]
}
] ]
} }
} }
logger.info("Configuring static route on router %s", dut) logger.info("Configuring static route on router %s", dut)
result = create_static_routes(tgen, input_dict_static) result = create_static_routes(tgen, input_dict_static)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
input_dict_2 = { input_dict_2 = {
dut: { dut: {
"bgp": { "bgp": {
"address_family": { "address_family": {
"ipv4": { "ipv4": {
"unicast": { "unicast": {"redistribute": [{"redist_type": "static"}]}
"redistribute": [{
"redist_type": "static"
}]
}
}, },
"ipv6": { "ipv6": {
"unicast": { "unicast": {"redistribute": [{"redist_type": "static"}]}
"redistribute": [{ },
"redist_type": "static"
}]
}
}
} }
} }
} }
@ -221,7 +216,8 @@ def static_or_nw(tgen, topo, tc_name, test_type, dut):
logger.info("Configuring redistribute static route on router %s", dut) logger.info("Configuring redistribute static route on router %s", dut)
result = create_router_bgp(tgen, topo, input_dict_2) result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
elif test_type == "advertise_nw": elif test_type == "advertise_nw":
input_dict_nw = { input_dict_nw = {
@ -230,28 +226,29 @@ def static_or_nw(tgen, topo, tc_name, test_type, dut):
"address_family": { "address_family": {
"ipv4": { "ipv4": {
"unicast": { "unicast": {
"advertise_networks": [ "advertise_networks": [{"network": NETWORK["ipv4"]}]
{"network": NETWORK["ipv4"]}
]
} }
}, },
"ipv6": { "ipv6": {
"unicast": { "unicast": {
"advertise_networks": [ "advertise_networks": [{"network": NETWORK["ipv6"]}]
{"network": NETWORK["ipv6"]}
]
} }
} },
} }
} }
} }
} }
logger.info("Advertising networks %s %s from router %s", logger.info(
NETWORK["ipv4"], NETWORK["ipv6"], dut) "Advertising networks %s %s from router %s",
NETWORK["ipv4"],
NETWORK["ipv6"],
dut,
)
result = create_router_bgp(tgen, topo, input_dict_nw) result = create_router_bgp(tgen, topo, input_dict_nw)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
@pytest.mark.parametrize("ecmp_num", ["8", "16", "32"]) @pytest.mark.parametrize("ecmp_num", ["8", "16", "32"])
@ -274,20 +271,8 @@ def test_modify_ecmp_max_paths(request, ecmp_num, test_type):
"r3": { "r3": {
"bgp": { "bgp": {
"address_family": { "address_family": {
"ipv4": { "ipv4": {"unicast": {"maximum_paths": {"ebgp": ecmp_num,}}},
"unicast": { "ipv6": {"unicast": {"maximum_paths": {"ebgp": ecmp_num,}}},
"maximum_paths": {
"ebgp": ecmp_num,
}
}
},
"ipv6": {
"unicast": {
"maximum_paths": {
"ebgp": ecmp_num,
}
}
}
} }
} }
} }
@ -295,30 +280,27 @@ def test_modify_ecmp_max_paths(request, ecmp_num, test_type):
logger.info("Configuring bgp maximum-paths %s on router r3", ecmp_num) logger.info("Configuring bgp maximum-paths %s on router r3", ecmp_num)
result = create_router_bgp(tgen, topo, input_dict) result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
# Verifying RIB routes # Verifying RIB routes
dut = "r3" dut = "r3"
protocol = "bgp" protocol = "bgp"
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -338,44 +320,39 @@ def test_ecmp_after_clear_bgp(request):
static_or_nw(tgen, topo, tc_name, "redist_static", "r2") static_or_nw(tgen, topo, tc_name, "redist_static", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
# Clear bgp # Clear bgp
result = clear_bgp_and_verify(tgen, topo, dut) result = clear_bgp_and_verify(tgen, topo, dut)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -395,22 +372,20 @@ def test_ecmp_remove_redistribute_static(request):
# Verifying RIB routes # Verifying RIB routes
dut = "r3" dut = "r3"
protocol = "bgp" protocol = "bgp"
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
input_dict_2 = { input_dict_2 = {
"r2": { "r2": {
@ -418,22 +393,14 @@ def test_ecmp_remove_redistribute_static(request):
"address_family": { "address_family": {
"ipv4": { "ipv4": {
"unicast": { "unicast": {
"redistribute": [{ "redistribute": [{"redist_type": "static", "delete": True}]
"redist_type": "static",
"delete": True
}]
} }
}, },
"ipv6": { "ipv6": {
"unicast": { "unicast": {
"redistribute": [{ "redistribute": [{"redist_type": "static", "delete": True}]
"redist_type": "static",
"delete": True
}]
} }
} },
} }
} }
} }
@ -441,76 +408,60 @@ def test_ecmp_remove_redistribute_static(request):
logger.info("Remove redistribute static") logger.info("Remove redistribute static")
result = create_router_bgp(tgen, topo, input_dict_2) result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
# Verifying RIB routes # Verifying RIB routes
dut = "r3" dut = "r3"
protocol = "bgp" protocol = "bgp"
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3 are deleted", addr_type) logger.info("Verifying %s routes on r3 are deleted", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=[], protocol=protocol, expected=False) tgen,
assert result is not True, "Testcase {} : Failed \n Routes still" \ addr_type,
" present in RIB".format(tc_name) dut,
input_dict_1,
next_hop=[],
protocol=protocol,
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n Routes still" " present in RIB".format(tc_name)
logger.info("Enable redistribute static") logger.info("Enable redistribute static")
input_dict_2 = { input_dict_2 = {
"r2": { "r2": {
"bgp": { "bgp": {
"address_family": { "address_family": {
"ipv4": { "ipv4": {"unicast": {"redistribute": [{"redist_type": "static"}]}},
"unicast": { "ipv6": {"unicast": {"redistribute": [{"redist_type": "static"}]}},
"redistribute": [{
"redist_type": "static"
}]
}
},
"ipv6": {
"unicast": {
"redistribute": [{
"redist_type": "static"
}]
}
}
} }
} }
} }
} }
result = create_router_bgp(tgen, topo, input_dict_2) result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
# Verifying RIB routes # Verifying RIB routes
dut = "r3" dut = "r3"
protocol = "bgp" protocol = "bgp"
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -537,37 +488,30 @@ def test_ecmp_shut_bgp_neighbor(request):
static_or_nw(tgen, topo, tc_name, "redist_static", "r2") static_or_nw(tgen, topo, tc_name, "redist_static", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
for intf_num in range(len(INTF_LIST_R2)+1, 16): for intf_num in range(len(INTF_LIST_R2) + 1, 16):
intf_val = INTF_LIST_R2[intf_num:intf_num+16] intf_val = INTF_LIST_R2[intf_num : intf_num + 16]
input_dict_1 = { input_dict_1 = {"r2": {"interface_list": [intf_val], "status": "down"}}
"r2": { logger.info("Shutting down neighbor interface {} on r2".format(intf_val))
"interface_list": [intf_val],
"status": "down"
}
}
logger.info("Shutting down neighbor interface {} on r2".
format(intf_val))
result = interface_status(tgen, topo, input_dict_1) result = interface_status(tgen, topo, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
if intf_num + 16 < 32: if intf_num + 16 < 32:
@ -575,52 +519,37 @@ def test_ecmp_shut_bgp_neighbor(request):
else: else:
check_hops = [] check_hops = []
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=check_hops, tgen, addr_type, dut, input_dict, next_hop=check_hops, protocol=protocol
protocol=protocol) )
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
input_dict_1 = { input_dict_1 = {"r2": {"interface_list": INTF_LIST_R2, "status": "up"}}
"r2": {
"interface_list": INTF_LIST_R2,
"status": "up"
}
}
logger.info("Enabling all neighbor interface {} on r2") logger.info("Enabling all neighbor interface {} on r2")
result = interface_status(tgen, topo, input_dict_1) result = interface_status(tgen, topo, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
static_or_nw(tgen, topo, tc_name, "redist_static", "r2") static_or_nw(tgen, topo, tc_name, "redist_static", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -643,22 +572,20 @@ def test_ecmp_remove_static_route(request):
static_or_nw(tgen, topo, tc_name, "redist_static", "r2") static_or_nw(tgen, topo, tc_name, "redist_static", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_dict_1, tgen,
next_hop=NEXT_HOPS[addr_type], protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_2 = { input_dict_2 = {
@ -667,7 +594,7 @@ def test_ecmp_remove_static_route(request):
{ {
"network": NETWORK[addr_type], "network": NETWORK[addr_type],
"next_hop": NEXT_HOP_IP[addr_type], "next_hop": NEXT_HOP_IP[addr_type],
"delete": True "delete": True,
} }
] ]
} }
@ -676,23 +603,29 @@ def test_ecmp_remove_static_route(request):
logger.info("Remove static routes") logger.info("Remove static routes")
result = create_static_routes(tgen, input_dict_2) result = create_static_routes(tgen, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
logger.info("Verifying %s routes on r3 are removed", addr_type) logger.info("Verifying %s routes on r3 are removed", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_2, result = verify_rib(
next_hop=[], protocol=protocol, expected=False) tgen,
assert result is not True, "Testcase {} : Failed \n Routes still" \ addr_type,
" present in RIB".format(tc_name) dut,
input_dict_2,
next_hop=[],
protocol=protocol,
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n Routes still" " present in RIB".format(tc_name)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
# Enable static routes # Enable static routes
input_dict_4 = { input_dict_4 = {
"r2": { "r2": {
"static_routes": [ "static_routes": [
{ {"network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP[addr_type]}
"network": NETWORK[addr_type],
"next_hop": NEXT_HOP_IP[addr_type]
}
] ]
} }
} }
@ -700,14 +633,21 @@ def test_ecmp_remove_static_route(request):
logger.info("Enable static route") logger.info("Enable static route")
result = create_static_routes(tgen, input_dict_4) result = create_static_routes(tgen, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_4, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_4,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
def test_ecmp_remove_nw_advertise(request): def test_ecmp_remove_nw_advertise(request):
@ -727,22 +667,20 @@ def test_ecmp_remove_nw_advertise(request):
reset_config_on_routers(tgen) reset_config_on_routers(tgen)
static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2") static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
input_dict_3 = { input_dict_3 = {
"r2": { "r2": {
@ -750,64 +688,59 @@ def test_ecmp_remove_nw_advertise(request):
"address_family": { "address_family": {
"ipv4": { "ipv4": {
"unicast": { "unicast": {
"advertise_networks": [{ "advertise_networks": [
"network": NETWORK["ipv4"], {"network": NETWORK["ipv4"], "delete": True}
"delete": True ]
}] }
} },
},
"ipv6": { "ipv6": {
"unicast": { "unicast": {
"advertise_networks": [{ "advertise_networks": [
"network": NETWORK["ipv6"], {"network": NETWORK["ipv6"], "delete": True}
"delete": True ]
}]
}
} }
} },
} }
} }
} }
}
logger.info("Withdraw advertised networks") logger.info("Withdraw advertised networks")
result = create_router_bgp(tgen, topo, input_dict_3) result = create_router_bgp(tgen, topo, input_dict_3)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=[], protocol=protocol, expected=False) tgen,
assert result is not True, "Testcase {} : Failed \n Routes still" \ addr_type,
" present in RIB".format(tc_name) dut,
input_dict,
next_hop=[],
protocol=protocol,
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n Routes still" " present in RIB".format(tc_name)
static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2") static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)

559
tests/topotests/bgp-ecmp-topo2/test_ibgp_ecmp_topo2.py
View File

@ -41,10 +41,11 @@ import sys
import time import time
import json import json
import pytest import pytest
# Save the Current Working Directory to find configuration files. # Save the Current Working Directory to find configuration files.
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
sys.path.append(os.path.join(CWD, '../../')) sys.path.append(os.path.join(CWD, "../../"))
# pylint: disable=C0413 # pylint: disable=C0413
# Import topogen and topotest helpers # Import topogen and topotest helpers
@ -52,15 +53,17 @@ from lib.topogen import Topogen, get_topogen
from mininet.topo import Topo from mininet.topo import Topo
from lib.common_config import ( from lib.common_config import (
start_topology, write_test_header, start_topology,
write_test_header,
write_test_footer, write_test_footer,
verify_rib, create_static_routes, check_address_types, verify_rib,
interface_status, reset_config_on_routers create_static_routes,
check_address_types,
interface_status,
reset_config_on_routers,
) )
from lib.topolog import logger from lib.topolog import logger
from lib.bgp import ( from lib.bgp import verify_bgp_convergence, create_router_bgp, clear_bgp_and_verify
verify_bgp_convergence, create_router_bgp,
clear_bgp_and_verify)
from lib.topojson import build_topo_from_json, build_config_from_json from lib.topojson import build_topo_from_json, build_config_from_json
# Reading the data from JSON File for topology and configuration creation # Reading the data from JSON File for topology and configuration creation
@ -131,27 +134,32 @@ def setup_module(mod):
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo) BGP_CONVERGENCE = verify_bgp_convergence(tgen, topo)
assert BGP_CONVERGENCE is True, ("setup_module :Failed \n Error:" assert BGP_CONVERGENCE is True, "setup_module :Failed \n Error:" " {}".format(
" {}".format(BGP_CONVERGENCE)) BGP_CONVERGENCE
)
link_data = [val for links, val in link_data = [
topo["routers"]["r2"]["links"].iteritems() val
if "r3" in links] for links, val in topo["routers"]["r2"]["links"].iteritems()
if "r3" in links
]
for adt in ADDR_TYPES: for adt in ADDR_TYPES:
NEXT_HOPS[adt] = [val[adt].split("/")[0] for val in link_data] NEXT_HOPS[adt] = [val[adt].split("/")[0] for val in link_data]
if adt == "ipv4": if adt == "ipv4":
NEXT_HOPS[adt] = sorted( NEXT_HOPS[adt] = sorted(NEXT_HOPS[adt], key=lambda x: int(x.split(".")[2]))
NEXT_HOPS[adt], key=lambda x: int(x.split(".")[2]))
elif adt == "ipv6": elif adt == "ipv6":
NEXT_HOPS[adt] = sorted( NEXT_HOPS[adt] = sorted(
NEXT_HOPS[adt], key=lambda x: int(x.split(':')[-3], 16)) NEXT_HOPS[adt], key=lambda x: int(x.split(":")[-3], 16)
)
INTF_LIST_R2 = [val["interface"].split("/")[0] for val in link_data] INTF_LIST_R2 = [val["interface"].split("/")[0] for val in link_data]
INTF_LIST_R2 = sorted(INTF_LIST_R2, key=lambda x: int(x.split("eth")[1])) INTF_LIST_R2 = sorted(INTF_LIST_R2, key=lambda x: int(x.split("eth")[1]))
link_data = [val for links, val in link_data = [
topo["routers"]["r3"]["links"].iteritems() val
if "r2" in links] for links, val in topo["routers"]["r3"]["links"].iteritems()
if "r2" in links
]
INTF_LIST_R3 = [val["interface"].split("/")[0] for val in link_data] INTF_LIST_R3 = [val["interface"].split("/")[0] for val in link_data]
INTF_LIST_R3 = sorted(INTF_LIST_R3, key=lambda x: int(x.split("eth")[1])) INTF_LIST_R3 = sorted(INTF_LIST_R3, key=lambda x: int(x.split("eth")[1]))
@ -180,40 +188,27 @@ def static_or_nw(tgen, topo, tc_name, test_type, dut):
input_dict_static = { input_dict_static = {
dut: { dut: {
"static_routes": [ "static_routes": [
{ {"network": NETWORK["ipv4"], "next_hop": NEXT_HOP_IP["ipv4"]},
"network": NETWORK["ipv4"], {"network": NETWORK["ipv6"], "next_hop": NEXT_HOP_IP["ipv6"]},
"next_hop": NEXT_HOP_IP["ipv4"]
},
{
"network": NETWORK["ipv6"],
"next_hop": NEXT_HOP_IP["ipv6"]
}
] ]
} }
} }
logger.info("Configuring static route on router %s", dut) logger.info("Configuring static route on router %s", dut)
result = create_static_routes(tgen, input_dict_static) result = create_static_routes(tgen, input_dict_static)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
input_dict_2 = { input_dict_2 = {
dut: { dut: {
"bgp": { "bgp": {
"address_family": { "address_family": {
"ipv4": { "ipv4": {
"unicast": { "unicast": {"redistribute": [{"redist_type": "static"}]}
"redistribute": [{
"redist_type": "static"
}]
}
}, },
"ipv6": { "ipv6": {
"unicast": { "unicast": {"redistribute": [{"redist_type": "static"}]}
"redistribute": [{ },
"redist_type": "static"
}]
}
}
} }
} }
} }
@ -222,7 +217,8 @@ def static_or_nw(tgen, topo, tc_name, test_type, dut):
logger.info("Configuring redistribute static route on router %s", dut) logger.info("Configuring redistribute static route on router %s", dut)
result = create_router_bgp(tgen, topo, input_dict_2) result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
elif test_type == "advertise_nw": elif test_type == "advertise_nw":
input_dict_nw = { input_dict_nw = {
@ -231,28 +227,29 @@ def static_or_nw(tgen, topo, tc_name, test_type, dut):
"address_family": { "address_family": {
"ipv4": { "ipv4": {
"unicast": { "unicast": {
"advertise_networks": [ "advertise_networks": [{"network": NETWORK["ipv4"]}]
{"network": NETWORK["ipv4"]}
]
} }
}, },
"ipv6": { "ipv6": {
"unicast": { "unicast": {
"advertise_networks": [ "advertise_networks": [{"network": NETWORK["ipv6"]}]
{"network": NETWORK["ipv6"]}
]
} }
} },
} }
} }
} }
} }
logger.info("Advertising networks %s %s from router %s", logger.info(
NETWORK["ipv4"], NETWORK["ipv6"], dut) "Advertising networks %s %s from router %s",
NETWORK["ipv4"],
NETWORK["ipv6"],
dut,
)
result = create_router_bgp(tgen, topo, input_dict_nw) result = create_router_bgp(tgen, topo, input_dict_nw)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
@pytest.mark.parametrize("ecmp_num", ["8", "16", "32"]) @pytest.mark.parametrize("ecmp_num", ["8", "16", "32"])
@ -275,20 +272,8 @@ def test_modify_ecmp_max_paths(request, ecmp_num, test_type):
"r3": { "r3": {
"bgp": { "bgp": {
"address_family": { "address_family": {
"ipv4": { "ipv4": {"unicast": {"maximum_paths": {"ibgp": ecmp_num,}}},
"unicast": { "ipv6": {"unicast": {"maximum_paths": {"ibgp": ecmp_num,}}},
"maximum_paths": {
"ibgp": ecmp_num,
}
}
},
"ipv6": {
"unicast": {
"maximum_paths": {
"ibgp": ecmp_num,
}
}
}
} }
} }
} }
@ -296,30 +281,27 @@ def test_modify_ecmp_max_paths(request, ecmp_num, test_type):
logger.info("Configuring bgp maximum-paths %s on router r3", ecmp_num) logger.info("Configuring bgp maximum-paths %s on router r3", ecmp_num)
result = create_router_bgp(tgen, topo, input_dict) result = create_router_bgp(tgen, topo, input_dict)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
# Verifying RIB routes # Verifying RIB routes
dut = "r3" dut = "r3"
protocol = "bgp" protocol = "bgp"
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -339,44 +321,39 @@ def test_ecmp_after_clear_bgp(request):
static_or_nw(tgen, topo, tc_name, "redist_static", "r2") static_or_nw(tgen, topo, tc_name, "redist_static", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
# Clear bgp # Clear bgp
result = clear_bgp_and_verify(tgen, topo, dut) result = clear_bgp_and_verify(tgen, topo, dut)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -396,22 +373,20 @@ def test_ecmp_remove_redistribute_static(request):
# Verifying RIB routes # Verifying RIB routes
dut = "r3" dut = "r3"
protocol = "bgp" protocol = "bgp"
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
input_dict_2 = { input_dict_2 = {
"r2": { "r2": {
@ -419,22 +394,14 @@ def test_ecmp_remove_redistribute_static(request):
"address_family": { "address_family": {
"ipv4": { "ipv4": {
"unicast": { "unicast": {
"redistribute": [{ "redistribute": [{"redist_type": "static", "delete": True}]
"redist_type": "static",
"delete": True
}]
} }
}, },
"ipv6": { "ipv6": {
"unicast": { "unicast": {
"redistribute": [{ "redistribute": [{"redist_type": "static", "delete": True}]
"redist_type": "static",
"delete": True
}]
} }
} },
} }
} }
} }
@ -442,76 +409,60 @@ def test_ecmp_remove_redistribute_static(request):
logger.info("Remove redistribute static") logger.info("Remove redistribute static")
result = create_router_bgp(tgen, topo, input_dict_2) result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
# Verifying RIB routes # Verifying RIB routes
dut = "r3" dut = "r3"
protocol = "bgp" protocol = "bgp"
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3 are deleted", addr_type) logger.info("Verifying %s routes on r3 are deleted", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=[], protocol=protocol, expected=False) tgen,
assert result is not True, "Testcase {} : Failed \n Routes still" \ addr_type,
" present in RIB".format(tc_name) dut,
input_dict_1,
next_hop=[],
protocol=protocol,
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n Routes still" " present in RIB".format(tc_name)
logger.info("Enable redistribute static") logger.info("Enable redistribute static")
input_dict_2 = { input_dict_2 = {
"r2": { "r2": {
"bgp": { "bgp": {
"address_family": { "address_family": {
"ipv4": { "ipv4": {"unicast": {"redistribute": [{"redist_type": "static"}]}},
"unicast": { "ipv6": {"unicast": {"redistribute": [{"redist_type": "static"}]}},
"redistribute": [{
"redist_type": "static"
}]
}
},
"ipv6": {
"unicast": {
"redistribute": [{
"redist_type": "static"
}]
}
}
} }
} }
} }
} }
result = create_router_bgp(tgen, topo, input_dict_2) result = create_router_bgp(tgen, topo, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
# Verifying RIB routes # Verifying RIB routes
dut = "r3" dut = "r3"
protocol = "bgp" protocol = "bgp"
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_1, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -533,37 +484,30 @@ def test_ecmp_shut_bgp_neighbor(request):
static_or_nw(tgen, topo, tc_name, "redist_static", "r2") static_or_nw(tgen, topo, tc_name, "redist_static", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
for intf_num in range(len(INTF_LIST_R2)+1, 16): for intf_num in range(len(INTF_LIST_R2) + 1, 16):
intf_val = INTF_LIST_R2[intf_num:intf_num+16] intf_val = INTF_LIST_R2[intf_num : intf_num + 16]
input_dict_1 = { input_dict_1 = {"r2": {"interface_list": [intf_val], "status": "down"}}
"r2": { logger.info("Shutting down neighbor interface {} on r2".format(intf_val))
"interface_list": [intf_val],
"status": "down"
}
}
logger.info("Shutting down neighbor interface {} on r2".
format(intf_val))
result = interface_status(tgen, topo, input_dict_1) result = interface_status(tgen, topo, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
if intf_num + 16 < 32: if intf_num + 16 < 32:
@ -571,52 +515,37 @@ def test_ecmp_shut_bgp_neighbor(request):
else: else:
check_hops = [] check_hops = []
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=check_hops, tgen, addr_type, dut, input_dict, next_hop=check_hops, protocol=protocol
protocol=protocol) )
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
input_dict_1 = { input_dict_1 = {"r2": {"interface_list": INTF_LIST_R2, "status": "up"}}
"r2": {
"interface_list": INTF_LIST_R2,
"status": "up"
}
}
logger.info("Enabling all neighbor interface {} on r2") logger.info("Enabling all neighbor interface {} on r2")
result = interface_status(tgen, topo, input_dict_1) result = interface_status(tgen, topo, input_dict_1)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
static_or_nw(tgen, topo, tc_name, "redist_static", "r2") static_or_nw(tgen, topo, tc_name, "redist_static", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -639,22 +568,20 @@ def test_ecmp_remove_static_route(request):
static_or_nw(tgen, topo, tc_name, "redist_static", "r2") static_or_nw(tgen, topo, tc_name, "redist_static", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_1 = { input_dict_1 = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib( result = verify_rib(
tgen, addr_type, dut, input_dict_1, tgen,
next_hop=NEXT_HOPS[addr_type], protocol=protocol) addr_type,
dut,
input_dict_1,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict_2 = { input_dict_2 = {
@ -663,7 +590,7 @@ def test_ecmp_remove_static_route(request):
{ {
"network": NETWORK[addr_type], "network": NETWORK[addr_type],
"next_hop": NEXT_HOP_IP[addr_type], "next_hop": NEXT_HOP_IP[addr_type],
"delete": True "delete": True,
} }
] ]
} }
@ -672,23 +599,29 @@ def test_ecmp_remove_static_route(request):
logger.info("Remove static routes") logger.info("Remove static routes")
result = create_static_routes(tgen, input_dict_2) result = create_static_routes(tgen, input_dict_2)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
logger.info("Verifying %s routes on r3 are removed", addr_type) logger.info("Verifying %s routes on r3 are removed", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_2, result = verify_rib(
next_hop=[], protocol=protocol, expected=False) tgen,
assert result is not True, "Testcase {} : Failed \n Routes still" \ addr_type,
" present in RIB".format(tc_name) dut,
input_dict_2,
next_hop=[],
protocol=protocol,
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n Routes still" " present in RIB".format(tc_name)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
# Enable static routes # Enable static routes
input_dict_4 = { input_dict_4 = {
"r2": { "r2": {
"static_routes": [ "static_routes": [
{ {"network": NETWORK[addr_type], "next_hop": NEXT_HOP_IP[addr_type]}
"network": NETWORK[addr_type],
"next_hop": NEXT_HOP_IP[addr_type]
}
] ]
} }
} }
@ -696,14 +629,21 @@ def test_ecmp_remove_static_route(request):
logger.info("Enable static route") logger.info("Enable static route")
result = create_static_routes(tgen, input_dict_4) result = create_static_routes(tgen, input_dict_4)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict_4, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict_4,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
write_test_footer(tc_name) write_test_footer(tc_name)
@ -725,22 +665,20 @@ def test_ecmp_remove_nw_advertise(request):
reset_config_on_routers(tgen) reset_config_on_routers(tgen)
static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2") static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
input_dict_3 = { input_dict_3 = {
"r2": { "r2": {
@ -748,64 +686,59 @@ def test_ecmp_remove_nw_advertise(request):
"address_family": { "address_family": {
"ipv4": { "ipv4": {
"unicast": { "unicast": {
"advertise_networks": [{ "advertise_networks": [
"network": NETWORK["ipv4"], {"network": NETWORK["ipv4"], "delete": True}
"delete": True ]
}] }
} },
},
"ipv6": { "ipv6": {
"unicast": { "unicast": {
"advertise_networks": [{ "advertise_networks": [
"network": NETWORK["ipv6"], {"network": NETWORK["ipv6"], "delete": True}
"delete": True ]
}]
}
} }
} },
} }
} }
} }
}
logger.info("Withdraw advertised networks") logger.info("Withdraw advertised networks")
result = create_router_bgp(tgen, topo, input_dict_3) result = create_router_bgp(tgen, topo, input_dict_3)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(tc_name, result)
tc_name, result)
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=[], protocol=protocol, expected=False) tgen,
assert result is not True, "Testcase {} : Failed \n Routes still" \ addr_type,
" present in RIB".format(tc_name) dut,
input_dict,
next_hop=[],
protocol=protocol,
expected=False,
)
assert (
result is not True
), "Testcase {} : Failed \n Routes still" " present in RIB".format(tc_name)
static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2") static_or_nw(tgen, topo, tc_name, "advertise_nw", "r2")
for addr_type in ADDR_TYPES: for addr_type in ADDR_TYPES:
input_dict = { input_dict = {"r3": {"static_routes": [{"network": NETWORK[addr_type]}]}}
"r3": {
"static_routes": [
{
"network": NETWORK[addr_type]
}
]
}
}
logger.info("Verifying %s routes on r3", addr_type) logger.info("Verifying %s routes on r3", addr_type)
result = verify_rib(tgen, addr_type, dut, input_dict, result = verify_rib(
next_hop=NEXT_HOPS[addr_type], tgen,
protocol=protocol) addr_type,
dut,
input_dict,
next_hop=NEXT_HOPS[addr_type],
protocol=protocol,
)
assert result is True, "Testcase {} : Failed \n Error: {}".format( assert result is True, "Testcase {} : Failed \n Error: {}".format(
tc_name, result) tc_name, result
)
if __name__ == "__main__": if __name__ == "__main__":

1120
tests/topotests/bgp-path-attributes-topo1/test_bgp_path_attributes.py
View File

File diff suppressed because it is too large Load Diff

585
tests/topotests/bgp-prefix-list-topo1/test_prefix_lists.py
View File

File diff suppressed because it is too large Load Diff

824
tests/topotests/bgp-route-map/test_route_map_topo1.py
View File

File diff suppressed because it is too large Load Diff

3920
tests/topotests/bgp-route-map/test_route_map_topo2.py
View File

File diff suppressed because it is too large Load Diff

64
tests/topotests/bgp-vrf-route-leak-basic/test_bgp.py
View File

@ -31,7 +31,7 @@ import sys
import pytest import pytest
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -47,7 +47,8 @@ class BGPVRFTopo(Topo):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 2): for routern in range(1, 2):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
def setup_module(mod): def setup_module(mod):
"Sets up the pytest environment" "Sets up the pytest environment"
@ -58,17 +59,16 @@ def setup_module(mod):
for rname, router in tgen.routers().iteritems(): for rname, router in tgen.routers().iteritems():
router.run("/bin/bash {}/setup_vrfs".format(CWD)) router.run("/bin/bash {}/setup_vrfs".format(CWD))
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
# After loading the configurations, this function loads configured daemons. # After loading the configurations, this function loads configured daemons.
tgen.start_router() tgen.start_router()
#tgen.mininet_cli() # tgen.mininet_cli()
def teardown_module(mod): def teardown_module(mod):
"Teardown the pytest environment" "Teardown the pytest environment"
@ -77,6 +77,7 @@ def teardown_module(mod):
# This function tears down the whole topology. # This function tears down the whole topology.
tgen.stop_topology() tgen.stop_topology()
def test_vrf_route_leak(): def test_vrf_route_leak():
logger.info("Ensure that routes are leaked back and forth") logger.info("Ensure that routes are leaked back and forth")
tgen = get_topogen() tgen = get_topogen()
@ -84,49 +85,50 @@ def test_vrf_route_leak():
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
r1 = tgen.gears['r1'] r1 = tgen.gears["r1"]
donna = r1.vtysh_cmd("show ip route vrf DONNA json", isjson=True) donna = r1.vtysh_cmd("show ip route vrf DONNA json", isjson=True)
route0 = donna["10.0.0.0/24"][0] route0 = donna["10.0.0.0/24"][0]
assert route0['protocol'] == "connected" assert route0["protocol"] == "connected"
route1 = donna["10.0.1.0/24"][0] route1 = donna["10.0.1.0/24"][0]
assert route1['protocol'] == "bgp" assert route1["protocol"] == "bgp"
assert route1['selected'] == True assert route1["selected"] == True
nhop = route1['nexthops'][0] nhop = route1["nexthops"][0]
assert nhop['fib'] == True assert nhop["fib"] == True
route2 = donna["10.0.2.0/24"][0] route2 = donna["10.0.2.0/24"][0]
assert route2['protocol'] == "connected" assert route2["protocol"] == "connected"
route3 = donna["10.0.3.0/24"][0] route3 = donna["10.0.3.0/24"][0]
assert route3['protocol'] == "bgp" assert route3["protocol"] == "bgp"
assert route3['selected'] == True assert route3["selected"] == True
nhop = route3['nexthops'][0] nhop = route3["nexthops"][0]
assert nhop['fib'] == True assert nhop["fib"] == True
eva = r1.vtysh_cmd("show ip route vrf EVA json", isjson=True) eva = r1.vtysh_cmd("show ip route vrf EVA json", isjson=True)
route0 = eva["10.0.0.0/24"][0] route0 = eva["10.0.0.0/24"][0]
assert route0['protocol'] == "bgp" assert route0["protocol"] == "bgp"
assert route0['selected'] == True assert route0["selected"] == True
nhop = route0['nexthops'][0] nhop = route0["nexthops"][0]
assert nhop['fib'] == True assert nhop["fib"] == True
route1 = eva["10.0.1.0/24"][0] route1 = eva["10.0.1.0/24"][0]
assert route1['protocol'] == "connected" assert route1["protocol"] == "connected"
route2 = eva["10.0.2.0/24"][0] route2 = eva["10.0.2.0/24"][0]
assert route2['protocol'] == "bgp" assert route2["protocol"] == "bgp"
assert route2['selected'] == True assert route2["selected"] == True
nhop = route2['nexthops'][0] nhop = route2["nexthops"][0]
assert nhop['fib'] == True assert nhop["fib"] == True
route3 = eva["10.0.3.0/24"][0] route3 = eva["10.0.3.0/24"][0]
assert route3['protocol'] == "connected" assert route3["protocol"] == "connected"
#tgen.mininet_cli() # tgen.mininet_cli()
def test_memory_leak(): def test_memory_leak():
"Run the memory leak test and report results." "Run the memory leak test and report results."
tgen = get_topogen() tgen = get_topogen()
if not tgen.is_memleak_enabled(): if not tgen.is_memleak_enabled():
pytest.skip('Memory leak test/report is disabled') pytest.skip("Memory leak test/report is disabled")
tgen.report_memory_leaks() tgen.report_memory_leaks()
if __name__ == '__main__': if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

47
tests/topotests/bgp_aggregate-address_origin/test_bgp_aggregate-address_origin.py
View File

@ -39,7 +39,7 @@ import pytest
import functools import functools
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -47,16 +47,18 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 3): for routern in range(1, 3):
tgen.add_router('r{}'.format(routern)) 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'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -66,51 +68,41 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_bgp_aggregate_address_origin(): def test_bgp_aggregate_address_origin():
tgen = get_topogen() tgen = get_topogen()
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
router = tgen.gears['r2'] router = tgen.gears["r2"]
def _bgp_converge(router): def _bgp_converge(router):
output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")) output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json"))
expected = { expected = {
'192.168.255.1': { "192.168.255.1": {
'bgpState': 'Established', "bgpState": "Established",
'addressFamilyInfo': { "addressFamilyInfo": {"ipv4Unicast": {"acceptedPrefixCounter": 3}},
'ipv4Unicast': {
'acceptedPrefixCounter': 3
}
}
} }
} }
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
def _bgp_aggregate_address_has_metric(router): def _bgp_aggregate_address_has_metric(router):
output = json.loads(router.vtysh_cmd("show ip bgp 172.16.255.0/24 json")) output = json.loads(router.vtysh_cmd("show ip bgp 172.16.255.0/24 json"))
expected = { expected = {"paths": [{"origin": "IGP"}]}
'paths': [
{
'origin': 'IGP'
}
]
}
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
test_func = functools.partial(_bgp_converge, router) test_func = functools.partial(_bgp_converge, router)
@ -121,8 +113,11 @@ def test_bgp_aggregate_address_origin():
test_func = functools.partial(_bgp_aggregate_address_has_metric, router) test_func = functools.partial(_bgp_aggregate_address_has_metric, router)
success, result = topotest.run_and_expect(test_func, None, count=30, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=30, wait=0.5)
assert result is None, 'Failed to see applied ORIGIN (igp) for aggregated prefix in "{}"'.format(router) assert (
result is None
), 'Failed to see applied ORIGIN (igp) for aggregated prefix in "{}"'.format(router)
if __name__ == '__main__':
if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

47
tests/topotests/bgp_aggregate-address_route-map/test_bgp_aggregate-address_route-map.py
View File

@ -42,7 +42,7 @@ import pytest
import functools import functools
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -50,16 +50,18 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 3): for routern in range(1, 3):
tgen.add_router('r{}'.format(routern)) 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'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -69,51 +71,41 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_bgp_maximum_prefix_invalid(): def test_bgp_maximum_prefix_invalid():
tgen = get_topogen() tgen = get_topogen()
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
router = tgen.gears['r2'] router = tgen.gears["r2"]
def _bgp_converge(router): def _bgp_converge(router):
output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")) output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json"))
expected = { expected = {
'192.168.255.1': { "192.168.255.1": {
'bgpState': 'Established', "bgpState": "Established",
'addressFamilyInfo': { "addressFamilyInfo": {"ipv4Unicast": {"acceptedPrefixCounter": 3}},
'ipv4Unicast': {
'acceptedPrefixCounter': 3
}
}
} }
} }
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
def _bgp_aggregate_address_has_metric(router): def _bgp_aggregate_address_has_metric(router):
output = json.loads(router.vtysh_cmd("show ip bgp 172.16.255.0/24 json")) output = json.loads(router.vtysh_cmd("show ip bgp 172.16.255.0/24 json"))
expected = { expected = {"paths": [{"metric": 123}]}
'paths': [
{
'metric': 123
}
]
}
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
test_func = functools.partial(_bgp_converge, router) test_func = functools.partial(_bgp_converge, router)
@ -124,8 +116,11 @@ def test_bgp_maximum_prefix_invalid():
test_func = functools.partial(_bgp_aggregate_address_has_metric, router) test_func = functools.partial(_bgp_aggregate_address_has_metric, router)
success, result = topotest.run_and_expect(test_func, None, count=30, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=30, wait=0.5)
assert result is None, 'Failed to see applied metric for aggregated prefix in "{}"'.format(router) assert (
result is None
), 'Failed to see applied metric for aggregated prefix in "{}"'.format(router)
if __name__ == '__main__':
if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

45
tests/topotests/bgp_as_wide_bgp_identifier/test_bgp_as_wide_bgp_identifier.py
View File

@ -37,7 +37,7 @@ import pytest
import functools import functools
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -45,17 +45,19 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 4): for routern in range(1, 4):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
switch = tgen.add_switch("s1")
switch.add_link(tgen.gears["r1"])
switch.add_link(tgen.gears["r2"])
switch.add_link(tgen.gears["r3"])
switch = tgen.add_switch('s1')
switch.add_link(tgen.gears['r1'])
switch.add_link(tgen.gears['r2'])
switch.add_link(tgen.gears['r3'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -65,20 +67,20 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_bgp_as_wide_bgp_identifier(): def test_bgp_as_wide_bgp_identifier():
tgen = get_topogen() tgen = get_topogen()
@ -87,32 +89,31 @@ def test_bgp_as_wide_bgp_identifier():
def _bgp_converge(router): def _bgp_converge(router):
output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")) output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json"))
expected = { expected = {"192.168.255.1": {"bgpState": "Established"}}
'192.168.255.1': {
'bgpState': 'Established'
}
}
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
def _bgp_failed(router): def _bgp_failed(router):
output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")) output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json"))
expected = { expected = {
'192.168.255.1': { "192.168.255.1": {
'lastNotificationReason': 'OPEN Message Error/Bad BGP Identifier' "lastNotificationReason": "OPEN Message Error/Bad BGP Identifier"
} }
} }
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
test_func = functools.partial(_bgp_converge, tgen.gears['r1']) test_func = functools.partial(_bgp_converge, tgen.gears["r1"])
success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assert result is None, 'Failed to converge: "{}"'.format(tgen.gears['r1']) assert result is None, 'Failed to converge: "{}"'.format(tgen.gears["r1"])
test_func = functools.partial(_bgp_failed, tgen.gears['r3']) test_func = functools.partial(_bgp_failed, tgen.gears["r3"])
success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assert result is None, 'Bad BGP Identifier notification not sent: "{}"'.format(tgen.gears['r3']) assert result is None, 'Bad BGP Identifier notification not sent: "{}"'.format(
tgen.gears["r3"]
)
if __name__ == '__main__':
if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

46
tests/topotests/bgp_comm-list_delete/test_bgp_comm-list_delete.py
View File

@ -37,7 +37,7 @@ import time
import pytest import pytest
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -45,16 +45,18 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 3): for routern in range(1, 3):
tgen.add_router('r{}'.format(routern)) 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'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -64,20 +66,20 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_bgp_maximum_prefix_invalid(): def test_bgp_maximum_prefix_invalid():
tgen = get_topogen() tgen = get_topogen()
@ -86,20 +88,30 @@ def test_bgp_maximum_prefix_invalid():
def _bgp_converge(router): def _bgp_converge(router):
while True: while True:
output = json.loads(tgen.gears[router].vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")) output = json.loads(
if output['192.168.255.1']['bgpState'] == 'Established': tgen.gears[router].vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")
if output['192.168.255.1']['addressFamilyInfo']['ipv4Unicast']['acceptedPrefixCounter'] == 2: )
if output["192.168.255.1"]["bgpState"] == "Established":
if (
output["192.168.255.1"]["addressFamilyInfo"]["ipv4Unicast"][
"acceptedPrefixCounter"
]
== 2
):
return True return True
def _bgp_comm_list_delete(router): def _bgp_comm_list_delete(router):
output = json.loads(tgen.gears[router].vtysh_cmd("show ip bgp 172.16.255.254/32 json")) output = json.loads(
if '333:333' in output['paths'][0]['community']['list']: tgen.gears[router].vtysh_cmd("show ip bgp 172.16.255.254/32 json")
)
if "333:333" in output["paths"][0]["community"]["list"]:
return False return False
return True return True
if _bgp_converge('r2'): if _bgp_converge("r2"):
assert _bgp_comm_list_delete('r2') == True assert _bgp_comm_list_delete("r2") == True
if __name__ == '__main__':
if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

47
tests/topotests/bgp_default-route_route-map/test_bgp_default-originate_route-map.py
View File

@ -42,7 +42,7 @@ import pytest
import functools import functools
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -50,16 +50,18 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 3): for routern in range(1, 3):
tgen.add_router('r{}'.format(routern)) 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'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -69,51 +71,41 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_bgp_default_originate_route_map(): def test_bgp_default_originate_route_map():
tgen = get_topogen() tgen = get_topogen()
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
router = tgen.gears['r2'] router = tgen.gears["r2"]
def _bgp_converge(router): def _bgp_converge(router):
output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")) output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.1 json"))
expected = { expected = {
'192.168.255.1': { "192.168.255.1": {
'bgpState': 'Established', "bgpState": "Established",
'addressFamilyInfo': { "addressFamilyInfo": {"ipv4Unicast": {"acceptedPrefixCounter": 1}},
'ipv4Unicast': {
'acceptedPrefixCounter': 1
}
}
} }
} }
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
def _bgp_default_route_has_metric(router): def _bgp_default_route_has_metric(router):
output = json.loads(router.vtysh_cmd("show ip bgp 0.0.0.0/0 json")) output = json.loads(router.vtysh_cmd("show ip bgp 0.0.0.0/0 json"))
expected = { expected = {"paths": [{"metric": 123}]}
'paths': [
{
'metric': 123
}
]
}
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
test_func = functools.partial(_bgp_converge, router) test_func = functools.partial(_bgp_converge, router)
@ -124,8 +116,11 @@ def test_bgp_default_originate_route_map():
test_func = functools.partial(_bgp_default_route_has_metric, router) test_func = functools.partial(_bgp_default_route_has_metric, router)
success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assert result is None, 'Failed to see applied metric for default route in "{}"'.format(router) assert (
result is None
), 'Failed to see applied metric for default route in "{}"'.format(router)
if __name__ == '__main__':
if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

54
tests/topotests/bgp_distance_change/test_bgp_distance_change.py
View File

@ -41,7 +41,7 @@ import pytest
import functools import functools
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -49,16 +49,18 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 3): for routern in range(1, 3):
tgen.add_router('r{}'.format(routern)) 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'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -68,60 +70,51 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_bgp_maximum_prefix_invalid(): def test_bgp_maximum_prefix_invalid():
tgen = get_topogen() tgen = get_topogen()
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
router = tgen.gears['r1'] router = tgen.gears["r1"]
def _bgp_converge(router): def _bgp_converge(router):
output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.2 json")) output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.2 json"))
expected = { expected = {
'192.168.255.2': { "192.168.255.2": {
'bgpState': 'Established', "bgpState": "Established",
'addressFamilyInfo': { "addressFamilyInfo": {"ipv4Unicast": {"acceptedPrefixCounter": 2}},
'ipv4Unicast': {
'acceptedPrefixCounter': 2
}
}
} }
} }
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
def _bgp_distance_change(router): def _bgp_distance_change(router):
router.vtysh_cmd(""" router.vtysh_cmd(
"""
configure terminal configure terminal
router bgp 65000 router bgp 65000
address-family ipv4 unicast address-family ipv4 unicast
distance bgp 123 123 123 distance bgp 123 123 123
""") """
)
def _bgp_check_distance_change(router): def _bgp_check_distance_change(router):
output = json.loads(router.vtysh_cmd("show ip route 172.16.255.254/32 json")) output = json.loads(router.vtysh_cmd("show ip route 172.16.255.254/32 json"))
expected = { expected = {"172.16.255.254/32": [{"protocol": "bgp", "distance": 123}]}
'172.16.255.254/32': [
{
'protocol': 'bgp',
'distance': 123
}
]
}
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
test_func = functools.partial(_bgp_converge, router) test_func = functools.partial(_bgp_converge, router)
@ -134,8 +127,11 @@ def test_bgp_maximum_prefix_invalid():
test_func = functools.partial(_bgp_check_distance_change, router) test_func = functools.partial(_bgp_check_distance_change, router)
success, result = topotest.run_and_expect(test_func, None, count=15, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=15, wait=0.5)
assert result is None, 'Failed to see applied BGP distance in RIB "{}"'.format(router) assert result is None, 'Failed to see applied BGP distance in RIB "{}"'.format(
router
)
if __name__ == '__main__':
if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

73
tests/topotests/bgp_ebgp_requires_policy/test_bgp_ebgp_requires_policy.py
View File

@ -37,7 +37,7 @@ import pytest
import functools import functools
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -45,24 +45,26 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 7): for routern in range(1, 7):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
switch = tgen.add_switch('s1') switch = tgen.add_switch("s1")
switch.add_link(tgen.gears['r1']) switch.add_link(tgen.gears["r1"])
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch = tgen.add_switch('s2') switch = tgen.add_switch("s2")
switch.add_link(tgen.gears['r3']) switch.add_link(tgen.gears["r3"])
switch.add_link(tgen.gears['r4']) switch.add_link(tgen.gears["r4"])
switch = tgen.add_switch("s3")
switch.add_link(tgen.gears["r5"])
switch.add_link(tgen.gears["r6"])
switch = tgen.add_switch('s3')
switch.add_link(tgen.gears['r5'])
switch.add_link(tgen.gears['r6'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -72,20 +74,20 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_ebgp_requires_policy(): def test_ebgp_requires_policy():
tgen = get_topogen() tgen = get_topogen()
@ -93,51 +95,46 @@ def test_ebgp_requires_policy():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
def _bgp_converge(router): def _bgp_converge(router):
output = json.loads(tgen.gears[router].vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")) output = json.loads(
expected = { tgen.gears[router].vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")
'192.168.255.1': { )
'bgpState': 'Established' expected = {"192.168.255.1": {"bgpState": "Established"}}
}
}
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
def _bgp_has_routes(router): def _bgp_has_routes(router):
output = json.loads(tgen.gears[router].vtysh_cmd("show ip bgp neighbor 192.168.255.1 routes json")) output = json.loads(
expected = { tgen.gears[router].vtysh_cmd(
'routes': { "show ip bgp neighbor 192.168.255.1 routes json"
'172.16.255.254/32': [ )
{ )
'valid': True expected = {"routes": {"172.16.255.254/32": [{"valid": True}]}}
}
]
}
}
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
test_func = functools.partial(_bgp_converge, 'r2') test_func = functools.partial(_bgp_converge, "r2")
success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assert success is True, 'Failed bgp convergence (r2) in "{}"'.format(router) assert success is True, 'Failed bgp convergence (r2) in "{}"'.format(router)
test_func = functools.partial(_bgp_has_routes, 'r2') test_func = functools.partial(_bgp_has_routes, "r2")
success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assert success is True, 'eBGP policy is not working (r2) in "{}"'.format(router) assert success is True, 'eBGP policy is not working (r2) in "{}"'.format(router)
test_func = functools.partial(_bgp_converge, 'r4') test_func = functools.partial(_bgp_converge, "r4")
success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assert success is True, 'Failed bgp convergence (r4) in "{}"'.format(router) assert success is True, 'Failed bgp convergence (r4) in "{}"'.format(router)
test_func = functools.partial(_bgp_has_routes, 'r4') test_func = functools.partial(_bgp_has_routes, "r4")
success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assert success is False, 'eBGP policy is not working (r4) in "{}"'.format(router) assert success is False, 'eBGP policy is not working (r4) in "{}"'.format(router)
test_func = functools.partial(_bgp_converge, 'r6') test_func = functools.partial(_bgp_converge, "r6")
success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assert success is True, 'Failed bgp convergence (r6) in "{}"'.format(router) assert success is True, 'Failed bgp convergence (r6) in "{}"'.format(router)
test_func = functools.partial(_bgp_has_routes, 'r6') test_func = functools.partial(_bgp_has_routes, "r6")
success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5) success, result = topotest.run_and_expect(test_func, None, count=60, wait=0.5)
assert success is True, 'eBGP policy is not working (r6) in "{}"'.format(router) assert success is True, 'eBGP policy is not working (r6) in "{}"'.format(router)
if __name__ == '__main__':
if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

73
tests/topotests/bgp_instance_del_test/test_bgp_instance_del_test.py
View File

@ -25,65 +25,72 @@ import os
import sys import sys
import pytest import pytest
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), '../')) sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../"))
from lib.ltemplate import * from lib.ltemplate import *
def test_check_linux_vrf(): def test_check_linux_vrf():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/check_linux_vrf.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/check_linux_vrf.py", False, CliOnFail, CheckFunc)
def test_adjacencies(): def test_adjacencies():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\')' CheckFunc = "ltemplateVersionCheck('4.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)'
ltemplateTest('scripts/adjacencies.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/adjacencies.py", False, CliOnFail, CheckFunc)
def SKIP_test_add_routes(): def SKIP_test_add_routes():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\')' CheckFunc = "ltemplateVersionCheck('4.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)'
ltemplateTest('scripts/add_routes.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/add_routes.py", False, CliOnFail, CheckFunc)
def test_check_routes(): def test_check_routes():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\')' CheckFunc = "ltemplateVersionCheck('4.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)'
ltemplateTest('scripts/check_routes.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/check_routes.py", False, CliOnFail, CheckFunc)
#manual data path setup test - remove once have bgp/zebra vrf path working
# manual data path setup test - remove once have bgp/zebra vrf path working
def test_check_linux_mpls(): def test_check_linux_mpls():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/check_linux_mpls.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/check_linux_mpls.py", False, CliOnFail, CheckFunc)
def test_del_bgp_instances(): def test_del_bgp_instances():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\')' CheckFunc = "ltemplateVersionCheck('4.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)'
ltemplateTest('scripts/del_bgp_instances.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/del_bgp_instances.py", False, CliOnFail, CheckFunc)
if __name__ == '__main__':
if __name__ == "__main__":
retval = pytest.main(["-s"]) retval = pytest.main(["-s"])
sys.exit(retval) sys.exit(retval)

56
tests/topotests/bgp_ipv6_rtadv/test_bgp_ipv6_rtadv.py
View File

@ -34,7 +34,7 @@ import pytest
# Save the Current Working Directory to find configuration files. # Save the Current Working Directory to find configuration files.
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
# Import topogen and topotest helpers # Import topogen and topotest helpers
@ -48,17 +48,19 @@ from mininet.topo import Topo
class BGPIPV6RTADVTopo(Topo): class BGPIPV6RTADVTopo(Topo):
"Test topology builder" "Test topology builder"
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
"Build function" "Build function"
tgen = get_topogen(self) tgen = get_topogen(self)
# Create 2 routers. # Create 2 routers.
tgen.add_router('r1') tgen.add_router("r1")
tgen.add_router('r2') tgen.add_router("r2")
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'])
def setup_module(mod): def setup_module(mod):
"Sets up the pytest environment" "Sets up the pytest environment"
@ -69,17 +71,16 @@ def setup_module(mod):
for rname, router in router_list.iteritems(): for rname, router in router_list.iteritems():
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
# Initialize all routers. # Initialize all routers.
tgen.start_router() tgen.start_router()
def teardown_module(_mod): def teardown_module(_mod):
"Teardown the pytest environment" "Teardown the pytest environment"
tgen = get_topogen() tgen = get_topogen()
@ -99,44 +100,51 @@ def test_protocols_convergence():
# Check IPv4 routing tables. # Check IPv4 routing tables.
logger.info("Checking IPv4 routes for convergence") logger.info("Checking IPv4 routes for convergence")
for router in tgen.routers().values(): for router in tgen.routers().values():
json_file = '{}/{}/ipv4_routes.json'.format(CWD, router.name) json_file = "{}/{}/ipv4_routes.json".format(CWD, router.name)
if not os.path.isfile(json_file): if not os.path.isfile(json_file):
logger.info('skipping file {}'.format(json_file)) logger.info("skipping file {}".format(json_file))
continue continue
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ip route json'.format(router.name), expected) topotest.router_json_cmp,
_, result = topotest.run_and_expect(test_func, None, count=160, router,
wait=0.5) "show ip route json".format(router.name),
expected,
)
_, result = topotest.run_and_expect(test_func, None, count=160, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
# Check IPv6 routing tables. # Check IPv6 routing tables.
logger.info("Checking IPv6 routes for convergence") logger.info("Checking IPv6 routes for convergence")
for router in tgen.routers().values(): for router in tgen.routers().values():
json_file = '{}/{}/ipv6_routes.json'.format(CWD, router.name) json_file = "{}/{}/ipv6_routes.json".format(CWD, router.name)
if not os.path.isfile(json_file): if not os.path.isfile(json_file):
logger.info('skipping file {}'.format(json_file)) logger.info("skipping file {}".format(json_file))
continue continue
expected = json.loads(open(json_file).read()) expected = json.loads(open(json_file).read())
test_func = partial(topotest.router_json_cmp, test_func = partial(
router, 'show ipv6 route json'.format(router.name), expected) topotest.router_json_cmp,
_, result = topotest.run_and_expect(test_func, None, count=160, router,
wait=0.5) "show ipv6 route json".format(router.name),
expected,
)
_, result = topotest.run_and_expect(test_func, None, count=160, wait=0.5)
assertmsg = '"{}" JSON output mismatches'.format(router.name) assertmsg = '"{}" JSON output mismatches'.format(router.name)
assert result is None, assertmsg assert result is None, assertmsg
def test_memory_leak(): def test_memory_leak():
"Run the memory leak test and report results." "Run the memory leak test and report results."
tgen = get_topogen() tgen = get_topogen()
if not tgen.is_memleak_enabled(): if not tgen.is_memleak_enabled():
pytest.skip('Memory leak test/report is disabled') pytest.skip("Memory leak test/report is disabled")
tgen.report_memory_leaks() tgen.report_memory_leaks()
if __name__ == '__main__': if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

76
tests/topotests/bgp_l3vpn_to_bgp_direct/customize.py
View File

@ -88,12 +88,15 @@ from lib.ltemplate import ltemplateRtrCmd
from mininet.topo import Topo from mininet.topo import Topo
import shutil import shutil
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
# test name based on directory # test name based on directory
TEST = os.path.basename(CWD) TEST = os.path.basename(CWD)
class ThisTestTopo(Topo): class ThisTestTopo(Topo):
"Test topology builder" "Test topology builder"
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
"Build function" "Build function"
tgen = get_topogen(self) tgen = get_topogen(self)
@ -102,68 +105,71 @@ class ThisTestTopo(Topo):
# between routers, switches and hosts. # between routers, switches and hosts.
# #
# Create P/PE routers # Create P/PE routers
tgen.add_router('r1') tgen.add_router("r1")
#check for mpls # check for mpls
if tgen.hasmpls != True: if tgen.hasmpls != True:
logger.info('MPLS not available, tests will be skipped') logger.info("MPLS not available, tests will be skipped")
return return
for routern in range(2, 5): for routern in range(2, 5):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
# Create CE routers # Create CE routers
for routern in range(1, 4): for routern in range(1, 4):
tgen.add_router('ce{}'.format(routern)) tgen.add_router("ce{}".format(routern))
#CE/PE links # CE/PE links
tgen.add_link(tgen.gears['ce1'], tgen.gears['r1'], 'ce1-eth0', 'r1-eth4') tgen.add_link(tgen.gears["ce1"], tgen.gears["r1"], "ce1-eth0", "r1-eth4")
tgen.add_link(tgen.gears['ce2'], tgen.gears['r3'], 'ce2-eth0', 'r3-eth4') tgen.add_link(tgen.gears["ce2"], tgen.gears["r3"], "ce2-eth0", "r3-eth4")
tgen.add_link(tgen.gears['ce3'], tgen.gears['r4'], 'ce3-eth0', 'r4-eth4') tgen.add_link(tgen.gears["ce3"], tgen.gears["r4"], "ce3-eth0", "r4-eth4")
# Create a switch with just one router connected to it to simulate a # Create a switch with just one router connected to it to simulate a
# empty network. # empty network.
switch = {} switch = {}
switch[0] = tgen.add_switch('sw0') switch[0] = tgen.add_switch("sw0")
switch[0].add_link(tgen.gears['r1'], nodeif='r1-eth0') switch[0].add_link(tgen.gears["r1"], nodeif="r1-eth0")
switch[0].add_link(tgen.gears['r2'], nodeif='r2-eth0') switch[0].add_link(tgen.gears["r2"], nodeif="r2-eth0")
switch[1] = tgen.add_switch('sw1') switch[1] = tgen.add_switch("sw1")
switch[1].add_link(tgen.gears['r2'], nodeif='r2-eth1') switch[1].add_link(tgen.gears["r2"], nodeif="r2-eth1")
switch[1].add_link(tgen.gears['r3'], nodeif='r3-eth0') switch[1].add_link(tgen.gears["r3"], nodeif="r3-eth0")
switch[1].add_link(tgen.gears['r4'], nodeif='r4-eth0') switch[1].add_link(tgen.gears["r4"], nodeif="r4-eth0")
switch[1] = tgen.add_switch("sw2")
switch[1].add_link(tgen.gears["r2"], nodeif="r2-eth2")
switch[1].add_link(tgen.gears["r3"], nodeif="r3-eth1")
switch[1] = tgen.add_switch('sw2')
switch[1].add_link(tgen.gears['r2'], nodeif='r2-eth2')
switch[1].add_link(tgen.gears['r3'], nodeif='r3-eth1')
def ltemplatePreRouterStartHook(): def ltemplatePreRouterStartHook():
cc = ltemplateRtrCmd() cc = ltemplateRtrCmd()
tgen = get_topogen() tgen = get_topogen()
logger.info('pre router-start hook') logger.info("pre router-start hook")
#check for mpls # check for mpls
if tgen.hasmpls != True: if tgen.hasmpls != True:
logger.info('MPLS not available, skipping setup') logger.info("MPLS not available, skipping setup")
return False return False
#check for normal init # check for normal init
if len(tgen.net) == 1: if len(tgen.net) == 1:
logger.info('Topology not configured, skipping setup') logger.info("Topology not configured, skipping setup")
return False return False
#configure r2 mpls interfaces # configure r2 mpls interfaces
intfs = ['lo', 'r2-eth0', 'r2-eth1', 'r2-eth2'] intfs = ["lo", "r2-eth0", "r2-eth1", "r2-eth2"]
for intf in intfs: for intf in intfs:
cc.doCmd(tgen, 'r2', 'echo 1 > /proc/sys/net/mpls/conf/{}/input'.format(intf)) cc.doCmd(tgen, "r2", "echo 1 > /proc/sys/net/mpls/conf/{}/input".format(intf))
#configure MPLS # configure MPLS
rtrs = ['r1', 'r3', 'r4'] rtrs = ["r1", "r3", "r4"]
cmds = ['echo 1 > /proc/sys/net/mpls/conf/lo/input'] cmds = ["echo 1 > /proc/sys/net/mpls/conf/lo/input"]
for rtr in rtrs: for rtr in rtrs:
router = tgen.gears[rtr] router = tgen.gears[rtr]
for cmd in cmds: for cmd in cmds:
cc.doCmd(tgen, rtr, cmd) cc.doCmd(tgen, rtr, cmd)
intfs = ['lo', rtr+'-eth0', rtr+'-eth4'] intfs = ["lo", rtr + "-eth0", rtr + "-eth4"]
for intf in intfs: for intf in intfs:
cc.doCmd(tgen, rtr, 'echo 1 > /proc/sys/net/mpls/conf/{}/input'.format(intf)) cc.doCmd(
logger.info('setup mpls input') tgen, rtr, "echo 1 > /proc/sys/net/mpls/conf/{}/input".format(intf)
)
logger.info("setup mpls input")
return True return True
def ltemplatePostRouterStartHook(): def ltemplatePostRouterStartHook():
logger.info('post router-start hook') logger.info("post router-start hook")
return True return True

226
tests/topotests/bgp_l3vpn_to_bgp_direct/scripts/add_routes.py
View File

@ -1,51 +1,193 @@
from lutil import luCommand from lutil import luCommand
luCommand('r1','vtysh -c "show bgp next"','99.0.0.. valid', 'wait', 'See CE static NH')
luCommand('r3','vtysh -c "show bgp next"','99.0.0.. valid', 'wait', 'See CE static NH')
luCommand('r4','vtysh -c "show bgp next"','99.0.0.. valid', 'wait', 'See CE static NH')
luCommand('r1','vtysh -c "show bgp ipv4 uni"','i5.*i5','wait','See CE routes')
luCommand('r3','vtysh -c "show bgp ipv4 uni"','i5.*i5','wait','See CE routes')
luCommand('r4','vtysh -c "show bgp ipv4 uni"','i5.*i5','wait','See CE routes')
luCommand('ce1','vtysh -c "show bgp ipv4 uni 5.1.0.0/24"','','none','See CE routes')
luCommand('r1','vtysh -c "show bgp ipv4 uni 5.1.0.0/24"','','none','See CE routes')
luCommand('ce2','vtysh -c "show bgp ipv4 uni 5.1.0.0/24"','','none','See CE routes')
luCommand('r3','vtysh -c "show bgp ipv4 uni 5.1.0.0/24"','','none','See CE routes')
luCommand('ce3','vtysh -c "show bgp ipv4 uni 5.1.2.0/24"','','none','See CE routes')
luCommand('r4','vtysh -c "show bgp ipv4 uni 5.1.2.0/24"','','none','See CE routes')
luCommand('r1','vtysh -c "add vrf cust1 prefix 99.0.0.1/32"','.','none','IP Address') luCommand(
luCommand('r1','vtysh -c "show vnc registrations local"','99.0.0.1','wait','Local Registration') "r1", 'vtysh -c "show bgp next"', "99.0.0.. valid", "wait", "See CE static NH"
luCommand('r1','vtysh -c "show vnc registrations imported"','2 out of 2 imported','wait','Imported Registrations') )
luCommand('r3','vtysh -c "show bgp ipv4 vpn"','i99.0.0.1/32','wait','See R1s static address') luCommand(
luCommand('r4','vtysh -c "show bgp ipv4 vpn"','i99.0.0.1/32','wait','See R1s static address') "r3", 'vtysh -c "show bgp next"', "99.0.0.. valid", "wait", "See CE static NH"
luCommand('r3','vtysh -c "show bgp ipv4 vpn rd 10:1"','i5.*i5','wait','See R1s imports') )
luCommand('r4','vtysh -c "show bgp ipv4 vpn rd 10:1"','i5.*i5','wait','See R1s imports') luCommand(
"r4", 'vtysh -c "show bgp next"', "99.0.0.. valid", "wait", "See CE static NH"
)
luCommand("r1", 'vtysh -c "show bgp ipv4 uni"', "i5.*i5", "wait", "See CE routes")
luCommand("r3", 'vtysh -c "show bgp ipv4 uni"', "i5.*i5", "wait", "See CE routes")
luCommand("r4", 'vtysh -c "show bgp ipv4 uni"', "i5.*i5", "wait", "See CE routes")
luCommand("ce1", 'vtysh -c "show bgp ipv4 uni 5.1.0.0/24"', "", "none", "See CE routes")
luCommand("r1", 'vtysh -c "show bgp ipv4 uni 5.1.0.0/24"', "", "none", "See CE routes")
luCommand("ce2", 'vtysh -c "show bgp ipv4 uni 5.1.0.0/24"', "", "none", "See CE routes")
luCommand("r3", 'vtysh -c "show bgp ipv4 uni 5.1.0.0/24"', "", "none", "See CE routes")
luCommand("ce3", 'vtysh -c "show bgp ipv4 uni 5.1.2.0/24"', "", "none", "See CE routes")
luCommand("r4", 'vtysh -c "show bgp ipv4 uni 5.1.2.0/24"', "", "none", "See CE routes")
luCommand('r3','vtysh -c "add vrf cust1 prefix 99.0.0.2/32"','.','none','IP Address') luCommand(
luCommand('r3','vtysh -c "show vnc registrations local"','99.0.0.2','wait','Local Registration') "r1", 'vtysh -c "add vrf cust1 prefix 99.0.0.1/32"', ".", "none", "IP Address"
have2ndImports = luCommand('r3','vtysh -c "show vnc registrations imported"','2 out of 2 imported','none','Imported Registrations',2) )
luCommand(
"r1",
'vtysh -c "show vnc registrations local"',
"99.0.0.1",
"wait",
"Local Registration",
)
luCommand(
"r1",
'vtysh -c "show vnc registrations imported"',
"2 out of 2 imported",
"wait",
"Imported Registrations",
)
luCommand(
"r3",
'vtysh -c "show bgp ipv4 vpn"',
"i99.0.0.1/32",
"wait",
"See R1s static address",
)
luCommand(
"r4",
'vtysh -c "show bgp ipv4 vpn"',
"i99.0.0.1/32",
"wait",
"See R1s static address",
)
luCommand(
"r3", 'vtysh -c "show bgp ipv4 vpn rd 10:1"', "i5.*i5", "wait", "See R1s imports"
)
luCommand(
"r4", 'vtysh -c "show bgp ipv4 vpn rd 10:1"', "i5.*i5", "wait", "See R1s imports"
)
luCommand(
"r3", 'vtysh -c "add vrf cust1 prefix 99.0.0.2/32"', ".", "none", "IP Address"
)
luCommand(
"r3",
'vtysh -c "show vnc registrations local"',
"99.0.0.2",
"wait",
"Local Registration",
)
have2ndImports = luCommand(
"r3",
'vtysh -c "show vnc registrations imported"',
"2 out of 2 imported",
"none",
"Imported Registrations",
2,
)
if have2ndImports: if have2ndImports:
luCommand('r3','vtysh -c "show vnc registrations imported"','2 out of 2 imported','pass','Imported Registrations') luCommand(
luCommand('r1','vtysh -c "show bgp ipv4 vpn"','i99.0.0.2/32','wait','See R3s static address') "r3",
luCommand('r4','vtysh -c "show bgp ipv4 vpn"','i99.0.0.2/32','wait','See R3s static address') 'vtysh -c "show vnc registrations imported"',
"2 out of 2 imported",
"pass",
"Imported Registrations",
)
luCommand(
"r1",
'vtysh -c "show bgp ipv4 vpn"',
"i99.0.0.2/32",
"wait",
"See R3s static address",
)
luCommand(
"r4",
'vtysh -c "show bgp ipv4 vpn"',
"i99.0.0.2/32",
"wait",
"See R3s static address",
)
if have2ndImports: if have2ndImports:
luCommand('r1','vtysh -c "show bgp ipv4 vpn rd 10:3"','i5.*i5','none','See R3s imports') luCommand(
luCommand('r4','vtysh -c "show bgp ipv4 vpn rd 10:3"','i5.*i5','none','See R3s imports') "r1",
'vtysh -c "show bgp ipv4 vpn rd 10:3"',
"i5.*i5",
"none",
"See R3s imports",
)
luCommand(
"r4",
'vtysh -c "show bgp ipv4 vpn rd 10:3"',
"i5.*i5",
"none",
"See R3s imports",
)
luCommand('r4','vtysh -c "add vrf cust1 prefix 99.0.0.3/32"','.','none','IP Address') luCommand(
luCommand('r4','vtysh -c "show vnc registrations local"','99.0.0.3','wait','Local Registration') "r4", 'vtysh -c "add vrf cust1 prefix 99.0.0.3/32"', ".", "none", "IP Address"
luCommand('r4','vtysh -c "show vnc registrations imported"','2 out of 2 imported','wait','Imported Registrations') )
luCommand('r1','vtysh -c "show bgp ipv4 vpn"','i99.0.0.3/32','wait','See R4s static address') luCommand(
luCommand('r3','vtysh -c "show bgp ipv4 vpn"','i99.0.0.3/32','wait','See R4s static address') "r4",
luCommand('r1','vtysh -c "show bgp ipv4 vpn rd 10:4"','i5.*i5','wait','See R4s imports') 'vtysh -c "show vnc registrations local"',
luCommand('r3','vtysh -c "show bgp ipv4 vpn rd 10:4"','i5.*i5','wait','See R4s imports') "99.0.0.3",
"wait",
"Local Registration",
)
luCommand(
"r4",
'vtysh -c "show vnc registrations imported"',
"2 out of 2 imported",
"wait",
"Imported Registrations",
)
luCommand(
"r1",
'vtysh -c "show bgp ipv4 vpn"',
"i99.0.0.3/32",
"wait",
"See R4s static address",
)
luCommand(
"r3",
'vtysh -c "show bgp ipv4 vpn"',
"i99.0.0.3/32",
"wait",
"See R4s static address",
)
luCommand(
"r1", 'vtysh -c "show bgp ipv4 vpn rd 10:4"', "i5.*i5", "wait", "See R4s imports"
)
luCommand(
"r3", 'vtysh -c "show bgp ipv4 vpn rd 10:4"', "i5.*i5", "wait", "See R4s imports"
)
luCommand('r1','vtysh -c "show vnc registrations remote"','5.1.2.0/24 .*5.1.3.0/24','wait','R4s registrations') luCommand(
luCommand('r3','vtysh -c "show vnc registrations remote"','5.1.2.0/24 .*5.1.3.0/24','wait','R4s registrations') "r1",
'vtysh -c "show vnc registrations remote"',
"5.1.2.0/24 .*5.1.3.0/24",
"wait",
"R4s registrations",
)
luCommand(
"r3",
'vtysh -c "show vnc registrations remote"',
"5.1.2.0/24 .*5.1.3.0/24",
"wait",
"R4s registrations",
)
if have2ndImports: if have2ndImports:
luCommand('r1','vtysh -c "show vnc registrations remote"','5.1.0.0/24 .*5.1.1.0/24','wait','Remote registrations') luCommand(
luCommand('r3','vtysh -c "show vnc registrations remote"','5.1.0.0/24 .*5.1.1.0/24','wait','Remote registrations') "r1",
luCommand('r4','vtysh -c "show vnc registrations remote"','5.1.0.0/24 .*5.1.1.0/24','wait','Remote registrations') 'vtysh -c "show vnc registrations remote"',
luCommand('r1','vtysh -c "show vnc registrations"','.','none') "5.1.0.0/24 .*5.1.1.0/24",
luCommand('r3','vtysh -c "show vnc registrations"','.','none') "wait",
luCommand('r4','vtysh -c "show vnc registrations"','.','none') "Remote registrations",
)
luCommand(
"r3",
'vtysh -c "show vnc registrations remote"',
"5.1.0.0/24 .*5.1.1.0/24",
"wait",
"Remote registrations",
)
luCommand(
"r4",
'vtysh -c "show vnc registrations remote"',
"5.1.0.0/24 .*5.1.1.0/24",
"wait",
"Remote registrations",
)
luCommand("r1", 'vtysh -c "show vnc registrations"', ".", "none")
luCommand("r3", 'vtysh -c "show vnc registrations"', ".", "none")
luCommand("r4", 'vtysh -c "show vnc registrations"', ".", "none")

82
tests/topotests/bgp_l3vpn_to_bgp_direct/scripts/adjacencies.py
View File

@ -1,20 +1,64 @@
from lutil import luCommand from lutil import luCommand
luCommand('ce1','ping 192.168.1.1 -c 1',' 0. packet loss','pass','CE->PE ping')
luCommand('ce2','ping 192.168.1.1 -c 1',' 0. packet loss','pass','CE->PE ping') luCommand("ce1", "ping 192.168.1.1 -c 1", " 0. packet loss", "pass", "CE->PE ping")
luCommand('ce3','ping 192.168.1.1 -c 1',' 0. packet loss','pass','CE->PE ping') luCommand("ce2", "ping 192.168.1.1 -c 1", " 0. packet loss", "pass", "CE->PE ping")
luCommand('ce1','vtysh -c "show bgp summary"',' 00:0','wait','Adjacencies up',180) luCommand("ce3", "ping 192.168.1.1 -c 1", " 0. packet loss", "pass", "CE->PE ping")
luCommand('ce2','vtysh -c "show bgp summary"',' 00:0','wait','Adjacencies up',180) luCommand("ce1", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Adjacencies up", 180)
luCommand('ce3','vtysh -c "show bgp summary"',' 00:0','wait','Adjacencies up',180) luCommand("ce2", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Adjacencies up", 180)
luCommand('r1','ping 2.2.2.2 -c 1',' 0. packet loss','wait','PE->P2 (loopback) ping',60) luCommand("ce3", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Adjacencies up", 180)
luCommand('r3','ping 2.2.2.2 -c 1',' 0. packet loss','wait','PE->P2 (loopback) ping',60) luCommand(
luCommand('r4','ping 2.2.2.2 -c 1',' 0. packet loss','wait','PE->P2 (loopback) ping',60) "r1", "ping 2.2.2.2 -c 1", " 0. packet loss", "wait", "PE->P2 (loopback) ping", 60
luCommand('r2','vtysh -c "show bgp summary"',' 00:0.* 00:0.* 00:0','wait','Core adjacencies up',180) )
luCommand('r1','vtysh -c "show bgp summary"',' 00:0','wait','Core adjacencies up',180) luCommand(
luCommand('r3','vtysh -c "show bgp summary"',' 00:0','wait','Core adjacencies up',180) "r3", "ping 2.2.2.2 -c 1", " 0. packet loss", "wait", "PE->P2 (loopback) ping", 60
luCommand('r4','vtysh -c "show bgp summary"',' 00:0','wait','Core adjacencies up',180) )
luCommand('r1','vtysh -c "show bgp vrf all summary"',' 00:0.* 00:0','pass','All adjacencies up') luCommand(
luCommand('r3','vtysh -c "show bgp vrf all summary"',' 00:0.* 00:0','pass','All adjacencies up') "r4", "ping 2.2.2.2 -c 1", " 0. packet loss", "wait", "PE->P2 (loopback) ping", 60
luCommand('r4','vtysh -c "show bgp vrf all summary"',' 00:0.* 00:0','pass','All adjacencies up') )
luCommand('r1','ping 3.3.3.3 -c 1',' 0. packet loss','wait','PE->PE3 (loopback) ping') luCommand(
luCommand('r1','ping 4.4.4.4 -c 1',' 0. packet loss','wait','PE->PE4 (loopback) ping') "r2",
luCommand('r4','ping 3.3.3.3 -c 1',' 0. packet loss','wait','PE->PE3 (loopback) ping') 'vtysh -c "show bgp summary"',
" 00:0.* 00:0.* 00:0",
"wait",
"Core adjacencies up",
180,
)
luCommand(
"r1", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Core adjacencies up", 180
)
luCommand(
"r3", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Core adjacencies up", 180
)
luCommand(
"r4", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Core adjacencies up", 180
)
luCommand(
"r1",
'vtysh -c "show bgp vrf all summary"',
" 00:0.* 00:0",
"pass",
"All adjacencies up",
)
luCommand(
"r3",
'vtysh -c "show bgp vrf all summary"',
" 00:0.* 00:0",
"pass",
"All adjacencies up",
)
luCommand(
"r4",
'vtysh -c "show bgp vrf all summary"',
" 00:0.* 00:0",
"pass",
"All adjacencies up",
)
luCommand(
"r1", "ping 3.3.3.3 -c 1", " 0. packet loss", "wait", "PE->PE3 (loopback) ping"
)
luCommand(
"r1", "ping 4.4.4.4 -c 1", " 0. packet loss", "wait", "PE->PE4 (loopback) ping"
)
luCommand(
"r4", "ping 3.3.3.3 -c 1", " 0. packet loss", "wait", "PE->PE3 (loopback) ping"
)

66
tests/topotests/bgp_l3vpn_to_bgp_direct/scripts/check_routes.py
View File

@ -1,17 +1,55 @@
from lutil import luCommand from lutil import luCommand
luCommand('ce1','vtysh -c "show bgp ipv4 uni"','7 routes and 7','wait','Local and remote routes')
luCommand('ce2','vtysh -c "show bgp ipv4 uni"','7 routes and 9','wait','Local and remote routes') luCommand(
luCommand('ce3','vtysh -c "show bgp ipv4 uni"','7 routes and 7','wait','Local and remote routes') "ce1",
luCommand('r1','vtysh -c "show bgp ipv4 uni"','7 routes and 9','pass','Unicast SAFI') 'vtysh -c "show bgp ipv4 uni"',
luCommand('r2','vtysh -c "show bgp ipv4 uni"','No BGP prefixes displayed','pass','Unicast SAFI') "7 routes and 7",
luCommand('r3','vtysh -c "show bgp ipv4 uni"','7 routes and 9','pass','Unicast SAFI') "wait",
luCommand('r4','vtysh -c "show bgp ipv4 uni"','7 routes and 9','pass','Unicast SAFI') "Local and remote routes",
have2ndImports = luCommand('r3','vtysh -c "show vnc registrations imported"','2 out of 2 imported','none','Imported Registrations',2) )
luCommand(
"ce2",
'vtysh -c "show bgp ipv4 uni"',
"7 routes and 9",
"wait",
"Local and remote routes",
)
luCommand(
"ce3",
'vtysh -c "show bgp ipv4 uni"',
"7 routes and 7",
"wait",
"Local and remote routes",
)
luCommand(
"r1", 'vtysh -c "show bgp ipv4 uni"', "7 routes and 9", "pass", "Unicast SAFI"
)
luCommand(
"r2",
'vtysh -c "show bgp ipv4 uni"',
"No BGP prefixes displayed",
"pass",
"Unicast SAFI",
)
luCommand(
"r3", 'vtysh -c "show bgp ipv4 uni"', "7 routes and 9", "pass", "Unicast SAFI"
)
luCommand(
"r4", 'vtysh -c "show bgp ipv4 uni"', "7 routes and 9", "pass", "Unicast SAFI"
)
have2ndImports = luCommand(
"r3",
'vtysh -c "show vnc registrations imported"',
"2 out of 2 imported",
"none",
"Imported Registrations",
2,
)
if have2ndImports: if have2ndImports:
num = '9 routes and 9' num = "9 routes and 9"
else: else:
num = '7 routes and 7' num = "7 routes and 7"
luCommand('r1','vtysh -c "show bgp ipv4 vpn"',num,'pass','VPN SAFI') luCommand("r1", 'vtysh -c "show bgp ipv4 vpn"', num, "pass", "VPN SAFI")
luCommand('r2','vtysh -c "show bgp ipv4 vpn"',num,'pass','VPN SAFI') luCommand("r2", 'vtysh -c "show bgp ipv4 vpn"', num, "pass", "VPN SAFI")
luCommand('r3','vtysh -c "show bgp ipv4 vpn"',num,'pass','VPN SAFI') luCommand("r3", 'vtysh -c "show bgp ipv4 vpn"', num, "pass", "VPN SAFI")
luCommand('r4','vtysh -c "show bgp ipv4 vpn"',num,'pass','VPN SAFI') luCommand("r4", 'vtysh -c "show bgp ipv4 vpn"', num, "pass", "VPN SAFI")

129
tests/topotests/bgp_l3vpn_to_bgp_direct/scripts/cleanup_all.py
View File

@ -1,17 +1,114 @@
from lutil import luCommand from lutil import luCommand
luCommand('r1','vtysh -c "clear vrf cust1 prefix 99.0.0.1/32"','.','none','Cleared VRF route')
luCommand('r3','vtysh -c "clear vrf cust1 prefix 99.0.0.2/32"','.','none','Cleared VRF route') luCommand(
luCommand('r4','vtysh -c "clear vrf cust1 prefix 99.0.0.3/32"','.','none','Cleared VRF route') "r1",
luCommand('r1','vtysh -c "show vnc registrations local"','99.0.0.1','fail','Local Registration cleared') 'vtysh -c "clear vrf cust1 prefix 99.0.0.1/32"',
luCommand('r3','vtysh -c "show vnc registrations local"','99.0.0.2','fail','Local Registration cleared') ".",
luCommand('r4','vtysh -c "show vnc registrations local"','99.0.0.3','fail','Local Registration cleared') "none",
luCommand('r1','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Unicast SAFI updated') "Cleared VRF route",
luCommand('r2','vtysh -c "show bgp ipv4 uni"','No BGP prefixes displayed','pass','Unicast SAFI') )
luCommand('r3','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Unicast SAFI updated') luCommand(
luCommand('r4','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Unicast SAFI updated') "r3",
luCommand('ce1','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Local and remote routes') 'vtysh -c "clear vrf cust1 prefix 99.0.0.2/32"',
luCommand('ce2','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Local and remote routes') ".",
luCommand('ce3','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Local and remote routes') "none",
luCommand('r1','vtysh -c "show vnc registrations remote"','Prefix ','fail','Remote Registration cleared') "Cleared VRF route",
luCommand('r3','vtysh -c "show vnc registrations remote"','Prefix ','fail','Remote Registration cleared') )
luCommand('r4','vtysh -c "show vnc registrations remote"','Prefix ','fail','Remote Registration cleared') luCommand(
"r4",
'vtysh -c "clear vrf cust1 prefix 99.0.0.3/32"',
".",
"none",
"Cleared VRF route",
)
luCommand(
"r1",
'vtysh -c "show vnc registrations local"',
"99.0.0.1",
"fail",
"Local Registration cleared",
)
luCommand(
"r3",
'vtysh -c "show vnc registrations local"',
"99.0.0.2",
"fail",
"Local Registration cleared",
)
luCommand(
"r4",
'vtysh -c "show vnc registrations local"',
"99.0.0.3",
"fail",
"Local Registration cleared",
)
luCommand(
"r1",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Unicast SAFI updated",
)
luCommand(
"r2",
'vtysh -c "show bgp ipv4 uni"',
"No BGP prefixes displayed",
"pass",
"Unicast SAFI",
)
luCommand(
"r3",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Unicast SAFI updated",
)
luCommand(
"r4",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Unicast SAFI updated",
)
luCommand(
"ce1",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Local and remote routes",
)
luCommand(
"ce2",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Local and remote routes",
)
luCommand(
"ce3",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Local and remote routes",
)
luCommand(
"r1",
'vtysh -c "show vnc registrations remote"',
"Prefix ",
"fail",
"Remote Registration cleared",
)
luCommand(
"r3",
'vtysh -c "show vnc registrations remote"',
"Prefix ",
"fail",
"Remote Registration cleared",
)
luCommand(
"r4",
'vtysh -c "show vnc registrations remote"',
"Prefix ",
"fail",
"Remote Registration cleared",
)

49
tests/topotests/bgp_l3vpn_to_bgp_direct/test_bgp_l3vpn_to_bgp_direct.py
View File

@ -25,46 +25,51 @@ import os
import sys import sys
import pytest import pytest
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')) sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".."))
from lib.ltemplate import * from lib.ltemplate import *
def test_adjacencies(): def test_adjacencies():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'3.1\')' CheckFunc = "ltemplateVersionCheck('3.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'3.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'3.1\', cli=True)'
ltemplateTest('scripts/adjacencies.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/adjacencies.py", False, CliOnFail, CheckFunc)
def test_add_routes(): def test_add_routes():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'3.1\')' CheckFunc = "ltemplateVersionCheck('3.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'3.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'3.1\', cli=True)'
ltemplateTest('scripts/add_routes.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/add_routes.py", False, CliOnFail, CheckFunc)
def test_check_routes(): def test_check_routes():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'3.1\')' CheckFunc = "ltemplateVersionCheck('3.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'3.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'3.1\', cli=True)'
ltemplateTest('scripts/check_routes.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/check_routes.py", False, CliOnFail, CheckFunc)
def test_cleanup_all(): def test_cleanup_all():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'3.1\')' CheckFunc = "ltemplateVersionCheck('3.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'3.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'3.1\', cli=True)'
ltemplateTest('scripts/cleanup_all.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/cleanup_all.py", False, CliOnFail, CheckFunc)
if __name__ == '__main__':
if __name__ == "__main__":
retval = pytest.main(["-s"]) retval = pytest.main(["-s"])
sys.exit(retval) sys.exit(retval)

160
tests/topotests/bgp_l3vpn_to_bgp_vrf/customize.py
View File

@ -89,12 +89,15 @@ from lib.ltemplate import ltemplateRtrCmd
from mininet.topo import Topo from mininet.topo import Topo
import shutil import shutil
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
# test name based on directory # test name based on directory
TEST = os.path.basename(CWD) TEST = os.path.basename(CWD)
class ThisTestTopo(Topo): class ThisTestTopo(Topo):
"Test topology builder" "Test topology builder"
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
"Build function" "Build function"
tgen = get_topogen(self) tgen = get_topogen(self)
@ -103,125 +106,148 @@ class ThisTestTopo(Topo):
# between routers, switches and hosts. # between routers, switches and hosts.
# #
# Create P/PE routers # Create P/PE routers
#check for mpls # check for mpls
tgen.add_router('r1') tgen.add_router("r1")
if tgen.hasmpls != True: if tgen.hasmpls != True:
logger.info('MPLS not available, tests will be skipped') logger.info("MPLS not available, tests will be skipped")
return return
mach = platform.machine() mach = platform.machine()
krel = platform.release() krel = platform.release()
if mach[:1] == 'a' and topotest.version_cmp(krel, '4.11') < 0: if mach[:1] == "a" and topotest.version_cmp(krel, "4.11") < 0:
logger.info('Need Kernel version 4.11 to run on arm processor') logger.info("Need Kernel version 4.11 to run on arm processor")
return return
for routern in range(2, 5): for routern in range(2, 5):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
# Create CE routers # Create CE routers
for routern in range(1, 5): for routern in range(1, 5):
tgen.add_router('ce{}'.format(routern)) tgen.add_router("ce{}".format(routern))
#CE/PE links # CE/PE links
tgen.add_link(tgen.gears['ce1'], tgen.gears['r1'], 'ce1-eth0', 'r1-eth4') tgen.add_link(tgen.gears["ce1"], tgen.gears["r1"], "ce1-eth0", "r1-eth4")
tgen.add_link(tgen.gears['ce2'], tgen.gears['r3'], 'ce2-eth0', 'r3-eth4') tgen.add_link(tgen.gears["ce2"], tgen.gears["r3"], "ce2-eth0", "r3-eth4")
tgen.add_link(tgen.gears['ce3'], tgen.gears['r4'], 'ce3-eth0', 'r4-eth4') tgen.add_link(tgen.gears["ce3"], tgen.gears["r4"], "ce3-eth0", "r4-eth4")
tgen.add_link(tgen.gears['ce4'], tgen.gears['r4'], 'ce4-eth0', 'r4-eth5') tgen.add_link(tgen.gears["ce4"], tgen.gears["r4"], "ce4-eth0", "r4-eth5")
# Create a switch with just one router connected to it to simulate a # Create a switch with just one router connected to it to simulate a
# empty network. # empty network.
switch = {} switch = {}
switch[0] = tgen.add_switch('sw0') switch[0] = tgen.add_switch("sw0")
switch[0].add_link(tgen.gears['r1'], nodeif='r1-eth0') switch[0].add_link(tgen.gears["r1"], nodeif="r1-eth0")
switch[0].add_link(tgen.gears['r2'], nodeif='r2-eth0') switch[0].add_link(tgen.gears["r2"], nodeif="r2-eth0")
switch[1] = tgen.add_switch('sw1') switch[1] = tgen.add_switch("sw1")
switch[1].add_link(tgen.gears['r2'], nodeif='r2-eth1') switch[1].add_link(tgen.gears["r2"], nodeif="r2-eth1")
switch[1].add_link(tgen.gears['r3'], nodeif='r3-eth0') switch[1].add_link(tgen.gears["r3"], nodeif="r3-eth0")
switch[1].add_link(tgen.gears['r4'], nodeif='r4-eth0') switch[1].add_link(tgen.gears["r4"], nodeif="r4-eth0")
switch[1] = tgen.add_switch("sw2")
switch[1].add_link(tgen.gears["r2"], nodeif="r2-eth2")
switch[1].add_link(tgen.gears["r3"], nodeif="r3-eth1")
switch[1] = tgen.add_switch('sw2')
switch[1].add_link(tgen.gears['r2'], nodeif='r2-eth2')
switch[1].add_link(tgen.gears['r3'], nodeif='r3-eth1')
l3mdev_accept = 0 l3mdev_accept = 0
def ltemplatePreRouterStartHook(): def ltemplatePreRouterStartHook():
global l3mdev_accept global l3mdev_accept
cc = ltemplateRtrCmd() cc = ltemplateRtrCmd()
krel = platform.release() krel = platform.release()
tgen = get_topogen() tgen = get_topogen()
logger.info('pre router-start hook, kernel=' + krel) logger.info("pre router-start hook, kernel=" + krel)
if topotest.version_cmp(krel, '4.15') >= 0 and \ if (
topotest.version_cmp(krel, '4.18') <= 0: topotest.version_cmp(krel, "4.15") >= 0
and topotest.version_cmp(krel, "4.18") <= 0
):
l3mdev_accept = 1 l3mdev_accept = 1
if topotest.version_cmp(krel, '5.0') >= 0: if topotest.version_cmp(krel, "5.0") >= 0:
l3mdev_accept = 1 l3mdev_accept = 1
logger.info('setting net.ipv4.tcp_l3mdev_accept={}'.format(l3mdev_accept)) logger.info("setting net.ipv4.tcp_l3mdev_accept={}".format(l3mdev_accept))
#check for mpls # check for mpls
if tgen.hasmpls != True: if tgen.hasmpls != True:
logger.info('MPLS not available, skipping setup') logger.info("MPLS not available, skipping setup")
return False return False
#check for normal init # check for normal init
if len(tgen.net) == 1: if len(tgen.net) == 1:
logger.info('Topology not configured, skipping setup') logger.info("Topology not configured, skipping setup")
return False return False
#trace errors/unexpected output # trace errors/unexpected output
cc.resetCounts() cc.resetCounts()
#configure r2 mpls interfaces # configure r2 mpls interfaces
intfs = ['lo', 'r2-eth0', 'r2-eth1', 'r2-eth2'] intfs = ["lo", "r2-eth0", "r2-eth1", "r2-eth2"]
for intf in intfs: for intf in intfs:
cc.doCmd(tgen, 'r2', 'echo 1 > /proc/sys/net/mpls/conf/{}/input'.format(intf)) cc.doCmd(tgen, "r2", "echo 1 > /proc/sys/net/mpls/conf/{}/input".format(intf))
#configure cust1 VRFs & MPLS # configure cust1 VRFs & MPLS
rtrs = ['r1', 'r3', 'r4'] rtrs = ["r1", "r3", "r4"]
cmds = ['ip link add {0}-cust1 type vrf table 10', cmds = [
'ip ru add oif {0}-cust1 table 10', "ip link add {0}-cust1 type vrf table 10",
'ip ru add iif {0}-cust1 table 10', "ip ru add oif {0}-cust1 table 10",
'ip link set dev {0}-cust1 up', "ip ru add iif {0}-cust1 table 10",
'sysctl -w net.ipv4.tcp_l3mdev_accept={}'.format(l3mdev_accept)] "ip link set dev {0}-cust1 up",
"sysctl -w net.ipv4.tcp_l3mdev_accept={}".format(l3mdev_accept),
]
for rtr in rtrs: for rtr in rtrs:
router = tgen.gears[rtr] router = tgen.gears[rtr]
for cmd in cmds: for cmd in cmds:
cc.doCmd(tgen, rtr, cmd.format(rtr)) cc.doCmd(tgen, rtr, cmd.format(rtr))
cc.doCmd(tgen, rtr, 'ip link set dev {0}-eth4 master {0}-cust1'.format(rtr)) cc.doCmd(tgen, rtr, "ip link set dev {0}-eth4 master {0}-cust1".format(rtr))
intfs = [rtr+'-cust1', 'lo', rtr+'-eth0', rtr+'-eth4'] intfs = [rtr + "-cust1", "lo", rtr + "-eth0", rtr + "-eth4"]
for intf in intfs: for intf in intfs:
cc.doCmd(tgen, rtr, 'echo 1 > /proc/sys/net/mpls/conf/{}/input'.format(intf)) cc.doCmd(
logger.info('setup {0} vrf {0}-cust1, {0}-eth4. enabled mpls input.'.format(rtr)) tgen, rtr, "echo 1 > /proc/sys/net/mpls/conf/{}/input".format(intf)
#configure cust2 VRFs & MPLS )
rtrs = ['r4'] logger.info(
cmds = ['ip link add {0}-cust2 type vrf table 20', "setup {0} vrf {0}-cust1, {0}-eth4. enabled mpls input.".format(rtr)
'ip ru add oif {0}-cust2 table 20', )
'ip ru add iif {0}-cust2 table 20', # configure cust2 VRFs & MPLS
'ip link set dev {0}-cust2 up'] rtrs = ["r4"]
cmds = [
"ip link add {0}-cust2 type vrf table 20",
"ip ru add oif {0}-cust2 table 20",
"ip ru add iif {0}-cust2 table 20",
"ip link set dev {0}-cust2 up",
]
for rtr in rtrs: for rtr in rtrs:
for cmd in cmds: for cmd in cmds:
cc.doCmd(tgen, rtr, cmd.format(rtr)) cc.doCmd(tgen, rtr, cmd.format(rtr))
cc.doCmd(tgen, rtr, 'ip link set dev {0}-eth5 master {0}-cust2'.format(rtr)) cc.doCmd(tgen, rtr, "ip link set dev {0}-eth5 master {0}-cust2".format(rtr))
intfs = [rtr+'-cust2', rtr+'-eth5'] intfs = [rtr + "-cust2", rtr + "-eth5"]
for intf in intfs: for intf in intfs:
cc.doCmd(tgen, rtr, 'echo 1 > /proc/sys/net/mpls/conf/{}/input'.format(intf)) cc.doCmd(
logger.info('setup {0} vrf {0}-cust2, {0}-eth5. enabled mpls input.'.format(rtr)) tgen, rtr, "echo 1 > /proc/sys/net/mpls/conf/{}/input".format(intf)
#put ce4-eth0 into a VRF (no default instance!) )
rtrs = ['ce4'] logger.info(
cmds = ['ip link add {0}-cust2 type vrf table 20', "setup {0} vrf {0}-cust2, {0}-eth5. enabled mpls input.".format(rtr)
'ip ru add oif {0}-cust2 table 20', )
'ip ru add iif {0}-cust2 table 20', # put ce4-eth0 into a VRF (no default instance!)
'ip link set dev {0}-cust2 up', rtrs = ["ce4"]
'sysctl -w net.ipv4.tcp_l3mdev_accept={}'.format(l3mdev_accept)] cmds = [
"ip link add {0}-cust2 type vrf table 20",
"ip ru add oif {0}-cust2 table 20",
"ip ru add iif {0}-cust2 table 20",
"ip link set dev {0}-cust2 up",
"sysctl -w net.ipv4.tcp_l3mdev_accept={}".format(l3mdev_accept),
]
for rtr in rtrs: for rtr in rtrs:
for cmd in cmds: for cmd in cmds:
cc.doCmd(tgen, rtr, cmd.format(rtr)) cc.doCmd(tgen, rtr, cmd.format(rtr))
cc.doCmd(tgen, rtr, 'ip link set dev {0}-eth0 master {0}-cust2'.format(rtr)) cc.doCmd(tgen, rtr, "ip link set dev {0}-eth0 master {0}-cust2".format(rtr))
if cc.getOutput() != 4: if cc.getOutput() != 4:
InitSuccess = False InitSuccess = False
logger.info('Unexpected output seen ({} times, tests will be skipped'.format(cc.getOutput())) logger.info(
"Unexpected output seen ({} times, tests will be skipped".format(
cc.getOutput()
)
)
else: else:
InitSuccess = True InitSuccess = True
logger.info('VRF config successful!') logger.info("VRF config successful!")
return InitSuccess return InitSuccess
def ltemplatePostRouterStartHook(): def ltemplatePostRouterStartHook():
logger.info('post router-start hook') logger.info("post router-start hook")
return True return True

70
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/add_routes.py
View File

@ -1,13 +1,59 @@
from lutil import luCommand from lutil import luCommand
luCommand('r1','vtysh -c "add vrf r1-cust1 prefix 99.0.0.1/32"','.','none','IP Address')
luCommand('r3','vtysh -c "add vrf r3-cust1 prefix 99.0.0.2/32"','.','none','IP Address') luCommand(
luCommand('r4','vtysh -c "add vrf r4-cust1 prefix 99.0.0.3/32"','.','none','IP Address') "r1", 'vtysh -c "add vrf r1-cust1 prefix 99.0.0.1/32"', ".", "none", "IP Address"
luCommand('r1','vtysh -c "show vnc registrations local"','99.0.0.1','pass','Local Registration') )
luCommand('r3','vtysh -c "show vnc registrations local"','99.0.0.2','pass','Local Registration') luCommand(
luCommand('r4','vtysh -c "show vnc registrations local"','99.0.0.3','pass','Local Registration') "r3", 'vtysh -c "add vrf r3-cust1 prefix 99.0.0.2/32"', ".", "none", "IP Address"
luCommand('r1','vtysh -c "show vnc registrations remote"','4 out of 4','wait','Remote Registration', 10) )
luCommand('r3','vtysh -c "show vnc registrations remote"','6 out of 6','wait','Remote Registration', 10) luCommand(
luCommand('r4','vtysh -c "show vnc registrations remote"','4 out of 4','wait','Remote Registration', 10) "r4", 'vtysh -c "add vrf r4-cust1 prefix 99.0.0.3/32"', ".", "none", "IP Address"
luCommand('r1','vtysh -c "show vnc registrations"','.','none') )
luCommand('r3','vtysh -c "show vnc registrations"','.','none') luCommand(
luCommand('r4','vtysh -c "show vnc registrations"','.','none') "r1",
'vtysh -c "show vnc registrations local"',
"99.0.0.1",
"pass",
"Local Registration",
)
luCommand(
"r3",
'vtysh -c "show vnc registrations local"',
"99.0.0.2",
"pass",
"Local Registration",
)
luCommand(
"r4",
'vtysh -c "show vnc registrations local"',
"99.0.0.3",
"pass",
"Local Registration",
)
luCommand(
"r1",
'vtysh -c "show vnc registrations remote"',
"4 out of 4",
"wait",
"Remote Registration",
10,
)
luCommand(
"r3",
'vtysh -c "show vnc registrations remote"',
"6 out of 6",
"wait",
"Remote Registration",
10,
)
luCommand(
"r4",
'vtysh -c "show vnc registrations remote"',
"4 out of 4",
"wait",
"Remote Registration",
10,
)
luCommand("r1", 'vtysh -c "show vnc registrations"', ".", "none")
luCommand("r3", 'vtysh -c "show vnc registrations"', ".", "none")
luCommand("r4", 'vtysh -c "show vnc registrations"', ".", "none")

80
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/adjacencies.py
View File

@ -1,18 +1,64 @@
from lutil import luCommand from lutil import luCommand
luCommand('ce1','vtysh -c "show bgp summary"',' 00:0','wait','Adjacencies up',180)
luCommand('ce2','vtysh -c "show bgp summary"',' 00:0','wait','Adjacencies up',180) luCommand("ce1", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Adjacencies up", 180)
luCommand('ce3','vtysh -c "show bgp summary"',' 00:0','wait','Adjacencies up',180) luCommand("ce2", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Adjacencies up", 180)
luCommand('ce4','vtysh -c "show bgp vrf all summary"',' 00:0','wait','Adjacencies up',180) luCommand("ce3", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Adjacencies up", 180)
luCommand('r1','ping 2.2.2.2 -c 1',' 0. packet loss','wait','PE->P2 (loopback) ping',60) luCommand(
luCommand('r3','ping 2.2.2.2 -c 1',' 0. packet loss','wait','PE->P2 (loopback) ping',60) "ce4", 'vtysh -c "show bgp vrf all summary"', " 00:0", "wait", "Adjacencies up", 180
luCommand('r4','ping 2.2.2.2 -c 1',' 0. packet loss','wait','PE->P2 (loopback) ping',60) )
luCommand('r2','vtysh -c "show bgp summary"',' 00:0.* 00:0.* 00:0','wait','Core adjacencies up',180) luCommand(
luCommand('r1','vtysh -c "show bgp summary"',' 00:0','wait','Core adjacencies up', 180) "r1", "ping 2.2.2.2 -c 1", " 0. packet loss", "wait", "PE->P2 (loopback) ping", 60
luCommand('r3','vtysh -c "show bgp summary"',' 00:0','wait','Core adjacencies up', 180) )
luCommand('r4','vtysh -c "show bgp summary"',' 00:0','wait','Core adjacencies up', 180) luCommand(
luCommand('r1','vtysh -c "show bgp vrf all summary"',' 00:0.* 00:0','pass','All adjacencies up') "r3", "ping 2.2.2.2 -c 1", " 0. packet loss", "wait", "PE->P2 (loopback) ping", 60
luCommand('r3','vtysh -c "show bgp vrf all summary"',' 00:0.* 00:0','pass','All adjacencies up') )
luCommand('r4','vtysh -c "show bgp vrf all summary"',' 00:0.* 00:0.* 00:0','pass','All adjacencies up') luCommand(
luCommand('r1','ping 3.3.3.3 -c 1',' 0. packet loss','wait','PE->PE3 (loopback) ping') "r4", "ping 2.2.2.2 -c 1", " 0. packet loss", "wait", "PE->P2 (loopback) ping", 60
luCommand('r1','ping 4.4.4.4 -c 1',' 0. packet loss','wait','PE->PE4 (loopback) ping') )
luCommand('r4','ping 3.3.3.3 -c 1',' 0. packet loss','wait','PE->PE3 (loopback) ping') luCommand(
"r2",
'vtysh -c "show bgp summary"',
" 00:0.* 00:0.* 00:0",
"wait",
"Core adjacencies up",
180,
)
luCommand(
"r1", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Core adjacencies up", 180
)
luCommand(
"r3", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Core adjacencies up", 180
)
luCommand(
"r4", 'vtysh -c "show bgp summary"', " 00:0", "wait", "Core adjacencies up", 180
)
luCommand(
"r1",
'vtysh -c "show bgp vrf all summary"',
" 00:0.* 00:0",
"pass",
"All adjacencies up",
)
luCommand(
"r3",
'vtysh -c "show bgp vrf all summary"',
" 00:0.* 00:0",
"pass",
"All adjacencies up",
)
luCommand(
"r4",
'vtysh -c "show bgp vrf all summary"',
" 00:0.* 00:0.* 00:0",
"pass",
"All adjacencies up",
)
luCommand(
"r1", "ping 3.3.3.3 -c 1", " 0. packet loss", "wait", "PE->PE3 (loopback) ping"
)
luCommand(
"r1", "ping 4.4.4.4 -c 1", " 0. packet loss", "wait", "PE->PE4 (loopback) ping"
)
luCommand(
"r4", "ping 3.3.3.3 -c 1", " 0. packet loss", "wait", "PE->PE3 (loopback) ping"
)

94
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/check_linux_mpls.py
View File

@ -1,47 +1,83 @@
from lutil import luCommand, luLast from lutil import luCommand, luLast
from lib import topotest from lib import topotest
ret = luCommand('r2', 'ip -M route show', ret = luCommand(
'\d*(?= via inet 10.0.2.4 dev r2-eth1)','wait','See mpls route to r4') "r2",
"ip -M route show",
"\d*(?= via inet 10.0.2.4 dev r2-eth1)",
"wait",
"See mpls route to r4",
)
found = luLast() found = luLast()
if ret != False and found != None: if ret != False and found != None:
label4r4 = found.group(0) label4r4 = found.group(0)
luCommand('r2', 'ip -M route show', luCommand("r2", "ip -M route show", ".", "pass", "See %s as label to r4" % label4r4)
'.', 'pass', ret = luCommand(
'See %s as label to r4' % label4r4) "r2",
ret = luCommand('r2', 'ip -M route show', "ip -M route show",
'\d*(?= via inet 10.0.1.1 dev r2-eth0)', 'wait', "\d*(?= via inet 10.0.1.1 dev r2-eth0)",
'See mpls route to r1') "wait",
"See mpls route to r1",
)
found = luLast() found = luLast()
if ret != False and found != None: if ret != False and found != None:
label4r1 = found.group(0) label4r1 = found.group(0)
luCommand('r2', 'ip -M route show', luCommand("r2", "ip -M route show", ".", "pass", "See %s as label to r1" % label4r1)
'.', 'pass', 'See %s as label to r1' % label4r1)
luCommand('r1', 'ip route show vrf r1-cust1', luCommand(
'99.0.0.4', 'pass', 'VRF->MPLS PHP route installed') "r1",
luCommand('r4', 'ip route show vrf r4-cust2', "ip route show vrf r1-cust1",
'99.0.0.1','pass', 'VRF->MPLS PHP route installed') "99.0.0.4",
"pass",
"VRF->MPLS PHP route installed",
)
luCommand(
"r4",
"ip route show vrf r4-cust2",
"99.0.0.1",
"pass",
"VRF->MPLS PHP route installed",
)
luCommand('r1', 'ip -M route show', '101', 'pass', 'MPLS->VRF route installed') luCommand("r1", "ip -M route show", "101", "pass", "MPLS->VRF route installed")
luCommand('r4', 'ip -M route show', '1041', 'pass', 'MPLS->VRF1 route installed') luCommand("r4", "ip -M route show", "1041", "pass", "MPLS->VRF1 route installed")
luCommand('r4', 'ip -M route show', '1042', 'pass', 'MPLS->VRF2 route installed') luCommand("r4", "ip -M route show", "1042", "pass", "MPLS->VRF2 route installed")
luCommand('ce1', 'ping 99.0.0.4 -I 99.0.0.1 -c 1', luCommand(
' 0. packet loss','wait','CE->CE (loopback) ping - l3vpn+zebra case') "ce1",
#skip due to VRF weirdness "ping 99.0.0.4 -I 99.0.0.1 -c 1",
#luCommand('ce4', 'ping 99.0.0.1 -I 99.0.0.4 -c 1', " 0. packet loss",
"wait",
"CE->CE (loopback) ping - l3vpn+zebra case",
)
# skip due to VRF weirdness
# luCommand('ce4', 'ping 99.0.0.1 -I 99.0.0.4 -c 1',
# ' 0. packet loss','wait','CE->CE (loopback) ping - l3vpn+zebra case') # ' 0. packet loss','wait','CE->CE (loopback) ping - l3vpn+zebra case')
luCommand('ce1', 'ping 99.0.0.4 -I 99.0.0.1 -c 1', luCommand(
' 0. packet loss','wait','CE->CE (loopback) ping') "ce1",
#luCommand('ce4', 'ping 99.0.0.1 -I 99.0.0.4 -c 1', "ping 99.0.0.4 -I 99.0.0.1 -c 1",
" 0. packet loss",
"wait",
"CE->CE (loopback) ping",
)
# luCommand('ce4', 'ping 99.0.0.1 -I 99.0.0.4 -c 1',
# ' 0. packet loss','wait','CE->CE (loopback) ping') # ' 0. packet loss','wait','CE->CE (loopback) ping')
luCommand('r3', 'ip -M route show', '103', 'pass', 'MPLS->VRF route installed') luCommand("r3", "ip -M route show", "103", "pass", "MPLS->VRF route installed")
luCommand('ce2', 'ping 99.0.0.3 -I 99.0.0.2 -c 1', luCommand(
' 0. packet loss','wait','CE2->CE3 (loopback) ping') "ce2",
luCommand('ce3', 'ping 99.0.0.4 -I 99.0.0.3 -c 1', "ping 99.0.0.3 -I 99.0.0.2 -c 1",
' 0. packet loss','wait','CE3->CE4 (loopback) ping') " 0. packet loss",
"wait",
"CE2->CE3 (loopback) ping",
)
luCommand(
"ce3",
"ping 99.0.0.4 -I 99.0.0.3 -c 1",
" 0. packet loss",
"wait",
"CE3->CE4 (loopback) ping",
)

104
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/check_linux_vrf.py
View File

@ -1,27 +1,93 @@
from lutil import luCommand from lutil import luCommand
from customize import l3mdev_accept from customize import l3mdev_accept
l3mdev_rtrs = ['r1', 'r3', 'r4', 'ce4'] l3mdev_rtrs = ["r1", "r3", "r4", "ce4"]
for rtr in l3mdev_rtrs: for rtr in l3mdev_rtrs:
luCommand(rtr,'sysctl net.ipv4.tcp_l3mdev_accept',' = \d*','none','') luCommand(rtr, "sysctl net.ipv4.tcp_l3mdev_accept", " = \d*", "none", "")
found = luLast() found = luLast()
luCommand(rtr,'ss -naep',':179','pass','IPv4:bgp, l3mdev{}'.format(found.group(0))) luCommand(
luCommand(rtr,'ss -naep',':.*:179','pass','IPv6:bgp') rtr, "ss -naep", ":179", "pass", "IPv4:bgp, l3mdev{}".format(found.group(0))
luCommand(rtr,'sysctl net.ipv4.tcp_l3mdev_accept',' = {}'.format(l3mdev_accept),'pass','l3mdev matches expected (real/expected{}/{})'.format(found.group(0),l3mdev_accept)) )
luCommand(rtr, "ss -naep", ":.*:179", "pass", "IPv6:bgp")
luCommand(
rtr,
"sysctl net.ipv4.tcp_l3mdev_accept",
" = {}".format(l3mdev_accept),
"pass",
"l3mdev matches expected (real/expected{}/{})".format(
found.group(0), l3mdev_accept
),
)
rtrs = ['r1', 'r3', 'r4'] rtrs = ["r1", "r3", "r4"]
for rtr in rtrs: for rtr in rtrs:
luCommand(rtr, 'ip link show type vrf {}-cust1'.format(rtr),'cust1: .*UP','pass','VRF cust1 intf up') luCommand(
luCommand(rtr, 'ip add show vrf {}-cust1'.format(rtr),'r..eth4.*UP','pass','VRF cust1 IP intf up') rtr,
luCommand(rtr, 'ip add show vrf {}-cust1'.format(rtr),'192.168','pass','VRF cust1 IP config') "ip link show type vrf {}-cust1".format(rtr),
luCommand(rtr, 'ip route show vrf {}-cust1'.format(rtr),'192.168...0/24 dev r.-eth','pass','VRF cust1 interface route') "cust1: .*UP",
luCommand('r4', 'ip link show type vrf r4-cust2','cust2: .*UP','pass','VRF cust2 up') "pass",
luCommand('r4', 'ip add show vrf r4-cust2','r..eth5.*UP.* 192.168','pass','VRF cust1 IP config') "VRF cust1 intf up",
luCommand(rtr, 'ip route show vrf r4-cust2'.format(rtr),'192.168...0/24 dev r.-eth','pass','VRF cust2 interface route') )
rtrs = ['ce1', 'ce2', 'ce3'] luCommand(
rtr,
"ip add show vrf {}-cust1".format(rtr),
"r..eth4.*UP",
"pass",
"VRF cust1 IP intf up",
)
luCommand(
rtr,
"ip add show vrf {}-cust1".format(rtr),
"192.168",
"pass",
"VRF cust1 IP config",
)
luCommand(
rtr,
"ip route show vrf {}-cust1".format(rtr),
"192.168...0/24 dev r.-eth",
"pass",
"VRF cust1 interface route",
)
luCommand("r4", "ip link show type vrf r4-cust2", "cust2: .*UP", "pass", "VRF cust2 up")
luCommand(
"r4",
"ip add show vrf r4-cust2",
"r..eth5.*UP.* 192.168",
"pass",
"VRF cust1 IP config",
)
luCommand(
rtr,
"ip route show vrf r4-cust2".format(rtr),
"192.168...0/24 dev r.-eth",
"pass",
"VRF cust2 interface route",
)
rtrs = ["ce1", "ce2", "ce3"]
for rtr in rtrs: for rtr in rtrs:
luCommand(rtr, 'ip route show','192.168...0/24 dev ce.-eth0','pass','CE interface route') luCommand(
luCommand(rtr,'ping 192.168.1.1 -c 1',' 0. packet loss','wait','CE->PE ping') rtr,
luCommand('ce4', 'ip link show type vrf ce4-cust2','cust2: .*UP','pass','VRF cust2 up') "ip route show",
luCommand('ce4', 'ip route show vrf ce4-cust2','192.168...0/24 dev ce.-eth0','pass','CE interface route') "192.168...0/24 dev ce.-eth0",
luCommand('ce4','ping 192.168.2.1 -c 1 -I ce4-cust2',' 0. packet loss','wait','CE4->PE4 ping') "pass",
"CE interface route",
)
luCommand(rtr, "ping 192.168.1.1 -c 1", " 0. packet loss", "wait", "CE->PE ping")
luCommand(
"ce4", "ip link show type vrf ce4-cust2", "cust2: .*UP", "pass", "VRF cust2 up"
)
luCommand(
"ce4",
"ip route show vrf ce4-cust2",
"192.168...0/24 dev ce.-eth0",
"pass",
"CE interface route",
)
luCommand(
"ce4",
"ping 192.168.2.1 -c 1 -I ce4-cust2",
" 0. packet loss",
"wait",
"CE4->PE4 ping",
)

462
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/check_routes.py
View File

@ -1,5 +1,5 @@
from lutil import luCommand from lutil import luCommand
from bgprib import bgpribRequireVpnRoutes,bgpribRequireUnicastRoutes from bgprib import bgpribRequireVpnRoutes, bgpribRequireUnicastRoutes
######################################################################## ########################################################################
# CE routers: contain routes they originate # CE routers: contain routes they originate
@ -12,32 +12,32 @@ from bgprib import bgpribRequireVpnRoutes,bgpribRequireUnicastRoutes
# ce4 vtysh -c "show bgp ipv4 uni" # ce4 vtysh -c "show bgp ipv4 uni"
want = [ want = [
{'p':'5.1.0.0/24', 'n':'99.0.0.1'}, {"p": "5.1.0.0/24", "n": "99.0.0.1"},
{'p':'5.1.1.0/24', 'n':'99.0.0.1'}, {"p": "5.1.1.0/24", "n": "99.0.0.1"},
{'p':'99.0.0.1/32', 'n':'0.0.0.0'}, {"p": "99.0.0.1/32", "n": "0.0.0.0"},
] ]
bgpribRequireUnicastRoutes('ce1','ipv4','','Cust 1 routes in ce1',want) bgpribRequireUnicastRoutes("ce1", "ipv4", "", "Cust 1 routes in ce1", want)
want = [ want = [
{'p':'5.1.0.0/24', 'n':'99.0.0.2'}, {"p": "5.1.0.0/24", "n": "99.0.0.2"},
{'p':'5.1.1.0/24', 'n':'99.0.0.2'}, {"p": "5.1.1.0/24", "n": "99.0.0.2"},
{'p':'99.0.0.2/32', 'n':'0.0.0.0'}, {"p": "99.0.0.2/32", "n": "0.0.0.0"},
] ]
bgpribRequireUnicastRoutes('ce2','ipv4','','Cust 2 routes in ce1',want) bgpribRequireUnicastRoutes("ce2", "ipv4", "", "Cust 2 routes in ce1", want)
want = [ want = [
{'p':'5.1.2.0/24', 'n':'99.0.0.3'}, {"p": "5.1.2.0/24", "n": "99.0.0.3"},
{'p':'5.1.3.0/24', 'n':'99.0.0.3'}, {"p": "5.1.3.0/24", "n": "99.0.0.3"},
{'p':'99.0.0.3/32', 'n':'0.0.0.0'}, {"p": "99.0.0.3/32", "n": "0.0.0.0"},
] ]
bgpribRequireUnicastRoutes('ce3','ipv4','','Cust 3 routes in ce1',want) bgpribRequireUnicastRoutes("ce3", "ipv4", "", "Cust 3 routes in ce1", want)
want = [ want = [
{'p':'5.4.2.0/24', 'n':'99.0.0.4'}, {"p": "5.4.2.0/24", "n": "99.0.0.4"},
{'p':'5.4.3.0/24', 'n':'99.0.0.4'}, {"p": "5.4.3.0/24", "n": "99.0.0.4"},
{'p':'99.0.0.4/32', 'n':'0.0.0.0'}, {"p": "99.0.0.4/32", "n": "0.0.0.0"},
] ]
bgpribRequireUnicastRoutes('ce4','ipv4','ce4-cust2','Cust 4 routes in ce1',want) bgpribRequireUnicastRoutes("ce4", "ipv4", "ce4-cust2", "Cust 4 routes in ce1", want)
######################################################################## ########################################################################
@ -47,116 +47,169 @@ bgpribRequireUnicastRoutes('ce4','ipv4','ce4-cust2','Cust 4 routes in ce1',want)
# r1 vtysh -c "show bgp vrf r1-cust1 ipv4" # r1 vtysh -c "show bgp vrf r1-cust1 ipv4"
# #
want_r1_cust1_routes = [ want_r1_cust1_routes = [
{'p':'5.1.0.0/24', 'n':'99.0.0.1'}, {"p": "5.1.0.0/24", "n": "99.0.0.1"},
{'p':'5.1.1.0/24', 'n':'99.0.0.1'}, {"p": "5.1.1.0/24", "n": "99.0.0.1"},
{'p':'99.0.0.1/32', 'n':'192.168.1.2'}, {"p": "99.0.0.1/32", "n": "192.168.1.2"},
] ]
bgpribRequireUnicastRoutes('r1','ipv4','r1-cust1','Customer 1 routes in r1 vrf',want_r1_cust1_routes) bgpribRequireUnicastRoutes(
"r1", "ipv4", "r1-cust1", "Customer 1 routes in r1 vrf", want_r1_cust1_routes
)
want_r3_cust1_routes = [ want_r3_cust1_routes = [
{'p':'5.1.0.0/24', 'n':'99.0.0.2'}, {"p": "5.1.0.0/24", "n": "99.0.0.2"},
{'p':'5.1.1.0/24', 'n':'99.0.0.2'}, {"p": "5.1.1.0/24", "n": "99.0.0.2"},
{'p':'99.0.0.2/32', 'n':'192.168.1.2'}, {"p": "99.0.0.2/32", "n": "192.168.1.2"},
] ]
bgpribRequireUnicastRoutes('r3','ipv4','r3-cust1','Customer 1 routes in r3 vrf',want_r3_cust1_routes) bgpribRequireUnicastRoutes(
"r3", "ipv4", "r3-cust1", "Customer 1 routes in r3 vrf", want_r3_cust1_routes
)
want_r4_cust1_routes = [ want_r4_cust1_routes = [
{'p':'5.1.2.0/24', 'n':'99.0.0.3'}, {"p": "5.1.2.0/24", "n": "99.0.0.3"},
{'p':'5.1.3.0/24', 'n':'99.0.0.3'}, {"p": "5.1.3.0/24", "n": "99.0.0.3"},
{'p':'99.0.0.3/32', 'n':'192.168.1.2'}, {"p": "99.0.0.3/32", "n": "192.168.1.2"},
] ]
bgpribRequireUnicastRoutes('r4','ipv4','r4-cust1','Customer 1 routes in r4 vrf',want_r4_cust1_routes) bgpribRequireUnicastRoutes(
"r4", "ipv4", "r4-cust1", "Customer 1 routes in r4 vrf", want_r4_cust1_routes
)
want_r4_cust2_routes = [ want_r4_cust2_routes = [
{'p':'5.4.2.0/24', 'n':'99.0.0.4'}, {"p": "5.4.2.0/24", "n": "99.0.0.4"},
{'p':'5.4.3.0/24', 'n':'99.0.0.4'}, {"p": "5.4.3.0/24", "n": "99.0.0.4"},
{'p':'99.0.0.4/32', 'n':'192.168.2.2'}, {"p": "99.0.0.4/32", "n": "192.168.2.2"},
] ]
bgpribRequireUnicastRoutes('r4','ipv4','r4-cust2','Customer 2 routes in r4 vrf',want_r4_cust2_routes) bgpribRequireUnicastRoutes(
"r4", "ipv4", "r4-cust2", "Customer 2 routes in r4 vrf", want_r4_cust2_routes
)
######################################################################## ########################################################################
# PE routers: core unicast routes are empty # PE routers: core unicast routes are empty
######################################################################## ########################################################################
luCommand('r1','vtysh -c "show bgp ipv4 uni"','No BGP prefixes displayed','pass','Core Unicast SAFI clean') luCommand(
luCommand('r2','vtysh -c "show bgp ipv4 uni"','No BGP prefixes displayed','pass','Core Unicast SAFI clean') "r1",
luCommand('r3','vtysh -c "show bgp ipv4 uni"','No BGP prefixes displayed','pass','Core Unicast SAFI clean') 'vtysh -c "show bgp ipv4 uni"',
luCommand('r4','vtysh -c "show bgp ipv4 uni"','No BGP prefixes displayed','pass','Core Unicast SAFI clean') "No BGP prefixes displayed",
"pass",
"Core Unicast SAFI clean",
)
luCommand(
"r2",
'vtysh -c "show bgp ipv4 uni"',
"No BGP prefixes displayed",
"pass",
"Core Unicast SAFI clean",
)
luCommand(
"r3",
'vtysh -c "show bgp ipv4 uni"',
"No BGP prefixes displayed",
"pass",
"Core Unicast SAFI clean",
)
luCommand(
"r4",
'vtysh -c "show bgp ipv4 uni"',
"No BGP prefixes displayed",
"pass",
"Core Unicast SAFI clean",
)
######################################################################## ########################################################################
# PE routers: local ce-originated routes are leaked to vpn # PE routers: local ce-originated routes are leaked to vpn
######################################################################## ########################################################################
# nhzero is for the new code that sets nh of locally-leaked routes to 0 # nhzero is for the new code that sets nh of locally-leaked routes to 0
#nhzero = 1 # nhzero = 1
nhzero = 0 nhzero = 0
if nhzero: if nhzero:
luCommand('r1','vtysh -c "show bgp ipv4 vpn"', luCommand(
'Distinguisher: *10:1.*5.1.0.0/24 *0.0.0.0 .*5.1.1.0/24 *0.0.0.0 .*99.0.0.1/32 *0.0.0.0 ', "r1",
'pass','vrf->vpn routes') 'vtysh -c "show bgp ipv4 vpn"',
luCommand('r3','vtysh -c "show bgp ipv4 vpn"', "Distinguisher: *10:1.*5.1.0.0/24 *0.0.0.0 .*5.1.1.0/24 *0.0.0.0 .*99.0.0.1/32 *0.0.0.0 ",
'Distinguisher: *10:3.*5.1.0.0/24 *0.0.0.0 .*5.1.1.0/24 *0.0.0.0 .*99.0.0.2/32 *0.0.0.0 ', "pass",
'pass','vrf->vpn routes') "vrf->vpn routes",
)
luCommand(
"r3",
'vtysh -c "show bgp ipv4 vpn"',
"Distinguisher: *10:3.*5.1.0.0/24 *0.0.0.0 .*5.1.1.0/24 *0.0.0.0 .*99.0.0.2/32 *0.0.0.0 ",
"pass",
"vrf->vpn routes",
)
want = [ want = [
{'rd':'10:41', 'p':'5.1.2.0/24', 'n':'0.0.0.0'}, {"rd": "10:41", "p": "5.1.2.0/24", "n": "0.0.0.0"},
{'rd':'10:41', 'p':'5.1.3.0/24', 'n':'0.0.0.0'}, {"rd": "10:41", "p": "5.1.3.0/24", "n": "0.0.0.0"},
{'rd':'10:41', 'p':'99.0.0.3/32', 'n':'0.0.0.0'}, {"rd": "10:41", "p": "99.0.0.3/32", "n": "0.0.0.0"},
{"rd": "10:42", "p": "5.4.2.0/24", "n": "0.0.0.0"},
{'rd':'10:42', 'p':'5.4.2.0/24', 'n':'0.0.0.0'}, {"rd": "10:42", "p": "5.4.3.0/24", "n": "0.0.0.0"},
{'rd':'10:42', 'p':'5.4.3.0/24', 'n':'0.0.0.0'}, {"rd": "10:42", "p": "99.0.0.4/32", "n": "0.0.0.0"},
{'rd':'10:42', 'p':'99.0.0.4/32', 'n':'0.0.0.0'},
] ]
bgpribRequireVpnRoutes('r4','vrf->vpn routes',want) bgpribRequireVpnRoutes("r4", "vrf->vpn routes", want)
else: else:
luCommand('r1','vtysh -c "show bgp ipv4 vpn"', luCommand(
r'Distinguisher: *10:1.*5.1.0.0/24 *99.0.0.1\b.*5.1.1.0/24 *99.0.0.1\b.*99.0.0.1/32 *192.168.1.2\b', "r1",
'pass','vrf->vpn routes') 'vtysh -c "show bgp ipv4 vpn"',
luCommand('r3','vtysh -c "show bgp ipv4 vpn"', r"Distinguisher: *10:1.*5.1.0.0/24 *99.0.0.1\b.*5.1.1.0/24 *99.0.0.1\b.*99.0.0.1/32 *192.168.1.2\b",
r'Distinguisher: *10:3.*5.1.0.0/24 *99.0.0.2\b.*5.1.1.0/24 *99.0.0.2\b.*99.0.0.2/32 *192.168.1.2\b', "pass",
'pass','vrf->vpn routes') "vrf->vpn routes",
)
luCommand(
"r3",
'vtysh -c "show bgp ipv4 vpn"',
r"Distinguisher: *10:3.*5.1.0.0/24 *99.0.0.2\b.*5.1.1.0/24 *99.0.0.2\b.*99.0.0.2/32 *192.168.1.2\b",
"pass",
"vrf->vpn routes",
)
want = [ want = [
{'rd':'10:41', 'p':'5.1.2.0/24', 'n':'99.0.0.3'}, {"rd": "10:41", "p": "5.1.2.0/24", "n": "99.0.0.3"},
{'rd':'10:41', 'p':'5.1.3.0/24', 'n':'99.0.0.3'}, {"rd": "10:41", "p": "5.1.3.0/24", "n": "99.0.0.3"},
{'rd':'10:41', 'p':'99.0.0.3/32', 'n':'192.168.1.2'}, {"rd": "10:41", "p": "99.0.0.3/32", "n": "192.168.1.2"},
{"rd": "10:42", "p": "5.4.2.0/24", "n": "99.0.0.4"},
{'rd':'10:42', 'p':'5.4.2.0/24', 'n':'99.0.0.4'}, {"rd": "10:42", "p": "5.4.3.0/24", "n": "99.0.0.4"},
{'rd':'10:42', 'p':'5.4.3.0/24', 'n':'99.0.0.4'}, {"rd": "10:42", "p": "99.0.0.4/32", "n": "192.168.2.2"},
{'rd':'10:42', 'p':'99.0.0.4/32', 'n':'192.168.2.2'},
] ]
bgpribRequireVpnRoutes('r4','vrf->vpn routes',want) bgpribRequireVpnRoutes("r4", "vrf->vpn routes", want)
######################################################################## ########################################################################
# PE routers: exporting vrfs set MPLS vrf labels in kernel # PE routers: exporting vrfs set MPLS vrf labels in kernel
######################################################################## ########################################################################
luCommand('r1','vtysh -c "show mpls table"',' 101 *BGP *r1-cust1','pass','vrf labels') luCommand(
luCommand('r3','vtysh -c "show mpls table"',' 103 *BGP *r3-cust1','pass','vrf labels') "r1", 'vtysh -c "show mpls table"', " 101 *BGP *r1-cust1", "pass", "vrf labels"
luCommand('r4','vtysh -c "show mpls table"',' 1041 *BGP *r4-cust1 .*1042 *BGP *r4-cust2','pass','vrf labels') )
luCommand(
"r3", 'vtysh -c "show mpls table"', " 103 *BGP *r3-cust1", "pass", "vrf labels"
)
luCommand(
"r4",
'vtysh -c "show mpls table"',
" 1041 *BGP *r4-cust1 .*1042 *BGP *r4-cust2",
"pass",
"vrf labels",
)
######################################################################## ########################################################################
# Core VPN router: all customer routes # Core VPN router: all customer routes
######################################################################## ########################################################################
want_rd_routes = [ want_rd_routes = [
{'rd':'10:1', 'p':'5.1.0.0/24', 'n':'1.1.1.1'}, {"rd": "10:1", "p": "5.1.0.0/24", "n": "1.1.1.1"},
{'rd':'10:1', 'p':'5.1.0.0/24', 'n':'1.1.1.1'}, {"rd": "10:1", "p": "5.1.0.0/24", "n": "1.1.1.1"},
{'rd':'10:1', 'p':'99.0.0.1/32', 'n':'1.1.1.1'}, {"rd": "10:1", "p": "99.0.0.1/32", "n": "1.1.1.1"},
{"rd": "10:3", "p": "5.1.0.0/24", "n": "3.3.3.3"},
{'rd':'10:3', 'p':'5.1.0.0/24', 'n':'3.3.3.3'}, {"rd": "10:3", "p": "5.1.0.0/24", "n": "3.3.3.3"},
{'rd':'10:3', 'p':'5.1.0.0/24', 'n':'3.3.3.3'}, {"rd": "10:3", "p": "99.0.0.2/32", "n": "3.3.3.3"},
{'rd':'10:3', 'p':'99.0.0.2/32', 'n':'3.3.3.3'}, {"rd": "10:41", "p": "5.1.2.0/24", "n": "4.4.4.4"},
{"rd": "10:41", "p": "5.1.3.0/24", "n": "4.4.4.4"},
{'rd':'10:41', 'p':'5.1.2.0/24', 'n':'4.4.4.4'}, {"rd": "10:41", "p": "99.0.0.3/32", "n": "4.4.4.4"},
{'rd':'10:41', 'p':'5.1.3.0/24', 'n':'4.4.4.4'}, {"rd": "10:42", "p": "5.4.2.0/24", "n": "4.4.4.4"},
{'rd':'10:41', 'p':'99.0.0.3/32', 'n':'4.4.4.4'}, {"rd": "10:42", "p": "5.4.3.0/24", "n": "4.4.4.4"},
{"rd": "10:42", "p": "99.0.0.4/32", "n": "4.4.4.4"},
{'rd':'10:42', 'p':'5.4.2.0/24', 'n':'4.4.4.4'},
{'rd':'10:42', 'p':'5.4.3.0/24', 'n':'4.4.4.4'},
{'rd':'10:42', 'p':'99.0.0.4/32', 'n':'4.4.4.4'},
] ]
bgpribRequireVpnRoutes('r2','Customer routes in provider vpn core',want_rd_routes) bgpribRequireVpnRoutes("r2", "Customer routes in provider vpn core", want_rd_routes)
######################################################################## ########################################################################
# PE routers: VPN routes from remote customers # PE routers: VPN routes from remote customers
@ -165,46 +218,46 @@ bgpribRequireVpnRoutes('r2','Customer routes in provider vpn core',want_rd_route
# r1 vtysh -c "show bgp ipv4 vpn" # r1 vtysh -c "show bgp ipv4 vpn"
# #
want_r1_remote_vpn_routes = [ want_r1_remote_vpn_routes = [
{'rd':'10:3', 'p':'5.1.0.0/24', 'n':'3.3.3.3'}, {"rd": "10:3", "p": "5.1.0.0/24", "n": "3.3.3.3"},
{'rd':'10:3', 'p':'5.1.1.0/24', 'n':'3.3.3.3'}, {"rd": "10:3", "p": "5.1.1.0/24", "n": "3.3.3.3"},
{'rd':'10:3', 'p':'99.0.0.2/32', 'n':'3.3.3.3'}, {"rd": "10:3", "p": "99.0.0.2/32", "n": "3.3.3.3"},
{"rd": "10:41", "p": "5.1.2.0/24", "n": "4.4.4.4"},
{'rd':'10:41', 'p':'5.1.2.0/24', 'n':'4.4.4.4'}, {"rd": "10:41", "p": "5.1.3.0/24", "n": "4.4.4.4"},
{'rd':'10:41', 'p':'5.1.3.0/24', 'n':'4.4.4.4'}, {"rd": "10:41", "p": "99.0.0.3/32", "n": "4.4.4.4"},
{'rd':'10:41', 'p':'99.0.0.3/32', 'n':'4.4.4.4'}, {"rd": "10:42", "p": "5.4.2.0/24", "n": "4.4.4.4"},
{"rd": "10:42", "p": "5.4.3.0/24", "n": "4.4.4.4"},
{'rd':'10:42', 'p':'5.4.2.0/24', 'n':'4.4.4.4'}, {"rd": "10:42", "p": "99.0.0.4/32", "n": "4.4.4.4"},
{'rd':'10:42', 'p':'5.4.3.0/24', 'n':'4.4.4.4'},
{'rd':'10:42', 'p':'99.0.0.4/32', 'n':'4.4.4.4'},
] ]
bgpribRequireVpnRoutes('r1','Remote Customer routes in R1 vpn',want_r1_remote_vpn_routes) bgpribRequireVpnRoutes(
"r1", "Remote Customer routes in R1 vpn", want_r1_remote_vpn_routes
)
want_r3_remote_vpn_routes = [ want_r3_remote_vpn_routes = [
{'rd':'10:1', 'p':'5.1.0.0/24', 'n':'1.1.1.1'}, {"rd": "10:1", "p": "5.1.0.0/24", "n": "1.1.1.1"},
{'rd':'10:1', 'p':'5.1.1.0/24', 'n':'1.1.1.1'}, {"rd": "10:1", "p": "5.1.1.0/24", "n": "1.1.1.1"},
{'rd':'10:1', 'p':'99.0.0.1/32', 'n':'1.1.1.1'}, {"rd": "10:1", "p": "99.0.0.1/32", "n": "1.1.1.1"},
{"rd": "10:41", "p": "5.1.2.0/24", "n": "4.4.4.4"},
{'rd':'10:41', 'p':'5.1.2.0/24', 'n':'4.4.4.4'}, {"rd": "10:41", "p": "5.1.3.0/24", "n": "4.4.4.4"},
{'rd':'10:41', 'p':'5.1.3.0/24', 'n':'4.4.4.4'}, {"rd": "10:41", "p": "99.0.0.3/32", "n": "4.4.4.4"},
{'rd':'10:41', 'p':'99.0.0.3/32', 'n':'4.4.4.4'}, {"rd": "10:42", "p": "5.4.2.0/24", "n": "4.4.4.4"},
{"rd": "10:42", "p": "5.4.3.0/24", "n": "4.4.4.4"},
{'rd':'10:42', 'p':'5.4.2.0/24', 'n':'4.4.4.4'}, {"rd": "10:42", "p": "99.0.0.4/32", "n": "4.4.4.4"},
{'rd':'10:42', 'p':'5.4.3.0/24', 'n':'4.4.4.4'},
{'rd':'10:42', 'p':'99.0.0.4/32', 'n':'4.4.4.4'},
] ]
bgpribRequireVpnRoutes('r3','Remote Customer routes in R3 vpn',want_r3_remote_vpn_routes) bgpribRequireVpnRoutes(
"r3", "Remote Customer routes in R3 vpn", want_r3_remote_vpn_routes
)
want_r4_remote_vpn_routes = [ want_r4_remote_vpn_routes = [
{'rd':'10:1', 'p':'5.1.0.0/24', 'n':'1.1.1.1'}, {"rd": "10:1", "p": "5.1.0.0/24", "n": "1.1.1.1"},
{'rd':'10:1', 'p':'5.1.1.0/24', 'n':'1.1.1.1'}, {"rd": "10:1", "p": "5.1.1.0/24", "n": "1.1.1.1"},
{'rd':'10:1', 'p':'99.0.0.1/32', 'n':'1.1.1.1'}, {"rd": "10:1", "p": "99.0.0.1/32", "n": "1.1.1.1"},
{"rd": "10:3", "p": "5.1.0.0/24", "n": "3.3.3.3"},
{'rd':'10:3', 'p':'5.1.0.0/24', 'n':'3.3.3.3'}, {"rd": "10:3", "p": "5.1.1.0/24", "n": "3.3.3.3"},
{'rd':'10:3', 'p':'5.1.1.0/24', 'n':'3.3.3.3'}, {"rd": "10:3", "p": "99.0.0.2/32", "n": "3.3.3.3"},
{'rd':'10:3', 'p':'99.0.0.2/32', 'n':'3.3.3.3'},
] ]
bgpribRequireVpnRoutes('r4','Remote Customer routes in R4 vpn',want_r4_remote_vpn_routes) bgpribRequireVpnRoutes(
"r4", "Remote Customer routes in R4 vpn", want_r4_remote_vpn_routes
)
# r1 vtysh -c "show bgp vrf r1-cust1 ipv4" # r1 vtysh -c "show bgp vrf r1-cust1 ipv4"
@ -213,54 +266,58 @@ bgpribRequireVpnRoutes('r4','Remote Customer routes in R4 vpn',want_r4_remote_vp
# PE routers: VRFs contain routes from remote customer nets # PE routers: VRFs contain routes from remote customer nets
######################################################################## ########################################################################
want_r1_remote_cust1_routes = [ want_r1_remote_cust1_routes = [
{'p':'5.1.0.0/24', 'n':'3.3.3.3'}, {"p": "5.1.0.0/24", "n": "3.3.3.3"},
{'p':'5.1.1.0/24', 'n':'3.3.3.3'}, {"p": "5.1.1.0/24", "n": "3.3.3.3"},
{'p':'99.0.0.2/32', 'n':'3.3.3.3'}, {"p": "99.0.0.2/32", "n": "3.3.3.3"},
{"p": "5.1.2.0/24", "n": "4.4.4.4"},
{'p':'5.1.2.0/24', 'n':'4.4.4.4'}, {"p": "5.1.3.0/24", "n": "4.4.4.4"},
{'p':'5.1.3.0/24', 'n':'4.4.4.4'}, {"p": "99.0.0.3/32", "n": "4.4.4.4"},
{'p':'99.0.0.3/32', 'n':'4.4.4.4'}, {"p": "5.4.2.0/24", "n": "4.4.4.4"},
{"p": "5.4.3.0/24", "n": "4.4.4.4"},
{'p':'5.4.2.0/24', 'n':'4.4.4.4'}, {"p": "99.0.0.3/32", "n": "4.4.4.4"},
{'p':'5.4.3.0/24', 'n':'4.4.4.4'},
{'p':'99.0.0.3/32', 'n':'4.4.4.4'},
] ]
bgpribRequireUnicastRoutes('r1','ipv4','r1-cust1','Customer 1 routes in r1 vrf',want_r1_remote_cust1_routes) bgpribRequireUnicastRoutes(
"r1", "ipv4", "r1-cust1", "Customer 1 routes in r1 vrf", want_r1_remote_cust1_routes
)
want_r3_remote_cust1_routes = [ want_r3_remote_cust1_routes = [
{'p':'5.1.0.0/24', 'n':'1.1.1.1'}, {"p": "5.1.0.0/24", "n": "1.1.1.1"},
{'p':'5.1.1.0/24', 'n':'1.1.1.1'}, {"p": "5.1.1.0/24", "n": "1.1.1.1"},
{'p':'99.0.0.1/32', 'n':'1.1.1.1'}, {"p": "99.0.0.1/32", "n": "1.1.1.1"},
{"p": "5.1.2.0/24", "n": "4.4.4.4"},
{'p':'5.1.2.0/24', 'n':'4.4.4.4'}, {"p": "5.1.3.0/24", "n": "4.4.4.4"},
{'p':'5.1.3.0/24', 'n':'4.4.4.4'}, {"p": "99.0.0.3/32", "n": "4.4.4.4"},
{'p':'99.0.0.3/32', 'n':'4.4.4.4'}, {"p": "5.4.2.0/24", "n": "4.4.4.4"},
{"p": "5.4.3.0/24", "n": "4.4.4.4"},
{'p':'5.4.2.0/24', 'n':'4.4.4.4'}, {"p": "99.0.0.3/32", "n": "4.4.4.4"},
{'p':'5.4.3.0/24', 'n':'4.4.4.4'},
{'p':'99.0.0.3/32', 'n':'4.4.4.4'},
] ]
bgpribRequireUnicastRoutes('r3','ipv4','r3-cust1','Customer 1 routes in r3 vrf',want_r3_remote_cust1_routes) bgpribRequireUnicastRoutes(
"r3", "ipv4", "r3-cust1", "Customer 1 routes in r3 vrf", want_r3_remote_cust1_routes
)
want_r4_remote_cust1_routes = [ want_r4_remote_cust1_routes = [
{'p':'5.1.0.0/24', 'n':'1.1.1.1'}, {"p": "5.1.0.0/24", "n": "1.1.1.1"},
{'p':'5.1.1.0/24', 'n':'1.1.1.1'}, {"p": "5.1.1.0/24", "n": "1.1.1.1"},
{'p':'5.1.0.0/24', 'n':'3.3.3.3'}, {"p": "5.1.0.0/24", "n": "3.3.3.3"},
{'p':'5.1.1.0/24', 'n':'3.3.3.3'}, {"p": "5.1.1.0/24", "n": "3.3.3.3"},
{'p':'99.0.0.1/32', 'n':'1.1.1.1'}, {"p": "99.0.0.1/32", "n": "1.1.1.1"},
{'p':'99.0.0.2/32', 'n':'3.3.3.3'}, {"p": "99.0.0.2/32", "n": "3.3.3.3"},
] ]
bgpribRequireUnicastRoutes('r4','ipv4','r4-cust1','Customer 1 routes in r4 vrf',want_r4_remote_cust1_routes) bgpribRequireUnicastRoutes(
"r4", "ipv4", "r4-cust1", "Customer 1 routes in r4 vrf", want_r4_remote_cust1_routes
)
want_r4_remote_cust2_routes = [ want_r4_remote_cust2_routes = [
{'p':'5.1.0.0/24', 'n':'1.1.1.1'}, {"p": "5.1.0.0/24", "n": "1.1.1.1"},
{'p':'5.1.1.0/24', 'n':'1.1.1.1'}, {"p": "5.1.1.0/24", "n": "1.1.1.1"},
{'p':'5.1.0.0/24', 'n':'3.3.3.3'}, {"p": "5.1.0.0/24", "n": "3.3.3.3"},
{'p':'5.1.1.0/24', 'n':'3.3.3.3'}, {"p": "5.1.1.0/24", "n": "3.3.3.3"},
{'p':'99.0.0.1/32', 'n':'1.1.1.1'}, {"p": "99.0.0.1/32", "n": "1.1.1.1"},
{'p':'99.0.0.2/32', 'n':'3.3.3.3'}, {"p": "99.0.0.2/32", "n": "3.3.3.3"},
] ]
bgpribRequireUnicastRoutes('r4','ipv4','r4-cust2','Customer 2 routes in r4 vrf',want_r4_remote_cust2_routes) bgpribRequireUnicastRoutes(
"r4", "ipv4", "r4-cust2", "Customer 2 routes in r4 vrf", want_r4_remote_cust2_routes
)
######################################################################### #########################################################################
@ -270,49 +327,78 @@ bgpribRequireUnicastRoutes('r4','ipv4','r4-cust2','Customer 2 routes in r4 vrf',
# r1 vtysh -c "show bgp vrf r1-cust1 ipv4" # r1 vtysh -c "show bgp vrf r1-cust1 ipv4"
# r1 vtysh -c "show bgp vrf r1-cust1 ipv4 5.1.2.0/24" # r1 vtysh -c "show bgp vrf r1-cust1 ipv4 5.1.2.0/24"
luCommand('ce1','vtysh -c "show bgp ipv4 uni"','10 routes and 10','wait','Local and remote routes', 10) luCommand(
"ce1",
'vtysh -c "show bgp ipv4 uni"',
"10 routes and 10",
"wait",
"Local and remote routes",
10,
)
want = [ want = [
{'p':'5.1.2.0/24', 'n':'192.168.1.1'}, {"p": "5.1.2.0/24", "n": "192.168.1.1"},
{'p':'5.1.3.0/24', 'n':'192.168.1.1'}, {"p": "5.1.3.0/24", "n": "192.168.1.1"},
{'p':'5.4.2.0/24', 'n':'192.168.1.1'}, {"p": "5.4.2.0/24", "n": "192.168.1.1"},
{'p':'5.4.3.0/24', 'n':'192.168.1.1'}, {"p": "5.4.3.0/24", "n": "192.168.1.1"},
] ]
bgpribRequireUnicastRoutes('ce1','ipv4','','Cust 1 routes from remote',want) bgpribRequireUnicastRoutes("ce1", "ipv4", "", "Cust 1 routes from remote", want)
luCommand('ce2','vtysh -c "show bgp ipv4 uni"','10 routes and 12','wait','Local and remote routes', 10) luCommand(
"ce2",
'vtysh -c "show bgp ipv4 uni"',
"10 routes and 12",
"wait",
"Local and remote routes",
10,
)
want = [ want = [
{'p':'5.1.0.0/24', 'n':'192.168.1.1'}, {"p": "5.1.0.0/24", "n": "192.168.1.1"},
{'p':'5.1.1.0/24', 'n':'192.168.1.1'}, {"p": "5.1.1.0/24", "n": "192.168.1.1"},
{'p':'5.1.2.0/24', 'n':'192.168.1.1'}, {"p": "5.1.2.0/24", "n": "192.168.1.1"},
{'p':'5.1.3.0/24', 'n':'192.168.1.1'}, {"p": "5.1.3.0/24", "n": "192.168.1.1"},
{'p':'5.4.2.0/24', 'n':'192.168.1.1'}, {"p": "5.4.2.0/24", "n": "192.168.1.1"},
{'p':'5.4.3.0/24', 'n':'192.168.1.1'}, {"p": "5.4.3.0/24", "n": "192.168.1.1"},
] ]
bgpribRequireUnicastRoutes('ce2','ipv4','','Cust 1 routes from remote',want) bgpribRequireUnicastRoutes("ce2", "ipv4", "", "Cust 1 routes from remote", want)
# human readable output for debugging # human readable output for debugging
luCommand('r4','vtysh -c "show bgp vrf r4-cust1 ipv4 uni"') luCommand("r4", 'vtysh -c "show bgp vrf r4-cust1 ipv4 uni"')
luCommand('r4','vtysh -c "show bgp vrf r4-cust2 ipv4 uni"') luCommand("r4", 'vtysh -c "show bgp vrf r4-cust2 ipv4 uni"')
luCommand('r4','vtysh -c "show bgp ipv4 vpn"') luCommand("r4", 'vtysh -c "show bgp ipv4 vpn"')
luCommand('r4','vtysh -c "show ip route vrf r4-cust1"') luCommand("r4", 'vtysh -c "show ip route vrf r4-cust1"')
luCommand('r4','vtysh -c "show ip route vrf r4-cust2"') luCommand("r4", 'vtysh -c "show ip route vrf r4-cust2"')
luCommand('ce3','vtysh -c "show bgp ipv4 uni"','10 routes and 10','wait','Local and remote routes', 10) luCommand(
"ce3",
'vtysh -c "show bgp ipv4 uni"',
"10 routes and 10",
"wait",
"Local and remote routes",
10,
)
# Requires bvl-bug-degenerate-no-label fix (FRR PR #2053) # Requires bvl-bug-degenerate-no-label fix (FRR PR #2053)
want = [ want = [
{'p':'5.1.0.0/24', 'n':'192.168.1.1'}, {"p": "5.1.0.0/24", "n": "192.168.1.1"},
{'p':'5.1.1.0/24', 'n':'192.168.1.1'}, {"p": "5.1.1.0/24", "n": "192.168.1.1"},
{'p':'5.4.2.0/24', 'n':'192.168.1.1'}, {"p": "5.4.2.0/24", "n": "192.168.1.1"},
{'p':'5.4.3.0/24', 'n':'192.168.1.1'}, {"p": "5.4.3.0/24", "n": "192.168.1.1"},
] ]
bgpribRequireUnicastRoutes('ce3','ipv4','','Cust 1 routes from remote',want) bgpribRequireUnicastRoutes("ce3", "ipv4", "", "Cust 1 routes from remote", want)
luCommand('ce4','vtysh -c "show bgp vrf ce4-cust2 ipv4 uni"','10 routes and 10','wait','Local and remote routes', 10) luCommand(
"ce4",
'vtysh -c "show bgp vrf ce4-cust2 ipv4 uni"',
"10 routes and 10",
"wait",
"Local and remote routes",
10,
)
want = [ want = [
{'p':'5.1.0.0/24', 'n':'192.168.2.1'}, {"p": "5.1.0.0/24", "n": "192.168.2.1"},
{'p':'5.1.1.0/24', 'n':'192.168.2.1'}, {"p": "5.1.1.0/24", "n": "192.168.2.1"},
{'p':'5.1.2.0/24', 'n':'192.168.2.1'}, {"p": "5.1.2.0/24", "n": "192.168.2.1"},
{'p':'5.1.3.0/24', 'n':'192.168.2.1'}, {"p": "5.1.3.0/24", "n": "192.168.2.1"},
] ]
bgpribRequireUnicastRoutes('ce4','ipv4','ce4-cust2','Cust 2 routes from remote',want) bgpribRequireUnicastRoutes(
"ce4", "ipv4", "ce4-cust2", "Cust 2 routes from remote", want
)

135
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/cleanup_all.py
View File

@ -1,17 +1,120 @@
from lutil import luCommand from lutil import luCommand
luCommand('r1','vtysh -c "clear vrf r1-cust1 prefix 99.0.0.1/32"','.','none','Cleared VRF route')
luCommand('r3','vtysh -c "clear vrf r3-cust1 prefix 99.0.0.2/32"','.','none','Cleared VRF route') luCommand(
luCommand('r4','vtysh -c "clear vrf r3-cust1 prefix 99.0.0.3/32"','.','none','Cleared VRF route') "r1",
luCommand('r1','vtysh -c "show vnc registrations local"','99.0.0.1','fail','Local Registration cleared') 'vtysh -c "clear vrf r1-cust1 prefix 99.0.0.1/32"',
luCommand('r3','vtysh -c "show vnc registrations local"','99.0.0.2','fail','Local Registration cleared') ".",
luCommand('r4','vtysh -c "show vnc registrations local"','99.0.0.3','fail','Local Registration cleared') "none",
luCommand('r1','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Unicast SAFI updated', 10) "Cleared VRF route",
luCommand('r2','vtysh -c "show bgp ipv4 uni"','No BGP prefixes displayed','pass','Unicast SAFI') )
luCommand('r3','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Unicast SAFI updated', 10) luCommand(
luCommand('r4','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Unicast SAFI updated', 10) "r3",
luCommand('ce1','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Local and remote routes', 10) 'vtysh -c "clear vrf r3-cust1 prefix 99.0.0.2/32"',
luCommand('ce2','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Local and remote routes', 10) ".",
luCommand('ce3','vtysh -c "show bgp ipv4 uni"','2 routes and 2','wait','Local and remote routes', 10) "none",
luCommand('r1','vtysh -c "show vnc registrations remote"','Prefix ','fail','Remote Registration cleared') "Cleared VRF route",
luCommand('r3','vtysh -c "show vnc registrations remote"','Prefix ','fail','Remote Registration cleared') )
luCommand('r4','vtysh -c "show vnc registrations remote"','Prefix ','fail','Remote Registration cleared') luCommand(
"r4",
'vtysh -c "clear vrf r3-cust1 prefix 99.0.0.3/32"',
".",
"none",
"Cleared VRF route",
)
luCommand(
"r1",
'vtysh -c "show vnc registrations local"',
"99.0.0.1",
"fail",
"Local Registration cleared",
)
luCommand(
"r3",
'vtysh -c "show vnc registrations local"',
"99.0.0.2",
"fail",
"Local Registration cleared",
)
luCommand(
"r4",
'vtysh -c "show vnc registrations local"',
"99.0.0.3",
"fail",
"Local Registration cleared",
)
luCommand(
"r1",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Unicast SAFI updated",
10,
)
luCommand(
"r2",
'vtysh -c "show bgp ipv4 uni"',
"No BGP prefixes displayed",
"pass",
"Unicast SAFI",
)
luCommand(
"r3",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Unicast SAFI updated",
10,
)
luCommand(
"r4",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Unicast SAFI updated",
10,
)
luCommand(
"ce1",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Local and remote routes",
10,
)
luCommand(
"ce2",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Local and remote routes",
10,
)
luCommand(
"ce3",
'vtysh -c "show bgp ipv4 uni"',
"2 routes and 2",
"wait",
"Local and remote routes",
10,
)
luCommand(
"r1",
'vtysh -c "show vnc registrations remote"',
"Prefix ",
"fail",
"Remote Registration cleared",
)
luCommand(
"r3",
'vtysh -c "show vnc registrations remote"',
"Prefix ",
"fail",
"Remote Registration cleared",
)
luCommand(
"r4",
'vtysh -c "show vnc registrations remote"',
"Prefix ",
"fail",
"Remote Registration cleared",
)

33
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/del_bgp_instances.py
View File

@ -1,7 +1,30 @@
from lutil import luCommand from lutil import luCommand
luCommand('r1','/usr/lib/frr/vtysh -c "conf ter" -c "no router bgp 5227 vrf r1-cust1" -c "no router bgp 5226"','.','none','Cleared bgp instances') luCommand(
luCommand('r2','/usr/lib/frr/vtysh -c "conf ter" -c "no router bgp 5226"','.','none','Cleared bgp instances') "r1",
luCommand('r3','/usr/lib/frr/vtysh -c "conf ter" -c "no router bgp 5227 vrf r3-cust1" -c "no router bgp 5226"','.','none','Cleared bgp instances') '/usr/lib/frr/vtysh -c "conf ter" -c "no router bgp 5227 vrf r1-cust1" -c "no router bgp 5226"',
luCommand('r4','/usr/lib/frr/vtysh -c "conf ter" -c "no router bgp 5228 vrf r4-cust2" -c "no router bgp 5227 vrf r4-cust1" -c "no router bgp 5226"','.','none','Cleared bgp instances') ".",
"none",
"Cleared bgp instances",
)
luCommand(
"r2",
'/usr/lib/frr/vtysh -c "conf ter" -c "no router bgp 5226"',
".",
"none",
"Cleared bgp instances",
)
luCommand(
"r3",
'/usr/lib/frr/vtysh -c "conf ter" -c "no router bgp 5227 vrf r3-cust1" -c "no router bgp 5226"',
".",
"none",
"Cleared bgp instances",
)
luCommand(
"r4",
'/usr/lib/frr/vtysh -c "conf ter" -c "no router bgp 5228 vrf r4-cust2" -c "no router bgp 5227 vrf r4-cust1" -c "no router bgp 5226"',
".",
"none",
"Cleared bgp instances",
)

21
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/notification_check.py
View File

@ -1,9 +1,22 @@
from lutil import luCommand from lutil import luCommand
rtrs = ['ce1', 'ce2', 'ce3', 'r1', 'r2', 'r3', 'r4']
rtrs = ["ce1", "ce2", "ce3", "r1", "r2", "r3", "r4"]
for rtr in rtrs: for rtr in rtrs:
ret = luCommand(rtr, 'vtysh -c "show bgp neigh"', 'Notification received .([A-Za-z0-9/ ]*)', 'none', 'collect neighbor stats') ret = luCommand(
rtr,
'vtysh -c "show bgp neigh"',
"Notification received .([A-Za-z0-9/ ]*)",
"none",
"collect neighbor stats",
)
found = luLast() found = luLast()
if ret != False and found != None: if ret != False and found != None:
val = found.group(1) val = found.group(1)
ret = luCommand(rtr, 'vtysh -c "show bgp neigh"', 'Notification received', 'fail', 'Notify RXed! {}'.format(val)) ret = luCommand(
#done rtr,
'vtysh -c "show bgp neigh"',
"Notification received",
"fail",
"Notify RXed! {}".format(val),
)
# done

94
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/scale_down.py
View File

@ -1,25 +1,87 @@
from lutil import luCommand from lutil import luCommand
ret = luCommand('ce1', 'vtysh -c "show ip route" | grep -c \\ 10\\.\\*/32','(.*)','pass', 'Looking for sharp routes')
ret = luCommand(
"ce1",
'vtysh -c "show ip route" | grep -c \\ 10\\.\\*/32',
"(.*)",
"pass",
"Looking for sharp routes",
)
found = luLast() found = luLast()
if ret != False and found != None: if ret != False and found != None:
num = int(found.group()) num = int(found.group())
luCommand('ce3', 'vtysh -c "show bgp sum"', luCommand(
'.', 'pass', 'See %s sharp routes' % num) "ce3", 'vtysh -c "show bgp sum"', ".", "pass", "See %s sharp routes" % num
)
if num > 0: if num > 0:
rtrs = ['ce1', 'ce2', 'ce3'] rtrs = ["ce1", "ce2", "ce3"]
for rtr in rtrs: for rtr in rtrs:
luCommand(rtr, 'vtysh -c "show bgp ipv4 uni" | grep Display','.', 'none', 'BGP routes pre remove') luCommand(
luCommand(rtr, 'ip route show | cat -n | tail','.', 'none', 'Linux routes pre remove') rtr,
wait = 2*num/500 'vtysh -c "show bgp ipv4 uni" | grep Display',
luCommand('ce1', 'vtysh -c "sharp remove routes 10.0.0.0 {}"'.format(num),'.','none','Removing {} routes'.format(num)) ".",
luCommand('ce2', 'vtysh -c "sharp remove routes 10.0.0.0 {}"'.format(num),'.','none','Removing {} routes'.format(num)) "none",
"BGP routes pre remove",
)
luCommand(
rtr,
"ip route show | cat -n | tail",
".",
"none",
"Linux routes pre remove",
)
wait = 2 * num / 500
luCommand(
"ce1",
'vtysh -c "sharp remove routes 10.0.0.0 {}"'.format(num),
".",
"none",
"Removing {} routes".format(num),
)
luCommand(
"ce2",
'vtysh -c "sharp remove routes 10.0.0.0 {}"'.format(num),
".",
"none",
"Removing {} routes".format(num),
)
for rtr in rtrs: for rtr in rtrs:
luCommand(rtr, 'vtysh -c "show bgp ipv4 uni" | grep Display',' 10 route', 'wait', 'BGP routes removed', wait, wait_time=10) luCommand(
luCommand(rtr, 'vtysh -c "show bgp ipv4 uni"','.', 'none', 'BGP routes post remove') rtr,
'vtysh -c "show bgp ipv4 uni" | grep Display',
" 10 route",
"wait",
"BGP routes removed",
wait,
wait_time=10,
)
luCommand(
rtr,
'vtysh -c "show bgp ipv4 uni"',
".",
"none",
"BGP routes post remove",
)
for rtr in rtrs: for rtr in rtrs:
luCommand(rtr, 'ip route show | grep -c \\^10\\.','^0$', 'wait', 'Linux routes removed', wait, wait_time=10) luCommand(
luCommand(rtr, 'ip route show','.', 'none', 'Linux routes post remove') rtr,
rtrs = ['r1', 'r3', 'r4'] "ip route show | grep -c \\^10\\.",
"^0$",
"wait",
"Linux routes removed",
wait,
wait_time=10,
)
luCommand(rtr, "ip route show", ".", "none", "Linux routes post remove")
rtrs = ["r1", "r3", "r4"]
for rtr in rtrs: for rtr in rtrs:
luCommand(rtr, 'ip route show vrf {}-cust1 | grep -c \\^10\\.'.format(rtr),'^0$','wait','VRF route removed',wait, wait_time=10) luCommand(
#done rtr,
"ip route show vrf {}-cust1 | grep -c \\^10\\.".format(rtr),
"^0$",
"wait",
"VRF route removed",
wait,
wait_time=10,
)
# done

243
tests/topotests/bgp_l3vpn_to_bgp_vrf/scripts/scale_up.py
View File

@ -1,29 +1,38 @@
from lutil import luCommand from lutil import luCommand
num = 50000 num = 50000
b = int(num/(256*256)) b = int(num / (256 * 256))
if b > 0: if b > 0:
r = num - b * (256*256) r = num - b * (256 * 256)
else: else:
r = num r = num
c = int(r/256) c = int(r / 256)
if c > 0: if c > 0:
d = r - c * 256 - 1 d = r - c * 256 - 1
else: else:
d = r d = r
wait = 2*num/1000 wait = 2 * num / 1000
mem_z = {} mem_z = {}
mem_b = {} mem_b = {}
rtrs = ['ce1', 'ce2', 'ce3', 'r1', 'r2', 'r3', 'r4'] rtrs = ["ce1", "ce2", "ce3", "r1", "r2", "r3", "r4"]
for rtr in rtrs: for rtr in rtrs:
mem_z[rtr] = {'value': 0, 'units': 'unknown'} mem_z[rtr] = {"value": 0, "units": "unknown"}
mem_b[rtr] = {'value': 0, 'units': 'unknown'} mem_b[rtr] = {"value": 0, "units": "unknown"}
ret = luCommand(rtr, 'vtysh -c "show memory"', 'zebra: System allocator statistics: Total heap allocated: *(\d*) ([A-Za-z]*) .*bgpd: System allocator statistics: Total heap allocated: *(\d*) ([A-Za-z]*)', 'none', 'collect bgpd memory stats') ret = luCommand(
rtr,
'vtysh -c "show memory"',
"zebra: System allocator statistics: Total heap allocated: *(\d*) ([A-Za-z]*) .*bgpd: System allocator statistics: Total heap allocated: *(\d*) ([A-Za-z]*)",
"none",
"collect bgpd memory stats",
)
found = luLast() found = luLast()
if ret != False and found != None: if ret != False and found != None:
mem_z[rtr] = {'value': int(found.group(1)), 'units': found.group(2)} mem_z[rtr] = {"value": int(found.group(1)), "units": found.group(2)}
mem_b[rtr] = {'value': int(found.group(3)), 'units': found.group(4)} mem_b[rtr] = {"value": int(found.group(3)), "units": found.group(4)}
luCommand('ce1', 'vtysh -c "show mem"', 'qmem sharpd', 'none','check if sharpd running') luCommand(
"ce1", 'vtysh -c "show mem"', "qmem sharpd", "none", "check if sharpd running"
)
doSharp = False doSharp = False
found = luLast() found = luLast()
if ret != False and found != None: if ret != False and found != None:
@ -31,47 +40,195 @@ if ret != False and found != None:
doSharp = True doSharp = True
if doSharp != True: if doSharp != True:
luCommand('ce1', 'vtysh -c "sharp data nexthop"', '.', 'pass','sharpd NOT running, skipping test') luCommand(
"ce1",
'vtysh -c "sharp data nexthop"',
".",
"pass",
"sharpd NOT running, skipping test",
)
else: else:
luCommand('ce1', 'vtysh -c "sharp install routes 10.0.0.0 nexthop 99.0.0.1 {}"'.format(num),'','pass','Adding {} routes'.format(num)) luCommand(
luCommand('ce2', 'vtysh -c "sharp install routes 10.0.0.0 nexthop 99.0.0.2 {}"'.format(num),'','pass','Adding {} routes'.format(num)) "ce1",
rtrs = ['ce1', 'ce2', 'ce3'] 'vtysh -c "sharp install routes 10.0.0.0 nexthop 99.0.0.1 {}"'.format(num),
"",
"pass",
"Adding {} routes".format(num),
)
luCommand(
"ce2",
'vtysh -c "sharp install routes 10.0.0.0 nexthop 99.0.0.2 {}"'.format(num),
"",
"pass",
"Adding {} routes".format(num),
)
rtrs = ["ce1", "ce2", "ce3"]
for rtr in rtrs: for rtr in rtrs:
luCommand(rtr, 'vtysh -c "show bgp ipv4 uni 10.{}.{}.{}"'.format(b,c,d), 'Last update:', 'wait', 'RXed last route, 10.{}.{}.{}'.format(b,c,d), wait, wait_time=10) luCommand(
luCommand(rtr, 'vtysh -c "show bgp ipv4 uni" | grep -c 10\\.\\*/32', str(num), 'wait', 'See all sharp routes in BGP', wait, wait_time=10) rtr,
luCommand('r1', 'vtysh -c "show bgp vrf r1-cust1 ipv4 uni 10.{}.{}.{}"'.format(b,c,d),'99.0.0.1','wait','RXed -> 10.{}.{}.{} from CE1'.format(b,c,d), wait, wait_time=10) 'vtysh -c "show bgp ipv4 uni 10.{}.{}.{}"'.format(b, c, d),
luCommand('r3', 'vtysh -c "show bgp vrf r3-cust1 ipv4 uni 10.{}.{}.{}"'.format(b,c,d),'99.0.0.2','wait','RXed -> 10.{}.{}.{} from CE2'.format(b,c,d), wait, wait_time=10) "Last update:",
luCommand('r1', 'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b,c,d),'99.0.0.1','wait','see VPN safi -> 10.{}.{}.{} from CE1'.format(b,c,d)) "wait",
luCommand('r3', 'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b,c,d),'99.0.0.2','wait','see VPN safi -> 10.{}.{}.{} from CE2'.format(b,c,d)) "RXed last route, 10.{}.{}.{}".format(b, c, d),
luCommand('r3', 'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b,c,d),'1.1.1.1','wait','see VPN safi -> 10.{}.{}.{} from CE1'.format(b,c,d)) wait,
luCommand('r1', 'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b,c,d),'3.3.3.3','wait','see VPN safi -> 10.{}.{}.{} from CE2'.format(b,c,d)) wait_time=10,
luCommand('r4', 'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b,c,d),'1.1.1.1','wait','see VPN safi -> 10.{}.{}.{} from CE1'.format(b,c,d)) )
luCommand('r4', 'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b,c,d),'3.3.3.3','wait','see VPN safi -> 10.{}.{}.{} from CE2'.format(b,c,d)) luCommand(
rtrs = ['ce1', 'ce2', 'ce3'] rtr,
'vtysh -c "show bgp ipv4 uni" | grep -c 10\\.\\*/32',
str(num),
"wait",
"See all sharp routes in BGP",
wait,
wait_time=10,
)
luCommand(
"r1",
'vtysh -c "show bgp vrf r1-cust1 ipv4 uni 10.{}.{}.{}"'.format(b, c, d),
"99.0.0.1",
"wait",
"RXed -> 10.{}.{}.{} from CE1".format(b, c, d),
wait,
wait_time=10,
)
luCommand(
"r3",
'vtysh -c "show bgp vrf r3-cust1 ipv4 uni 10.{}.{}.{}"'.format(b, c, d),
"99.0.0.2",
"wait",
"RXed -> 10.{}.{}.{} from CE2".format(b, c, d),
wait,
wait_time=10,
)
luCommand(
"r1",
'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b, c, d),
"99.0.0.1",
"wait",
"see VPN safi -> 10.{}.{}.{} from CE1".format(b, c, d),
)
luCommand(
"r3",
'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b, c, d),
"99.0.0.2",
"wait",
"see VPN safi -> 10.{}.{}.{} from CE2".format(b, c, d),
)
luCommand(
"r3",
'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b, c, d),
"1.1.1.1",
"wait",
"see VPN safi -> 10.{}.{}.{} from CE1".format(b, c, d),
)
luCommand(
"r1",
'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b, c, d),
"3.3.3.3",
"wait",
"see VPN safi -> 10.{}.{}.{} from CE2".format(b, c, d),
)
luCommand(
"r4",
'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b, c, d),
"1.1.1.1",
"wait",
"see VPN safi -> 10.{}.{}.{} from CE1".format(b, c, d),
)
luCommand(
"r4",
'vtysh -c "show bgp ipv4 vpn 10.{}.{}.{}"'.format(b, c, d),
"3.3.3.3",
"wait",
"see VPN safi -> 10.{}.{}.{} from CE2".format(b, c, d),
)
rtrs = ["ce1", "ce2", "ce3"]
for rtr in rtrs: for rtr in rtrs:
luCommand(rtr, 'ip route get 10.{}.{}.{}'.format(b,c,d),'dev','wait','Route to 10.{}.{}.{} available'.format(b,c,d), wait, wait_time=10) luCommand(
luCommand(rtr, 'ip route show | grep -c \\^10\\.', str(num), 'wait', 'See {} linux routes'.format(num), wait, wait_time=10) rtr,
"ip route get 10.{}.{}.{}".format(b, c, d),
"dev",
"wait",
"Route to 10.{}.{}.{} available".format(b, c, d),
wait,
wait_time=10,
)
luCommand(
rtr,
"ip route show | grep -c \\^10\\.",
str(num),
"wait",
"See {} linux routes".format(num),
wait,
wait_time=10,
)
rtrs = ['r1', 'r3', 'r4'] rtrs = ["r1", "r3", "r4"]
for rtr in rtrs: for rtr in rtrs:
luCommand(rtr, 'ip route get vrf {}-cust1 10.{}.{}.{}'.format(rtr,b,c,d),'dev','wait','VRF route available',wait, wait_time=10) luCommand(
luCommand(rtr, 'ip route show vrf {}-cust1 | grep -c \\^10\\.'.format(rtr), str(num), 'wait','See {} linux routes'.format(num), wait, wait_time=10) rtr,
rtrs = ['ce1', 'ce2', 'ce3', 'r1', 'r2', 'r3', 'r4'] "ip route get vrf {}-cust1 10.{}.{}.{}".format(rtr, b, c, d),
"dev",
"wait",
"VRF route available",
wait,
wait_time=10,
)
luCommand(
rtr,
"ip route show vrf {}-cust1 | grep -c \\^10\\.".format(rtr),
str(num),
"wait",
"See {} linux routes".format(num),
wait,
wait_time=10,
)
rtrs = ["ce1", "ce2", "ce3", "r1", "r2", "r3", "r4"]
for rtr in rtrs: for rtr in rtrs:
ret = luCommand(rtr, 'vtysh -c "show memory"', 'zebra: System allocator statistics: Total heap allocated: *(\d*) ([A-Za-z]*) .*bgpd: System allocator statistics: Total heap allocated: *(\d*) ([A-Za-z]*)', 'none', 'collect bgpd memory stats') ret = luCommand(
rtr,
'vtysh -c "show memory"',
"zebra: System allocator statistics: Total heap allocated: *(\d*) ([A-Za-z]*) .*bgpd: System allocator statistics: Total heap allocated: *(\d*) ([A-Za-z]*)",
"none",
"collect bgpd memory stats",
)
found = luLast() found = luLast()
if ret != False and found != None: if ret != False and found != None:
val_z = int(found.group(1)) val_z = int(found.group(1))
if mem_z[rtr]['units'] != found.group(2): if mem_z[rtr]["units"] != found.group(2):
val_z *= 1000 val_z *= 1000
delta_z = val_z - int(mem_z[rtr]['value']) delta_z = val_z - int(mem_z[rtr]["value"])
ave_z = float(delta_z)/float(num) ave_z = float(delta_z) / float(num)
val_b = int(found.group(3)) val_b = int(found.group(3))
if mem_b[rtr]['units'] != found.group(4): if mem_b[rtr]["units"] != found.group(4):
val_b *= 1000 val_b *= 1000
delta_b = val_b - int(mem_b[rtr]['value']) delta_b = val_b - int(mem_b[rtr]["value"])
ave_b = float(delta_b)/float(num) ave_b = float(delta_b) / float(num)
luCommand(rtr, 'vtysh -c "show thread cpu"', '.', 'pass', 'BGPd heap: {0} {1} --> {2} {3} ({4} {1}/vpn route)'.format(mem_b[rtr]['value'], mem_b[rtr]['units'], found.group(3), found.group(4), round(ave_b,4))) luCommand(
luCommand(rtr, 'vtysh -c "show thread cpu"', '.', 'pass', 'Zebra heap: {0} {1} --> {2} {3} ({4} {1}/vpn route)'.format(mem_z[rtr]['value'], mem_z[rtr]['units'], found.group(1), found.group(2), round(ave_z,4))) rtr,
#done 'vtysh -c "show thread cpu"',
".",
"pass",
"BGPd heap: {0} {1} --> {2} {3} ({4} {1}/vpn route)".format(
mem_b[rtr]["value"],
mem_b[rtr]["units"],
found.group(3),
found.group(4),
round(ave_b, 4),
),
)
luCommand(
rtr,
'vtysh -c "show thread cpu"',
".",
"pass",
"Zebra heap: {0} {1} --> {2} {3} ({4} {1}/vpn route)".format(
mem_z[rtr]["value"],
mem_z[rtr]["units"],
found.group(1),
found.group(2),
round(ave_z, 4),
),
)
# done

139
tests/topotests/bgp_l3vpn_to_bgp_vrf/test_bgp_l3vpn_to_bgp_vrf.py
View File

@ -25,119 +25,132 @@ import os
import sys import sys
import pytest import pytest
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), '../')) sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../"))
from lib.ltemplate import * from lib.ltemplate import *
def test_check_linux_vrf(): def test_check_linux_vrf():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/check_linux_vrf.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/check_linux_vrf.py", False, CliOnFail, CheckFunc)
def test_adjacencies(): def test_adjacencies():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\')' CheckFunc = "ltemplateVersionCheck('4.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)'
ltemplateTest('scripts/adjacencies.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/adjacencies.py", False, CliOnFail, CheckFunc)
def test_notification_check(): def test_notification_check():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/notification_check.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/notification_check.py", False, CliOnFail, CheckFunc)
def SKIP_test_add_routes(): def SKIP_test_add_routes():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\')' CheckFunc = "ltemplateVersionCheck('4.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)'
ltemplateTest('scripts/add_routes.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/add_routes.py", False, CliOnFail, CheckFunc)
def test_check_routes(): def test_check_routes():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\')' CheckFunc = "ltemplateVersionCheck('4.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)'
ltemplateTest('scripts/check_routes.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/check_routes.py", False, CliOnFail, CheckFunc)
#manual data path setup test - remove once have bgp/zebra vrf path working
# manual data path setup test - remove once have bgp/zebra vrf path working
def test_check_linux_mpls(): def test_check_linux_mpls():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/check_linux_mpls.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/check_linux_mpls.py", False, CliOnFail, CheckFunc)
def test_notification_check(): def test_notification_check():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/notification_check.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/notification_check.py", False, CliOnFail, CheckFunc)
def test_check_scale_up(): def test_check_scale_up():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/scale_up.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/scale_up.py", False, CliOnFail, CheckFunc)
def test_notification_check(): def test_notification_check():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/notification_check.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/notification_check.py", False, CliOnFail, CheckFunc)
def test_check_scale_down(): def test_check_scale_down():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/scale_down.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/scale_down.py", False, CliOnFail, CheckFunc)
def test_notification_check(): def test_notification_check():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\', iproute2=\'4.9\')' CheckFunc = "ltemplateVersionCheck('4.1', iproute2='4.9')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True, iproute2=\'4.9\')'
ltemplateTest('scripts/notification_check.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/notification_check.py", False, CliOnFail, CheckFunc)
def SKIP_test_cleanup_all(): def SKIP_test_cleanup_all():
CliOnFail = None CliOnFail = None
# For debugging, uncomment the next line # For debugging, uncomment the next line
#CliOnFail = 'tgen.mininet_cli' # CliOnFail = 'tgen.mininet_cli'
CheckFunc = 'ltemplateVersionCheck(\'4.1\')' CheckFunc = "ltemplateVersionCheck('4.1')"
#uncomment next line to start cli *before* script is run # uncomment next line to start cli *before* script is run
#CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)' # CheckFunc = 'ltemplateVersionCheck(\'4.1\', cli=True)'
ltemplateTest('scripts/cleanup_all.py', False, CliOnFail, CheckFunc) ltemplateTest("scripts/cleanup_all.py", False, CliOnFail, CheckFunc)
if __name__ == '__main__':
if __name__ == "__main__":
retval = pytest.main(["-s"]) retval = pytest.main(["-s"])
sys.exit(retval) sys.exit(retval)

532
tests/topotests/bgp_large_community/test_bgp_large_community_topo_1.py
View File

File diff suppressed because it is too large Load Diff

1078
tests/topotests/bgp_large_community/test_bgp_large_community_topo_2.py
View File

File diff suppressed because it is too large Load Diff

55
tests/topotests/bgp_local_as_private_remove/test_bgp_local_as_private_remove.py
View File

@ -35,7 +35,7 @@ import time
import pytest import pytest
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -43,20 +43,22 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 5): for routern in range(1, 5):
tgen.add_router('r{}'.format(routern)) tgen.add_router("r{}".format(routern))
switch = tgen.add_switch('s1') switch = tgen.add_switch("s1")
switch.add_link(tgen.gears['r1']) switch.add_link(tgen.gears["r1"])
switch.add_link(tgen.gears['r2']) switch.add_link(tgen.gears["r2"])
switch = tgen.add_switch("s2")
switch.add_link(tgen.gears["r3"])
switch.add_link(tgen.gears["r4"])
switch = tgen.add_switch('s2')
switch.add_link(tgen.gears['r3'])
switch.add_link(tgen.gears['r4'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -66,20 +68,20 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_bgp_remove_private_as(): def test_bgp_remove_private_as():
tgen = get_topogen() tgen = get_topogen()
@ -88,24 +90,29 @@ def test_bgp_remove_private_as():
def _bgp_converge(router): def _bgp_converge(router):
while True: while True:
output = json.loads(tgen.gears[router].vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")) output = json.loads(
if output['192.168.255.1']['bgpState'] == 'Established': tgen.gears[router].vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")
)
if output["192.168.255.1"]["bgpState"] == "Established":
time.sleep(1) time.sleep(1)
return True return True
def _bgp_as_path(router): def _bgp_as_path(router):
output = json.loads(tgen.gears[router].vtysh_cmd("show ip bgp 172.16.255.254/32 json")) output = json.loads(
if output['prefix'] == '172.16.255.254/32': tgen.gears[router].vtysh_cmd("show ip bgp 172.16.255.254/32 json")
return output['paths'][0]['aspath']['segments'][0]['list'] )
if output["prefix"] == "172.16.255.254/32":
return output["paths"][0]["aspath"]["segments"][0]["list"]
if _bgp_converge('r2'): if _bgp_converge("r2"):
assert len(_bgp_as_path('r2')) == 1 assert len(_bgp_as_path("r2")) == 1
assert 65000 not in _bgp_as_path('r2') assert 65000 not in _bgp_as_path("r2")
if _bgp_converge('r4'): if _bgp_converge("r4"):
assert len(_bgp_as_path('r4')) == 2 assert len(_bgp_as_path("r4")) == 2
assert 3000 in _bgp_as_path('r4') assert 3000 in _bgp_as_path("r4")
if __name__ == '__main__':
if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

36
tests/topotests/bgp_maximum_prefix_invalid_update/test_bgp_maximum_prefix_invalid_update.py
View File

@ -39,7 +39,7 @@ import time
import pytest import pytest
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -47,16 +47,18 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 3): for routern in range(1, 3):
tgen.add_router('r{}'.format(routern)) 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'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -66,20 +68,20 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_bgp_maximum_prefix_invalid(): def test_bgp_maximum_prefix_invalid():
tgen = get_topogen() tgen = get_topogen()
@ -88,12 +90,16 @@ def test_bgp_maximum_prefix_invalid():
def _bgp_converge(router): def _bgp_converge(router):
while True: while True:
output = json.loads(tgen.gears[router].vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")) output = json.loads(
if output['192.168.255.1']['connectionsEstablished'] > 0: tgen.gears[router].vtysh_cmd("show ip bgp neighbor 192.168.255.1 json")
)
if output["192.168.255.1"]["connectionsEstablished"] > 0:
return True return True
def _bgp_parsing_nlri(router): def _bgp_parsing_nlri(router):
cmd_max_exceeded = 'grep "%MAXPFXEXCEED: No. of IPv4 Unicast prefix received" bgpd.log' cmd_max_exceeded = (
'grep "%MAXPFXEXCEED: No. of IPv4 Unicast prefix received" bgpd.log'
)
cmdt_error_parsing_nlri = 'grep "Error parsing NLRI" bgpd.log' cmdt_error_parsing_nlri = 'grep "Error parsing NLRI" bgpd.log'
output_max_exceeded = tgen.gears[router].run(cmd_max_exceeded) output_max_exceeded = tgen.gears[router].run(cmd_max_exceeded)
output_error_parsing_nlri = tgen.gears[router].run(cmdt_error_parsing_nlri) output_error_parsing_nlri = tgen.gears[router].run(cmdt_error_parsing_nlri)
@ -103,10 +109,10 @@ def test_bgp_maximum_prefix_invalid():
return False return False
return True return True
if _bgp_converge("r2"):
assert _bgp_parsing_nlri("r2") == True
if _bgp_converge('r2'):
assert _bgp_parsing_nlri('r2') == True
if __name__ == '__main__': if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

35
tests/topotests/bgp_maximum_prefix_out/test_bgp_maximum_prefix_out.py
View File

@ -35,7 +35,7 @@ import pytest
import functools import functools
CWD = os.path.dirname(os.path.realpath(__file__)) CWD = os.path.dirname(os.path.realpath(__file__))
sys.path.append(os.path.join(CWD, '../')) sys.path.append(os.path.join(CWD, "../"))
# pylint: disable=C0413 # pylint: disable=C0413
from lib import topotest from lib import topotest
@ -43,16 +43,18 @@ from lib.topogen import Topogen, TopoRouter, get_topogen
from lib.topolog import logger from lib.topolog import logger
from mininet.topo import Topo from mininet.topo import Topo
class TemplateTopo(Topo): class TemplateTopo(Topo):
def build(self, *_args, **_opts): def build(self, *_args, **_opts):
tgen = get_topogen(self) tgen = get_topogen(self)
for routern in range(1, 3): for routern in range(1, 3):
tgen.add_router('r{}'.format(routern)) 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'])
def setup_module(mod): def setup_module(mod):
tgen = Topogen(TemplateTopo, mod.__name__) tgen = Topogen(TemplateTopo, mod.__name__)
@ -62,38 +64,34 @@ def setup_module(mod):
for i, (rname, router) in enumerate(router_list.iteritems(), 1): for i, (rname, router) in enumerate(router_list.iteritems(), 1):
router.load_config( router.load_config(
TopoRouter.RD_ZEBRA, TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
os.path.join(CWD, '{}/zebra.conf'.format(rname))
) )
router.load_config( router.load_config(
TopoRouter.RD_BGP, TopoRouter.RD_BGP, os.path.join(CWD, "{}/bgpd.conf".format(rname))
os.path.join(CWD, '{}/bgpd.conf'.format(rname))
) )
tgen.start_router() tgen.start_router()
def teardown_module(mod): def teardown_module(mod):
tgen = get_topogen() tgen = get_topogen()
tgen.stop_topology() tgen.stop_topology()
def test_bgp_maximum_prefix_out(): def test_bgp_maximum_prefix_out():
tgen = get_topogen() tgen = get_topogen()
if tgen.routers_have_failure(): if tgen.routers_have_failure():
pytest.skip(tgen.errors) pytest.skip(tgen.errors)
router = tgen.gears['r2'] router = tgen.gears["r2"]
def _bgp_converge(router): def _bgp_converge(router):
output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.2 json")) output = json.loads(router.vtysh_cmd("show ip bgp neighbor 192.168.255.2 json"))
expected = { expected = {
'192.168.255.2': { "192.168.255.2": {
'bgpState': 'Established', "bgpState": "Established",
'addressFamilyInfo': { "addressFamilyInfo": {"ipv4Unicast": {"acceptedPrefixCounter": 2}},
'ipv4Unicast': {
'acceptedPrefixCounter': 2
}
}
} }
} }
return topotest.json_cmp(output, expected) return topotest.json_cmp(output, expected)
@ -103,6 +101,7 @@ def test_bgp_maximum_prefix_out():
assert result is None, 'Failed bgp convergence in "{}"'.format(router) assert result is None, 'Failed bgp convergence in "{}"'.format(router)
if __name__ == '__main__':
if __name__ == "__main__":
args = ["-s"] + sys.argv[1:] args = ["-s"] + sys.argv[1:]
sys.exit(pytest.main(args)) sys.exit(pytest.main(args))

6
tests/topotests/bgp_multiview_topo1/peer1/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

11
tests/topotests/bgp_multiview_topo1/peer1/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -16,13 +16,16 @@ numRoutes = int(argv[2])
# Announce numRoutes different routes per PE # Announce numRoutes different routes per PE
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n' % ((peer+100), i, peer, peer)) stdout.write(
"announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n"
% ((peer + 100), i, peer, peer)
)
stdout.flush() stdout.flush()
# Announce 1 overlapping route per peer # Announce 1 overlapping route per peer
stdout.write('announce route 10.0.1.0/24 next-hop 172.16.1.%i\n' % peer) stdout.write("announce route 10.0.1.0/24 next-hop 172.16.1.%i\n" % peer)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp_multiview_topo1/peer2/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

11
tests/topotests/bgp_multiview_topo1/peer2/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -16,13 +16,16 @@ numRoutes = int(argv[2])
# Announce numRoutes different routes per PE # Announce numRoutes different routes per PE
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n' % ((peer+100), i, peer, peer)) stdout.write(
"announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n"
% ((peer + 100), i, peer, peer)
)
stdout.flush() stdout.flush()
# Announce 1 overlapping route per peer # Announce 1 overlapping route per peer
stdout.write('announce route 10.0.1.0/24 next-hop 172.16.1.%i\n' % peer) stdout.write("announce route 10.0.1.0/24 next-hop 172.16.1.%i\n" % peer)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp_multiview_topo1/peer3/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

11
tests/topotests/bgp_multiview_topo1/peer3/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -16,13 +16,16 @@ numRoutes = int(argv[2])
# Announce numRoutes different routes per PE # Announce numRoutes different routes per PE
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n' % ((peer+100), i, peer, peer)) stdout.write(
"announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n"
% ((peer + 100), i, peer, peer)
)
stdout.flush() stdout.flush()
# Announce 1 overlapping route per peer # Announce 1 overlapping route per peer
stdout.write('announce route 10.0.1.0/24 next-hop 172.16.1.%i\n' % peer) stdout.write("announce route 10.0.1.0/24 next-hop 172.16.1.%i\n" % peer)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp_multiview_topo1/peer4/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

11
tests/topotests/bgp_multiview_topo1/peer4/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -16,13 +16,16 @@ numRoutes = int(argv[2])
# Announce numRoutes different routes per PE # Announce numRoutes different routes per PE
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n' % ((peer+100), i, peer, peer)) stdout.write(
"announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n"
% ((peer + 100), i, peer, peer)
)
stdout.flush() stdout.flush()
# Announce 1 overlapping route per peer # Announce 1 overlapping route per peer
stdout.write('announce route 10.0.1.0/24 next-hop 172.16.1.%i\n' % peer) stdout.write("announce route 10.0.1.0/24 next-hop 172.16.1.%i\n" % peer)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp_multiview_topo1/peer5/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

11
tests/topotests/bgp_multiview_topo1/peer5/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -16,13 +16,16 @@ numRoutes = int(argv[2])
# Announce numRoutes different routes per PE # Announce numRoutes different routes per PE
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n' % ((peer+100), i, peer, peer)) stdout.write(
"announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n"
% ((peer + 100), i, peer, peer)
)
stdout.flush() stdout.flush()
# Announce 1 overlapping route per peer # Announce 1 overlapping route per peer
stdout.write('announce route 10.0.1.0/24 next-hop 172.16.1.%i\n' % peer) stdout.write("announce route 10.0.1.0/24 next-hop 172.16.1.%i\n" % peer)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp_multiview_topo1/peer6/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

11
tests/topotests/bgp_multiview_topo1/peer6/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -16,13 +16,16 @@ numRoutes = int(argv[2])
# Announce numRoutes different routes per PE # Announce numRoutes different routes per PE
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n' % ((peer+100), i, peer, peer)) stdout.write(
"announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n"
% ((peer + 100), i, peer, peer)
)
stdout.flush() stdout.flush()
# Announce 1 overlapping route per peer # Announce 1 overlapping route per peer
stdout.write('announce route 10.0.1.0/24 next-hop 172.16.1.%i\n' % peer) stdout.write("announce route 10.0.1.0/24 next-hop 172.16.1.%i\n" % peer)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp_multiview_topo1/peer7/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

11
tests/topotests/bgp_multiview_topo1/peer7/exa-send.py
View File

@ -4,7 +4,7 @@
exa-send.py: Send a few testroutes with ExaBGP exa-send.py: Send a few testroutes with ExaBGP
""" """
from sys import stdout,argv from sys import stdout, argv
from time import sleep from time import sleep
sleep(5) sleep(5)
@ -16,13 +16,16 @@ numRoutes = int(argv[2])
# Announce numRoutes different routes per PE # Announce numRoutes different routes per PE
for i in range(0, numRoutes): for i in range(0, numRoutes):
stdout.write('announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n' % ((peer+100), i, peer, peer)) stdout.write(
"announce route 10.%s.%s.0/24 med 100 community %i:1 next-hop 172.16.1.%i\n"
% ((peer + 100), i, peer, peer)
)
stdout.flush() stdout.flush()
# Announce 1 overlapping route per peer # Announce 1 overlapping route per peer
stdout.write('announce route 10.0.1.0/24 next-hop 172.16.1.%i\n' % peer) stdout.write("announce route 10.0.1.0/24 next-hop 172.16.1.%i\n" % peer)
stdout.flush() stdout.flush()
#Loop endlessly to allow ExaBGP to continue running # Loop endlessly to allow ExaBGP to continue running
while True: while True:
sleep(1) sleep(1)

6
tests/topotests/bgp_multiview_topo1/peer8/exa-receive.py
View File

@ -4,7 +4,7 @@
exa-receive.py: Save received routes form ExaBGP into file exa-receive.py: Save received routes form ExaBGP into file
""" """
from sys import stdin,argv from sys import stdin, argv
from datetime import datetime from datetime import datetime
# 1st arg is peer number # 1st arg is peer number
@ -13,12 +13,12 @@ peer = int(argv[1])
# When the parent dies we are seeing continual newlines, so we only access so many before stopping # When the parent dies we are seeing continual newlines, so we only access so many before stopping
counter = 0 counter = 0
routesavefile = open('/tmp/peer%s-received.log' % peer, 'w') routesavefile = open("/tmp/peer%s-received.log" % peer, "w")
while True: while True:
try: try:
line = stdin.readline() line = stdin.readline()
timestamp = datetime.now().strftime('%Y%m%d_%H:%M:%S - ') timestamp = datetime.now().strftime("%Y%m%d_%H:%M:%S - ")
routesavefile.write(timestamp + line) routesavefile.write(timestamp + line)
routesavefile.flush() routesavefile.flush()

Some files were not shown because too many files have changed in this diff Show More