assert, unicast routing update... not tested (just for backup)

CustomTimer/RemainingTimer.py

+from time import time
+
+try:
+    from threading import _Timer as Timer
+except ImportError:
+    from threading import Timer
+
+class RemainingTimer(Timer):
+    def __init__(self, interval, function):
+        super().__init__(interval, function)
+        self.start_time = time()
+
+    def time_remaining(self):
+        delta_time = time() - self.start_time
+        return self.interval - delta_time
+
+
+'''
+def test():
+    print("ola")
+
+x = RemainingTimer(10, test)
+x.start()
+from time import sleep
+for i in range(0, 10):
+    print(x.time_remaining())
+    sleep(1)
+'''

Interface.py

@@ -15,6 +15,7 @@ class Interface(object):
     def __init__(self, interface_name: str):
         self.interface_name = interface_name
         ip_interface = netifaces.ifaddresses(interface_name)[netifaces.AF_INET][0]['addr']
+        self.ip_mask_interface = netifaces.ifaddresses(interface_name)[netifaces.AF_INET][0]['netmask']
         self.ip_interface = ip_interface
 
         s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_PIM)

InterfacePIM.py

@@ -125,7 +125,10 @@ class InterfacePim(Interface):
 
     def get_neighbor(self, ip):
         with self.neighbors_lock.genRlock():
+            if ip in self.neighbors:
                 return self.neighbors[ip]
+            else:
+                return None
 
     def remove_neighbor(self, ip):
         with self.neighbors_lock.genWlock():

Kernel.py

@@ -3,6 +3,9 @@ import struct
 import netifaces
 import threading
 import traceback
+
+import ipaddress
+
 from RWLock.RWLock import RWLockWrite
 import Main
 
@@ -364,8 +367,15 @@ class Kernel:
                 return None
 
 
-    def neighbor_removed(self, interface_name, neighbor_ip):
+    def notify_unicast_changes(self, subnet):
         # todo
+        with self.rwlock.genWlock():
+            for (source_ip, group) in self.routing.keys():
+                source_ip_obj = ipaddress.ip_address(source_ip)
+                if source_ip_obj in subnet:
+                    self.routing[(source_ip, group)].network_update()
+                    print(source_ip)
+
         pass
 
 

Main.py

@@ -173,7 +173,7 @@ def list_routing_state():
     routing_entries = kernel.routing.values()
     vif_indexes = kernel.vif_index_to_name_dic.keys()
 
-    t = PrettyTable(['SourceIP', 'GroupIP', 'Interface', 'PruneState', 'AssertState', "Is Forwarding?"])
+    t = PrettyTable(['SourceIP', 'GroupIP', 'Interface', 'PruneState', 'AssertState', 'LocalMembership', "Is Forwarding?"])
     for entry in routing_entries:
         ip = entry.source_ip
         group = entry.group_ip
@@ -182,19 +182,21 @@ def list_routing_state():
         for index in vif_indexes:
             interface_state = entry.interface_state[index]
             interface_name = kernel.vif_index_to_name_dic[index]
-            is_forwarding = interface_state.is_forwarding()
+            local_membership = type(interface_state._local_membership_state).__name__
             try:
                 if index != upstream_if_index:
                     prune_state = type(interface_state._prune_state).__name__
                     assert_state = type(interface_state._assert_state).__name__
+                    is_forwarding = interface_state.is_forwarding()
                 else:
                     prune_state = type(interface_state._graft_prune_state).__name__
                     assert_state = "-"
+                    is_forwarding = "upstream"
             except:
                 prune_state = "-"
                 assert_state = "-"
 
-            t.add_row([ip, group, interface_name, prune_state, assert_state, is_forwarding])
+            t.add_row([ip, group, interface_name, prune_state, assert_state, local_membership, is_forwarding])
     return str(t)
 
 
@@ -222,3 +224,6 @@ def main():
 
     global igmp
     igmp = IGMP()
+
+    global u
+    u = UnicastRouting.UnicastRouting()

Neighbor.py

@@ -2,6 +2,7 @@ from threading import Timer
 import time
 from utils import HELLO_HOLD_TIME_NO_TIMEOUT, HELLO_HOLD_TIME_TIMEOUT, TYPE_CHECKING
 from threading import Lock
+from RWLock.RWLock import RWLockWrite
 import Main
 if TYPE_CHECKING:
     from InterfacePIM import InterfacePim
