Modulo QSPN - Analisi Funzionale

Il modulo realizza lo scambio di messaggi con i vicini del nodo al fine di esplorare la rete. Tali messaggi sono chiamati ETP, acronimo di Extended Tracer Packet. In questo documento non illustriamo nel dettaglio come sono fatti questi messaggi. Rimandiamo per questo al documento esplorazione ma consigliamo di leggerlo solo dopo aver letto il presente documento. Per ora basta considerare che ogni nodo usa questi messaggi per comunicare ai suoi vicini le informazioni riguardanti i percorsi della rete che sono a lui noti.

L'obiettivo di ogni nodo n è di reperire e mantenere per ogni destinazione dst fino a max_paths percorsi disgiunti (vedi documento percorsi disgiunti), che siano i più rapidi. Inoltre n vuole mantenere per ogni destinazione dst e per ogni proprio vicino v, almeno 1 percorso, se esiste, indipendentemente dal valore di max_paths e dalle regole di disgiunzione, verso dst che non contiene v tra i suoi passaggi. Infine n vuole mantenere per ogni destinazione dst almeno 1 percorso per ogni diverso fingerprint di dst che gli viene segnalato (questo concetto sarà chiarito in seguito).

Struttura gerarchica della rete

L'assegnazione degli indirizzi ai nodi della rete avviene sulla base di una struttura gerarchica imposta alla rete. Tale gerarchia è composta da un numero fisso di livelli: l.

Al livello 0 ci sono i singoli nodi. Ogni nodo da solo costituisce un vertice.

Al livello 1 i singoli nodi sono raggruppati a costituire gruppi (o cluster) che chiamiamo g-nodi di livello 1. Un g-nodo di livello 1 può essere costituito anche da un solo nodo, oppure da più nodi fino ad un numero massimo fissato. Ogni g-nodo di livello 1 può essere considerato come un singolo vertice.

Al livello 2 i g-nodi di livello 1 sono raggruppati a costituire g-nodi di livello 2. Un g-nodo di livello 2 può essere costituito anche da un solo g-nodo di livello 1, oppure da più g-nodi fino ad un numero massimo fissato. Ogni g-nodo di livello 2 può essere considerato come un singolo vertice. Si noti che i singoli nodi che fanno parte di un g-nodo di livello 1 che fa parte a sua volta di un g-nodo di livello 2, ognuno di questi singoli nodi fa parte allo stesso tempo anche del g-nodo di livello 2.

E così via. Nel livello più alto l è presente un solo gruppo che costituisce tutta la rete.

Anche il singolo nodo a volte viene chiamato (impropriamente) un g-nodo di livello 0.

Come detto, ogni g-nodo di qualsiasi livello i può essere considerato come se fosse un unico vertice. Si forma cioè per ogni livello i una sorta di partizionamento del grafo che costituisce l'intera rete.

Abbiamo detto che ogni g-nodo di livello i+1 contiene un numero massimo fissato di g-nodi di livello i. Il numero massimo di elementi di un g-nodo è detto gsize. Ogni livello da 0 a l-1 può avere un valore gsize diverso. Chiamiamo gsize(i) il numero massimo di g-nodi di livello i in un g-nodo di livello i+1.

Ogni g-nodo di livello i ha un identificativo che lo individua univocamente all'interno del suo g-nodo di livello i+1. Tale identificativo è un numero intero da 0 a gsize(i) - 1.

L'indirizzo del singolo nodo va ad essere composto mettendo in sequenza gli identificativi di tutti i g-nodi a cui esso appartiene, a partire da quello di livello l-1 fino a quello di livello 0. Si noti che ogni singolo nodo, dal momento che conosce il proprio indirizzo, sa di far parte di un preciso g-nodo di livello 1, di un preciso g-nodo di livello 2, e così via, fino al livello più alto.

Questa strutturazione gerarchica è adottata per evitare che la mappa della rete che ogni nodo tiene in memoria diventi troppo grande.

