Connessioni dirette

Le infrastrutture peer graphing e peer grouping consentono alle applicazioni di connettersi direttamente a un nodo (grafo) o a un membro (raggruppamento) e quindi scambiare i 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 grafo, entrambi i nodi devono essere registrati per l'evento PEER_GRAPH_EVENT_DIRECT_CONNECTION. Per ricevere dati tramite una connessione diretta, è necessario registrare anche i nodi 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 PeerGraphOpenDirectConnectione quindi passa un handle al grafo, 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. Al termine, PeerGraphOpenDirectConnection restituisce un ID di connessione a 64 bit. Tuttavia, il peer deve attendere l'evento PEER_GROUP_EVENT_DIRECT_CONNECTION prima che l'ID connessione diretta possa essere identificato come valido.

Dopo aver effettuato una connessione e aver confermato un ID di connessione valido, un'applicazione può chiamare PeerGraphSendData per inviare i dati attraverso la 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 nella PEER_EVENT_INCOMING_DATA restituita dall'evento PEER_GRAPH_EVENT_INCOMING_DATA.

Quando non è necessaria una connessione, un'applicazione chiama PeerGraphCloseDirectConnection con l'handle del grafo 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 poter stabilire una connessione diretta tra due membri di un gruppo, entrambi i membri devono registrarsi per l'evento PEER_GROUP_EVENT_DIRECT_CONNECTION. Se un membro del gruppo desidera 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 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 PeerGroupOpenDirectConnection viene restituito nella struttura PEER_GROUP_EVENT_DATA.

Per creare una connessione diretta, un'applicazione chiama PeerGroupOpenDirectConnectione quindi passa un handle al gruppo, un puntatore all'identità dell'altro membro che parteciperà a questa connessione e un puntatore a una struttura di indirizzi IPv6 per il membro partecipante. Il membro la cui identità e l'indirizzo IPv6 sono 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 quando ha esito positivo. Tuttavia, un peer deve attendere che venga generato l'evento PEER_GRAPH_EVENT_DIRECT_CONNECTION prima che l'ID connessione diretta possa essere identificato come valido.

Dopo aver effettuato una connessione e aver confermato un ID di connessione valido, un'applicazione può chiamare PeerGroupSendData per inviare dati in una connessione specificata dall'ID di 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 nella PEER_EVENT_INCOMING_DATA restituita dall'evento PEER_GROUP_EVENT_INCOMING_DATA.

Quando la connessione non è necessaria, l'applicazione chiama PeerGroupCloseDirectConnection con l'handle di 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;
}