Skip to content

Documentation for Idleneighborpolicy Module

IDLENeighborPolicy

Bases: NeighborPolicy

Neighbor policy for minimal connectivity scenarios.

This policy only attempts to discover or establish new neighbor connections if the node is currently isolated (i.e., has no neighbors). All incoming connection requests are accepted regardless of the current neighbor state.

This policy is suitable for scenarios where minimal intervention is preferred, and connections are formed opportunistically rather than proactively.

Attributes:

Name Type Description
max_neighbors int | None

Unused in this policy but maintained for compatibility.
nodes_known set[str]

Set of known node IDs discovered during federation.
neighbors set[str]

Set of currently connected neighbor node IDs.
addr str | None

This node's own address.
neighbors_lock Locker

Async lock for thread-safe access to neighbors.
nodes_known_lock Locker

Async lock for thread-safe access to nodes_known.
_verbose bool

Enables verbose logging for debugging and traceability.
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
class IDLENeighborPolicy(NeighborPolicy):
    """
    Neighbor policy for minimal connectivity scenarios.

    This policy only attempts to discover or establish new neighbor connections 
    if the node is currently isolated (i.e., has no neighbors). All incoming 
    connection requests are accepted regardless of the current neighbor state.

    This policy is suitable for scenarios where minimal intervention is preferred, 
    and connections are formed opportunistically rather than proactively.

    Attributes:
        max_neighbors (int | None): Unused in this policy but maintained for compatibility.
        nodes_known (set[str]): Set of known node IDs discovered during federation.
        neighbors (set[str]): Set of currently connected neighbor node IDs.
        addr (str | None): This node's own address.
        neighbors_lock (Locker): Async lock for thread-safe access to `neighbors`.
        nodes_known_lock (Locker): Async lock for thread-safe access to `nodes_known`.
        _verbose (bool): Enables verbose logging for debugging and traceability.
    """

    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 
63
64
65
66
67
68
69
70
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 
108
109
110
111
112
113
114
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 
149
150
151
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 
72
73
74
75
76
77
78
79
80
81
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 
37
38
39
40
41
42
43
44
45
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 
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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