Red de conocimiento de divisas - Consulta hotelera - Explicación del código fuente de IPFS (4)-p2p

Explicación del código fuente de IPFS (4)-p2p

paquete p2p

importación(

"contexto"

"error"

"tiempo"

net " GX/IPFS/QMPJVXTPVH 8 QJYQDNXNSXF 9KV 9 JEZKD 1 KOZZ 1 HS 3 FCGSNH/Go-Lib P2P-NET "

MANET" GX/qmv 6 FJEMM 1K 8 0X JR VUQ 3 WUVwwou 2 TLDPMN nkrxhzy 3V 6 ai/go-multi addr-net "

ma " GX/ipfs/qmymsdtj 3 hsodkepe 3 eu 3 tscap 2 yvpzj 4 loxnnkde 5 tpt 7/go-multi addr "

pro " GX/ipfs/qmznkthpqfvxs 9 gnbexprfbbxslnyekre 7 jwfm 2 oqhbyqn/go-libp2p-protocol "

p store " GX/ipfs/qmzr 2 xwvvbcbtbgbwnqhwk 2 xcqfar 3 w8 faqpriaaj 7 RSR/go-libp 2p- compañero store "

p2phost " GX/ipfs/qmb 8t 6 ybbsjysvgfrihqlfcjvcezznnesbqbkkyebwdjge/go-libp2p-host "

peer " GX/ipfs/qmdvrmn 1 lhb 4 ybb 8 hmvamlxna 8 xrsewmnk 6 yqxkxotcr vn /go-lib P2P-peer "

)

//La estructura P2P guarda la información de la transmisión/escucha actualmente en ejecución.

//La estructura P2P guarda la información del flujo/escucha que se está ejecutando actualmente

Tipo de estructura P2P {

//Escucha

Registro ListenerRegistry

//Flujo de datos

Registro de transmisión

//ID de nodo

Emparejamiento de identidad. Certificado de identidad

//Dirección de nodo

peerHost p2phost. Host

//Almacén de pares seguro para subprocesos

peerstore pstore. Pierce Stoll

}

//Crear una nueva estructura p2p

// NewP2PCrear una nueva estructura P2P

//Este El nuevo La estructura p2p no contiene los oyentes ni los flujos de datos en la estructura p2p.

func NewP2P(identidad peer.ID, peerHost p2phost.host peerstore pstore.Peerstore) *P2P {

return & ampP2P{

identidad:identidad,

Pilhorst:Pilhorst,

peerstore: peerstore,

}

}

//Crear nuevos datos Método de herramienta de flujo para construir el flujo con ID de nodo, contenido y protocolo.

func (p2p P2P) newStreamTo(ctx2 context. context, p peer. ID, protocolo string) (net. stream, error) {

//se producirá automáticamente después de 30 segundos afuera.

ctx,cancelar:= contexto. ConTimeout(ctx2, time.

Segundos 30) //TODO: ¿Configurable?

DelayCancel()

err := p2p.peerHost.Connect(ctx, pstore.PeerInfo{ID: p})

Si error! = cero {

Devuelve cero, error

}

Devuelve p2p.peerHost.NewStream(ctx2, p, pro. ID (protocolo))

}

//La conversación crea una nueva transmisión P2P para el oyente remoto.

//Crea una nueva transmisión p2p para monitorear la sesión.

// Dial crea una nueva transmisión P2P para el oyente remoto

//Multiaddr es una dirección de Internet multiprotocolo y multiplataforma. Enfatiza la claridad y la autodescripción.

//Recepción interna

func (p2p P2P) dial(ctx context. context, dirección ma. multidirección, peer. ID, cadena prototipo, bindAddr ma. Multiaddr) ( ListenerInfo, error) {

//Obtener información del nodo de la red, host, nulo.

lnet, _, err := manet. DialArgs(bindAddr)

Si se equivoca! =cero{

Devuelve cero, error

}

//Información de monitoreo

listenerInfo := ListenerInfo{

//Identificación del nodo

Identidad: p2p.identity,

///Identificador del protocolo de aplicación.

Protocolo: proto,

}

//Llame a newStreamTo para obtener el nuevo a través del proto ctx (contenido) peer (id de nodo) ( identificador de protocolo) flujo de datos de parámetros.

remoto, err := p2p.newStreamTo(ctx, peer, proto)

Si err! =cero{

Devuelve cero, error

}

//Identificación del protocolo de red

Cambiar lnet {

//La red es "TCP", "TCP 4", "TCP 6".

Caso "tcp", "tcp4", "tcp6":

//Obtener nueva información del oyente nla. oyente, nil

Oyente, err := manet. Escuche(bindAddr)

Si se equivoca! =cero{

si err2 := remoto. restablecer();err2! =cero{

Devuelve cero, error 2

}

Devuelve cero, error

}

/ /Guardar la nueva información obtenida en listeningerInfo.

Información del oyente. dirección = oyente. multiAddress()

listenerInfo. close=oyente

listenerInfo. run=true

//abrir para aceptar

ir a P2P aceptar(& listenerInfo, remoto, oyente)

Predeterminado:

Devuelve cero, error. new("protocolo no compatible:" + lnet)

}

return & amplistenerInfo, cero

}

