def test_uncfg_as(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxe')
intf1 = Interface(device=dev1, name='Ethernet0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1, name='Ethernet0/0/2',
ipv4='10.2.0.1/24')
dev2 = Device(testbed=testbed, name='PE2', os='iosxe')
intf3 = Interface(device=dev2, name='Ethernet0/0/3',
ipv4='10.1.0.2/24', ipv6='2001:111:222::/64')
intf4 = Interface(device=dev2, name='Ethernet0/0/4',
ipv4='10.2.0.2/24')
with self.assertNoWarnings():
Genie.testbed = testbed
bgp = Bgp(bgp_id='304.304')
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(bgp_id='304.304')
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
uncfgs = bgp.build_unconfig(apply=False)
self.assertCountEqual(uncfgs.keys(), [dev1.name])
self.assertMultiLineEqual(str(uncfgs[dev1.name]), '\n'.join([
'no router bgp 304.304',
]))
def test_cfg_as(self):
''' Test 4-byte AS support'''
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxe')
intf1 = Interface(device=dev1, name='Ethernet0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1, name='Ethernet0/0/2',
ipv4='10.2.0.1/24',
ipv6='2001::1')
dev2 = Device(testbed=testbed, name='PE2', os='iosxe')
intf3 = Interface(device=dev2, name='Ethernet0/0/3',
ipv4='10.1.0.2/24', ipv6='2001:111:222::/64')
intf4 = Interface(device=dev2, name='Ethernet0/0/4',
ipv4='10.2.0.2/24')
with self.assertNoWarnings():
Genie.testbed = testbed
bgp = Bgp(bgp_id='304.304')
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(bgp_id='304.304')
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.maxDiff = None
self.assertEqual(str(cfgs[dev1.name]), '\n'.join(
['router bgp 304.304',
' exit',
]))
def test_partial_cfg(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxe')
with self.assertNoWarnings():
Genie.testbed = testbed
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
# Defining attributes
bgp.device_attr[dev1]
dev1.add_feature(bgp)
ps_name = 'PEER-SESSION'
bgp.device_attr[dev1].peer_session_attr[ps_name].ps_fall_over_bfd=\
True
partial_cfg1 = bgp.build_config(
apply=False,
attributes={'device_attr':\
{'*':{'peer_session_attr':\
{'*':"ps_fall_over_bfd"}}}})
self.assertCountEqual(partial_cfg1.keys(), [dev1.name])
self.assertMultiLineEqual(str(partial_cfg1[dev1.name]), '\n'.\
join([
'router bgp 100',
' template peer-session PEER-SESSION',
' fall-over bfd',
' exit',
' exit',
]))
def test_uncfg2(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxe')
with self.assertNoWarnings():
Genie.testbed = testbed
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
# Defining attributes
af_name = 'ipv4 unicast'
bgp.device_attr[dev1]
bgp.device_attr[dev1].vrf_attr[None].always_compare_med = True
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name]
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_label_allocation_mode = 'per-vrf'
uncfg = bgp.build_unconfig(apply=False)
self.assertCountEqual(uncfg.keys(), [dev1.name])
self.assertMultiLineEqual(str(uncfg[dev1.name]), '\n'.\
join([
'no router bgp 100',
'no mpls label mode vrf default protocol bgp-vpnv4 per-vrf',
]))
def test_cfg_vxlan_rewrite_mvpn(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='nxos')
bgp = Bgp(bgp_id=100)
# Defining attributes
af_name = 'ipv4 mvpn'
vrf = Vrf('default')
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
neighbor_id = '10.0.0.1'
bgp.device_attr[dev1].vrf_attr[vrf].neighbor_attr[neighbor_id].\
nbr_peer_type = Bgp.NBR_PEER_TYPE.fabric_border_leaf
bgp.device_attr[dev1].vrf_attr[vrf].neighbor_attr[neighbor_id].address_family_attr[af_name]. \
nbr_af_rewrite_mvpn_rt_asn = True
bgp.device_attr[dev1]
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' neighbor 10.0.0.1',
' peer-type fabric-border-leaf',
' address-family ipv4 mvpn',
' rewrite-rt-asn',
' exit',
' exit',
' exit',
]))
uncfgs2 = bgp.build_unconfig(
apply=False,
attributes={'device_attr': {'*': {'vrf_attr':
{'*': {'neighbor_attr': \
{'*': {"nbr_peer_type":None,
'address_family_attr': \
{'*': "nbr_af_rewrite_mvpn_rt_asn"},
}}}}}}})
self.assertCountEqual(uncfgs2.keys(), [dev1.name])
self.maxDiff = None
self.assertMultiLineEqual(
str(uncfgs2[dev1.name]), '\n'.join([
'router bgp 100',
' neighbor 10.0.0.1',
' no peer-type fabric-border-leaf',
' address-family ipv4 mvpn',
' no rewrite-rt-asn',
' exit',
' exit',
' exit',
]))
def test_feature_bgp_config(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='nxos')
bgp = Bgp()
bgp.device_attr[dev1].enabled = True
dev1.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertEqual(str(cfgs[dev1.name]), "feature bgp")
def test_bgp_peer_policy_attr(self):
# For failures
self.maxDiff = None
# shorten the line
dev1 = self.dev1
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
pp = 'PEERPOLICY'
bgp.device_attr[dev1].peer_policy_attr[pp].pp_af_name = 'ipv4 unicast'
bgp.device_attr[dev1].peer_policy_attr[pp].pp_allowas_in = True
bgp.device_attr[dev1].peer_policy_attr[pp].pp_allowas_in_as_number = 5
bgp.device_attr[dev1].peer_policy_attr[pp].pp_as_override = True
bgp.device_attr[dev1].peer_policy_attr[pp].pp_default_originate = True
bgp.device_attr[dev1].peer_policy_attr[
pp].pp_default_originate_route_map = 'pp-map-test'
bgp.device_attr[dev1].peer_policy_attr[
pp].pp_route_map_name_in = 'allin'
bgp.device_attr[dev1].peer_policy_attr[
pp].pp_route_map_name_out = 'allout'
bgp.device_attr[dev1].peer_policy_attr[
pp].pp_maximum_prefix_max_prefix_no = 100
bgp.device_attr[dev1].peer_policy_attr[
pp].pp_maximum_prefix_threshold = 50
bgp.device_attr[dev1].peer_policy_attr[
pp].pp_maximum_prefix_restart = 99
bgp.device_attr[dev1].peer_policy_attr[pp].pp_next_hop_self = True
bgp.device_attr[dev1].peer_policy_attr[
pp].pp_route_reflector_client = True
bgp.device_attr[dev1].peer_policy_attr[
pp].pp_send_community = 'standard'
bgp.device_attr[dev1].peer_policy_attr[
pp].pp_soft_reconfiguration = True
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' af-group PEERPOLICY address-family ipv4 unicast',
' allowas-in 5',
' as-override',
' default-originate route-policy pp-map-test',
' route-policy allin in',
' route-policy allout out',
' maximum-prefix 100 50 restart 99',
' next-hop-self',
' route-reflector-client',
' send-community-ebgp',
' soft-reconfiguration inbound',
' exit',
' exit',
]))
def test_cfg_l2vpn_vpls(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='nxos')
bgp = Bgp(bgp_id=100)
# Defining attributes
nbr_af_name = 'l2vpn vpls'
neighbor_id = '10.2.0.2'
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name].nbr_af_suppress_signaling_protocol_ldp = True
bgp.device_attr[dev1]
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' neighbor 10.2.0.2',
' address-family l2vpn vpls',
' suppress-signling-protocol ldp',
' exit',
' exit',
' exit',
]))
uncfgs = bgp.build_unconfig(
apply=False,
attributes={'device_attr': {'*': {'vrf_attr':
{'*': {'neighbor_attr': \
{'*': {'address_family_attr': \
{'*': "nbr_af_suppress_signaling_protocol_ldp"}}}}}}}})
self.assertCountEqual(uncfgs.keys(), [dev1.name])
self.maxDiff = None
self.assertMultiLineEqual(
str(uncfgs[dev1.name]), '\n'.join([
'router bgp 100',
' neighbor 10.2.0.2',
' address-family l2vpn vpls',
' no suppress-signling-protocol ldp',
' exit',
' exit',
' exit',
]))
def test_bgp_peer_session_attr(self):
# For failures
self.maxDiff = None
# shorten the line
dev1 = self.dev1
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
ps = 'PEERSESSION'
bgp.device_attr[dev1].peer_session_attr[
ps].ps_transport_connection_mode = 'passive'
bgp.device_attr[dev1].peer_session_attr[
ps].ps_suppress_four_byte_as_capability = True
bgp.device_attr[dev1].peer_session_attr[
ps].ps_description = 'some description'
bgp.device_attr[dev1].peer_session_attr[
ps].ps_disable_connected_check = True
bgp.device_attr[dev1].peer_session_attr[ps].ps_shutdown = True
bgp.device_attr[dev1].peer_session_attr[
ps].ps_update_source = 'GigabitEthernet0/0/0/2'
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' session-group PEERSESSION',
' capability suppress 4-byte-as',
' description some description',
' ignore-connected-check',
' shutdown',
' session-open-mode passive',
' update-source GigabitEthernet0/0/0/2',
' exit',
' exit',
]))
def test_uncfg3(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxe')
dev2 = Device(testbed=testbed, name='PE2', os='iosxe')
intf4 = Interface(device=dev2, name='Ethernet0/0/4',
ipv4='10.2.0.2/24')
with self.assertNoWarnings():
Genie.testbed = testbed
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
# Defining attributes
bgp.device_attr[dev1]
neighbor_id = intf4.ipv4
bgp.device_attr[dev1].vrf_attr[None].add_neighbor(neighbor_id)
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id]
partial_uncfg = bgp.build_unconfig(
apply=False,
attributes={'device_attr':\
{'*':{'vrf_attr':\
{'*':{'neighbor_attr':'*'}}}}})
self.assertCountEqual(partial_uncfg.keys(), [dev1.name])
self.assertMultiLineEqual(str(partial_uncfg[dev1.name]), '\n'.\
join([
'router bgp 100',
' no neighbor 10.2.0.2',
' exit',
]))
def test_cfg(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='nxos')
intf1 = Interface(device=dev1, name='Ethernet0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1, name='Ethernet0/0/2',
ipv4='10.2.0.1/24')
dev2 = Device(testbed=testbed, name='PE2', os='nxos')
intf3 = Interface(device=dev2, name='Ethernet0/0/3',
ipv4='10.1.0.2/24', ipv6='2001:111:222::/64')
intf4 = Interface(device=dev2, name='Ethernet0/0/4',
ipv4='10.2.0.2/24')
with self.assertNoWarnings():
Genie.testbed = None
with self.assertRaises(TypeError):
bgp = Bgp()
with self.assertRaises(TypeError):
bgp = Bgp(testbed=testbed)
Genie.testbed = testbed
with self.assertRaises(TypeError):
bgp = Bgp()
bgp = Bgp(asn=100, bgp_id=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(asn=100, bgp_id=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
# Defining attributes
af_name = 'vpnv4 unicast'
af_name2 = 'link-state'
bgp.device_attr[dev1]
bgp.device_attr[dev1].enabled = True
bgp.device_attr[dev1].vrf_attr[None].always_compare_med = True
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name]
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name2]
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name]. \
af_retain_rt_all = True
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name]. \
af_dampening = True
neighbor_id = intf4.ipv4
bgp.device_attr[dev1].vrf_attr[None].add_neighbor(neighbor_id)
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id]
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id]. \
nbr_fall_over_bfd = True
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id]. \
nbr_shutdown = True
nbr_af_name = 'ipv4 unicast'
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id]. \
address_family_attr[nbr_af_name]
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id]. \
address_family_attr[nbr_af_name].nbr_af_allowas_in = True
dev1.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.join(
['feature bgp',
'router bgp 100',
' bestpath always-compare-med',
' neighbor 10.2.0.2',
' bfd',
' shutdown',
' address-family ipv4 unicast',
' allowas-in',
' exit',
' exit',
' address-family link-state',
' exit',
' address-family vpnv4 unicast',
' dampening',
' retain route-target all',
' exit',
' exit',
]))
bgp.device_attr[dev1].protocol_shutdown = True
partial_cfg1 = bgp.build_config(
apply=False,
attributes={'device_attr': \
{'*': "enabled", '*': "protocol_shutdown"}})
self.assertCountEqual(partial_cfg1.keys(), [dev1.name])
self.assertMultiLineEqual(str(partial_cfg1[dev1.name]), '\n'. \
join([
'router bgp 100',
' shutdown',
' exit',
]))
def test_cfg2(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='nxos')
intf1 = Interface(device=dev1, name='Ethernet0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1, name='Ethernet0/0/2',
ipv4='10.2.0.1/24')
dev2 = Device(testbed=testbed, name='PE2', os='nxos')
intf3 = Interface(device=dev2, name='Ethernet0/0/3',
ipv4='10.1.0.2/24', ipv6='2001:111:222::/64')
intf4 = Interface(device=dev2, name='Ethernet0/0/4',
ipv4='10.2.0.2/24')
with self.assertNoWarnings():
Genie.testbed = None
with self.assertRaises(TypeError):
bgp = Bgp()
with self.assertRaises(TypeError):
bgp = Bgp(testbed=testbed)
Genie.testbed = testbed
with self.assertRaises(TypeError):
bgp = Bgp()
bgp = Bgp(asn=100,bgp_id=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(asn=100,bgp_id=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
# Defining attributes
vrf_id = 'vrf1'
vrf1 = Vrf(vrf_id)
pp_name = 'PEER-POLICY'
ps_name = 'PEER-SESSION'
bgp.device_attr[dev2].enabled = True
bgp.device_attr[dev2].peer_policy_attr[pp_name].pp_allowas_in =\
True
bgp.device_attr[dev2].peer_session_attr[ps_name].ps_fall_over_bfd=\
True
bgp.device_attr[dev2].vrf_attr[None].cluster_id = '150'
af_name = 'ipv6 unicast'
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name]
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_nexthop_route_map = 'test'
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening = True
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening_half_life_time = 1
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening_reuse_time = 10
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening_suppress_time = 30
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening_max_suppress_time = 2
neighbor_id = intf2.ipv4
bgp.device_attr[dev2].vrf_attr[vrf1].add_neighbor(neighbor_id)
bgp.device_attr[dev2].vrf_attr[vrf1].neighbor_attr[neighbor_id].\
nbr_suppress_four_byte_as_capability = True
nbr_af_name = 'vpnv6 unicast'
bgp.device_attr[dev2].vrf_attr[vrf1].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name]
bgp.device_attr[dev2].vrf_attr[vrf1].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name].\
nbr_af_maximum_prefix_max_prefix_no = 300000
bgp.device_attr[dev2].vrf_attr[vrf1].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name].nbr_af_default_originate = True
dev2.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev2.name])
self.maxDiff = None
self.assertEqual(str(cfgs[dev2.name]), '\n'.join(
['feature bgp',
'router bgp 100',
' cluster-id 150',
' address-family ipv6 unicast',
' dampening 1 10 30 2',
' nexthop route-map test',
' exit',
' vrf vrf1',
' neighbor 10.2.0.1',
' capability suppress 4-byte-as',
' address-family vpnv6 unicast',
' maximum-prefix 300000',
' default-originate',
' exit',
' exit',
' exit',
' template peer-session PEER-SESSION',
' bfd',
' exit',
' template peer-policy PEER-POLICY',
' allowas-in',
' exit',
' exit',
]))
partial_uncfg1 = bgp.build_unconfig(apply=False, attributes={\
'device_attr':\
{dev2.name:\
{'vrf_attr':\
{'vrf1':\
{'neighbor_attr':\
{'10.2.0.1':\
{'address_family_attr':\
{'vpnv6 unicast':\
{'nbr_af_default_originate': None}}}}}}}}})
self.assertCountEqual(partial_uncfg1.keys(), [dev2.name])
self.assertMultiLineEqual(str(partial_uncfg1[dev2.name]), '\n'.\
join([
'router bgp 100',
' vrf vrf1',
' neighbor 10.2.0.1',
' address-family vpnv6 unicast',
' no default-originate',
' exit',
' exit',
' exit',
' exit',
]))
def test_bgp_vrf_family_attr(self):
# For failures
self.maxDiff = None
# shorten the line
dev1 = self.dev1
# ===== none-default vrf =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
af = 'ipv4 unicast'
af6 = 'ipv6 unicast'
bgp.device_attr[dev1].add_vrf(self.vrf1)
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af]
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_dampening = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_dampening_route_map = 'route-test'
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_dampening_half_life_time = 30
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_client_to_client_reflection = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_distance_extern_as = 100
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_distance_internal_as = 110
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_distance_local = 120
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_maximum_paths_ebgp = 15
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_maximum_paths_ibgp = 20
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_maximum_paths_eibgp = 30
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_aggregate_address_ipv4_address = '2.2.2.2'
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_aggregate_address_ipv4_mask = 24
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_aggregate_address_summary_only = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_network_number = '3.3.3.3'
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_network_mask = 24
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_network_route_map = 'network-map-test'
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_redist_isis = '1'
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_redist_ospf = '1'
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_redist_ospf_metric = 10
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_redist_rip = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af].\
af_redist_rip_route_policy = 'rip-route-test'
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af6].\
af_v6_network_number = '3:3::/48'
bgp.device_attr[dev1].vrf_attr[self.vrf1].address_family_attr[af6].\
af_v6_aggregate_address_ipv6_address = '2:2::/64'
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' vrf vrf1',
' address-family ipv4 unicast',
' bgp dampening 30',
' distance bgp 100 110 120',
' maximum-paths ebgp 15',
' maximum-paths ibgp 20',
' maximum-paths eibgp 30',
' aggregate-address 2.2.2.2/24 summary-only',
' network 3.3.3.3/24 route-policy network-map-test',
' redistribute ospf 1 metric 10',
' redistribute rip route-policy rip-route-test',
' exit',
' address-family ipv6 unicast',
' aggregate-address 2:2::/64',
' network 3:3::/48',
' exit',
' exit',
' exit',
]))
# ===== default vrf =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
af = 'vpnv4 unicast'
bgp.device_attr[dev1].add_vrf(self.vrf2)
bgp.device_attr[dev1].vrf_attr[self.vrf2].always_compare_med = True
bgp.device_attr[dev1].vrf_attr[self.vrf2].address_family_attr[af].\
af_retain_rt_all = True
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' bgp bestpath med always',
' address-family vpnv4 unicast',
' retain route-target all',
' exit',
' exit',
]))
def test_bgp_vrf_attr(self):
# For failures
self.maxDiff = None
# shorten the line
dev1 = self.dev1
# ===== none-default vrf =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
bgp.device_attr[dev1].add_vrf(self.vrf1)
bgp.device_attr[dev1].vrf_attr[self.vrf1].rd = '100:1'
bgp.device_attr[dev1].vrf_attr[self.vrf1].always_compare_med = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].graceful_restart = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].\
graceful_restart_restart_time = 100
bgp.device_attr[dev1].vrf_attr[self.vrf1].\
graceful_restart_stalepath_time = 150
bgp.device_attr[dev1].vrf_attr[self.vrf1].log_neighbor_changes = False
bgp.device_attr[dev1].vrf_attr[self.vrf1].router_id = '1.1.1.1'
bgp.device_attr[dev1].vrf_attr[self.vrf1].keepalive_interval = 10
bgp.device_attr[dev1].vrf_attr[self.vrf1].holdtime = 100
bgp.device_attr[dev1].vrf_attr[self.vrf1].enforce_first_as = False
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' vrf vrf1',
' bgp bestpath med always',
' rd 100:1',
' bgp log neighbor changes disable',
' bgp router-id 1.1.1.1',
' timers bgp 10 100',
' bgp enforce-first-as disable',
' exit',
' exit',
]))
# ===== default vrf =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
bgp.device_attr[dev1].add_vrf(self.vrf2)
bgp.device_attr[dev1].vrf_attr[self.vrf2].always_compare_med = True
bgp.device_attr[dev1].vrf_attr[self.vrf2].cluster_id = 10
bgp.device_attr[dev1].vrf_attr[self.vrf2].confederation_identifier = 20
bgp.device_attr[dev1].vrf_attr[self.vrf2].confederation_peers_as = '66'
bgp.device_attr[dev1].vrf_attr[self.vrf2].graceful_restart = True
bgp.device_attr[dev1].vrf_attr[self.vrf2].\
graceful_restart_restart_time = 100
bgp.device_attr[dev1].vrf_attr[self.vrf2].\
graceful_restart_stalepath_time = 150
bgp.device_attr[dev1].vrf_attr[self.vrf2].log_neighbor_changes = True
bgp.device_attr[dev1].vrf_attr[self.vrf2].router_id = '1.1.1.1'
bgp.device_attr[dev1].vrf_attr[self.vrf2].keepalive_interval = 10
bgp.device_attr[dev1].vrf_attr[self.vrf2].holdtime = 100
bgp.device_attr[dev1].vrf_attr[
self.vrf2].fast_external_fallover = False
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' bgp bestpath med always',
' bgp cluster-id 10',
' bgp confederation identifier 20',
' bgp confederation peers 66',
' bgp graceful-restart',
' bgp graceful-restart restart-time 100',
' bgp graceful-restart stalepath-time 150',
' bgp router-id 1.1.1.1',
' timers bgp 10 100',
' bgp fast-external-fallover disable',
' exit',
]))
def test_cfg3(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxe')
intf1 = Interface(device=dev1,
name='Ethernet0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1,
name='Ethernet0/0/2',
ipv4='10.2.0.1/24',
ipv6='2001::1')
dev2 = Device(testbed=testbed, name='PE2', os='iosxe')
intf3 = Interface(device=dev2,
name='Ethernet0/0/3',
ipv4='10.1.0.2/24',
ipv6='2001:111:222::/64')
intf4 = Interface(device=dev2,
name='Ethernet0/0/4',
ipv4='10.2.0.2/24')
with self.assertNoWarnings():
Genie.testbed = None
with self.assertRaises(TypeError):
bgp = Bgp()
with self.assertRaises(TypeError):
bgp = Bgp(testbed=testbed)
Genie.testbed = testbed
with self.assertRaises(TypeError):
bgp = Bgp()
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
# Defining attributes
vrf_id = 'vrf1'
vrf1 = Vrf(vrf_id)
pp_name = 'PEER-POLICY'
ps_name = 'PEER-SESSION'
bgp.device_attr[dev2].peer_policy_attr[pp_name].pp_as_override =\
True
bgp.device_attr[dev2].peer_session_attr[ps_name].ps_remote_as=\
12
bgp.device_attr[dev2].vrf_attr[None].cluster_id = '150'
af_name = 'ipv6 unicast'
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name]
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_client_to_client_reflection = True
nbr_af_name = 'ipv6 unicast'
neighbor_id2 = intf2.ipv6
bgp.device_attr[dev2].vrf_attr[vrf1].neighbor_attr[neighbor_id2].\
address_family_attr[nbr_af_name]
bgp.device_attr[dev2].vrf_attr[vrf1].neighbor_attr[neighbor_id2].\
address_family_attr[nbr_af_name].\
nbr_af_maximum_prefix_max_prefix_no = 300000
dev2.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev2.name])
self.maxDiff = None
self.assertEqual(
str(cfgs[dev2.name]), '\n'.join([
'router bgp 100',
' bgp cluster-id 150',
' address-family ipv6 unicast',
' bgp client-to-client reflection',
' exit',
' address-family ipv6 unicast vrf vrf1',
' neighbor 2001::1 activate',
' neighbor 2001::1 maximum-prefix 300000',
' exit',
' template peer-session PEER-SESSION',
' remote-as 12',
' exit',
' template peer-policy PEER-POLICY',
' as-override',
' exit',
' exit',
]))
def test_bgp_vrf_neighbor_attr(self):
# For failures
self.maxDiff = None
# shorten the line
dev1 = self.dev1
# ===== none-default vrf =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
nei = '10.1.1.1'
nei6 = '10:1::1:1'
bgp.device_attr[dev1].add_vrf(self.vrf1)
bgp.device_attr[dev1].vrf_attr[self.vrf1].add_neighbor(nei)
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_fall_over_bfd = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_ebgp_multihop = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_ebgp_multihop_max_hop = 30
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_inherit_peer_session = 'PEERSESSION'
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_local_as_as_no = 200
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_remote_as = 500
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_remove_private_as = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_remove_private_as_af_name = 'ipv4 unicast'
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_shutdown = True
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_keepalive_interval = 15
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_holdtime = 300
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_update_source = 'GigabitEthernet0/0/0/1'
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_password_text = 'somePassword'
bgp.device_attr[dev1].vrf_attr[self.vrf1].neighbor_attr[nei].\
nbr_transport_connection_mode = 'active'
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' vrf vrf1',
' neighbor 10.1.1.1',
' bfd fast-detect',
' remote-as 500',
' update-source GigabitEthernet0/0/0/1',
' ebgp-multihop 30',
' use session-group PEERSESSION',
' local-as 200',
' address-family ipv4 unicast remove-private-AS',
' shutdown',
' timers 15 300',
' password somePassword',
' session-open-mode active',
' exit',
' exit',
' exit',
]))
def test_init(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxe')
intf1 = Interface(device=dev1,
name='GigabitEthernet0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1,
name='GigabitEthernet0/0/2',
ipv4='10.2.0.1/24')
dev2 = Device(testbed=testbed, name='PE2', os='iosxe')
intf3 = Interface(device=dev2,
name='GigabitEthernet0/0/3',
ipv4='10.1.0.2/24')
intf4 = Interface(device=dev2,
name='GigabitEthernet0/0/4',
ipv4='10.2.0.2/24')
vrf1 = Vrf(name='vrf1')
vrf2 = Vrf(name='a')
with self.assertNoWarnings():
Genie.testbed = None
with self.assertRaises(TypeError):
bgp = Bgp()
with self.assertRaises(TypeError):
bgp = Bgp(testbed=testbed)
Genie.testbed = testbed
with self.assertRaises(TypeError):
bgp = Bgp()
bgp = Bgp(asn=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(asn=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' exit',
' exit',
]))
dev2.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name, dev2.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' exit',
' exit',
]))
self.assertMultiLineEqual(
str(cfgs[dev2.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' exit',
' exit',
]))
bgp.device_attr[dev1].add_neighbor(intf3.ipv4)
bgp.device_attr[dev1].add_vrf(vrf1)
bgp.device_attr[dev1].vrf_attr[vrf1].add_neighbor(intf4.ipv4)
bgp.device_attr[dev1].vrf_attr[vrf1].neighbor_attr[intf4.ipv4].\
address_family_attr['ipv4 unicast'].activate = True
bgp.device_attr[dev1].add_vrf(vrf2)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name, dev2.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' neighbor 10.1.0.2 remote-as 100',
' address-family ipv4 unicast',
' exit',
' address-family ipv4 unicast vrf a',
' exit',
' neighbor 10.2.0.2 remote-as 100',
' address-family ipv4 unicast vrf vrf1',
' neighbor 10.2.0.2 activate',
' exit',
' address-family ipv4 unicast vrf vrf1',
' exit',
' exit',
]))
self.assertMultiLineEqual(
str(cfgs[dev2.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' exit',
' exit',
]))
cfgs = bgp.build_config(
apply=False, attributes='device_attr__PE1__vrf_attr__default')
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' neighbor 10.1.0.2 remote-as 100',
' address-family ipv4 unicast',
' exit',
' exit',
]))
cfgs = bgp.build_config(apply=False,
attributes={
'device_attr': {
'*': (),
},
})
self.assertCountEqual(cfgs.keys(), [dev1.name, dev2.name])
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' exit',
]))
self.assertMultiLineEqual(str(cfgs[dev2.name]), '\n'.join([
'router bgp 100',
' exit',
]))
cfgs = bgp.build_config(apply=False,
attributes={
'device_attr': {
'PE1': 'vrf_attr__default',
},
})
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' neighbor 10.1.0.2 remote-as 100',
' address-family ipv4 unicast',
' exit',
' exit',
]))
cfgs = bgp.build_config(
apply=False,
attributes={
'device_attr': {
'PE1': 'vrf_attr__default__neighbor_attr__10.1.0.2',
},
})
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' neighbor 10.1.0.2 remote-as 100',
' exit',
]))
def test_cfg2(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxe')
intf1 = Interface(device=dev1,
name='Ethernet0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1,
name='Ethernet0/0/2',
ipv4='10.2.0.1/24',
ipv6='2001::1')
dev2 = Device(testbed=testbed, name='PE2', os='iosxe')
intf3 = Interface(device=dev2,
name='Ethernet0/0/3',
ipv4='10.1.0.2/24',
ipv6='2001:111:222::/64')
intf4 = Interface(device=dev2,
name='Ethernet0/0/4',
ipv4='10.2.0.2/24')
with self.assertNoWarnings():
Genie.testbed = None
with self.assertRaises(TypeError):
bgp = Bgp()
with self.assertRaises(TypeError):
bgp = Bgp(testbed=testbed)
Genie.testbed = testbed
with self.assertRaises(TypeError):
bgp = Bgp()
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
# Defining attributes
vrf_id = 'vrf1'
vrf1 = Vrf(vrf_id)
pp_name = 'PEER-POLICY'
ps_name = 'PEER-SESSION'
bgp.device_attr[dev2].peer_policy_attr[pp_name].pp_allowas_in =\
True
bgp.device_attr[dev2].peer_session_attr[ps_name].ps_fall_over_bfd=\
True
bgp.device_attr[dev2].vrf_attr[None].cluster_id = '150'
af_name = 'ipv6 unicast'
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name]
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_nexthop_route_map = 'test'
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening = True
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening_half_life_time = 1
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening_reuse_time = 10
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening_suppress_time = 30
bgp.device_attr[dev2].vrf_attr[None].address_family_attr[af_name].\
af_dampening_max_suppress_time = 2
neighbor_id = intf2.ipv4
bgp.device_attr[dev2].vrf_attr[vrf1].add_neighbor(neighbor_id)
bgp.device_attr[dev2].vrf_attr[vrf1].neighbor_attr[neighbor_id].\
nbr_suppress_four_byte_as_capability = True
dev2.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev2.name])
self.maxDiff = None
self.assertEqual(
str(cfgs[dev2.name]), '\n'.join([
'router bgp 100',
' bgp cluster-id 150',
' address-family ipv6 unicast',
' bgp dampening 1 10 30 2',
' bgp nexthop route-map test',
' exit',
' address-family ipv4 unicast vrf vrf1',
' neighbor 10.2.0.1 dont-capability-negotiate four-octets-as',
' exit',
' template peer-session PEER-SESSION',
' fall-over bfd',
' exit',
' template peer-policy PEER-POLICY',
' allowas-in',
' exit',
' exit',
]))
def test_cfg(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxe')
intf1 = Interface(device=dev1,
name='Ethernet0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1,
name='Ethernet0/0/2',
ipv4='10.2.0.1/24')
dev2 = Device(testbed=testbed, name='PE2', os='iosxe')
intf3 = Interface(device=dev2,
name='Ethernet0/0/3',
ipv4='10.1.0.2/24',
ipv6='2001:111:222::/64')
intf4 = Interface(device=dev2,
name='Ethernet0/0/4',
ipv4='10.2.0.2/24')
with self.assertNoWarnings():
Genie.testbed = None
with self.assertRaises(TypeError):
bgp = Bgp()
with self.assertRaises(TypeError):
bgp = Bgp(testbed=testbed)
Genie.testbed = testbed
with self.assertRaises(TypeError):
bgp = Bgp()
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(bgp_id=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
# Defining attributes
af_name = 'ipv4 unicast'
af_name2 = 'link-state'
bgp.device_attr[dev1]
bgp.device_attr[dev1].vrf_attr[None].always_compare_med = True
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name]
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name2]
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_label_allocation_mode = 'per-vrf'
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_dampening = True
neighbor_id = intf4.ipv4
bgp.device_attr[dev1].vrf_attr[None].add_neighbor(neighbor_id)
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id]
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
nbr_remote_as = 200
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
nbr_fall_over_bfd = True
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
nbr_shutdown = True
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
nbr_update_source = 'loopback0'
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
nbr_remove_private_as = True
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
nbr_remove_private_as_af_name = 'ipv4 unicast'
nbr_af_name = 'ipv4 multicast'
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name]
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name].nbr_af_allowas_in = True
dev1.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' bgp always-compare-med',
' neighbor 10.2.0.2 fall-over bfd',
' neighbor 10.2.0.2 remote-as 200',
' address-family ipv4 unicast',
' neighbor 10.2.0.2 remove-private-as',
' exit',
' neighbor 10.2.0.2 shutdown',
' neighbor 10.2.0.2 update-source loopback0',
' address-family ipv4 multicast',
' neighbor 10.2.0.2 activate',
' neighbor 10.2.0.2 allowas-in',
' exit',
' address-family ipv4 unicast',
' bgp dampening',
' exit',
' address-family link-state',
' exit',
' exit',
'mpls label mode vrf default protocol bgp-vpnv4 per-vrf',
]))
def test_bgp_vrf_neighbor_family_attr(self):
# For failures
self.maxDiff = None
# shorten the line
dev1 = self.dev1
# ===== none-default vrf =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
nei = '10:1::1:1'
af = 'ipv6 unicast'
bgp.device_attr[dev1].add_vrf(self.vrf2)
bgp.device_attr[dev1].vrf_attr[self.vrf2].address_family_attr[af]
bgp.device_attr[dev1].vrf_attr[self.vrf2].add_neighbor(nei)
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
nbr_remote_as = 100
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
address_family_attr[af]
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
address_family_attr[af].nbr_af_allowas_in = True
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
address_family_attr[af].nbr_af_inherit_peer_policy = 'policy-test'
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
address_family_attr[af].nbr_af_maximum_prefix_max_prefix_no = 666
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
address_family_attr[af].nbr_af_maximum_prefix_warning_only = True
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
address_family_attr[af].nbr_af_route_map_name_in = 'nei-af-in'
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
address_family_attr[af].nbr_af_route_reflector_client = True
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
address_family_attr[af].nbr_af_next_hop_self = True
bgp.device_attr[dev1].vrf_attr[self.vrf2].neighbor_attr[nei].\
address_family_attr[af].nbr_af_default_originate = True
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' address-family ipv6 unicast',
' exit',
' neighbor 10:1::1:1',
' remote-as 100',
' address-family ipv6 unicast',
' allowas-in',
' use af-group policy-test',
' maximum-prefix 666 warning-only',
' route-policy nei-af-in in',
' route-reflector-client',
' next-hop-self',
' default-originate',
' exit',
' exit',
' exit',
]))
def test_bgp_device_attr(self):
# For failures
self.maxDiff = None
# shorten the line
dev1 = self.dev1
# ===== no instance =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' exit',
]))
# ===== with instance =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
bgp.device_attr[dev1].instance_name = 'test'
# Build config
cfgs = bgp.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100 instance test',
' exit',
]))
# ===== with different instances =======
# Bgp object
bgp1 = Bgp(bgp_id=100, instance_name='test1')
dev1.add_feature(bgp1)
# Bgp object
bgp2 = Bgp(bgp_id=100, instance_name='test2')
dev1.add_feature(bgp2)
# Bgp object
bgp3 = Bgp(bgp_id=100, instance_name='test3')
dev1.add_feature(bgp3)
# Build config
cfg1 = bgp1.build_config(apply=False)
cfg2 = bgp2.build_config(apply=False)
cfg3 = bgp3.build_config(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfg1[dev1.name]), '\n'.\
join([
'router bgp 100 instance test1',
' exit',
]))
# Check config built correctly
self.assertMultiLineEqual(str(cfg2[dev1.name]), '\n'.\
join([
'router bgp 100 instance test2',
' exit',
]))
# Check config built correctly
self.assertMultiLineEqual(str(cfg3[dev1.name]), '\n'.\
join([
'router bgp 100 instance test3',
' exit',
]))
# Build unconfig
cfg1 = bgp1.build_unconfig(apply=False)
cfg2 = bgp2.build_unconfig(apply=False)
cfg3 = bgp3.build_unconfig(apply=False)
# Check config built correctly
self.assertMultiLineEqual(str(cfg1[dev1.name]), '\n'.\
join([
'no router bgp 100 instance test1',
]))
# Check config built correctly
self.assertMultiLineEqual(str(cfg2[dev1.name]), '\n'.\
join([
'no router bgp 100 instance test2',
]))
# Check config built correctly
self.assertMultiLineEqual(str(cfg3[dev1.name]), '\n'.\
join([
'no router bgp 100 instance test3',
]))
def test_uncfg(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='nxos')
intf1 = Interface(device=dev1, name='Ethernet0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1, name='Ethernet0/0/2',
ipv4='10.2.0.1/24')
dev2 = Device(testbed=testbed, name='PE2', os='nxos')
intf3 = Interface(device=dev2, name='Ethernet0/0/3',
ipv4='10.1.0.2/24', ipv6='2001:111:222::/64')
intf4 = Interface(device=dev2, name='Ethernet0/0/4',
ipv4='10.2.0.2/24')
with self.assertNoWarnings():
Genie.testbed = None
with self.assertRaises(TypeError):
bgp = Bgp()
with self.assertRaises(TypeError):
bgp = Bgp(testbed=testbed)
Genie.testbed = testbed
with self.assertRaises(TypeError):
bgp = Bgp()
bgp = Bgp(asn=100,bgp_id=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(asn=100,bgp_id=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
bgp.device_attr[dev1].enabled = True
uncfgs = bgp.build_unconfig(apply=False)
self.assertCountEqual(uncfgs.keys(), [dev1.name])
self.assertMultiLineEqual(str(uncfgs[dev1.name]), '\n'.join([
'no feature bgp',
]))
# Defining attributes
af_name = 'vpnv4 unicast'
af_name2 = 'link-state'
vrf_id = 'vrf1'
vrf1 = Vrf(vrf_id)
bgp.device_attr[dev1]
bgp.device_attr[dev1].vrf_attr[None].always_compare_med = True
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name]
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name2]
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_retain_rt_all = True
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_dampening = True
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_dampening_half_life_time = 1
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_dampening_reuse_time = 10
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_dampening_suppress_time = 30
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_dampening_max_suppress_time = 2
neighbor_id = intf4.ipv4
bgp.device_attr[dev1].vrf_attr[vrf1].add_neighbor(neighbor_id)
bgp.device_attr[dev1].vrf_attr[vrf1].neighbor_attr[neighbor_id]
bgp.device_attr[dev1].vrf_attr[vrf1].neighbor_attr[neighbor_id].\
nbr_fall_over_bfd = True
nbr_af_name = 'ipv4 unicast'
bgp.device_attr[dev1].vrf_attr[vrf1].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name]
bgp.device_attr[dev1].vrf_attr[vrf1].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name].nbr_af_allowas_in = True
partial_uncfg1 = bgp.build_unconfig(
apply=False,
attributes={'device_attr':\
{'*':{'vrf_attr':\
{'*':"always_compare_med"}}}})
self.assertCountEqual(partial_uncfg1.keys(), [dev1.name])
self.assertMultiLineEqual(str(partial_uncfg1[dev1.name]), '\n'.\
join([
'router bgp 100',
' no bestpath always-compare-med',
' exit',
]))
partial_uncfg2 = bgp.build_unconfig(\
apply=False,
attributes={'device_attr':\
{'*':{'vrf_attr':'*'}}})
self.assertCountEqual(partial_uncfg2.keys(), [dev1.name])
self.assertMultiLineEqual(str(partial_uncfg2[dev1.name]), '\n'.\
join([
'router bgp 100',
' no bestpath always-compare-med',
' no address-family link-state',
' no address-family vpnv4 unicast',
' no vrf vrf1',
' exit',
]))
partial_uncfg3 = bgp.build_unconfig(
apply=False,
attributes={'device_attr': {'*': {'vrf_attr':
{'*': {'neighbor_attr':\
{'*': {'address_family_attr':\
{'*':"nbr_af_allowas_in"}}}}}}}})
self.assertCountEqual(partial_uncfg3.keys(), [dev1.name])
self.assertMultiLineEqual(str(partial_uncfg3[dev1.name]), '\n'.\
join([
'router bgp 100',
' vrf vrf1',
' neighbor 10.2.0.2',
' address-family ipv4 unicast',
' no allowas-in',
' exit',
' exit',
' exit',
' exit',
]))
bgp.device_attr[dev1].protocol_shutdown = True
partial_uncfg4 = bgp.build_unconfig(
apply=False,
attributes={'device_attr':\
{'*':"protocol_shutdown"}})
self.assertCountEqual(partial_uncfg4.keys(), [dev1.name])
self.assertMultiLineEqual(str(partial_uncfg4[dev1.name]), '\n'.\
join([
'router bgp 100',
' no shutdown',
' exit',
]))
partial_uncfg5 = bgp.build_unconfig(\
apply=False,
attributes={'device_attr':\
{'*':\
{'vrf_attr':\
{'*':\
{'address_family_attr':\
{'*':\
"af_dampening"}}}}}})
self.assertCountEqual(partial_uncfg5.keys(), [dev1.name])
self.assertMultiLineEqual(str(partial_uncfg5[dev1.name]), '\n'.\
join([
'router bgp 100',
' address-family vpnv4 unicast',
' no dampening',
' exit',
' exit',
]))
bgp.device_attr[dev1].enabled = False
uncfgs = bgp.build_unconfig(apply=False)
self.assertCountEqual(uncfgs.keys(), [dev1.name])
self.assertMultiLineEqual(str(uncfgs[dev1.name]), '\n'.join([
'no router bgp 100',
]))
bgp.device_attr[dev1].enabled = True
uncfgs = bgp.build_unconfig(apply=False)
self.assertCountEqual(uncfgs.keys(), [dev1.name])
self.assertMultiLineEqual(str(uncfgs[dev1.name]), '\n'.join([
'no feature bgp',
]))
def test_bgp_with_attributes(self):
# For failures
self.maxDiff = None
# shorten the line
dev1 = self.dev1
# ===== no instance =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
bgp.device_attr[dev1].vrf_attr[self.vrf1]
attributes = {'device_attr': {dev1: {'vrf_attr': {self.vrf1: None}}}}
# Build config
cfgs = bgp.build_unconfig(apply=False, attributes=attributes)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100',
' no vrf vrf1',
' exit',
]))
# ===== instance =======
# Bgp object
bgp = Bgp(bgp_id=100, instance_name='test')
dev1.add_feature(bgp)
bgp.device_attr[dev1].vrf_attr[self.vrf1]
bgp.device_attr[dev1].instance_name = 'test'
attributes = {'device_attr': {dev1: {'vrf_attr': {self.vrf1: None}}}}
# Build config
cfgs = bgp.build_unconfig(apply=False, attributes=attributes)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'router bgp 100 instance test',
' no vrf vrf1',
' exit',
]))
# ===== instance as attribute =======
# Bgp object
bgp = Bgp(bgp_id=100)
dev1.add_feature(bgp)
bgp.device_attr[dev1].instance_name = 'test'
attributes = {'device_attr': {dev1: {'instance_name': {'test': None}}}}
# Build config
cfgs = bgp.build_unconfig(apply=False, attributes=attributes)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'no router bgp 100 instance test',
]))
# ===== instance as attribute =======
# Bgp object
bgp = Bgp(bgp_id=100, instance='test')
dev1.add_feature(bgp)
bgp.device_attr[dev1].instance_name = 'test'
attributes = {'device_attr': {dev1: {'instance_name': {'test': None}}}}
# Build config
cfgs = bgp.build_unconfig(apply=False, attributes=attributes)
# Check config built correctly
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.\
join([
'no router bgp 100 instance test',
]))
def test_learn_config(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='nxos')
dev1.custom = {'abstraction':{'order':['os'], 'context':'cli'}}
dev2 = Device(testbed=testbed, name='PE2', os='nxos')
golden_output = {'return_value': '''
pinxdt-n9kv-3# show run bgp
!Command: show running-config bgp
!Time: Wed Jun 28 06:23:27 2017
version 7.0(3)I7(1)
feature bgp
router bgp 333
dynamic-med-interval 70
shutdown
cluster-id 3
no graceful-restart
flush-routes
isolate
disable-policy-batching ipv4 prefix-list s
no enforce-first-as
event-history objstore size large
address-family ipv4 multicast
dampening 1 10 30 2
redistribute static route-map PERMIT_ALL_RM
address-family ipv6 multicast
dampening 1 10 30 2
redistribute static route-map PERMIT_ALL_RM
address-family ipv6 unicast
dampening 1 10 30 2
redistribute static route-map PERMIT_ALL_RM
inject-map ORIGINATE_IPV6 exist-map INJECTED_IPV6 copy-attributes
nexthop route-map test
address-family vpnv4 unicast
dampening route-map PASS-ALL
nexthop trigger-delay critical 4 non-critical 5
address-family vpnv6 unicast
dampening 1 10 30 2
address-family ipv4 labeled-unicast
template peer-session PEER-SESSION
ebgp-multihop 3
neighbor fec1::1002
remote-as 333
address-family ipv4 unicast
send-community
send-community extended
route-reflector-client
soft-reconfiguration inbound always
neighbor fec1::2002
remote-as 888
address-family ipv4 unicast
send-community
send-community extended
soft-reconfiguration inbound always
address-family ipv6 multicast
send-community
send-community extended
soft-reconfiguration inbound always
address-family ipv6 unicast
send-community
send-community extended
soft-reconfiguration inbound always
neighbor 4.4.4.4
capability suppress 4-byte-as
address-family vpnv6 unicast
send-community
send-community extended
soft-reconfiguration inbound always
maximum-prefix 300000
neighbor 21.0.101.1
remote-as 333
address-family ipv4 multicast
send-community
send-community extended
route-reflector-client
soft-reconfiguration inbound always
address-family ipv4 unicast
send-community
send-community extended
route-reflector-client
soft-reconfiguration inbound always
address-family ipv6 multicast
send-community
send-community extended
route-reflector-client
soft-reconfiguration inbound always
address-family ipv6 unicast
send-community
send-community extended
route-reflector-client
soft-reconfiguration inbound always
address-family vpnv4 unicast
send-community
send-community extended
route-reflector-client
address-family vpnv6 unicast
send-community
send-community extended
route-reflector-client
neighbor 21.0.102.1
remote-as 333
update-source loopback0
address-family ipv4 multicast
send-community
send-community extended
route-reflector-client
soft-reconfiguration inbound always
address-family ipv4 unicast
send-community
send-community extended
route-reflector-client
soft-reconfiguration inbound always
address-family ipv6 multicast
send-community
send-community extended
route-reflector-client
soft-reconfiguration inbound always
address-family ipv6 unicast
send-community
send-community extended
route-reflector-client
soft-reconfiguration inbound always
address-family vpnv4 unicast
send-community
send-community extended
address-family vpnv6 unicast
send-community
send-community extended
route-reflector-client
neighbor 21.0.201.1
remote-as 888
address-family ipv4 multicast
send-community
send-community extended
soft-reconfiguration inbound always
address-family ipv4 unicast
send-community
send-community extended
soft-reconfiguration inbound always
address-family ipv6 multicast
send-community
send-community extended
soft-reconfiguration inbound always
address-family ipv6 unicast
send-community
send-community extended
soft-reconfiguration inbound always
address-family vpnv4 unicast
send-community
send-community extended
address-family vpnv6 unicast
send-community
send-community extended
vrf ac
bestpath always-compare-med
address-family ipv4 unicast
neighbor 2.2.2.2
bfd
local-as 222
description ja
remove-private-as
disable-connected-check
capability suppress 4-byte-as
address-family ipv4 unicast
allowas-in 3
send-community
send-community extended
maximum-prefix 2
vrf management
neighbor 5.5.5.5
password 3 386c0565965f89de
vrf vpn1
address-family ipv4 multicast
redistribute static route-map PERMIT_ALL_RM
address-family ipv4 unicast
dampening 1 10 30 2
redistribute static route-map PERMIT_ALL_RM
address-family ipv6 multicast
dampening 1 10 30 2
redistribute static route-map PERMIT_ALL_RM
address-family ipv6 unicast
dampening 1 10 30 2
redistribute static route-map PERMIT_ALL_RM
vrf context vpn1
rd 1:100
address-family ipv4 unicast
route-target import 100:1
route-target export 100:1
route-target export 400:400
export map PERMIT_ALL_RM
import map PERMIT_ALL_RM
import vrf default map PERMIT_ALL_RM
export vrf default map PERMIT_ALL_RM
address-family ipv6 unicast
route-target import 1:100
route-target export 1:100
route-target export 600:600
export map PERMIT_ALL_RM
import map PERMIT_ALL_RM
import vrf default map PERMIT_ALL_RM
export vrf default map PERMIT_ALL_RM
vrf context vpn2
rd 2:100
address-family ipv4 unicast
route-target import 400:400
address-family ipv6 unicast
route-target import 600:600
'''}
bgp = Bgp(asn=333, bgp_id=333)
dev1.execute = Mock(**golden_output)
bgp.device_attr[dev1]
bgp.device_attr[dev1].enabled = True
bgp.device_attr[dev1].vrf_attr[None].cluster_id = '3'
af_name = 'ipv6 unicast'
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name]
bgp.device_attr[dev1].vrf_attr[None].address_family_attr[af_name].\
af_nexthop_route_map = 'test'
neighbor_id = '4.4.4.4'
bgp.device_attr[dev1].vrf_attr[None].add_neighbor(neighbor_id)
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
nbr_suppress_four_byte_as_capability = True
nbr_af_name = 'vpnv6 unicast'
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name]
bgp.device_attr[dev1].vrf_attr[None].neighbor_attr[neighbor_id].\
address_family_attr[nbr_af_name].\
nbr_af_maximum_prefix_max_prefix_no = 300000
cfgs = bgp.build_config(apply=False)
# List of BGP conf objects representing the different instances
# For NXOS, it is only one.
learn = Bgp.learn_config(device=dev1)
# Testing cluster_id
self.assertEqual(learn[0].device_attr[dev1].vrf_attr['default'].\
cluster_id,bgp.device_attr[dev1].vrf_attr['default'].cluster_id)
# Testing af_nexthop_route_map
self.assertEqual(learn[0].device_attr[dev1].vrf_attr['default'].\
address_family_attr['ipv6 unicast'].af_nexthop_route_map,
bgp.device_attr[dev1].vrf_attr['default'].address_family_attr\
['ipv6 unicast'].af_nexthop_route_map)
# Testing nbr_suppress_four_byte_as_capability
self.assertEqual(learn[0].device_attr[dev1].vrf_attr['default'].\
neighbor_attr['4.4.4.4'].nbr_suppress_four_byte_as_capability,
bgp.device_attr[dev1].vrf_attr['default'].neighbor_attr['4.4.4.4']\
.nbr_suppress_four_byte_as_capability)
# Testing nbr_af_maximum_prefix_max_prefix_no
self.assertEqual(learn[0].device_attr[dev1].vrf_attr['default'].\
neighbor_attr['4.4.4.4'].address_family_attr[nbr_af_name].\
nbr_af_maximum_prefix_max_prefix_no, bgp.device_attr[dev1].\
vrf_attr['default'].neighbor_attr['4.4.4.4'].address_family_attr\
[nbr_af_name].nbr_af_maximum_prefix_max_prefix_no)
def test_init(self):
Genie.testbed = testbed = Testbed()
dev1 = Device(testbed=testbed, name='PE1', os='iosxr')
intf1 = Interface(device=dev1,
name='GigabitEthernet0/0/0/1',
ipv4='10.1.0.1/24')
intf2 = Interface(device=dev1,
name='GigabitEthernet0/0/0/2',
ipv4='10.2.0.1/24')
dev2 = Device(testbed=testbed, name='PE2', os='iosxr')
intf3 = Interface(device=dev2,
name='GigabitEthernet0/0/0/3',
ipv4='10.1.0.2/24')
intf4 = Interface(device=dev2,
name='GigabitEthernet0/0/0/4',
ipv4='10.2.0.2/24')
vrf1 = Vrf(name='vrf1')
vrf2 = Vrf(name='a') # must be < 'default'
with self.assertNoWarnings():
Genie.testbed = None
with self.assertRaises(TypeError):
bgp = Bgp()
with self.assertRaises(TypeError):
bgp = Bgp(testbed=testbed)
Genie.testbed = testbed
with self.assertRaises(TypeError):
bgp = Bgp()
bgp = Bgp(asn=100)
self.assertIs(bgp.testbed, testbed)
Genie.testbed = testbed
bgp = Bgp(asn=100)
self.assertIs(bgp.testbed, Genie.testbed)
self.assertIs(bgp.testbed, testbed)
dev1.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' exit',
]))
dev2.add_feature(bgp)
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name, dev2.name])
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' exit',
]))
self.assertMultiLineEqual(str(cfgs[dev2.name]), '\n'.join([
'router bgp 100',
' exit',
]))
ospf1 = Ospf(pid=1)
isis1 = Isis(pid=1)
rtepol1 = RoutePolicy(name='rtepol1')
bgp.redistributes = (
'connected',
Redistribution(ospf1, metric=20),
Redistribution(isis1, route_policy=rtepol1),
)
bgp.device_attr[dev1].address_family_attr['ipv4 unicast']
bgp.device_attr[dev2].address_family_attr['ipv4 unicast']
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name, dev2.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' redistribute connected',
' redistribute ospf 1 metric 20',
' redistribute isis 1 route-policy rtepol1',
' exit',
' exit',
]))
self.assertMultiLineEqual(
str(cfgs[dev2.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' redistribute connected',
' redistribute ospf 1 metric 20',
' redistribute isis 1 route-policy rtepol1',
' exit',
' exit',
]))
del bgp.redistributes
bgp.device_attr[dev1].add_neighbor(intf3.ipv4)
bgp.device_attr[dev1].neighbor_attr[intf3.ipv4].\
address_family_attr['ipv4 unicast']
bgp.device_attr[dev1].add_vrf(vrf1)
bgp.device_attr[dev1].vrf_attr[vrf1].address_family_attr[
'ipv4 unicast']
bgp.device_attr[dev1].vrf_attr[vrf1].add_neighbor(intf4.ipv4)
bgp.device_attr[dev1].vrf_attr[vrf1].neighbor_attr[intf4.ipv4].\
address_family_attr['ipv4 unicast']
bgp.device_attr[dev1].add_vrf(vrf2)
bgp.device_attr[dev1].vrf_attr[vrf2].address_family_attr[
'ipv4 unicast']
cfgs = bgp.build_config(apply=False)
self.assertCountEqual(cfgs.keys(), [dev1.name, dev2.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' exit',
' neighbor 10.1.0.2',
' remote-as 100',
' address-family ipv4 unicast',
' exit',
' exit',
' vrf a',
' address-family ipv4 unicast',
' exit',
' exit',
' vrf vrf1',
' address-family ipv4 unicast',
' exit',
' neighbor 10.2.0.2',
' remote-as 100',
' address-family ipv4 unicast',
' exit',
' exit',
' exit',
' exit',
]))
self.assertMultiLineEqual(
str(cfgs[dev2.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' exit',
' exit',
]))
cfgs = bgp.build_config(
apply=False, attributes='device_attr__PE1__vrf_attr__default')
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' exit',
' neighbor 10.1.0.2',
' remote-as 100',
' address-family ipv4 unicast',
' exit',
' exit',
' exit',
]))
cfgs = bgp.build_config(apply=False,
attributes={
'device_attr': {
'*': (),
},
})
self.assertCountEqual(cfgs.keys(), [dev1.name, dev2.name])
self.assertMultiLineEqual(str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' exit',
]))
self.assertMultiLineEqual(str(cfgs[dev2.name]), '\n'.join([
'router bgp 100',
' exit',
]))
cfgs = bgp.build_config(apply=False,
attributes={
'device_attr': {
'PE1': 'vrf_attr__default',
},
})
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' address-family ipv4 unicast',
' exit',
' neighbor 10.1.0.2',
' remote-as 100',
' address-family ipv4 unicast',
' exit',
' exit',
' exit',
]))
cfgs = bgp.build_config(
apply=False,
attributes={
'device_attr': {
'PE1': 'vrf_attr__default__neighbor_attr__10.1.0.2',
},
})
self.assertCountEqual(cfgs.keys(), [dev1.name])
self.assertMultiLineEqual(
str(cfgs[dev1.name]), '\n'.join([
'router bgp 100',
' neighbor 10.1.0.2',
' remote-as 100',
' address-family ipv4 unicast',
' exit',
' exit',
' exit',
]))
