fix: make it experimental

Author: hugomrdias

package.json

@@ -148,6 +148,8 @@
     "multihashes": "~0.4.14",
     "multihashing-async": "~0.6.0",
     "node-fetch": "^2.3.0",
+    "p-any": "^2.1.0",
+    "p-settle": "^3.1.0",
     "peer-book": "~0.9.0",
     "peer-id": "~0.12.0",
     "peer-info": "~0.15.0",

src/cli/commands/daemon.js

@@ -20,6 +20,16 @@ module.exports = {
         type: 'boolean',
         default: false
       })
+      .option('enable-ipns-experiment', {
+        type: 'boolean',
+        default: false,
+        desc: 'EXPERIMENTAL ipns routers.'
+      })
+      .option('experimental-ipns-alias', {
+        type: 'string',
+        default: '',
+        desc: 'EXPERIMENTAL human readable alias for ipns subdomains.'
+      })
       .option('offline', {
         type: 'boolean',
         desc: 'Run offline. Do not connect to the rest of the network but provide local API.',
@@ -54,9 +64,13 @@ module.exports = {
         preload: { enabled: argv.enablePreload },
         EXPERIMENTAL: {
           pubsub: argv.enablePubsubExperiment,
+          ipnsDNS: argv.enableIpnsExperiment,
           ipnsPubsub: argv.enableNamesysPubsub,
           dht: argv.enableDhtExperiment,
           sharding: argv.enableShardingExperiment
+        },
+        ipns: {
+          alias: argv.experimentalIpnsAlias
         }
       })
 

src/core/config.js

@@ -46,9 +46,10 @@ const configSchema = s({
   EXPERIMENTAL: optional(s({
     pubsub: 'boolean?',
     ipnsPubsub: 'boolean?',
+    ipnsDNS: 'boolean?',
     sharding: 'boolean?',
     dht: 'boolean?'
-  }, { dht: false, pubsub: false, ipnsPubsub: false, sharding: false })),
+  }, { dht: false, pubsub: false, ipnsDNS: false, ipnsPubsub: false, sharding: false })),
   connectionManager: 'object?',
   config: optional(s({
     API: 'object?',
@@ -69,9 +70,11 @@ const configSchema = s({
     Bootstrap: optional(s(['multiaddr-ipfs']))
   })),
   ipld: 'object?',
+  ipns: 'object?',
   libp2p: optional(union(['function', 'object'])) // libp2p validates this
 }, {
-  repoOwner: true
+  repoOwner: true,
+  ipns: {}
 })
 
 const validate = (opts) => {

src/core/ipns/routing/config.js

@@ -3,9 +3,10 @@
 const { TieredDatastore } = require('datastore-core')
 const PubsubDatastore = require('./pubsub-datastore')
 const OfflineDatastore = require('./offline-datastore')
-const DnsDatastore = require('./dns-datastore')
-const MDnsDatastore = require('./mdns-datastore')
-const WorkersDatastore = require('./workers-datastore')
+const DnsDatastore = require('./experimental/dns-datastore')
+const MDnsDatastore = require('./experimental/mdns-datastore')
+const WorkersDatastore = require('./experimental/workers-datastore')
+const ExperimentalTieredDatastore = require('./experimental/tiered-datastore')
 /**
  * @typedef { import("../../index") } IPFS
  */
@@ -19,6 +20,12 @@ const WorkersDatastore = require('./workers-datastore')
 module.exports = (ipfs) => {
   // Setup online routing for IPNS with a tiered routing composed by a DHT and a Pubsub router (if properly enabled)
   const ipnsStores = []
+  if (ipfs._options.EXPERIMENTAL.ipnsDNS) {
+    ipnsStores.push(new WorkersDatastore(ipfs._options.ipns))
+    ipnsStores.push(new DnsDatastore(ipfs._options.ipns))
+    ipnsStores.push(new MDnsDatastore(ipfs._options.ipns))
+    return new ExperimentalTieredDatastore(ipnsStores)
+  }
 
   // // Add IPNS pubsub if enabled
   if (ipfs._options.EXPERIMENTAL.ipnsPubsub) {
@@ -32,10 +39,6 @@ module.exports = (ipfs) => {
     ipnsStores.push(new OfflineDatastore(ipfs._repo))
   }
 
-  ipnsStores.push(new MDnsDatastore())
-  ipnsStores.push(new DnsDatastore())
-  ipnsStores.push(new WorkersDatastore())
-
   // Create ipns routing with a set of datastores
   return new TieredDatastore(ipnsStores)
 }

src/core/ipns/routing/dns-datastore.js

@@ -0,0 +1,76 @@
+/* eslint-disable no-console */
+'use strict'
+
+const ky = require('ky-universal').default
+const errcode = require('err-code')
+const debug = require('debug')
+const { dohBinary, keyToBase32 } = require('./utils')
+
+const log = debug('ipfs:ipns:dns-datastore')
+log.error = debug('ipfs:ipns:dns-datastore:error')
+
+class DNSDataStore {
+  constructor (options) {
+    this.options = options
+  }
+
+  /**
+   * Put a key value pair into the datastore
+   * @param {Buffer} key identifier of the value.
+   * @param {Buffer} value value to be stored.
+   * @returns {Promise}
+   */
+  async put (key, value) {
+    const start = Date.now()
+    if (key.toString().startsWith('/pk/')) {
+      return
+    }
+    if (!Buffer.isBuffer(key)) {
+      throw errcode(new Error('DNS datastore key must be a buffer'), 'ERR_INVALID_KEY')
+    }
+    if (!Buffer.isBuffer(value)) {
+      throw errcode(new Error(`DNS datastore value must be a buffer`), 'ERR_INVALID_VALUE')
+    }
+
+    const keyStr = keyToBase32(key)
+    const data = await ky
+      .put(
+        'https://ipns.dev',
+        {
+          json: {
+            key: keyStr,
+            record: value.toString('base64'),
+            subdomain: true,
+            alias: this.options.alias
+          }
+        }
+      )
+      .json()
+
+    console.log(`
+    DNS Store
+    Domain: ipns.dev
+    Key: ${keyStr}
+    Subdomain: ${data.subdomain}
+    Alias: ${data.alias}
+    Time: ${(Date.now() - start)}ms
+    `)
+  }
+
+  /**
+   * Get a value from the local datastore indexed by the received key properly encoded.
+   * @param {Buffer} key identifier of the value to be obtained.
+   * @returns {Promise}
+   */
+  get (key) {
+    if (!Buffer.isBuffer(key)) {
+      throw errcode(new Error(`DNS datastore key must be a buffer`), 'ERR_INVALID_KEY')
+    }
+    // https://dns.google.com/experimental
+    // https://cloudflare-dns.com/dns-query
+    // https://mozilla.cloudflare-dns.com/dns-query
+    return dohBinary('https://cloudflare-dns.com/dns-query', 'dns.ipns.dev', key)
+  }
+}
+
+module.exports = DNSDataStore

src/core/ipns/routing/experimental/dns-datastore.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 'use strict'
 
 const ky = require('ky-universal').default
@@ -11,61 +12,55 @@ log.error = debug('ipfs:ipns:mdns-datastore:error')
 // DNS datastore aims to mimic the same encoding as routing when storing records
 // to the local datastore
 class MDNSDataStore {
+  constructor (options) {
+    this.options = options
+  }
   /**
-   * Put a value to the local datastore indexed by the received key properly encoded.
+   * Put a key value pair into the datastore
    * @param {Buffer} key identifier of the value.
    * @param {Buffer} value value to be stored.
-   * @param {function(Error)} callback
-   * @returns {void}
+   * @returns {Promise}
    */
-  put (key, value, callback) {
+  async put (key, value) {
+    const start = Date.now()
     if (key.toString().startsWith('/pk/')) {
-      return callback()
+      return
     }
     if (!Buffer.isBuffer(key)) {
-      return callback(errcode(new Error('MDNS datastore key must be a buffer'), 'ERR_INVALID_KEY'))
+      throw errcode(new Error('MDNS datastore key must be a buffer'), 'ERR_INVALID_KEY')
     }
     if (!Buffer.isBuffer(value)) {
-      return callback(errcode(new Error(`MDNS datastore value must be a buffer`), 'ERR_INVALID_VALUE'))
+      throw errcode(new Error(`MDNS datastore value must be a buffer`), 'ERR_INVALID_VALUE')
     }
 
-    let keyStr
-    try {
-      keyStr = keyToBase32(key)
-    } catch (err) {
-      log.error(err)
-      return callback(err)
-    }
-    ky.put(
+    const keyStr = keyToBase32(key)
+    await ky.put(
       'http://ipns.local:8000',
       {
         json: {
           key: keyStr,
           record: value.toString('base64')
         }
       })
-      .then(data => {
-        log(`publish key: ${keyStr}`)
-        setImmediate(() => callback())
-      })
-      .catch(err => {
-        log.error(err)
-        setImmediate(() => callback(err))
-      })
+    console.log(`
+    Local Store
+    Domain: ipns.local
+    Key: ${keyStr}
+    Time: ${(Date.now() - start)}ms
+    `)
   }
 
   /**
    * Get a value from the local datastore indexed by the received key properly encoded.
    * @param {Buffer} key identifier of the value to be obtained.
-   * @param {function(Error, Buffer)} callback
-   * @returns {void}
+   * @returns {Promise}
    */
-  get (key, callback) {
+  get (key) {
     if (!Buffer.isBuffer(key)) {
-      return callback(errcode(new Error(`MDNS datastore key must be a buffer`), 'ERR_INVALID_KEY'))
+      throw errcode(new Error(`MDNS datastore key must be a buffer`), 'ERR_INVALID_KEY')
     }
 
-    dohBinary('http://ipns.local:8000/dns-query', 'ipns.local', key, callback)
+    return dohBinary('http://ipns.local:8000/dns-query', 'ipns.local', key)
   }
 }
 

src/core/ipns/routing/mdns-datastore.js renamed to src/core/ipns/routing/experimental/mdns-datastore.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const pany = require('p-any')
+const pSettle = require('p-settle')
+const debug = require('debug')
+const Errors = require('interface-datastore').Errors
+
+const log = debug('ipfs:ipns:tiered-datastore')
+log.error = debug('ipfs:ipns:tiered-datastore:error')
+
+class TieredDatastore {
+  constructor (stores) {
+    this.stores = stores.slice()
+  }
+
+  put (key, value, callback) {
+    pSettle(this.stores.map(s => s.put(key, value)))
+      .then(results => {
+        let fulfilled = false
+        results.forEach(r => {
+          if (r.isFulfilled) {
+            fulfilled = true
+          } else {
+            log.error(r.reason)
+          }
+        })
+
+        if (fulfilled) {
+          return setImmediate(() => callback())
+        }
+        setImmediate(() => callback(Errors.dbWriteFailedError()))
+      })
+  }
+
+  get (key, callback) {
+    pany(this.stores.map(s => s.get(key)))
+      .then(r => setImmediate(() => callback(null, r)))
+      .catch(err => {
+        log.error(err)
+        setImmediate(() => callback(Errors.notFoundError()))
+      })
+  }
+}
+
+module.exports = TieredDatastore