Cleans up node transmission code

pydtn/buffer.py

@@ -16,8 +16,9 @@ class Buffer:
         if self.used < self.capacity:
             self.used += 1
             self.buffer[packet] = None
+            return True
         else:
-            raise Exception('buffer full')
+            return False
 
     def remove(self, packet):
         self.used -= 1

pydtn/node.py

@@ -33,35 +33,51 @@ class Node(TickProcess):
 
         self.transfer_queue = Store(self.env)
 
-    def route_packets(self):
-        packets_to_delete = []
+    def route_packet(self, packet):
+        '''
+        Applies the routing heuristic to packet and queues packet for
+        transfer if requested
 
-        for packet in self.buffer:
-            # remove expired packets from buffer
-            if packet.expired(self.env.now):
-                packets_to_delete.append(packet)
-                continue
+        Returns:
+            True - if the packet should be deleted from the buffer
+            False - otherwise
+        '''
 
-            # ask the router what to do
-            targets, reason, delete = self.router(packet)
+        # check if packet has expired
+        if packet.expired(self.env.now):
+            return True
 
-            # check if there are targets to send to
-            if targets is None:
-                continue
+        # ask the router what to do
+        targets, reason, delete = self.router(packet)
 
-            # allow for targets to be iterable or single item
-            if not isinstance(targets, Iterable):
-                targets = [targets]
+        # check if there are targets to send to
+        if targets is None:
+            return False
+
+        # allow for targets to be iterable or single item
+        if not isinstance(targets, Iterable):
+            targets = [targets]
+
+        # add the packet to the transfer queue
+        self.transfer_queue.put((packet, targets, reason))
+
+        return delete
+
+    def route_packets(self):
+        '''
+        Applies the routing heuristic to all packets in the buffer and
+        queues transfers if requested. Additionally, removes packets
+        from the buffer if the packet has exipred or if the router
+        requests the packet to be removed.
+        '''
 
-            # add the packet to the transfer queue
-            self.transfer_queue.put((packet, targets, reason))
-            #self.send(targets, packet, reason)
+        packets_to_delete = []
 
-            # if the router requested deletion from the buffer do it
+        for packet in self.buffer:
+            delete = self.route_packet(packet)
             if delete:
                 packets_to_delete.append(packet)
 
-
         for packet in packets_to_delete:
             self.buffer.remove(packet)
 
@@ -70,6 +86,8 @@ class Node(TickProcess):
         while True:
             packet, targets, reason = yield self.transfer_queue.get()
 
+            failed = False
+
             # simulate transfer delay of packet
             delay = packet.size / self.bandwidth
             yield self.env.timeout(delay)
@@ -78,19 +96,44 @@ class Node(TickProcess):
             # simulates broadcast
             for target in targets:
                 # try sending packet
-                if self.network.send_link(self, target, packet):
+                if self.send(target, packet):
                     success.append(target)
                     self.router.on_send_success(target, packet)
                 else:
+                    failed = True
                     self.router.on_send_failure(target, packet)
 
             packet.send(self, success, reason=reason)
 
+            if failed:
+                delete = self.route_packet(packet)
+                if delete:
+                    self.buffer.remove(packet)
+
+    def send(self, target, packet):
+        '''
+        Instantly sends a packet to a target if they are connected.
+        Returns:
+            True - if successful
+            False - otherwise
+        '''
+        if self.connected_to(target):
+            return target.recv(packet)
+        else:
+            return False
+
     def recv(self, packet):
+        '''
+        Tells the node to recieve a packet.
+        Returns:
+            True - if the node was able to recieved the packet.
+            False - otherwise, triggered by buffer being full.
+        '''
         if packet.destination == self:
             packet.recv()
+            return True
         else:
-            self.buffer.add(packet)
+            return self.buffer.add(packet)
 
     @property
     def community(self):