@@ -24,6 +25,10 @@ class Neighbor:
         self.time_of_last_update = time.time()
         self.neighbor_lock = Lock()
 
+        self.tree_interface_nlt_subscribers = []
+        self.tree_interface_nlt_subscribers_lock = RWLockWrite()
+
+
         # send hello to new neighbor
         #self.contact_interface.send_hello()
         # todo RANDOM DELAY??? => DO NOTHING... EVENTUALLY THE HELLO MESSAGE WILL BE SENT
@@ -71,11 +76,14 @@ class Neighbor:
 
         del self.contact_interface.neighbors[self.ip]
 
+        # notify interfaces which have this neighbor as AssertWinner
+        with self.tree_interface_nlt_subscribers_lock.genRlock():
+            for tree_if in self.tree_interface_nlt_subscribers:
+                tree_if.assert_winner_nlt_expires()
+
+
     def reset(self):
-        interface_name = self.contact_interface.interface_name
-        neighbor_ip = self.ip
-        Main.kernel.neighbor_removed(interface_name, neighbor_ip)
-        # todo new neighbor
+        return
 
 
     def receive_hello(self, generation_id, hello_hold_time):
@@ -85,3 +93,15 @@ class Neighbor:
             self.time_of_last_update = time.time()
             self.set_generation_id(generation_id)
             self.set_hello_hold_time(hello_hold_time)
+
+
+
+    def subscribe_nlt_expiration(self, tree_if):
+        with self.tree_interface_nlt_subscribers_lock.genWlock():
+            if tree_if not in self.tree_interface_nlt_subscribers:
+                self.tree_interface_nlt_subscribers.append(tree_if)
+
+    def unsubscribe_nlt_expiration(self, tree_if):
+        with self.tree_interface_nlt_subscribers_lock.genWlock():
+            if tree_if in self.tree_interface_nlt_subscribers:
+                self.tree_interface_nlt_subscribers.remove(tree_if)

Packet/PacketPimAssert.py

@@ -2,6 +2,7 @@ import struct
 import socket
 from Packet.PacketPimEncodedGroupAddress import PacketPimEncodedGroupAddress
 from Packet.PacketPimEncodedUnicastAddress import PacketPimEncodedUnicastAddress
