Fix relay connectivity issues

Signed-off-by: Gustavo Sampaio <[email protected]>

Author: GustavoKatel

examples/relay/relay.go

@@ -14,14 +14,14 @@ import (
 )
 
 func relayStart(ctx context.Context, bootstrapPeers []string, id identity.Identity) {
-	relay, err := crabfs.RelayNew(ctx, 1717, bootstrapPeers, id)
+	relay, err := crabfs.RelayNew(ctx, 1700, bootstrapPeers, id)
 	if err != nil {
 		panic(err)
 	}
 
-	log.Printf("Relay id: %s\n", relay.GetRelayID())
+	log.Printf("ID: %s\n", relay.GetHostID())
 	for i, addr := range relay.GetAddrs() {
-		log.Printf("Relay addr [%d]: %s\n", i, addr)
+		log.Printf("Addr [%d]: %s\n", i, addr)
 	}
 }
 

go.mod

@@ -20,6 +20,7 @@ require (
 	github.com/libp2p/go-libp2p-kad-dht v0.1.0
 	github.com/libp2p/go-libp2p-peerstore v0.1.0
 	github.com/libp2p/go-libp2p-record v0.1.0
+	github.com/libp2p/go-libp2p-routing v0.1.0
 	github.com/libp2p/go-libp2p-swarm v0.1.0
 	github.com/multiformats/go-multiaddr v0.0.4
 	github.com/multiformats/go-multihash v0.0.5

host.go

@@ -26,13 +26,16 @@ import (
 	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	"github.com/libp2p/go-libp2p"
 	libp2pCircuit "github.com/libp2p/go-libp2p-circuit"
+	"github.com/libp2p/go-libp2p-core/host"
 	libp2pHost "github.com/libp2p/go-libp2p-core/host"
 	libp2pNet "github.com/libp2p/go-libp2p-core/network"
 	libp2pRouting "github.com/libp2p/go-libp2p-core/routing"
 	discovery "github.com/libp2p/go-libp2p-discovery"
 	libp2pDht "github.com/libp2p/go-libp2p-kad-dht"
 	libp2pDhtOptions "github.com/libp2p/go-libp2p-kad-dht/opts"
 	libp2pPeerstore "github.com/libp2p/go-libp2p-peerstore"
+	routing "github.com/libp2p/go-libp2p-routing"
+	libp2pSwarm "github.com/libp2p/go-libp2p-swarm"
 	libp2pRoutedHost "github.com/libp2p/go-libp2p/p2p/host/routed"
 )
 
@@ -58,6 +61,24 @@ type hostImpl struct {
 
 // HostNew creates a new host
 func HostNew(settings *options.Settings, ds ipfsDatastore.Batching, blockstore blockstore.Blockstore) (interfaces.Host, error) {
+	provideWorker, err := executor.NewDefaultExecutorContext(settings.Context, 4)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := provideWorker.Start(); err != nil {
+		return nil, err
+	}
+
+	newHost := &hostImpl{
+		settings: settings,
+
+		ds:         ds,
+		blockstore: blockstore,
+
+		provideWorker: provideWorker,
+	}
+
 	sourceMultiAddrIP4, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", settings.Port))
 	if err != nil {
 		return nil, err
@@ -75,7 +96,7 @@ func HostNew(settings *options.Settings, ds ipfsDatastore.Batching, blockstore b
 	if settings.RelayOnly {
 		opts = append(opts, libp2p.EnableRelay(libp2pCircuit.OptHop))
 	} else {
-		opts = append(opts, libp2p.EnableRelay(libp2pCircuit.OptDiscovery))
+		opts = append(opts, libp2p.EnableRelay(libp2pCircuit.OptDiscovery), libp2p.EnableAutoRelay())
 	}
 
 	id, ok := settings.Identity.(*identity.Libp2pIdentity)
@@ -85,58 +106,42 @@ func HostNew(settings *options.Settings, ds ipfsDatastore.Batching, blockstore b
 
 	opts = append(opts, libp2p.Identity(id.GetLibp2pPrivateKey()))
 
-	p2pHost, err := libp2p.New(
-		settings.Context,
-		opts...,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return HostNewWithP2P(settings, p2pHost, ds, blockstore)
-}
+	dhtCreator := func(h host.Host) (routing.PeerRouting, error) {
+		// Configure peer discovery and key validator
+		dhtValidator := libp2pDhtOptions.NamespacedValidator(
+			"crabfs",
+			DHTNamespaceValidatorNew(settings.Context, newHost.GetSwarmPublicKey),
+		)
+		dhtPKValidator := libp2pDhtOptions.NamespacedValidator(
+			"crabfs_pk",
+			DHTNamespacePKValidatorNew(),
+		)
+
+		dht, err := libp2pDht.New(settings.Context, h, dhtValidator, dhtPKValidator, libp2pDhtOptions.Datastore(ds))
+		if err != nil {
+			return nil, err
+		}
 
-// HostNewWithP2P creates a new host with an underlying p2p host
-func HostNewWithP2P(settings *options.Settings, p2pHost libp2pHost.Host, ds ipfsDatastore.Batching, blockstore blockstore.Blockstore) (interfaces.Host, error) {
-	provideWorker, err := executor.NewDefaultExecutorContext(settings.Context, 4)
-	if err != nil {
-		return nil, err
-	}
+		if err = dht.Bootstrap(settings.Context); err != nil {
+			return nil, err
+		}
 
-	if err := provideWorker.Start(); err != nil {
-		return nil, err
+		newHost.dht = dht
+		return dht, nil
 	}
 
-	newHost := &hostImpl{
-		settings: settings,
-
-		ds:         ds,
-		blockstore: blockstore,
-
-		provideWorker: provideWorker,
-	}
+	opts = append(opts, libp2p.Routing(dhtCreator))
 
-	// Configure peer discovery and key validator
-	dhtValidator := libp2pDhtOptions.NamespacedValidator(
-		"crabfs",
-		DHTNamespaceValidatorNew(settings.Context, newHost.GetSwarmPublicKey),
-	)
-	dhtPKValidator := libp2pDhtOptions.NamespacedValidator(
-		"crabfs_pk",
-		DHTNamespacePKValidatorNew(),
+	p2pHost, err := libp2p.New(
+		settings.Context,
+		opts...,
 	)
-	dht, err := libp2pDht.New(settings.Context, p2pHost, dhtValidator, dhtPKValidator, libp2pDhtOptions.Datastore(ds))
 	if err != nil {
 		return nil, err
 	}
 
-	newHost.dht = dht
-
-	if err = dht.Bootstrap(settings.Context); err != nil {
-		return nil, err
-	}
-
-	newHost.p2pHost = libp2pRoutedHost.Wrap(p2pHost, dht)
+	newHost.p2pHost = libp2pRoutedHost.Wrap(p2pHost, newHost.dht)
+	// newHost.p2pHost = p2pHost
 
 	newHost.p2pHost.SetStreamHandler(ProtocolV1, newHost.handleStreamV1)
 
@@ -620,6 +625,15 @@ func (host *hostImpl) FindProviders(ctx context.Context, blockMeta *pb.BlockMeta
 }
 
 func (host *hostImpl) CreateBlockStream(ctx context.Context, blockMeta *pb.BlockMetadata, peer *libp2pPeerstore.PeerInfo) (io.Reader, error) {
+	circuitAddr, err := multiaddr.NewMultiaddr("/p2p-circuit/p2p/" + peer.ID.Pretty())
+	if err != nil {
+		return nil, err
+	}
+
+	// Add the relay addr circuit to this peer
+	host.p2pHost.Peerstore().AddAddr(peer.ID, circuitAddr, libp2pPeerstore.TempAddrTTL)
+
+	host.p2pHost.Network().(*libp2pSwarm.Swarm).Backoff().Clear(peer.ID)
 	stream, err := host.p2pHost.NewStream(ctx, peer.ID, ProtocolV1)
 	if err != nil {
 		return nil, err

relay.go

@@ -2,15 +2,10 @@ package crabfs
 
 import (
 	"context"
-	"fmt"
-	"strings"
 
 	"github.com/runletapp/crabfs/identity"
 
-	"github.com/libp2p/go-libp2p"
-	libp2pCircuit "github.com/libp2p/go-libp2p-circuit"
 	libp2pHost "github.com/libp2p/go-libp2p-core/host"
-	"github.com/multiformats/go-multiaddr"
 	"github.com/runletapp/crabfs/interfaces"
 	"github.com/runletapp/crabfs/options"
 )
@@ -27,42 +22,20 @@ type Relay struct {
 
 // RelayNew creates a new relay instance
 func RelayNew(ctx context.Context, port uint, bootstrapPeers []string, id identity.Identity) (*Relay, error) {
-	relayHost, err := libp2p.New(
-		ctx,
-		libp2p.EnableRelay(libp2pCircuit.OptHop),
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	relayAddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/p2p/%s", relayHost.ID().Pretty()))
-	if err != nil {
-		return nil, err
-	}
-
-	addrs := bootstrapPeers
-	for _, addr := range relayHost.Addrs() {
-		if strings.HasPrefix(addr.String(), "/ip4/127") || strings.HasPrefix(addr.String(), "/ip6/::1") {
-			addrs = append(addrs, addr.Encapsulate(relayAddr).String())
-		}
-	}
-
 	host, err := New(
 		options.Port(port),
 		options.RelayOnly(true),
-		options.BootstrapPeers(addrs),
+		options.BootstrapPeers(bootstrapPeers),
 		options.Identity(id),
 	)
 	if err != nil {
-		relayHost.Close()
 		return nil, err
 	}
 
 	relay := &Relay{
-		ctx:          ctx,
-		port:         port,
-		host:         host,
-		p2pRelayHost: relayHost,
+		ctx:  ctx,
+		port: port,
+		host: host,
 	}
 
 	return relay, nil
@@ -86,8 +59,3 @@ func (relay *Relay) GetAddrs() []string {
 func (relay *Relay) GetHostID() string {
 	return relay.host.GetID()
 }
-
-// GetRelayID returns the id of this p2p relay
-func (relay *Relay) GetRelayID() string {
-	return relay.p2pRelayHost.ID().Pretty()
-}