Skip to content

Documentation for Idleneighborpolicy Module

IDLENeighborPolicy

Bases: NeighborPolicy

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/idleneighborpolicy.py 
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
class IDLENeighborPolicy(NeighborPolicy):
    def __init__(self):
        self.max_neighbors = None
        self.nodes_known = set()
        self.neighbors = set()
        self.addr = None
        self.neighbors_lock = Locker(name="neighbors_lock")
        self.nodes_known_lock = Locker(name="nodes_known_lock")
        self._verbose = False

    async def need_more_neighbors(self):
        """
        Fully connected network requires to be connected to all devices, therefore,
        if there are more nodes known that self.neighbors, more neighbors are required
        """
        self.neighbors_lock.acquire()
        need_more = len(self.neighbors) <= 0
        self.neighbors_lock.release()
        return need_more

    async def set_config(self, config):
        """
        Args:
            config[0] -> list of self neighbors
            config[1] -> list of nodes known on federation
            config[2] -> self addr
            config[3] -> stricted_topology
        """
        logging.info("Initializing Random Topology Neighbor Policy")
        self.neighbors_lock.acquire()
        self.neighbors = config[0]
        self.neighbors_lock.release()
        for addr in config[1]:
            self.nodes_known.add(addr)
        self.addr

    async def accept_connection(self, source, joining=False):
        """
        return true if connection is accepted
        """
        self.neighbors_lock.acquire()
        ac = source not in self.neighbors
        self.neighbors_lock.release()
        return ac

    async def meet_node(self, node):
        """
        Update the list of nodes known on federation
        """
        self.nodes_known_lock.acquire()
        if node != self.addr:
            if node not in self.nodes_known:
                logging.info(f"Update nodes known | addr: {node}")
            self.nodes_known.add(node)
        self.nodes_known_lock.release()

    async def get_nodes_known(self, neighbors_too=False, neighbors_only=False):
        if neighbors_only:
            self.neighbors_lock.acquire()
            no = self.neighbors.copy()
            self.neighbors_lock.release()
            return no

        self.nodes_known_lock.acquire()
        nk = self.nodes_known.copy()
        if not neighbors_too:
            self.neighbors_lock.acquire()
            nk = self.nodes_known - self.neighbors
            self.neighbors_lock.release()
        self.nodes_known_lock.release()
        return nk

    async def forget_nodes(self, nodes, forget_all=False):
        self.nodes_known_lock.acquire()
        if forget_all:
            self.nodes_known.clear()
        else:
            for node in nodes:
                self.nodes_known.discard(node)
        self.nodes_known_lock.release()

    async def get_actions(self):
        """
        return list of actions to do in response to connection
            - First list represents addrs argument to LinkMessage to connect to
            - Second one represents the same but for disconnect from LinkMessage
        """
        return [await self._connect_to(), await self._disconnect_from()]

    async def _disconnect_from(self):
        return ""

    async def _connect_to(self):
        ct = ""
        self.neighbors_lock.acquire()
        ct = " ".join(self.neighbors)
        self.neighbors_lock.release()
        return ct

    async def update_neighbors(self, node, remove=False):
        if node == self.addr:
            return
        self.neighbors_lock.acquire()
        if remove:
            try:
                self.neighbors.remove(node)
                if self._verbose:
                    logging.info(f"Remove neighbor | addr: {node}")
            except KeyError:
                pass
        else:
            self.neighbors.add(node)
            if self._verbose:
                logging.info(f"Add neighbor | addr: {node}")
        self.neighbors_lock.release()

    async def any_leftovers_neighbors(self):
        return False

    async def get_neighbors_to_remove(self):
        return set()

    async def get_posible_neighbors(self):
        """Return set of posible neighbors to connect to."""
        return await self.get_nodes_known(neighbors_too=False)

    async def stricted_topology_status(stricted_topology: bool):
        pass

accept_connection(source, joining=False) async

return true if connection is accepted

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/idleneighborpolicy.py 
43
44
45
46
47
48
49
50
async def accept_connection(self, source, joining=False):
    """
    return true if connection is accepted
    """
    self.neighbors_lock.acquire()
    ac = source not in self.neighbors
    self.neighbors_lock.release()
    return ac

get_actions() async

return list of actions to do in response to connection - First list represents addrs argument to LinkMessage to connect to - Second one represents the same but for disconnect from LinkMessage

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/idleneighborpolicy.py 
88
89
90
91
92
93
94
async def get_actions(self):
    """
    return list of actions to do in response to connection
        - First list represents addrs argument to LinkMessage to connect to
        - Second one represents the same but for disconnect from LinkMessage
    """
    return [await self._connect_to(), await self._disconnect_from()]

get_posible_neighbors() async

Return set of posible neighbors to connect to.

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/idleneighborpolicy.py 
129
130
131
async def get_posible_neighbors(self):
    """Return set of posible neighbors to connect to."""
    return await self.get_nodes_known(neighbors_too=False)

meet_node(node) async

Update the list of nodes known on federation

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/idleneighborpolicy.py 
52
53
54
55
56
57
58
59
60
61
async def meet_node(self, node):
    """
    Update the list of nodes known on federation
    """
    self.nodes_known_lock.acquire()
    if node != self.addr:
        if node not in self.nodes_known:
            logging.info(f"Update nodes known | addr: {node}")
        self.nodes_known.add(node)
    self.nodes_known_lock.release()

need_more_neighbors() async

Fully connected network requires to be connected to all devices, therefore, if there are more nodes known that self.neighbors, more neighbors are required

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/idleneighborpolicy.py 
17
18
19
20
21
22
23
24
25
async def need_more_neighbors(self):
    """
    Fully connected network requires to be connected to all devices, therefore,
    if there are more nodes known that self.neighbors, more neighbors are required
    """
    self.neighbors_lock.acquire()
    need_more = len(self.neighbors) <= 0
    self.neighbors_lock.release()
    return need_more

set_config(config) async

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/idleneighborpolicy.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
async def set_config(self, config):
    """
    Args:
        config[0] -> list of self neighbors
        config[1] -> list of nodes known on federation
        config[2] -> self addr
        config[3] -> stricted_topology
    """
    logging.info("Initializing Random Topology Neighbor Policy")
    self.neighbors_lock.acquire()
    self.neighbors = config[0]
    self.neighbors_lock.release()
    for addr in config[1]:
        self.nodes_known.add(addr)
    self.addr