Connessioni dirette

Le infrastrutture peer graphing e peer grouping consentono alle applicazioni di connettersi direttamente a un nodo (Grafico) o membro (Raggruppamento) e quindi scambiare dati direttamente con il nodo. Questa connessione viene chiamata connessione diretta.

Connessioni dirette tramite l'infrastruttura Peer Graphing

Prima di poter stabilire una connessione diretta tra due nodi in un grafico, entrambi i nodi devono essere registrati per l'evento PEER_GRAPH_EVENT_DIRECT_CONNECTION . Per ricevere i dati tramite una connessione diretta, i nodi devono essere registrati anche per l'evento PEER_GRAPH_EVENT_INCOMING_DATA .

PEER_GRAPH_EVENT_DIRECT_CONNECTION è un evento che notifica a un'applicazione se un tentativo di connessione diretta ha esito positivo o negativo. Lo stato effettivo di esito positivo o negativo di una chiamata a PeerGraphOpenDirectConnection viene restituito nella struttura PEER_GRAPH_EVENT_DATA .

Per creare una connessione diretta, un'applicazione chiama PeerGraphOpenDirectConnection e quindi passa un handle al grafico, un puntatore all'identità dell'altro nodo che partecipa alla connessione e un puntatore a una struttura di indirizzi IPv6 per il nodo partecipante. L'identità del nodo e l'indirizzo IPv6 specificati nella chiamata a PeerGraphOpenDirectConnection devono essere registrati per l'evento PEER_GRAPH_EVENT_INCOMING_DATA oppure non possono ricevere dati inviati da un peer chiamante. In caso di esito positivo, PeerGraphOpenDirectConnection restituisce un ID di connessione a 64 bit. Tuttavia, il peer deve attendere l'evento PEER_GROUP_EVENT_DIRECT_CONNECTION prima che sia possibile identificare l'ID connessione diretta come valido.

Dopo aver effettuato una connessione e viene confermato un ID di connessione valido, un'applicazione può chiamare PeerGraphSendData per inviare i dati nella connessione specificata dall'ID di connessione valido al peer partecipante, se il peer partecipante è registrato per l'evento PEER_GRAPH_EVENT_INCOMING_DATA . I dati opachi sono disponibili come struttura PEER_DATA nel PEER_EVENT_INCOMING_DATA restituito dall'evento PEER_GRAPH_EVENT_INCOMING_DATA.

Quando una connessione non è necessaria, un'applicazione chiama PeerGraphCloseDirectConnection con l'handle grafico e l'ID connessione.

Connessioni dirette tramite l'infrastruttura di raggruppamento peer

Le connessioni dirette all'interno dell'infrastruttura di raggruppamento peer vengono gestite in modo simile all'infrastruttura peer graphing.

Prima di stabilire una connessione diretta tra due membri in un gruppo, entrambi i membri devono registrarsi per l'evento PEER_GROUP_EVENT_DIRECT_CONNECTION . Se un membro del gruppo vuole ricevere dati tramite una connessione diretta, il membro del gruppo deve anche registrarsi per l'evento PEER_GROUP_EVENT_INCOMING_DATA .

PEER_GROUP_EVENT_DIRECT_CONNECTION è un evento che indica a un'applicazione se un tentativo di connessione diretta ha esito positivo o negativo. Lo stato effettivo di esito positivo o negativo di una chiamata a PeerGroupOpenDirectConnection viene restituito nella struttura PEER_GROUP_EVENT_DATA .

Per creare una connessione diretta, un'applicazione chiama PeerGroupOpenDirectConnection e quindi passa un handle al gruppo, un puntatore all'identità dell'altro membro che partecipa a questa connessione e un puntatore a una struttura di indirizzi IPv6 per il membro partecipante. Il membro l'identità e l'indirizzo IPv6 specificati nella chiamata a PeerGroupOpenDirectConnection devono essere registrati per l'evento PEER_GROUP_EVENT_INCOMING_DATA oppure il membro non può ricevere dati inviati da un peer chiamante. PeerGroupOpenDirectConnection restituisce un ID connessione a 64 bit al termine dell'operazione. Tuttavia, un peer deve attendere che l'evento PEER_GRAPH_EVENT_DIRECT_CONNECTION venga generato prima che l'ID connessione diretta possa essere identificato come valido.

Dopo aver effettuato una connessione e viene confermato un ID di connessione valido, un'applicazione può chiamare PeerGroupSendData per inviare dati in una connessione specificata dall'ID connessione valido al peer partecipante, se il peer partecipante è registrato per l'evento PEER_GROUP_EVENT_INCOMING_DATA . I dati opachi sono disponibili come struttura PEER_DATA nel PEER_EVENT_INCOMING_DATA restituito dall'evento PEER_GROUP_EVENT_INCOMING_DATA .

Quando la connessione non è necessaria, l'applicazione chiama PeerGroupCloseDirectConnection con l'handle del gruppo e l'ID connessione.

Esempio di connessione diretta per Graphing

#include <p2p.h>

#pragma comment(lib, "p2pgraph.lib")

//-----------------------------------------------------------------------------
// Function: CreateDirectConnection
//
// Purpose:  Demonstrate how to create a direct connection.
//
// Arguments:
//           hGraph - the graph in which to create the connection
//           pwzId  - the peer identification string
//
// Returns:  ULONGLONG - the connection id or 0
//

ULONGLONG CreateDirectConnection(HGRAPH hGraph, PCWSTR pwzId)
{
    HRESULT   hr = S_OK;

    ULONGLONG ullConnection = 0; // the connection id to return

    HPEERENUM hPeerEnum = NULL;
 
    hr = PeerGraphEnumNodes(hGraph, pwzId, &hPeerEnum);

    if (SUCCEEDED(hr))
    {
        ULONG cItem = 1; // want only one matching result

        PEER_NODE_INFO ** ppNodeInfo = NULL;

        hr = PeerGraphGetNextItem(hPeerEnum, &cItem, (PVOID**) &ppNodeInfo);

        if (SUCCEEDED(hr))
        {
            if ((cItem > 0) && (NULL != ppNodeInfo))
            {
                if ((*ppNodeInfo)->cAddresses > 0)
                {
                    hr = PeerGraphOpenDirectConnection(hGraph, pwzId,
                            &(*ppNodeInfo)->pAddresses[0], &ullConnection);
                }
                PeerGraphFreeData(ppNodeInfo);
            }
        }
        PeerGraphEndEnumeration(hPeerEnum);
    }
    return ullConnection;
}