def test_telemetry_ouput(duthost, ptfhost, localhost):
"""Run pyclient from ptfdocker and show gnmi server outputself.
"""
docker_present = verify_telemetry_dockerimage(duthost)
if not docker_present:
pytest.skip("docker-sonic-telemetry is not part of the image")
logger.info('start telemetry output testing')
setup_telemetry_forpyclient(duthost)
# wait till telemetry is restarted
pytest_assert(
wait_until(100, 10, duthost.is_service_fully_started, "telemetry"),
"TELEMETRY not started")
logger.info('telemetry process restarted. Now run pyclient on ptfdocker')
# Wait until the TCP port is open
dut_ip = duthost.mgmt_ip
wait_tcp_connection(localhost, dut_ip, TELEMETRY_PORT, timeout_s=60)
# pyclient should be available on ptfhost. If not fail pytest.
file_exists = ptfhost.stat(path="/gnxi/gnmi_cli_py/py_gnmicli.py")
pytest_assert(file_exists["stat"]["exists"] is True)
cmd = 'python /gnxi/gnmi_cli_py/py_gnmicli.py -g -t {0} -p {1} -m get -x COUNTERS/Ethernet0 -xt COUNTERS_DB \
-o "ndastreamingservertest"'.format(dut_ip, TELEMETRY_PORT)
show_gnmi_out = ptfhost.shell(cmd)['stdout']
logger.info("GNMI Server output")
logger.info(show_gnmi_out)
result = str(show_gnmi_out)
inerrors_match = re.search("SAI_PORT_STAT_IF_IN_ERRORS", result)
pytest_assert(inerrors_match is not None,
"SAI_PORT_STAT_IF_IN_ERRORS not found in gnmi_output")
def setup_streaming_telemetry(duthosts, rand_one_dut_hostname, localhost, ptfhost):
"""
@summary: Post setting up the streaming telemetry before running the test.
"""
duthost = duthosts[rand_one_dut_hostname]
setup_telemetry_forpyclient(duthost)
# Wait until telemetry was restarted
pytest_assert(wait_until(100, 10, duthost.is_service_fully_started, "telemetry"), "TELEMETRY not started.")
logger.info("telemetry process restarted. Now run pyclient on ptfdocker")
# Wait until the TCP port was opened
dut_ip = duthost.mgmt_ip
wait_tcp_connection(localhost, dut_ip, TELEMETRY_PORT, timeout_s=60)
# pyclient should be available on ptfhost. If it was not available, then fail pytest.
file_exists = ptfhost.stat(path="/gnxi/gnmi_cli_py/py_gnmicli.py")
pytest_assert(file_exists["stat"]["exists"] is True)
def bgpmon_setup_teardown(ptfhost, duthost, localhost, setup_interfaces):
connection = setup_interfaces[0]
dut_lo_addr = connection["loopback_ip"].split("/")[0]
peer_addr = connection['neighbor_addr'].split("/")[0]
mg_facts = duthost.minigraph_facts(host=duthost.hostname)['ansible_facts']
asn = mg_facts['minigraph_bgp_asn']
# TODO: Add a common method to load BGPMON config for test_bgpmon and test_traffic_shift
logger.info("Configuring bgp monitor session on DUT")
bgpmon_args = {
'db_table_name': 'BGP_MONITORS',
'peer_addr': peer_addr,
'asn': asn,
'local_addr': dut_lo_addr,
'peer_name': BGP_MONITOR_NAME
}
bgpmon_template = Template(open(BGPMON_TEMPLATE_FILE).read())
duthost.copy(content=bgpmon_template.render(**bgpmon_args),
dest=BGPMON_CONFIG_FILE)
# Start bgpmon on DUT
logger.info("Starting bgpmon on DUT")
duthost.command("sonic-cfggen -j {} -w".format(BGPMON_CONFIG_FILE))
logger.info("Starting bgp monitor session on PTF")
ptfhost.file(path=DUMP_FILE, state="absent")
ptfhost.copy(src=CUSTOM_DUMP_SCRIPT, dest=CUSTOM_DUMP_SCRIPT_DEST)
ptfhost.exabgp(name=BGP_MONITOR_NAME,
state="started",
local_ip=peer_addr,
router_id=peer_addr,
peer_ip=dut_lo_addr,
local_asn=asn,
peer_asn=asn,
port=BGP_MONITOR_PORT,
dump_script=CUSTOM_DUMP_SCRIPT_DEST)
# Add the route to DUT loopback IP and the interface router mac
ptfhost.shell("ip neigh add %s lladdr %s dev %s" %
(dut_lo_addr, duthost.facts["router_mac"],
connection["neighbor_intf"]))
ptfhost.shell("ip route add %s dev %s" %
(dut_lo_addr + "/32", connection["neighbor_intf"]))
pt_assert(
wait_tcp_connection(localhost, ptfhost.mgmt_ip, BGP_MONITOR_PORT),
"Failed to start bgp monitor session on PTF")
yield
# Cleanup bgp monitor
duthost.shell("redis-cli -n 4 -c DEL 'BGP_MONITORS|{}'".format(peer_addr))
ptfhost.exabgp(name=BGP_MONITOR_NAME, state="absent")
ptfhost.file(path=CUSTOM_DUMP_SCRIPT_DEST, state="absent")
ptfhost.file(path=DUMP_FILE, state="absent")
# Remove the route to DUT loopback IP and the interface router mac
ptfhost.shell("ip route del %s dev %s" %
(dut_lo_addr + "/32", connection["neighbor_intf"]))
ptfhost.shell("ip neigh del %s lladdr %s dev %s" %
(dut_lo_addr, duthost.facts["router_mac"],
connection["neighbor_intf"]))
def start_session(self):
"""Start the BGP session."""
logging.debug("start bgp session %s", self.name)
self.ptfhost.shell("ifconfig %s %s/32" % (self.iface, self.ip))
self.ptfhost.exabgp(
name=self.name,
state="started",
local_ip=self.ip,
router_id=self.ip,
peer_ip=self.peer_ip,
local_asn=self.asn,
peer_asn=self.peer_asn,
port=self.port
)
if not wait_tcp_connection(self.ptfhost, self.ptfip, self.port):
raise RuntimeError("Failed to start BGP neighbor %s" % self.name)
_write_variable_from_j2_to_configdb(
self.duthost,
"bgp/templates/neighbor_metadata_template.j2",
save_dest_path=NEIGHBOR_SAVE_DEST_TMPL % self.name,
neighbor_name=self.name,
neighbor_lo_addr=self.ip,
neighbor_mgmt_addr=self.ip,
neighbor_hwsku=None,
neighbor_type="ToRRouter"
)
_write_variable_from_j2_to_configdb(
self.duthost,
"bgp/templates/bgp_template.j2",
save_dest_path=BGP_SAVE_DEST_TMPL % self.name,
db_table_name="BGP_NEIGHBOR",
peer_addr=self.ip,
asn=self.asn,
local_addr=self.peer_ip,
peer_name=self.name
)
if self.is_quagga:
allow_ebgp_multihop_cmd = (
"vtysh "
"-c 'configure terminal' "
"-c 'router bgp %s' "
"-c 'neighbor %s ebgp-multihop'"
)
allow_ebgp_multihop_cmd %= (self.peer_asn, self.ip)
self.duthost.shell(allow_ebgp_multihop_cmd)
# populate DUT arp table
self.duthost.shell("ping -c 3 %s" % (self.ip))
def common_setup_teardown(ptfhost, duthost, localhost):
mg_facts = duthost.minigraph_facts(host=duthost.hostname)['ansible_facts']
dut_lo_addr = mg_facts['minigraph_lo_interfaces'][0]['addr']
dut_mgmt_ip = mg_facts['minigraph_mgmt_interface']['addr']
asn = mg_facts['minigraph_bgp_asn']
peer_addr = ptfhost.mgmt_ip
# TODO: Add a common method to load BGPMON config for test_bgpmon and test_traffic_shift
logger.info("Configuring bgp monitor session on DUT")
bgpmon_args = {
'db_table_name': 'BGP_MONITORS',
'peer_addr': peer_addr,
'asn': asn,
'local_addr': dut_lo_addr,
'peer_name': BGP_MONITOR_NAME
}
bgpmon_template = Template(open(BGPMON_TEMPLATE_FILE).read())
duthost.copy(content=bgpmon_template.render(**bgpmon_args),
dest=BGPMON_CONFIG_FILE)
# Add a static route via mgmt interface on ptf
ptfhost.shell('ip route add {}/32 via {} dev mgmt'.format(
dut_lo_addr, dut_mgmt_ip))
logger.info("Starting bgp monitor session on PTF")
ptfhost.file(path=DUMP_FILE, state="absent")
ptfhost.copy(src=CUSTOM_DUMP_SCRIPT, dest=CUSTOM_DUMP_SCRIPT_DEST)
ptfhost.exabgp(name=BGP_MONITOR_NAME,
state="started",
local_ip=peer_addr,
router_id=peer_addr,
peer_ip=dut_lo_addr,
local_asn=asn,
peer_asn=asn,
port=BGP_MONITOR_PORT,
dump_script=CUSTOM_DUMP_SCRIPT_DEST)
pytest_assert(
wait_tcp_connection(localhost, ptfhost.mgmt_ip, BGP_MONITOR_PORT),
"Failed to start bgp monitor session on PTF")
yield
# Cleanup bgp monitor
duthost.shell("redis-cli -n 4 -c DEL 'BGP_MONITORS|{}'".format(peer_addr))
ptfhost.exabgp(name=BGP_MONITOR_NAME, state="absent")
ptfhost.file(path=CUSTOM_DUMP_SCRIPT_DEST, state="absent")
ptfhost.file(path=DUMP_FILE, state="absent")
ptfhost.shell('ip route flush {}/32'.format(dut_lo_addr))
def common_setup_teardown(duthost, ptfhost, localhost):
logging.info("########### Setup for bgp speaker testing ###########")
ptfip = ptfhost.host.options['inventory_manager'].get_host(
ptfhost.hostname).vars['ansible_host']
logging.info("ptfip=%s" % ptfip)
mg_facts = duthost.minigraph_facts(host=duthost.hostname)['ansible_facts']
interface_facts = duthost.interface_facts()['ansible_facts']
constants_stat = duthost.stat(path="/etc/sonic/constants.yml")
if constants_stat["stat"]["exists"]:
res = duthost.shell(
"sonic-cfggen -m -d -y /etc/sonic/constants.yml -v \"constants.deployment_id_asn_map[DEVICE_METADATA['localhost']['deployment_id']]\""
)
else:
res = duthost.shell(
"sonic-cfggen -m -d -y /etc/sonic/deployment_id_asn_map.yml -v \"deployment_id_asn_map[DEVICE_METADATA['localhost']['deployment_id']]\""
)
bgp_speaker_asn = res['stdout']
vlan_ips = generate_ips(
3, "%s/%s" % (mg_facts['minigraph_vlan_interfaces'][0]['addr'],
mg_facts['minigraph_vlan_interfaces'][0]['prefixlen']),
[IPAddress(mg_facts['minigraph_vlan_interfaces'][0]['addr'])])
logging.info("Generated vlan_ips: %s" % str(vlan_ips))
speaker_ips = generate_ips(
2, mg_facts['minigraph_bgp_peers_with_range'][0]['ip_range'][0], [])
speaker_ips.append(vlan_ips[0])
logging.info("speaker_ips: %s" % str(speaker_ips))
port_num = [7000, 8000, 9000]
lo_addr = mg_facts['minigraph_lo_interfaces'][0]['addr']
lo_addr_prefixlen = int(
mg_facts['minigraph_lo_interfaces'][0]['prefixlen'])
vlan_addr = mg_facts['minigraph_vlan_interfaces'][0]['addr']
vlan_ports = []
for i in range(0, 3):
vlan_ports.append(mg_facts['minigraph_port_indices'][
mg_facts['minigraph_vlans'][mg_facts['minigraph_vlan_interfaces']
[0]['attachto']]['members'][i]])
logging.info("vlan_ports: %s" % str(vlan_ports))
# Generate ipv6 nexthops
vlan_ipv6_entry = mg_facts['minigraph_vlan_interfaces'][1]
vlan_ipv6_prefix = "%s/%s" % (vlan_ipv6_entry["addr"],
vlan_ipv6_entry["prefixlen"])
vlan_ipv6_address = vlan_ipv6_entry["addr"]
vlan_if_name = vlan_ipv6_entry['attachto']
nexthops_ipv6 = generate_ips(3, vlan_ipv6_prefix,
[IPAddress(vlan_ipv6_address)])
logging.info("Generated nexthops_ipv6: %s" % str(nexthops_ipv6))
# Set ipv6 nexthop addresses on the ptf interfaces
for nh in nexthops_ipv6:
duthost.command("ip -6 route flush %s/64" % nh.ip)
duthost.command("ip -6 route add %s/64 dev %s" % (nh.ip, vlan_if_name))
logging.info("setup ip/routes in ptf")
ptfhost.shell("ifconfig eth%d %s" % (vlan_ports[0], vlan_ips[0]))
ptfhost.shell("ifconfig eth%d:0 %s" % (vlan_ports[0], speaker_ips[0]))
ptfhost.shell("ifconfig eth%d:1 %s" % (vlan_ports[0], speaker_ips[1]))
ptfhost.shell("ifconfig eth%d %s" % (vlan_ports[1], vlan_ips[1]))
ptfhost.shell("ifconfig eth%d %s" % (vlan_ports[2], vlan_ips[2]))
ptfhost.shell("ip route flush %s/%d" % (lo_addr, lo_addr_prefixlen))
ptfhost.shell("ip route add %s/%d via %s" %
(lo_addr, lo_addr_prefixlen, vlan_addr))
logging.info("clear ARP cache on DUT")
duthost.command("sonic-clear arp")
for ip in vlan_ips:
duthost.command("ip route flush %s/32" % ip.ip)
# The ping here is workaround for known issue:
# https://github.com/Azure/SONiC/issues/387 Pre-ARP support for static route config
# When there is no arp entry for next hop, routes learnt from exabgp will not be set down to ASIC
# Also because of issue https://github.com/Azure/sonic-buildimage/issues/5185 ping is done before route addition.
duthost.shell("ping %s -c 3" % ip.ip)
time.sleep(2)
duthost.command(
"ip route add %s/32 dev %s" %
(ip.ip, mg_facts['minigraph_vlan_interfaces'][0]['attachto']))
logging.info("setup ip/routes in ptf")
for i in [0, 1, 2]:
ptfhost.shell("ip -6 addr add %s dev eth%d:%d" %
(nexthops_ipv6[i], vlan_ports[0], i))
logging.info("Start exabgp on ptf")
for i in range(0, 3):
local_ip = str(speaker_ips[i].ip)
ptfhost.exabgp(name="bgps%d" % i,
state="started",
local_ip=local_ip,
router_id=local_ip,
peer_ip=lo_addr,
local_asn=bgp_speaker_asn,
peer_asn=mg_facts['minigraph_bgp_asn'],
port=str(port_num[i]))
# check exabgp http_api port is ready
http_ready = True
for i in range(0, 3):
http_ready = wait_tcp_connection(localhost, ptfip, port_num[i])
if not http_ready:
break
logging.info("########### Done setup for bgp speaker testing ###########")
yield ptfip, mg_facts, interface_facts, vlan_ips, nexthops_ipv6, vlan_if_name, speaker_ips, port_num, http_ready
logging.info("########### Teardown for bgp speaker testing ###########")
for i in range(0, 3):
ptfhost.exabgp(name="bgps%d" % i, state="absent")
logging.info("exabgp stopped")
for nh in nexthops_ipv6:
duthost.command("ip -6 route flush %s/64" % nh.ip)
logging.info("Flushed ipv6 nexthop routes from dut")
for ip in vlan_ips:
duthost.command("ip route flush %s/32" % ip.ip,
module_ignore_errors=True)
logging.info(
"########### Done teardown for bgp speaker testing ###########")
def fib_t0(ptfhost, testbed, localhost, topology=None):
logger.info("use fib_t0 to setup routes for topo {}".format(testbed['topo']['name']))
podset_number = 200
tor_number = 16
tor_subnet_number = 2
max_tor_subnet_number = 16
tor_subnet_size = 128
# TODO: spine_asn, leaf_asn_start and tor_asn_start should come from the topology file
spine_asn = 65534
if topology == 't0-116':
leaf_asn_start = 4200064600
tor_asn_start = 4200065500
else:
leaf_asn_start = 64600
tor_asn_start = 65500
topo = testbed['topo']['properties']
ptf_hostname = testbed['ptf']
ptfip = ptfhost.host.options['inventory_manager'].get_host(ptf_hostname).vars['ansible_host']
local_ip = ipaddress.IPAddress("10.10.246.254")
local_ipv6 = ipaddress.IPAddress("fc0a::ff")
for k, v in testbed['topo']['properties']['configuration'].items():
vm_offset = testbed['topo']['properties']['topology']['VMs'][k]['vm_offset']
peer_ip = ipaddress.IPNetwork(v['bp_interface']['ipv4'])
peer_ipv6 = ipaddress.IPNetwork(v['bp_interface']['ipv6'])
asn = int(v['bgp']['asn'])
port = 5000 + vm_offset
port6 = 6000 + vm_offset
ptfhost.exabgp(name=k,
state="started", \
router_id = str(local_ip), \
local_ip = str(local_ip), \
peer_ip = str(peer_ip.ip), \
local_asn = asn, \
peer_asn = asn, \
port = port)
ptfhost.exabgp(name="%s-v6" % k,
state="started", \
router_id = str(local_ip), \
local_ip = str(local_ipv6), \
peer_ip = str(peer_ipv6.ip), \
local_asn = asn, \
peer_asn = asn, \
port = port6)
# check if bgp http_api is ready
for k, v in testbed['topo']['properties']['configuration'].items():
vm_offset = testbed['topo']['properties']['topology']['VMs'][k]['vm_offset']
port = 5000 + vm_offset
assert wait_tcp_connection(localhost, ptfip, port)
port6 = 6000 + vm_offset
assert wait_tcp_connection(localhost, ptfip, port6)
for k, v in testbed['topo']['properties']['configuration'].items():
vm_offset = testbed['topo']['properties']['topology']['VMs'][k]['vm_offset']
port = 5000 + vm_offset
port6 = 6000 + vm_offset
routes_v4 = generate_routes("v4", podset_number, tor_number, tor_subnet_number,
spine_asn, leaf_asn_start, tor_asn_start,
local_ip, local_ipv6)
routes_v6 = generate_routes("v6", podset_number, tor_number, tor_subnet_number,
spine_asn, leaf_asn_start, tor_asn_start,
local_ip, local_ipv6)
announce_routes(ptfip, port, routes_v4)
announce_routes(ptfip, port6, routes_v6)
def fib_t1_lag(ptfhost, testbed, localhost):
logger.info("use fib_t1_lag to setup routes for topo {}".format(testbed['topo']['name']))
podset_number = 200
tor_number = 16
tor_subnet_number = 2
max_tor_subnet_number = 16
tor_subnet_size = 128
leaf_asn_start = 64600
tor_asn_start = 65500
topo = testbed['topo']['properties']
ptf_hostname = testbed['ptf']
ptfip = ptfhost.host.options['inventory_manager'].get_host(ptf_hostname).vars['ansible_host']
local_ip = ipaddress.IPAddress("10.10.246.254")
local_ipv6 = ipaddress.IPAddress("fc0a::ff")
for k, v in testbed['topo']['properties']['configuration'].items():
vm_offset = testbed['topo']['properties']['topology']['VMs'][k]['vm_offset']
peer_ip = ipaddress.IPNetwork(v['bp_interface']['ipv4'])
peer_ipv6 = ipaddress.IPNetwork(v['bp_interface']['ipv6'])
asn = int(v['bgp']['asn'])
port = 5000 + vm_offset
port6 = 6000 + vm_offset
ptfhost.exabgp(name=k,
state="started", \
router_id = str(local_ip), \
local_ip = str(local_ip), \
peer_ip = str(peer_ip.ip), \
local_asn = asn, \
peer_asn = asn, \
port = port)
ptfhost.exabgp(name="%s-v6" % k,
state="started", \
router_id = str(local_ip), \
local_ip = str(local_ipv6), \
peer_ip = str(peer_ipv6.ip), \
local_asn = asn, \
peer_asn = asn, \
port = port6)
# Check if bgp http_api port is ready
for k, v in testbed['topo']['properties']['configuration'].items():
vm_offset = testbed['topo']['properties']['topology']['VMs'][k]['vm_offset']
port = 5000 + vm_offset
assert wait_tcp_connection(localhost, ptfip, port)
port6 = 6000 + vm_offset
assert wait_tcp_connection(localhost, ptfip, port6)
for k, v in testbed['topo']['properties']['configuration'].items():
vm_offset = testbed['topo']['properties']['topology']['VMs'][k]['vm_offset']
port = 5000 + vm_offset
port6 = 6000 + vm_offset
router_type = None
if 'spine' in v['properties']:
router_type = 'spine'
elif 'tor' in v['properties']:
router_type = 'tor'
if router_type:
routes_v4 = generate_routes("v4", podset_number, tor_number, tor_subnet_number,
None, leaf_asn_start, tor_asn_start,
local_ip, local_ipv6, router_type=router_type)
routes_v6 = generate_routes("v6", podset_number, tor_number, tor_subnet_number,
None, leaf_asn_start, tor_asn_start,
local_ip, local_ipv6, router_type=router_type)
announce_routes(ptfip, port, routes_v4)
announce_routes(ptfip, port6, routes_v6)
if 'vips' in v:
routes_vips = []
for prefix in v["vips"]["ipv4"]["prefixes"]:
routes_vips.append((prefix, local_ip, v["vips"]["ipv4"]["asn"]))
announce_routes(ptfip, port, routes_vips)
def test_bgpmon(duthost, localhost, common_setup_teardown, ptfadapter,
ptfhost):
"""
Add a bgp monitor on ptf and verify that DUT is attempting to establish connection to it
"""
def bgpmon_peer_connected(duthost, bgpmon_peer):
try:
bgp_summary = json.loads(
duthost.shell('vtysh -c "show bgp summary json"')['stdout'])
return bgp_summary['ipv4Unicast']['peers'][bgpmon_peer][
"state"] == "Established"
except Exception as e:
logger.info('Unable to get bgp status')
return False
local_addr, peer_addr, peer_ports, asn = common_setup_teardown
exp_packet = build_syn_pkt(local_addr, peer_addr)
# Flush dataplane
ptfadapter.dataplane.flush()
# Load bgp monitor config
logger.info(
"Configured bgpmon and verifying packet on {}".format(peer_ports))
duthost.command("sonic-cfggen -j {} -w".format(BGPMON_CONFIG_FILE))
# Verify syn packet on ptf
(rcvd_port_index,
rcvd_pkt) = testutils.verify_packet_any_port(test=ptfadapter,
pkt=exp_packet,
ports=peer_ports,
timeout=BGP_CONNECT_TIMEOUT)
#To establish the connection we set the PTF port that receive syn packet following properties
# ip as BGMPMON IP , mac as the neighbor mac(mac for default nexthop that was used for sending syn packet) ,
# add the neighbor entry and the default route for dut loopback
ptf_interface = "eth" + str(peer_ports[rcvd_port_index])
res = ptfhost.shell('cat /sys/class/net/{}/address'.format(ptf_interface))
original_mac = res['stdout']
ptfhost.shell("ifconfig %s hw ether %s" %
(ptf_interface, Ether(rcvd_pkt).dst))
ptfhost.shell("ip add add %s dev %s" % (peer_addr + "/24", ptf_interface))
ptfhost.exabgp(name=BGP_MONITOR_NAME,
state="started",
local_ip=peer_addr,
router_id=peer_addr,
peer_ip=local_addr,
local_asn=asn,
peer_asn=asn,
port=BGP_MONITOR_PORT,
passive=True)
ptfhost.shell("ip neigh add %s lladdr %s dev %s" %
(local_addr, duthost.facts["router_mac"], ptf_interface))
ptfhost.shell("ip route add %s dev %s" %
(local_addr + "/32", ptf_interface))
try:
pytest_assert(
wait_tcp_connection(localhost, ptfhost.mgmt_ip, BGP_MONITOR_PORT),
"Failed to start bgp monitor session on PTF")
pytest_assert(
wait_until(30, 5, bgpmon_peer_connected, duthost, peer_addr),
"BGPMon Peer connection not established")
finally:
ptfhost.exabgp(name=BGP_MONITOR_NAME, state="absent")
ptfhost.shell("ip route del %s dev %s" %
(local_addr + "/32", ptf_interface))
ptfhost.shell("ip neigh del %s lladdr %s dev %s" %
(local_addr, duthost.facts["router_mac"], ptf_interface))
ptfhost.shell("ip add del %s dev %s" %
(peer_addr + "/24", ptf_interface))
ptfhost.shell("ifconfig %s hw ether %s" %
(ptf_interface, original_mac))
def fib_t0(ptfhost, tbinfo, localhost, topology=None):
logger.info("use fib_t0 to setup routes for topo {}".format(tbinfo['topo']['name']))
common_config_topo = tbinfo['topo']['properties']['configuration_properties']['common']
podset_number = common_config_topo.get("podset_number", 200)
tor_number = common_config_topo.get("tor_number", 16)
tor_subnet_number = common_config_topo.get("tor_subnet_number", 2)
max_tor_subnet_number = common_config_topo.get("max_tor_subnet_number", 16)
tor_subnet_size = common_config_topo.get("tor_subnet_size", 128)
nhipv4 = common_config_topo.get("nhipv4", "10.10.246.254")
nhipv6 = common_config_topo.get("nhipv6", "fc0a::ff")
spine_asn = common_config_topo.get("spine_asn", 65534)
leaf_asn_start = common_config_topo.get("leaf_asn_start", 64600)
tor_asn_start = common_config_topo.get("tor_asn_start", 65500)
ptf_hostname = tbinfo['ptf']
ptfip = ptfhost.host.options['inventory_manager'].get_host(ptf_hostname).vars['ansible_host']
local_ip = ipaddress.IPAddress(nhipv4)
local_ipv6 = ipaddress.IPAddress(nhipv6)
for k, v in tbinfo['topo']['properties']['configuration'].items():
vm_offset = tbinfo['topo']['properties']['topology']['VMs'][k]['vm_offset']
peer_ip = ipaddress.IPNetwork(v['bp_interface']['ipv4'])
peer_ipv6 = ipaddress.IPNetwork(v['bp_interface']['ipv6'])
asn = int(v['bgp']['asn'])
port = 5000 + vm_offset
port6 = 6000 + vm_offset
ptfhost.exabgp(name=k,
state="started", \
router_id = str(local_ip), \
local_ip = str(local_ip), \
peer_ip = str(peer_ip.ip), \
local_asn = asn, \
peer_asn = asn, \
port = port)
ptfhost.exabgp(name="%s-v6" % k,
state="started", \
router_id = str(local_ip), \
local_ip = str(local_ipv6), \
peer_ip = str(peer_ipv6.ip), \
local_asn = asn, \
peer_asn = asn, \
port = port6)
# check if bgp http_api is ready
for k, v in tbinfo['topo']['properties']['configuration'].items():
vm_offset = tbinfo['topo']['properties']['topology']['VMs'][k]['vm_offset']
port = 5000 + vm_offset
assert wait_tcp_connection(localhost, ptfip, port)
port6 = 6000 + vm_offset
assert wait_tcp_connection(localhost, ptfip, port6)
for k, v in tbinfo['topo']['properties']['configuration'].items():
vm_offset = tbinfo['topo']['properties']['topology']['VMs'][k]['vm_offset']
port = 5000 + vm_offset
port6 = 6000 + vm_offset
routes_v4 = generate_routes("v4", podset_number, tor_number, tor_subnet_number,
spine_asn, leaf_asn_start, tor_asn_start,
local_ip, local_ipv6, tor_subnet_size, max_tor_subnet_number)
routes_v6 = generate_routes("v6", podset_number, tor_number, tor_subnet_number,
spine_asn, leaf_asn_start, tor_asn_start,
local_ip, local_ipv6, tor_subnet_size, max_tor_subnet_number)
announce_routes(ptfip, port, routes_v4)
announce_routes(ptfip, port6, routes_v6)
def common_setup_teardown(duthost, ptfhost, localhost):
logging.info("########### Setup for bgp speaker testing ###########")
ptfip = ptfhost.host.options['inventory_manager'].get_host(
ptfhost.hostname).vars['ansible_host']
logging.info("ptfip=%s" % ptfip)
ptfhost.script("./scripts/remove_ip.sh")
mg_facts = duthost.minigraph_facts(host=duthost.hostname)['ansible_facts']
interface_facts = duthost.interface_facts()['ansible_facts']
res = duthost.shell(
"sonic-cfggen -m -d -y /etc/sonic/constants.yml -v \"constants.deployment_id_asn_map[DEVICE_METADATA['localhost']['deployment_id']]\""
)
bgp_speaker_asn = res['stdout']
vlan_ips = generate_ips(
3, "%s/%s" % (mg_facts['minigraph_vlan_interfaces'][0]['addr'],
mg_facts['minigraph_vlan_interfaces'][0]['prefixlen']),
[IPAddress(mg_facts['minigraph_vlan_interfaces'][0]['addr'])])
logging.info("Generated vlan_ips: %s" % str(vlan_ips))
speaker_ips = generate_ips(
2, mg_facts['minigraph_bgp_peers_with_range'][0]['ip_range'][0], [])
speaker_ips.append(vlan_ips[0])
logging.info("speaker_ips: %s" % str(speaker_ips))
for ip in vlan_ips:
duthost.command("ip route flush %s/32" % ip.ip)
duthost.command(
"ip route add %s/32 dev %s" %
(ip.ip, mg_facts['minigraph_vlan_interfaces'][0]['attachto']))
port_num = [7000, 8000, 9000]
lo_addr = mg_facts['minigraph_lo_interfaces'][0]['addr']
lo_addr_prefixlen = int(
mg_facts['minigraph_lo_interfaces'][0]['prefixlen'])
vlan_addr = mg_facts['minigraph_vlan_interfaces'][0]['addr']
vlan_ports = []
for i in range(0, 3):
vlan_ports.append(mg_facts['minigraph_port_indices'][
mg_facts['minigraph_vlans'][mg_facts['minigraph_vlan_interfaces']
[0]['attachto']]['members'][i]])
logging.info("vlan_ports: %s" % str(vlan_ports))
logging.info("setup ip/routes in ptf")
ptfhost.shell("ifconfig eth%d %s" % (vlan_ports[0], vlan_ips[0]))
ptfhost.shell("ifconfig eth%d:0 %s" % (vlan_ports[0], speaker_ips[0]))
ptfhost.shell("ifconfig eth%d:1 %s" % (vlan_ports[0], speaker_ips[1]))
ptfhost.shell("ifconfig eth%d %s" % (vlan_ports[1], vlan_ips[1]))
ptfhost.shell("ifconfig eth%d %s" % (vlan_ports[2], vlan_ips[2]))
ptfhost.shell("ip route flush %s/%d" % (lo_addr, lo_addr_prefixlen))
ptfhost.shell("ip route add %s/%d via %s" %
(lo_addr, lo_addr_prefixlen, vlan_addr))
logging.info("Start exabgp on ptf")
for i in range(0, 3):
local_ip = str(speaker_ips[i].ip)
ptfhost.exabgp(name="bgps%d" % i,
state="started",
local_ip=local_ip,
router_id=local_ip,
peer_ip=lo_addr,
local_asn=bgp_speaker_asn,
peer_asn=mg_facts['minigraph_bgp_asn'],
port=str(port_num[i]))
# check exabgp http_api port is ready
http_ready = True
for i in range(0, 3):
http_ready = wait_tcp_connection(localhost, ptfip, port_num[i])
if not http_ready:
break
logging.info("########### Done setup for bgp speaker testing ###########")
yield ptfip, mg_facts, interface_facts, vlan_ips, speaker_ips, port_num, http_ready
logging.info("########### Teardown for bgp speaker testing ###########")
for i in range(0, 3):
ptfhost.exabgp(name="bgps%d" % i, state="absent")
for ip in vlan_ips:
duthost.command("ip route flush %s/32" % ip.ip,
module_ignore_errors=True)
ptfhost.script("./scripts/remove_ip.sh")
logging.info(
"########### Done teardown for bgp speaker testing ###########")