+from tree.globals import ASSERT_CANCEL_METRIC
 '''
  0                   1                   2                   3
  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -29,12 +30,15 @@ class PacketPimAssert:
     PIM_HDR_ASSERT_v4_LEN = struct.calcsize(PIM_HDR_ASSERT_v4)
     PIM_HDR_ASSERT_v6_LEN = struct.calcsize(PIM_HDR_ASSERT_v6)
 
-    def __init__(self, multicast_group_address: str or bytes, source_address: str or bytes, metric_preference, metric):
+    def __init__(self, multicast_group_address: str or bytes, source_address: str or bytes, metric_preference: int, metric: int or float):
         if type(multicast_group_address) is bytes:
             multicast_group_address = socket.inet_ntoa(multicast_group_address)
         if type(source_address) is bytes:
             source_address = socket.inet_ntoa(source_address)
-
+        if metric_preference > ASSERT_CANCEL_METRIC:
+            metric_preference = ASSERT_CANCEL_METRIC
+        if metric > ASSERT_CANCEL_METRIC:
+            metric = ASSERT_CANCEL_METRIC
         self.multicast_group_address = multicast_group_address
         self.source_address = source_address
         self.metric_preference = metric_preference

Packet/PacketPimHeader.py

@@ -65,9 +65,10 @@ class PacketPimHeader(PacketPayload):
             raise Exception
 
         msg_to_checksum = data[0:2] + b'\x00\x00' + data[4:]
-        print("checksum calculated: " + str(checksum(msg_to_checksum)))
         if checksum(msg_to_checksum) != rcv_checksum:
             print("wrong checksum")
+            print("checksum calculated: " + str(checksum(msg_to_checksum)))
+            print("checksum recv: " + str(rcv_checksum))
             raise Exception
 
         pim_payload = data[PacketPimHeader.PIM_HDR_LEN:]

UnicastRouting.py

+from queue import Queue
+from threading import Thread
+
 from pyroute2 import IPDB, IPRoute
 import socket
+import RWLock
+import Main
+import ipaddress
 
-#ipdb = IPDB()
-ipr = IPRoute()
 
 def get_route(ip_dst: str):
-    with IPDB() as ipdb:
+    return UnicastRouting.get_route(ip_dst)
+
+def get_metric(ip_dst: str):
+    return UnicastRouting.get_metric(ip_dst)
+
+def check_rpf(ip_dst):
+    return UnicastRouting.check_rpf(ip_dst)
+
+
+class UnicastRouting(object):
+    ipr = None
+    ipdb = None
+
+    def __init__(self):
+        self.event_queue = Queue(maxsize=0)
+
+
+        UnicastRouting.ipr = IPRoute()
+        UnicastRouting.ipdb = IPDB()
+        self._ipdb = UnicastRouting.ipdb
+        self._ipdb.register_callback(UnicastRouting.unicast_changes)
+        #self.working = True
+        #self.worker_thread = Thread(target=self.worker)
+        #self.worker_thread.daemon = True
+        #self.worker_thread.start()
+
+
+    @staticmethod
+    def get_route(ip_dst: str):
+        ipdb = UnicastRouting.ipdb
+
         ip_bytes = socket.inet_aton(ip_dst)
         ip_int = int.from_bytes(ip_bytes, byteorder='big')
         info = None
@@ -25,15 +59,16 @@ def get_route(ip_dst: str):
         return info
 
 
-# get metrics (routing preference and cost) to IP ip_dst
-def get_metric(ip_dst: str):
-    unicast_routing_entry = get_route(ip_dst)
+    # get metrics (routing preference and cost) to IP ip_dst
+    @staticmethod
+    def get_metric(ip_dst: str):
+        unicast_routing_entry = UnicastRouting.get_route(ip_dst)
         entry_protocol = unicast_routing_entry["proto"]
         entry_cost = unicast_routing_entry["priority"]
         return (entry_protocol, entry_cost)
 
-"""
-def get_rpf(ip_dst: str):
+    """
+    def get_rpf(ip_dst: str):
         unicast_routing_entry = get_route(ip_dst)
         #interface_oif = unicast_routing_entry['oif']
         if not unicast_routing_entry['multipath']:
@@ -55,23 +90,83 @@ def get_rpf(ip_dst: str):
             if interface['family'] == socket.AF_INET:
                 return interface['address']
         return None
-"""
+    """
 
-# get output interface IP, used to send data to IP ip_dst
-# (root interface IP to ip_dst)
-def check_rpf(ip_dst):
+    # get output interface IP, used to send data to IP ip_dst
+    # (root interface IP to ip_dst)
+    @staticmethod
+    def check_rpf(ip_dst):
         # obter index da interface
         # rpf_interface_index = ipr.get_routes(family=socket.AF_INET, dst=ip)[0]['attrs'][2][1]
         # interface_name = if_indextoname(rpf_interface_index)
         # return interface_name
 
         # obter ip da interface de saida
-    rpf_interface_source = ipr.get_routes(family=socket.AF_INET, dst=ip_dst)[0]['attrs'][3][1]
+        rpf_interface_source = UnicastRouting.ipr.get_routes(family=socket.AF_INET, dst=ip_dst)[0]['attrs'][3][1]
         return rpf_interface_source
 
 
-"""
-def get_metric(ip_dst: str):
+    @staticmethod
+    def unicast_changes(ipdb, msg, action):
+        #unicast_event = QueueItem(ipdb, msg, action)
+        #self.event_queue.put(unicast_event)
+        print("unicast change?")
+        print(action)
+        UnicastRouting.ipdb = ipdb
+        if action == "RTM_NEWROUTE" or action == "RTM_DELROUTE":
+            print(ipdb.routes)
+            mask_len = msg["dst_len"]
+            network_address = None
+            attrs = msg["attrs"]
+            print(attrs)
+            for (key, value) in attrs:
+                print((key,value))
+                if key == "RTA_DST":
+                    network_address = value
+                    break
+            if network_address is None:
+                network_address = "0.0.0.0"
+            print(network_address)
+            print(mask_len)
+            print(network_address + "/" + str(mask_len))
+            subnet = ipaddress.ip_network(network_address + "/" + str(mask_len))
+            print(str(subnet))
+            #Main.kernel.notify_unicast_changes(subnet)
+        elif action == "RTM_NEWADDR" or action == "RTM_DELADDR":
+            print("a")
+
+    '''
+    def worker(self):
+        global ipdb
+        while self.working:
+            item = self.event_queue.get()
+            ipdb = item.ipdb
+            if item.action == "RTM_NEWROUTE" or item.action == "RTM_DELROUTE":
+                mask_len = item.action["dst_len"]
+                network_address = None
+                attrs = item.action["attrs"]
+                for (key, value) in attrs:
+                    if key == "RTA_DST":
+                        network_address = value
+                        break
+                subnet = ipaddress.ip_network(network_address + "/" + mask_len)
+                Main.kernel.notify_kernel_about_unicast_change(subnet)
+            elif item.action == "RTM_NEWADDR" or item.action == "RTM_DELADDR":
+                print("a")
+    '''
+
+
+            #print(ipdb)
+            #print(msg)
+            #print(action)
+
+
+
+
+
+
+    """
+    def get_metric(ip_dst: str):
         ip_bytes = socket.inet_aton(ip_dst)
         ip_int = int.from_bytes(ip_bytes, byteorder='big')
         info = None
@@ -98,7 +193,7 @@ def get_metric(ip_dst: str):
         return (info["proto"], info["priority"])
     
     
-def check_rpf(ip_dst: str):
+    def check_rpf(ip_dst: str):
         from pyroute2 import IPRoute
         # from utils import if_indextoname
     
@@ -111,11 +206,27 @@ def check_rpf(ip_dst: str):
         # obter ip da interface de saida
         rpf_interface_source = ipr.get_routes(family=socket.AF_INET, dst=ip_dst)[0]['attrs'][3][1]
         return rpf_interface_source
-"""
+    """
+
+
+    def stop(self):
+        #self.working = False
+
+        if UnicastRouting.ipr:
+            UnicastRouting.ipr.close()
+        if UnicastRouting.ipdb:
+            UnicastRouting.ipdb = None
+        if self._ipdb:
+            self._ipdb.release()
 
 
-def stop():
-    ipr.close()
+        #ip = input("ip=")
+    #get_metric(ip)
 
-#ip = input("ip=")
-#get_metric(ip)
+'''
+class QueueItem(object):
\ No newline at end of file
+    def __init__(self, ipdb, msg, action):
+        self.ipdb = ipdb
+        self.msg = msg
+        self.action = action
+'''

tree/KernelEntry.py

@@ -6,6 +6,7 @@ from tree.tree_if_upstream import TreeInterfaceUpstream
 from tree.tree_if_downstream import TreeInterfaceDownstream
 from .tree_interface import TreeInterface
 from threading import Timer, Lock, RLock
+from tree.metric import AssertMetric
 import UnicastRouting
 
 class KernelEntry:
@@ -17,7 +18,25 @@ class KernelEntry:
         self.group_ip = group_ip
 
         # ip of neighbor of the rpf
-        self._rpf_node = None
+        #next_hop = UnicastRouting.get_route(source_ip)["gateway"]
+        #self.rpf_node = source_ip if next_hop is None else next_hop
+
+        next_hop = UnicastRouting.get_route(source_ip)["gateway"]
+        multipaths = UnicastRouting.get_route(source_ip)["multipath"]
+
+        self.rpf_node = next_hop if next_hop is not None else source_ip
+        print("MUL", multipaths)
+        #self.rpf_node = multipaths[0]["gateway"]
+        for m in multipaths:
+            if m["gateway"] is None:
+                self.rpf_node = source_ip
+                break
+            else:
+                self.rpf_node = m["gateway"]
+
+        print("RPF_NODE:", UnicastRouting.get_route(source_ip))
+        print(self.rpf_node == source_ip)
+
 
         # (S,G) starts IG state
         self._was_olist_null = None
@@ -81,20 +100,29 @@ class KernelEntry:
 
     def recv_assert_msg(self, index, packet):
         print("recv assert")
-        self.interface_state[index].recv_assert_msg()
+        pkt_assert = packet.payload.payload
+        metric = pkt_assert.metric
+        metric_preference = pkt_assert.metric_preference
+        assert_sender_ip = packet.ip_header.ip_src
+
+        received_metric = AssertMetric(metric_preference=metric_preference, route_metric=metric, ip_address=assert_sender_ip)
+        self.interface_state[index].recv_assert_msg(received_metric)
 
     def recv_prune_msg(self, index, packet):
         print("recv prune msg")
-        self.interface_state[index].recv_prune_msg()
+        holdtime = packet.payload.payload.hold_time
+        upstream_neighbor_address = packet.payload.payload.upstream_neighbor_address
+        self.interface_state[index].recv_prune_msg(upstream_neighbor_address=upstream_neighbor_address, holdtime=holdtime)
 
     def recv_join_msg(self, index, packet):
         print("recv join msg")
-        print("type: ")
-        self.interface_state[index].recv_join_msg()
+        upstream_neighbor_address = packet.payload.payload.upstream_neighbor_address
+        self.interface_state[index].recv_join_msg(upstream_neighbor_address)
 
     def recv_graft_msg(self, index, packet):
         print("recv graft msg")
-        self.interface_state[index].recv_graft_msg()
+        upstream_neighbor_address = packet.payload.payload.upstream_neighbor_address
+        self.interface_state[index].recv_graft_msg(upstream_neighbor_address)
 
     def recv_graft_ack_msg(self, index, packet):
         print("recv graft ack msg")
@@ -105,13 +133,47 @@ class KernelEntry:
         prune_indicator = 1
         self.interface_state[index].recv_state_refresh_msg(prune_indicator)
 
-    def network_update(self, change, args):
-        #todo
-        return
+
+    ###############################################################
+    # Unicast Changes to RPF
+    ###############################################################
+    def network_update(self):
+        with self.CHANGE_STATE_LOCK:
+            #next_hop = UnicastRouting.get_route(self.source_ip)["gateway"]
+            #rpf_node = self.source_ip if next_hop is None else next_hop
+
+            next_hop = UnicastRouting.get_route(self.source_ip)["gateway"]
+            multipaths = UnicastRouting.get_route(self.source_ip)["multipath"]
+
+            rpf_node = next_hop
+            print("MUL", multipaths)
+            # self.rpf_node = multipaths[0]["gateway"]
+            for m in multipaths:
+                if m["gateway"] is None:
+                    rpf_node = self.source_ip
+                    break
+                else:
+                    rpf_node = m["gateway"]
+
+            print("RPF_NODE:", UnicastRouting.get_route(self.source_ip))
 
 
+            print(self.rpf_node == self.source_ip)
 
+            new_inbound_interface_index = Main.kernel.vif_dic[self.check_rpf()]
+            if new_inbound_interface_index != self.inbound_interface_index:
+                # todo: criar novo upstream e downstream interface
+                # todo: stop upstream e downstream
+                #self.interface_state[self.inbound_interface_index].stop()
+                #self.interface_state[new_inbound_interface_index].stop()
+                #Unicast routing or Assert state causes RPF'(S) to change,
+                self.interface_state[self.inbound_interface_index] = TreeInterfaceDownstream
+                self.interface_state[new_inbound_interface_index] = TreeInterfaceUpstream
+                self.inbound_interface_index = new_inbound_interface_index
 
+            if self.rpf_node != rpf_node:
+                self.rpf_node = rpf_node
+                self.interface_state[self.inbound_interface_index].change_rpf(self._was_olist_null)
 
     def update(self, caller, arg):
         #todo

tree/downstream_prune.py

@@ -133,7 +133,8 @@ class NoInfo(DownstreamStateABS):
 
         @type interface: TreeInterfaceDownstreamDownstream
         """
-        assert False
+        #assert False
+        return
 
     @staticmethod
     def PTexpires(interface: "TreeInterfaceDownstream"):
@@ -142,7 +143,8 @@ class NoInfo(DownstreamStateABS):
 
         @type interface: TreeInterfaceDownstreamDownstream
         """
-        assert False
+        #assert False
+        return
 
     @staticmethod
     def is_now_RPF_Interface(interface: "TreeInterfaceDownstream"):
@@ -230,7 +232,8 @@ class PrunePending(DownstreamStateABS):
 
         #pt = interface.get_pt()
         #pt.start(interface.get_lpht() - pim_globals.JT_OVERRIDE_INTERVAL)
-        interface.set_prune_timer(prune_holdtime - pim_globals.JT_OVERRIDE_INTERVAL)
+        #interface.set_prune_timer(prune_holdtime - pim_globals.JT_OVERRIDE_INTERVAL)
+        interface.set_prune_timer(interface.get_received_prune_holdtime() - pim_globals.JT_OVERRIDE_INTERVAL)
 
 
         interface.send_pruneecho()
@@ -245,7 +248,8 @@ class PrunePending(DownstreamStateABS):
         @type interface: TreeInterfaceDownstreamDownstream
         """
 
-        assert False
+        #assert False
+        return
 
     @staticmethod
     def is_now_RPF_Interface(interface: "TreeInterfaceDownstream"):
@@ -259,6 +263,8 @@ class PrunePending(DownstreamStateABS):
         #interface.get_ppt().stop()
         interface.clear_prune_pending_timer()
 
+        interface.set_prune_state(DownstreamState.NoInfo)
+
         print('is_now_RPF_Interface, PP -> NI')
 
     @staticmethod
@@ -293,7 +299,8 @@ class Pruned(DownstreamStateABS):
         #    ppt.set_timer(interface.get_lpht())
         #    ppt.reset()
         # todo nao percebo... corrigir 0
-        if holdtime > 0:
+        #if holdtime > 0:
+        if interface.get_received_prune_holdtime() > interface.remaining_prune_timer():
             interface.set_prune_timer(holdtime)
 
         print('receivedPrune, P -> P')
@@ -334,7 +341,8 @@ class Pruned(DownstreamStateABS):
 
         @type interface: TreeInterfaceDownstreamDownstream
         """
-        assert False
+        #assert False
+        return
 
     @staticmethod
     def PTexpires(interface: "TreeInterfaceDownstream"):
@@ -358,6 +366,7 @@ class Pruned(DownstreamStateABS):
         # todo ver melhor
         #interface.get_pt().stop()
         interface.clear_prune_timer()
+        interface.set_prune_state(DownstreamState.NoInfo)
 
         print('is_now_RPF_Interface, P -> NI')
 
@@ -372,7 +381,8 @@ class Pruned(DownstreamStateABS):
         #pt = interface.get_pt()
         #pt.set_timer(interface.get_lpht())
         #pt.reset()
-        interface.set_prune_timer(interface.get_lpht())
+        #interface.set_prune_timer(interface.get_lpht())
+        interface.set_prune_timer(interface.get_received_prune_holdtime())
 
         print('send_state_refresh, P -> P')
 

tree/globals.py

@@ -13,3 +13,7 @@ OVERRIDE_INTERVAL = 2.5
 REFRESH_INTERVAL = 60  # State Refresh Interval
 SOURCE_LIFETIME = 210
 T_LIMIT = 210
+
+
+
+ASSERT_CANCEL_METRIC = 0xFFFFFFFF
\ No newline at end of file

tree/local_membership.py

+from abc import ABCMeta, abstractmethod
+
+
+class LocalMembershipStateABC(metaclass=ABCMeta):
+    @staticmethod
+    @abstractmethod
+    def has_members():
+        raise NotImplementedError
+
+
+class NoInfo(LocalMembershipStateABC):
+    @staticmethod
+    def has_members():
+        return False
+
+
+class Include(LocalMembershipStateABC):
+    @staticmethod
+    def has_members():
+        return True
+
+
+class LocalMembership():
+    NoInfo = NoInfo()
+    Include = Include()
\ No newline at end of file

tree/metric.py

-'''
-Created on Sep 8, 2014
-
-@author: alex
-'''
-
+import ipaddress
 
 class AssertMetric(object):
     '''
     Note: we consider the node name the ip of the metric.
     '''
 
-    def __init__(self):
-        '''
-         @type tree_if: TreeInterface
-        '''
-        self._pref = None
-        self._metric = None
-        self._node = None
-
-    def is_worse_than(self, other):
-        if self._pref != other.pref:
-            return self._pref > other.pref
+    def __init__(self, metric_preference: int or float = float("Inf"), route_metric: int or float = float("Inf"), ip_address: str = "0.0.0.0"):
+        if type(ip_address) is str:
+            ip_address = ipaddress.ip_address(ip_address)
 
-        elif self._metric != other.metric:
-            return self._metric > other.metric
+        self._metric_preference = metric_preference
+        self._route_metric = route_metric
+        self._ip_address = ip_address
 
+    def is_better_than(self, other):
+        if self.metric_preference != other.metric_preference:
+            return self.metric_preference < other.metric_preference
+        elif self.route_metric != other.route_metric:
+            return self.route_metric < other.route_metric
         else:
-            return self._node.__str__() <= other.node.__str__()
+            return self.ip_address > other.ip_address
 
-    @property
-    def pref(self):
-        return self._pref
-
-    @property
-    def metric(self):
-        return self._metric
-
-    @property
-    def node(self):
-        return self._node
+    def is_worse(self, other):
+        return not self.is_better_than(other)
 
     @staticmethod
     def infinite_assert_metric():
         '''
         @type metric: AssertMetric
         '''
-        metric = AssertMetric()
-
-        metric._pref = 1
-        metric._metric = float("Inf")
-        metric._node = ""
-
-        return metric
+        return AssertMetric(metric_preference=float("Inf"), route_metric=float("Inf"), ip_address="0.0.0.0")
 
     @staticmethod
     def spt_assert_metric(tree_if):
@@ -59,15 +37,40 @@ class AssertMetric(object):
         @type metric: AssertMetric
         @type tree_if: TreeInterface
         '''