Mappa gerarchica della rete

In ogni singolo nodo, il modulo QSPN ha il compito di costruire e tenere in memoria una mappa a topologia gerarchica della rete.

Per ogni livello i della rete, da 0 a l-1, un nodo n deve memorizzare in tale mappa tutti i g-nodi di livello i appartenenti al suo stesso g-nodo di livello i+1 di cui n conosce l'esistenza, cioè conosce almeno un percorso per raggiungerli. Per ognuno vanno memorizzati tutti i percorsi noti e per ogni percorso alcune informazioni che elencheremo più sotto.

Ad esempio, sia il nodo n con indirizzo n_l-1·...·n₁·n₀. Vale a dire che n ha identificativo n₀ all'interno del suo g-nodo di livello 1, il quale ha identificativo n₁ all'interno del suo g-nodo di livello 2, ... fino a n_l-1. Per il livello 0 il nodo n dovrà memorizzare nella mappa tutti i nodi (detti g-nodi di livello 0) che conosce che appartengono al g-nodo di livello 1 n₁. Il nodo n non memorizzerà nella sua mappa n₀ perché è esso stesso. Per il livello 1 il nodo n dovrà memorizzare nella mappa tutti i g-nodi di livello 1 che conosce che appartengono al g-nodo di livello 2 n₂ come se fossero singoli vertici. Il nodo n non memorizzerà n₁ come un singolo vertice perché di esso ha già memorizzato tutti i vertici di cui è composto. Per il livello 2 il nodo n dovrà memorizzare nella mappa tutti i g-nodi di livello 2 che conosce che appartengono al g-nodo di livello 3 n₃ come se fossero singoli vertici. Il nodo n non memorizzerà n₂ come un singolo vertice perché di esso ha già memorizzato tutti i vertici di cui è composto. E così via fino a memorizzare come fossero singoli vertici anche tutti i g-nodi di livello l-1 che conosce, tranne n_l-1.

Affinché questa mappa gerarchica sia sufficiente al nodo per raggiungere ogni singolo nodo esistente nella rete, ogni g-nodo deve essere internamente connesso. E' compito del modulo QSPN scoprire e segnalare se un g-nodo di cui si conosce l'esistenza (e almeno 2 diversi percorsi) è divenuto disconnesso. Eventuali successive azioni volte a porre rimedio non sono di competenza del modulo.

A questo scopo ogni g-nodo ha anche un altro identificativo chiamato fingerprint. Vediamo come si genera un fingerprint e come viene "assegnato" ad un g-nodo.

Fingerprint

A livello 0, il fingerprint di un nodo è composto da un identificativo del nodo, univoco a livello di rete, e da una lista di valori che rappresentano l'anzianità ai vari livelli dal livello 0 al livello l-1. L'anzianità a livello 0 indica quanto è vecchio il nodo rispetto agli altri nodi del suo stesso g-nodo di livello 1; a livello i indica quanto è vecchio il suo g-nodo di livello i rispetto agli altri g-nodi di livello i del suo stesso g-nodo di livello i+1. L'oggetto fingerprint del nodo viene passato al modulo QSPN dal suo utilizzatore; quindi come vengano generati o recuperati i dati in esso contenuti non è di pertinenza del modulo, e nemmeno in che modo sia implementato il confronto fra due valori di anzianità.

Il fingerprint di un g-nodo di livello 1 ha come identificativo l'identificativo del nodo più anziano in esso contenuto e i suoi stessi valori di anzianità dal livello 1 in su (valori che dovrebbero risultare gli stessi per tutti i nodi del g-nodo). Come vedremo subito, quando un nodo viene a conoscenza dell'esistenza di un altro nodo di livello 0 nel suo g-nodo di livello 1, cioè viene a conoscenza di un percorso per raggiungerlo, viene anche portato a conoscenza del fingerprint di quel nodo. Di conseguenza ogni nodo è in grado di computare il fingerprint del suo g-nodo di livello 1.

