Skip to content

Documentation for Starneighborpolicy Module

STARNeighborPolicy

Bases: NeighborPolicy

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/starneighborpolicy.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
class STARNeighborPolicy(NeighborPolicy):
    def __init__(self):
        self.max_neighbors = 1
        self.nodes_known = set()
        self.neighbors = set()
        self.neighbors_lock = Locker(name="neighbors_lock")
        self.nodes_known_lock = Locker(name="nodes_known_lock")
        self.addr = ""
        self._verbose = False

    async def need_more_neighbors(self):
        self.neighbors_lock.acquire()
        need_more = len(self.neighbors) < self.max_neighbors
        self.neighbors_lock.release()
        return need_more

    async def set_config(self, config):
        """
        Args:
            config[0] -> list of self neighbors, in this case, the star point
            config[1] -> list of nodes known on federation
            config[2] -> self.addr
            config[3] -> stricted_topology
        """
        self.neighbors_lock.acquire()
        self.neighbors = config[0]
        self.neighbors_lock.release()
        for addr in config[1]:
            self.nodes_known.add(addr)
        self.addr = config[2]

    async def accept_connection(self, source, joining=False):
        """
        return true if connection is accepted
        """
        ac = joining
        return ac

    async def meet_node(self, node):
        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 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_nodes_known(self, neighbors_too=False, neighbors_only=False):
        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 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
        """
        self.neighbors_lock.acquire()
        ct_actions = []
        df_actions = []
        if len(self.neighbors) < self.max_neighbors:
            ct_actions.append(self.neighbors[0])  # connect to star point
            df_actions.append(self.addr)  # disconnect from me
        self.neighbors_lock.release()
        return [ct_actions, df_actions]

    async def update_neighbors(self, node, remove=False):
        pass

    async def stricted_topology_status(stricted_topology: bool):
        pass

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

accept_connection(source, joining=False) async

return true if connection is accepted

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/starneighborpolicy.py 
38
39
40
41
42
43
async def accept_connection(self, source, joining=False):
    """
    return true if connection is accepted
    """
    ac = joining
    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/starneighborpolicy.py 
72
73
74
75
76
77
78
79
80
81
82
83
84
85
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
    """
    self.neighbors_lock.acquire()
    ct_actions = []
    df_actions = []
    if len(self.neighbors) < self.max_neighbors:
        ct_actions.append(self.neighbors[0])  # connect to star point
        df_actions.append(self.addr)  # disconnect from me
    self.neighbors_lock.release()
    return [ct_actions, df_actions]

get_posible_neighbors() async

Return set of posible neighbors to connect to.

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

set_config(config) async

Source code in nebula/core/situationalawareness/awareness/sanetwork/neighborpolicies/starneighborpolicy.py 
23
24
25
26
27
28
29
30
31
32
33
34
35
36
async def set_config(self, config):
    """
    Args:
        config[0] -> list of self neighbors, in this case, the star point
        config[1] -> list of nodes known on federation
        config[2] -> self.addr
        config[3] -> stricted_topology
    """
    self.neighbors_lock.acquire()
    self.neighbors = config[0]
    self.neighbors_lock.release()
    for addr in config[1]:
        self.nodes_known.add(addr)
    self.addr = config[2]