Add metadata support

package.json

@@ -39,31 +39,34 @@
   "homepage": "https://github.com/ipfs/js-ipfs-mfs#readme",
   "devDependencies": {
     "aegir": "^20.0.0",
-    "async-iterator-all": "^1.0.0",
     "chai": "^4.2.0",
+    "chai-as-promised": "^7.1.1",
+    "delay": "^4.3.0",
     "detect-node": "^2.0.4",
     "detect-webworker": "^1.0.0",
     "dirty-chai": "^2.0.1",
     "ipfs-block-service": "~0.16.0",
-    "ipfs-repo": "~0.27.0",
+    "ipfs-repo": "^0.29.1",
     "ipld": "~0.25.0",
-    "memdown": "^4.0.0",
+    "it-all": "^1.0.1",
+    "memdown": "^5.1.0",
     "temp-write": "^4.0.0"
   },
   "dependencies": {
     "@hapi/boom": "^7.4.2",
     "@hapi/joi": "^15.1.0",
-    "async-iterator-last": "^1.0.0",
     "cids": "~0.7.1",
     "debug": "^4.1.0",
     "err-code": "^2.0.0",
     "hamt-sharding": "~0.0.2",
-    "interface-datastore": "~0.7.0",
+    "interface-datastore": "^0.8.0",
     "ipfs-multipart": "~0.2.0",
-    "ipfs-unixfs": "~0.1.16",
-    "ipfs-unixfs-exporter": "~0.38.0",
-    "ipfs-unixfs-importer": "~0.40.0",
+    "ipfs-unixfs": "^0.2.0",
+    "ipfs-unixfs-exporter": "~0.39.0",
+    "ipfs-unixfs-importer": "^0.42.0",
+    "ipfs-utils": "ipfs/js-ipfs-utils#support-unixfs-metadata",
     "ipld-dag-pb": "~0.18.0",
+    "it-last": "^1.0.1",
     "joi-browser": "^13.4.0",
     "mortice": "^2.0.0",
     "multicodec": "~0.5.3",

src/cli/chmod.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const {
+  asBoolean,
+  asOctal
+} = require('./utils')
+
+module.exports = {
+  command: 'chmod [mode] [path]',
+
+  describe: 'Change file modes',
+
+  builder: {
+    path: {
+      type: 'string',
+      describe: 'The MFS path to change the mode of'
+    },
+    mode: {
+      type: 'int',
+      coerce: asOctal,
+      describe: 'The mode to use'
+    },
+    recursive: {
+      type: 'boolean',
+      default: false,
+      coerce: asBoolean,
+      describe: 'Whether to change modes recursively'
+    },
+    flush: {
+      alias: 'f',
+      type: 'boolean',
+      default: true,
+      coerce: asBoolean,
+      describe: 'Flush the changes to disk immediately'
+    },
+    'shard-split-threshold': {
+      type: 'number',
+      default: 1000,
+      describe: 'If a directory has more links than this, it will be transformed into a hamt-sharded-directory'
+    }
+  },
+
+  handler (argv) {
+    const {
+      path,
+      mode,
+      getIpfs,
+      recursive,
+      flush,
+      shardSplitThreshold
+    } = argv
+
+    argv.resolve((async () => {
+      const ipfs = await getIpfs()
+
+      return ipfs.files.chmod(path, mode, {
+        recursive,
+        flush,
+        shardSplitThreshold
+      })
+    })())
+  }
+}

src/cli/cp.js

@@ -18,7 +18,7 @@ module.exports = {
       describe: 'Create any non-existent intermediate directories'
     },
     format: {
-      alias: 'h',
+      alias: 'f',
       type: 'string',
       default: 'dag-pb',
       describe: 'If intermediate directories are created, use this format to create them (experimental)'

src/cli/ls.js

@@ -10,6 +10,8 @@ const {
 const {
   FILE_SEPARATOR
 } = require('../core/utils/constants')
+const formatMode = require('ipfs-utils/src/files/format-mode')
+const formatMtime = require('ipfs-utils/src/files/format-mtime')
 
 module.exports = {
   command: 'ls [path]',
@@ -64,8 +66,8 @@ module.exports = {
               }
 
               if (long) {
-                files.forEach(link => {
-                  print(`${link.name}\t${link.hash}\t${link.size}`)
+                files.forEach(file => {
+                  print(`${formatMode(file.mode, file.type === 1)}\t${formatMtime(file.mtime)}\t${file.name}\t${file.hash}\t${file.size}`)
                 })
               } else {
                 files.forEach(link => print(link.name))
@@ -85,7 +87,7 @@ module.exports = {
           }),
           through(file => {
             if (long) {
-              print(`${file.name}\t${file.hash}\t${file.size}`)
+              print(`${formatMode(file.mode, file.type === 1)}\t${formatMtime(file.mtime)}\t${file.name}\t${file.hash}\t${file.size}`)
             } else {
               print(file.name)
             }

src/cli/mkdir.js

@@ -1,7 +1,8 @@
 'use strict'
 
 const {
-  asBoolean
+  asBoolean,
+  asOctal
 } = require('./utils')
 
 module.exports = {
@@ -38,6 +39,20 @@ module.exports = {
       type: 'number',
       default: 1000,
       describe: 'If a directory has more links than this, it will be transformed into a hamt-sharded-directory'
+    },
+    mode: {
+      alias: 'm',
+      type: 'number',
+      default: true,
+      coerce: asOctal,
+      describe: 'Mode to apply to the new directory'
+    },
+    mtime: {
+      alias: 'm',
+      type: 'number',
+      default: true,
+      coerce: asOctal,
+      describe: 'Mtime to apply to the new directory'
     }
   },
 
@@ -49,7 +64,9 @@ module.exports = {
       cidVersion,
       hashAlg,
       flush,
-      shardSplitThreshold
+      shardSplitThreshold,
+      mode,
+      mtime
     } = argv
 
     argv.resolve((async () => {
@@ -60,7 +77,9 @@ module.exports = {
         cidVersion,
         hashAlg,
         flush,
-        shardSplitThreshold
+        shardSplitThreshold,
+        mode,
+        mtime
       })
     })())
   }

src/cli/stat.js

@@ -18,8 +18,10 @@ module.exports = {
 Size: <size>
 CumulativeSize: <cumulsize>
 ChildBlocks: <childs>
-Type: <type>`,
-      describe: 'Print statistics in given format. Allowed tokens: <hash> <size> <cumulsize> <type> <childs>. Conflicts with other format options.'
+Type: <type>
+Mode: <mode>
+Mtime: <mtime>`,
+      describe: 'Print statistics in given format. Allowed tokens: <hash> <size> <cumulsize> <type> <childs> <mode> <mtime>. Conflicts with other format options.'
     },
     hash: {
       alias: 'h',
@@ -79,6 +81,8 @@ Type: <type>`,
             .replace('<cumulsize>', stats.cumulativeSize)
             .replace('<childs>', stats.blocks)
             .replace('<type>', stats.type)
+            .replace('<mode>', stats.mode)
+            .replace('<mtime>', stats.mtime)
           )
         })
     })())

src/cli/touch.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const {
+  asBoolean
+} = require('./utils')
+
+module.exports = {
+  command: 'touch [path]',
+
+  describe: 'change file modification times',
+
+  builder: {
+    flush: {
+      alias: 'f',
+      type: 'boolean',
+      default: true,
+      coerce: asBoolean,
+      describe: 'Flush the changes to disk immediately'
+    },
+    'shard-split-threshold': {
+      type: 'number',
+      default: 1000,
+      describe: 'If a directory has more links than this, it will be transformed into a hamt-sharded-directory'
+    },
+    'cid-version': {
+      alias: ['cid-ver'],
+      type: 'number',
+      default: 0,
+      describe: 'Cid version to use'
+    },
+    mtime: {
+      alias: 'm',
+      type: 'number',
+      default: parseInt(Date.now() / 1000),
+      describe: 'Time to use as the new modification time'
+    }
+  },
+
+  handler (argv) {
+    const {
+      path,
+      getIpfs,
+      flush,
+      shardSplitThreshold,
+      cidVersion,
+      mtime
+    } = argv
+
+    argv.resolve((async () => {
+      const ipfs = await getIpfs()
+
+      return ipfs.files.touch(path, mtime, {
+        flush,
+        shardSplitThreshold,
+        cidVersion
+      })
+    })())
+  }
+}

src/cli/utils.js

@@ -31,8 +31,13 @@ const asBoolean = (value) => {
   return false
 }
 
+const asOctal = (value) => {
+  return parseInt(value, 8)
+}
+
 module.exports = {
   disablePrinting,
   print,
-  asBoolean
+  asBoolean,
+  asOctal
 }

src/core/chmod.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const applyDefaultOptions = require('./utils/apply-default-options')
+const toMfsPath = require('./utils/to-mfs-path')
+const log = require('debug')('ipfs:mfs:touch')
+const errCode = require('err-code')
+const UnixFS = require('ipfs-unixfs')
+const toTrail = require('./utils/to-trail')
+const addLink = require('./utils/add-link')
+const updateTree = require('./utils/update-tree')
+const updateMfsRoot = require('./utils/update-mfs-root')
+const { DAGNode } = require('ipld-dag-pb')
+const mc = require('multicodec')
+const mh = require('multihashes')
+
+const defaultOptions = {
+  flush: true,
+  shardSplitThreshold: 1000,
+  cidVersion: 1,
+  format: 'dag-pb',
+  hashAlg: 'sha2-256'
+}
+
+module.exports = (context) => {
+  return async function mfsChmod (path, mode, options) {
+    options = applyDefaultOptions(options, defaultOptions)
+
+    log(`Fetching stats for ${path}`)
+
+    const {
+      cid,
+      mfsDirectory,
+      name
+    } = await toMfsPath(context, path)
+
+    if (cid.codec !== 'dag-pb') {
+      throw errCode(new Error(`${path} was not a UnixFS node`), 'ERR_NOT_UNIXFS')
+    }
+
+    let node = await context.ipld.get(cid)
+    const metadata = UnixFS.unmarshal(node.Data)
+    metadata.mode = mode
+    node = new DAGNode(metadata.marshal(), node.Links)
+
+    const updatedCid = await context.ipld.put(node, mc.DAG_PB, {
+      cidVersion: cid.version,
+      hashAlg: mh.names['sha2-256'],
+      hashOnly: !options.flush
+    })
+
+    const trail = await toTrail(context, mfsDirectory, options)
+    const parent = trail[trail.length - 1]
+    const parentNode = await context.ipld.get(parent.cid)
+
+    const result = await addLink(context, {
+      parent: parentNode,
+      name: name,
+      cid: updatedCid,
+      size: node.serialize().length,
+      flush: options.flush,
+      format: 'dag-pb',
+      hashAlg: 'sha2-256',
+      cidVersion: cid.version
+    })
+
+    parent.cid = result.cid
+
+    // update the tree with the new child
+    const newRootCid = await updateTree(context, trail, options)
+
+    // Update the MFS record with the new CID for the root of the tree
+    await updateMfsRoot(context, newRootCid)
+  }
+}

src/core/index.js

@@ -10,11 +10,13 @@ const readOperations = {
 
 // These operations are locked at the function level and will execute in series
 const writeOperations = {
+  chmod: require('./chmod'),
   cp: require('./cp'),
   flush: require('./flush'),
   mkdir: require('./mkdir'),
   mv: require('./mv'),
-  rm: require('./rm')
+  rm: require('./rm'),
+  touch: require('./touch')
 }
 
 // These operations are asynchronous and manage their own locking