//< /p >

func(P2P * P2P) acepta (información del oyente * información del oyente, transmisión de red remota, manet. del oyente) {

//Cierre el oyente y elimine el controlador de transmisión.

Retrasar al oyente.

close()

//Devuelve conexiones multidireccionales compatibles

//Interfaz con buenas conexiones multidireccionales

local, error:= oyente. aceptar()

si se equivoca! =cero{

Retorno

}

stream := StreamInfo{

//Protocolo de conexión

Protocolo : información del oyente. Protocolo,

//Nodo de ubicación

LocalPeer: listenerInfo. Identidad,

//Dirección del nodo de ubicación

LocalAddr: listenerInfo. Dirección,

//Nodo remoto

RemotePeer: remoto. conectar(). RemotePeer(),

//Dirección del nodo remoto

RemoteAddr: remoto. conectar(). RemoteMultiaddr(),

//Posicionamiento

Local: local,

//Remoto

Remoto: remoto,

//Código de registro

Tabla de registro: & ampp2p. Transmitir,

}

//Registrar información de conexión

p2p. Registrarse (y transmitir)

//Difusión de nodo abierto

stream.startStreaming()

}

//El oyente transmitirá los controladores están envueltos en los oyentes.

//El oyente envuelve el controlador de transmisión en el oyente.

Escriba la interfaz del oyente {

Accept() (net.stream, Error)

Close()Error

}

//P2PListener guarda información sobre el oyente.

// P2PListener contiene información sobre el oyente

Etiqueta de estructura P2PListener

peerHost p2phost. Alojado

Conch Greedy Network. transmitir

proto pro. Identidad

Contexto ctx. Contexto

Cancelar función()

}

//Esperando a que el oyente se conecte.

//Aceptar espera una conexión del oyente

func(il * P2PListener)Accept()(net. stream, error) {

Seleccione {

Caso c:= <-il.conCh:

Devuelve c, cero

Caso <-il.ctx.Done():

return nil, il.ctx.Err()

}

}

//Cierre el oyente y elimine el controlador de transmisión.

// Cerrar cierra el oyente y elimina el controlador de transmisión

func (il *P2PListener) Close() error {

il.cancel()

il . peer host . removestreamhandler(il . proto)

Devuelve cero

}

// Listen crea un nuevo P2PListener.

//Listen crea un nuevo P2PListener

func(P2P P2P)registerStreamHandler(CT x2 context. context, protocolo string)(P2PListener, error){

ctx, cancelar: = contexto.

con cancel(ctx2)

List:= & ampP2PListener{

peerHost: p2p.peerHost,

proto: pro. ID (acuerdo),

Concha: hacer (禞网.Stream),

ctx: ctx,

Cancelar: cancelar,

}

P2P . peer host . setstreamhandler(list . proto, func(s net. stream) {

Seleccione {

lista de casos . conch & lt ;- s:

caso<ctx.done():

southreset()

}

})

p>

Lista de retorno, cero

}

// NewListener crea un nuevo oyente p2p.

//NewListener crea un nuevo oyente p2p

//Transmisión externa

func (p2p P2P) NewListener(ctx contexto. contexto, cadena prototipo, dirección ma . Multiaddr) (ListenerInfo, error) {

//Llame a RegisterStreamHandler para construir un nuevo oyente.

oyente, err:= P2P.registerstreamhandler(CTX, proto)

Si error! =cero{

Devuelve cero, error

}

//Construye una nueva información de escucha

listenerInfo:= ListenerInfo{

Identidad: p2p.identity,

Protocolo: proto,

Dirección: addr,

Cierre: oyente,

En ejecución: verdadero,

registro:&p2p. Oyentes,

}

vayan a P2P. Aceptar transmisiones(& listenerInfo, oyente)

//Registrar información de conexión

p2p. audiencia. Registrarse(&listenerInfo)

Devolver &listenerInfo, cero

}

//Aceptar transmisión

func(P2P * P2P)aceptar transmisiones( Información del oyente * Información del oyente, oyente Oyente) {

Para listenerInfo. ejecute {

//Un control remoto con una buena conexión remota

, error:= oyente. aceptar()

si se equivoca! =cero{

Oyente. Close()

Roto

}

}

//Cancelar el oyente p2p en el registro

p2p. oyentes .de registrarse(listener info.protocol)

}

// CheckProtoExists comprueba si el controlador de protocolo se ha registrado.

//Manejador multiplex

// CheckProtoExists comprueba si el controlador de protocolo está registrado en

//Manejador multiplex

func(P2P * P2P) comprobar que existe proto (cadena de proto) bool {

protos := p2p.peerHost.Mux().

protocolo()

para _, p := rango de protos {

si p! =Prototipo

Continuar

}

Devuelve verdadero

}

Devuelve falso

}

上篇: ¿Quién ganó el Mundial de 1998? 下篇: ¿Qué tipo de combinación es Kara? ¿Son tan populares como Girls' Generation?
Artículos populares