Infrastruttura di eventi peer

Articolo
06/12/2023

L'infrastruttura peer usa eventi per notificare alle applicazioni le modifiche che si sono verificate all'interno di una rete peer, ad esempio un nodo aggiunto o rimosso da un grafico. Le infrastrutture peer graphing e peer grouping usano l'infrastruttura di eventi peer.

Ricezione della notifica degli eventi peer

Un peer può registrarsi per ricevere una notifica quando si verifica un attributo di un grafico o di un gruppo o un evento peer specifico. Un'applicazione peer chiama la funzione PeerGraphRegisterEvent o PeerGroupRegisterEvent e passa un handle di evento all'infrastruttura peer, creata in precedenza da una chiamata a CreateEvent. L'infrastruttura peer usa l'handle per segnalare a un'applicazione che si è verificato un evento peer.

L'applicazione passa anche una serie di strutture PEER_GRAPH_EVENT_REGISTRATION o PEER_GROUP_EVENT_REGISTRATION che indicano all'infrastruttura peer gli eventi peer specifici per cui l'applicazione richiede la notifica. L'applicazione deve anche specificare esattamente il numero di strutture passate.

Eventi di peer graphing

Un'applicazione Peer Graphing può registrarsi per ricevere una notifica per 9 eventi del grafico peer. Ogni nome di evento è preceduto da PEER_GRAPH_EVENT_, ad esempio PEER_GRAPH_STATUS_CHANGED. Se non diversamente specificato, le informazioni su una modifica vengono recuperate tramite PeerGraphGetEventData.

PEER_GRAPH_EVENT_STATUS_CHANGED indica che lo stato di un grafico viene modificato, ad esempio un nodo è sincronizzato con un grafico.
PEER_GRAPH_EVENT_PROPERTY_CHANGED indica che è stata modificata una proprietà di un grafico o di un gruppo, ad esempio il nome descrittivo di un grafico.

Nota

L'applicazione deve chiamare PeerGraphGetProperties per ottenere le informazioni modificate.
PEER_GRAPH_EVENT_RECORD_CHANGED indica che viene modificato un record, ad esempio un record viene eliminato.
PEER_GRAPH_EVENT_DIRECT_CONNECTION indica che viene modificata una connessione diretta, ad esempio un nodo è connesso.
PEER_GRAPH_EVENT_NEIGHBOR_CONNECTION indica che viene modificata una connessione a un nodo adiacente, ad esempio un nodo è connesso.
PEER_GRAPH_EVENT_INCOMING_DATA indica che i dati sono stati ricevuti da una connessione diretta o adiacente.
PEER_GRAPH_EVENT_CONNECTION_REQUIRED indica che l'infrastruttura graphing richiede una nuova connessione.

Nota

Una chiamata a PeerGraphConnect si connette a un nuovo nodo. Una chiamata a PeerGraphGetEventData non restituisce dati.
PEER_GRAPH_EVENT_NODE_CHANGED indica che le informazioni sulla presenza del nodo sono state modificate, ad esempio un indirizzo IP.
PEER_GRAPH_EVENT_SYNCHRONIZED indica che un tipo di record specifico è sincronizzato.

Dopo che un'applicazione riceve la notifica che si è verificato un evento peer, l'applicazione chiama PeerGraphGetEventData e passa l'handle dell'evento peer restituito da PeerGraphRegisterEvent. L'infrastruttura peer restituisce un puntatore a una struttura PEER_GRAPH_EVENT_DATA che contiene i dati richiesti. Questa funzione deve essere chiamata fino a quando non viene restituita PEER_S_NO_EVENT_DATA.

Dopo che un'applicazione non richiede una notifica di evento peer, l'applicazione chiama PeerGraphUnregisterEvent e passa l'handle dell'evento peer restituito da PeerGraphRegisterEvent quando l'applicazione è stata registrata.

Gestione delle segnalazioni di connessione graph

