Proficient in IPFS | IPFS startup start function

Libp2p.start(err => {
If (err) return cb(err)
Self.libp2p = libp2p
Cb()
})
})

 } 

createLibp2pBundle function is located in the libp2p.js file in the current directory. The execution flow of this function is as follows:

• Generate configuration objects and option objects, the former is passed in by parameters, and the latter is obtained through IPFS objects.

   const options = self._options || {} config = config || {} 

• Determine how to create a libp2p object. If the creation method is specified in the options object, the specified creation method is used, otherwise the default creation method is used. By default, the user does not specify a creation method, so the default creation method is used here.

   const createBundle = typeof options.libp2p === 'function'    ? options.libp2p    : defaultBundle 

• Get the information needed to create a libp2p object from an IPFS object.

   const { datastore } = self._repo const peerInfo = self._peerInfo const peerBook = self._peerInfoBook 

• Call the create method to create a libp2p object. The default creation method is as follows:
  • First, set the default options.

     const libp2pDefaults = {    datastore,    peerInfo,    peerBook,    config: {      peerDiscovery: {        mdns: {          enabled: get(options, 'config.Discovery.MDNS.Enabled',            get(config, 'Discovery.MDNS.Enabled', true))        },        webRTCStar: {          enabled: get(options, 'config.Discovery.webRTCStar.Enabled',            get(config, 'Discovery.webRTCStar.Enabled', true))        },        bootstrap: {          list: get(options, 'config.Bootstrap',            get(config, 'Bootstrap', []))        }      },      relay: {        enabled: get(options, 'relay.enabled',          get(config, 'relay.enabled', true)),        hop: {          enabled: get(options, 'relay.hop.enabled',            get(config, 'relay.hop.enabled', false)),          active: get(options, 'relay.hop.active',            get(config, 'relay.hop.active', false))        }      },      dht: {        kBucketSize: get(options, 'dht.kBucketSize', 20),        enabled: false,        randomWalk: {          enabled: false // disabled waiting for https://github.com/libp2p/js-libp2p-kad-dht/issues/86        },        validators: {          ipns: ipnsUtils.validator        },        selectors: {          ipns: ipnsUtils.selector        }      },      EXPERIMENTAL: {        pubsub: get(options, 'EXPERIMENTAL.pubsub', false)      }    },    connectionManager: get(options, 'connectionManager',      {        maxPeers: get(config, 'Swarm.ConnMgr.HighWater'),        minPeers: get(config, 'Swarm.ConnMgr.LowWater')    }) } 

    Among them, datastore , peerInfo , peerBook , options and other related private attributes from IPFS objects, config comes from the configuration file of the final generated warehouse and the user-specified configuration.

  • Then, call the mergeOptions method to merge the default options with the user-specified options.

     const libp2pOptions = mergeOptions(libp2pDefaults, get(options, 'libp2p', {})) 

  • Finally, load the Node object defined in the core/runtime/libp2p-nodejs.js file (inherited from the object defined by the libp2p library) and call its constructor to generate the libp2p object.

     const Node = require('../runtime/libp2p-nodejs') return new Node(libp2pOptions) 

    libp2p-nodejs.js file mainly defines the default options for creating libp2p objects, and merges the previously generated options with the default options, and then calls the constructor of the parent class to create the object. The specific default options are:

    • Where is the blockchain enterprise settled? 7 urban blockchain special support measures competition
    • Why is it true that Facebook currency is really important?
    • Ethereum Essence: Complex Consensus Agreement Operation

     {  switch: {    blacklistTTL: 2 * 60 * 1e3, // 2 minute base    blackListAttempts: 5, // back off 5 times    maxParallelDials: 150,    maxColdCalls: 50,    dialTimeout: 10e3 // Be strict with dial time  },  modules: {    transport: [      TCP,      WS,      wsstar    ],    streamMuxer: [      Multiplex    ],    connEncryption: [      SECIO    ],    peerDiscovery: [      MulticastDNS,      Bootstrap,      wsstar.discovery    ],    dht: KadDHT  },  config: {    peerDiscovery: {      autoDial: true,      mdns: {        enabled: true      },      bootstrap: {        enabled: true      },      websocketStar: {        enabled: true      }    },    dht: {      kBucketSize: 20,      enabled: false,      randomWalk: {        enabled: false      }    },    EXPERIMENTAL: {      pubsub: false    }  } } 

  From the above code, we can find that the process of creating libp2p is more complicated. The actual type of libp2p object is the object defined in the libp2p library.

Because libp2p is a very, very important component/library that can be used in IPFS/Filecoin, it can be used independently, or in other projects. Since it is so important, we will specifically explain it in the future. This is just a simple matter.

The libp2p object inherits from the EventEmitter class, so it can trigger an event, and it also has a state variable of type fsm-event internally, so it can also be considered a state machine object.

 libp2p.start(err => {    if (err) return cb(err)    self.libp2p = libp2p    cb() } 

When several functions of the series method are executed, the system basically starts up. The last action to be executed is to call the done function defined in the start function and set the state to running.

When the done function is completed, the IPFS system is started.

We will continue to update Blocking; if you have any questions or suggestions, please contact us!