ready for beta

pasupulaphani · pasupulaphani · commit 54b41a1e7462 · 2016-11-11T19:44:51.000Z
diff --git a/.eslintignore b/.eslintignore
@@ -0,0 +1 @@
+**/*{.,-}min.js
diff --git a/.eslintrc b/.eslintrc
@@ -1,11 +1,12 @@
 {
   "extends": "eslint:recommended",
   "env": {
-    // I write for browser
     "browser": false,
-    // in CommonJS
     "node": true
   },
+  "parserOptions": {
+    "ecmaVersion": 6
+  },
   "globals": {
     "describe": false,
     "before": false,
diff --git a/.gitignore b/.gitignore
@@ -35,3 +35,5 @@ jspm_packages
 
 # Optional REPL history
 .node_repl_history
+
+coverage
diff --git a/.travis.yml b/.travis.yml
@@ -1,5 +1,17 @@
 language: node_js
 node_js:
-  - "6"
+  - '4'
+  - '5'
+  - '6'
+  - 'node'
+before_install:
+  - sudo apt-key adv --keyserver pgp.mit.edu --recv D101F7899D41F3C3
+  - echo "deb http://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
+  - sudo apt-get update -qq
+  - sudo apt-get install -y -qq yarn
+install: yarn
 services:
   - redis-server
+after_success:
+  - npm run lint
+  - npm run coveralls
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -0,0 +1 @@
+# Change Log
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -0,0 +1,7 @@
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
diff --git a/README.md b/README.md
@@ -1,9 +1,17 @@
-[![Build Status](https://travis-ci.org/pasupulaphani/angular-gist-embed.svg?branch=master)](https://travis-ci.org/pasupulaphani/simple-redis-cache) [![npm version](https://badge.fury.io/js/simple-redis-cache.svg)](https://badge.fury.io/js/simple-redis-cache) [![Test Coverage](https://codeclimate.com/github/pasupulaphani/simple-redis-cache/badges/coverage.svg)](https://codeclimate.com/github/pasupulaphani/simple-redis-cache/coverage) [![Code Climate](https://codeclimate.com/github/pasupulaphani/simple-redis-cache/badges/gpa.svg)](https://codeclimate.com/github/pasupulaphani/simple-redis-cache)
+[![npm version](http://img.shields.io/npm/v/simple-redis-cache.svg)](https://npmjs.org/package/simple-redis-cache)
+[![Build Status](https://travis-ci.org/pasupulaphani/simple-redis-cache.svg?branch=master)](https://travis-ci.org/pasupulaphani/simple-redis-cache)
+[![Coverage Status](https://coveralls.io/repos/github/pasupulaphani/simple-redis-cache/badge.svg?branch=master)](https://coveralls.io/github/pasupulaphani/simple-redis-cache?branch=master)
+[![dependencies Status](https://david-dm.org/pasupulaphani/simple-redis-cache/status.svg)](https://david-dm.org/pasupulaphani/simple-redis-cache)
+[![Gratipay donate button](https://img.shields.io/badge/gratipay-donate-yellow.svg)](https://gratipay.com/simple-redis-cache/)
 
 # simple-redis-cache
 Redis cache ready to scale with node-pool support
 
-> Note: This lib is still in alpha
+> Note: This lib is in beta
+
+## Prerequisites
+
+This module requires nodejs v4 or above as it has dependencies on constious es6 components such as Map, Set, Promise etc.
 
 ### Getting started
 
@@ -14,3 +22,7 @@ Redis cache ready to scale with node-pool support
 
     // set
     cache.set("key", "value");
+
+### Run tests
+
+    bash test.sh
diff --git a/lib/logger.js b/lib/logger.js
@@ -0,0 +1 @@
+module.exports = console;
diff --git a/lib/redis.js b/lib/redis.js
@@ -0,0 +1,7 @@
+const redis = require("redis");
+const Bluebird = require("bluebird");
+
+Bluebird.promisifyAll(redis.RedisClient.prototype);
+Bluebird.promisifyAll(redis.Multi.prototype);
+
+module.exports = redis;
diff --git a/lib/redis_cache.js b/lib/redis_cache.js
@@ -1,18 +1,19 @@
-var Bluebird = require("bluebird");
-var RedisStore = require("simple-redis-store");
-var Debug = require("debug");
+var RedisStore = require("./redis_store");
+var logger = require("./logger");
 
-var debug = new Debug("simpleRedisCache");
+const debug = require("debug")("simpleRedisCache");
+
+function RedisCache (name, logger, redisOptions, poolOptions) {
+  let store;
 
-module.exports = function (name, logger, redisOptions, poolOptions) {
   try {
 
-    var store = new RedisStore(name, redisOptions, poolOptions);
+    store = new RedisStore(name, redisOptions, poolOptions);
 
     // setTimeout(function storeStats (store) {
     //   // periodically report statistics
     //
-    //   var status = store.status();
+    //   const status = store.status();
     //   logger.info("REDIS CACHE STORE STATS: ", status);
     //
     //   if (status.waitingClients > 0) {
@@ -38,7 +39,7 @@ module.exports = function (name, logger, redisOptions, poolOptions) {
         .then(function (value) {
           if (!value) {
             debug("MISS", {key: key});
-            return Bluebird.resolve(promise)
+            return Promise.resolve(promise)
               .then(function (value) {
                 value = JSON.stringify(value);
                 store.setex(key, value, ttlInSeconds);
@@ -75,4 +76,6 @@ module.exports = function (name, logger, redisOptions, poolOptions) {
       return store.deleteAll();
     }
   };
-};
+}
+
+module.exports = RedisCache;
diff --git a/lib/redis_pool.js b/lib/redis_pool.js
@@ -0,0 +1,129 @@
+"use strict";
+
+const genericPool = require("generic-pool");
+const redis = require("./redis");
+const logger = require("./logger");
+
+const debug = require("debug")("simpleRedisPool");
+
+function RedisPool (name, redisOptions, poolOptions) {
+
+  this.name = name;
+  this._redisDb = redisOptions.db || 0;
+  let _pool = null;
+
+  const factory = {
+    create: () => {
+      return new Promise((resolve, reject) => {
+
+        const client = redis.createClient(redisOptions);
+
+        if (["undefined", null, ""].indexOf(this._redisDb) !== -1) {
+          logger.info("Selected Redis DB: ", this._redisDb);
+          debug("Selected Redis DB: ", this._redisDb);
+          client.select(this._redisDb);
+        }
+
+        // Handle client connection errors.
+        client.on("error", err => {
+          logger.error("Redis pool: ", name, err);
+          reject(err);
+        });
+
+        // Register the authentication password if needed.
+        if (redisOptions.auth_pass) {
+          client.auth(redisOptions.auth_pass);
+        }
+
+        resolve(client);
+      });
+    },
+    destroy: (client) => {
+      return new Promise((resolve) => {
+
+        try {
+          // Flush when closing.
+          client.end(true);
+          logger.info("Checking pool info after client destroyed. Available count : %s. Pool size: %s", _pool.availableObjectsCount(), _pool.getPoolSize());
+          resolve();
+        } catch (err) {
+          throw new Error("error", "Error destroying redis client.");
+        }
+      });
+    }
+  };
+
+  // Now that the pool settings are ready create a pool instance.
+  _pool = genericPool.createPool(factory, poolOptions);
+
+  // Acquire a database connection and use an optional priority.
+  this.acquire = (priority) => {
+    return _pool.acquire(priority);
+  };
+
+  this.acquireDb = (db, priority) => {
+    return _pool.acquire(priority)
+      .then(client => {
+        if (client._db_selected !== db) {
+          client["_db_selected"] = db;
+          client.select(db);
+        }
+        debug("DB selected: ", client._db_selected);
+      });
+  };
+
+  // Release a database connection to the pool.
+  this.release = (client) => {
+    // Always reset the DB to the default. This prevents issues
+    // if a user used the select command to change the DB.
+
+    if (client._db_selected !== this._redisDb) {
+      debug("Releasing client. Reset the DB to the given: ", this._redisDb);
+      client.select(this._redisDb);
+    }
+    _pool.release(client);
+  };
+
+  // Drains the connection pool and call the callback id provided.
+  this.drain = (cb) => {
+    _pool.drain(() => {
+      _pool.destroyAllNow();
+      if (cb) {
+        cb();
+      }
+    });
+  };
+
+  // Returns factory.name for this pool
+  this.getName = () => {
+    return this.name;
+  };
+
+  this.getDB = () => {
+    return this._redisDb;
+  };
+
+  this.getPoolSize = () => {
+    return _pool.size;
+  };
+
+  this.availableObjectsCount = () => {
+    return _pool.available;
+  };
+
+  this.waitingClientsCount = () => {
+    return _pool.pending;
+  };
+
+  this.status = () => {
+    return {
+      name: this.name,
+      size: _pool.size,
+      db: this._redisDb,
+      avail: _pool.available,
+      waiting: _pool.pending
+    };
+  };
+}
+
+module.exports = RedisPool;
diff --git a/lib/redis_store.js b/lib/redis_store.js
@@ -0,0 +1,79 @@
+const RedisPool = require("./redis_pool");
+const bind = require("./util/bind");
+const logger = require("./logger");
+
+const debug = require("debug")("simpleRedisStore");
+
+function wrapFunc (pool, func) {
+  return pool.acquire()
+    .then((conn) => func(conn)
+        .then((result) => {
+          pool.release(conn);
+          return result;
+        })
+        .catch(err => {
+          pool.release(conn);
+          throw err;
+        }));
+}
+
+function RedisStore (name, redisOptions, poolOptions) {
+
+  if (!poolOptions) {
+    poolOptions = {};
+  }
+  poolOptions = Object.assign({
+    acquireTimeoutMillis: 50
+  }, poolOptions);
+
+  const pool = new RedisPool(name, redisOptions, poolOptions);
+  logger.info("Redis store created.", pool.status());
+
+  this.getName = bind(pool.getName, pool);
+  this.getRedisDB = bind(pool.getDB, pool);
+  this.getPoolStatus = bind(pool.status, pool);
+
+  this.get = (key) => wrapFunc(pool, (conn) => conn.getAsync(key));
+
+  this.set = (key, value) => wrapFunc(pool, (conn) => conn.setAsync(key, value));
+
+  this.setex = (key, value, ttlInSeconds) => wrapFunc(pool, (conn) => conn.setexAsync(key, ttlInSeconds, value));
+
+  this.del = (key) => wrapFunc(pool, (conn) => conn.delAsync(key));
+
+  this.expire = (key, ttlInSeconds) => wrapFunc(pool, (conn) => conn.expireAsync(key, ttlInSeconds));
+
+  this.ttlInSeconds = (key) => wrapFunc(pool, (conn) => conn.ttlAsync(key));
+
+  this.keys = (pattern) => {
+    if (!pattern || pattern === "") {
+      pattern = "*";
+    }
+
+    return wrapFunc(pool, (conn) => conn.keysAsync(pattern));
+  };
+
+  this.deleteAll = (pattern) => {
+    if (!pattern || pattern === "") {
+      pattern = "*";
+    }
+    logger.info("clearing redis keys: ", pattern);
+
+    return pool.acquire()
+      .then((conn) => {
+        return conn.keysAsync(pattern)
+          .then((keys) => {
+            if (keys.length > 0) {
+              debug("deleting keys ", keys);
+              return conn.delAsync(keys)
+                .then((result) => {
+                  pool.release(conn);
+                  return result;
+                });
+            }
+          });
+      });
+  };
+}
+
+module.exports = RedisStore;
diff --git a/lib/util/bind.js b/lib/util/bind.js
@@ -0,0 +1,20 @@
+/**
+* Binds a function to a specific object.
+*
+* @example
+*
+*      const obj = {a: 1, b: function() { console.log(a); }};
+*      const bound = utils.bind(obj, obj.b);
+*      bound(); // prints 1
+*
+* @param {Function} fn The function to bind.
+* @param {Object} cnxt The object to bind to.
+* @returns {Function} The bound function.
+*
+* @function bind
+*/
+module.exports = function (fn, cnxt) {
+  return function () {
+    return fn.apply(cnxt, arguments);
+  };
+};
diff --git a/package.json b/package.json
diff --git a/test.sh b/test.sh
diff --git a/test/Dockerfile.test b/test/Dockerfile.test
diff --git a/test/docker-compose.test.yml b/test/docker-compose.test.yml
diff --git a/yarn.lock b/yarn.lock