Quando viene chiamato PeerGraphConnect , il peer di connessione riceve una notifica di esito positivo o negativo tramite l'evento di PEER_GRAPH_EVENT_NEIGHBOR_CONNECTION asincrono. Se la connessione non è riuscita a causa di problemi di rete specifici, ad esempio un firewall non configurato correttamente, viene generato l'evento PEER_GRAPH_EVENT_NEIGHBOR_CONNECTION , con lo stato della connessione impostato su PEER_CONNECTION_FAILED.

Tuttavia, quando un peer riceve una segnalazione quando tenta di connettersi a un nodo occupato, il PEER_GRAPH_EVENT_NEIGHBOR_CONNECTION viene generato nel peer di connessione, con lo stato della connessione impostato su PEER_CONNECTION_FAILED. Il peer di connessione può essere indicato a un altro nodo che è occupato e può inviare una segnalazione e lo stesso evento e lo stesso stato vengono generati nel peer di connessione. Questa catena di segnalazioni che generano PEER_CONNECTION_FAILED gli stati degli eventi possono continuare fino a quando il numero massimo di tentativi di connessione non è stato esaurito. Il peer non dispone di un meccanismo per determinare la differenza tra un tentativo di connessione completo e la segnalazione di connessione.

Per risolvere questo problema, gli sviluppatori devono prendere in considerazione l'uso degli eventi di modifica dello stato del grafico peer per determinare se il tentativo di connessione è stato eseguito. Se l'evento non viene ricevuto entro un periodo di tempo specifico, l'applicazione può presupporre che venga fatto riferimento al peer di connessione e che l'applicazione peer debba considerare il tentativo di connessione un errore.

Eventi di raggruppamento peer

Un'applicazione peer grouping può registrarsi per ricevere una notifica per 8 eventi peer. Ogni nome di evento è preceduto da PEER_GROUP_EVENT_; ad esempio , PEER_GROUP_EVENT_STATUS_CHANGED. Se non diversamente specificato, le informazioni su una modifica vengono recuperate tramite PeerGroupGetEventData.

PEER_GROUP_EVENT_STATUS_CHANGED indica che lo stato del gruppo è stato modificato. Sono possibili due valori di stato: PEER_GROUP_STATUS_LISTENING, che indica che il gruppo non dispone di connessioni ed è in attesa di nuovi membri; e PEER_GROUP_STATUS_HAS CONNECTIONS, che indica che il gruppo ha almeno una connessione. Questo valore di stato può essere ottenuto chiamando PeerGroupGetStatus dopo la generazione di questo evento.
PEER_GROUP_EVENT_PROPERTY_CHANGED indica che le proprietà del gruppo sono state modificate o aggiornate dall'autore del gruppo.
PEER_GROUP_EVENT_RECORD_CHANGED indica che è stata eseguita un'operazione di record. Questo evento viene generato quando un peer che partecipa al gruppo pubblica, aggiorna o elimina un record. Ad esempio, questo evento viene generato quando un'applicazione di chat invia un messaggio di chat.
PEER_GROUP_EVENT_MEMBER_CHANGED indica che lo stato di un membro all'interno del gruppo è cambiato. Le modifiche dello stato includono:
- PEER_MEMBER_CONNECTED. Un peer è connesso al gruppo.
- PEER_MEMBER_DISCONNECTED. Un peer è disconnesso dal gruppo.
- PEER_MEMBER_JOINED. Sono state pubblicate nuove informazioni sull'appartenenza per un peer.
- PEER_MEMBER_UPDATED. Un peer ha aggiornato con nuove informazioni, ad esempio un nuovo indirizzo IP.
PEER_GROUP_EVENT_NEIGHBOR_CONNECTION. I peer che partecipano alle connessioni adiacenti all'interno del gruppo devono registrarsi per questo evento. Si noti che la registrazione per questo evento non consente al peer di ricevere dati; la registrazione per questo evento garantisce la notifica solo quando viene ricevuta una richiesta per una connessione adiacente.
PEER_GROUP_EVENT_DIRECT_CONNECTION. I peer che partecipano alle connessioni dirette all'interno del gruppo devono registrarsi per questo evento. Si noti che la registrazione per questo evento non consente al peer di ricevere dati; la registrazione per questo evento garantisce la notifica solo quando viene ricevuta una richiesta per una connessione diretta.
PEER_GROUP_EVENT_INCOMING_DATA. I peer che riceveranno dati tramite una connessione vicina o diretta devono registrarsi per questo evento. Quando questo evento viene generato, i dati opachi trasmessi dall'altro peer partecipante possono essere ottenuti chiamando PeerGroupGetEventData. Si noti che per ricevere questo evento, il peer deve essere registrato in precedenza per PEER_GROUP_EVENT_DIRECT_CONNECTION o PEER_GROUP_EVENT_NEIGHBOR_CONNECTION.
PEER_GROUP_EVENT_CONNECTION_FAILED. Una connessione non è riuscita per qualche motivo. Non vengono forniti dati quando viene generato questo evento e PeerGroupGetEventData non deve essere chiamato.

