feat: most of the cp command

License: MIT
Signed-off-by: achingbrain <[email protected]>

Author: achingbrain

src/cli/cp.js

@@ -0,0 +1,41 @@
+'use strict'
+
+module.exports = {
+  command: 'cp <source> <dest>',
+
+  describe: 'Copy files between locations in the mfs.',
+
+  builder: {
+    recursive: {
+      alias: 'r',
+      type: 'boolean',
+      default: false,
+      describe: 'Copy directories recursively'
+    },
+    parents: {
+      alias: 'p',
+      type: 'boolean',
+      default: false,
+      describe: 'Create any non-existent intermediate directories'
+    }
+  },
+
+  handler (argv) {
+    let {
+      source,
+      dest,
+      ipfs,
+      recursive,
+      parents
+    } = argv
+
+    ipfs.mfs.cp(source, dest, {
+      recursive,
+      parents
+    }, (error) => {
+      if (error) {
+        throw error
+      }
+    })
+  }
+}

src/core/cp.js

@@ -0,0 +1,141 @@
+'use strict'
+
+const promisify = require('promisify-es6')
+const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
+const series = require('async/series')
+const path = require('path')
+const {
+  traverseTo,
+  addLink,
+  updateTree,
+  updateMfsRoot
+} = require('./utils')
+const stat = require('./stat')
+
+const defaultOptions = {
+  recursive: false,
+  parents: false,
+  flush: true,
+  format: 'dag-pb',
+  hashAlg: 'sha2-256'
+}
+
+module.exports = function mfsCp (ipfs) {
+  return promisify(function () {
+    const args = Array.prototype.slice.call(arguments)
+    const callback = args.pop()
+
+    if (args.length < 2) {
+      return callback(new Error('Please specify a source(s) and a destination'))
+    }
+
+    let destination = args.pop()
+    let options = {}
+
+    if (typeof destination !== 'string') {
+      options = destination
+      destination = args.pop()
+    }
+
+    options = Object.assign({}, defaultOptions, options)
+
+    const sources = args.map(source => ({
+      path: source,
+      name: path.basename(source),
+      dir: path.dirname(source)
+    }))
+
+    destination = {
+      path: destination,
+      name: path.basename(destination),
+      dir: path.dirname(destination)
+    }
+
+    if (sources.length < 1) {
+      return callback(new Error('Please specify a path to copy'))
+    }
+
+    if (sources.length === 1) {
+      return copyToFile(ipfs, sources.pop(), destination, options, callback)
+    }
+
+    copyToDirectory(ipfs, sources, destination, options, callback)
+  })
+}
+
+const copyToFile = (ipfs, source, destination, options, callback) => {
+  waterfall([
+    (cb) => {
+      parallel([
+        (next) => stat(ipfs)(source.path, options, next),
+        (next) => stat(ipfs)(destination.path, options, (error) => {
+          if (!error) {
+            return next(new Error('Destination exists'))
+          }
+
+          next()
+        }),
+        (next) => traverseTo(ipfs, destination.dir, options, next)
+      ], cb)
+    },
+    ([sourceStats, _, dest], cb) => {
+      waterfall([
+        (next) => addLink(ipfs, {
+          parent: dest.node,
+          child: sourceStats, // nb. file size here is not including protobuf wrapper so is wrong
+          name: destination.name
+        }, next),
+        (newParent, next) => {
+          dest.node = newParent
+          updateTree(ipfs, dest, next)
+        },
+        (newRoot, cb) => updateMfsRoot(ipfs, newRoot.node.multihash, cb)
+      ], cb)
+    }
+  ], callback)
+}
+
+const copyToDirectory = (ipfs, sources, destination, options, callback) => {
+  waterfall([
+    (cb) => {
+      series([
+        // stat in parallel
+        (done) => parallel(
+          sources.map(source => (next) => stat(ipfs)(source.path, options, next)),
+          done
+        ),
+        // this could end up changing the root mfs node so do it after parallel
+        (done) => traverseTo(ipfs, destination.path, Object.assign({}, options, {
+          createLastComponent: true
+        }), done)
+      ], cb)
+    },
+    (results, cb) => {
+      const dest = results.pop()
+      const sourceStats = results[0]
+
+      waterfall([
+        (next) => waterfall([
+          (done) => done(null, dest.node)
+        ].concat(
+          sourceStats.map((sourceStat, index) => {
+            return (dest, done) => {
+              return addLink(ipfs, {
+                parent: dest,
+                child: sourceStat, // nb. file size here is not including protobuf wrapper so is wrong
+                name: sources[index].name
+              }, done)
+            }
+          })
+        ), next),
+        (newParent, next) => {
+          dest.node = newParent
+
+          updateTree(ipfs, dest, next)
+        },
+        (newRoot, cb) => updateMfsRoot(ipfs, newRoot.node.multihash, cb)
+      ], cb)
+    }
+  ], callback)
+}

