def test_update_message_new_routes_parses(self):
serialised_message = build_byte_string("0000000e40010101400200400304c0a80021080a")
message = BgpMessageParser().parse(BgpMessage.UPDATE_MESSAGE, serialised_message)
self.assertEqual(message.nlri[0], IP4Prefix.from_string("10.0.0.0/8"))
self.assertEqual(message.path_attributes["next_hop"], IP4Address.from_string("192.168.0.33"))
self.assertEqual(message.path_attributes["origin"], "EGP")
self.assertEqual(message.path_attributes["as_path"], "")
def test_open_message_packs(self):
expected_serialised_message = build_byte_string(
"04fe0900b4c0a8000f080206010400010001")
message = BgpOpenMessage(4, 65033, 180,
IP4Address.from_string("192.168.0.15"),
{"multiprotocol": ["ipv4-unicast"]})
serialised_message = BgpMessagePacker().pack(message)
self.assertEqual(serialised_message[19:], expected_serialised_message)
def test_open_message_parses_ipv6_multiprotocol(self):
serialised_message = build_byte_string("04fe0900b4c0a8000f080206010400020001")
message = BgpMessageParser().parse(BgpMessage.OPEN_MESSAGE, serialised_message)
self.assertEqual(message.version, 4)
self.assertEqual(message.peer_as, 65033)
self.assertEqual(message.hold_time, 180)
self.assertEqual(message.identifier, IP4Address.from_string("192.168.0.15"))
self.assertEqual(message.capabilities["multiprotocol"], ["ipv6-unicast"])
def test_update_message_new_routes_parses_as4(self):
serialised_message = build_byte_string("000000274001010040020802035ba0fe08fdebc0110e020300bc614e0000fe080000fdeb400304ac1900042009090909")
message = BgpMessageParser().parse(BgpMessage.UPDATE_MESSAGE, serialised_message)
self.assertEqual(message.nlri, [IP4Prefix.from_string("9.9.9.9/32")])
self.assertEqual(message.path_attributes["next_hop"], IP4Address.from_string("172.25.0.4"))
self.assertEqual(message.path_attributes["origin"], "IGP")
self.assertEqual(message.path_attributes["as_path"], "23456 65032 65003")
self.assertEqual(message.path_attributes["as4_path"], "12345678 65032 65003")
def test_open_message_advances_to_idle_and_sends_notification(self):
message = BgpOpenMessage(4, 65002, 240, IP4Address.from_string("2.2.2.2"), {"multiprotocol": "ipv4-unicast"})
with self.assertRaises(IdleError) as context:
self.state_machine.event(EventMessageReceived(message), self.tick)
self.assertEqual(self.state_machine.state, "idle")
self.assertEqual(self.state_machine.output_messages.qsize(), 1)
message = self.state_machine.output_messages.get()
self.assertEqual(message.error_code, 6) # Cease
def test_update_message_adds_route(self):
path_attributes = {
"next_hop" : IP4Address.from_string("5.4.3.2"),
"as_path" : "65032 65011 65002",
"origin" : "EGP"
}
route_attributes = {
"prefix" : IP4Prefix.from_string("192.168.0.0/16"),
"next_hop" : IP4Address.from_string("5.4.3.2"),
"as_path" : "65032 65011 65002",
"origin" : "EGP"
}
message = BgpUpdateMessage([], path_attributes, [IP4Prefix.from_string("192.168.0.0/16")])
self.state_machine.event(EventMessageReceived(message), self.tick)
self.assertEqual(self.state_machine.state, "established")
self.assertEqual(self.state_machine.route_updates.qsize(), 1)
self.assertEqual(self.state_machine.route_updates.get(), RouteAddition(**route_attributes))
def test_open_message_parses_exabgp_optional_params(self):
serialised_message = build_byte_string("04fe0900b4c0a8000f9402060104000100010206010400010002020601040001000402060104000100800206010400010084020601040001008502060104000100860206010400020001020601040002000202060104000200040206010400020080020601040002008502060104000200860206010400190041020601040019004602060104400400470206010440040048020206000206410400010001")
message = BgpMessageParser().parse(BgpMessage.OPEN_MESSAGE, serialised_message)
self.assertEqual(message.version, 4)
self.assertEqual(message.peer_as, 65033)
self.assertEqual(message.hold_time, 180)
self.assertEqual(message.identifier, IP4Address.from_string("192.168.0.15"))
self.assertTrue("ipv4-unicast" in message.capabilities["multiprotocol"])
self.assertTrue("ipv6-unicast" in message.capabilities["multiprotocol"])
def test_open_message_packs_capabilities(self):
expected_serialised_message = build_byte_string("04fe0900b4c0a8000f160214010400010001010400020001020041040000fdeb")
capabilities = {
"multiprotocol": ["ipv4-unicast", "ipv6-unicast"],
"routerefresh": [True],
"fourbyteas": [65003]
}
message = BgpOpenMessage(4, 65033, 180, IP4Address.from_string("192.168.0.15"), capabilities)
serialised_message = BgpMessagePacker().pack(message)
self.assertEqual(serialised_message[19:], expected_serialised_message)
def test_update_message_advances_to_idle(self):
path_attributes = {
"next_hop" : IP4Address.from_string("5.4.3.2"),
"as_path" : "65032 65011 65002",
"origin" : "EGP"
}
message = BgpUpdateMessage([], path_attributes, [IP4Prefix.from_string("192.168.0.0/16")])
with self.assertRaises(IdleError) as context:
self.state_machine.event(EventMessageReceived(message), self.tick)
self.assertEqual(self.state_machine.state, "idle")
def setUp(self):
self.tick = 10000
self.state_machine = StateMachine(local_as=65001, peer_as=65002, local_address="1.1.1.1", router_id="1.1.1.1", neighbor="2.2.2.2", hold_time=240)
message = BgpOpenMessage(4, 65002, 240, IP4Address.from_string("2.2.2.2"), {"multiprotocol": "ipv4-unicast"})
self.state_machine.event(EventMessageReceived(message), self.tick)
self.assertEqual(self.state_machine.state, "open_confirm")
for _ in range(self.state_machine.output_messages.qsize()):
self.state_machine.output_messages.get()
self.assertTrue(self.state_machine.timers["keepalive"].running())
self.assertTrue(self.state_machine.timers["hold"].running())
def test_open_message_advances_to_open_confirm_and_sets_timers(self):
capabilities = {"multiprotocol": "ipv4-unicast"}
message = BgpOpenMessage(4, 65002, 240, IP4Address.from_string("2.2.2.2"), capabilities)
self.state_machine.event(EventMessageReceived(message), self.tick)
self.assertEqual(self.state_machine.state, "open_confirm")
self.assertEqual(self.state_machine.output_messages.qsize(), 1)
self.open_handler.assert_called_with(capabilities)
self.assertTrue(isinstance(self.state_machine.output_messages.get(), BgpKeepaliveMessage))
self.assertTrue(self.state_machine.timers["hold"].running())
self.assertTrue(self.state_machine.timers["keepalive"].running())
def test_update_message_new_routes_parses_as4_new(self):
serialised_message = build_byte_string("0000001c4001010040020e020300bc614e0000fe080001b2e5400304ac1900042009090909")
parser = BgpMessageParser()
parser.capabilities = {
"fourbyteas": 12345
}
message = parser.parse(BgpMessage.UPDATE_MESSAGE, serialised_message)
self.assertEqual(message.nlri, [IP4Prefix.from_string("9.9.9.9/32")])
self.assertEqual(message.path_attributes["next_hop"], IP4Address.from_string("172.25.0.4"))
self.assertEqual(message.path_attributes["origin"], "IGP")
self.assertEqual(message.path_attributes["as_path"], "12345678 65032 111333")
def test_keepalive_message_sends_all_routes(self):
self.tick += 3600
self.state_machine.routes_to_advertise = [
RouteAddition(
IP4Prefix.from_string("10.0.0.0/8"),
IP4Address.from_string("192.168.1.33"),
"",
"IGP"
),
RouteAddition(
IP4Prefix.from_string("192.168.64.0/23"),
IP4Address.from_string("192.168.1.33"),
"",
"IGP"
),
RouteAddition(
IP4Prefix.from_string("192.168.128.0/23"),
IP4Address.from_string("192.168.1.34"),
"",
"IGP"
)
]
message = BgpKeepaliveMessage()
self.state_machine.event(EventMessageReceived(message), self.tick)
self.assertEqual(self.state_machine.state, "established")
self.assertTrue(self.state_machine.timers["hold"].running())
self.assertFalse(self.state_machine.timers["hold"].expired(self.tick))
self.assertEqual(self.state_machine.output_messages.qsize(), 2)
first_update = self.state_machine.output_messages.get()
second_update = self.state_machine.output_messages.get()
self.assertTrue(isinstance(first_update, BgpUpdateMessage))
self.assertTrue(isinstance(second_update, BgpUpdateMessage))
self.assertEqual(first_update.path_attributes["next_hop"], IP4Address.from_string("192.168.1.33"))
self.assertEqual(first_update.nlri, [
IP4Prefix.from_string("10.0.0.0/8"),
IP4Prefix.from_string("192.168.64.0/23")
])
self.assertEqual(second_update.path_attributes["next_hop"], IP4Address.from_string("192.168.1.34"))
self.assertEqual(second_update.nlri, [
IP4Prefix.from_string("192.168.128.0/23")
])
def test_update_message_new_routes_packs_as4(self):
expected_serialised_message = build_byte_string("000000274001010040020802035ba0fe08fdebc0110e020300bc614e0000fe080000fdeb400304ac1900042009090909")
nlri = [
IP4Prefix.from_string("9.9.9.9/32"),
]
path_attributes = {
"next_hop": IP4Address.from_string("172.25.0.4"),
"origin": "IGP",
"as_path": "23456 65032 65003",
"as4_path": "12345678 65032 65003"
}
message = BgpUpdateMessage([], path_attributes, nlri)
serialised_message = BgpMessagePacker().pack(message)
self.assertEqual(serialised_message[19:], expected_serialised_message)
def test_update_message_new_routes_packs(self):
expected_serialised_message = build_byte_string("0000000e40010101400200400304c0a80021080a17c0a840")
nlri = [
IP4Prefix.from_string("10.0.0.0/8"),
IP4Prefix.from_string("192.168.64.0/23")
]
path_attributes = {
"next_hop": IP4Address.from_string("192.168.0.33"),
"origin": "EGP",
"as_path": ""
}
message = BgpUpdateMessage([], path_attributes, nlri)
serialised_message = BgpMessagePacker().pack(message)
self.assertEqual(serialised_message[19:], expected_serialised_message)
def test_update_message_new_routes_packs_as4_new(self):
expected_serialised_message = build_byte_string("0000001c4001010040020e020300bc614e0000fe080001b2e5400304ac1900042009090909")
nlri = [
IP4Prefix.from_string("9.9.9.9/32"),
]
path_attributes = {
"next_hop": IP4Address.from_string("172.25.0.4"),
"origin": "IGP",
"as_path": "12345678 65032 111333"
}
message = BgpUpdateMessage([], path_attributes, nlri)
packer = BgpMessagePacker()
packer.capabilities = {"fourbyteas": 12345}
serialised_message = packer.pack(message)
self.assertEqual(serialised_message[19:], expected_serialised_message)