Dopo che un'applicazione riceve la notifica che si è verificato un evento peer (escluso PEER_GROUP_EVENT_CONNECTION_FAILED), l'applicazione chiama PeerGroupGetEventData e passa l'handle dell'evento peer restituito da PeerGroupRegisterEvent. L'infrastruttura peer restituisce un puntatore a una struttura PEER_GROUP_EVENT_DATA che contiene i dati richiesti. Questa funzione deve essere chiamata fino a quando non viene restituita PEER_S_NO_EVENT_DATA. Quando un'applicazione non richiede più una notifica per un evento peer, è necessario effettuare una chiamata a PeerGroupUnregisterEvent, passando l'handle dell'evento peer restituito da PeerGroupRegisterEvent quando l'applicazione registrata per l'evento specifico.

Esempio di registrazione per gli eventi di peer graphing

L'esempio di codice seguente illustra come eseguire la registrazione con gli eventi peer graphing.

//-----------------------------------------------------------------------------
// Function: RegisterForEvents
//
// Purpose:  Registers the EventCallback function so it can be called for only
//           the events that are specified.
//
// Returns:  HRESULT
//
HRESULT RegisterForEvents()
{
    HPEEREVENT  g_hPeerEvent = NULL;        // The one PeerEvent handle
    HANDLE      g_hEvent = NULL;            // Handle signaled by Graphing when we have an event
    HRESULT hr = S_OK;
    PEER_GRAPH_EVENT_REGISTRATION regs[] = {
        { PEER_GRAPH_EVENT_RECORD_CHANGED, 0 },
        { PEER_GRAPH_EVENT_NODE_CHANGED,   0 },
        { PEER_GRAPH_EVENT_STATUS_CHANGED, 0 },
        { PEER_GRAPH_EVENT_DIRECT_CONNECTION, 0 },
        { PEER_GRAPH_EVENT_INCOMING_DATA, 0 },
    };

    g_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (g_hEvent == NULL)
    {
        wprintf(L"CreateEvent call failed.\n");
        hr = E_OUTOFMEMORY;
    }
    else
    {
        hr = PeerGraphRegisterEvent(g_hGraph, g_hEvent, celems(regs), regs,  &g_hPeerEvent);
        if (FAILED(hr))
        {
           wprintf(L"PeerGraphRegisterEvent call failed.\n");
            CloseHandle(g_hEvent);
            g_hEvent = NULL;
        }
    }

    if (SUCCEEDED(hr))
    {
        if (!RegisterWaitForSingleObject(&g_hWait, g_hEvent, EventCallback, NULL, INFINITE, WT_EXECUTEDEFAULT))
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
            wprintf(L"Could not set up event callback.\n");
            CloseHandle(g_hEvent);
            g_hEvent = NULL;
        }
    }

    return hr;
}

Condividi tramite