def test_10_bestpath_selection_of_received_route(self):
print "test_bestpath_selection_of_received_route"
if self.check_load_config() is False:
return
go_path = parser_option.go_path
fab.docker_container_make_bestpath_env_executor(
self.append_quagga_best, go_path, is_route_server=False)
print "please wait " + str(self.initial_wait_time) + " second"
time.sleep(self.initial_wait_time)
print "add neighbor setting"
tn = qaccess.login("11.0.0.20")
qaccess.add_neighbor(tn, "65020", "11.0.0.2", "65002")
qaccess.add_neighbor(tn, "65020", "12.0.0.3", "65003")
tn = qaccess.login("11.0.0.2")
tn = qaccess.add_metric(tn, "200", "192.168.20.0")
qaccess.add_neighbor(tn, "65002", "11.0.0.20", "65020")
qaccess.add_neighbor_metric(tn, "65002", "10.0.255.1", "200")
tn = qaccess.login("10.0.0.3")
tn = qaccess.add_metric(tn, "100", "192.168.20.0")
qaccess.add_neighbor(tn, "65003", "12.0.0.20", "65020")
qaccess.add_neighbor_metric(tn, "65003", "10.0.255.1", "100")
print "please wait " + str(self.initial_wait_time) + " second"
time.sleep(self.initial_wait_time)
target_network = "192.168.20.0/24"
ans_nexthop = "10.0.0.3"
print "check whether target network %s 's nexthop is %s" % (
target_network, ans_nexthop)
self.retry_routine_for_bestpath("", target_network, ans_nexthop)
def test_10_bestpath_selection_of_received_route(self):
print "test_bestpath_selection_of_received_route"
if self.check_load_config() is False:
return
go_path = parser_option.go_path
fab.docker_container_make_bestpath_env_executor(self.append_quagga_best, go_path, is_route_server=False)
print "please wait " + str(self.initial_wait_time) + " second"
time.sleep(self.initial_wait_time)
print "add neighbor setting"
tn = qaccess.login("11.0.0.20")
qaccess.add_neighbor(tn, "65020", "11.0.0.2", "65002")
qaccess.add_neighbor(tn, "65020", "12.0.0.3", "65003")
tn = qaccess.login("11.0.0.2")
tn = qaccess.add_metric(tn, "200", "192.168.20.0")
qaccess.add_neighbor(tn, "65002", "11.0.0.20", "65020")
qaccess.add_neighbor_metric(tn, "65002", "10.0.255.1", "200")
tn = qaccess.login("10.0.0.3")
tn = qaccess.add_metric(tn, "100", "192.168.20.0")
qaccess.add_neighbor(tn, "65003", "12.0.0.20", "65020")
qaccess.add_neighbor_metric(tn, "65003", "10.0.255.1", "100")
print "please wait " + str(self.initial_wait_time) + " second"
time.sleep(self.initial_wait_time)
target_network = "192.168.20.0/24"
ans_nexthop = "10.0.0.3"
print "check whether target network %s 's nexthop is %s" % (target_network, ans_nexthop)
self.retry_routine_for_bestpath("", target_network, ans_nexthop)
def get_routing_table(self, neighbor_address, target_prefix, retry=3, interval=-1):
if interval < 0:
interval = self.wait_per_retry
print "check route %s on quagga : %s" % (target_prefix, neighbor_address)
retry_count = 0
# quagga cli doesn't show prefix's netmask
quagga_prefix = target_prefix.split('/')[0]
while True:
tn = qaccess.login(neighbor_address)
q_rib = qaccess.show_rib(tn)
qaccess.logout(tn)
for q_path in q_rib:
if quagga_prefix == q_path['Network']:
return q_path
retry_count += 1
if retry_count > retry:
break
else:
print "target_prefix %s is none" % target_prefix
print "wait (" + str(interval) + " seconds)"
time.sleep(interval)
print "route : %s is none" % target_prefix
return None
def check_func():
tn = qaccess.login(address)
q_rib = qaccess.show_rib(tn, af)
for quagga_config in self.quagga_configs:
if quagga_config.peer_ip == address or quagga_config.ip_version != af:
for c_dest in quagga_config.destinations.itervalues():
exist_n = 0
for c_path in c_dest.paths:
# print "conf : ", c_path.network, c_path.nexthop, "my ip or different ip version!!!"
for q_path in q_rib:
# print "quag : ", q_path['Network'], q_path['Next Hop']
if "0.0.0.0" == q_path['Next Hop'] or "::" == q_path['Next Hop']:
continue
if c_path.network.split("/")[0] == q_path['Network']:
exist_n += 1
if exist_n != 0:
return False
else:
for c_dest in quagga_config.destinations.itervalues():
exist_n = 0
for c_path in c_dest.paths:
# print "conf : ", c_path.network, c_path.nexthop
for q_path in q_rib:
# print "quag : ", q_path['Network'], q_path['Next Hop']
if quagga_config.ip_version != fab.IPv6:
c_path.network = c_path.network.split("/")[0]
if c_path.network == q_path['Network'] and c_path.nexthop == q_path['Next Hop']:
exist_n += 1
if exist_n != 1:
return False
return True
def check_community(self,
neighbor_address,
target_addr,
community,
retry=3,
interval=-1,
af=IPv4):
if interval < 0:
interval = self.wait_per_retry
print "check route %s on quagga : %s" % (target_addr, neighbor_address)
retry_count = 0
while True:
tn = qaccess.login(neighbor_address)
result = qaccess.check_community(tn, target_addr, community, af)
qaccess.logout(tn)
if result:
return True
else:
print "target path %s with community %s is none" % (
target_addr, community)
retry_count += 1
if retry_count > retry:
break
else:
print "wait (" + str(interval) + " seconds)"
time.sleep(interval)
return False
def get_route(self,
neighbor_address,
target_prefix,
retry=3,
interval=-1,
af=IPv4):
if interval < 0:
interval = self.wait_per_retry
print "check route %s on quagga : %s" % (target_prefix,
neighbor_address)
retry_count = 0
while True:
tn = qaccess.login(neighbor_address)
q_rib = qaccess.lookup_prefix(tn, target_prefix, af)
qaccess.logout(tn)
for q_path in q_rib:
if target_prefix == q_path['Network']:
return q_path
retry_count += 1
if retry_count > retry:
break
else:
print "target_prefix %s is none" % target_prefix
print "wait (" + str(interval) + " seconds)"
time.sleep(interval)
print "route : %s is none" % target_prefix
return None
def assert_quagga_rib(self, address):
retry_count = 0
cmp_result = False
while retry_count < self.dest_check_limit:
tn = qaccess.login(address)
q_rib = qaccess.show_rib(tn)
cmp_result = self.compare_route_with_quagga_configs(address, q_rib, route_server=False)
if cmp_result:
print "compare OK"
break
else:
retry_count += 1
print "compare NG -> retry ( %d / %d )" % (retry_count, self.dest_check_limit)
time.sleep(self.wait_per_retry)
self.assertTrue(cmp_result)
def assert_quagga_rib(self, address):
retry_count = 0
cmp_result = False
while retry_count < self.dest_check_limit:
tn = qaccess.login(address)
q_rib = qaccess.show_rib(tn)
cmp_result = self.compare_route_with_quagga_configs(
address, q_rib, route_server=False)
if cmp_result:
print "compare OK"
break
else:
retry_count += 1
print "compare NG -> retry ( %d / %d )" % (
retry_count, self.dest_check_limit)
time.sleep(self.wait_per_retry)
self.assertTrue(cmp_result)
def test_09_advertising_route_when_quagga_removed(self):
print "test_advertising_route_when_removed_quagga"
if self.check_load_config() is False:
return
remove_quagga_address = "10.0.0." + str(self.remove_quagga)
removed_prefix = "10.0.0.%d/24" % self.remove_quagga
for address in self.get_neighbor_address(self.gobgp_config):
if remove_quagga_address == address:
continue
print "check of [ " + address + " ]"
retry_count = 0
cmp_result = False
while retry_count < self.dest_check_limit:
tn = qaccess.login(address)
q_rib = qaccess.show_rib(tn)
still_exists = False
for q_path in q_rib:
if q_path['Network'] == removed_prefix:
still_exists = True
#self.assertEqual(still_exists, False)
cmp_result = self.compare_route_with_quagga_configs(
address, q_rib, route_server=False)
if cmp_result and not still_exists:
print "compare OK"
break
else:
retry_count += 1
print "compare NG -> retry ( %d / %d )" % (
retry_count, self.dest_check_limit)
time.sleep(self.wait_per_retry)
self.assertEqual(still_exists, False)
self.assertEqual(cmp_result, True)
def check_func():
tn = qaccess.login(address)
q_rib = qaccess.show_rib(tn, af)
for quagga_config in self.quagga_configs:
if quagga_config.peer_ip == address or quagga_config.ip_version != af:
for c_dest in quagga_config.destinations.itervalues():
exist_n = 0
for c_path in c_dest.paths:
# print "conf : ", c_path.network, c_path.nexthop, "my ip or different ip version!!!"
for q_path in q_rib:
# print "quag : ", q_path['Network'], q_path['Next Hop']
if "0.0.0.0" == q_path[
'Next Hop'] or "::" == q_path[
'Next Hop']:
continue
if c_path.network.split(
"/")[0] == q_path['Network']:
exist_n += 1
if exist_n != 0:
return False
else:
for c_dest in quagga_config.destinations.itervalues():
exist_n = 0
for c_path in c_dest.paths:
# print "conf : ", c_path.network, c_path.nexthop
for q_path in q_rib:
# print "quag : ", q_path['Network'], q_path['Next Hop']
if quagga_config.ip_version != fab.IPv6:
c_path.network = c_path.network.split(
"/")[0]
if c_path.network == q_path[
'Network'] and c_path.nexthop == q_path[
'Next Hop']:
exist_n += 1
if exist_n != 1:
return False
return True
def test_09_advertising_route_when_quagga_removed(self):
print "test_advertising_route_when_removed_quagga"
if self.check_load_config() is False:
return
remove_quagga_address = "10.0.0." + str(self.remove_quagga)
removed_prefix = "10.0.0.%d/24" % self.remove_quagga
for address in self.get_neighbor_address(self.gobgp_config):
if remove_quagga_address == address:
continue
print "check of [ " + address + " ]"
retry_count = 0
cmp_result = False
while retry_count < self.dest_check_limit:
tn = qaccess.login(address)
q_rib = qaccess.show_rib(tn)
still_exists = False
for q_path in q_rib:
if q_path['Network'] == removed_prefix:
still_exists = True
#self.assertEqual(still_exists, False)
cmp_result = self.compare_route_with_quagga_configs(address, q_rib, route_server=False)
if cmp_result and not still_exists:
print "compare OK"
break
else:
retry_count += 1
print "compare NG -> retry ( %d / %d )" % (retry_count, self.dest_check_limit)
time.sleep(self.wait_per_retry)
self.assertEqual(still_exists, False)
self.assertEqual(cmp_result, True)
def check_med(self, neighbor_address, target_addr, med, retry=3, interval=-1, af=IPv4):
if interval < 0:
interval = self.wait_per_retry
print "check route %s on quagga : %s" % (target_addr, neighbor_address)
retry_count = 0
while True:
tn = qaccess.login(neighbor_address)
result = qaccess.check_med(tn, target_addr, med, af)
qaccess.logout(tn)
if result:
return True
else:
print "target path %s with med %s is none" % (target_addr, med)
retry_count += 1
if retry_count > retry:
break
else:
print "wait (" + str(interval) + " seconds)"
time.sleep(interval)
return False
def get_route(self, neighbor_address, target_prefix, retry=3, interval=-1, af=IPv4):
if interval < 0:
interval = self.wait_per_retry
print "check route %s on quagga : %s" % (target_prefix, neighbor_address)
retry_count = 0
while True:
tn = qaccess.login(neighbor_address)
q_rib = qaccess.lookup_prefix(tn, target_prefix, af)
qaccess.logout(tn)
for q_path in q_rib:
if target_prefix == q_path['Network']:
return q_path
retry_count += 1
if retry_count > retry:
break
else:
print "target_prefix %s is none" % target_prefix
print "wait (" + str(interval) + " seconds)"
time.sleep(interval)
print "route : %s is none" % target_prefix
return None
def test_04_export_policy_update(self):
# initialize test environment
# policy_pattern:p4 attaches a policy to reject route
# 192.168.2.0/24, 192.168.20.0/24, 192.168.200.0/24
# coming from peer2(10.0.0.2) to peer3(10.0.0.3)'s export-policy.
self.initialize(policy_pattern="p4")
# add other network
tn = qaccess.login(peer2)
print "add network 192.168.20.0/24"
qaccess.add_network(tn, 65002, prefix2)
print "add network 192.168.200.0/24"
qaccess.add_network(tn, 65002, prefix3)
qaccess.logout(tn)
addresses = self.get_neighbor_address(self.gobgp_config)
self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED")
time.sleep(self.initial_wait_time)
def path_exists_in_localrib(peer, prefix,r=10):
paths = self.get_paths_in_localrib(peer, prefix, retry=r)
return paths is not None
def path_exists_in_routing_table(peer, prefix,r=10):
qpath = self.get_routing_table(peer, prefix, retry=r)
return qpath is not None
def path_exists_in_adj_rib_in(peer, prefix,r=10):
path = self.get_adj_rib_in(peer, prefix, retry=r)
return path is not None
def path_exists_in_adj_rib_out(peer, prefix,r=10):
path = self.get_adj_rib_out(peer, prefix, retry=r)
return path is not None
self.assertTrue(path_exists_in_localrib(peer1,prefix1))
self.assertTrue(path_exists_in_localrib(peer1,prefix2))
self.assertTrue(path_exists_in_localrib(peer1,prefix3))
# check peer3 local-rib
self.assertTrue(path_exists_in_localrib(peer3,prefix1))
self.assertTrue(path_exists_in_localrib(peer3,prefix2))
self.assertTrue(path_exists_in_localrib(peer3,prefix3))
# check peer3 rib-out
self.assertTrue(path_exists_in_adj_rib_out(peer3,prefix1))
self.assertFalse(path_exists_in_adj_rib_out(peer3,prefix2,r=3))
self.assertFalse(path_exists_in_adj_rib_out(peer3,prefix3,r=3))
# check show ip bgp on peer1(quagga1)
self.assertTrue(path_exists_in_routing_table(peer1, prefix1))
self.assertTrue(path_exists_in_routing_table(peer1, prefix2))
self.assertTrue(path_exists_in_routing_table(peer1, prefix3))
# check show ip bgp on peer3(quagga3)
self.assertTrue(path_exists_in_routing_table(peer3, prefix1))
self.assertFalse(path_exists_in_routing_table(peer3, prefix2,r=3))
self.assertFalse(path_exists_in_routing_table(peer3, prefix3,r=0))
# check adj-rib-out in peer2
peer2 = "10.0.0.2"
self.assertTrue(path_exists_in_adj_rib_in(peer2, prefix1))
self.assertTrue(path_exists_in_adj_rib_in(peer2, prefix2))
self.assertTrue(path_exists_in_adj_rib_in(peer2, prefix3))
# update policy
print "update_policy_config"
fab.update_policy_config(parser_option.go_path, policy_pattern="p4")
time.sleep(self.initial_wait_time)
# soft reset
print "soft_reset"
self.soft_reset(peer2, IPv4)
# check local-rib
self.assertTrue(path_exists_in_localrib(peer3,prefix1))
self.assertTrue(path_exists_in_localrib(peer3,prefix2))
self.assertTrue(path_exists_in_localrib(peer3,prefix3))
# check local-adj-out-rib
self.assertTrue(path_exists_in_adj_rib_out(peer3, prefix1))
self.assertFalse(path_exists_in_adj_rib_out(peer3, prefix2,r=3))
self.assertTrue(path_exists_in_adj_rib_out(peer3, prefix3))
# check show ip bgp on peer3(quagga3)
self.assertTrue(path_exists_in_routing_table(peer3, prefix1))
self.assertFalse(path_exists_in_routing_table(peer3, prefix2,r=3))
self.assertTrue(path_exists_in_routing_table(peer3, prefix3))
def test_04_export_policy_update(self):
# initialize test environment
# policy_pattern:p4 attaches a policy to reject route
# 192.168.2.0/24, 192.168.20.0/24, 192.168.200.0/24
# coming from peer2(10.0.0.2) to peer3(10.0.0.3)'s export-policy.
self.initialize(policy_pattern="p4")
# add other network
tn = qaccess.login(peer2)
print "add network 192.168.20.0/24"
qaccess.add_network(tn, 65002, prefix2)
print "add network 192.168.200.0/24"
qaccess.add_network(tn, 65002, prefix3)
qaccess.logout(tn)
addresses = self.get_neighbor_address(self.gobgp_config)
self.retry_routine_for_state(addresses, "BGP_FSM_ESTABLISHED")
time.sleep(self.initial_wait_time)
def path_exists_in_localrib(peer, prefix, r=10):
paths = self.get_paths_in_localrib(peer, prefix, retry=r)
return paths is not None
def path_exists_in_routing_table(peer, prefix, r=10):
qpath = self.get_routing_table(peer, prefix, retry=r)
return qpath is not None
def path_exists_in_adj_rib_in(peer, prefix, r=10):
path = self.get_adj_rib_in(peer, prefix, retry=r)
return path is not None
def path_exists_in_adj_rib_out(peer, prefix, r=10):
path = self.get_adj_rib_out(peer, prefix, retry=r)
return path is not None
self.assertTrue(path_exists_in_localrib(peer1, prefix1))
self.assertTrue(path_exists_in_localrib(peer1, prefix2))
self.assertTrue(path_exists_in_localrib(peer1, prefix3))
# check peer3 local-rib
self.assertTrue(path_exists_in_localrib(peer3, prefix1))
self.assertTrue(path_exists_in_localrib(peer3, prefix2))
self.assertTrue(path_exists_in_localrib(peer3, prefix3))
# check peer3 rib-out
self.assertTrue(path_exists_in_adj_rib_out(peer3, prefix1))
self.assertFalse(path_exists_in_adj_rib_out(peer3, prefix2, r=3))
self.assertFalse(path_exists_in_adj_rib_out(peer3, prefix3, r=3))
# check show ip bgp on peer1(quagga1)
self.assertTrue(path_exists_in_routing_table(peer1, prefix1))
self.assertTrue(path_exists_in_routing_table(peer1, prefix2))
self.assertTrue(path_exists_in_routing_table(peer1, prefix3))
# check show ip bgp on peer3(quagga3)
self.assertTrue(path_exists_in_routing_table(peer3, prefix1))
self.assertFalse(path_exists_in_routing_table(peer3, prefix2, r=3))
self.assertFalse(path_exists_in_routing_table(peer3, prefix3, r=0))
# check adj-rib-out in peer2
peer2 = "10.0.0.2"
self.assertTrue(path_exists_in_adj_rib_in(peer2, prefix1))
self.assertTrue(path_exists_in_adj_rib_in(peer2, prefix2))
self.assertTrue(path_exists_in_adj_rib_in(peer2, prefix3))
# update policy
print "update_policy_config"
fab.update_policy_config(parser_option.go_path, policy_pattern="p4")
time.sleep(self.initial_wait_time)
# soft reset
print "soft_reset"
self.soft_reset(peer2, IPv4)
# check local-rib
self.assertTrue(path_exists_in_localrib(peer3, prefix1))
self.assertTrue(path_exists_in_localrib(peer3, prefix2))
self.assertTrue(path_exists_in_localrib(peer3, prefix3))
# check local-adj-out-rib
self.assertTrue(path_exists_in_adj_rib_out(peer3, prefix1))
self.assertFalse(path_exists_in_adj_rib_out(peer3, prefix2, r=3))
self.assertTrue(path_exists_in_adj_rib_out(peer3, prefix3))
# check show ip bgp on peer3(quagga3)
self.assertTrue(path_exists_in_routing_table(peer3, prefix1))
self.assertFalse(path_exists_in_routing_table(peer3, prefix2, r=3))
self.assertTrue(path_exists_in_routing_table(peer3, prefix3))
