nim-libp2p/examples/tutorial_5_discovery.nim

## # Discovery Manager
##
## In the [previous tutorial](tutorial_4_gossipsub.md), we built a custom protocol using [protobuf](https://developers.google.com/protocol-buffers) and
## spread informations (some metrics) on the network using gossipsub.
## For this tutorial, on the other hand, we'll go back on a simple example
## we'll try to discover a specific peers to greet on the network.
##
## First, as usual, we import the dependencies:
import sequtils
import chronos
import stew/byteutils

import libp2p
import libp2p/protocols/rendezvous
import libp2p/discovery/rendezvousinterface
import libp2p/discovery/discoverymngr

## We'll not use newStandardSwitch this time as we need the discovery protocol
## [RendezVous](https://github.com/libp2p/specs/blob/master/rendezvous/README.md) to be mounted on the switch using withRendezVous.
##
## Note that other discovery methods such as [Kademlia](https://github.com/libp2p/specs/blob/master/kad-dht/README.md) or [discv5](https://github.com/ethereum/devp2p/blob/master/discv5/discv5.md) exist.
proc createSwitch(rdv: RendezVous = RendezVous.new()): Switch =
  SwitchBuilder.new()
    .withRng(newRng())
    .withAddresses(@[ MultiAddress.init("/ip4/0.0.0.0/tcp/0").tryGet() ])
    .withTcpTransport()
    .withYamux()
    .withNoise()
    .withRendezVous(rdv)
    .build()

# Create a really simple protocol to log one message received then close the stream
const DumbCodec = "/dumb/proto/1.0.0"
type DumbProto = ref object of LPProtocol
proc new(T: typedesc[DumbProto], nodeNumber: int): T =
  proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
    echo "Node", nodeNumber, " received: ", string.fromBytes(await conn.readLp(1024))
    await conn.close()
  return T(codecs: @[DumbCodec], handler: handle)

## ## Bootnodes
## The first time a p2p program is ran, he needs to know how to join
## its network. This is generally done by hard-coding a list of stable
## nodes in the binary, called "bootnodes". These bootnodes are a
## critical part of a p2p network, since they are used by every new
## user to onboard the network.
##
## By using libp2p, we can use any node supporting our discovery protocol
## (rendezvous in this case) as a bootnode. For this example, we'll
## create a bootnode, and then every peer will advertise itself on the
## bootnode, and use it to find other peers
proc main() {.async, gcsafe.} =
  let bootNode = createSwitch()
  await bootNode.start()

  # Create 5 nodes in the network
  var
    switches: seq[Switch] = @[]
    discManagers: seq[DiscoveryManager] = @[]

  for i in 0..5:
    let rdv = RendezVous.new()
    # Create a remote future to await at the end of the program
    let switch = createSwitch(rdv)
    switch.mount(DumbProto.new(i))
    switches.add(switch)

    # A discovery manager is a simple tool, you can set it up by adding discovery
    # interfaces (such as RendezVousInterface) then you can use it to advertise
    # something on the network or to request something from it.
    let dm = DiscoveryManager()
    # A RendezVousInterface is a RendezVous protocol wrapped to be usable by the
    # DiscoveryManager.
    dm.add(RendezVousInterface.new(rdv))
    discManagers.add(dm)

    # We can now start the switch and connect to the bootnode
    await switch.start()
    await switch.connect(bootNode.peerInfo.peerId, bootNode.peerInfo.addrs)

    # Each nodes of the network will advertise on some topics (EvenGang or OddClub)
    dm.advertise(RdvNamespace(if i mod 2 == 0: "EvenGang" else: "OddClub"))

  ## We can now create the newcomer. This peer will connect to the boot node, and use
  ## it to discover peers & greet them.
  let
    rdv = RendezVous.new()
    newcomer = createSwitch(rdv)
    dm = DiscoveryManager()
  await newcomer.start()
  await newcomer.connect(bootNode.peerInfo.peerId, bootNode.peerInfo.addrs)
  dm.add(RendezVousInterface.new(rdv, ttr = 250.milliseconds))

  # Use the discovery manager to find peers on the OddClub topic to greet them
  let queryOddClub = dm.request(RdvNamespace("OddClub"))
  for _ in 0..2:
    let
      # getPeer give you a PeerAttribute containing informations about the peer.
      res = await queryOddClub.getPeer()
      # Here we will use the PeerId and the MultiAddress to greet him
      conn = await newcomer.dial(res[PeerId], res.getAll(MultiAddress), DumbCodec)
    await conn.writeLp("Odd Club suuuucks! Even Gang is better!")
    # Uh-oh!
    await conn.close()
    # Wait for the peer to close the stream
    await conn.join()
  # Queries will run in a loop, so we must stop them when we are done
  queryOddClub.stop()

  # Maybe it was because he wanted to join the EvenGang
  let queryEvenGang = dm.request(RdvNamespace("EvenGang"))
  for _ in 0..2:
    let
      res = await queryEvenGang.getPeer()
      conn = await newcomer.dial(res[PeerId], res.getAll(MultiAddress), DumbCodec)
    await conn.writeLp("Even Gang is sooo laaame! Odd Club rocks!")
    # Or maybe not...
    await conn.close()
    await conn.join()
  queryEvenGang.stop()
  # What can I say, some people just want to watch the world burn... Anyway

  # Stop all the discovery managers
  for d in discManagers:
    d.stop()
  dm.stop()

  # Stop all the switches
  await allFutures(switches.mapIt(it.stop()))
  await allFutures(bootNode.stop(), newcomer.stop())

waitFor(main())