-        metric = AssertMetric()
+        (source_ip, _) = tree_if.get_tree_id()
+        import UnicastRouting
+        metric_preference, metric_cost = UnicastRouting.get_metric(source_ip)
+        return AssertMetric(metric_preference, metric_cost, tree_if.get_ip())
+
+
+    def i_am_assert_winner(self, tree_if):
+        interface_ip = ipaddress.ip_address(tree_if.get_ip())
+        return self._ip_address == interface_ip
+
+    @property
+    def metric_preference(self):
+        return self._metric_preference
+
+    @metric_preference.setter
+    def metric_preference(self, value):
+        self._metric_preference = value
 
-        metric._pref = 1  # TODO: ver isto melhor no route preference
-        metric._metric = tree_if.metric
-        metric._node = tree_if.node
+    @property
+    def route_metric(self):
+        return self._route_metric
+
+    @route_metric.setter
+    def route_metric(self, value):
+        self._route_metric = value
+
+
+    @property
+    def ip_address(self):
+        return self._ip_address
 
-        return metric
+    @ip_address.setter
+    def ip_address(self, value):
+        if type(value) is str:
+            value = ipaddress.ip_address(value)
 
-    # overrides
-    def __str__(self):
-        return "AssertMetric<{}:{}:{}>".format(self._pref, self._metric,
-                                               self._node)
+        self._ip_address = value

