def run(self): print(threading.currentThread().getName() + ': Starting') while True: self.process_queues() if self.stop: print(threading.currentThread().getName() + ': Ending') return
def run(self): while not self.stoprequest.isSet(): try: filename = self.file_q.get() print("check " + filename) unknown = 0 known = 0 doc = load(filename) for page in doc: for zone in page: if zone.label.name == "unknown": unknown += 1 else: known += 1 delete = False if known + unknown == 0: delete = True factor = 0 else: factor = known / (known + unknown) except Queue.Empty: continue except SAXParseException: factor = 0 self.write_q.put('%s %4.3f\n' % (os.path.basename(filename), factor))
def run(self): print(threading.currentThread().getName() + ': Starting') while True: self.forward() if self.stop: print(threading.currentThread().getName() + ': Ending') return
def __init__(self, name, cost_D, max_queue_size): self.stop = False # for thread termination self.name = name # create a list of interfaces self.intf_L = [Interface(max_queue_size) for _ in range(len(cost_D))] # save neighbors and interfeces on which we connect to them self.cost_D = cost_D # {neighbor: {interface: cost}} self.rt_tbl_D = {} # {destination: {from-router: cost}} self.neighboring_routers = [self.name] for neighbor in self.cost_D: if Router.is_router( neighbor): # check to see if neighbor is a router self.neighboring_routers.append(neighbor) for destination in ["H1", "H2", "RA", "RB", "RC", "RD"]: for router in self.neighboring_routers: if destination not in self.rt_tbl_D: self.rt_tbl_D.update({destination: {router: "-"}}) else: self.rt_tbl_D[destination].update({router: "-"}) if router == self.name and destination in self.cost_D: for interface, cost in self.cost_D[destination].items(): self.rt_tbl_D[destination][router] = cost self.rt_tbl_D[self.name][self.name] = 0 print('%s: Initialized routing table' % self) self.print_routes()
def run(self): while not self.stoprequest.isSet(): try: filename = self.file_q.get() print("check " + filename) unknown = 0 known = 0 doc = load(filename) for page in doc: for zone in page: if zone.label.name == "unknown": unknown += 1 else: known += 1 delete = False if known+unknown == 0: delete = True factor = 0 else: factor = known / (known+unknown) except Queue.Empty: continue except SAXParseException: factor = 0 self.write_q.put('%s %4.3f\n' % (os.path.basename(filename), factor))
def forward_packet(self, p, i): last_hop = False # flag to determine whether this is the last hop before destination cost_to_dst = self.rt_tbl_D[p.dst][self.name] next_hop_out_intf = None # checks if we're at last hop before destination and if so sets appropriate out intf if p.dst in self.cost_D and cost_to_dst == self.rt_tbl_D[p.dst][ self.name]: next_hop_out_intf = list(self.cost_D[p.dst])[0] last_hop = True # if it's not the last hop before the destination, it determines the out intf of the next hop to reach dst if not last_hop: for neighbor in self.cost_D: if neighbor not in self.rt_tbl_D[p.dst]: continue if self.rt_tbl_D[p.dst][neighbor] + self.rt_tbl_D[neighbor][ self.name] == cost_to_dst: next_hop_out_intf = list(self.cost_D[neighbor])[0] if next_hop_out_intf is None: return # something went wrong, there is no hop that matches routing table try: self.intf_L[next_hop_out_intf].put(p.to_byte_S(), 'out', True) print('%s: forwarding packet "%s" from interface %d to %d' % \ (self, p, i, next_hop_out_intf)) except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, i)) pass
def run(self): print (threading.currentThread().getName() + ': Starting') while True: #transfer one packet on all the links self.transfer() #terminate if self.stop: print (threading.currentThread().getName() + ': Ending') return
def run(self): print(threading.currentThread().getName() + ': Starting') while True: # receive data arriving to the in interface self.udt_receive() # terminate if (self.stop): print(threading.currentThread().getName() + ': Ending') return
def tic(self): tic = 0 print("tic " + str(tic)) sleep(1) while tic < 13: for arm in self.arms: arm.nextTic() print("tic " + str(tic)) tic += 1 sleep(self.tic_time)
def forward_packet(self, p, i): try: # TODO: Here you will need to implement a lookup into the # forwarding table to find the appropriate outgoing interface # for now we assume the outgoing interface is 1 self.intf_L[1].put(p.to_byte_S(), 'out', True) print('%s: forwarding packet "%s" from interface %d to %d' % \ (self, p, i, 1)) except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, i)) pass
def udt_receive(self): pkt_S = self.in_intf_L[0].get() if pkt_S is not None: if pkt_S[5] == '0': self.out += pkt_S[5:] else: dst = pkt_S[:5] self.out = dst + self.out + pkt_S[6:] print('%s: received packet "%s" on the in interface' % (self, self.out)) self.out = ''
def send_routes(self, i): to_send = {"from": self.name, "rt_tbl": self.rt_tbl_D} json_to_send = json.dumps(to_send) p = NetworkPacket(0, 'control', json_to_send) # create a routing table update packet try: print('%s: sending routing update "%s" from interface %d' % (self, p, i)) self.intf_L[i].put(p.to_byte_S(), 'out', True) except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, i)) pass
def udt_send(self, dst_addr, data_S): # splits up packet into two pieces to be able to forward them through the host's out interface packet_len = len(data_S) // 2 p = NetworkPacket(dst_addr, data_S[:packet_len]) print('%s: sending packet "%s" on the out interface with mtu=%d' % (self, p, self.out_intf_L[0].mtu)) self.out_intf_L[0].put( p.to_byte_S()) # send packets always enqueued successfully p = NetworkPacket(dst_addr, data_S[packet_len:]) print('%s: sending packet "%s" on the out interface with mtu=%d' % (self, p, self.out_intf_L[0].mtu)) self.out_intf_L[0].put( p.to_byte_S()) # send packets always enqueued successfully
def update_routes(self, p, i): print('%s: Received routing update %s from interface %d' % (self, p, i)) update = False # flag to check if there has been an update to current router's cost to destinations src_router = json.loads( p.data_S)["from"] # src of router who sent updated routing table rcvd_rt_tbl = json.loads(p.data_S)["rt_tbl"] # received routing table # iterates over every destination in received routing table for destination in rcvd_rt_tbl: # if there isn't a cost for that destination move onto next destination if rcvd_rt_tbl[destination][src_router] == "-": continue # update the destination costs for the src router in the routing table self.rt_tbl_D[destination][src_router] = rcvd_rt_tbl[destination][ src_router] # calculate the cost to the destination taking into account the new received cost from src router rcvd_cost_to_dest = int( self.rt_tbl_D[src_router][self.name]) + int( rcvd_rt_tbl[destination][src_router]) curr_cost_to_dest = float( 'inf') # sets default current cost to infinity # updates current cost if there is an actual cost saved if destination in self.rt_tbl_D and self.rt_tbl_D[destination][ self.name] != "-": curr_cost_to_dest = int(self.rt_tbl_D[destination][self.name]) # calcualtes new cost to destination by taking the min value of the received cost to destination and the # current cost to destination new_cost_to_dest = min(curr_cost_to_dest, rcvd_cost_to_dest) # if the new cost is different, it updates the routing table and sets the update flag to True if new_cost_to_dest != curr_cost_to_dest: self.rt_tbl_D[destination][self.name] = new_cost_to_dest update = True # checks if there were any updates, if so it sends new routes to all neighboring routers if update: for neighbor in self.cost_D: if Router.is_router(neighbor): out_intf = list(self.cost_D[neighbor])[0] self.send_routes(out_intf)
def forward(self): for i in range(len(self.in_intf_L)): pkt_S = None try: # get packet from interface i pkt_S = self.in_intf_L[i].get() # if packet exists make a forwarding decision if pkt_S is not None: p = NetworkPacket.from_byte_S(pkt_S) # parse a packet out print('%s: forwarding packet "%s" from interface %d to %d with mtu %d' \ % (self, p, i, i, self.out_intf_L[i].mtu)) self.out_intf_L[i].put(p.to_byte_S()) except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, i)) pass
def udt_send(self, dst_addr, data_S): data = data_S while len(data) > 44: p = NetworkPacket(dst_addr, '0', data[:44]) data = data[44:] print('%s: sending packet "%s" on the out interface with mtu=%d' % (self, p, self.out_intf_L[0].mtu)) self.out_intf_L[0].put( p.to_byte_S()) # send packets always enqueued successfully p = NetworkPacket(dst_addr, '1', data) print('%s: sending packet "%s" on the out interface with mtu=%d' % (self, p, self.out_intf_L[0].mtu)) self.out_intf_L[0].put( p.to_byte_S()) # send packets always enqueued successfully
def forward_packet(self, p, i): try: # TODO: Here you will need to implement a lookup into the # forwarding table to find the appropriate outgoing interface # for now we assume the outgoing interface is 1 interface = self.fwd_tbl_D[p.dst] self.intf_L[interface].put(p.to_byte_S(), 'out', True) # I removed the 'to interface %d' portion of the below print because I could find no way to # determine the interface it would be arriving on at the next router/host print('%s: forwarding packet "%s" on interface %d' % \ (self, p, interface)) except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, i)) pass
def udt_receive(self): pkt_S = self.in_intf_L[0].get() # if there's an incoming packet start building up fragmented packets into a buffer until all fragments have # been received, then print packet that and clear said buffer if pkt_S is not None: frag_pkt = NetworkPacket.from_byte_S(pkt_S) pkt_id = int(frag_pkt.pkt_id) if pkt_id in self.frag_pkt_buffer.keys(): self.frag_pkt_buffer[pkt_id].append(frag_pkt.data_S) else: self.frag_pkt_buffer[pkt_id] = [frag_pkt.data_S] if frag_pkt.frag_flag == "0": frag_list = self.frag_pkt_buffer[pkt_id] del self.frag_pkt_buffer[pkt_id] print('%s: received packet "%s" on the in interface' % (self, ''.join(frag_list)))
def print_routes(self): table = "╒══════╤══════╤══════╤══════╤══════╤══════╤══════╕\n│ " table += self.name table += " │" for destination in ["H1", "H2", "RA", "RB", "RC", "RD"]: table += " " + destination + " │" table += "\n╞══════╪══════╪══════╪══════╪══════╪══════╪══════╡\n" for router in self.neighboring_routers: table += "│ " + router + " │" for destination in ["H1", "H2", "RA", "RB", "RC", "RD"]: table += " " table += str(self.rt_tbl_D[destination][router]) table += " │" table += "\n├──────┼──────┼──────┼──────┼──────┼──────┼──────┤\n" print(table)
def udt_receive(self): pkt_S = self.in_intf_L[0].get() if pkt_S is not None: pkt = NetworkPacket.from_byte_S(pkt_S) if(pkt.fragment == 1): print('%s: received packet segment on the in interface' % (self)) if(pkt.offset == 0): self.pkt = NetworkPacket(pkt.dst_addr, pkt.data_S, pkt.pktID, 0, 1, pkt.src_addr) else: self.pkt = NetworkPacket(pkt.dst_addr, (self.pkt.data_S + pkt.data_S), pkt.pktID, 0, 1, pkt.src_addr) else: if(self.pkt is not None): self.pkt = NetworkPacket(pkt.dst_addr, (self.pkt.data_S + pkt.data_S), pkt.pktID, 0, 0, pkt.src_addr) else: self.pkt = pkt print('%s: received packet "%s" on the in interface' % (self, self.pkt.to_byte_S())) self.pkt = None
def update_routes(self, p, i): #TODO: add logic to update the routing tables and # possibly send out routing updates print('%s: Received routing update %s from interface %d' % (self, p, i)) routing_table_msg = pickle.loads(p.data_S.encode('latin1')) # examine incoming routing table for destination in routing_table_msg: # find unknown destinations if destination not in self.rt_tbl_D.keys(): self.rt_tbl_D[destination] = {self.name: 0} self.fwd_tbl_D[ destination] = 99 # placeholder value until next-hop is known # examine known routers in incoming routing table for router in routing_table_msg[destination]: if router in self.cost_D.keys(): # router is a neighbor of self self.rt_tbl_D[destination][router] = routing_table_msg[ destination][router] for rt_tbl_destination in self.rt_tbl_D: if rt_tbl_destination not in routing_table_msg.keys(): self.rt_tbl_D[rt_tbl_destination][router] = 0 # Bellman-Ford equation for destination in self.rt_tbl_D: if destination != self.name: prev_value = self.rt_tbl_D[destination][self.name] min_cost = self.rt_tbl_D[destination][self.name] min_cost_next_hop = None for router in self.rt_tbl_D[destination]: if router != self.name and self.rt_tbl_D[destination][ router] != 0: # look at every other known router in network cost_to_dest = self.rt_tbl_D[router][ self.name] + self.rt_tbl_D[destination][router] if min_cost == 0 or cost_to_dest < min_cost: min_cost = cost_to_dest min_cost_next_hop = router if min_cost != prev_value: # cost value has changed self.rt_tbl_D[destination][self.name] = min_cost for interface in self.cost_D[min_cost_next_hop]: self.fwd_tbl_D[destination] = interface break self.send_routes()
def forward(self): for i in range(len(self.in_intf_L)): pkt_S = None try: # get packet from interface i pkt_S = self.in_intf_L[i].get() # if packet exists make a forwarding decision if pkt_S is not None: p = NetworkPacket.from_byte_S(pkt_S) # parse a packet out # HERE you will need to implement a lookup into the # forwarding table to find the appropriate outgoing interface # for now we assume the outgoing interface is also i print('%s: forwarding packet "%s" from interface %d to %d with mtu %d' \ % (self, p, i, i, self.out_intf_L[i].mtu)) self.out_intf_L[i].put(p.to_byte_S()) except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, i)) pass
def tx_pkt(self): for (node_a, node_a_intf, node_b, node_b_intf) in \ [(self.node_1, self.node_1_intf, self.node_2, self.node_2_intf), (self.node_2, self.node_2_intf, self.node_1, self.node_1_intf)]: intf_a = node_a.intf_L[node_a_intf] intf_b = node_b.intf_L[node_b_intf] pkt_S = intf_a.get('out') if pkt_S is None: continue #continue if no packet to transfer #otherwise transmit the packet try: intf_b.put(pkt_S, 'in') print('%s: direction %s-%s -> %s-%s: transmitting packet "%s"' % \ (self, node_a, node_a_intf, node_b, node_b_intf, pkt_S)) except queue.Full: print('%s: direction %s-%s -> %s-%s: packet lost' % \ (self, node_a, node_a_intf, node_b, node_b_intf)) pass
def forward(self): for i in range(len(self.in_intf_L)): pkt_S = None try: # get packet from interface i pkt_S = self.in_intf_L[i].get() # if packet exists make a forwarding decision if pkt_S is not None: p = NetworkPacket.from_byte_S(pkt_S) # parse a packet out output_intf_num = self.table.getOutIntfNum(p.dst_addr, self.name, p.src_addr, i) mtu = self.out_intf_L[output_intf_num].mtu #print("output intf: " + str(output_intf_num)) if(output_intf_num == -1): print('%s: packet "%s" lost on interface %d' % (self, p, i)) return if(len(p) > mtu): if(mtu <= NetworkPacket.header_S_length): print('%s: MTU on interface %d too small to transmit (mtu=%d)' % (self, i, mtu)) continue pktID = p.pktID offset = p.offset frag = 1 dst_addr = p.dst_addr self.pktData = p.data_S div = mtu - (NetworkPacket.header_S_length) numPkt = math.ceil(len(self.pktData)/div) for j in range(0, numPkt): if((p.fragment == 0) and (j == (numPkt-1))): frag = 0 fwdP = NetworkPacket(dst_addr, self.pktData[(div*(j)):(div*(j+1))], pktID, offset, frag) print('%s: forwarding packet segment "%s" from interface %d to %d with mtu %d' \ % (self, fwdP, i, output_intf_num, mtu)) self.out_intf_L[output_intf_num].put(fwdP.to_byte_S()) offset += div else: print('%s: forwarding packet "%s" from interface %d to %d with mtu %d' \ % (self, p, i, output_intf_num, mtu)) self.out_intf_L[output_intf_num].put(p.to_byte_S()) except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, i)) pass
def forward(self): for i in range(len(self.in_intf_L)): pkt_S = None try: # get packet from interface i pkt_S = self.in_intf_L[i].get() # if packet exists make a forwarding decision if pkt_S is not None: p = NetworkPacket.from_byte_S(pkt_S) # parse a packet out fwd_out_intf = self.routing_table.get(int( p.dst_addr)) # lookup forwarding out interface num if fwd_out_intf is None: print( "There is no forwarding information for such destination." ) continue # calculate max load of data interface can handle max_load = self.out_intf_L[ fwd_out_intf].mtu - NetworkPacket.header_length buffer = p.data_S # begin fragmentation if current packet's data length exceeds max load if len(buffer) > max_load: frag_flag = 1 frag_offset = 0 buffer = p.data_S # iterates over buffer sending packet fragments until end of packet while len(buffer) > 0: if len( buffer ) <= max_load: # checks if last fragment in packet frag_flag = 0 # creates fragment packet and forwards fragment frag_pkt = NetworkPacket(p.dst_addr, buffer[:max_load], p.pkt_id, frag_flag, frag_offset) print('%s: forwarding packet "%s" from interface %d to %d with mtu %d' \ % (self, frag_pkt, i, fwd_out_intf, self.out_intf_L[fwd_out_intf].mtu)) self.out_intf_L[fwd_out_intf].put( frag_pkt.to_byte_S()) buffer = buffer[max_load:] frag_offset += len(buffer[:max_load]) # otherwise just forward packet else: print('%s: forwarding packet "%s" from interface %d to %d with mtu %d' \ % (self, p, i, fwd_out_intf, self.out_intf_L[fwd_out_intf].mtu)) self.out_intf_L[fwd_out_intf].put(p.to_byte_S()) except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, i)) pass
def send_routes(self): # TODO: Send out a routing table update #create a routing table update packet routing_table_bytes = pickle.dumps(self.rt_tbl_D) p = NetworkPacket(0, 'control', routing_table_bytes.decode('latin1')) for neighbor in self.cost_D: if (neighbor.startswith('R')): # sends updates to all neighbors that are routers for interface in self.cost_D[neighbor]: try: print( '%s: sending routing update "%s" from interface %d' % (self, p, int(interface))) self.intf_L[int(interface)].put( p.to_byte_S(), 'out', True) except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, int(interface))) pass
def udt_send(self, dst_addr, data_S): mtu = self.out_intf_L[0].mtu if (len(data_S) > mtu): offset = 0 frag = 1 div = mtu - (NetworkPacket.header_S_length) numPkt = math.ceil(len(data_S) / div) print( '%s: segmenting packet "%s" into %s packets for the out interface with mtu=%d' % (self, data_S, numPkt, mtu)) for i in range(0, numPkt): if (i == (numPkt - 1)): frag = 0 p = NetworkPacket(dst_addr, data_S[offset:(offset + div)], self.pktID, offset, frag) print( '%s: sending packet "%s" on the out interface with mtu=%d' % (self, p, mtu)) self.out_intf_L[0].put(p.to_byte_S()) offset += div #print('%s: packet dropped; too large: length of %s on the out interface with mtu=%d' % (self, str(len(data_S)), mtu)) else: p = NetworkPacket(dst_addr, data_S) print('%s: sending packet "%s" on the out interface with mtu=%d' % (self, p, mtu)) self.out_intf_L[0].put( p.to_byte_S()) # send packets always enqueued successfully self.pktID += 1
def getLinks(self, table): l = '' self.links = [] for i in range(0, len(self.hops)-1): link = -1 if(i == 0): link = table.getLink(int(self.hops[i]), str(self.hops[i+1])) self.links.append(link) l += str(link.from_node) + "->" elif(i == (len(self.hops)-2)): link = table.getLink(str(self.hops[i]), int(self.hops[i+1])) self.links.append(link) l += str(self.links[-1].to_node) else: link = table.getLink(str(self.hops[i]), str(self.hops[i+1])) if(link != -1): self.links.append(link) l += str(link.to_node) + "->" if(link != -1): mtu = link.in_intf.mtu self.mtu = mtu if mtu < self.mtu else (self.mtu if self.mtu != 0 else mtu) print("Route: " + str(self) + " initialized with links: " + l + " with MTU=" + str(self.mtu))
def __init__(self, name, cost_D, max_queue_size): self.stop = False #for thread termination self.name = name #create a list of interfaces self.intf_L = [Interface(max_queue_size) for _ in range(len(cost_D))] #save neighbors and interfaces on which we connect to them self.cost_D = cost_D # {neighbor: {interface: cost}} #TODO: set up the routing table for connected hosts self.rt_tbl_D = {} # {destination: {router: cost}} self.fwd_tbl_D = {} # {destination: interface} for neighbor in cost_D: for interface in cost_D[neighbor]: self.rt_tbl_D[neighbor] = { self.name: cost_D[neighbor][interface] } # initialize forwarding table with neighbors self.fwd_tbl_D[neighbor] = interface # add self to routing table self.rt_tbl_D[self.name] = {self.name: 0} print('%s: Initialized routing table' % self) self.print_routes()
def forward(self): for i in range(len(self.in_intf_L)): mtu = self.out_intf_L[i].mtu pkt_S = None try: # get packet from interface i pkt_S = self.in_intf_L[i].get() # if packet exists make a forwarding decision if pkt_S is not None: p = NetworkPacket.from_byte_S(pkt_S) # parse a packet out if (len(p) > mtu): if (mtu <= NetworkPacket.header_S_length): print( '%s: MTU on interface %d too small to transmit (mtu=%d)' % (self, i, mtu)) continue pktID = p.pktID offset = p.offset frag = 1 dst_addr = p.dst_addr self.pktData = p.data_S div = mtu - (NetworkPacket.header_S_length) numPkt = math.ceil(len(self.pktData) / div) for j in range(0, numPkt): if ((p.fragment == 0) and (j == (numPkt - 1))): frag = 0 fwdP = NetworkPacket( dst_addr, self.pktData[(div * (j)):(div * (j + 1))], pktID, offset, frag) print('%s: forwarding packet segment "%s" from interface %d to %d with mtu %d' \ % (self, fwdP, i, i, self.out_intf_L[i].mtu)) self.out_intf_L[i].put(fwdP.to_byte_S()) offset += div else: print('%s: forwarding packet "%s" from interface %d to %d with mtu %d' \ % (self, p, i, i, self.out_intf_L[i].mtu)) self.out_intf_L[i].put(p.to_byte_S()) # HERE you will need to implement a lookup into the # forwarding table to find the appropriate outgoing interface # for now we assume the outgoing interface is also i except queue.Full: print('%s: packet "%s" lost on interface %d' % (self, p, i)) pass
def tx_pkt(self): pkt_S = self.in_intf.get() if pkt_S is None: return # return if no packet to transfer if len(pkt_S) > self.in_intf.mtu: print('%s: packet "%s" length greater than the from interface MTU (%d)' % (self, pkt_S, self.in_intf.mtu)) return # return without transmitting if packet too big if len(pkt_S) > self.out_intf.mtu: print('%s: packet "%s" length greater than the to interface MTU (%d)' % (self, pkt_S, self.out_intf.mtu)) return # return without transmitting if packet too big # otherwise transmit the packet try: self.out_intf.put(pkt_S) print('%s: transmitting packet "%s"' % (self, pkt_S)) except queue.Full: print('%s: packet lost' % (self)) pass
factor = 0 else: factor = known / (known+unknown) except Queue.Empty: continue except SAXParseException: factor = 0 self.write_q.put('%s %4.3f\n' % (os.path.basename(filename), factor)) def join(self): self.stoprequest.set() super(CheckThread, self).join() if len(sys.argv) != 3: print("Usage: remove_empty.py /path/to/xml/directory") exit(1) dir_path = sys.argv[2] all_files = [] for root, _, files in os.walk(dir_path): for filename in files: all_files.append(root + filename) print("number of all files: %d" % len(all_files)) for file in all_files: file_q.put(file) check_threads_pool = [CheckThread(write_q, file_q) for _ in xrange(0,10)] for thread in pool: