2020-04-18 23:26:46 +02:00
|
|
|
'use strict'
|
|
|
|
/* eslint-env mocha */
|
|
|
|
|
2020-10-15 15:31:33 +01:00
|
|
|
const { expect } = require('aegir/utils/chai')
|
2020-04-18 23:26:46 +02:00
|
|
|
const sinon = require('sinon')
|
|
|
|
|
2021-04-15 09:40:02 +02:00
|
|
|
const { Multiaddr } = require('multiaddr')
|
2020-10-15 15:31:33 +01:00
|
|
|
const isLoopback = require('libp2p-utils/src/multiaddr/is-loopback')
|
|
|
|
|
2020-04-18 23:26:46 +02:00
|
|
|
const { AddressesOptions } = require('./utils')
|
|
|
|
const peerUtils = require('../utils/creators/peer')
|
|
|
|
|
|
|
|
const listenAddresses = ['/ip4/127.0.0.1/tcp/0', '/ip4/127.0.0.1/tcp/8000/ws']
|
2020-10-15 15:31:33 +01:00
|
|
|
const announceAddreses = ['/dns4/peer.io/tcp/433/p2p/12D3KooWNvSZnPi3RrhrTwEY4LuuBeB6K6facKUCJcyWG1aoDd2p']
|
2020-04-18 23:26:46 +02:00
|
|
|
|
2020-04-28 16:21:25 +02:00
|
|
|
describe('libp2p.multiaddrs', () => {
|
2020-04-18 23:26:46 +02:00
|
|
|
let libp2p
|
|
|
|
|
|
|
|
afterEach(() => libp2p && libp2p.stop())
|
|
|
|
|
|
|
|
it('should keep listen addresses after start, even if changed', async () => {
|
|
|
|
[libp2p] = await peerUtils.createPeer({
|
|
|
|
started: false,
|
|
|
|
config: {
|
|
|
|
...AddressesOptions,
|
|
|
|
addresses: {
|
|
|
|
listen: listenAddresses,
|
|
|
|
announce: announceAddreses
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
let listenAddrs = libp2p.addressManager.listen
|
|
|
|
expect(listenAddrs.size).to.equal(listenAddresses.length)
|
|
|
|
expect(listenAddrs.has(listenAddresses[0])).to.equal(true)
|
|
|
|
expect(listenAddrs.has(listenAddresses[1])).to.equal(true)
|
|
|
|
|
|
|
|
// Should not replace listen addresses after transport listen
|
|
|
|
// Only transportManager has visibility of the port used
|
|
|
|
await libp2p.start()
|
|
|
|
|
|
|
|
listenAddrs = libp2p.addressManager.listen
|
|
|
|
expect(listenAddrs.size).to.equal(listenAddresses.length)
|
|
|
|
expect(listenAddrs.has(listenAddresses[0])).to.equal(true)
|
|
|
|
expect(listenAddrs.has(listenAddresses[1])).to.equal(true)
|
|
|
|
})
|
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
it('should announce transport listen addresses if announce addresses are not provided', async () => {
|
2020-04-18 23:26:46 +02:00
|
|
|
[libp2p] = await peerUtils.createPeer({
|
2020-10-27 15:58:18 +00:00
|
|
|
started: false,
|
2020-04-18 23:26:46 +02:00
|
|
|
config: {
|
|
|
|
...AddressesOptions,
|
|
|
|
addresses: {
|
2020-10-27 15:58:18 +00:00
|
|
|
listen: listenAddresses
|
2020-04-18 23:26:46 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
await libp2p.start()
|
2020-04-18 23:26:46 +02:00
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
const tmListen = libp2p.transportManager.getAddrs().map((ma) => ma.toString())
|
2020-04-18 23:26:46 +02:00
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
// Announce 2 listen (transport)
|
2020-04-28 16:21:25 +02:00
|
|
|
const advertiseMultiaddrs = libp2p.multiaddrs.map((ma) => ma.toString())
|
2020-10-27 15:58:18 +00:00
|
|
|
expect(advertiseMultiaddrs.length).to.equal(2)
|
2020-04-18 23:26:46 +02:00
|
|
|
tmListen.forEach((m) => {
|
|
|
|
expect(advertiseMultiaddrs).to.include(m)
|
|
|
|
})
|
|
|
|
expect(advertiseMultiaddrs).to.not.include(listenAddresses[0]) // Random Port switch
|
|
|
|
})
|
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
it('should only announce the given announce addresses when provided', async () => {
|
2020-04-18 23:26:46 +02:00
|
|
|
[libp2p] = await peerUtils.createPeer({
|
2020-10-27 15:58:18 +00:00
|
|
|
started: false,
|
2020-04-18 23:26:46 +02:00
|
|
|
config: {
|
|
|
|
...AddressesOptions,
|
|
|
|
addresses: {
|
|
|
|
listen: listenAddresses,
|
2020-10-27 15:58:18 +00:00
|
|
|
announce: announceAddreses
|
2020-04-18 23:26:46 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
await libp2p.start()
|
2020-04-18 23:26:46 +02:00
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
const tmListen = libp2p.transportManager.getAddrs().map((ma) => ma.toString())
|
2020-04-18 23:26:46 +02:00
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
// Announce 1 announce addr
|
2020-04-28 16:21:25 +02:00
|
|
|
const advertiseMultiaddrs = libp2p.multiaddrs.map((ma) => ma.toString())
|
2020-10-27 15:58:18 +00:00
|
|
|
expect(advertiseMultiaddrs.length).to.equal(announceAddreses.length)
|
|
|
|
advertiseMultiaddrs.forEach((m) => {
|
|
|
|
expect(tmListen).to.not.include(m)
|
|
|
|
expect(announceAddreses).to.include(m)
|
2020-04-18 23:26:46 +02:00
|
|
|
})
|
|
|
|
})
|
2020-10-15 15:31:33 +01:00
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
it('can filter out loopback addresses by the announce filter', async () => {
|
2020-10-15 15:31:33 +01:00
|
|
|
[libp2p] = await peerUtils.createPeer({
|
|
|
|
started: false,
|
|
|
|
config: {
|
|
|
|
...AddressesOptions,
|
|
|
|
addresses: {
|
|
|
|
listen: listenAddresses,
|
|
|
|
announceFilter: (multiaddrs) => multiaddrs.filter(m => !isLoopback(m))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
await libp2p.start()
|
|
|
|
|
2020-10-27 15:58:18 +00:00
|
|
|
expect(libp2p.multiaddrs.length).to.equal(0)
|
|
|
|
|
|
|
|
// Stub transportManager addresses to add a public address
|
2021-04-15 09:40:02 +02:00
|
|
|
const stubMa = new Multiaddr('/ip4/120.220.10.1/tcp/1000')
|
2020-10-27 15:58:18 +00:00
|
|
|
sinon.stub(libp2p.transportManager, 'getAddrs').returns([
|
2021-04-15 09:40:02 +02:00
|
|
|
...listenAddresses.map((a) => new Multiaddr(a)),
|
2020-10-27 15:58:18 +00:00
|
|
|
stubMa
|
|
|
|
])
|
|
|
|
|
2020-10-15 15:31:33 +01:00
|
|
|
const multiaddrs = libp2p.multiaddrs
|
2020-10-27 15:58:18 +00:00
|
|
|
expect(multiaddrs.length).to.equal(1)
|
|
|
|
expect(multiaddrs[0].equals(stubMa)).to.eql(true)
|
2020-10-15 15:31:33 +01:00
|
|
|
})
|
2020-10-15 15:31:33 +01:00
|
|
|
|
|
|
|
it('can filter out loopback addresses to announced by the announce filter', async () => {
|
|
|
|
[libp2p] = await peerUtils.createPeer({
|
|
|
|
started: false,
|
|
|
|
config: {
|
|
|
|
...AddressesOptions,
|
|
|
|
addresses: {
|
|
|
|
listen: listenAddresses,
|
|
|
|
announce: announceAddreses,
|
|
|
|
announceFilter: (multiaddrs) => multiaddrs.filter(m => !isLoopback(m))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
const listenAddrs = libp2p.addressManager.listen
|
|
|
|
expect(listenAddrs.size).to.equal(listenAddresses.length)
|
|
|
|
expect(listenAddrs.has(listenAddresses[0])).to.equal(true)
|
|
|
|
expect(listenAddrs.has(listenAddresses[1])).to.equal(true)
|
|
|
|
|
|
|
|
await libp2p.start()
|
|
|
|
|
|
|
|
const multiaddrs = libp2p.multiaddrs
|
|
|
|
expect(multiaddrs.length).to.equal(announceAddreses.length)
|
|
|
|
expect(multiaddrs.includes(listenAddresses[0])).to.equal(false)
|
|
|
|
expect(multiaddrs.includes(listenAddresses[1])).to.equal(false)
|
|
|
|
})
|
2021-01-27 13:55:26 +00:00
|
|
|
|
|
|
|
it('should include observed addresses in returned multiaddrs', async () => {
|
|
|
|
[libp2p] = await peerUtils.createPeer({
|
|
|
|
started: false,
|
|
|
|
config: {
|
|
|
|
...AddressesOptions,
|
|
|
|
addresses: {
|
|
|
|
listen: listenAddresses
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
const ma = '/ip4/83.32.123.53/tcp/43928'
|
|
|
|
|
|
|
|
await libp2p.start()
|
|
|
|
|
|
|
|
expect(libp2p.multiaddrs).to.have.lengthOf(listenAddresses.length)
|
|
|
|
|
|
|
|
libp2p.addressManager.addObservedAddr(ma)
|
|
|
|
|
|
|
|
expect(libp2p.multiaddrs).to.have.lengthOf(listenAddresses.length + 1)
|
|
|
|
expect(libp2p.multiaddrs.map(ma => ma.toString())).to.include(ma)
|
|
|
|
})
|
2020-04-18 23:26:46 +02:00
|
|
|
})
|