Tutorial Nim-libp2p: Um Exemplo de Chat Ponto a Ponto (3)

Este artigo é o terceiro de uma série de três.

Olá a todos, bem-vindos ao último artigo da série de tutoriais da nim-libp2p!

Este tutorial é para todos que estão interessados ​​em construir aplicativos de chat ponto a ponto. Nenhuma experiência de programação em Nim é necessária.

Nesta parte, vamos orientá-lo sobre como configurar e estabelecer um nó libp2p. O código completo pode ser encontrado em nosso repositório principal directchat.nim

Espero que você ache útil. Bom aprendizado! ;)

Nota: Este tutorial está dividido em três partes conforme abaixo:

• Parte I: Configure a função principal e use multi-thread para processamento de entrada e saída.
• Parte II: Chamar ponto remoto e permitir comandos de entrada de usuário personalizados.
• Parte III (agora): Configurar e estabelecer um nó libp2p.

Antes que você comece

Vamos tentar rodar este exemplo no mesmo computador com pares rodando em duas portas diferentes!

Abra uma nova janela de terminal e digite o seguinte:

nim c -r --threads:on examples/directchat.nim

Pressione enter para usar o endereço padrão para nosso primeiro par.

Saída do terminal após executar directchat.nim e pressionar enter.

Abra outra janela do terminal e inicie nossa segunda porta.

nim c -r --threads:on examples/directchat.nim

Digite um endereço com uma nova porta (55504) para servir nossa segunda porta. Insira /ip4/127.0.0.1/tcp/55504 e pressione enter.

Saída do terminal depois de executar directchat.nim e digitar /ip4/127.0.0.1/tcp/55504.

Copie o endereço de nossa primeira porta do primeiro terminal e conecte-se à primeira porta digitando seu endereço no segundo terminal.

Saída do terminal após executar directchat.nim e inserir o endereço de outra porta para conectar.

Isso é tudo! As duas portas estão agora conectadas. Qualquer coisa que você digitar em um terminal aparecerá no outro terminal. :)

Comece a codificar!

Primeiro, para nos ajudar a distinguir do primeiro arquivo de código, renomeie nosso arquivo second.nim para final.nim. Esta etapa é opcional porque nosso código final será o mesmo do directchat.nim.

Crie um procedimento para inicializar o nó libp2p.

proc newChatProto(switch: Switch, transp: StreamTransport): ChatProto =
  var chatproto = ChatProto(switch: switch, transp: transp, codec: ChatCodec)

  # criar gerenciador para conexão de entrada
  proc handle(stream: Connection, proto: string) {.async.} =
    if chatproto.connected and not chatproto.conn.closed:
      echo "a chat session is already in progress - disconnecting!"
      await stream.close()
    else:
      chatproto.conn = stream
      chatproto.connected = true

  # atribuir o novo gerenciador
  chatproto.handler = handle
  return chatproto

No código acima, instituímos uma nova instância ChatProto nomeada chatproto com os valores passados, criamos um gerenciador para conexões de entrada e o atribuímos à nossa nova instância ChatProto.

Observe que usamos var em vez de let para chatproto aqui porque alteraremos o valor atribuído chatproto após sua declaração inicial.

Modifique o procedimento processInput para inicializar o endereço do nó pela entrada do usuário da seguinte forma:

proc processInput(rfd: AsyncFD) {.async.} =
  let transp = fromPipe(rfd)

  let seckey = PrivateKey.random(RSA, rng[]).get()
  var localAddress = DefaultAddr
  while true:
    echo &"Type an address to bind to or Enter to use the default {DefaultAddr}"
    let a = await transp.readLine()
    try:
      if a.len > 0:
        localAddress = a
        break
      # uise default
      break
    except:
      echo "invalid address"
      localAddress = DefaultAddr
      continue

Primeiro, geramos uma chave privada aleatória usando o esquema de criptografia RSA e usamos essa chave para inicializar nossa nova porta.

Em seguida, atribuímos o endereço padrão localAddress e o substituímos se o usuário inserir um endereço válido (com o formato multiaddress). Se um endereço inválido for inserido, definimos o endereço de volta ao padrão e continuamos ouvindo a entrada do usuário.

Construa o switch que vamos usar para nosso nó libp2p (adicione o seguinte ao procedimento processInput).

var switch = SwitchBuilder
    .init()
    .withRng(rng)
    .withPrivateKey(seckey)
    .withAddress(MultiAddress.init(localAddress).tryGet())
    .build()

  let chatProto = newChatProto(switch, transp)
  switch.mount(chatProto)
  let libp2pFuts = await switch.start()
  chatProto.started = true

Na parte final, transp foi usado ao instanciar com newChatProto para nos permitir processar as mensagens de entrada do usuário usando conexões. A variável libp2pFuts armazena uma sequência de Futuros que foram retornados após o início da troca.

Não esqueça de configurar chatProto.started para que true não imprima a mensagem de ajuda especificada no procedimento writeAndPrint anterior.

Imprima o ID da porta atual e o endereço de acesso após o nó ter iniciado (adicione o seguinte ao procedimento processInput).

let id = peerInfo.peerId.pretty
echo "PeerID: " & id
echo "listening on: "
for a in peerInfo.addrs:
  echo &"{a}/p2p/{id}"

Comece a ler e escrever mensagens e comandos simultaneamente e espere que tudo termine após a chamada switch.start()(adicione o seguinte ao procedimento processInput).

await chatProto.readWriteLoop()
await allFuturesThrowing(libp2pFuts)

Agora seu código deve ser o mesmo que directchat.nim. Execute-o e comece a experimentar seu primeiro aplicativo de chat libp2p.

nim c -r --threads:on examples/directchat.nim

Saída do terminal após executar directchat.nim e pressionar enter para iniciar uma portar que acessa o endereço padrão.

Conclusão

Parabéns por concluir todas as etapas deste exemplo de chat ponto a ponto! Agora você aprendeu como definir e estabelecer um nó libp2p personalizado.

Sinta-se à vontade para deixar comentários com feedbacks e sugestões. Obrigado pelo seu tempo de leitura. Até a próxima :)

Este artigo foi publicado por Lee Ting Ting e traduzido por Marcelo Panegali. Seu original em inglês pode ser encontrado aqui.