[WIP] Autorelay Usage Example

autorelay/common.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"flag"
+
+	"github.com/libp2p/go-libp2p-peer"
+)
+
+type peerID peer.ID
+
+func (pid *peerID) String() string {
+	return pid.String()
+}
+
+
+func (pid *peerID) Set(value string) error {
+	newPID, err := peer.IDFromString(value)
+	if err != nil {
+		return err
+	}
+	*pid = peerID(newPID)
+	return nil
+}
+
+type Config struct {
+	RelayID          peerID
+	RendezvousString string
+}
+
+func parseFlags() (Config, error) {
+	config := Config{}
+	flag.Var(&config.RelayID, "relayID", "The peer ID of the relay node")
+	flag.StringVar(&config.RendezvousString, "rendezvous", "nat-node", "A string to advertise this node for discovery in the DHT")
+	flag.Parse()
+
+	return config, nil
+}
+

autorelay/listener.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"context"
+	"time"
+
+	"github.com/ipfs/go-datastore"
+	logging "github.com/ipfs/go-log"
+	"github.com/libp2p/go-libp2p"
+	"github.com/libp2p/go-libp2p-discovery"
+	"github.com/libp2p/go-libp2p-host"
+	"github.com/libp2p/go-libp2p-kad-dht"
+	inet "github.com/libp2p/go-libp2p-net"
+	"github.com/libp2p/go-libp2p-peer"
+	"github.com/libp2p/go-libp2p-routing"
+)
+
+var listenLogger = logging.Logger("arListener")
+
+func main() {
+	logging.SetLogLevel("autorelay", "DEBUG")
+	logging.SetLogLevel("relay", "DEBUG")
+	logging.SetLogLevel("autonat", "DEBUG")
+
+	ctx := context.Background()
+	config, err := parseFlags()
+	if err != nil {
+		listenLogger.Fatal("couldn't parse flags:", err)
+	}
+
+	dhtFactory := func (h host.Host) (routing.PeerRouting, error) {
+		return dht.New(ctx, h)
+	}
+
+	listenerHost, err := libp2p.New(ctx,
+		libp2p.EnableRelay(),
+		libp2p.Routing(dhtFactory),
+		libp2p.EnableAutoRelay())
+	if err != nil {
+		listenLogger.Fatal("could not create host:", err)
+	}
+	listenLogger.Info("listener: ", listenerHost.ID(), listenerHost.ID().Pretty())
+
+	// Now, to test things, let's set up a protocol handler on listenerHost
+	listenerHost.SetStreamHandler("/cats", func(s inet.Stream) {
+		listenLogger.Info("meow! It worked!")
+		s.Close()
+	})
+
+	// discover and connect to the relay node
+	dhtClient := dht.NewDHTClient(ctx, listenerHost, datastore.NewMapDatastore())
+	relayPeerInfo, err := dhtClient.FindPeer(ctx, peer.ID(config.RelayID))
+	if err != nil {
+		listenLogger.Fatal("could not get relay node peer info:", err)
+	}
+	if err := listenerHost.Connect(ctx, relayPeerInfo); err != nil {
+		listenLogger.Fatal("could not connect to relay node:", err)
+	}
+
+	// repeatedly advertise the rendezvous string through the DHT so our node can be found
+	routingDiscovery := discovery.NewRoutingDiscovery(dhtClient)
+	go func() {
+		for {
+			discovery.Advertise(ctx, routingDiscovery, config.RendezvousString)
+			time.Sleep(time.Minute)
+		}
+	}()
+}

autorelay/sender.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"context"
+
+	"github.com/ipfs/go-datastore"
+	logging "github.com/ipfs/go-log"
+	"github.com/libp2p/go-libp2p"
+	"github.com/libp2p/go-libp2p-discovery"
+	"github.com/libp2p/go-libp2p-kad-dht"
+	"github.com/libp2p/go-libp2p-peer"
+)
+
+var sendLogger = logging.Logger("arSender")
+
+func main() {
+	logging.SetLogLevel("relay", "DEBUG")
+
+	ctx := context.Background()
+	config, err := parseFlags()
+	if err != nil {
+		sendLogger.Fatal("could not parse flags:", err)
+	}
+
+	// Have the sending host enable content routing.
+	// Have the sending host enable autorelay
+	senderHost, err := libp2p.New(ctx, libp2p.EnableRelay())
+	if err != nil {
+		sendLogger.Fatal("could not create the host:", err)
+	}
+	sendLogger.Info("Sender: ", senderHost.ID(), senderHost.ID().Pretty())
+
+	// discover and connect to the relay node
+	dhtClient := dht.NewDHTClient(ctx, senderHost, datastore.NewMapDatastore())
+	relayPeerInfo, err := dhtClient.FindPeer(ctx, peer.ID(config.RelayID))
+	if err != nil {
+		sendLogger.Fatal("could not find the relay node:", err)
+	}
+	if err := senderHost.Connect(ctx, relayPeerInfo); err != nil {
+		sendLogger.Fatal("could not connect to relay node:", err)
+	}
+
+	// find the NAT listening host
+	routingDiscovery := discovery.NewRoutingDiscovery(dhtClient)
+	peerChan, err := routingDiscovery.FindPeers(ctx, config.RendezvousString)
+	if err != nil {
+		sendLogger.Fatal("could not find peers", err)
+	}
+
+	for p := range peerChan {
+		s, err := senderHost.NewStream(ctx, p.ID, "/cats")
+		if err != nil {
+			sendLogger.Warning("Connection failed:", err)
+			continue
+		} else {
+			s.Read(make([]byte, 1))
+		}
+	}
+}