tree/tree_if_downstream.py

@@ -7,6 +7,7 @@ Created on Jul 16, 2015
 #from convergence import Convergence
 #from des.event.timer import Timer
 from threading import Timer
+from CustomTimer.RemainingTimer import RemainingTimer
 from .assert_ import AssertState, AssertStateABC
 #from .messages.assert_msg import SFMRAssertMsg
 #from .messages.reset import SFMResetMsg
@@ -22,18 +23,18 @@ class TreeInterfaceDownstream(TreeInterface):
         TreeInterface.__init__(self, kernel_entry, interface_id)
 
         # State
-        self._local_membership_state = None # todo NoInfo or Include
+        #self._local_membership_state = None # todo NoInfo or Include
 
         # Prune State
-        self._prune_state = DownstreamState.NoInfo
-        self._prune_pending_timer = None
-        self._prune_timer = None
+        #self._prune_state = DownstreamState.NoInfo
+        #self._prune_pending_timer = None
+        #self._prune_timer = None
 
         # Assert Winner State
-        self._assert_state = AssertState.Winner
-        self._assert_timer = None
-        self._assert_winner_ip = None
-        self._assert_winner_metric = None
+        #self._assert_state = AssertState.NoInfo
+        #self._assert_timer = None
+        #self._assert_winner_ip = None
+        #self._assert_winner_metric = None
 
         #self.set_dipt_timer()
         #self.send_prune()
