Proficient in IPFS: IPFS startup init function

self.preStart((err) => {
If (err) {
Self.emit('error', err)
Return callback(err)
}

 self.state.initialized() self.emit('init') callback(null, res) 

   }) } 

 self.state.init() 

 if (opts.repo) {  self._repo = opts.repo  return done(null, true) } 

 opts.emptyRepo = opts.emptyRepo || false opts.bits = Number(opts.bits) || 2048 opts.log = opts.log || function () {} 

Then, check whether the private key is specified in the option. If the private key provided by the user is an object, the private method object is used to directly call the next method; if the private key provided by the user is not an object, the peerId.createFromPrivKey method is called, according to The private key generates a node ID, and then calls the next method with the parameter; if no private key is provided, the peerId.create method is called to generate a random node ID, and then the next method is called with the parameter.

The specific code is as follows:

• Video|"8"" domain name circle "Buffett" Dai Yue: not enough cognition, is to make leek
• CFTC Chairman: Facebook Stabilization Coin project design is "very smart" and is determining whether it is regulated by CFTC
• Depth | Blockchain drives the cloud computing market to create a new generation of IT infrastructure

   (exists, cb) => {    self.log('repo exists?', exists)    if (exists === true) {      return cb(new Error('repo already exists'))    } 

 if (opts.privateKey) {  self.log('using user-supplied private-key')  if (typeof opts.privateKey === 'object') {    cb(null, opts.privateKey)  } else {    peerId.createFromPrivKey(Buffer.from(opts.privateKey, 'base64'), cb)  } } else {  // Generate peer identity keypair + transform to desired format + add to config.  opts.log( generating ${opts.bits}-bit RSA keypair... , false)  self.log('generating peer id: %s bits', opts.bits)  peerId.create({ bits: opts.bits }, cb) } 

   } 

Then, depending on whether the pass attribute is specified, decide whether or not to generate a Keychain . Because this configuration is not specified by default, it will not be generated here.

Finally, the init method of the repository object is called to initialize the repository.

The specific code is as follows:

   (peerId, cb) => {    self.log('identity generated')    config.Identity = {      PeerID: peerId.toB58String(),      PrivKey: peerId.privKey.bytes.toString('base64')    }    privateKey = peerId.privKey    if (opts.pass) {      config.Keychain = Keychain.generateOptions()    } 

 // 初始化仓库self._repo.init(config, cb) 

   } 

In the initialization method of the warehouse, the series function is used. This function will call the open method of the main object of the repository and the set object of the configuration object, the specification object, and the version object in order to actually initialize the warehouse. After the execution of these methods, the warehouse is completed. Three files, config, datastore_spec, and version, are generated below the directory.

 (_, cb) => self._repo.open(cb) 

The call to the root object's open method is no different from the previous one, but when the _isInitialized method is called, since the configuration object, the specification object, and the version object already exist, this time the object will not generate the error object, thus executing the next one. The function is not the final callback function, but the next function, the _openLock function. The result of this function execution is that a repo.lock directory is generated in the repository directory, indicating that the current process is not executing, thus not allowing another IPFS process to execute at the same time.

Below, we take a closer look at the rest of the warehouse open method:

• Save the file lock object to the repository object. The code is as follows, skip it.

     (lck, cb) => {    log('aquired repo.lock')    this.lockfile = lck    cb()  } 

• Process data storage and block storage objects. First, call the backends.create method to generate the datastore object, and save it in the same name property of the warehouse object, and generate the datastore directory and the corresponding file under the warehouse directory. This create simple, it is based on the first parameter, from the warehouse's option storageBackends to obtain a directory / file method, and then according to the second parameter specified path created, the third parameter created by the configuration parameters, through These parameters create the specified directory/file under the specified path.

Then, call the backends.create method to generate the underlying blockstore object, and generate the blocks directory under the repository directory.

Finally, the blockstore method is called to handle the underlying blockstore object based on the configuration options.

The specific code is as follows:

   (cb) => {    log('creating datastore，类型为 js-datastore-level')    this.datastore = backends.create('datastore', path.join(this.path, 'datastore'), this.options)    const blocksBaseStore = backends.create('blocks', path.join(this.path, 'blocks'), this.options)    blockstore(      blocksBaseStore,      this.options.storageBackendOptions.blocks,      cb)  } 

For the configuration options here, please refer to the process of generating a warehouse object mentioned in the previous article.

   (blocks, cb) => {    this.blocks = blocks    cb()  } 

   (cb) => {    log('creating keystore')    this.keys = backends.create('keys', path.join(this.path, 'keys'), this.options)    cb()  } 

code show as below:

   (cb) => {    if (opts.pass) {      const keychainOptions = Object.assign({ passPhrase: opts.pass }, config.Keychain)      self._keychain = new Keychain(self._repo.keys, keychainOptions)      self._keychain.importPeer('self', { privKey: privateKey }, cb)    } else {      cb(null, true)    }  } 

   (_, cb) => {    const offlineDatastore = new OfflineDatastore(self._repo) 

 self._ipns = new IPNS(offlineDatastore, self._repo.datastore, self._peerInfo, self._keychain, self._options) cb(null, true) 

   } 

 (_, cb) => {    if (opts.emptyRepo) {      return cb(null, true)    }    const tasks = [      (cb) => {        waterfall([          (cb) => DAGNode.create(new UnixFs('directory').marshal(), cb),          (node, cb) => self.dag.put(node, {            version: 0,            format: 'dag-pb',            hashAlg: 'sha2-256'          }, cb),          (cid, cb) => self._ipns.initializeKeyspace(privateKey, cid.toBaseEncodedString(), cb)        ], cb)      }    ] 

 if (typeof addDefaultAssets === 'function') {  tasks.push((cb) => addDefaultAssets(self, opts.log, cb)) } parallel(tasks, (err) => {  if (err) {    cb(err)  } else {    cb(null, true)  } }) 

 } 

addDefaultAssets variable is defined at the beginning of the file and is a function, so the second task to be executed is this function. The main purpose of this function is to save all the files in the init-files/init-docs/ directory to the repository, so when we finish the initialization, we can see a lot of files in the blocks directory of the repository. These files are saved here. The documents mentioned. The process of saving the file will be explained in detail later, and it will be skipped here.

This function has two parameters, which respectively represent the errors and results of the previous function execution. When the execution is successful, the preStart method of the IPFS object is preStart to perform pre-start. After the pre-start is successful, the final callback method is called to execute the process. Go back to the boot function and start executing the system startup method to start the system.

Pre-launch and start these two methods, we will stay in the next article for detailed explanation. Through the above combing, we can find that the init function is to initialize the system, including initializing/generating the repository, generating the node ID, saving the init-docs document, calling the pre-start/start method, etc. This method is generally It is to prepare everything needed to start the system, and then officially start.

Author: white zone

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