feat(lock): allow for custom lock and no lock options

fix: failing tests

Author: jacobheun

src/default-options-browser.js

@@ -25,5 +25,6 @@ module.exports = {
     datastore: {
       db: require('level-js')
     }
-  }
+  },
+  locker: null
 }

src/default-options.js

@@ -19,5 +19,6 @@ module.exports = {
     },
     keys: {
     }
-  }
+  },
+  locker: null
 }

src/index.js

@@ -44,8 +44,7 @@ class IpfsRepo {
     this.closed = true
     this.path = repoPath
 
-    this._locker = lockers[this.options.lock]
-    assert(this._locker, 'Unknown lock type: ' + this.options.lock)
+    this._locker = this._getLocker()
 
     this.root = backends.create('root', this.path, this.options)
     this.version = version(this.root)
@@ -88,7 +87,7 @@ class IpfsRepo {
     waterfall([
       (cb) => this.root.open(ignoringAlreadyOpened(cb)),
       (cb) => this._isInitialized(cb),
-      (cb) => this._locker.lock(this.path, cb),
+      (cb) => this._openLock(this.path, cb),
       (lck, cb) => {
         log('aquired repo.lock')
         this.lockfile = lck
@@ -121,7 +120,7 @@ class IpfsRepo {
       }
     ], (err) => {
       if (err && this.lockfile) {
-        this.lockfile.close((err2) => {
+        this._closeLock((err2) => {
           if (!err2) {
             this.lockfile = null
           } else {
@@ -135,6 +134,65 @@ class IpfsRepo {
     })
   }
 
+  /**
+   * Returns the repo locker to be used. Null will be returned if no locker is requested
+   *
+   * @private
+   * @returns {Locker}
+   */
+  _getLocker () {
+    if (this.options.locker === false) {
+      return null
+    } else if (this.options.locker) {
+      return this.options.locker
+    }
+
+    assert(lockers[this.options.lock], 'Unknown lock type: ' + this.options.lock)
+    return lockers[this.options.lock]
+  }
+
+  /**
+   * Creates a lock on the repo if a locker is specified. The lockfile object will
+   * be returned in the callback if one has been created.
+   *
+   * @param {string} path
+   * @param {function(Error, lockfile)} callback
+   * @returns {void}
+   */
+  _openLock (path, callback) {
+    if (this._locker) {
+      return this._locker.lock(path, callback)
+    }
+    callback(null, null)
+  }
+
+  /**
+   * Closes the lock on the repo
+   *
+   * @param {function(Error)} callback
+   * @returns {void}
+   */
+  _closeLock (callback) {
+    if (this.lockfile) {
+      return this.lockfile.close(callback)
+    }
+    callback()
+  }
+
+  /**
+   * Gets the status of the lock on the repo
+   *
+   * @param {string} path
+   * @param {function(Error, boolean)} callback
+   * @returns {void}
+   */
+  _isLocked (path, callback) {
+    if (this._locker) {
+      return this._locker.locked(path, callback)
+    }
+    callback(null, false)
+  }
+
   /**
    * Check if the repo is already initialized.
    *
@@ -186,7 +244,7 @@ class IpfsRepo {
       (cb) => {
         log('unlocking')
         this.closed = true
-        this.lockfile.close(cb)
+        this._closeLock(cb)
       },
       (cb) => {
         this.lockfile = null

test/node.js

@@ -13,6 +13,22 @@ const IPFSRepo = require('../src')
 describe('IPFS Repo Tests onNode.js', () => {
   require('./options-test')
 
+  const customLocker = {
+    isLocked: false,
+    lock: (path, callback) => {
+      this.isLocked = true
+      callback(null, {
+        close: (cb) => {
+          this.locked = false
+          cb(null)
+        }
+      })
+    },
+    locked: (callback) => {
+      callback(null, this.isLocked)
+    }
+  }
+
   const repos = [{
     name: 'default inited',
     opts: undefined,
@@ -25,6 +41,16 @@ describe('IPFS Repo Tests onNode.js', () => {
       lock: 'memory'
     },
     init: true
+  }, {
+    name: 'custom locker',
+    opts: {
+      locker: customLocker
+    }
+  }, {
+    name: 'no locker',
+    opts: {
+      locker: false
+    }
   }, {
     name: 'default existing',
     opts: undefined,

test/options-test.js

@@ -28,6 +28,26 @@ describe('custom options tests', () => {
     const repo = new Repo(repoPath)
     expect(repo.options).to.deep.equal(expectedRepoOptions())
   })
+
+  it('allows for no locker', () => {
+    const repo = new Repo(repoPath, {
+      locker: false
+    })
+    expect(repo._locker).to.equal(null)
+  })
+
+  it('allows for a custom locker', () => {
+    const locker = {
+      lock: (path, callback) => { },
+      locked: (path, callback) => { }
+    }
+
+    const repo = new Repo(repoPath, {
+      locker
+    })
+
+    expect(repo._getLocker()).to.deep.equal(locker)
+  })
 })
 
 function noop () {}
@@ -52,7 +72,8 @@ function expectedRepoOptions () {
         sharding: true,
         extension: '.data'
       }
-    }
+    },
+    locker: null
   }
 
   if (process.browser) {