Avoid py2-only .iteritems() api.
Signed-off-by: Mark Stapp <mjs@voltanet.io>
.. code:: py
# For all registered routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA,
os.path.join(CWD, '{}/zebra.conf'.format(rname))
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname)),
)
router_list = tgen.routers()
# For all registered routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
tgen.start_topology()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
daemon_file = "{}/{}/bfdd.conf".format(CWD, rname)
if os.path.isfile(daemon_file):
router.load_config(TopoRouter.RD_BFD, daemon_file)
tgen.start_topology()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
tgen.start_topology()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
tgen.start_topology()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
daemon_file = "{}/{}/bfdd.conf".format(CWD, rname)
if os.path.isfile(daemon_file):
router.load_config(TopoRouter.RD_BFD, daemon_file)
router_list = tgen.routers()
# check for zebra capability
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
if router.check_capability(TopoRouter.RD_ZEBRA, "--vrfwnetns") == False:
return pytest.skip(
"Skipping BFD Topo1 VRF NETNS feature. VRF NETNS backend not available on FRR"
"ip netns exec {0}-cust1 ifconfig {0}-eth2 up",
]
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
# create VRF rx-cust1 and link rx-eth0 to rx-cust1
for cmd in cmds:
output = tgen.net[rname].cmd(cmd.format(rname))
for cmd in cmds2:
output = tgen.net[rname].cmd(cmd.format(rname))
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA,
os.path.join(CWD, "{}/zebra.conf".format(rname)),
]
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
if rname == "r2":
for cmd in cmds2:
tgen.net[rname].cmd(cmd.format(rname))
router_list = tgen.routers()
# For all registred routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
tgen = get_topogen()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
print(rname + ":")
print(router.vtysh_cmd("show run"))
print(router.vtysh_cmd("show ip route {}".format(vrf_str(vrf))))
tgen = get_topogen()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
with open(
os.path.join(CWD, "{}/{}").format(router.name, conf_file), "r+"
) as cfg:
tgen = get_topogen()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
if vrf == "":
router.vtysh_cmd("conf t\nno router ospf")
else:
# Starting Routers
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
# Starting Hosts and init ExaBGP on each of them
topotest.sleep(10, "starting BGP on all {} peers".format(total_ebgp_peers))
peer_list = tgen.exabgp_peers()
- for pname, peer in peer_list.iteritems():
+ for pname, peer in peer_list.items():
peer_dir = os.path.join(CWD, pname)
env_file = os.path.join(CWD, "exabgp.env")
peer.start(peer_dir, env_file)
link_data = [
val
- for links, val in topo["routers"]["r2"]["links"].iteritems()
+ for links, val in topo["routers"]["r2"]["links"].items()
if "r3" in links
]
for adt in ADDR_TYPES:
link_data = [
val
- for links, val in topo["routers"]["r3"]["links"].iteritems()
+ for links, val in topo["routers"]["r3"]["links"].items()
if "r2" in links
]
INTF_LIST_R3 = [val["interface"].split("/")[0] for val in link_data]
link_data = [
val
- for links, val in topo["routers"]["r2"]["links"].iteritems()
+ for links, val in topo["routers"]["r2"]["links"].items()
if "r3" in links
]
for adt in ADDR_TYPES:
link_data = [
val
- for links, val in topo["routers"]["r3"]["links"].iteritems()
+ for links, val in topo["routers"]["r3"]["links"].items()
if "r2" in links
]
INTF_LIST_R3 = [val["interface"].split("/")[0] for val in link_data]
# tgen.mininet_cli()
# This is a sample of configuration loading.
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
else:
tor_ips_rack = tor_ips_rack_2
- for tor_name, tor_ip in tor_ips_rack.iteritems():
+ for tor_name, tor_ip in tor_ips_rack.items():
if dut_name not in tor_name:
peer_ips.append(tor_ip)
else:
tor_ips_rack = tor_ips_rack_1
- for tor_name, tor_ip in tor_ips_rack.iteritems():
+ for tor_name, tor_ip in tor_ips_rack.items():
remote_ips.append(tor_ip)
# remove down VTEPs from the remote check list
result = None
- expected_es_set = set([v for k, v in host_es_map.iteritems()])
+ expected_es_set = set([v for k, v in host_es_map.items()])
curr_es_set = []
# check is ES content is correct
out = dut.vtysh_cmd("show evpn mac vni %d mac %s json" % (vni, mac))
mac_js = json.loads(out)
- for mac, info in mac_js.iteritems():
+ for mac, info in mac_js.items():
tmp_esi = info.get("esi", "")
tmp_m_type = info.get("type", "")
tmp_intf = info.get("intf", "") if tmp_m_type == "local" else ""
router_list = tgen.routers()
# For all registred routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
tgen.start_topology()
# For all registered routers, load the zebra configuration file
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
router.run("/bin/bash {}/setup_vrfs".format(CWD))
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
# Starting Routers
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router.start()
peer_list = tgen.exabgp_peers()
- for pname, peer in peer_list.iteritems():
+ for pname, peer in peer_list.items():
peer_dir = os.path.join(CWD, pname)
env_file = os.path.join(CWD, "exabgp.env")
peer.start(peer_dir, env_file)
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
tgen.start_topology()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA,
os.path.join(CWD, '{}/zebra.conf'.format(rname))
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
logger.info("starting exaBGP on peer1")
peer_list = tgen.exabgp_peers()
- for pname, peer in peer_list.iteritems():
+ for pname, peer in peer_list.items():
peer_dir = os.path.join(CWD, pname)
env_file = os.path.join(CWD, "exabgp.env")
logger.info("Running ExaBGP peer")
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
# This is a sample of configuration loading.
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
- for i, (rname, router) in enumerate(router_list.iteritems(), 1):
+ for i, (rname, router) in enumerate(router_list.items(), 1):
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
"ip link set {0}-eth0 master {0}-cust1",
]
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
for cmd in cmds:
output = tgen.net[rname].cmd(cmd.format(rname))
"sysctl -w net.ipv4.tcp_l3mdev_accept={}".format(l3mdev_accept)
)
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
# Starting Hosts and init ExaBGP on each of them
logger.info("starting exaBGP on peer1")
peer_list = tgen.exabgp_peers()
- for pname, peer in peer_list.iteritems():
+ for pname, peer in peer_list.items():
peer_dir = os.path.join(CWD, pname)
env_file = os.path.join(CWD, "exabgp.env")
logger.info("Running ExaBGP peer")
# This is a sample of configuration loading.
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
# tgen.mininet_cli()
# This is a sample of configuration loading.
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
# For all registred routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA,
# Uncomment next line to load configuration from ./router/zebra.conf
router_list = tgen.routers()
# For all registered routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA,
os.path.join(CWD, '{}/zebra.conf'.format(rname))
]
# For all registered routers, load the zebra configuration file
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
# create VRF rx-cust1 and link rx-eth0 to rx-cust1
for cmd in cmds:
output = tgen.net[rname].cmd(cmd.format(rname))
"sysctl -w net.ipv4.tcp_l3mdev_accept={}".format(l3mdev_accept)
)
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
router.load_config(
TopoRouter.RD_ZEBRA,
os.path.join(CWD, "{}/zebra.conf".format(rname))
logger.info("waiting for ISIS protocol to converge")
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_topology.json".format(CWD, rname)
expected = json.loads(open(filename).read())
def compare_isis_topology(router, expected):
logger.info("Checking routers for installed ISIS vrf routes")
# Check for routes in 'show ip route vrf {}-cust1 json'
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_route.json".format(CWD, rname)
expected = json.loads(open(filename, "r").read())
actual = router.vtysh_cmd("show ip route vrf {0}-cust1 json".format(rname) , isjson=True)
# Older FRR versions don't list interfaces in some ISIS routes
if router.has_version("<", "3.1"):
- for network, routes in expected.iteritems():
+ for network, routes in expected.items():
for route in routes:
if route["protocol"] != "isis":
continue
logger.info("Checking routers for installed ISIS vrf routes in OS")
# Check for routes in `ip route show vrf {}-cust1`
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_route_linux.json".format(CWD, rname)
expected = json.loads(open(filename, "r").read())
actual = topotest.ip4_vrf_route(router)
# Older FRR versions install routes using different proto
if router.has_version("<", "3.1"):
- for network, netoptions in expected.iteritems():
+ for network, netoptions in expected.items():
if "proto" in netoptions and netoptions["proto"] == "187":
netoptions["proto"] = "zebra"
logger.info("Checking routers for installed ISIS vrf IPv6 routes")
# Check for routes in 'show ipv6 route vrf {}-cust1 json'
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_route6.json".format(CWD, rname)
expected = json.loads(open(filename, "r").read())
actual = router.vtysh_cmd("show ipv6 route vrf {}-cust1 json".format(rname) , isjson=True)
# Older FRR versions don't list interfaces in some ISIS routes
if router.has_version("<", "3.1"):
- for network, routes in expected.iteritems():
+ for network, routes in expected.items():
for route in routes:
if route["protocol"] != "isis":
continue
logger.info("Checking routers for installed ISIS vrf IPv6 routes in OS")
# Check for routes in `ip -6 route show vrf {}-cust1`
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_route6_linux.json".format(CWD, rname)
expected = json.loads(open(filename, "r").read())
actual = topotest.ip6_vrf_route(router)
# Older FRR versions install routes using different proto
if router.has_version("<", "3.1"):
- for network, netoptions in expected.iteritems():
+ for network, netoptions in expected.items():
if "proto" in netoptions and netoptions["proto"] == "187":
netoptions["proto"] = "zebra"
Source:
https://gist.github.com/angstwad/bf22d1822c38a92ec0a9
"""
- for k, v in merge_dct.iteritems():
+ for k, v in merge_dct.items():
if (
k in dct
and isinstance(dct[k], dict)
tgen.start_topology()
# For all registered routers, load the zebra configuration file
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
logger.info("waiting for ISIS protocol to converge")
# Code to generate the json files.
- # for rname, router in tgen.routers().iteritems():
+ # for rname, router in tgen.routers().items():
# open('/tmp/{}_topology.json'.format(rname), 'w').write(
# json.dumps(show_isis_topology(router), indent=2, sort_keys=True)
# )
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_topology.json".format(CWD, rname)
expected = json.loads(open(filename).read())
logger.info("Checking routers for installed ISIS routes")
# Check for routes in 'show ip route json'
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_route.json".format(CWD, rname)
expected = json.loads(open(filename, "r").read())
actual = router.vtysh_cmd("show ip route json", isjson=True)
# Older FRR versions don't list interfaces in some ISIS routes
if router.has_version("<", "3.1"):
- for network, routes in expected.iteritems():
+ for network, routes in expected.items():
for route in routes:
if route["protocol"] != "isis":
continue
logger.info("Checking routers for installed ISIS routes in OS")
# Check for routes in `ip route`
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_route_linux.json".format(CWD, rname)
expected = json.loads(open(filename, "r").read())
actual = topotest.ip4_route(router)
# Older FRR versions install routes using different proto
if router.has_version("<", "3.1"):
- for network, netoptions in expected.iteritems():
+ for network, netoptions in expected.items():
if "proto" in netoptions and netoptions["proto"] == "187":
netoptions["proto"] = "zebra"
logger.info("Checking routers for installed ISIS IPv6 routes")
# Check for routes in 'show ip route json'
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_route6.json".format(CWD, rname)
expected = json.loads(open(filename, "r").read())
actual = router.vtysh_cmd("show ipv6 route json", isjson=True)
# Older FRR versions don't list interfaces in some ISIS routes
if router.has_version("<", "3.1"):
- for network, routes in expected.iteritems():
+ for network, routes in expected.items():
for route in routes:
# Older versions display different metrics for IPv6 routes
route.pop("metric", None)
logger.info("Checking routers for installed ISIS IPv6 routes in OS")
# Check for routes in `ip route`
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
filename = "{0}/{1}/{1}_route6_linux.json".format(CWD, rname)
expected = json.loads(open(filename, "r").read())
actual = topotest.ip6_route(router)
# Older FRR versions install routes using different proto
if router.has_version("<", "3.1"):
- for network, netoptions in expected.iteritems():
+ for network, netoptions in expected.items():
if "proto" in netoptions and netoptions["proto"] == "187":
netoptions["proto"] = "zebra"
Source:
https://gist.github.com/angstwad/bf22d1822c38a92ec0a9
"""
- for k, v in merge_dct.iteritems():
+ for k, v in merge_dct.items():
if (
k in dct
and isinstance(dct[k], dict)
router_list = tgen.routers()
# For all registered routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
# For all registered routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
# For all registered routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
# For all registered routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
# For all registered routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
bgp_data = input_dict["address_family"]
- for addr_type, addr_dict in bgp_data.iteritems():
+ for addr_type, addr_dict in bgp_data.items():
if not addr_dict:
continue
)
config_data.extend(neigh_data)
- for addr_type, addr_dict in bgp_data.iteritems():
+ for addr_type, addr_dict in bgp_data.items():
if not addr_dict or not check_address_types(addr_type):
continue
bgp_data = input_dict["address_family"]
- for family_type, family_dict in bgp_data.iteritems():
+ for family_type, family_dict in bgp_data.items():
if family_type != "l2vpn":
continue
bgp_data = input_dict["address_family"]
neigh_data = bgp_data[addr_type]["unicast"]["neighbor"]
- for name, peer_dict in neigh_data.iteritems():
- for dest_link, peer in peer_dict["dest_link"].iteritems():
+ for name, peer_dict in neigh_data.items():
+ for dest_link, peer in peer_dict["dest_link"].items():
nh_details = topo[name]
if "vrfs" in topo[router] or type(nh_details["bgp"]) is list:
bgp_data = input_dict["address_family"]
neigh_data = bgp_data[addr_type]["unicast"]["neighbor"]
- for peer_name, peer_dict in deepcopy(neigh_data).iteritems():
- for dest_link, peer in peer_dict["dest_link"].iteritems():
+ for peer_name, peer_dict in deepcopy(neigh_data).items():
+ for dest_link, peer in peer_dict["dest_link"].items():
deactivate = None
activate = None
nh_details = topo[peer_name]
deactivate_addr_family = peer.setdefault("deactivate", None)
# Loopback interface
if "source_link" in peer and peer["source_link"] == "lo":
- for destRouterLink, data in sorted(nh_details["links"].iteritems()):
+ for destRouterLink, data in sorted(nh_details["links"].items()):
if "type" in data and data["type"] == "loopback":
if dest_link == destRouterLink:
ip_addr = nh_details["links"][destRouterLink][
# Copy bgp config file to /etc/frr
for dut in input_dict.keys():
router_list = tgen.routers()
- for router, rnode in router_list.iteritems():
+ for router, rnode in router_list.items():
if router != dut:
continue
"""
logger.debug("Entering lib API: verify_bgp_convergence()")
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
if "bgp" not in topo["routers"][router]:
continue
bgp_neighbors = bgp_addr_type[addr_type]["unicast"]["neighbor"]
- for bgp_neighbor, peer_data in bgp_neighbors.iteritems():
+ for bgp_neighbor, peer_data in bgp_neighbors.items():
remote_as = input_dict[bgp_neighbor]["bgp"]["local_as"]
- for dest_link, peer_dict in peer_data["dest_link"].iteritems():
+ for dest_link, peer_dict in peer_data["dest_link"].items():
neighbor_ip = None
data = topo["routers"][bgp_neighbor]["links"]
logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
if dut is not None and dut != router:
continue
for addr_type in bgp_addr_type:
bgp_neighbors = bgp_addr_type[addr_type]["unicast"]["neighbor"]
- for bgp_neighbor, peer_data in bgp_neighbors.iteritems():
- for dest_link, peer_dict in peer_data["dest_link"].iteritems():
+ for bgp_neighbor, peer_data in bgp_neighbors.items():
+ for dest_link, peer_dict in peer_data["dest_link"].items():
data = topo["routers"][bgp_neighbor]["links"]
if dest_link in data:
for addr_type in bgp_addr_type:
bgp_neighbors = bgp_addr_type[addr_type]["unicast"]["neighbor"]
- for bgp_neighbor, peer_data in bgp_neighbors.iteritems():
- for dest_link, peer_dict in peer_data["dest_link"].iteritems():
+ for bgp_neighbor, peer_data in bgp_neighbors.items():
+ for dest_link, peer_dict in peer_data["dest_link"].items():
data = topo["routers"][bgp_neighbor]["links"]
if dest_link in data:
continue
bgp_neighbors = bgp_addr_type[addr_type]["unicast"]["neighbor"]
- for bgp_neighbor, peer_data in bgp_neighbors.iteritems():
- for dest_link, peer_dict in peer_data["dest_link"].iteritems():
+ for bgp_neighbor, peer_data in bgp_neighbors.items():
+ for dest_link, peer_dict in peer_data["dest_link"].items():
data = topo["routers"][bgp_neighbor]["links"]
keepalivetimer = peer_dict["keepalivetimer"]
"""
logger.debug("Entering lib API: verify_bgp_attributes()")
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
if router != dut:
continue
# - rule is IGP>EGP>INCOMPLETE
_next_hop = [
key
- for (key, value) in attribute_dict.iteritems()
+ for (key, value) in attribute_dict.items()
if value == "IGP"
][0]
compare = ""
list1 = []
list2 = []
for routerInput in input_dict.keys():
- for router, rnode in router_list.iteritems():
+ for router, rnode in router_list.items():
if router != dut:
continue
logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
if router != dut:
continue
logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
if router != dut:
continue
"""
logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
if router != dut:
continue
logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
if router != dut:
continue
logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
if router != dut:
continue
logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
if router != dut:
continue
"""
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
daemon_list = [
"zebra",
"ospfd",
try:
router_list = tgen.routers()
- for router, rnode in router_list.iteritems():
+ for router, rnode in router_list.items():
result = rnode.check_router_running()
if result != "":
"""
router_list = tgen.routers()
- for rname, rnode in router_list.iteritems():
+ for rname, rnode in router_list.items():
if rname != router:
continue
test_name = sys._getframe(2).f_code.co_name
TMPDIR = os.path.join(LOGDIR, tgen.modname)
- for rname, rnode in router_list.iteritems():
+ for rname, rnode in router_list.items():
logger.info("Generating support bundle for {}".format(rname))
rnode.run("mkdir -p /var/log/frr")
bundle_log = rnode.run("python2 /usr/lib/frr/generate_support_bundle.py")
input_dict = deepcopy(input_dict)
try:
- for c_router, c_data in input_dict.iteritems():
+ for c_router, c_data in input_dict.items():
rnode = tgen.routers()[c_router]
if "vrfs" in c_data:
for vrf in c_data["vrfs"]:
if "links" in c_data:
for destRouterLink, data in sorted(
- c_data["links"].iteritems()
+ c_data["links"].items()
):
# Loopback interfaces
if "type" in data and data["type"] == "loopback":
lo_list = []
interfaces_list = []
lo_exists = False
- for destRouterLink, data in sorted(link_data.iteritems()):
+ for destRouterLink, data in sorted(link_data.items()):
if loopback:
if "type" in data and data["type"] == "loopback":
lo_exists = True
topo = deepcopy(topo)
try:
- for c_router, c_data in topo.iteritems():
+ for c_router, c_data in topo.items():
interface_data = []
- for destRouterLink, data in sorted(c_data["links"].iteritems()):
+ for destRouterLink, data in sorted(c_data["links"].items()):
# Loopback interfaces
if "type" in data and data["type"] == "loopback":
interface_name = destRouterLink
config_data = []
prefix_lists = input_dict[router]["prefix_lists"]
- for addr_type, prefix_data in prefix_lists.iteritems():
+ for addr_type, prefix_data in prefix_lists.items():
if not check_address_types(addr_type):
continue
- for prefix_name, prefix_list in prefix_data.iteritems():
+ for prefix_name, prefix_list in prefix_data.items():
for prefix_dict in prefix_list:
if "action" not in prefix_dict or "network" not in prefix_dict:
errormsg = "'action' or network' missing in" " input_dict"
logger.debug("route_maps not present in input_dict")
continue
rmap_data = []
- for rmap_name, rmap_value in input_dict[router]["route_maps"].iteritems():
+ for rmap_name, rmap_value in input_dict[router]["route_maps"].items():
for rmap_dict in rmap_value:
del_action = rmap_dict.setdefault("delete", False)
additional_nexthops_in_required_nhs = []
found_hops = []
for routerInput in input_dict.keys():
- for router, rnode in router_list.iteritems():
+ for router, rnode in router_list.items():
if router != dut:
continue
router_list = tgen.routers()
for routerInput in input_dict.keys():
- for router, rnode in router_list.iteritems():
+ for router, rnode in router_list.items():
if router != dut:
continue
router_list = tgen.routers()
for routerInput in input_dict.keys():
- for router, rnode in router_list.iteritems():
+ for router, rnode in router_list.items():
if router != dut:
continue
router_list = tgen.routers()
# For all registred routers, load the zebra configuration file
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
logger.info("Setting up %s" % rname)
for rd_val in TopoRouter.RD:
config = os.path.join(self.testdir, '{}/{}.conf'.format(rname,TopoRouter.RD[rd_val]))
```py
tgen = get_topogen()
router_dict = tgen.get_gears(TopoRouter)
- for router_name, router in router_dict.iteritems():
+ for router_name, router in router_dict.items():
# Do stuff
```
* List iteration:
"""
return dict(
(name, gear)
- for name, gear in self.gears.iteritems()
+ for name, gear in self.gears.items()
if isinstance(gear, geartype)
)
"""
if router is None:
# pylint: disable=r1704
- for _, router in self.routers().iteritems():
+ for _, router in self.routers().items():
router.start()
else:
if isinstance(router, str):
def __str__(self):
links = ""
- for myif, dest in self.links.iteritems():
+ for myif, dest in self.links.items():
_, destif = dest
if links != "":
links += ","
# Enable all daemon command logging, logging files
# and set them to the start dir.
- for daemon, enabled in nrouter.daemons.iteritems():
+ for daemon, enabled in nrouter.daemons.items():
if enabled == 0:
continue
self.vtysh_cmd(
# Enable all daemon command logging, logging files
# and set them to the start dir.
- for daemon, enabled in nrouter.daemons.iteritems():
+ for daemon, enabled in nrouter.daemons.items():
for d in daemons:
if enabled == 0:
continue
return int(re_search("\d+", x).group(0))
for destRouterLink, data in sorted(
- topo["routers"][curRouter]["links"].iteritems(),
+ topo["routers"][curRouter]["links"].items(),
key=lambda x: link_sort(x[0]),
):
currRouter_lo_json = topo["routers"][curRouter]["links"][destRouterLink]
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
router_list = tgen.routers()
# check for zebra capability
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
if router.check_capability(TopoRouter.RD_ZEBRA, "--vrfwnetns") == False:
return pytest.skip(
"Skipping OSPF VRF NETNS feature. VRF NETNS backend not available on FRR"
"ip netns exec {0}-cust1 ifconfig {0}-eth1 up",
]
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
# create VRF rx-cust1 and link rx-eth0 to rx-cust1
for cmd in cmds:
]
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
for cmd in cmds:
tgen.net[rname].cmd(cmd.format(rname))
tgen.stop_topology()
if tgen.routers_have_failure():
pytest.skip("skipped because of router(s) failure")
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
logger.info('Waiting for router "%s" convergence', rname)
# Load expected results from the command
if tgen.routers_have_failure():
pytest.skip("skipped because of router(s) failure")
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
logger.info(
'Comparing router "%s" "show ip ospf vrf %s-cust1 json" output',
router.name,
)
# Expect convergence on all routers
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
logger.info('Waiting for router "%s" convergence after link failure', rname)
# Load expected results from the command
reffile = os.path.join(CWD, "{}/ospfroute_down.txt".format(rname))
ospf6_config = "ospf6d.conf-pre-v4"
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
if tgen.routers_have_failure():
pytest.skip("skipped because of router(s) failure")
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
logger.info('Waiting for router "%s" convergence', router)
# Load expected results from the command
router3.peer_link_enable("r3-eth0", False)
# Expect convergence on all routers
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
logger.info('Waiting for router "%s" convergence after link failure', router)
# Load expected results from the command
reffile = os.path.join(CWD, "{}/ospfroute_down.txt".format(router))
tgen.start_topology()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA,
os.path.join(CWD, '{}/zebra.conf'.format(rname))
if tgen.routers_have_failure():
pytest.skip('skipped because of router(s) failure')
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
logger.info('Waiting for router "%s" convergence', router)
json_file = '{}/{}/ospf-route.json'.format(CWD, router)
# tgen.mininet_cli()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
sys.stdout.flush()
# Look for any node not yet converged
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
resStr = rnode.vtysh_cmd("show ipv6 ospf neigh")
isConverged = False
# tgen.mininet_cli()
# Verify OSPFv3 Routing Table
- for router, rnode in tgen.routers().iteritems():
+ for router, rnode in tgen.routers().items():
logger.info('Waiting for router "%s" convergence', router)
# Load expected results from the command
pytest.skip(tgen.errors)
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
# Install vrf into the kernel and slave eth3
router.run("ip link add vrf-chiyoda type vrf table 1000")
router.run("ip link set dev {}-eth3 master vrf-chiyoda".format(rname))
tgen.start_topology()
# For all registered routers, load the zebra configuration file
- for rname, router in tgen.routers().iteritems():
+ for rname, router in tgen.routers().items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
tgen.start_topology()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
tgen.start_topology()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
tgen.start_topology()
router_list = tgen.routers()
- for rname, router in router_list.iteritems():
+ for rname, router in router_list.items():
router.load_config(
TopoRouter.RD_ZEBRA, os.path.join(CWD, "{}/zebra.conf".format(rname))
)
projects / mirror_frr.git / commitdiff