object_L.append(router_c)
# Router D
router_d = network.Router(name='D',
intf_count=len(table_D),
max_queue_size=router_queue_size,
routing_table=table_D)
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes
link_layer = link.LinkLayer()
object_L.append(link_layer)
#add all the links
#link parameters: from_node, from_intf_num, to_node, to_intf_num, mtu
link_layer.add_link(link.Link(client1, 0, router_a, 0, 50))
link_layer.add_link(link.Link(client2, 0, router_a, 1, 50))
# Router A links to next object
link_layer.add_link(link.Link(router_a, 0, router_b, 0, 50))
link_layer.add_link(link.Link(router_a, 1, router_c, 0, 50))
# Router B links to next object
link_layer.add_link(link.Link(router_b, 0, router_d, 0, 30))
# Router C links to next object
link_layer.add_link(link.Link(router_c, 0, router_d, 1, 30))
# Router D links to next object
link_layer.add_link(link.Link(router_d, 0, server1, 0, 50))
link_layer.add_link(link.Link(router_d, 1, server2, 0, 50))
router_d = network_3.Router(routing_table_d, name='D', intf_count=2, max_queue_size=router_queue_size)
object_L.append(router_d)
host_3 = network_3.Host(3)
object_L.append(host_3)
host_4 = network_3.Host(4)
object_L.append(host_4)
# create a Link Layer to keep track of links between network nodes
link_layer = link_3.LinkLayer()
object_L.append(link_layer)
# add all the links
# link parameters: from_node, from_intf_num, to_node, to_intf_num, mtu
# out interface of client, in interface of server
# 50 is the MTU - largest size of packet that can be transferred over links
link_layer.add_link(link_3.Link(host_1, 0, router_a, 0, 50))
link_layer.add_link(link_3.Link(host_2, 0, router_a, 1, 50))
link_layer.add_link(link_3.Link(router_a, 0, router_b, 0, 50))
link_layer.add_link(link_3.Link(router_a, 1, router_c, 0, 50))
link_layer.add_link(link_3.Link(router_b, 0, router_d, 0, 50))
link_layer.add_link(link_3.Link(router_c, 0, router_d, 1, 50))
link_layer.add_link(link_3.Link(router_d, 0, host_3, 0, 50))
link_layer.add_link(link_3.Link(router_d, 1, host_4, 0, 50))
# start all the objects
thread_L = []
thread_L.append(threading.Thread(name=host_1.__str__(), target=host_1.run))
thread_L.append(threading.Thread(name=host_2.__str__(), target=host_2.run))
thread_L.append(threading.Thread(name=host_3.__str__(), target=host_3.run))
thread_L.append(threading.Thread(name=host_4.__str__(), target=host_4.run))
thread_L.append(threading.Thread(name=router_a.__str__(), target=router_a.run))
elif isinstance(item, network.Router):
N.append(item.name)
R.append(item.name)
# update all routers, initialize routing table
for item in object_L:
if isinstance(item, network.Router):
item.update_network_nodes(N, R)
item.initialize_routing_table()
#create a Link Layer to keep track of links between network nodes
link_layer = link.LinkLayer()
object_L.append(link_layer)
#add all the links - need to reflect the connectivity in cost_D tables above
link_layer.add_link(link.Link(host_1, 0, router_a, 0))
link_layer.add_link(link.Link(router_a, 1, router_b, 0))
link_layer.add_link(link.Link(router_a, 2, router_c, 0))
link_layer.add_link(link.Link(router_b, 1, router_d, 0))
link_layer.add_link(link.Link(router_c, 1, router_d, 1))
link_layer.add_link(link.Link(router_d, 2, host_2, 0))
#start all the objects
thread_L = []
for obj in object_L:
thread_L.append(threading.Thread(name=obj.__str__(), target=obj.run))
for t in thread_L:
t.start()
## compute routing tables
max_queue_size=router_queue_size,
routing_table=routing_table[3])
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes
link_layer = link_3.LinkLayer()
object_L.append(link_layer)
#add all the links
#link parameters: from_node, from_intf_num, to_node, to_intf_num, mtu
"""
link_layer.add_link(link_2.Link(client, 0, router_a, 0, 50))
link_layer.add_link(link_2.Link(router_a, 0, server, 0, 30))
"""
link_layer.add_link(link_3.Link(client1, 0, router_a, 0,
mtu_length)) # client1 to router_a
link_layer.add_link(link_3.Link(client2, 0, router_a, 1,
mtu_length)) # client2 to router_a
link_layer.add_link(link_3.Link(router_a, 0, router_b, 0,
mtu_length)) # router_a to router_b
link_layer.add_link(link_3.Link(router_a, 1, router_c, 0,
mtu_length)) # router_a to router_c
link_layer.add_link(link_3.Link(router_b, 0, router_d, 0,
mtu_length)) # router_b to router_d
link_layer.add_link(link_3.Link(router_c, 0, router_d, 1,
mtu_length)) # router_c to router_d
link_layer.add_link(link_3.Link(router_d, 0, client3, 0,
mtu_length)) # router_d to client3
link_layer.add_link(link_3.Link(router_d, 1, client4, 0,
mtu_length)) # router_d to client4
router_d.addToTable((0, 1291))
router_d.addToTable((1, 1292))
#DL: Adding them to the object list
object_L.append(router_a)
object_L.append(router_b)
object_L.append(router_c)
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes Changed to correspond with part 2 of the assignment
link_layer = link_3.LinkLayer()
object_L.append(link_layer)
#add all the links
#DL: the addresses of the hosts are edited to appropriate values tier 1
link_layer.add_link(link_3.Link(host_1, 0, router_a, 0, 50))
link_layer.add_link(link_3.Link(host_2, 0, router_a, 1, 50))
#DL: tier 2
link_layer.add_link(link_3.Link(router_a, 0, router_b, 0, 50))
link_layer.add_link(link_3.Link(router_a, 1, router_c, 0, 50))
#DL: tier 3
link_layer.add_link(link_3.Link(router_b, 0, router_d, 0, 50))
link_layer.add_link(link_3.Link(router_c, 0, router_d, 1, 50))
#DL: tier 4
link_layer.add_link(
link_3.Link(router_d, 0, host_3, 0,
30)) #MTU change to 30 for part 2 of the assignment
link_layer.add_link(
link_3.Link(router_d, 1, host_4, 0,
30)) #MTU change to 30 for part 2 of the assignment
#DL: the tiers are just following the verticle line of the picture provided where each jump is a tier.
intf_count=2,
max_queue_size=router_queue_size,
routing_dictionary=table["D"])
object_L.append(router_a)
object_L.append(router_b)
object_L.append(router_c)
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes
link_layer = link.LinkLayer()
object_L.append(link_layer)
#add all the links
#link parameters: from_node, from_intf_num, to_node, to_intf_num, mtu
link_layer.add_link(link.Link(client_1, 0, router_a, 0, 50))
link_layer.add_link(link.Link(client_2, 0, router_a, 1, 50))
link_layer.add_link(link.Link(router_a, 0, router_b, 0, 50))
link_layer.add_link(link.Link(router_a, 1, router_c, 0, 50))
link_layer.add_link(link.Link(router_b, 0, router_d, 0, 50))
link_layer.add_link(link.Link(router_c, 0, router_d, 1, 50))
link_layer.add_link(link.Link(router_d, 0, client_3, 0, 50))
link_layer.add_link(link.Link(router_d, 1, client_4, 0, 50))
#start all the objects
thread_L = []
thread_L.append(
threading.Thread(name=client_1.__str__(), target=client_1.run))
thread_L.append(
threading.Thread(name=client_2.__str__(), target=client_2.run))
thread_L.append(
max_queue_size=router_queue_size,
forward_table=table_c)
object_L.append(router_c)
router_d = network_3.Router(name='D',
intf_count=4,
max_queue_size=router_queue_size,
forward_table=table_d)
object_L.append(router_d)
# create a Link Layer to keep track of links between network_3 nodes
link_layer = link.LinkLayer()
object_L.append(link_layer)
#add all the links
#link parameters: from_node, from_intf_num, to_node, to_intf_num, mtu
link_layer.add_link(link.Link(host1, 0, router_a, 0, 50))
link_layer.add_link(link.Link(host2, 0, router_a, 1, 50))
link_layer.add_link(link.Link(router_a, 2, router_b, 0, 50))
link_layer.add_link(link.Link(router_a, 3, router_c, 0, 50))
link_layer.add_link(link.Link(router_b, 1, router_d, 0, 50))
link_layer.add_link(link.Link(router_c, 1, router_d, 1, 50))
link_layer.add_link(link.Link(router_d, 2, host3, 0, 50))
link_layer.add_link(link.Link(router_d, 3, host4, 0, 50))
#start all the objects
thread_L = []
thread_L.append(threading.Thread(name=host1.__str__(), target=host1.run))
thread_L.append(threading.Thread(name=host2.__str__(), target=host2.run))
thread_L.append(threading.Thread(name=host3.__str__(), target=host3.run))
thread_L.append(threading.Thread(name=host4.__str__(), target=host4.run))
thread_L.append(
router_b = network_3.Router(name='B', intf_count=1, max_queue_size=router_queue_size, rtable=routing_table_B) #Router B
object_L.append(router_b)
router_c = network_3.Router(name='C', intf_count=1, max_queue_size=router_queue_size, rtable=routing_table_C) #Router C
object_L.append(router_c)
router_d = network_3.Router(name='D', intf_count=2, max_queue_size=router_queue_size, rtable=routing_table_D) #Router D
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes
link_layer = link_3.LinkLayer()
object_L.append(link_layer)
#add all the links
link_layer.add_link(link_3.Link(host_1, 0, router_a, 0, 50)) #Host 1 -> Router A
link_layer.add_link(link_3.Link(host_2, 0, router_a, 1, 50)) #Host 2 -> Router A
link_layer.add_link(link_3.Link(router_a, 0, router_b, 0, 30)) #Router A -> Router B
link_layer.add_link(link_3.Link(router_a, 1, router_c, 0, 30)) #Router A -> Router C
link_layer.add_link(link_3.Link(router_b, 0, router_d, 0, 30)) #Router B -> Router D
link_layer.add_link(link_3.Link(router_c, 0, router_d, 1, 30)) #Router C -> Router D
link_layer.add_link(link_3.Link(router_d, 0, host_3, 0, 30)) #Router D -> Host 3
link_layer.add_link(link_3.Link(router_d, 1, host_4, 0, 30)) #Router D -> Host 4
#start all the objects
thread_L = []
thread_L.append(threading.Thread(name=host_1.__str__(), target=host_1.run))
object_L.append(server)
router_a = network_3.Router(name='A', intf_count=2, max_queue_size=router_queue_size, outgoing_l_mtu=50, routing_table={1: 0, 2: 1})
router_b = network_3.Router(name='B', intf_count=1, max_queue_size=router_queue_size, outgoing_l_mtu=50, routing_table={1: 0, 2: 0})
router_c = network_3.Router(name='C', intf_count=1, max_queue_size=router_queue_size, outgoing_l_mtu=50, routing_table={1: 0, 2: 0})
router_d = network_3.Router(name='D', intf_count=2, max_queue_size=router_queue_size, outgoing_l_mtu=50, routing_table={1: 0, 2: 0})
object_L.append(router_a)
object_L.append(router_b)
object_L.append(router_c)
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes
link_layer = link_3.LinkLayer()
object_L.append(link_layer)
#add all the links
link_layer.add_link(link_3.Link(client_a, 0, router_a, 0, 50))
link_layer.add_link(link_3.Link(client_b, 0, router_a, 0, 50))
link_layer.add_link(link_3.Link(router_a, 0, router_b, 0, 50))
link_layer.add_link(link_3.Link(router_a, 1, router_c, 0, 50))
link_layer.add_link(link_3.Link(router_b, 0, router_d, 0, 50))
link_layer.add_link(link_3.Link(router_c, 0, router_d, 1, 50))
link_layer.add_link(link_3.Link(router_d, 0, server, 0, 50))
#start all the objects
thread_L = []
thread_L.append(threading.Thread(name=client_a.__str__(), target=client_a.run))
thread_L.append(threading.Thread(name=client_b.__str__(), target=client_b.run))
max_queue_size=router_queue_size,
routing_table=rout_tab)
object_L.append(router_c)
router_d = network_3.Router(name='D',
intf_count=2,
max_queue_size=router_queue_size,
routing_table=rout_tab)
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes
link_layer = link_3.LinkLayer()
object_L.append(link_layer)
#add all the links
#link parameters: from_node, from_intf_num, to_node, to_intf_num, mtu
link_layer.add_link(link_3.Link(host1, 0, router_a, 0, 50))
link_layer.add_link(link_3.Link(host2, 0, router_a, 1, 50))
link_layer.add_link(link_3.Link(router_a, 0, router_b, 0, 50))
link_layer.add_link(link_3.Link(router_a, 1, router_c, 0, 50))
link_layer.add_link(link_3.Link(router_b, 0, router_d, 0, 50))
link_layer.add_link(link_3.Link(router_c, 0, router_d, 1, 50))
link_layer.add_link(link_3.Link(router_d, 0, host3, 0, 50))
link_layer.add_link(link_3.Link(router_d, 1, host4, 0, 50))
#start all the objects
thread_L = []
thread_L.append(threading.Thread(name=host1.__str__(), target=host1.run))
thread_L.append(threading.Thread(name=host2.__str__(), target=host2.run))
thread_L.append(threading.Thread(name=host3.__str__(), target=host3.run))
thread_L.append(threading.Thread(name=host4.__str__(), target=host4.run))
thread_L.append(
object_L.append(router_a)
router_b = network.Router(name='B', intf_count=1, max_queue_size=router_queue_size)
object_L.append(router_b)
router_c = network.Router(name='C', intf_count=1, max_queue_size=router_queue_size)
object_L.append(router_c)
router_d = network.Router(name='D', intf_count=2, max_queue_size=router_queue_size)
object_L.append(router_d)
# create a Link Layer to keep track of links between network nodes
link_layer = link.LinkLayer()
object_L.append(link_layer)
# add all the links
# link parameters: from_node, from_intf_num, to_node, to_intf_num, mtu
link_layer.add_link(link.Link(client1, 0, router_a, 0, 50)) #host1 to A
link_layer.add_link(link.Link(client2, 0, router_a, 1, 50)) #host2 to A
link_layer.add_link(link.Link(router_a, 0, router_b, 0, 50)) #A to B
link_layer.add_link(link.Link(router_a, 1, router_c, 0, 50)) #A to C
link_layer.add_link(link.Link(router_b, 0, router_d, 0, 50)) #B to D
link_layer.add_link(link.Link(router_c, 0, router_d, 1, 50)) #C to D
link_layer.add_link(link.Link(router_d, 0, server1, 0, 50)) #D to host3
link_layer.add_link(link.Link(router_d, 1, server2, 0, 50)) #D to host4
# create routing table
hosts = [client1, client2, server1, server2]
routers = [router_a, router_b, router_c, router_d]
table = RoutingTable(link_layer, hosts, routers)
path1 = Route(1, 3, "1ABD3", table)
path2 = Route(1, 4, "1ABD4", table)
path3 = Route(1, 3, "1ACD3", table)
max_queue_size=router_queue_size,
routingTable=singleRouteRoutingTable)
object_L.append(router_c)
router_d = network_3.Router(name='D',
intf_count=2,
max_queue_size=router_queue_size,
routingTable=convergingRoutingTable)
object_L.append(router_d)
# object_L = an object list
#create a Link Layer to keep track of links between network nodes
link_layer = link_3.LinkLayer()
object_L.append(link_layer)
#add all the links
link_layer.add_link(link_3.Link(client1, 0, router_a, 0, 40))
link_layer.add_link(link_3.Link(client2, 0, router_a, 1, 40))
link_layer.add_link(link_3.Link(router_a, 0, router_b, 0, 40))
link_layer.add_link(link_3.Link(router_a, 1, router_c, 0, 40))
link_layer.add_link(link_3.Link(router_b, 0, router_d, 0, 40))
link_layer.add_link(link_3.Link(router_c, 0, router_d, 1, 40))
link_layer.add_link(link_3.Link(router_d, 0, server3, 0, 40))
link_layer.add_link(link_3.Link(router_d, 1, server4, 0, 40))
#start all the objects
thread_L = []
thread_L.append(
threading.Thread(name=client1.__str__(), target=client1.run))
thread_L.append(
threading.Thread(name=client2.__str__(), target=client2.run))
thread_L.append(
router_d = network_3.Router(routeTableD, name='D', intf_count=2,max_queue_size=router_queue_size)
#add routers to list
object_L.append(router_a)
object_L.append(router_b)
object_L.append(router_c)
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes
link_layer = link_3.LinkLayer()
object_L.append(link_layer)
print(len(msg_S))
#add all the links
#link parameters: from_node, from_intf_num, to_node, to_intf_num, mtu
#add link between host1 and A
link_layer.add_link(link_3.Link(client1, 0, router_a, 0, 152))
#add link between host2 and A
link_layer.add_link(link_3.Link(client2, 0, router_a, 1, 152))
#add link between A interface 0 to B interface 0
link_layer.add_link(link_3.Link(router_a, 0, router_b, 0, 152))
#add link between A interface 1 to C interface 0
link_layer.add_link(link_3.Link(router_a, 1, router_c, 0, 152))
#add link between B interface 0 to D interface 0
link_layer.add_link(link_3.Link(router_b, 0, router_d, 0, 152))
#add link between C interface 0 to D interface 1
link_layer.add_link(link_3.Link(router_c, 0, router_d, 1, 152))
#add link between D interface 0 to host3 interface 0
link_layer.add_link(link_3.Link(router_d, 0, server1, 0, 152))
#add link between D interface 1 to host4 interface 0
link_layer.add_link(link_3.Link(router_d, 1, server2, 0, 152))
},
'RC': {
2: 1
}
} # {neighbor: {interface: cost}}
router_d = network_3.Router(name='RD',
cost_D=cost_D,
max_queue_size=router_queue_size)
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes
link_layer = link_3.LinkLayer()
object_L.append(link_layer)
#add all the links - need to reflect the connectivity in cost_D tables above
link_layer.add_link(link_3.Link(host_1, 0, router_a, 0))
link_layer.add_link(link_3.Link(router_a, 1, router_b, 0))
link_layer.add_link(link_3.Link(router_b, 1, router_d, 0))
link_layer.add_link(link_3.Link(host_2, 0, router_a, 2))
link_layer.add_link(link_3.Link(router_a, 3, router_c, 0))
link_layer.add_link(link_3.Link(router_c, 1, router_d, 2))
link_layer.add_link(link_3.Link(router_d, 1, host_3, 0))
#start all the objects
thread_L = []
for obj in object_L:
thread_L.append(threading.Thread(name=obj.__str__(), target=obj.run))
for t in thread_L:
t.start()
