• Netsukuku
• ita
• docs
• ModuloPeers
• AppuntiMetodiHelper

Modulo PeerServices - Appunti - Metodi helper

bool my_gnode_participates(int p_id, int lvl)

• Questo metodo dice se il mio g-nodo di livello lvl partecipa attivamente al servizio con identificativo p_id.
• Se services.has_key(p_id):
  • Return True.
• Se (! participant_maps.has_key(p_id)):
  • Return False.

• map = participant_maps[p_id].

• Per ogni HCoord g in map.participant_list:

  • Se g.lvl < lvl:

    • Return True.
• Return False.

List<HCoord> get_non_participant_gnodes(int p_id)

• Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che, stando alle mie conoscenze, non partecipano al servizio con identificativo p_id.

• ret = new ArrayList di HCoord.

• bool opzionale = False.

• Se services.has_key(p_id):
  • opzionale = services[p_id].p_is_optional.
• Altrimenti:
  • opzionale = True.
• Se opzionale:

  • map = null.

  • Se (participant_maps.has_key(p_id)):

    • map = participant_maps[p_id].

  • Per ogni HCoord lp in get_all_gnodes_up_to_lvl(levels):

    • Se map = null:
      • Aggiungi a ret lp.
    • Altrimenti:
      • Se NOT map.participant_list.contains(lp):
        • Aggiungi a ret lp.
• Return ret.

List<HCoord> get_all_gnodes_up_to_lvl(int lvl)

• Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che sono dentro il mio g-nodo di livello lvl. Compresi i singoli nodi e compreso me stesso (0, pos[0]).

• ret = new ArrayList di HCoord.

• Per l da 0 a lvl-1:

  • Per p da 0 a gsizes[l]-1:

    • Se pos[l] ≠ p:
      • Aggiungi a ret HCoord(l, p).
• Aggiungi a ret HCoord(0, pos[0]).
• Return ret.

void convert_tuple_gnode(PeerTupleGNode t, out int case, out HCoord ret)

• Ricordiamo che un'istanza t di PeerTupleGNode rappresenta un g-nodo h di livello ε all'interno di un g-nodo (che chiamiamo g-nodo di riferimento) g di livello l. Il valore di l è memorizzato in t.top. Il valore di ε si calcola come t.top - t.tuple.size.

• Dato t il cui g-nodo di riferimento è uno dei g-nodi a cui il nodo corrente appartiene, questo metodo restituisce le seguenti informazioni:
  • int case:
    • Vale 1 se t rappresenta un g-nodo di cui il nodo corrente fa parte.
    • Vale 2 se t rappresenta un g-nodo visibile nella mia topologia come istanza di HCoord.
    • Vale 3 se t rappresenta un g-nodo non visibile nella mia topologia.
  • HCoord ret:
    • Il g-nodo che il nodo corrente ha in comune con h.
    • Nel caso 1 abbiamo ret.lvl = ε. Inoltre pos[ret.lvl] = ret.pos.
    • Nel caso 2 abbiamo ret.lvl = ε. Inoltre pos[ret.lvl] ≠ ret.pos.

    • Nel caso 3 abbiamo ret.lvl > ε.

• int lvl = t.top.
• int i = t.tuple.size.

• assert(i > 0).

• assert(i ≤ lvl).

• trovato = False.

• While True:
  • decrementa lvl di 1.
  • decrementa i di 1.
  • Se pos[lvl] ≠ t.tuple[i]:
    • ret = HCoord(lvl, t.tuple[i]).
    • trovato = True.
    • Se i = 0:
      • case = 2.
    • Altrimenti:
      • case = 3.
    • Esci dal ciclo.
  • Se i = 0:
    • ret = HCoord(lvl, t.tuple[i]).
    • case = 1.
    • Esci dal ciclo.
• Return case, ret.

PeerTupleGNode make_tuple_gnode(HCoord h, int top)

• Questo metodo produce un'istanza di PeerTupleGNode che rappresenta h nel nostro g-nodo di livello top.

• assert(top > h.lvl).

• tuple = [].

• i = top.

• While True:
  • Decrementa i di 1.
  • Se i = h.lvl:
    • Inserisci h.pos in posizione 0 in tuple.
    • Esci dal ciclo.
  • Altrimenti:
    • Inserisci pos[i] in posizione 0 in tuple.
• Return new PeerTupleGNode(tuple, top).