feat: enable recursive lookups on ipfs.dns

Author: niinpatel

src/cli/commands/dns.js

@@ -7,15 +7,22 @@ module.exports = {
   describe: 'Resolve DNS links',
 
   builder: {
+    recursive: {
+      type: 'boolean',
+      default: false,
+      alias: 'r',
+      desc: 'Resolve until the result is not a DNS link'
+    },
     format: {
       type: 'string'
     }
   },
 
-  handler ({ getIpfs, domain, resolve }) {
+  handler ({ getIpfs, domain, recursive, format, resolve }) {
+    const opts = { recursive, format }
     resolve((async () => {
       const ipfs = await getIpfs()
-      const path = await ipfs.dns(domain)
+      const path = await ipfs.dns(domain, opts)
       print(path)
     })())
   }

src/core/runtime/dns-nodejs.js

@@ -2,10 +2,28 @@
 
 const dns = require('dns')
 const _ = require('lodash')
+const isIPFS = require('is-ipfs')
 const errcode = require('err-code')
 
+const maxRecursiveDepth = 32
+
 module.exports = (domain, opts, callback) => {
-  resolveDnslink(domain)
+  const recursive = opts.recursive && opts.recursive.toString() === 'true'
+  let depth
+  if (recursive) {
+    depth = maxRecursiveDepth
+  }
+
+  return recursiveResolveDnslink(domain, depth, callback)
+}
+
+function recursiveResolveDnslink (domain, depth, callback) {
+  if (depth === 0) {
+    const errMsg = `recursion limit of ${maxRecursiveDepth} exceeded`
+    return callback(errcode(errMsg, 'ERR_DNSLINK_RECURSION_LIMIT'))
+  }
+
+  return resolveDnslink(domain)
     .catch(err => {
       // If the code is not ENOTFOUND or ERR_DNSLINK_NOT_FOUND or ENODATA then throw the error
       if (err.code !== 'ENOTFOUND' && err.code !== 'ERR_DNSLINK_NOT_FOUND' && err.code !== 'ENODATA') {
@@ -24,7 +42,14 @@ module.exports = (domain, opts, callback) => {
       return resolveDnslink(_dnslinkDomain)
     })
     .then(dnslinkRecord => {
-      callback(null, dnslinkRecord.replace('dnslink=', ''))
+      const result = dnslinkRecord.replace('dnslink=', '')
+      const domainOrCID = result.split('/')[2]
+      const isIPFSCID = isIPFS.cid(domainOrCID)
+
+      if (isIPFSCID || !depth) {
+        return callback(null, result)
+      }
+      return recursiveResolveDnslink(domainOrCID, depth - 1, callback)
     })
     .catch(callback)
 }

src/http/api/resources/dns.js

@@ -3,11 +3,13 @@
 const Boom = require('boom')
 
 module.exports = async (request, h) => {
-  if (!request.query.arg) {
+  const { arg: domain, ...opts } = request.query
+
+  if (!domain) {
     throw Boom.badRequest("Argument 'domain' is required")
   }
 
-  const path = await request.server.app.ipfs.dns(request.query.arg)
+  const path = await request.server.app.ipfs.dns(domain, opts)
   return h.response({
     Path: path
   })

test/cli/dns.js

@@ -3,6 +3,7 @@
 
 const expect = require('chai').expect
 const runOnAndOff = require('../utils/on-and-off')
+const isIPFS = require('is-ipfs')
 
 describe('dns', () => runOnAndOff((thing) => {
   let ipfs
@@ -28,6 +29,15 @@ describe('dns', () => runOnAndOff((thing) => {
     })
   })
 
+  it('recursively resolve ipfs.io', function () {
+    this.timeout(60 * 1000)
+
+    return ipfs('dns --recursive ipfs.io').then((res) => {
+      const resultingDomainOrCid = res.split('/')[2].trim()
+      expect(isIPFS.cid(resultingDomainOrCid)).to.eql(true)
+    })
+  })
+
   it('resolve subdomain docs.ipfs.io dns', function () {
     this.timeout(60 * 1000)