def network_alt(env):
simpynet.PointToPoint.unique_number=0
simpynet.Switch.unique_number=0
h0 = simpynet.Host(env , simpynet.Mac("00.00.00.00.00") , simpynet.IP("192.0.0.0"))
h1 = simpynet.Host(env , simpynet.Mac("00.00.00.00.01") , simpynet.IP("192.0.0.1"))
link0 = simpynet.PointToPoint(env, lambda x,y:PROPAGATION_DELAY, lambda src,trg,l: TRANSMISSION_DELAY)
link1 = simpynet.PointToPoint(env, lambda x,y:PROPAGATION_DELAY, lambda src,trg,l: TRANSMISSION_DELAY)
switch = simpynet.Switch( env, lambda x, y : PROCESSING_DELAY )
simpynet.physical.plug(link0,h0)
simpynet.physical.plug(link0,switch)
simpynet.physical.plug(link1,switch)
simpynet.physical.plug(link1,h1)
env.add_collector_functions( 'received_frames', switch.collector_receivedframes , TIME_INCREMENT )
env.add_collector_functions( 'sent_frames', switch.collector_sentframes , TIME_INCREMENT )
protocol0 = selective_repeat.Selective_Repeat( env, 10 )
protocol0.timeout_time = 30
protocol1 = selective_repeat.Selective_Repeat( env, 10 )
protocol1.timeout_time = 30
protocol0.add_handler( h0.add_transport_handler( protocol0.get_handler() ) )
protocol1.add_handler( h1.add_transport_handler( protocol1.get_handler() ) )
protocol0.send( NUMBER_OF_PACKETS , simpynet.IP("192.0.0.1") )
def network(env):
simpynet.PointToPoint.unique_number=0
simpynet.Switch.unique_number=0
h0 = simpynet.Host(env , simpynet.Mac("00.00.00.00.00") , simpynet.IP("192.0.0.0"))
h1 = simpynet.Host(env , simpynet.Mac("00.00.00.00.01") , simpynet.IP("192.0.0.1"))
link0 = simpynet.PointToPoint(env, lambda x,y:PROPAGATION_DELAY, lambda src,trg,l: TRANSMISSION_DELAY)
link1 = simpynet.PointToPoint(env, lambda x,y:PROPAGATION_DELAY, lambda src,trg,l: TRANSMISSION_DELAY)
switch = simpynet.Switch( env, lambda x, y : PROCESSING_DELAY )
tc = TimeCollector(env)
tc.reset()
simpynet.physical.plug(link0,h0)
tc.add_handlers( switch , link0 )
tc.add_handlers( switch , link1 )
simpynet.physical.plug(link1,h1)
env.add_collector_functions( 'data', tc.collector , float('inf') )
protocol0 = selective_repeat.Selective_Repeat( env, 10 )
protocol0.timeout_time = 30
protocol1 = selective_repeat.Selective_Repeat( env, 10 )
protocol1.timeout_time = 30
protocol0.add_handler( h0.add_transport_handler( protocol0.get_handler() ) )
protocol1.add_handler( h1.add_transport_handler( protocol1.get_handler() ) )
protocol0.send( NUMBER_OF_PACKETS , simpynet.IP("192.0.0.1") )
def sr_network(env):
h0 = simpynet.Host(env, simpynet.Mac("00.00.00.00.00"),
simpynet.IP("192.0.0.0"))
h1 = simpynet.Host(env, simpynet.Mac("00.00.00.00.01"),
simpynet.IP("192.0.0.1"))
link = simpynet.PointToPoint(env, lambda x, y: PROPAGATION_DELAY,
lambda src, trg, l: PROPAGATION_DELAY,
lambda src, trg, l: LOSS_PROBABILITY)
simpynet.physical.plug(link, h0)
simpynet.physical.plug(link, h1)
protocol0 = Selective_Repeat(env, 10)
protocol1 = Selective_Repeat(env, 10)
protocol0.add_handler(h0.add_transport_handler(protocol0.get_handler()))
protocol1.add_handler(h1.add_transport_handler(protocol1.get_handler()))
protocol0.send(NUMBER_OF_PACKETS, simpynet.IP("192.0.0.1"))
def example1(env):
"""
This example simulates the transfer of a packet of size 1000 byte
through a link with
-distance 2.5 km,
-propagation speed 2.5*10^8 m/s
-transmission rate 2 Mbps.
A ---link-----B
Make reference to exercise R18 at page 95
(Computer Networking, 6th edition, Kurose-Ross).
"""
packet_size = 1000 * 32 # bit
distance = 2500000 # m
speed_propagation = 250000 #000 # m/s
transmission_rate = 2000 #000 # 2 Mbps
trm_delay = lambda name, data: packet_size / float(transmission_rate)
prg_delay = lambda src, trg, link: distance / float(speed_propagation)
link = spn.PointToPoint(env, trm_delay, prg_delay)
def h_receiver(name, data, d_trm_delay): # receiver' s handler
def _new_handler(name, data, d_trm_delay):
yield env.timeout(d_trm_delay)
return env.process(_new_handler(name, data, d_trm_delay))
f_send = link.add_handler('rcv',
h_receiver) # handler of Point to Point link
packet = spn.Databits(packet_size)
def sender():
yield f_send('sender', packet, 0.0)
# env.add_collector_functions('l1 sent data', link.collector_sentdatabits , 4)
env.process(sender())
def example3(env):
"""
This example simulate a trasfer from a Host A to two hosts B and C,
A hub connects three links.
A---l1---Hub ---l2---B
|
|
l3
|
|
C
Statistics are collected from different intervall for every collector.
"""
packet_size = 12000 #bits
trm_rate = 2000 # b/s
trm_delay = lambda name, data: len(data) / float(trm_rate)
packet = spn.Databits(packet_size)
hub = spn.Hub(env, lambda d, l: 0.0)
def prg_delay(src_interface, trg_interface, link):
if (src_interface == 'sender' and trg_interface == repr(hub)):
return 4
if (src_interface == repr(hub) and trg_interface == 'b'):
return 8
if (src_interface == repr(hub) and trg_interface == 'c'):
return 16
l1 = spn.PointToPoint(env, trm_delay, prg_delay)
l2 = spn.PointToPoint(env, trm_delay, prg_delay)
l3 = spn.PointToPoint(env, trm_delay, prg_delay)
spn.physical.plug(l1, hub)
spn.physical.plug(hub, l2)
spn.physical.plug(hub, l3)
f_send = l1.get_handler()
def sender():
yield f_send('sender', packet, trm_delay=0.0)
def h_receiver(name, data, trm_delay):
def _new_handler(name, data, trm_delay):
yield env.timeout(trm_delay)
return env.process(_new_handler(name, data, trm_delay))
l1.add_handler('b', h_receiver)
l2.add_handler('c', h_receiver)
d = hub.collector_sentdatabits
c_l1 = l1.collector_sentdatabits
# env.set_stat_file_name('SPHY.EX3')
env.add_collector_functions('sent hub', d)
env.add_collector_functions('l1 sent data ', c_l1)
# def massimo( l ):
# return max(l)
#
# env.add_statistical_index( np.mean )
# env.add_statistical_index( massimo )
env.process(sender())
def network(env):
domains = {
"moogle.com": simpynet.IP("192.0.0.50"),
"mybank.com": simpynet.IP("192.0.0.80")
}
def dns_function(name):
if domains.has_key(name):
return domains[name]
else:
return None
def sender(env):
client.send("Hello", "moogle.com")
yield env.timeout(5)
client.send("Hello", "mybank.com")
yield env.timeout(5)
client.send("Hello", "random.com")
client.send("Hello again", "moogle.com")
def forwarding(datagram, router):
if datagram.dst_ip == simpynet.IP("192.0.0.0"):
return simpynet.Mac("00.00.00.00.00")
if datagram.dst_ip == simpynet.IP("192.0.0.1"):
return simpynet.Mac("00.00.00.00.01")
if datagram.dst_ip == simpynet.IP("192.0.0.50"):
return simpynet.Mac("00.00.00.00.02")
if datagram.dst_ip == simpynet.IP("192.0.0.80"):
return simpynet.Mac("00.00.00.00.03")
else:
return None
router = simpynet.Router(env, simpynet.Mac("00.00.00.00.10"), forwarding,
lambda x, y: PROCESSING_DELAY)
host = simpynet.Host(env, simpynet.Mac("00.00.00.00.00"),
simpynet.IP("192.0.0.0"))
dns_host = simpynet.Host(env, simpynet.Mac("00.00.00.00.01"),
simpynet.IP("192.0.0.1"))
server_host0 = simpynet.Host(env, simpynet.Mac("00.00.00.00.02"),
simpynet.IP("192.0.0.50"))
server_host1 = simpynet.Host(env, simpynet.Mac("00.00.00.00.03"),
simpynet.IP("192.0.0.80"))
host.set_default_gateway(simpynet.Mac("00.00.00.00.10"))
dns_host.set_default_gateway(simpynet.Mac("00.00.00.00.10"))
server_host0.set_default_gateway(simpynet.Mac("00.00.00.00.10"))
server_host1.set_default_gateway(simpynet.Mac("00.00.00.00.10"))
client = Client(env, host, dns_host.ip_addr)
dns = DNS_Server(env, dns_host, dns_function)
moogle = Server(env, server_host0, "moogle.com")
mybank = Server(env, server_host1, "mybank.com")
link0 = simpynet.PointToPoint(env, lambda x, y: PROPAGATION_DELAY,
lambda src, trg, l: PROPAGATION_DELAY)
link1 = simpynet.PointToPoint(env, lambda x, y: PROPAGATION_DELAY,
lambda src, trg, l: PROPAGATION_DELAY)
link2 = simpynet.PointToPoint(env, lambda x, y: PROPAGATION_DELAY,
lambda src, trg, l: PROPAGATION_DELAY)
link3 = simpynet.PointToPoint(env, lambda x, y: PROPAGATION_DELAY,
lambda src, trg, l: PROPAGATION_DELAY)
simpynet.physical.plug(link0, host)
simpynet.physical.plug(link0, router)
simpynet.physical.plug(link1, dns_host)
simpynet.physical.plug(link1, router)
simpynet.physical.plug(link2, server_host0)
simpynet.physical.plug(link2, router)
simpynet.physical.plug(link3, server_host1)
simpynet.physical.plug(link3, router)
env.process(sender(env))