feat: update ipfsd-ctl to 4.x

package.json

@@ -79,13 +79,16 @@
     "electron-updater": "^4.2.5",
     "fix-path": "^3.0.0",
     "fs-extra": "^9.0.0",
-    "go-ipfs-dep": "0.4.23",
     "i18next": "^19.4.3",
+    "go-ipfs-dep": "^0.4.23-3",
     "i18next-electron-language-detector": "0.0.10",
     "i18next-icu": "^1.3.1",
     "i18next-node-fs-backend": "^2.1.3",
-    "ipfsd-ctl": "^0.46.1",
+    "ipfs-http-client": "^44.0.0",
+    "ipfsd-ctl": "^4.0.1",
     "is-ipfs": "^1.0.0",
+    "it-all": "^1.0.1",
+    "it-concat": "^1.0.0",
     "multiaddr": "^7.4.3",
     "multiaddr-to-uri": "^5.1.0",
     "portfinder": "^1.0.25",

src/add-to-ipfs.js

@@ -3,8 +3,9 @@ const { clipboard } = require('electron')
 const i18n = require('i18next')
 const logger = require('./common/logger')
 const { notify, notifyError } = require('./common/notify')
+const { globSource } = require('ipfs-http-client')
 
-async function copyFile (ipfs, hash, name) {
+async function copyFile (ipfs, cid, name) {
   let i = 0
   const ext = extname(name)
   const base = basename(name, ext)
@@ -22,7 +23,7 @@ async function copyFile (ipfs, hash, name) {
     i++
   }
 
-  return ipfs.files.cp(`/ipfs/${hash}`, `/${name}`)
+  return ipfs.files.cp(`/ipfs/${cid.toString()}`, `/${name}`)
 }
 
 async function makeShareableObject (ipfs, results) {
@@ -33,15 +34,15 @@ async function makeShareableObject (ipfs, results) {
 
   let baseCID = await ipfs.object.new('unixfs-dir')
 
-  for (const { hash, path, size } of results) {
+  for (const { cid, path, size } of results) {
     baseCID = (await ipfs.object.patch.addLink(baseCID, {
       name: path,
       size,
-      cid: hash
-    })).toString()
+      cid
+    }))
   }
 
-  return { hash: baseCID, path: '' }
+  return { cid: baseCID, path: '' }
 }
 
 function sendNotification (failures, successes, launch, path) {
@@ -86,10 +87,13 @@ module.exports = async function ({ getIpfsd, launchWebUI }, files) {
 
   await Promise.all(files.map(async file => {
     try {
-      const results = await ipfsd.api.addFromFs(file, { recursive: true })
-      const { path, hash, size } = results[results.length - 1]
-      await copyFile(ipfsd.api, hash, path)
-      successes.push({ path, hash, size })
+      let result = null
+      for await (const res of ipfsd.api.add(globSource(file, { recursive: true }))) {
+        result = res
+      }
+
+      await copyFile(ipfsd.api, result.cid, result.path)
+      successes.push(result)
     } catch (e) {
       failures.push(e)
     }
@@ -101,9 +105,9 @@ module.exports = async function ({ getIpfsd, launchWebUI }, files) {
     log.end()
   }
 
-  const { hash, path } = await makeShareableObject(ipfsd.api, successes)
+  const { cid, path } = await makeShareableObject(ipfsd.api, successes)
   sendNotification(failures, successes, launchWebUI, path)
 
-  const url = `https://ipfs.io/ipfs/${hash}`
+  const url = `https://ipfs.io/ipfs/${cid.toString()}`
   clipboard.writeText(url)
 }

src/common/logger.js

@@ -61,7 +61,7 @@ module.exports = Object.freeze({
       },
       fail: (err) => {
         Countly.log_error(err)
-        logger.error(`${msg} ${err.toString()}`)
+        logger.error(`${msg} ${err.stack}`)
       }
     }
   },

src/daemon/config.js

@@ -9,8 +9,16 @@ const { showDialog } = require('../dialogs')
 const store = require('../common/store')
 const logger = require('../common/logger')
 
+function configExists (ipfsd) {
+  return fs.pathExistsSync(join(ipfsd.path, 'config'))
+}
+
+function apiFileExists (ipfsd) {
+  return fs.pathExistsSync(join(ipfsd.path, 'api'))
+}
+
 function configPath (ipfsd) {
-  return join(ipfsd.repoPath, 'config')
+  return join(ipfsd.path, 'config')
 }
 
 function readConfigFile (ipfsd) {
@@ -151,7 +159,7 @@ async function checkPortsArray (ipfsd, addrs) {
       })
 
       if (opt === 0) {
-        shell.openItem(join(ipfsd.repoPath, 'config'))
+        shell.openItem(join(ipfsd.path, 'config'))
       }
 
       throw new Error('ports already being used')
@@ -184,8 +192,13 @@ async function checkPorts (ipfsd) {
   const apiPort = parseInt(configApiMa.nodeAddress().port, 10)
   const gatewayPort = parseInt(configGatewayMa.nodeAddress().port, 10)
 
-  const freeGatewayPort = await portfinder.getPortPromise({ port: gatewayPort, stopPort: gatewayPort + 100 })
-  const freeApiPort = await portfinder.getPortPromise({ port: apiPort, stopPort: apiPort + 100 })
+  const findFreePort = async (port, from) => {
+    port = Math.max(port, from, 1024)
+    return portfinder.getPortPromise({ port, stopPort: port + 100 })
+  }
+
+  const freeGatewayPort = await findFreePort(gatewayPort, 8080)
+  const freeApiPort = await findFreePort(apiPort, 5001)
 
   const busyApiPort = apiPort !== freeApiPort
   const busyGatewayPort = gatewayPort !== freeGatewayPort
@@ -194,46 +207,51 @@ async function checkPorts (ipfsd) {
     return
   }
 
-  let message = null
-  let options = null
-
-  if (busyApiPort && busyGatewayPort) {
-    logger.info('[daemon] api and gateway ports busy')
-    message = 'busyPortsDialog'
-    options = {
-      port1: apiPort,
-      alt1: freeApiPort,
-      port2: gatewayPort,
-      alt2: freeGatewayPort
-    }
-  } else if (busyApiPort) {
-    logger.info('[daemon] api port busy')
-    message = 'busyPortDialog'
-    options = {
-      port: apiPort,
-      alt: freeApiPort
-    }
-  } else {
-    logger.info('[daemon] gateway port busy')
-    message = 'busyPortDialog'
-    options = {
-      port: gatewayPort,
-      alt: freeGatewayPort
+  // two "0" in config mean "pick free ports without any prompt"
+  const promptUser = (apiPort !== 0 || gatewayPort !== 0)
+
+  if (promptUser) {
+    let message = null
+    let options = null
+
+    if (busyApiPort && busyGatewayPort) {
+      logger.info('[daemon] api and gateway ports busy')
+      message = 'busyPortsDialog'
+      options = {
+        port1: apiPort,
+        alt1: freeApiPort,
+        port2: gatewayPort,
+        alt2: freeGatewayPort
+      }
+    } else if (busyApiPort) {
+      logger.info('[daemon] api port busy')
+      message = 'busyPortDialog'
+      options = {
+        port: apiPort,
+        alt: freeApiPort
+      }
+    } else {
+      logger.info('[daemon] gateway port busy')
+      message = 'busyPortDialog'
+      options = {
+        port: gatewayPort,
+        alt: freeGatewayPort
+      }
     }
-  }
 
-  const opt = showDialog({
-    title: i18n.t(`${message}.title`),
-    message: i18n.t(`${message}.message`, options),
-    type: 'error',
-    buttons: [
-      i18n.t(`${message}.action`, options),
-      i18n.t('close')
-    ]
-  })
+    const opt = showDialog({
+      title: i18n.t(`${message}.title`),
+      message: i18n.t(`${message}.message`, options),
+      type: 'error',
+      buttons: [
+        i18n.t(`${message}.action`, options),
+        i18n.t('close')
+      ]
+    })
 
-  if (opt !== 0) {
-    throw new Error('ports already being used')
+    if (opt !== 0) {
+      throw new Error('ports already being used')
+    }
   }
 
   if (busyApiPort) {
@@ -250,6 +268,8 @@ async function checkPorts (ipfsd) {
 
 module.exports = Object.freeze({
   configPath,
+  configExists,
+  apiFileExists,
   applyDefaults,
   checkCorsConfig,
   checkPorts

src/daemon/daemon.js

@@ -1,12 +1,9 @@
-const IPFSFactory = require('ipfsd-ctl')
+const Ctl = require('ipfsd-ctl')
 const i18n = require('i18next')
-const fs = require('fs-extra')
-const { app } = require('electron')
 const { execFileSync } = require('child_process')
-const findExecutable = require('ipfsd-ctl/src/utils/find-ipfs-executable')
 const { showDialog } = require('../dialogs')
 const logger = require('../common/logger')
-const { applyDefaults, checkCorsConfig, checkPorts, configPath } = require('./config')
+const { applyDefaults, checkCorsConfig, checkPorts, configExists, apiFileExists } = require('./config')
 
 function cannotConnectDialog (addr) {
   showDialog({
@@ -22,19 +19,19 @@ function cannotConnectDialog (addr) {
 async function cleanup (ipfsd) {
   const log = logger.start('[daemon] cleanup')
 
-  if (!await fs.pathExists(configPath(ipfsd))) {
+  if (!configExists(ipfsd)) {
     cannotConnectDialog(ipfsd.apiAddr)
-    throw new Error('cannot tonnect to api')
+    throw new Error('cannot connect to api')
   }
 
   log.info('run: ipfs repo fsck')
-  const exec = findExecutable('go', app.getAppPath())
+  const exec = require('go-ipfs-dep').path()
 
   try {
     execFileSync(exec, ['repo', 'fsck'], {
       env: {
         ...process.env,
-        IPFS_PATH: ipfsd.repoPath
+        IPFS_PATH: ipfsd.path
       }
     })
     log.end()
@@ -43,45 +40,54 @@ async function cleanup (ipfsd) {
   }
 }
 
-async function spawn ({ type, path, keysize }) {
-  const factory = IPFSFactory.create({ type: type })
-
-  const ipfsd = await factory.spawn({
+async function spawn ({ flags, path, keysize }) {
+  const ipfsd = await Ctl.createController({
+    ipfsHttpModule: require('ipfs-http-client'),
+    ipfsBin: require('go-ipfs-dep').path(),
+    ipfsOptions: {
+      repo: path
+    },
+    remote: false,
     disposable: false,
-    defaultAddrs: true,
-    repoPath: path,
-    init: false,
-    start: false
+    test: false,
+    args: flags
   })
 
-  if (ipfsd.initialized) {
+  if (configExists(ipfsd)) {
     checkCorsConfig(ipfsd)
-    return ipfsd
+    return { ipfsd, isRemote: false }
+  }
+
+  // If config does not exist, but $IPFS_PATH/api exists, then
+  // it is a remote repository.
+  if (apiFileExists(ipfsd)) {
+    return { ipfsd, isRemote: true }
   }
 
   await ipfsd.init({
-    directory: path,
-    keysize: keysize
+    bits: keysize
   })
 
   applyDefaults(ipfsd)
-  return ipfsd
+  return { ipfsd, isRemote: false }
 }
 
 module.exports = async function (opts) {
-  const ipfsd = await spawn(opts)
-  await checkPorts(ipfsd)
-  await ipfsd.start(opts.flags)
+  const { ipfsd, isRemote } = await spawn(opts)
+  if (!isRemote) await checkPorts(ipfsd)
 
   try {
-    await ipfsd.api.id()
+    await ipfsd.start()
+    const { id } = await ipfsd.api.id()
+    logger.info(`[daemon] PeerID is ${id}`)
+    logger.info(`[daemon] Repo is at ${ipfsd.path}`)
   } catch (err) {
     if (!err.message.includes('ECONNREFUSED')) {
       throw err
     }
 
     await cleanup(ipfsd)
-    await ipfsd.start(opts.flags)
+    await ipfsd.start()
   }
 
   return ipfsd

src/daemon/index.js

@@ -57,7 +57,7 @@ module.exports = async function (ctx) {
       // This way we use the default path when it is
       // not set.
       if (!config.path || typeof config.path !== 'string') {
-        config.path = ipfsd.repoPath
+        config.path = ipfsd.path
         store.set('ipfsConfig', config)
         writeIpfsPath(config.path)
       }
@@ -78,21 +78,19 @@ module.exports = async function (ctx) {
     const log = logger.start('[ipfsd] stop daemon', { withAnalytics: 'DAEMON_STOP' })
     updateStatus(STATUS.STOPPING_STARTED)
 
-    if (!fs.pathExists(join(ipfsd.repoPath, 'config'))) {
+    if (!fs.pathExistsSync(join(ipfsd.path, 'config'))) {
       // Is remote api... ignore
       ipfsd = null
       updateStatus(STATUS.STOPPING_FINISHED)
       return
     }
 
     try {
-      // give ipfs 3s to stop. An unclean shutdown is preferable to making the
-      // user wait, and taking longer prevents the update mechanism from working.
-      await ipfsd.stop(180)
+      await ipfsd.stop()
       log.end()
       updateStatus(STATUS.STOPPING_FINISHED)
     } catch (err) {
-      logger.error(`[ipfsd] ${err.toString}`)
+      logger.error(`[ipfsd] ${err.toString()}`)
       updateStatus(STATUS.STOPPING_FAILED)
     } finally {
       ipfsd = null