client = network.Host(1)
object_L.append(client)
server = network.Host(2)
object_L.append(server)
router_a = network.Router(name='A',
intf_count=1,
max_queue_size=router_queue_size)
object_L.append(router_a)
# 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, 0, router_a, 0, 50))
link_layer.add_link(link.Link(router_a, 0, server, 0, 30))
# start all the objects
thread_L = [
threading.Thread(name=object.__str__(), target=object.run)
for object in object_L
]
for t in thread_L:
t.start()
try:
## client.udt_send(2, "DATA")
## sleep(0.25)
client.udt_send(
2,
N.append(item.name)
R.append(item.name)
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_b, 1, host_2, 0))
#link_layer.add_link(link.Link(host_2, 0, router_b, 1))
#link_layer.add_link(link.Link(router_b, 0, router_a, 1))
#link_layer.add_link(link.Link(router_a, 0, host_1, 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()
'i_out': 0
}]
router_d = network.Router(name='D',
intf_cost_L=[1, 1, 1],
intf_capacity_L=[500, 300, 20],
rt_tbl_D=router_d_rt_tbl_D,
max_queue_size=router_queue_size,
mpls_tbl_L=router_d_mpls_tbl_L)
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_layer.add_link(link.Link(h1, 0, router_a, 0))
link_layer.add_link(link.Link(h2, 0, router_a, 1))
link_layer.add_link(link.Link(router_a, 2, router_b, 0))
link_layer.add_link(link.Link(router_a, 3, 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, h3, 0))
# link_layer.add_link(link.Link(h1, 0, router_a, 0))
# link_layer.add_link(link.Link(h2, 0, router_a, 1))
# link_layer.add_link(link.Link(router_a, 1, router_b, 0))
# link_layer.add_link(link.Link(router_b, 1, h2, 0))
1: INF,
2: INF
}
} # packet to host 2 through interface 0 for cost 3
router_d = network.Router(name='D',
intf_cost_L=[1, 1, 2],
rt_tbl_D=router_d_rt_tbl_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.LinkLayer()
object_L.append(link_layer)
#add all the links
#host_1
link_layer.add_link(link.Link(host_1, 0, router_a, 0))
#host_2
link_layer.add_link(link.Link(host_2, 0, router_a, 1))
#host3
link_layer.add_link(link.Link(host_3, 0, router_d, 0))
#router_a
link_layer.add_link(link.Link(router_a, 2, router_b, 0))
link_layer.add_link(link.Link(router_a, 3, router_c, 0))
#router_b
link_layer.add_link(link.Link(router_b, 1, router_d, 1))
#router_c
rt_tbl_D=router_c_rt_tbl_D,
max_queue_size=router_queue_size)
object_L.append(router_c)
router_d_rt_tcl_D = {3: {2: 1}}
router_d = network_2.Router(name='D',
intf_cost_L=[3, 1, 1],
rt_tbl_D=router_d_rt_tcl_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_2.LinkLayer()
object_L.append(link_layer)
# add all the links
link_layer.add_link(link_2.Link(client, 0, router_a, 0))
link_layer.add_link(link_2.Link(lazyguy, 0, router_a, 1))
link_layer.add_link(link_2.Link(router_a, 2, router_b, 0))
link_layer.add_link(link_2.Link(router_a, 3, router_c, 0))
link_layer.add_link(link_2.Link(router_b, 1, router_d, 0))
link_layer.add_link(link_2.Link(router_c, 1, router_d, 1))
link_layer.add_link(link_2.Link(router_d, 2, server, 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()
server = network_2.Host(2)
object_L.append(server)
router_a = network_2.Router(name='A',
intf_count=1,
max_queue_size=router_queue_size)
object_L.append(router_a)
#create a Link Layer to keep track of links between network nodes
link_layer = link_2.LinkLayer()
object_L.append(link_layer)
#add all the links
#link parameters: from_node, from_intf_num, to_node, to_intf_num, mtu/mtu_length
# Link between client and a router
link_layer.add_link(link_2.Link(client, 0, router_a, 0, mtu_length))
# Link between router and a client
link_layer.add_link(link_2.Link(router_a, 0, server, 0, mtu_length_2))
#start all the objects
thread_L = []
thread_L.append(threading.Thread(name=client.__str__(), target=client.run))
thread_L.append(threading.Thread(name=server.__str__(), target=server.run))
thread_L.append(
threading.Thread(name=router_a.__str__(), target=router_a.run))
thread_L.append(threading.Thread(name="Network", target=link_layer.run))
for t in thread_L:
t.start()
forwarding_table = forwarding_table)
object_L.append(router_c)
router_d_rt_tbl_D = {3: {2: 3}}
router_d = network_2.Router(name='D',
intf_cost_L=[2,1,3],
rt_tbl_D = router_d_rt_tbl_D,
max_queue_size=router_queue_size,
forwarding_table = forwarding_table)
object_L.append(router_d)
#create a Link Layer to keep track of links between network nodes
link_layer = link_2.LinkLayer()
object_L.append(link_layer)
#add all the links
link_layer.add_link(link_2.Link(host1, 0, router_a, 0))
link_layer.add_link(link_2.Link(host2, 0, router_a, 1))
link_layer.add_link(link_2.Link(router_a, 2, router_b, 0))
link_layer.add_link(link_2.Link(router_b, 1, router_d, 0))
link_layer.add_link(link_2.Link(router_d, 2, host3, 0))
link_layer.add_link(link_2.Link(host3, 0, router_d, 2))
link_layer.add_link(link_2.Link(router_d, 1, router_c, 1))
link_layer.add_link(link_2.Link(router_c, 0, router_a, 3))
link_layer.add_link(link_2.Link(router_a, 0, host1, 0))
#start all the objects
thread_L = []
for obj in object_L:
thread_L.append(threading.Thread(name=obj.__str__(), target=obj.run))
intf_cost_L=[1, 1, 1],
intf_capacity_L=[500, 500, 500],
rt_tbl_D={},
fwd_tbl_D={
'2': (None, 2),
'3': (None, 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_layer.add_link(link.Link(client1, 0, router_a, 0))
link_layer.add_link(link.Link(client2, 0, router_a, 1))
link_layer.add_link(link.Link(router_a, 2, router_b, 0))
link_layer.add_link(link.Link(router_a, 3, 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, server, 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()
client = network_2_2.Host(1)
object_L.append(client)
server = network_2_2.Host(2)
object_L.append(server)
router_a = network_2_2.Router(name='A',
intf_count=1,
max_queue_size=router_queue_size)
object_L.append(router_a)
# object_L = an object list
#create a Link Layer to keep track of links between network nodes
link_layer = link_2.LinkLayer()
object_L.append(link_layer)
#add all the links
link_layer.add_link(link_2.Link(client, 0, router_a, 0, 40))
link_layer.add_link(link_2.Link(router_a, 0, server, 0, 40))
#start all the objects
thread_L = []
thread_L.append(threading.Thread(name=client.__str__(), target=client.run))
thread_L.append(threading.Thread(name=server.__str__(), target=server.run))
thread_L.append(
threading.Thread(name=router_a.__str__(), target=router_a.run))
thread_L.append(threading.Thread(name="Network", target=link_layer.run))
for t in thread_L:
t.start()
#create some send events
#create network nodes
#part 3, add hosts, etc. (and make sure to start the threads)
client = network_2.Host(1) #client has address 1
object_L.append(client)
server = network_2.Host(2) #server has address 2
object_L.append(server)
router_a = network_2.Router(name='A', intf_count=1, max_queue_size=router_queue_size)
object_L.append(router_a)
#create a Link Layer to keep track of links between network nodes
link_layer = link_2.LinkLayer()
object_L.append(link_layer)
#add all the links
#client is output, router_a is input, 50 is largest size a packet can be to be transferred over a link
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, mtu)) #for part 2, change mtu to 30
#start all the objects
thread_L = []
thread_L.append(threading.Thread(name=client.__str__(), target=client.run))
thread_L.append(threading.Thread(name=server.__str__(), target=server.run))
thread_L.append(threading.Thread(name=router_a.__str__(), target=router_a.run))
thread_L.append(threading.Thread(name="Network", target=link_layer.run))
for t in thread_L:
t.start()
object_L = [] #keeps track of objects, so we can kill their threads
#create network nodes These are changed to correspond with the files for part 2 of the assignment
client = network_2.Host(1)
object_L.append(client)
server = network_2.Host(2)
object_L.append(server)
router_a = network_2.Router(name='A', intf_count=1, max_queue_size=router_queue_size)
object_L.append(router_a)
#create a Link Layer to keep track of links between network nodes Changed to correspond with part 2 of the assignment
link_layer = link_2.LinkLayer()
object_L.append(link_layer)
#add all the links
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)) #MTU change to 30 for part 2 of the assignment
#start all the objects
thread_L = []
thread_L.append(threading.Thread(name=client.__str__(), target=client.run))
thread_L.append(threading.Thread(name=server.__str__(), target=server.run))
thread_L.append(threading.Thread(name=router_a.__str__(), target=router_a.run))
thread_L.append(threading.Thread(name="Network", target=link_layer.run))
for t in thread_L:
t.start()
