helia-coord 1.2.1 → 1.2.2

package/lib/controllers/timer-controller.js

@@ -120,6 +120,9 @@ class TimerControllers {
       // Disable the timer while processing is happening.
       clearInterval(this.circuitRelayTimerHandle)
 
+      // Renew connections to V1 Circuit Relays
+      await useCases.relays.connectToV1Relays()
+
       // Remove any duplicate entries
       useCases.relays.removeDuplicates(thisNode)
 

package/lib/use-cases/relay-use-cases.js

@@ -18,6 +18,23 @@ class RelayUseCases {
         'Must inject instance of adapters when instantiating Relay Use Cases library.'
       )
     }
+
+    // Initialize v1 relay list. Allows user to overwrite with local config.
+    this.v1Relays = []
+    if (localConfig.v1Relays) {
+      this.v1Relays = localConfig.v1Relays
+      // console.log('v1Relays: ', this.v1Relays)
+    }
+
+    // Bind 'this' object to all subfunctions
+    this.connectToV1Relays = this.connectToV1Relays.bind(this)
+    this.initializeRelays = this.initializeRelays.bind(this)
+    this.getCRGist = this.getCRGist.bind(this)
+    this.connectToCRs = this.connectToCRs.bind(this)
+    this.sortRelays = this.sortRelays.bind(this)
+    this.addRelay = this.addRelay.bind(this)
+    this.measureRelays = this.measureRelays.bind(this)
+    this.removeDuplicates = this.removeDuplicates.bind(this)
   }
 
   // Connect to the pre-programmed circuit relays for the first time at startup.
@@ -183,11 +200,35 @@ class RelayUseCases {
       //   `status: ${now.toLocaleString()}: Renewed connections to all known Circuit Relay nodes.`
       // )
     } catch (err) {
-      console.log('Error in connectToCRs()')
+      console.error('Error in connectToCRs()')
       return false
     }
   }
 
