How to make the gossipsub-chat example works over internet?

[Rockung]

The gossipsub-chat example works fine with mDNS, but not work over internet. Can anyone have idea to make it work?

[thomaseizinger]

This is expected, mNDS only allows for discovery on the local network. See #3183 for a related discussion.

[Rockung]

03-chat-gossip-kad-args.rs works on local network without mDNS
03-chat-gossip-kad.rs cannot receive messages behind NAT even bootstrapping to IPFS network.

[elenaf9]

03-chat-gossip-kad.rs cannot receive messages behind NAT even bootstrapping to IPFS network.

I assume you are referring to published gossipsub messages?
Gossipsub messages are only sent to peers that are subscribed to the topic it was published to (in your case "test-net"). Thus bootstrapping to the IPFS network won't help you here since the IPFS nodes are not subscribed to this specific topic.

You could have your nodes listen via a public relay (e.g. an IPFS node) using the relay protocol. This allows your nodes behind NATs to establish a relayed connection. When the peers establish a connection, they exchange the gossipsub topics they are subscribed to and thus then know who to sent a published message to.
Note that if you use the IPFS nodes your should additionally add the DCUTR protocol to your nodes. IPFS nodes limit the amount of traffic they forward. The DCUTR allows your nodes with a relayed connection to establish a direct connection by doing hole-punching.

An alternative would be to simply have your own public nodes subscribed to your topic so they can forward gossipsub messages from those nodes that are behind NATs / firewalls.

[ehsan6sha]

can you please elaborate or share docs on how to:
1- You could have your nodes listen via a public relay (e.g. an IPFS node) using the relay protocol.
2- your should additionally add the DCUTR protocol to your nodes.

[thomaseizinger]

Have you looked at the DCUtR example? https://github.com/libp2p/rust-libp2p/tree/master/examples/dcutr

It also shows how to listen on a relay.

[fbozic]

I have the same issue. In Golang I've implemented an entire chat in ~100 lines. In Rust I am not even sure where to start (I have working chat with mDNS only). Here is my Golang code. I am looking for the libp2p.NATPortMap() feature in Rust. Any pointers?

If I am not mistaken NATPortMap() uses internally UPnP protocol. I've tried running Rust UPnP example but binary doesn't even start on my machine (while go binary start on the machine).
Error from UPnP example:

Gateway is not exposed directly to the public Internet, i.e. it itself has a private IP address.

The majority of this code comes from official examples. It would be nice if Rust examples would be usable as a starting point for real-world apps.

package main

import (
	"bufio"
	"context"
	"flag"
	"fmt"
	"os"
	"sync"

	"github.com/libp2p/go-libp2p"
	dht "github.com/libp2p/go-libp2p-kad-dht"
	pubsub "github.com/libp2p/go-libp2p-pubsub"
	"github.com/libp2p/go-libp2p/core/host"
	"github.com/libp2p/go-libp2p/core/peer"
	drouting "github.com/libp2p/go-libp2p/p2p/discovery/routing"
	dutil "github.com/libp2p/go-libp2p/p2p/discovery/util"

	"github.com/fatih/color"
)

var (
	topicNameFlag = flag.String("topicName", "chatroom", "topic name")
	hostName = flag.String("host", "/ip4/0.0.0.0/tcp/0", "host ip")
)

func main() {
	flag.Parse()
	ctx := context.Background()

	h, err := libp2p.New(libp2p.ListenAddrStrings(*hostName), libp2p.NATPortMap())
	if err != nil {
		panic(err)
	}
	go discover(ctx, h)

	ps, err := pubsub.NewGossipSub(ctx, h)
	if err != nil {
		panic(err)
	}
	topic, err := ps.Join(*topicNameFlag)
	if err != nil {
		panic(err)
	}
	go writeMessage(ctx, topic)

	sub, err := topic.Subscribe()
	if err != nil {
		panic(err)
	}
	readMessage(ctx, sub)
}

func discover(ctx context.Context, h host.Host) {
	kademliaDHT, err := dht.New(ctx, h)
	if err != nil {
		panic(err)
	}
	if err = kademliaDHT.Bootstrap(ctx); err != nil {
		panic(err)
	}
	var wg sync.WaitGroup
	for _, peerAddr := range dht.DefaultBootstrapPeers {
		peerinfo, _ := peer.AddrInfoFromP2pAddr(peerAddr)
		wg.Add(1)
		go func() {
			defer wg.Done()
			if err := h.Connect(ctx, *peerinfo); err != nil {
				fmt.Println("Bootstrap warning:", err)
			}
		}()
	}
	wg.Wait()


	routingDiscovery := drouting.NewRoutingDiscovery(kademliaDHT)
	dutil.Advertise(ctx, routingDiscovery, *topicNameFlag)

	anyConnected := false
	for !anyConnected {
		fmt.Println("Searching for peers...")
		peerChan, err := routingDiscovery.FindPeers(ctx, *topicNameFlag)
		if err != nil {
			panic(err)
		}
		for peer := range peerChan {
			if peer.ID == h.ID() {
				continue
			}
			err := h.Connect(ctx, peer)
			if err != nil {
				fmt.Printf("Failed connecting to %s, error: %s\n", peer.ID, err)
			} else {
				fmt.Printf("Connected to: %s\n", color.GreenString(peer.ID.String()))
				anyConnected = true
			}
		}
	}
	fmt.Println("Peer discovery complete")
}

func writeMessage(ctx context.Context, topic *pubsub.Topic) {
	reader := bufio.NewReader(os.Stdin)
	for {
		s, err := reader.ReadString('\n')
		if err != nil {
			panic(err)
		}
		if err := topic.Publish(ctx, []byte(s)); err != nil {
			fmt.Println("### Publish error:", err)
		}
	}
}

func readMessage(ctx context.Context, sub *pubsub.Subscription) {
	for {
		m, err := sub.Next(ctx)
		if err != nil {
			panic(err)
		}
		peerID := m.ReceivedFrom.String()
		coloredPeerID := color.CyanString(peerID)
		fmt.Printf("%s: %s\n", coloredPeerID, string(m.Message.Data))
	}
}

[thomaseizinger]

The Rust impl has a more modular and explicit design than go-libp2p. That unfortunately comes at the cost of being more verbose. I recommend reading and playing with all the examples to get an understanding how it works.

[jxs]

Hi,
Gateway is not exposed directly to the public Internet, i.e. it itself has a private IP address.
means that your UpnP enabled Gateway is not the interface directly exposed to the public internet, there's still another device forward to it, so it cannot figure it's public ip