def __repr__(self): d = self.data if d is not None: d = ': ' + str(d) else: d = '' return "<%s %s->%s ttl:%i%s>" % (type(self).__name__, api.get_name(self.src), api.get_name(self.dst), self.ttl, d)
def getOrigins(self, packet): src = api.get_name(packet.src) # RoutePacket uses "destination" instead of "dst" if isinstance(packet, basics.RoutePacket): dest = api.get_name(packet.destination) else: dest = api.get_name(packet.dst) return src, dest
def __repr__ (self): d = self.data if d is not None: d = ': ' + str(d) else: d = '' return "<%s %s->%s ttl:%i%s>" % (type(self).__name__, api.get_name(self.src), api.get_name(self.dst), self.ttl, d)
def handle_rx(self, packet, in_port): """ Called when a packet is received. You most certainly want to process packets here, learning where they're from, and either forwarding them toward the destination or flooding them. """ print("Entity:", api.get_name(self), "PACKET RECEIVED: ", packet, "ON PORT:", in_port) src, dest = self.getOrigins(packet) print("PACKET SRC:", src, "DEST:", dest, "TRACE:", packet.trace) # The source of the packet can obviously be reached via the input port, so # we should "learn" that the source host is out that port. If we later see # a packet with that host as the *destination*, we know where to send it! # But it's up to you to implement that. For now, we just implement a # simple hub. if isinstance(packet, basics.HostDiscoveryPacket): # Don't forward discovery messages if src not in self.rtable: print("UNKNOWN SOURCE") self.rtable[src] = in_port return # Sender is not known to switch if src not in self.rtable: print("UNKNOWN SOURCE") self.rtable[src] = in_port # destination properly defined and is not intended for this switch if dest and dest != api.get_name(self): if dest in self.rtable: # destination is a known route print("KNOWN ROUTE") self.send(packet, self.rtable[dest]) else: # destination is an unknown route print("FLOOD") self.send(packet, in_port, flood=True) else: print("packet has no destination or is... FOR ME!!")
def handle_rx(self, packet, in_port): if isinstance(packet, basics.RoutePacket): if self.block_route_packets: src = api.get_name(packet.src) api.userlog.debug('%s dropped a route packet from %s' % (self.name, src)) return return super(BlockingHub, self).handle_rx(packet, in_port)
def get_cell(self, x, y): """ return latency (cell value) in matrix given src(x) and dest(y) """ vector = self.get(x) if vector: try: return vector[api.get_name(y)] except KeyError as e: return None return None
def handle_rx(self, packet, in_port): """ Called when a packet is received. You most certainly want to process packets here, learning where they're from, and either forwarding them toward the destination or flooding them. """ # The source of the packet can obviously be reached via the input port, so # we should "learn" that the source host is out that port. If we later see # a packet with that host as the *destination*, we know where to send it! # But it's up to you to implement that. For now, we just implement a # simple hub. if isinstance(packet, basics.HostDiscoveryPacket): # Don't forward discovery messages return sender = packet.src sender_name = api.get_name(sender) if sender_name not in self.table: # Add sender to table self.table[sender_name] = in_port reciever = packet.dst reciever_name = api.get_name(reciever) if reciever_name in self.table: # Send packet to reciever's port reciever_port = self.table[reciever_name] packet.ttl -= 1 packet.trace.append(self) if packet.ttl != 0: self.send(packet, reciever_port) else: # Flood out all ports except the input port packet.ttl -= 1 packet.trace.append(self) self.send(packet, in_port, flood=True)
def get(self, x): try: vector = self.vectors[api.get_name(x)] return vector except KeyError as e: return None
def is_for_me(self, dest): return dest and dest == api.get_name(self)
def speak(self, msg): print ("\n%s says: %s\n" % (api.get_name(self.name), msg))
def __repr__(self): return "ForwardingTableEntry(dst={}, port={}, latency={})".format( get_name(self.dst), self.port, self.latency)
def __repr__(self): return "PeerTableEntry(dst={}, latency={}, expire_time={})".format( get_name(self.dst), self.latency, self.expire_time)