@@ -58,6 +59,9 @@ class TreeInterfaceDownstream(TreeInterface):
     def is_prune_timer_running(self):
         return self._prune_timer is not None and self._prune_timer.is_alive()
 
+    def remaining_prune_timer(self):
+        return 0 if not self._prune_timer else self._prune_timer.time_remaining()
+
     ##########################################
     # Set timers
     ##########################################
@@ -72,7 +76,8 @@ class TreeInterfaceDownstream(TreeInterface):
 
     def set_prune_timer(self, time):
         self.clear_prune_timer()
-        self._prune_timer = Timer(time, self.prune_timeout)
+        #self._prune_timer = Timer(time, self.prune_timeout)
+        self._prune_timer = RemainingTimer(time, self.prune_timeout)
         self._prune_timer.start()
 
     def clear_prune_timer(self):
@@ -88,27 +93,32 @@ class TreeInterfaceDownstream(TreeInterface):
     def prune_timeout(self):
         self._prune_state.PTexpires(self)
 
-
     ###########################################
     # Recv packets
     ###########################################
+    def recv_data_msg(self):
+        self._assert_state.receivedDataFromDownstreamIf(self)
+
     # Override
-    def recv_prune_msg(self):
-        self._prune_state.receivedPrune(self, 0)
+    def recv_prune_msg(self, upstream_neighbor_address, holdtime):
+        super().recv_prune_msg(upstream_neighbor_address, holdtime)
+
+        # set here???
+        self.set_receceived_prune_holdtime(holdtime)
+        self._prune_state.receivedPrune(self, holdtime)
 
     # Override