src/core/index.js

@@ -1,6 +1,7 @@
 'use strict'
 
 module.exports = {
+  cp: require('./cp'),
   ls: require('./ls'),
   mkdir: require('./mkdir'),
   read: require('./read'),

src/core/stat.js

@@ -8,6 +8,7 @@ const {
   traverseTo
 } = require('./utils')
 const waterfall = require('async/waterfall')
+const log = require('debug')('mfs:stat')
 
 const defaultOptions = {
   hash: false,
@@ -30,6 +31,8 @@ module.exports = function mfsStat (ipfs) {
       return callback(error)
     }
 
+    log(`Fetching stats for ${path}`)
+
     waterfall([
       (done) => traverseTo(ipfs, path, options, done),
       ({ node }, done) => {

src/core/utils/add-link.js

@@ -39,7 +39,7 @@ const addLink = (ipfs, options, callback) => {
     },
     (parent, done) => {
       if (!options.flush) {
-        return done()
+        return done(null, parent)
       }
 
       // Persist the new parent DAGNode

src/core/utils/create-node.js

@@ -5,7 +5,14 @@ const {
   DAGNode
 } = require('ipld-dag-pb')
 
+const defaultOptions = {
+  format: 'dag-pb',
+  hashAlg: 'sha2-256'
+}
+
 const createNode = (ipfs, data, links, options, callback) => {
+  options = Object.assign({}, defaultOptions, options)
+
   waterfall([
     // Create a DAGNode with the new data
     (cb) => DAGNode.create(data, links, cb),

src/core/utils/traverse-to.js

@@ -4,10 +4,6 @@ const bs58 = require('bs58')
 const CID = require('cids')
 const log = require('debug')('mfs:utils:traverse-to')
 const UnixFS = require('ipfs-unixfs')
-const dagPb = require('ipld-dag-pb')
-const {
-  DAGNode
-} = dagPb
 const waterfall = require('async/waterfall')
 const reduce = require('async/reduce')
 const withMfsRoot = require('./with-mfs-root')
@@ -16,12 +12,16 @@ const addLink = require('./add-link')
 const {
   FILE_SEPARATOR
 } = require('./constants')
+const createNode = require('./create-node')
+
+const defaultOptions = {
+  parents: false,
+  flush: true,
+  createLastComponent: false
+}
 
 const traverseTo = (ipfs, path, options, callback) => {
-  options = Object.assign({}, {
-    parents: false,
-    flush: true
-  }, options)
+  options = Object.assign({}, defaultOptions, options)
 
   waterfall([
     (done) => withMfsRoot(ipfs, done),
@@ -57,14 +57,18 @@ const traverseTo = (ipfs, path, options, callback) => {
             const existingLink = parent.node.links.find(link => link.name === pathSegment)
 
             if (!existingLink) {
+              if (index === pathSegments.length - 1 && !options.parents && !this.createLastComponent) {
+                return done(new Error(`Path ${path} did not exist`))
+              }
+
               if (!options.parents) {
-                return done(new Error(`Cannot traverse to ${path} - '${pathSegment}' did not exist: Try again with the --parents flag`))
+                return done(new Error(`Cannot find ${path} - '${pathSegment}' did not exist: Try again with the --parents flag to create it`))
               }
 
               log(`Adding empty directory '${pathSegment}' to parent ${parent.name}`)
 
               return waterfall([
-                (next) => DAGNode.create(new UnixFS('directory').marshal(), [], next),
+                (next) => createNode(ipfs, new UnixFS('directory').marshal(), [], options, next),
                 (emptyDirectory, next) => {
                   addLink(ipfs, {
                     parent: parent.node,
@@ -81,7 +85,11 @@ const traverseTo = (ipfs, path, options, callback) => {
                     })
                   })
                 }
-              ], done)
+              ], (error, child) => {
+                trail.push(child)
+
+                done(error, child)
+              })
             }
 
             let hash = existingLink.hash || existingLink.multihash

src/core/write/index.js

@@ -173,7 +173,10 @@ module.exports = function mfsWrite (ipfs) {
               )
 
               log('Importing file', fileName)
-              importNode(ipfs, source, options, next)
+              importNode(ipfs, source, options, (error, result) => {
+                log(`Imported file ${fileName}`)
+                next(error, result)
+              })
             }
           },
 

test/browser.js

@@ -1,5 +1,6 @@
 'use strict'
 
+require('./cp.spec.js')
 require('./ls.spec.js')
 require('./mkdir.spec.js')
 require('./read.spec.js')