Il fingerprint di un g-nodo di livello i ha come identificativo l'identificativo del g-nodo di livello i-1 più anziano in esso contenuto e i suoi stessi valori di anzianità dal livello i in su (valori che dovrebbero risultare gli stessi per tutti i g-nodi di livello i-1 del g-nodo). Anche a livello i abbiamo che quando un nodo viene a conoscenza dell'esistenza di un altro g-nodo di livello i-1 nel suo g-nodo di livello i, cioè viene a conoscenza di un percorso per raggiungerlo, viene anche portato a conoscenza del fingerprint di quel g-nodo. Di conseguenza ogni nodo è in grado di computare il fingerprint del suo g-nodo di livello i.

Proseguendo così si ottiene che il fingerprint a livello l non ha valori di anzianità ma solo un identificativo. Questo è l'identificativo della rete.

Questo meccanismo di costruzione del fingerprint di un g-nodo a partire da quelli dei g-nodi in esso contenuti (sulla base della conoscenza del nodo corrente) fa in modo che al variare della rete ogni nodo rilevi immediatamente il verificarsi dello split di un g-nodo (o dell'intera rete). Con questo termine indichiamo che il g-nodo non è più internamente connesso, ma si sono formate 2 o più isole.

Vediamo con un esempio come avviene questo rilevamento.

Sia g un g-nodo di livello 1; sia f il nodo più anziano in esso. Siano v e w due border-nodi appartenenti al g-nodo g di livello 1; il termine border-nodo di g indica un nodo appartenente a g che ha almeno un vicino che non appartiene a g. Sia x il vicino di v esterno a g; sia y il vicino di w esterno a g; supponiamo che entrambi siano appartenenti allo stesso g-nodo a di livello 2 in cui si trova anche tutto il g-nodo g.

I nodi v e w sono entrambi a conoscenza di alcuni percorsi per raggiungere f. Quindi entrambi hanno calcolato il fingerprint del g-nodo g ottenendo come identificativo lo stesso di f. Supponiamo che g diventi disconnesso, per esempio per via della rimozione di un arco; che si siano formate due isole; che v ed f si trovino nella prima isola; che w si trovi nella seconda isola. Quando w scopre di non avere più alcun percorso verso f lo considera morto, e ricalcola il fingerprint del g-nodo g ottenendo come identificativo quello di un altro nodo h. Per via di questa variazione il nodo w trasmette un ETP al nodo y. Supponiamo ora che il g-nodo a sia ancora internamente connesso. Quindi esiste un percorso che collega x ad y senza passare per g. Allora l'ETP ricevuto da y si propagherà e raggiungerà x. ¹ Ora x sarà a conoscenza di 2 percorsi verso la destinazione g che hanno informazioni diverse riguardo il fingerprint di g. Se questa situazione rimarrà tale per un certo tempo, allora x avrà rilevato lo split del g-nodo g.

Si intuisce che questo meccanismo si ripresenta in maniera analoga qualsiasi sia il livello del g-nodo che diventa disconnesso, basta che il g-nodo di livello superiore sia ancora connesso. Se invece lo split avviene sul livello più alto, cioè se si divide tutta la rete, quello che si ottiene è che le 2 isole diventano reti distinte con identificativi di rete distinti. Per entrambe le situazioni, come detto in precedenza, il compito del modulo QSPN è solo quello di permetterne il rilevamento, non quello di porre rimedio.

Nota 1: Per questo è importante che un nodo sempre mantenga e trasmetta per ogni destinazione d almeno un percorso per ogni diverso fingerprint di d che gli viene segnalato.

Elementi memorizzati nella mappa

Riassumendo, per ogni g-nodo nella topologia gerarchica del nodo corrente, la mappa mantiene queste informazioni:

• livello (lvl) e identificativo all'interno di quel livello (pos : numero da 0 a gsize(lvl) - 1). Il modulo QSPN lo rappresenta con una istanza della classe HCoord.

• tutti i percorsi che il nodo sa di poter usare per raggiungere quel g-nodo. Il modulo li rappresenta con istanze della classe NodePath. Per ogni percorso vanno mantenute queste informazioni:

  • l'arco verso il gateway;
  • tutti gli hops del percorso espressi come istanze di HCoord;
  • il costo del percorso;
  • il fingerprint del g-nodo destinazione come riportato da questo percorso;
  • il numero di nodi stimati all'interno del g-nodo destinazione come riportato da questo percorso.

Nota: da spostare nei dettagli tecnici

• Se per un g-nodo g vengono rilevate due percorsi che differiscono per il loro fingerprint e se questa situazione si mantiene per un certo lasso di tempo, questo è sintomo dello split del g-nodo g. Il modulo lo segnala con un evento.

• Il tempo di tolleranza è direttamente proporzionale alla somma delle latenze associate ai due percorsi che differiscono; ma il modulo QSPN non ha questa informazione in quanto il costo associato ad un percorso non sappiamo se sia espresso in latenza, in larghezza di banda o in altra metrica; quindi il calcolo di tale tempo di tolleranza va demandato all'utilizzatore del modulo il quale fornisce una callback. Per dare il massimo del supporto a questa callback vengono passate le istanze di IQspnNodePath che rappresentano i percorsi discordi. Da queste la callback potrà estrapolare i costi e sommarli se si tratta in effetti di latenze. Altrimenti la callback potrà leggere la destinazione e confrontarla con il proprio indirizzo per risalire al livello del minimo g-nodo comune, chiedere allo stesso modulo QSPN la stima dei nodi all'interno di tale livello e finalmente proporre un tempo di tolleranza sulla base di questo dato.
• I percorsi che riportano il fingerprint con minore anzianità sono mantenuti nella mappa del modulo e trasmessi tramite ETP, ma soltanto quelli con il fingerprint più anziano sono segnalati all'esterno del modulo.

Nota: da spostare nei dettagli tecnici

• Per un g-nodo g di livello i possono venire rilevati diversi percorsi che differiscono per il "numero di nodi nel g-nodo" e questa situazione si può mantenere stabile. Questo non indica che il g-nodo g sia splittato, infatti le variazioni nel numero di nodi possono venire ignorate se il cambiamento non è massiccio (per evitare eccessivo traffico). In questi casi il nodo prende per buono il numero di nodi come riportato dal percorso più veloce. Userà questa informazione per calcolare il numero di nodi (stimato) all'interno del suo g-nodo di livello i+1.

Netsukuku Address

Il Netsukuku address è l'indirizzo di una risorsa all'interno della rete, ad esempio un nodo o un g-nodo. Devono essere noti i parametri della topologia gerarchica della rete:

• numero di livelli in cui la rete è suddivisa (l);

• per ogni livello i, numero di posizioni in quel livello (gsize(i));

Dati questi parametri, un indirizzo di nodo è composto da un identificativo per ogni livello da l-1 a 0. Invece, un indirizzo di g-nodo di livello i è composto da un identificativo per ogni livello da l-1 a i.

Per convenienza, diciamo che i parametri della topologia fanno parte dell'indirizzo.

Per rappresentare gli indirizzi di nodi e g-nodi definiamo la classe Naddr. Gli indirizzi di g-nodi li chiamiamo PartialNaddr anche se la classe che li istanzia è la stessa.

Un nodo conosce, per requisito, il suo indirizzo e da questo può costruire gli indirizzi che rappresentano ognuno dei g-nodi di cui fa parte.

Un nodo può venire a conoscenza di Naddr e PartialNaddr di qualsiasi punto della topologia, cioè che non hanno necessariamente in comune il livello direttamente superiore con uno dei g-nodi di cui il nodo è membro.

Se un Naddr o PartialNaddr ha il suo livello direttamente superiore in comune con il nodo corrente, tale indirizzo può essere espresso sotto forma di HCoord (coordinate gerarchiche).

Nota: spostare nei dettagli tecnici. L'interfaccia del proprio indirizzo è distinta dalla interfaccia di un comune Naddr o PartialNaddr, perché solo partendo dal proprio indirizzo per il nodo corrente ha senso fare operazioni che coinvolgano le HCoord.

Requisiti

• Indirizzo Netsukuku del proprio nodo.
• Numero massimo di percorsi per destinazione da memorizzare.

• Massimo rapporto di hops comuni nella verifica di disgiunzione (vedi documento percorsi disgiunti).

• Archi che esistono tra il nodo e i suoi vicini.
• Durante le sue operazioni, il modulo viene informato alla costituzione di un nuovo arco; alla rimozione di un arco; al cambio di costo di un arco.

• Nota: spostare nei dettagli tecnici. Allo stesso tempo questo modulo può segnalare che rimuove un arco perché non funziona, di modo che l'utilizzatore del modulo lo viene a sapere e può prendere misure in merito (ad esempio chiedere al modulo Neighborhood di rimuoverlo); questa segnalazione il modulo QSPN la fa con un segnale.

• Il suo fingerprint come nodo (istanza di IQspnFingerprint).

• Nota: spostare nei dettagli tecnici. In ogni messaggio ETP inviato viene passato anche l'array dei fingerprint di tutti i g-nodi di cui il nodo è parte.

• Oggetto per calcolare il lasso temporale di tolleranza prima di segnalare il rilevamento di split di un g-nodo.
• Factory per creare uno "stub" per invocare metodi remoti nei vicini.
• Factory per la produzione di istanze di una classe serializzabile ETP.

Deliverables

• Emette un segnale per:
  • fallito hook nella rete.
  • il modulo è ora maturo.
  • rimosso un arco, perché non funzionava.
  • nuovo g-nodo nella mappa, rimosso g-nodo dalla mappa.
  • nuovo percorso, percorso cambiato o percorso rimosso per un certo g-nodo.
  • cambio nel fingerprint di uno dei miei g-nodi.
  • cambio nel numero di nodi interni ad uno dei miei g-nodi.
  • rilevamento di un g-nodo splittato.
• Fornisce metodi per:
  • Chiedere se il nodo è maturo nella rete. Restituisce un booleano.

  • Relativamente ad un g-nodo a cui il nodo non appartiene, vale a dire dato un HCoord, ottenere tutti i percorsi a disposizione per raggiungerlo, con i relativi costi. Restituisce una lista di IQspnNodePath. Se il nodo non è maturo lancia eccezione QspnNotMatureError.

  • Relativamente ad uno dei g-nodi a cui appartiene il nodo, vale a dire dato un livello da 0 a l compresi, ottenere:

    • il fingerprint del g-nodo. Restituisce un IQspnFingerprint. Se il nodo non è maturo lancia eccezione QspnNotMatureError.

    • una stima del numero di nodi al suo interno. Restituisce un intero. Se il nodo non è maturo lancia eccezione QspnNotMatureError.

Classi e interfacce

L'oggetto che rappresenta gli indirizzi non è del tutto noto a questo modulo, che conosce alcune sue interfacce a seconda dell'uso che può farne.

Per il proprio indirizzo il nodo conosce l'interfaccia IQspnMyNaddr, per gli indirizzi di altri nodi conosce l'interfaccia IQspnNaddr, per gli indirizzi di g-nodi conosce l'interfaccia IQspnPartialNaddr.

Questi i metodi delle interfacce note al modulo:

• IQspnNaddr

  • leggere i parametri della topologia della rete, cioè l e gsize(i) con i da 0 a l-1;

  • leggere pos(i) di questo indirizzo, con i da 0 a l-1.

• IQspnMyNaddr (che richiede IQspnNaddr)
  • dato un HCoord ottenere il IQspnPartialNaddr (nodo o g-nodo) riferito; il metodo 'i_qspn_get_address_by_coord' restituisce un IQspnPartialNaddr che quindi è anche un IQspnNaddr.
  • dato un IQspnNaddr (nodo o g-nodo) ottenere il HCoord riferito al g-nodo che lo contiene; come effetto collaterale ottengo anche il minimo livello comune; il metodo 'i_qspn_get_coord_by_address' prende come argomento un IQspnNaddr che accetta quindi anche un IQspnPartialNaddr.
• IQspnPartialNaddr (che richiede IQspnNaddr)
  • leggere il livello del g-nodo; può essere 0 se questa istanza potrebbe rappresentare sia un g-nodo sia un nodo.

La classe HCoord è nota a questo modulo. Una sua istanza contiene le coordinate gerarchiche di un g-nodo nella mappa del nodo: livello e identificativo nel livello.

Con tali coordinate e l'istanza di IQspnMyNaddr del proprio nodo si può ottenere una istanza di IQspnPartialNaddr che rappresenta il g-nodo.

In vari casi è necessario rappresentare una serie di hop percorsi da un TP, oppure un percorso noto verso una destinazione. Questa serie di hop la chiamiamo TP-List. Si tratta di una lista di HCoord. Include in testa la coordinata che rappresenta il vicino che usiamo come gateway (o meglio il suo massimo distinto g-nodo rispetto a noi) e in coda la coordinata che rappresenta la destinazione.

Una TP-List è sempre in termini di g-nodi che hanno il g-nodo superiore in comune con questo nodo.

Non viene definita una classe per contenere questa informazione: si usa una lista di HCoord.

Il fingerprint di un g-nodo è un oggetto che il modulo non istanzia da solo; gli viene passato il suo fingerprint di nodo (a livello 0) e il modulo ne conosce l'interfaccia IQspnFingerprint. Il modulo inoltre assume che sia una istanza di ISerializable.

L'interfaccia IQspnFingerprint consente di:

• Confrontare due fingerprint per stabilire se sono identici (metodo 'i_qspn_equals').
• ?? Leggere il livello del g-nodo a cui appartiene (proprietà 'i_qspn_level').
• Confrontare due fingerprint discordi riferiti allo stesso g-nodo e decidere quale sia più anziano (metodo 'i_qspn_elder').

• Sul fingerprint del proprio g-nodo g di livello i, dati i fingerprint di tutti gli altri g-nodi conosciuti di livello i dentro il mio g-nodo h di livello i+1, ottenere l'istanza di fingerprint del g-nodo h (metodo 'i_qspn_construct').

Il costo di un arco e il costo di un percorso sono rappresentati da istanze di una classe non del tutto nota a questo modulo. La sua interfaccia nota al modulo (IQspnREM) gli consente di:

• sommare il costo di un percorso a quello di un arco (metodo 'i_qspn_add_segment');
• comparare il costo di due percorsi, valutando quale sia il minore (metodo 'i_qspn_compare_to')

Il costo di un percorso, che viene pubblicizzato al modulo QSPN da un vicino, può essere un costo fittizio per indicare una certa situazione – come null per indicare che la destinazione è proprio il vicino, o dead per indicare che il percorso non è più funzionante. Invece il costo di un arco, che viene passato al modulo QSPN dal suo utilizzatore, è sempre un valore frutto di una reale misurazione. Infatti non ha alcun significato un arco verso me stesso, e un arco non funzionante viene semplicemente rimosso.

Un arco è un oggetto il cui contenuto non è del tutto noto al modulo QSPN. L'interfaccia di questo oggetto nota al modulo (IQspnArc) gli consente di:

• verificare se due archi sono identici (metodo 'i_qspn_equals');
• leggere l'indirizzo Netsukuku del vicino (metodo 'i_qspn_get_naddr');
• leggere il costo associato all'arco (metodo 'i_qspn_get_cost').

Un ETP è una istanza della classe EtpMessage che è interna al modulo. Essa è serializzabile. Un ETP contiene:

• L'indirizzo del nodo n che produce l'ETP.

• La lista di fingerprint per i g-nodi di n ai livelli da 0 a l-1.

• La lista del numero approssimativo di nodi all'interno dei g-nodi di n ai livelli da 0 a l-1.

• La lista dei g-nodi attraversati da questo ETP.

• La lista P dei percorsi. Ogni percorso p ∈ P è una istanza di EtpPath (descritta più sotto) che contiene:

  • La lista dei g-nodi che costituiscono il percorso p, da n escluso fino a d incluso.

  • Il costo di p da n a d.

  • Il fingerprint del g-nodo d.

  • Il numero approssimativo di nodi all'interno del g-nodo d.

La prima volta che un nodo produce un ETP la sua mappa è vuota, quindi la lista dei percorsi P è vuota. Ci sono due informazioni che vanno inserite nell'ETP e che sono rappresentate con classi che il modulo non conosce: il fingerprint dei suoi g-nodi ai vari livelli e il suo indirizzo di nodo.

Al modulo viene passato l'indirizzo del nodo come istanza dell'interfaccia IQspnMyNaddr, che a sua volta richiede l'interfaccia IQspnNaddr. Nell'ETP va inclusa una istanza di IQspnNaddr, quindi questa istanza va bene. Il modulo assume che l'istanza sia anche una istanza di ISerializable.

Al modulo viene passato il fingerprint del nodo a livello 0 come istanza dell'interfaccia IQspnFingerprint. Anche questa si assume che sia un ISerializable. Inoltre, tramite il metodo i_qspn_construct chiamato sull'istanza del fingerprint a livello 0 e passando un set vuoto (ci riferiamo sempre ad un nodo con la mappa ancora vuota), gli viene restituita un'altra istanza di IQspnFingerprint che è il fingerprint del suo g-nodo a livello 1. Anche questa si assume che sia un ISerializable. E così via.

La lista del numero approssimativo di nodi all'interno dei propri g-nodi ai vari livelli, per un nodo con la mappa ancora vuota è banalmente una lista con l volte il valore 1.

Ogni g-nodo nell'ETP è espresso come HCoord, una classe serializzabile che il modulo conosce.

In conclusione il modulo è in grado di costruire una istanza della classe EtpMessage con i dati necessari e serializzarla per usarla nelle chiamate a metodi remoti.

Quando il modulo riceve una istanza di EtpMessage che gli viene trasmessa in una chiamata a metodo remoto, questa contiene le istanze degli oggetti che l'utilizzatore del modulo ha costruito e che il modulo continua a conoscere solo in quanto implementazioni delle interfacce a lui note. Inoltre riconoscendo l'arco a da cui ha ricevuto il messaggio può ottenere l'istanza di IQspnREM che rappresenta il suo costo. Anche questa si assume che sia un ISerializable.

Quindi il modulo comincia a popolare la mappa del nodo. Infatti: chiamiamo n il nodo che ci ha inviato l'ETP e v il nodo corrente; anche quando la lista P nell'ETP ricevuto fosse vuota, l'ETP contiene intrinsecamente un percorso verso il massimo distinto g-nodo di n per v. Per rappresentare questo percorso intrinseco, il modulo nel nodo v costruisce una istanza della classe EtpPath con questi dati:

• La TP-List è composta da un solo hop che è il massimo distinto g-nodo di n per v.

• Il costo del percorso è null. Esso rappresenta il costo da n ad n.

• Il fingerprint del g-nodo è il fingerprint indicato nell'ETP al livello del massimo distinto g-nodo di n per v.

• Il numero di nodi nel g-nodo è il numero di nodi indicato nell'ETP al livello del massimo distinto g-nodo di n per v.

In tutte le istanze di EtpPath ricevute nell'ETP (più quella costruita come detto adesso per rappresentare il percorso intrinseco) il costo del percorso rappresenta il costo da n alla destinazione. Invece il costo da v ad n è il costo dell'arco a. Questo dato è già memorizzato nell'oggetto arco che comunque il modulo deve mantenere associato al percorso, per questo nella mappa interna del nodo v ogni percorso è in realtà memorizzato come istanza della classe NodePath (descritta più sotto) la quale include l'istanza di EtpPath.

La prossima volta che il nodo v produce un ETP la sua mappa non sarà più vuota. Sia q una istanza di NodePath della mappa di v che va comunicata. Indichiamo con q.path l'istanza di EtpPath inclusa in q. Indichiamo con q.arc l'istanza di IQspnArc inclusa in q. Il nodo v prepara una nuova istanza di EtpPath copiando tutte le informazioni da q.path; ma come costo dovrà indicare la somma dei costi q.path.cost e q.arc.cost.

Un percorso scritto nella lista P di un ETP è una istanza della classe EtpPath che è interna al modulo. Essa è serializzabile. Contiene:

• La TP-List (lista di hops) che costituisce questo percorso dal primo vicino del nodo fino alla destinazione.
• Il costo del percorso (escluso il costo dell'arco dal nodo al vicino). E' una istanza dell'interfaccia IQspnREM. Il modulo assume che sia anche un ISerializable.
• Il fingerprint del g-nodo come riportato da questo percorso. E' una istanza dell'interfaccia IQspnFingerprint. Il modulo assume che sia anche un ISerializable.
• Il numero di nodi nel g-nodo come riportato da questo percorso.

La classe NodePath è interna al modulo. Una sua istanza rappresenta un percorso da questo nodo alla destinazione comprensivo dell'arco dal nodo al vicino che ha pubblicizzato il percorso. Contiene:

• L'arco da usare come primo hop (istanza dell'interfaccia IQspnArc).

• Il percorso come è stato pubblicizzato dal vicino attraverso questo arco (istanza di EtpPath).

Il percorso fornito dal metodo pubblico del modulo non ha le stesse informazioni usate internamente al modulo e presenti nella classe NodePath. Si usa un'altra classe, RetPath. Anche questa è una classe interna al modulo. La sua interfaccia nota all'esterno del modulo (IQspnNodePath) consente di:

• Leggere la destinazione come IQspnPartialNaddr.
• Leggere l'arco come IQspnArc.
• Leggere gli hops successivi come IQspnPartialNaddr.
• Leggere il costo come IQspnREM.
• Leggere il numero di nodi.

La stub factory è un oggetto di cui il modulo conosce l'interfaccia IQspnStubFactory. Tramite essa il modulo può:

• Creare uno stub per chiamare un metodo in broadcast su tutti i propri vicini (con callback per gli archi in cui il messaggio fallisce); il modulo può opzionalmente indicare un arco per ottenere uno stub che invia un messaggio destinato a tutti tranne che al nodo collegato tramite quell'arco.
• Creare uno stub per chiamare un metodo in modo reliable su un vicino tramite un dato arco.

Se per un g-nodo g vengono rilevati due percorsi (istanze di IQspnNodePath) che differiscono per il loro fingerprint e se questa situazione si mantiene per un certo lasso di tempo, questo è sintomo dello split del g-nodo g.

Per valutare quanto deve attendere prima di segnalare lo split del g-nodo, al modulo viene fornito un oggetto dal suo utilizzatore, che implementa l'interfaccia IQspnThresholdCalculator. Tramite essa il modulo può:

• Calcolare, passando un paio di istanze di IQspnNodePath che rappresentano i percorsi discordi, il tempo di tolleranza che deve passare da quando si verifica il disallineamento per poter segnalare lo split del g-nodo.