-    def recv_join_msg(self):
+    def recv_join_msg(self, upstream_neighbor_address):
+        super().recv_join_msg(upstream_neighbor_address)
         self._prune_state.receivedJoin(self)
 
     # Override
-    def recv_graft_msg(self):
+    def recv_graft_msg(self, upstream_neighbor_address):
+        super().recv_graft_msg(upstream_neighbor_address)
         self._prune_state.receivedGraft(self)
 
 
 
-
-
-
     # Override
     def is_forwarding(self):
         return ((len(self.get_interface().neighbors) >= 1 and not self.is_pruned()) or self.igmp_has_members()) and not self.lost_assert()
@@ -133,15 +143,6 @@ class TreeInterfaceDownstream(TreeInterface):
     def get_metric(self):
         return AssertMetric.spt_assert_metric(self)
 
-    def _set_assert_state(self, value: AssertStateABC):
-        with self.get_state_lock():
-            if value != self._assert_state:
-                self._assert_state = value
-
-                self.change_tree()
-                self.evaluate_ingroup()
-                #Convergence.mark_change()
-
     def _get_winner_metric(self):
         '''
         @rtype: SFMRAssertMetric

tree/tree_if_upstream.py

@@ -24,6 +24,9 @@ class TreeInterfaceUpstream(TreeInterface):
 
         self._originator_state = None
 
+        if self.is_S_directly_conn():
+            self._graft_prune_state.sourceIsNowDirectConnect(self)
+
     ##########################################
     # Set state
     ##########################################
@@ -95,7 +98,7 @@ class TreeInterfaceUpstream(TreeInterface):
     ###########################################
     def recv_data_msg(self):
         # todo check olist
-        if self.is_olist_null() and not self.is_prune_limit_timer_running():
+        if self.is_olist_null() and not self.is_prune_limit_timer_running() and not self.is_S_directly_conn():
             self._graft_prune_state.dataArrivesRPFinterface_OListNull_PLTstoped(self)
 
     def recv_state_refresh_msg(self, prune_indicator: int):
@@ -105,11 +108,13 @@ class TreeInterfaceUpstream(TreeInterface):
         elif prune_indicator == 0 and not self.is_prune_limit_timer_running():
             self._graft_prune_state.stateRefreshArrivesRPFnbr_pruneIs0_PLTstoped(self)
 
-    def recv_join_msg(self):
+    def recv_join_msg(self, upstream_neighbor_address):
+        super().recv_join_msg(upstream_neighbor_address)
         # todo check rpf nbr
         self._graft_prune_state.seeJoinToRPFnbr(self)
 
-    def recv_prune_msg(self):
+    def recv_prune_msg(self, upstream_neighbor_address, holdtime):
+        super().recv_prune_msg(upstream_neighbor_address, holdtime)
         self._graft_prune_state.seePrune(self)
 
     def recv_graft_ack_msg(self):
@@ -128,8 +133,11 @@ class TreeInterfaceUpstream(TreeInterface):
     ###########################################
     # Changes on Unicast Routing Table
     ###########################################
-    # todo
-
+    def change_rpf(self, olist_is_null):
+        if olist_is_null:
+            self._graft_prune_state.RPFnbrChanges_olistIsNull()
+        else:
+            self._graft_prune_state.RPFnbrChanges_olistIsNotNull()
 
     #Override
     def is_forwarding(self):
@@ -149,5 +157,5 @@ class TreeInterfaceUpstream(TreeInterface):
 
     @property
     def t_override(self):
-        oi = self.get_interface()._override_internal
+        oi = self.get_interface()._override_interval
         return random.uniform(0, oi)