Integrate Railing.. well, when we have railing nodes

[daviddias]

0.3.0 was just released, updated and compatible with new libp2p

https://github.com/libp2p/js-libp2p-railing

now we just need railing nodes.

[nunofmn]

Hey, I would like to work on this.

Question: should the libp2p-railing be integrated directly into the base js-libp2p? Shouldn't it be required as a discovery mechanism in the js-libp2p bundles?

[daviddias]

@nunofmn awesome!

The way it is set up means that it has to be passed as an extra module loaded by js-ipfs into libp2p, because only js-ipfs has access to the bootstrap list.

Another question is how to hot load swarm into it. Trying to figure out a nice way to plug in this discovery mechanism, that requires swarm (or libp2p) to work. So far, what is making sense is to have a mechanism to add modules on the fly:

libp2p.module.add('discovery', <instance>)

Thoughts?

[nunofmn]

Adding modules on-the-fly is useful and a good default solution, but maybe supporting some configuration-based initialization could be also useful (similar to the already existing one in js-libp2p-ipfs)

const modules = {
      transport: [
        new TCP(),
        new WS()
      ],
      connection: {
        muxer: [
          spdy
        ],
        crypto: [
          secio
        ]
      },
      discovery: [
        {
          module: require('js-libp2p-railing'),
          options: { verify: true }
        },
        {
          module: require('js-libp2p-mdns-discovery'),
          options: { verify: true }
        }
      ]
}

This way in the base js-libp2p is then possible to initialize the discovery modules, since the swarm instance is already available.

The only disadvantage is that is necessary a common "constructor function signature" in all discovery modules.

[daviddias]

you still run into the issue of having to pass swarm for the verification to happen.

[nunofmn]

In the base class you can now do something like this:

// Attach discovery mechanisms
if (this.discovery) {
  let discoveries = this.modules.discovery
    discoveries = Array.isArray(discoveries) ? discoveries : [discoveries]
    discoveries.forEach((discovery) => {
      let Discovery = discovery.module
      let disc = new Discovery(discovery.options, this.swarm)

      disc.on('peer', (peerInfo) => {
        this.discovery.emit('peer', peerInfo)
       })
   })
}

[daviddias]

@nunofmn here is what we are going to do.

• the bundles get a new options object passed feat: add options object ipfs-inactive/js-libp2p-ipfs-nodejs#46
• the discovery mechanisms (for now) might or not receive as the last argument of their constructor, a reference to the libp2p instance itself. So in case of libp2p-railing, you would pass the libp2p node, and access swarm from there. Through this direct reference to the instance, the options can be fetched, for example bootstrap-list.

Makes sense?

[daviddias]

This ⛴ has sailed!