+  // If a list of v1 Circuit Relays is provided, then renew connections to them.
+  async connectToV1Relays (relays) {
+    try {
+      for (let i = 0; i < this.v1Relays.length; i++) {
+        const thisRelay = this.v1Relays[i]
+
+        try {
+          this.adapters.log.statusLog(2, `Connecting to v1 Relay: ${thisRelay}`)
+
+          await this.adapters.ipfs.connectToPeer(
+            { multiaddr: thisRelay }
+          )
+        } catch (err) {
+          /* exit quietly */
+        }
+      }
+
+      return true
+    } catch (err) {
+      console.error('Error in connectToV1Relays()')
+      throw err
+    }
+  }
+
   // Sort the relay data relative to the measured latency metrics.
   sortRelays (relayData) {
     try {
@@ -299,6 +340,8 @@ class RelayUseCases {
         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
         return true
       })
       // console.log('filteredMultiaddrs: ', filteredMultiaddrs)

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

@@ -2,13 +2,10 @@
   Use Cases library for the thisNode entity.
 */
 
+// Local libraries
 import ThisNodeEntity from '../entities/this-node-entity.js'
 import Schema from './schema.js'
 
-// A global variable that maintains scope to the instance of this class, when
-// the context of 'this' is lost.
-let _this
-
 class ThisNodeUseCases {
   constructor (localConfig = {}) {
     // Dependency Injection.
@@ -31,7 +28,22 @@ class ThisNodeUseCases {
     // Additional information for connecting to the circuit relay.
     this.circuitRelayInfo = localConfig.circuitRelayInfo
 
-    _this = this
+    // Initialize v1 relay list. Allows user to overwrite with local config.
+    this.v1Relays = []
+    if (localConfig.v1Relays) {
+      this.v1Relays = localConfig.v1Relays
+      // console.log('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)
+    this.createSelf = this.createSelf.bind(this)
+    this.addSubnetPeer = this.addSubnetPeer.bind(this)
+    this.isFreshPeer = this.isFreshPeer.bind(this)
+    this.refreshPeerConnections = this.refreshPeerConnections.bind(this)
+    this.enforceBlacklist = this.enforceBlacklist.bind(this)
+    this.enforceWhitelist = this.enforceWhitelist.bind(this)
   }
 
   // Update this instance with copies of the other Use Case libraries.
@@ -107,60 +119,60 @@ class ThisNodeUseCases {
       // console.log('announceObj: ', announceObj)
 
       // Exit if the announcement object is stale.
-      if (!_this.isFreshPeer(announceObj)) return
+      if (!this.isFreshPeer(announceObj)) return
 
       const thisPeerId = announceObj.from.toString()
-      _this.adapters.log.statusLog(
+      this.adapters.log.statusLog(
         2,
         `announcement recieved from ${thisPeerId}`
       )
 
-      _this.adapters.log.statusLog(
+      this.adapters.log.statusLog(
         3,
         `announcement recieved from ${thisPeerId}: `,
         announceObj
       )
 
-      // console.log('_this.thisNode.peerList: ', _this.thisNode.peerList)
+      // console.log('this.thisNode.peerList: ', this.thisNode.peerList)
 
       // Add a timestamp.
       const now = new Date()
       announceObj.data.updatedAt = now.toISOString()
 
       // If the peer is not already in the list of known peers, then add it.
-      if (!_this.thisNode.peerList.includes(thisPeerId)) {
-        _this.adapters.log.statusLog(1, `New peer found: ${thisPeerId}`)
+      if (!this.thisNode.peerList.includes(thisPeerId)) {
+        this.adapters.log.statusLog(1, `New peer found: ${thisPeerId}`)
 
         // Add this peer to the list of subnet peers tracked by this node.
-        _this.thisNode.peerList.push(thisPeerId)
+        this.thisNode.peerList.push(thisPeerId)
 
         // Add the announcement data object to the peerData array tracked by This Node.
-        _this.thisNode.peerData.push(announceObj)
+        this.thisNode.peerData.push(announceObj)
 
         // Subscribe to pubsub channel for private messages to peer.
         // Ignore any messages on this channel, since it is only used for
         // broadcasting encrypted messages to the new peer, and they will
         // respond on our own channel.
-        _this.adapters.ipfs.ipfs.libp2p.services.pubsub.subscribe(thisPeerId)
-        // _this.adapters.ipfs.ipfs.libp2p.services.pubsub.addEventListener('message', (msg) => {})
-        _this.adapters.log.statusLog(2, `Subscribed to peer pubsub channel ${thisPeerId}`)
+        this.adapters.ipfs.ipfs.libp2p.services.pubsub.subscribe(thisPeerId)
+        // this.adapters.ipfs.ipfs.libp2p.services.pubsub.addEventListener('message', (msg) => {})
+        this.adapters.log.statusLog(2, `Subscribed to peer pubsub channel ${thisPeerId}`)
 
         // If the new peer has the isCircuitRelay flag set, then try to add it
         // to the list of Circuit Relays.
         if (announceObj.data.isCircuitRelay) {
-          // console.log('_this.thisNode: ', _this.thisNode)
-          await _this.useCases.relays.addRelay(thisPeerId, _this.thisNode)
+          // console.log('this.thisNode: ', this.thisNode)
+          await this.useCases.relays.addRelay(thisPeerId, this.thisNode)
         }
       } else {
         // Peer already exists in the list.
         // console.log(`debug: Updating existing peer: ${thisPeerId}`)
 
         // Get the data for this peer.
-        let thisPeerData = _this.thisNode.peerData.filter(
+        let thisPeerData = this.thisNode.peerData.filter(
           x => x.from === thisPeerId
         )
         thisPeerData = thisPeerData[0]
-        const dataIndex = _this.thisNode.peerData.indexOf(thisPeerData)
+        const dataIndex = this.thisNode.peerData.indexOf(thisPeerData)
         // console.log(`dataIndex: ${dataIndex}`)
 
         // If the new announceObj is older than the last announceObj, then
@@ -172,7 +184,7 @@ class ThisNodeUseCases {
         }
 
         // Replace the old data with the new data.
-        _this.thisNode.peerData[dataIndex] = announceObj
+        this.thisNode.peerData[dataIndex] = announceObj
       }
 
       // console.log(`addSubnetPeer() finished processing pubsub message from ${announceObj.from}`)
@@ -181,7 +193,7 @@ class ThisNodeUseCases {
     } catch (err) {
       console.error('Error in this-node-use-cases.js/addSubnetPeer(): ', err)
 
-      _this.adapters.log.statusLog(
+      this.adapters.log.statusLog(
         2,
         'Error in this-node-use-cases.js/addSubnetPeer(): ',
         err
@@ -274,10 +286,12 @@ class ThisNodeUseCases {
         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 i = 0; i < sortedRelays.length; i++) {
-          const thisRelay = sortedRelays[i]
+        for (let j = 0; j < sortedRelays.length; j++) {
+          const thisRelay = sortedRelays[j]
           // console.log(`thisRelay: ${JSON.stringify(thisRelay, null, 2)}`)
 
           // Generate a multiaddr for connecting to the peer through a circuit relay.
@@ -289,7 +303,7 @@ class ThisNodeUseCases {
             this.adapters.log.statusLog(2, `refreshPeerConnections() connecting to peer with this multiaddr: ${multiaddr}`)
 
             // Attempt to connect to the node through a circuit relay.
-            const connected = await this.adapters.ipfs.connectToPeer({ multiaddr })
+            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.
@@ -303,6 +317,25 @@ class ThisNodeUseCases {
             }
           }
         }
+
+        // If we could not connect to the node through the v2 Circuit Relays,
+        // try connecting to it through the v1 Circuit Relays.
+        if (!connected) {
+          for (let j = 0; j < this.v1Relays.length; j++) {
+            const thisV1Relay = this.v1Relays[j]
+
+            // Generate a multiaddr for connecting to the peer through a circuit relay.
+            const multiaddr = `${thisV1Relay.multiaddr}/p2p-circuit/p2p/${thisPeer}`
+
+            console.log(`refreshPeerConnections() connecting to peer through V1 Circuit Relay with this multiaddr: ${multiaddr}`)
+            this.adapters.log.statusLog(2, `refreshPeerConnections() connecting to peer through V1 Circuit Relay with this multiaddr: ${multiaddr}`)
+
+            // Attempt to connect to the node through a circuit relay.
+            connected = await this.adapters.ipfs.connectToPeer({ multiaddr })
+
+            if (connected) break
+          }
+        }
       }
 
       const now = new Date()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helia-coord",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "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/mocks/use-case-mocks.js

@@ -14,7 +14,8 @@ class UseCasesMock {
       addRelay: () => {},
       measureRelays: () => {},
       sortRelays: obj => obj,
-      removeDuplicates: () => {}
+      removeDuplicates: () => {},
+      connectToV1Relays: async () => {}
     }
     this.pubsub = {}
     this.peer = {}

package/test/unit/use-cases/relay-use-cases-unit.js

@@ -34,7 +34,8 @@ describe('#relay-Use-Cases', () => {
     uut = new RelayUseCases({
       adapters,
       statusLog: () => {
-      }
+      },
+      v1Relays: ['fake-multiaddr']
     })
   })
 
@@ -432,7 +433,9 @@ describe('#relay-Use-Cases', () => {
                 '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/addr1',
+                '/ip4/192.168.0.1/addr1',
+                '/ip4/172.16.0.1/addr1'
               ],
               isCircuitRelay: true
             }
@@ -680,4 +683,31 @@ describe('#relay-Use-Cases', () => {
       }
     })
   })
+
+  describe('#connectToV1Relays', () => {
+    it('should connect to a list of v1 Circuit Relays', async () => {
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer').resolves()
+
+      uut.v1Relays = ['fake-multiaddr']
+
+      const result = await uut.connectToV1Relays()
+
+      assert.equal(result, true)
+    })
+
+    it('should catch, report, and throw errors', async () => {
+      try {
+        // Force and error
+        uut.v1Relays = null
+
+        await uut.connectToV1Relays()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, 'Cannot read')
+      }
+    })
+  })
 })

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

@@ -23,7 +23,8 @@ describe('#thisNode-Use-Cases', () => {
     sandbox = sinon.createSandbox()
 
     uut = new ThisNodeUseCases({
-      adapters
+      adapters,
+      v1Relays: ['fake-addr']
     })
 
     const useCases = new UseCasesMock()
@@ -235,6 +236,34 @@ describe('#thisNode-Use-Cases', () => {
       assert.equal(result, true)
     })
 
+    it('should connect over v1 Circuit Relay if v2 Circuit Relays fail', async () => {
+      await uut.createSelf({ type: 'node.js' })
+      // Add a peer that is not in the list of connected peers.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId }]
+
+      // 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(false)
+        .onCall(1).resolves(true)
+
+      uut.v1Relays = ['fake-v1-relay']
+
+      // 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.