• 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 lp ∉ map.participant_list:
        • 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).

PeerTupleNode make_tuple_node(HCoord h, int top)

• Questo metodo produce un'istanza di PeerTupleNode che rappresenta h nel nostro g-nodo di livello top. In realtà h è un g-nodo ma il risultato deve essere un PeerTupleNode perché va usato nel calcolo di dist. I valori delle posizioni inferiori a h.lvl non sono significativi purché rientrino nella topologia, quindi li impostiamo a 0.

• assert(top > h.lvl).

• tuple = [].

• i = top.

• While i > 0:

  • Decrementa i di 1.

  • Se i > h.lvl:

    • Inserisci pos[i] in posizione 0 in tuple.
  • Se i = h.lvl:
    • Inserisci h.pos in posizione 0 in tuple.

  • Se i < h.lvl:

    • Inserisci 0 in posizione 0 in tuple.

• Return new PeerTupleNode(tuple).

bool visible_by_someone_inside_my_gnode(PeerTupleGNode t, int lvl)

• Dato un g-nodo rappresentato da t, decidere se qualcuno dei nodi dentro il mio g-nodo di livello lvl può rappresentare quel g-nodo in forma di HCoord.

• ε = t.top - t.tuple.size

• l = ε.

• Se l ≥ lvl-1:
  • l = l + 1.
• Altrimenti:
  • l = lvl.
• Se t.top ≤ l:
  • Return True.

• # Calcola h il g-nodo di livello l in cui si trova g.

• PeerTupleGNode h = new PeerTupleGNode(t.tuple.slice(l-ε, t.tuple.size), t.top).

• # Ora scopriamo se h è uno dei g-nodi a cui appartiene n.

• int case, HCoord ret.

• convert_tuple_gnode(h, out case, out ret).
• Se case = 1:
  • Return True.
• Return False.