helia-coord 1.2.4 → 1.2.5

package/lib/use-cases/this-node-use-cases.js

@@ -5,6 +5,7 @@
 // Local libraries
 import ThisNodeEntity from '../entities/this-node-entity.js'
 import Schema from './schema.js'
+import Util from '../util/utils.js'
 
 class ThisNodeUseCases {
   constructor (localConfig = {}) {
@@ -16,6 +17,9 @@ class ThisNodeUseCases {
       )
     }
 
+    // Encapsulate dependencies
+    this.utils = new Util()
+
     // Optional JSON-LD used for announcements. If present, will override
     // default announcement object in Schema library.
     this.announceJsonLd = localConfig.announceJsonLd
@@ -34,7 +38,7 @@ class ThisNodeUseCases {
       this.v1Relays = localConfig.v1Relays
       // console.log('v1Relays: ', this.v1Relays)
     }
-    console.log('this-node-use-cases.js v1Relays: ', this.v1Relays)
+    // console.log('this-node-use-cases.js v1Relays: ', this.v1Relays)
 
     // Bind 'this' object to all subfunctions
     this.updateUseCases = this.updateUseCases.bind(this)
@@ -234,6 +238,12 @@ class ThisNodeUseCases {
 
   // Called by an Interval, ensures connections are maintained to known pubsub
   // peers. This will heal connections if nodes drop in and out of the network.
+  // Connection workflow:
+  // - If peer is advertised as a circuit relay, try to connect directly through
+  //   the advertised Circuit Relay IP address and port.
+  // - Attempt to connect to peer directly through its advertised multiaddrs.
+  // - Connect to peer through v2 Circuit Relays (built into ipfs-service-provider)
+  // - Connect to peer through v1 Circuit Relays (standalone v1 Circuit Relay)
   async refreshPeerConnections () {
     try {
       // console.log('this.thisNode: ', this.thisNode)
@@ -251,6 +261,8 @@ class ThisNodeUseCases {
         connectedPeers
       )
 
+      // console.log('thisNode.peerData: ', this.thisNode.peerData)
+
       // Loop through each known peer
       for (let i = 0; i < peers.length; i++) {
         // const thisPeer = this.state.peers[peer]
@@ -278,21 +290,74 @@ class ThisNodeUseCases {
         peerData = peerData[0]
         // console.log('peerData: ', peerData)
 
-        // TODO: if broadcastedAt value is older than 10 minutes, skip connecting
+        // If broadcastedAt value is older than 10 minutes, skip connecting
         // to the peer. It may be stale information.
         if (!this.isFreshPeer(peerData)) {
           this.adapters.log.statusLog(2, `Peer ${peerData.from} is stale. Skipping.`)
           continue
         }
 
+        let connected = false
+
+        // If peer advertises itself as a Circuit Relay, connect to the circuit
+        // relay connection info
+        if (peerData.data && peerData.data.isCircuitRelay) {
+          const multiaddr = `/ip4/${peerData.data.circuitRelayInfo.ip4}/tcp/${peerData.data.circuitRelayInfo.tcpPort}/p2p/${thisPeer}`
+
+          connected = await this.adapters.ipfs.connectToPeer({ multiaddr })
+
+          if (connected) {
+            this.adapters.log.statusLog(2,
+              `Successfully connected to Circuit Relay peer ${thisPeer} through direct connection: ${multiaddr}.`
+            )
+
+            // Add the connection multiaddr to the peer, so that we can see
+            // exactly how we're connected to the peer.
+            const thisPeerData = this.thisNode.peerData.filter(x => x.from === thisPeer)
+            thisPeerData[0].data.connectionAddr = multiaddr
+
+            // Break out of the loop once we've made a successful connection.
+            continue
+          }
+        }
+
+        // Try a direct connection with the peer by going through
+        // the multiaddrs in the announcement object.
+        const filteredMultiaddrs = this.utils.filterMultiaddrs(peerData.data.ipfsMultiaddrs)
+        console.log('filteredMultiaddrs: ', filteredMultiaddrs)
+
+        for (let j = 0; j < filteredMultiaddrs.length; j++) {
+          const multiaddr = filteredMultiaddrs[j]
+
+          // Attempt to connect to the node through a circuit relay.
+          connected = await this.adapters.ipfs.connectToPeer({ multiaddr })
+
+          // If the connection was successful, break out of the relay loop.
+          // Otherwise try to connect through the next relay.
+          if (connected) {
+            this.adapters.log.statusLog(2,
+              `Successfully connected to peer ${thisPeer} through direct connection: ${multiaddr}.`
+            )
+
+            // Add the connection multiaddr to the peer, so that we can see
+            // exactly how we're connected to the peer.
+            const thisPeerData = this.thisNode.peerData.filter(x => x.from === thisPeer)
+            thisPeerData[0].data.connectionAddr = multiaddr
+
+            // Break out of the loop once we've made a successful connection.
+            break
+          }
+        }
+        if (connected) {
+          continue
+        }
+
         // Sort the Circuit Relays by the average of the aboutLatency
         // array. Connect to peers through the Relays with the lowest latencies
         // first.
         const sortedRelays = this.thisNode.useCases.relays.sortRelays(relays)
         // console.log(`sortedRelays: ${JSON.stringify(sortedRelays, null, 2)}`)
 
-        let connected = false
-
         // Loop through each known circuit relay and attempt to connect to the
         // peer through a relay.
         for (let j = 0; j < sortedRelays.length; j++) {

package/lib/util/utils.js

@@ -7,6 +7,28 @@ class Util {
   sleep (ms) {
     return new Promise(resolve => setTimeout(resolve, ms))
   }
+
+  // This function takes an array of multiaddrs as input, and returns an array
+  // filtered to remove any local network IP addresses.
+  filterMultiaddrs (multiaddrs) {
+    try {
+      const filteredMultiaddrs = multiaddrs.filter((x) => {
+        if (x.includes('127.0.0.1')) return false
+        if (x.includes('udp')) return false
+        if (x.includes('quic')) return false
+        if (x.includes('p2p-circuit')) return false
+        if (x.includes('192.168.')) return false
+        if (x.includes('172.16.')) return false
+        if (x.includes('/10.')) return false
+        return true
+      })
+
+      return filteredMultiaddrs
+    } catch (err) {
+      console.error('Error in util.js/filterMultiaddrs()')
+      throw err
+    }
+  }
 }
 
 export default Util

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helia-coord",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "A JS library for helping IPFS peers coordinate, find a common interest, and stay connected around that interest.",
   "main": "./index.js",
   "type": "module",

package/test/unit/use-cases/this-node-use-cases-unit.js

@@ -229,6 +229,7 @@ describe('#thisNode-Use-Cases', () => {
       sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
       sandbox.stub(uut.adapters.ipfs, 'connectToPeer').resolves(true)
       sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns([])
 
       // Connect to that peer.
       const result = await uut.refreshPeerConnections()
@@ -255,6 +256,7 @@ describe('#thisNode-Use-Cases', () => {
       sandbox.stub(uut.adapters.ipfs, 'connectToPeer')
         .onCall(0).resolves(false)
         .onCall(1).resolves(true)
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns([])
 
       uut.v1Relays = ['fake-v1-relay']
 
@@ -264,6 +266,67 @@ describe('#thisNode-Use-Cases', () => {
       assert.equal(result, true)
     })
 
+    it('should connect directly to circuit relays advertised IP and port', async () => {
+      await uut.createSelf({ type: 'node.js' })
+      // Add a circuit relay peer with advertised IP and port.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{
+        from: ipfsId,
+        data: {
+          isCircuitRelay: true,
+          circuitRelayInfo: {
+            ip4: '123.456.7.8',
+            tcpPort: 4001
+          }
+        }
+      }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer')
+        .onCall(0).resolves(true)
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns([])
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
+
+    it('should connect directly to IPFS peers multiaddr', async () => {
+      await uut.createSelf({ type: 'node.js' })
+      // Add a circuit relay peer with advertised IP and port.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId, data: {} }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer')
+        .onCall(0).resolves(true)
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns(['/ip4/123.45.6.7/p2p/ipfs-id'])
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
+
     it('should skip if peer is stale', async () => {
       await uut.createSelf({ type: 'node.js' })
       // Add a peer that is not in the list of connected peers.

package/test/unit/util/utils-unit.js

@@ -28,4 +28,37 @@ describe('#utils.js', () => {
       assert.isOk(true)
     })
   })
+
+  describe('#filterMultiaddrs', () => {
+    it('should filter out undesired multiaddrs', () => {
+      const ipfsMultiaddrs = [
+        'ip4/tcp/127.0.0.1/addr1',
+        'ip4/udp/123.456.789.1/addr1',
+        'ip4/quic/123.456.789.1/addr1',
+        'ip4/tcp/123.456.789.1/p2p-circuit/p2p/addr1',
+        '/ip4/addr1',
+        '/ip4/192.168.0.1/addr1',
+        '/ip4/10.0.0.1/addr1',
+        '/ip4/172.16.0.1/addr1'
+      ]
+
+      const result = uut.filterMultiaddrs(ipfsMultiaddrs)
+      // console.log('result: ', result)
+
+      assert.equal(result.length, 1)
+      assert.equal(result[0], '/ip4/addr1')
+    })
+
+    it('should catch, report, and throw errors', () => {
+      try {
+        uut.filterMultiaddrs(4)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+
+        assert.include(err.message, 'is not a function')
+      }
+    })
+  })
 })