def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It
also might not be a bad place to check for whether any entries
have expired.
"""
if self.POISON_MODE:
for p_route in self.routing_data.get_poisoned_route_map():
self.send(basics.RoutePacket(p_route, INFINITY), flood=True)
for host in self.routing_data.get_host_route_map():
route = self.routing_data.get_route(host)
if route:
time_diff = api.current_time() - route.get_time()
if route.get_time() == -1 or time_diff <= self.ROUTE_TIMEOUT:
if self.POISON_MODE:
self.send(basics.RoutePacket(host, INFINITY),
route.get_port())
self.send(basics.RoutePacket(host, route.get_distance()),
route.get_port(),
flood=True)
else:
if self.POISON_MODE:
self.send(basics.RoutePacket(host, INFINITY),
route.get_port())
self.routing_data.set_poisoned_route(host, route)
self.routing_data.null_route(host)
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It also might
not be a bad place to check for whether any entries have expired.
"""
#self.log("handle_timer " + str(len(self.routesToDest)))
deleteDests = set()
for dest in self.routesToDest:
recievedTime = self.routesToDest[dest][2]
if api.current_time(
) - recievedTime <= TimeDiff or self.routesToDest[dest][3]:
latency = self.routesToDest[dest][1]
packet = basics.RoutePacket(dest, latency)
port = self.routesToDest[dest][0]
self.send(packet, port, True)
else:
if dest in self.hosts:
packet = basics.RoutePacket(dest, self.hosts[dest][1])
self.send(packet, self.hosts[dest][0], True)
self.routesToDest[dest] = self.hosts[dest]
else:
deleteDests.add(dest)
self.sendPoison(dest)
for dest in deleteDests:
del self.routesToDest[dest]
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It
also might not be a bad place to check for whether any entries
have expired.
"""
expired = []
for entity, node in self.table.iteritems():
if entity in self.connection_entities:
new_port = self.connection_entities[entity]
if new_port in self.connection_latencies:
new_latency = self.connection_latencies[new_port]
if new_latency < node.latency:
self.table[entity] = self.NetworkNode(
new_latency, entity, new_port)
node.timeout += self.DEFAULT_TIMER_INTERVAL
if node.predecessor_port in self.connection_latencies:
if node.timeout <= self.ROUTE_TIMEOUT and node.latency < INFINITY and self.connection_latencies[
node.predecessor_port] < INFINITY:
for port in self.connection_latencies.keys():
self.send(basics.RoutePacket(entity, node.latency),
port=port)
continue
if self.POISON_MODE:
for port in self.connection_latencies.keys():
self.send(basics.RoutePacket(entity, INFINITY), port=port)
expired.append(entity)
for entity in expired:
del self.table[entity]
def handle_link_down(self, port):
"""
Called by the framework when a link attached to this Entity does down.
The port number used by the link is passed in.
"""
#poison the route then wait for replacement route via RoutePacket
if port in self.port_table.keys():
del self.port_table[port]
to_remove = []
if self.POISON_MODE:
for dst in self.distance_table.keys():
if self.distance_table[dst][0] == port:
#send poison with INFINITY cost, delete local table[dst]
p = basics.RoutePacket(dst, INFINITY)
self.send(p, flood=True)
to_remove.append(dst)
for dst in to_remove:
del self.distance_table[dst]
else:
to_remove = []
for dst in self.distance_table.keys():
if self.distance_table[dst][0] == port:
to_remove.append(dst)
for dst in to_remove:
del self.distance_table[dst]
for dst in self.distance_table.keys():
p = basics.RoutePacket(dst, self.distance_table[dst][1])
self.send(p, flood=True)
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It
also might not be a bad place to check for whether any entries
have expired.
"""
#will make expire_routes pass.
#If time has expired, you remove the entry from the routing table.
for key, val in self.routing_table.items():
if val[2] != None:
if api.current_time() - val[2] > self.ROUTE_TIMEOUT:
if self.POISON_MODE:
self.routing_table[key][1] = INFINITY
else:
del self.routing_table[key]
for port in self.link_up:
for dest, val_list in self.routing_table.items():
if self.POISON_MODE == True:
latency = val_list[1]
if val_list[0] == port:
latency = INFINITY
new_packet = basics.RoutePacket(dest, latency)
self.send(new_packet, port, flood=False)
else:
latency = val_list[1]
if val_list[0] != port:
new_packet = basics.RoutePacket(dest, latency)
self.send(new_packet, port, flood=False)
def handle_rx (self, packet, port):
"""
Called by the framework when this Entity receives a packet.
packet is a Packet (or subclass).
port is the port number it arrived on.
You definitely want to fill this in.
"""
self.log("RX %s on %s (%s)", packet, port, api.current_time())
if isinstance(packet, basics.RoutePacket):
new_latency = packet.latency + self.weights[port]
if new_latency >= INFINITY:
if packet.destination in self.DP and self.DP[packet.destination][0] == port:
del self.DP[packet.destination]
if self.POISON_MODE:
self.send(basics.RoutePacket(packet.destination, INFINITY), port, flood=True)
elif packet.destination not in self.DP or self.DP[packet.destination][1] >= new_latency or self.DP[packet.destination][0] == port:
self.DP[packet.destination] = (port, new_latency)
self.timer[packet.destination] = api.current_time()
self.send(basics.RoutePacket(packet.destination, new_latency), port, flood=True)
elif isinstance(packet, basics.HostDiscoveryPacket):
self.DP[packet.src] = (port, self.weights[port])
self.timer[packet.src] = api.current_time()
elif packet.dst in self.DP:
self.send(packet, self.DP[packet.dst][0])
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It
also might not be a bad place to check for whether any entries
have expired.
"""
# remove expired routes
remove_dests = []
for dest, info in self.router_table.items():
time = api.current_time() - info[2]
if time >= self.ROUTE_TIMEOUT:
remove_dests.append(dest)
for dest in remove_dests:
# remove routes
del self.router_table[dest]
if self.POISON_MODE:
self.poison.append(dest)
self.host_route_default(dest, api.current_time())
# send to neighbors the router_table
for port in self.port_latency.keys():
for dest, info in self.router_table.items():
if (info[0] != port):
self.send(basics.RoutePacket(dest, info[1]), port)
elif (info[0] == port and self.POISON_MODE):
self.send(basics.RoutePacket(dest, INFINITY), port)
if self.POISON_MODE:
for dest in self.poison:
if dest not in self.host_port:
self.send(basics.RoutePacket(dest, INFINITY), port)
self.poison = []
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It also might
not be a bad place to check for whether any entries have expired.
"""
to_delete = []
for dest in self.routeTableLatency:
if api.current_time() - self.routeTableTime[dest] <= 15:
routePacket = basics.RoutePacket(dest,
self.routeTableLatency[dest])
self.send(routePacket, self.routeTablePort[dest], True)
else:
if dest in self.neighborHosts and self.neighborHosts[dest][
1] == self.routeTablePort[dest]:
self.routeTableLatency[dest] = self.neighborHosts[dest][0]
self.routeTablePort[dest] = self.neighborHosts[dest][1]
self.routeTableTime[dest] = api.current_time()
routePacket = basics.RoutePacket(
dest, self.routeTableLatency[dest])
self.send(routePacket, self.routeTablePort[dest], True)
else:
to_delete.append(dest)
routePacket = basics.RoutePacket(dest, INFINITY)
self.send(routePacket, self.routeTablePort[dest], True)
self.delete(to_delete)
def handle_timer(self):
for i in self.routeTable.keys():
if (((api.current_time() - self.routeTable[i][2]) <=
self.ROUTE_TIMEOUT)
or (self.routeTable[i][2]
== -1)): #Checks if a route is expired or not
self.send(
basics.RoutePacket(i, self.routeTable[i][0]),
flood=True) #updates neighbours with distance vector table
if self.POISON_MODE == True:
self.send(basics.RoutePacket(i, INFINITY),
self.routeTable[i][1],
flood=False)
else:
if self.POISON_MODE == True:
self.p_reverse[i] = self.routeTable[
i] #populates poisoned reverse dictionary
self.send(basics.RoutePacket(i, INFINITY),
self.routeTable[i][1],
flood=False)
del self.routeTable[
i] #deletes route from dictionary if it is expired.
if self.POISON_MODE == True:
for i in self.p_reverse.keys():
self.send(basics.RoutePacket(i, INFINITY),
port=None,
flood=True)
def valid_packet(self, packet, port):
new_dist = packet.latency + self.port_to_latency[port];
if self.POISON_MODE:
if packet.destination in self.poison_state:
self.poison_state.pop(packet.destination)
self.send(basics.RoutePacket(packet.destination, INFINITY), port)
if packet.destination not in self.host_to_route.keys() \
or self.host_to_route[packet.destination] is None \
or self.host_to_route[packet.destination][0] > new_dist:
self.host_to_route[packet.destination] = \
[self.port_to_latency[port] + packet.latency, port, api.current_time()]
self.send(basics.RoutePacket(packet.destination, new_dist), port,
flood=True)
else:
if new_dist == self.host_to_route[packet.destination][0]:
if self.host_to_route[packet.destination][2] < api.current_time():
self.host_to_route[packet.destination] = \
[new_dist, port, api.current_time()]
self.send(basics.RoutePacket(
packet.destination, new_dist), port, flood=True)
if self.host_to_route[packet.destination][1] == port: # ???
if new_dist > self.host_to_route[packet.destination][0]:
self.host_to_route[packet.destination][0] = new_dist
self.send(basics.RoutePacket(
packet.destination, new_dist), port, flood=True)
self.host_to_route[packet.destination][2] = api.current_time()
def handle_timer (self):
"""
Called periodically.
When called, your router should send tables to neighbors. It also might
not be a bad place to check for whether any entries have expired.
"""
for x in self.DV.keys():
#print x, self.DV[x][2], self.DV[x][0], self
if (api.current_time() - self.DV[x][1] ) <= 15 or self.DV[x][1] == -1:
route = basics.RoutePacket(x, self.DV[x][0])
self.send(route, self.DV[x][2], flood=True)
if self.POISON_MODE:
routePoison = basics.RoutePacket(x, INFINITY)
self.send(routePoison, self.DV[x][2], flood=False)
else:
if self.POISON_MODE:
routePoison = basics.RoutePacket(x, INFINITY)
self.send(routePoison, self.DV[x][2], flood=False)
self.poisoned[x] = self.DV[x]
del self.DV[x]
if self.POISON_MODE:
for x in self.poisoned.keys():
poison = basics.RoutePacket(x, INFINITY)
self.send(poison, port=None, flood=True)
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It
also might not be a bad place to check for whether any entries
have expired.
"""
# check through the routes and see if 15 seconds have passed -> remove route
for dest in self.destination_map.keys():
if dest == self:
self.destination_map.get(dest)[2] = api.current_time()
if self.destination_map.get(dest)[3] == True:
self.destination_map.get(dest)[2] = api.current_time()
if api.current_time() - self.destination_map.get(
dest)[2] >= self.ROUTE_TIMEOUT:
del self.destination_map[dest]
#send updated routes to neighbors/ poison stuff
for port in self.port_latency:
for dest in self.destination_map:
#if dest is itself, send with latency 0
if self.destination_map.get(dest)[0] == 0:
latency = 0
destination = dest
rPacket = basics.RoutePacket(destination, latency)
self.send(rPacket, port)
continue
#poison mode
if self.POISON_MODE:
#same port that the route uses, advertise dist of INFINITY
if port == self.destination_map.get(dest)[1]:
destination = dest
latency = INFINITY
rPacket = basics.RoutePacket(destination, latency)
self.send(rPacket, port)
#different port than the one route uses
elif port != self.destination_map.get(dest)[1]:
latency = self.destination_map.get(dest)[0]
destination = dest
rPacket = basics.RoutePacket(destination, latency)
self.send(rPacket, port)
#not poison mode
else:
#same port that the route uses, don't advertise route
if port == dest[1]:
continue
#different port than the one route uses
elif port != dest[1]:
latency = self.destination_map.get(dest)[0]
destination = dest
rPacket = basics.RoutePacket(destination, latency)
self.send(rPacket, port)
def handle_rx(self, packet, port):
"""
Called by the framework when this Entity receives a packet.
packet is a Packet (or subclass).
port is the port number it arrived on.
You definitely want to fill this in.
"""
#self.log("RX %s on %s (%s)", packet, port, api.current_time())
if isinstance(packet, basics.RoutePacket):
#if host is not in table
if packet.destination not in self.table:
#add host to table with (link latency + this latency) and current time
newLatency = packet.latency + self.portLatency[port]
self.table[packet.destination] = (newLatency, port, api.current_time(), port)
#flood new host to other switches/routers
self.send(basics.RoutePacket(packet.destination, newLatency), port, flood=True)
#else try to update vector
else:
hostVector = self.table[packet.destination]
originalLatency = hostVector[0]
newLatency = packet.latency + self.portLatency[port]
if self.directRoute.has_key(packet.destination) and self.directRoute[packet.destination][0] < originalLatency:
#update to direct route if possible
self.table[packet.destination] = self.directRoute[packet.destination]
elif hostVector[1] == port:
#update time
if newLatency > originalLatency:
#update latency
self.table[packet.destination] = (newLatency, hostVector[1], api.current_time(), hostVector[3])
self.send(basics.RoutePacket(packet.destination, newLatency), port, flood=True)
else:
self.table[packet.destination] = (originalLatency, hostVector[1], api.current_time(), hostVector[3])
elif newLatency <= originalLatency:
#update vector with lower latency
self.table[packet.destination] = (newLatency, port, api.current_time(), originalLatency)
elif isinstance(packet, basics.HostDiscoveryPacket):
#add host to table
hostVector = (self.portLatency[port], port, None, port)
self.table[packet.src] = hostVector
self.directRoute[packet.src] = hostVector
#send host to other links
self.send(basics.RoutePacket(packet.src, hostVector[0]), port, flood=True)
else:
#forward regular packet
isHairpin = packet.src != packet.dst #need to better implement
isIntable = packet.dst in self.table
if isinstance(packet.dst, api.HostEntity) and isHairpin and isIntable:
hostPort = self.table[packet.dst][1]
hostLatency = self.table[packet.dst][0]
if not hostLatency >= INFINITY:
self.send(packet, hostPort)
def handle_rx (self, packet, port):
"""
Called by the framework when this Entity receives a packet.
packet is a Packet (or subclass).
port is the port number it arrived on.
You definitely want to fill this in.
"""
#self.log("RX %s on %s (%s)", packet, port, api.current_time())
if isinstance(packet, basics.RoutePacket):
dest = packet.destination
newLatency = self.neighbours[port] + packet.latency
oldLatency = INFINITY
if dest in self.routesToDest:
oldLatency = self.routesToDest[dest][1]
if dest not in self.routesToDest or newLatency <= oldLatency or (dest in self.routesToDest and self.routesToDest[dest][0] == port):
self.routesToDest[dest] = (port, newLatency, api.current_time(), False)
if dest in self.hosts and self.hosts[dest][1] <= self.routesToDest[dest][1]:
self.routesToDest[dest] = self.hosts[dest]
if oldLatency != self.routesToDest[dest][1]:
newPacket = basics.RoutePacket(dest, self.routesToDest[dest][1])
self.send(newPacket, port, True)
elif isinstance(packet, basics.HostDiscoveryPacket):
self.routesToDest[packet.src] = (port, self.neighbours[port], api.current_time(), True)
self.send(basics.RoutePacket(packet.src, self.neighbours[port]), port, True)
self.hosts[packet.src] = (port, self.neighbours[port], api.current_time(), True)
else:
# Totally wrong behavior for the sake of demonstration only: send
# the packet back to where it came from!
reciever = packet.dst
if reciever in self.routesToDest:
latency = self.routesToDest[reciever][1]
if latency < INFINITY and self.routesToDest[reciever][0] != port:
self.send(packet, self.routesToDest[reciever][0], False)
return
if reciever in self.hosts:
self.routesToDest[reciever] = self.hosts[reciever]
latency = self.routesToDest[reciever][1]
if latency < INFINITY and self.routesToDest[reciever][0] != port:
self.send(packet, self.hosts[reciever][0], False)
def calc_send(self, cost, port, host):
self.routing_tb[host] = self.b_ford(cost, port, host)
if cost == INFINITY:
if self.POISON_MODE:
self.routing_tb[host] = [INFINITY, port, api.current_time()]
self.send(basics.RoutePacket(host, cost), port, flood=True)
elif host in self.routing_tb:
del self.routing_tb[host]
else:
self.routing_tb[host] = [cost, port, api.current_time()]
self.send(basics.RoutePacket(host, cost), port, flood=True)
def send_all_vectors_to(self, port):
"""
Sends all current distance vector information to the specified port
"""
for destination in self.distanceVectors:
minDistance = self.min_distance_to(destination)
# print("Attempting to send destination: " + str(destination) + "to port: " + str(port))
if (self.POISON_MODE or not self.is_infinity(minDistance)):
if self.passes_split_horizon(destination, port):
# print("Sent!")
self.send(basics.RoutePacket(destination, minDistance),
port)
elif self.POISON_MODE:
self.send(basics.RoutePacket(destination, INFINITY), port)
def handle_link_up(self, port, latency):
"""
Called by the framework when a link attached to this Entity goes up.
The port attached to the link and the link latency are passed
in.
"""
self.port_latency[port] = latency
for dest, info in self.router_table.items():
if (info[0] != port):
self.send(basics.RoutePacket(dest, info[1]), port)
elif (info[0] == port and self.POISON_MODE):
self.send(basics.RoutePacket(dest, INFINITY), port)
def handle_link_up(self, port, latency):
"""
Called by the framework when a link attached to this Entity goes up.
The port attached to the link and the link latency are passed
in.
"""
self.link[port] = latency
self.port_dst_lookup[port] = []
for dst in self.dst_latency_lookup:
pack = basics.RoutePacket(dst, self.dst_latency_lookup[dst])
self.send(pack, port)
pack = basics.RoutePacket(self, 0)
self.send(pack, port)
def handle_link_down(self, port):
"""
Called by the framework when a link attached to this Entity does down.
The port number used by the link is passed in.
"""
del self.neighbors[port]
del self.ports_latency[port]
for dst in self.paths.keys():
if self.paths[dst][0] == port:
del self.paths[dst]
if not self.POISON_MODE:
del self.dv[dst]
else:
self.dv[dst] = INFINITY
for dst in self.direct_paths.keys():
if self.direct_paths[dst] == port:
del self.direct_paths[dst]
if not self.POISON_MODE:
del self.dv[dst]
else:
self.dv[dst] = INFINITY
for neighbor in self.neighbors.keys():
for dst in self.dv.keys():
if self.paths.has_key(dst):
if self.paths[dst][0] == neighbor:
continue
self.send(basics.RoutePacket(dst, self.dv[dst]), neighbor)
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It
also might not be a bad place to check for whether any entries
have expired.
"""
for route in self.routes:
if (api.current_time() -
self.route_time[route]) > self.ROUTE_TIMEOUT:
self.log("%s (%s)",
api.current_time() - self.route_time[route],
api.current_time())
self.delete_route(route)
self.update_state(route[0])
for destination in self.dst_port_lookup:
self.update_neighbors(destination,
self.dst_port_lookup[destination],
self.dst_latency_lookup[destination])
for port in self.link:
pack = basics.RoutePacket(self, 0)
self.send(pack, port)
def handle_link_down(self, port):
"""
Called by the framework when a link attached to this Entity does down.
The port number used by the link is passed in.
"""
# self.log(" %s (%s)", port, api.current_time())
to_delete = []
del self.portLatency[port]
for d in self.neighborHosts.keys():
if self.neighborHosts[d][1] == port:
del self.neighborHosts[d]
for d in self.routeTablePort:
if self.routeTablePort[d] == port:
if d in self.neighborHosts:
self.routeTableLatency[d] = self.neighborHosts[d][0]
self.routeTablePort[d] = self.neighborHosts[d][1]
self.routeTableTime[d] = api.current_time()
self.send(basics.RoutePacket(d, self.routeTableLatency[d]),
port, True)
else:
to_delete.append(d)
self.sendPoison(port, d)
self.delete(to_delete)
def handle_link_up(self, port, latency):
self.neighbours[port] = latency #populates neighbours dictionary
for i in self.routeTable.keys():
self.send(basics.RoutePacket(i, self.routeTable[i][0]),
port,
flood=False)
"""
def handle_link_down (self, port):
"""
Called by the framework when a link attached to this Entity does down.
The port number used by the link is passed in.
"""
for dest in self.hosts.keys():
currPort = self.hosts[dest][0]
if currPort == port:
del self.hosts[dest]
deleteDests = set()
for dest in self.routesToDest:
currPort = self.routesToDest[dest][0]
if currPort == port:
if dest in self.hosts:
self.routesToDest[dest] = self.hosts[dest]
packet = basics.RoutePacket(dest, self.routesToDest[dest][1])
self.send(packet, self.routesToDest[dest][0], True)
else:
self.sendPoison(dest)
deleteDests.add(dest)
for dest in deleteDests:
del self.routesToDest[dest]
del self.neighbours[port]
def handle_rx(self, packet, port):
"""
Called by the framework when this Entity receives a packet.
packet is a Packet (or subclass).
port is the port number it arrived on.
You definitely want to fill this in.
"""
if isinstance(packet, basics.RoutePacket):
self.handle_route_packet(packet, port)
return
elif isinstance(packet, basics.HostDiscoveryPacket):
self.handle_host_discover_packet(packet, port)
return
else:
if not self.NO_LOG:
self.log("RX UNKNOWN %s on %s (%s)", packet, port,
api.current_time())
host = packet.dst
mapping = self.route_map.next_hop(host)
if mapping == DESTINATION_NOT_FOUND:
self.send(packet, port, flood=True)
return
next_hop = m_next_hop(mapping)
if next_hop != port:
self.send(packet, next_hop)
elif self.POISON_MODE:
# The correct route is sending the packet back to the port
# we received it on. We need to poison this route
poison_packet = basics.RoutePacket(host, INFINITY)
self.send(poison_packet, port)
def handle_link_down(self, port):
"""
Called by the framework when a link attached to this Entity does down.
The port number used by the link is passed in.
"""
# remove port from our remembered ports
if port in self.ports:
self.ports.pop(port)
to_be_removed = [] # to not mutate collection while iterating
for entity in self.table: # for entity in entities
if port == self.table[entity][
0]: # if I could reach that entity through this port
to_be_removed.append(entity) # remove that route from my table
if entity in self.neighboring_hosts: # if it is neighboring host
self.neighboring_hosts.remove(
entity) # remove from remembered neighboring hosts
if self.POISON_MODE:
# send poisoned packets to tell other routers that I can't reach that entity anymore
info = basics.RoutePacket(entity, INFINITY)
self.send(
info, port, flood=True
) # with flood=True packets are sent from all ports except listed
for entity in to_be_removed:
self.table.pop(entity)
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It
also might not be a bad place to check for whether any entries
have expired.
"""
# check through the routes and see if 15 seconds have passed if so remove route
expire = []
for dst in self.distance_table.keys():
self.distance_table[dst][2] += self.DEFAULT_TIMER_INTERVAL
if self.distance_table[dst][2] >= 15:
expire.append(dst)
for dst in expire:
if self.distance_table[dst][0] in self.port_table.keys(
) and self.port_table[self.distance_table[dst]
[0]] == self.distance_table[dst][1]:
self.distance_table[dst] = [
self.distance_table[dst][0], self.distance_table[dst][1], 0
]
else:
del self.distance_table[dst]
# send table to all neighbour except that using
for dst in self.distance_table.keys():
p = basics.RoutePacket(dst, self.distance_table[dst][1])
self.send(p, self.distance_table[dst][0], flood=True)
def handle_link_down(self, port):
"""
Called by the framework when a link attached to this Entity does down.
The port number used by the link is passed in.
"""
del self.ports_info[port]
nodes_to_delete = []
for dst in self.table.keys():
dst_info = self.table[dst]
if (port == dst_info[0]):
#change my cost to infinity
nodes_to_delete.append(dst)
if (self.POISON_MODE):
#iterate over all ports except given port and send infinitu to neighbours
for my_port in self.ports_info:
if (port != my_port):
r_packet = basics.RoutePacket(dst, INFINITY)
self.send(r_packet, my_port)
for node in nodes_to_delete:
del self.table[node]
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It also might
not be a bad place to check for whether any entries have expired.
"""
# if(self.counter <=1):
# print("in handle_timer router",self.counter)
# print("table ",self.table)
nodes_to_delete_for_timeout = []
for dest in self.table.keys():
for port in self.ports_info.keys():
time_now = time.time()
dest_info = self.table[dest]
if ((time_now - dest_info[2]) > 15 and dest_info[3] == True):
if (dest not in nodes_to_delete_for_timeout):
nodes_to_delete_for_timeout.append(dest)
else:
r_packet = basics.RoutePacket(dest, dest_info[1])
self.send(r_packet, port)
#not delete nodes for timeout
for node in nodes_to_delete_for_timeout:
# print("expired", node)
del self.table[node]
def handle_timer(self):
"""
Called periodically.
When called, your router should send tables to neighbors. It also might
not be a bad place to check for whether any entries have expired.
"""
dead_table = True
current_time = api.current_time()
for destination in self.table:
to_expire = []
for port in self.table[destination]:
if current_time - self.table[destination][port][1] > 15:
to_expire.append(port)
if destination not in self.hosts:
for port in to_expire:
del (self.table[destination][port])
self.poison(destination, port)
for destination in self.table:
port = self.best_path(destination)
if not (port == None):
dead_table = False
update_packet = basics.RoutePacket(
destination, self.table[destination][port][0])
self.send(update_packet, [port] + self.hosts.values(),
flood=True)
def send_updated_route_to_neighbours(self, destination, latency,
input_port):
#should i send update to neighbour from where it came from?
for port in self.ports_info.keys():
if (port != input_port):
r_packet = basics.RoutePacket(destination, latency)
self.send(r_packet, port)
