working with 2.2.x need to check version and send null for value on ttl reset for 2.3+

Author: thebigredgeek

.npmignore

@@ -1,3 +1,7 @@
 src
 test
 coverage
+npm-debug.log
+.DS_Store
+.gitignore
+circle.yml

Makefile

@@ -6,13 +6,14 @@ SHELL := /bin/bash
 all: .FORCE
 	babel src -d lib
 
-test: .FORCE
+unit: .FORCE
 	mocha test/unit
 
 integration: .FORCE
-	docker-compose up -d
+	PREFIX=$(etcd_command_prefix) VERSION=$(etcd_image_version) docker-compose up -d
 	mocha test/integration
-	docker-compose down
+	PREFIX=$(etcd_command_prefix) VERSION=$(etcd_image_version) docker-compose stop || echo 'failed to bring down containers'
+	PREFIX=$(etcd_command_prefix) VERSION=$(etcd_image_version) docker-compose rm -f || echo 'failed to remove containers'
 
 lint: .FORCE
 	eslint src

README.md

@@ -1,2 +1,167 @@
-# microlock
-Simple distributed locking with Etcd for Node.js
+# Microlock
+A dead simple distributed locking library for Node.js and [etcd](http://github.com/coreos/etcd) (via [node-etcd](https://github.com/stianeikeland/node-etcd))
+
+[![NPM](https://nodei.co/npm/microlock.png)](https://nodei.co/npm/microlock/)
+
+[![CircleCI](https://circleci.com/gh/thebigredgeek/microlock/tree/master.svg?style=shield)](https://circleci.com/gh/thebigredgeek/microlock/tree/master)
+
+
+## What is a distrbuted lock?
+
+A distributed lock is a mechanism that provides serialized flow control on a context that is acted on by more than one process.  These processes typically operate on different machines via Service Oriented Architecture.  Each process uses an object called a distributed lock to "lock" access to the shared context so that only one process can act on it at a time, thereby ensuring consistency and preventing race conditions.
+
+## Notes
+
+Microlock is currently compatible with Etd 2.2.x.  Within the next two weeks, there will be full support and test coverage for Etcd 2.2.x - 3.x.
+
+## Install
+**Requires NodeJS >= 4.0**
+
+```bash
+$ npm install microlock
+```
+
+## Basic usage
+
+### ES5
+```javascript
+var os = require('os');
+var Etcd = require('node-etcd');
+var Microlock = require('microlock');
+
+var key = 'foo'; //name of the lock
+var id = os.hostname(); //id of *this* node
+var ttl = 5; //5 second lease on lock
+
+var etcd = new Etcd();
+var foo = new Microlock.default(etcd, key, id, ttl);
+
+foo.lock().then(function () {
+  // foo is locked by this node
+
+  // do some stuff...
+
+  // release the lock
+  return foo.unlock();
+}, function (e) {
+  if (e instanceof Microlock.AlreadyLockedError) {
+    // foo is already locked by a different node
+  }
+});
+```
+
+### ES2015 (with babel)
+```javascript
+import { hostname } from 'os';
+import Etcd from 'node-etcd';
+import Microlock, { AlreadyLockedError } from 'microlock';
+
+const key = 'foo'; //name of the lock
+const id = hostname(); //id of *this* node
+const ttl = 5; //5 second lease on lock
+
+const etcd = new Etcd();
+const foo = new Microlock(etcd, key, id, ttl);
+
+foo.lock().then(() => {
+  // foo is locked by this node
+
+  // do some stuff...
+
+  // release the lock
+  return foo.unlock();
+}, (e) => {
+  if (e instanceof AlreadyLockedError) {
+    // foo is already locked by a different node
+  }
+});
+```
+
+### ES2016/2017 (with babel)
+```javascript
+
+import { hostname } from 'os';
+import Etcd from 'node-etcd';
+import Microlock, { AlreadyLockedError } from 'microlock';
+
+async function main () {
+
+  const key = 'foo'; //name of the lock
+  const id = hostname(); //id of *this* node
+  const ttl = 5; //5 second lease on lock
+
+  const etcd = new Etcd();
+  const foo = new Microlock(etcd, key, id, ttl);
+
+  try {
+    await foo.lock();
+    // foo is locked by this node
+
+    // do some stuff...
+
+    // release the lock
+    await foo.unlock();
+  } catch (e) {
+    if (e instanceof AlreadyLockedError) {
+      // foo is already locked by a different node
+    }
+  }
+}
+
+main();
+```
+
+## Methods
+
+### Microlock(etcd, key, node_id, [ttl = 1])
+Creates a microlock client for a lock key.
+
+```javascript
+var Etcd = require('node-etcd');
+var Microlock = require('microlock');
+
+var etcd = new Etcd();
+var foo = new Microlock.default(microlock, 'foo', 'bar');
+```
+
+### .lock()
+Attempts to lock the `key` for the `node_id`.
+
+```javascript
+foo.lock().then(function () {
+  // foo is locked by this node
+}, function (e) {
+  if (e instanceof Microlock.AlreadyLockedError) {
+    // foo is already locked by a different node
+  }
+});
+```
+
+### .unlock()
+Attempts to release the `key` for the `node_id`.
+
+```javascript
+foo.unlock().then(function () {
+  // foo is unlocked
+}, function (e) {
+  if (e instanceof Microlock.LockNotOwnedError) {
+    // foo is not locked by `node_id`
+  }
+})
+```
+
+### .renew()
+Attempts to renew the lock on `key` for the `node_id`.
+
+```javascript
+foo.renew().then(function () {
+  // foo lease is renewed... ttl is refreshed
+}, function (e) {
+  if (e instanceof Microlock.LockNotOwnedError) {
+    // foo is not locked by `node_id`
+  }
+})
+```
+
+### .destroy()
+Unbinds listeners/watchers from this client

circle.yml

@@ -6,11 +6,11 @@ machine:
 test:
   override:
     - make lint
-    - make test
-    - make build
-    - make integration
-deployment:
-  npm:
-    branch: master
-    commands:
-      - make publish
+    - make unit
+    - make
+    - make integration etcd_image_version=v2.2.0
+    - make integration etcd_image_version=v2.2.1
+    - make integration etcd_image_version=v2.2.2
+    - make integration etcd_image_version=v2.2.3
+    - make integration etcd_image_version=v2.2.4
+    - make integration etcd_image_version=v2.2.5

docker-compose.yml

@@ -1,5 +1,5 @@
 etcd:
-  image: quay.io/coreos/etcd
+  image: quay.io/coreos/etcd:$VERSION
   ports:
     - "2379:2379"
-  command: -advertise-client-urls=http://0.0.0.0:2379 -listen-client-urls=http://0.0.0.0:2379
+  command: $PREFIX-advertise-client-urls=http://0.0.0.0:2379 -listen-client-urls=http://0.0.0.0:2379

package.json

@@ -34,6 +34,7 @@
     "eslint": "^2.8.0",
     "eslint-plugin-babel": "^3.2.0",
     "mocha": "^2.4.5",
+    "node-etcd": "^5.0.3",
     "sinon": "^1.17.3",
     "source-map-support": "^0.4.2"
   }

src/microlock.js

@@ -149,7 +149,6 @@ export default class Microlock extends EventEmitter {
   renew () {
     return new Promise((resolve, reject) => {
       return this.__etcd.set(this.__key, this.__node_id, {
-        prevExist: true,
         prevValue: this.__node_id,
         refresh: true,
         ttl: this.__ttl

test/integration/microlock_spec.js

@@ -0,0 +1,132 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import Promise from 'bluebird';
+import Etcd from 'node-etcd';
+
+import Microlock, {
+  events,
+
+  EtcdClientRequiredError,
+  KeyRequiredError,
+  NodeIdRequiredError,
+  InvalidTtlError,
+  AlreadyLockedError,
+  LockNotOwnedError
+} from '../../lib/microlock';
+
+describe('microlock', () => {
+  let etcd = null
+    , key = null
+    , node1 = null
+    , node2 = null
+    , lock1 = null
+    , lock2 = null
+    , ttl = null;
+
+  beforeEach(() => {
+    etcd = new Etcd();
+
+    key = 'key';
+
+    node1 = 'node_1';
+    node2 = 'node_2';
+
+    ttl = 5;
+
+    lock1 = new Microlock(etcd, key, node1, ttl);
+    lock2 = new Microlock(etcd, key, node2, ttl);
+  });
+
+  afterEach(() => Promise.all([
+    lock1.unlock(),
+    lock2.unlock()
+  ]).catch((e) => e));
+
+  describe('lock', () => {
+    context('is locked', () => {
+      beforeEach(() => lock2.lock());
+      it('rejects with AlreadyLockedError', (done) => {
+        lock1
+        .lock()
+        .then(() => done(new Error('should have rejected')), (e) => {
+          expect(e instanceof AlreadyLockedError).to.be.true;
+          done();
+        })
+        .catch(done);
+      });
+    });
+    context('is not locked', () => {
+      it('resolves', (done) => {
+        lock1
+        .lock()
+        .then(() => done(), () => done(new Error('should have resolved')));
+      });
+    });
+  });
+  describe('unlock', () => {
+    context('is locked by current node', () => {
+      beforeEach(() => lock1.lock());
+      it('resolves', (done) => {
+        lock1
+        .unlock()
+        .then(() => done(), () => done(new Error('should have resolved')));
+      });
+    });
+    context('is not locked by current node', () => {
+      beforeEach(() => lock2.lock());
+      it('rejects with LockNotOwnedError', (done) => {
+        lock1
+        .unlock()
+        .then(() => done(new Error('should have rejected')), (e) => {
+          expect(e instanceof LockNotOwnedError).to.be.true;
+          done();
+        })
+        .catch(done);
+      });
+    });
+    context('is not locked', () => {
+      it('rejects with LockNotOwnedError', (done) => {
+        lock1
+        .unlock()
+        .then(() => done(new Error('should have rejected')), (e) => {
+          expect(e instanceof LockNotOwnedError).to.be.true;
+          done();
+        })
+        .catch(done);
+      });
+    });
+  });
+  describe('renew', () => {
+    context('is locked by current node', () => {
+      beforeEach(() => lock1.lock());
+      it('resolves', (done) => {
+        lock1
+        .renew()
+        .then(() => done(), () => done(new Error('should have resolved')));
+      });
+    });
+    context('is not locked by current node', () => {
+      beforeEach(() => lock2.lock());
+      it('rejects with LockNotOwnedError', (done) => {
+        lock1
+        .renew()
+        .then(() => done(new Error('should have rejected')), (e) => {
+          expect(e instanceof LockNotOwnedError).to.be.true;
+          done();
+        })
+        .catch(done);
+      });
+    });
+    context('is not locked', () => {
+      it('rejects with LockNotOwnedError', (done) => {
+        lock1
+        .renew()
+        .then(() => done(new Error('should have rejected')), (e) => {
+          expect(e instanceof LockNotOwnedError).to.be.true;
+          done();
+        })
+        .catch(done);
+      });
+    });
+  });
+});

test/setup.js

@@ -1,4 +1,4 @@
-require('source-map-support').install();
+//require('source-map-support').install();
 require('babel-register');
 require('babel-polyfill');
 
@@ -7,5 +7,5 @@ function kill (e) {
   process.exit(1);
 }
 
-process.on('uncaughtException', kill);
-process.on('unhandledRejection', kill);
+//process.on('uncaughtException', kill);
+//process.on('unhandledRejection', kill);

test/unit/microlock_spec.js

@@ -206,7 +206,6 @@ describe('microlock', () => {
           microlock.renew();
           expect(etcd.set.calledWith(key, node_id, {
             ttl,
-            prevExist: true,
             prevValue: node_id,
             refresh: true
           })).to.be.true;