modified configuration file for web

Signed-off-by: ajeetraina <ajeetraina@gmail.com>
2022-03-13 13:09:07 +05:30
parent 62bef58719
commit 7770fe6e3f
369 changed files with 64621 additions and 1 deletions
--- a/nginx-nodejs-redis/web/node_modules/redis-parser/.npmignore
+++ b/nginx-nodejs-redis/web/node_modules/redis-parser/.npmignore
@@ -0,0 +1,15 @@
+# IntelliJ project files
+.idea
+*.iml
+out
+gen
+
+# Unrelevant files and folders
+benchmark
+coverage
+test
+.travis.yml
+.gitignore
+*.log
+.vscode
+.codeclimate.yml
--- a/nginx-nodejs-redis/web/node_modules/redis-parser/LICENSE
+++ b/nginx-nodejs-redis/web/node_modules/redis-parser/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 NodeRedis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
--- a/nginx-nodejs-redis/web/node_modules/redis-parser/README.md
+++ b/nginx-nodejs-redis/web/node_modules/redis-parser/README.md
@@ -0,0 +1,166 @@
+[![Build Status](https://travis-ci.org/NodeRedis/node-redis-parser.png?branch=master)](https://travis-ci.org/NodeRedis/node-redis-parser)
+[![Test Coverage](https://codeclimate.com/github/NodeRedis/node-redis-parser/badges/coverage.svg)](https://codeclimate.com/github/NodeRedis/node-redis-parser/coverage)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
+
+# redis-parser
+
+A high performance javascript redis parser built for [node_redis](https://github.com/NodeRedis/node_redis) and [ioredis](https://github.com/luin/ioredis). Parses all [RESP](http://redis.io/topics/protocol) data.
+
+## Install
+
+Install with [NPM](https://npmjs.org/):
+
+    npm install redis-parser
+
+## Usage
+
+```js
+const Parser = require('redis-parser');
+
+const myParser = new Parser(options);
+```
+
+### Options
+
+* `returnReply`: *function*; mandatory
+* `returnError`: *function*; mandatory
+* `returnFatalError`: *function*; optional, defaults to the returnError function
+* `returnBuffers`: *boolean*; optional, defaults to false
+* `stringNumbers`: *boolean*; optional, defaults to false
+
+### Functions
+
+* `reset()`: reset the parser to it's initial state
+* `setReturnBuffers(boolean)`: set the returnBuffers option on/off without resetting the parser
+* `setStringNumbers(boolean)`: set the stringNumbers option on/off without resetting the parser
+
+### Error classes
+
+* `RedisError` sub class of Error
+* `ReplyError` sub class of RedisError
+* `ParserError` sub class of RedisError
+
+All Redis errors will be returned as `ReplyErrors` while a parser error is returned as `ParserError`.  
+All error classes can be imported by the npm `redis-errors` package.
+
+### Example
+
+```js
+const Parser = require("redis-parser");
+
+class Library {
+  returnReply(reply) { /* ... */ }
+  returnError(err) { /* ... */ }
+  returnFatalError(err) { /* ... */ }
+
+  streamHandler() {
+    this.stream.on('data', (buffer) => {
+      // Here the data (e.g. `Buffer.from('$5\r\nHello\r\n'`))
+      // is passed to the parser and the result is passed to
+      // either function depending on the provided data.
+      parser.execute(buffer);
+    });
+  }
+}
+
+const lib = new Library();
+
+const parser = new Parser({
+  returnReply(reply) {
+    lib.returnReply(reply);
+  },
+  returnError(err) {
+    lib.returnError(err);
+  },
+  returnFatalError(err) {
+    lib.returnFatalError(err);
+  }
+});
+```
+
+You do not have to use the returnFatalError function. Fatal errors will be returned in the normal error function in that case.
+
+And if you want to return buffers instead of strings, you can do this by adding the `returnBuffers` option.
+
+If you handle with big numbers that are to large for JS (Number.MAX_SAFE_INTEGER === 2^53 - 16) please use the `stringNumbers` option. That way all numbers are going to be returned as String and you can handle them safely.
+
+```js
+// Same functions as in the first example
+
+const parser = new Parser({
+  returnReply(reply) {
+    lib.returnReply(reply);
+  },
+  returnError(err) {
+    lib.returnError(err);
+  },
+  returnBuffers: true, // All strings are returned as Buffer e.g. <Buffer 48 65 6c 6c 6f>
+  stringNumbers: true // All numbers are returned as String
+});
+
+// The streamHandler as above
+```
+
+## Protocol errors
+
+To handle protocol errors (this is very unlikely to happen) gracefully you should add the returnFatalError option, reject any still running command (they might have been processed properly but the reply is just wrong), destroy the socket and reconnect. Note that while doing this no new command may be added, so all new commands have to be buffered in the meantime, otherwise a chunk might still contain partial data of a following command that was already processed properly but answered in the same chunk as the command that resulted in the protocol error.
+
+## Contribute
+
+The parser is highly optimized but there may still be further optimizations possible.
+
+    npm install
+    npm test
+    npm run benchmark
+
+Currently the benchmark compares the performance against the hiredis parser:
+
+    HIREDIS:   $ multiple chunks in a bulk string x 994,387 ops/sec ±0.22% (554 runs sampled)
+    JS PARSER: $ multiple chunks in a bulk string x 1,010,728 ops/sec ±0.28% (559 runs sampled)
+    HIREDIS BUF:   $ multiple chunks in a bulk string x 648,742 ops/sec ±0.80% (526 runs sampled)
+    JS PARSER BUF: $ multiple chunks in a bulk string x 1,728,849 ops/sec ±0.41% (555 runs sampled)
+
+    HIREDIS:   + multiple chunks in a string x 1,861,132 ops/sec ±0.18% (564 runs sampled)
+    JS PARSER: + multiple chunks in a string x 2,131,892 ops/sec ±0.31% (558 runs sampled)
+    HIREDIS BUF:   + multiple chunks in a string x 965,132 ops/sec ±0.58% (521 runs sampled)
+    JS PARSER BUF: + multiple chunks in a string x 2,304,482 ops/sec ±0.31% (559 runs sampled)
+
+    HIREDIS:   $ 4mb bulk string x 269 ops/sec ±0.56% (452 runs sampled)
+    JS PARSER: $ 4mb bulk string x 763 ops/sec ±0.25% (466 runs sampled)
+    HIREDIS BUF:   $ 4mb bulk string x 336 ops/sec ±0.59% (459 runs sampled)
+    JS PARSER BUF: $ 4mb bulk string x 994 ops/sec ±0.36% (482 runs sampled)
+
+    HIREDIS:   + simple string x 2,504,305 ops/sec ±0.19% (563 runs sampled)
+    JS PARSER: + simple string x 5,121,952 ops/sec ±0.30% (560 runs sampled)
+    HIREDIS BUF:   + simple string x 1,122,899 ops/sec ±0.52% (516 runs sampled)
+    JS PARSER BUF: + simple string x 5,907,323 ops/sec ±0.23% (562 runs sampled)
+
+    HIREDIS:   : integer x 2,461,376 ops/sec ±0.14% (561 runs sampled)
+    JS PARSER: : integer x 18,543,688 ops/sec ±0.19% (539 runs sampled)
+    JS PARSER STR: : integer x 14,149,305 ops/sec ±0.24% (561 runs sampled)
+
+    HIREDIS:   : big integer x 2,114,270 ops/sec ±0.15% (561 runs sampled)
+    JS PARSER: : big integer x 10,794,439 ops/sec ±0.25% (560 runs sampled)
+    JS PARSER STR: : big integer x 4,594,807 ops/sec ±0.24% (558 runs sampled)
+
+    HIREDIS:   * array x 45,597 ops/sec ±0.23% (565 runs sampled)
+    JS PARSER: * array x 68,396 ops/sec ±0.30% (563 runs sampled)
+    HIREDIS BUF:   * array x 14,726 ops/sec ±0.39% (498 runs sampled)
+    JS PARSER BUF: * array x 80,961 ops/sec ±0.25% (561 runs sampled)
+
+    HIREDIS:   * big nested array x 212 ops/sec ±0.17% (511 runs sampled)
+    JS PARSER: * big nested array x 243 ops/sec ±0.21% (496 runs sampled)
+    HIREDIS BUF:   * big nested array x 207 ops/sec ±0.37% (430 runs sampled)
+    JS PARSER BUF: * big nested array x 297 ops/sec ±1.10% (421 runs sampled)
+
+    HIREDIS:   - error x 168,761 ops/sec ±0.28% (559 runs sampled)
+    JS PARSER: - error x 424,257 ops/sec ±0.28% (557 runs sampled)
+
+    Platform info:
+    Ubuntu 17.04
+    Node.js 7.10.0
+    Intel(R) Core(TM) i7-5600U CPU
+
+## License
+
+[MIT](./LICENSE)
--- a/nginx-nodejs-redis/web/node_modules/redis-parser/changelog.md
+++ b/nginx-nodejs-redis/web/node_modules/redis-parser/changelog.md
@@ -0,0 +1,156 @@
+# Changelog
+
+## v.3.0.0 - 25 May, 2017
+
+Breaking Changes
+
+- Drop support for Node.js < 4
+- Removed support for hiredis completely
+
+Internals
+
+- Due to the changes to ES6 the error performance improved by factor 2-3x
+- Improved length calculation performance (bulk strings + arrays)
+
+Features
+
+- The parser now handles weird input graceful
+
+## v.2.6.0 - 03 Apr, 2017
+
+Internals
+
+- Use Buffer.allocUnsafe instead of new Buffer() with modern Node.js versions
+
+## v.2.5.0 - 11 Mar, 2017
+
+Features
+
+- Added a `ParserError` class to differentiate them to ReplyErrors. The class is also exported
+
+Bugfixes
+
+- All errors now show their error message again next to the error name in the stack trace
+- ParserErrors now show the offset and buffer attributes while being logged
+
+## v.2.4.1 - 05 Feb, 2017
+
+Bugfixes
+
+- Fixed minimal memory consumption overhead for chunked buffers
+
+## v.2.4.0 - 25 Jan, 2017
+
+Features
+
+- Added `reset` function to reset the parser to it's initial values
+- Added `setReturnBuffers` function to reset the returnBuffers option (Only for the JSParser)
+- Added `setStringNumbers` function to reset the stringNumbers option (Only for the JSParser)
+- All Errors are now of sub classes of the new `RedisError` class. It is also exported.
+- Improved bulk string chunked data handling performance
+
+Bugfixes
+
+- Parsing time for big nested arrays is now linear
+
+## v.2.3.0 - 25 Nov, 2016
+
+Features
+
+- Parsing time for big arrays (e.g. 4mb+) is now linear and works well for arbitrary array sizes
+
+This case is a magnitude faster than before
+
+    OLD STR: * big array x 1.09 ops/sec ±2.15% (7 runs sampled)
+    OLD BUF: * big array x 1.23 ops/sec ±2.67% (8 runs sampled)
+
+    NEW STR: * big array x 273 ops/sec ±2.09% (85 runs sampled)
+    NEW BUF: * big array x 259 ops/sec ±1.32% (85 runs sampled)
+    (~10mb array with 1000 entries)
+
+## v.2.2.0 - 18 Nov, 2016
+
+Features
+
+- Improve `stringNumbers` parsing performance by up to 100%
+
+Bugfixes
+
+- Do not unref the interval anymore due to issues with NodeJS
+
+## v.2.1.1 - 31 Oct, 2016
+
+Bugfixes
+
+- Remove erroneously added const to support Node.js 0.10
+
+## v.2.1.0 - 30 Oct, 2016
+
+Features
+
+- Improve parser errors by adding more detailed information to them
+- Accept manipulated Object.prototypes
+- Unref the interval if used
+
+## v.2.0.4 - 21 Jul, 2016
+
+Bugfixes
+
+- Fixed multi byte characters getting corrupted
+
+## v.2.0.3 - 17 Jun, 2016
+
+Bugfixes
+
+- Fixed parser not working with huge buffers (e.g. 300 MB)
+
+## v.2.0.2 - 08 Jun, 2016
+
+Bugfixes
+
+- Fixed parser with returnBuffers option returning corrupted data
+
+## v.2.0.1 - 04 Jun, 2016
+
+Bugfixes
+
+- Fixed multiple parsers working concurrently resulting in faulty data in some cases
+
+## v.2.0.0 - 29 May, 2016
+
+The javascript parser got completely rewritten by [Michael Diarmid](https://github.com/Salakar) and [Ruben Bridgewater](https://github.com/BridgeAR) and is now a lot faster than the hiredis parser.
+Therefore the hiredis parser was deprecated and should only be used for testing purposes and benchmarking comparison.
+
+All Errors returned by the parser are from now on of class ReplyError
+
+Features
+
+- Improved performance by up to 15x as fast as before
+- Improved options validation
+- Added ReplyError Class
+- Added parser benchmark
+- Switched default parser from hiredis to JS, no matter if hiredis is installed or not
+
+Removed
+
+- Deprecated hiredis support
+
+## v.1.3.0 - 27 Mar, 2016
+
+Features
+
+- Added `auto` as parser name option to check what parser is available
+- Non existing requested parsers falls back into auto mode instead of always choosing the JS parser
+
+## v.1.2.0 - 27 Mar, 2016
+
+Features
+
+- Added `stringNumbers` option to make sure all numbers are returned as string instead of a js number for precision
+- The parser is from now on going to print warnings if a parser is explicitly requested that does not exist and gracefully chooses the JS parser
+
+## v.1.1.0 - 26 Jan, 2016
+
+Features
+
+- The parser is from now on going to reset itself on protocol errors
--- a/nginx-nodejs-redis/web/node_modules/redis-parser/index.js
+++ b/nginx-nodejs-redis/web/node_modules/redis-parser/index.js
@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./lib/parser')
--- a/nginx-nodejs-redis/web/node_modules/redis-parser/lib/parser.js
+++ b/nginx-nodejs-redis/web/node_modules/redis-parser/lib/parser.js
@@ -0,0 +1,552 @@
+'use strict'
+
+const Buffer = require('buffer').Buffer
+const StringDecoder = require('string_decoder').StringDecoder
+const decoder = new StringDecoder()
+const errors = require('redis-errors')
+const ReplyError = errors.ReplyError
+const ParserError = errors.ParserError
+var bufferPool = Buffer.allocUnsafe(32 * 1024)
+var bufferOffset = 0
+var interval = null
+var counter = 0
+var notDecreased = 0
+
+/**
+ * Used for integer numbers only
+ * @param {JavascriptRedisParser} parser
+ * @returns {undefined|number}
+ */
+function parseSimpleNumbers (parser) {
+  const length = parser.buffer.length - 1
+  var offset = parser.offset
+  var number = 0
+  var sign = 1
+
+  if (parser.buffer[offset] === 45) {
+    sign = -1
+    offset++
+  }
+
+  while (offset < length) {
+    const c1 = parser.buffer[offset++]
+    if (c1 === 13) { // \r\n
+      parser.offset = offset + 1
+      return sign * number
+    }
+    number = (number * 10) + (c1 - 48)
+  }
+}
+
+/**
+ * Used for integer numbers in case of the returnNumbers option
+ *
+ * Reading the string as parts of n SMI is more efficient than
+ * using a string directly.
+ *
+ * @param {JavascriptRedisParser} parser
+ * @returns {undefined|string}
+ */
+function parseStringNumbers (parser) {
+  const length = parser.buffer.length - 1
+  var offset = parser.offset
+  var number = 0
+  var res = ''
+
+  if (parser.buffer[offset] === 45) {
+    res += '-'
+    offset++
+  }
+
+  while (offset < length) {
+    var c1 = parser.buffer[offset++]
+    if (c1 === 13) { // \r\n
+      parser.offset = offset + 1
+      if (number !== 0) {
+        res += number
+      }
+      return res
+    } else if (number > 429496728) {
+      res += (number * 10) + (c1 - 48)
+      number = 0
+    } else if (c1 === 48 && number === 0) {
+      res += 0
+    } else {
+      number = (number * 10) + (c1 - 48)
+    }
+  }
+}
+
+/**
+ * Parse a '+' redis simple string response but forward the offsets
+ * onto convertBufferRange to generate a string.
+ * @param {JavascriptRedisParser} parser
+ * @returns {undefined|string|Buffer}
+ */
+function parseSimpleString (parser) {
+  const start = parser.offset
+  const buffer = parser.buffer
+  const length = buffer.length - 1
+  var offset = start
+
+  while (offset < length) {
+    if (buffer[offset++] === 13) { // \r\n
+      parser.offset = offset + 1
+      if (parser.optionReturnBuffers === true) {
+        return parser.buffer.slice(start, offset - 1)
+      }
+      return parser.buffer.toString('utf8', start, offset - 1)
+    }
+  }
+}
+
+/**
+ * Returns the read length
+ * @param {JavascriptRedisParser} parser
+ * @returns {undefined|number}
+ */
+function parseLength (parser) {
+  const length = parser.buffer.length - 1
+  var offset = parser.offset
+  var number = 0
+
+  while (offset < length) {
+    const c1 = parser.buffer[offset++]
+    if (c1 === 13) {
+      parser.offset = offset + 1
+      return number
+    }
+    number = (number * 10) + (c1 - 48)
+  }
+}
+
+/**
+ * Parse a ':' redis integer response
+ *
+ * If stringNumbers is activated the parser always returns numbers as string
+ * This is important for big numbers (number > Math.pow(2, 53)) as js numbers
+ * are 64bit floating point numbers with reduced precision
+ *
+ * @param {JavascriptRedisParser} parser
+ * @returns {undefined|number|string}
+ */
+function parseInteger (parser) {
+  if (parser.optionStringNumbers === true) {
+    return parseStringNumbers(parser)
+  }
+  return parseSimpleNumbers(parser)
+}
+
+/**
+ * Parse a '$' redis bulk string response
+ * @param {JavascriptRedisParser} parser
+ * @returns {undefined|null|string}
+ */
+function parseBulkString (parser) {
+  const length = parseLength(parser)
+  if (length === undefined) {
+    return
+  }
+  if (length < 0) {
+    return null
+  }
+  const offset = parser.offset + length
+  if (offset + 2 > parser.buffer.length) {
+    parser.bigStrSize = offset + 2
+    parser.totalChunkSize = parser.buffer.length
+    parser.bufferCache.push(parser.buffer)
+    return
+  }
+  const start = parser.offset
+  parser.offset = offset + 2
+  if (parser.optionReturnBuffers === true) {
+    return parser.buffer.slice(start, offset)
+  }
+  return parser.buffer.toString('utf8', start, offset)
+}
+
+/**
+ * Parse a '-' redis error response
+ * @param {JavascriptRedisParser} parser
+ * @returns {ReplyError}
+ */
+function parseError (parser) {
+  var string = parseSimpleString(parser)
+  if (string !== undefined) {
+    if (parser.optionReturnBuffers === true) {
+      string = string.toString()
+    }
+    return new ReplyError(string)
+  }
+}
+
+/**
+ * Parsing error handler, resets parser buffer
+ * @param {JavascriptRedisParser} parser
+ * @param {number} type
+ * @returns {undefined}
+ */
+function handleError (parser, type) {
+  const err = new ParserError(
+    'Protocol error, got ' + JSON.stringify(String.fromCharCode(type)) + ' as reply type byte',
+    JSON.stringify(parser.buffer),
+    parser.offset
+  )
+  parser.buffer = null
+  parser.returnFatalError(err)
+}
+
+/**
+ * Parse a '*' redis array response
+ * @param {JavascriptRedisParser} parser
+ * @returns {undefined|null|any[]}
+ */
+function parseArray (parser) {
+  const length = parseLength(parser)
+  if (length === undefined) {
+    return
+  }
+  if (length < 0) {
+    return null
+  }
+  const responses = new Array(length)
+  return parseArrayElements(parser, responses, 0)
+}
+
+/**
+ * Push a partly parsed array to the stack
+ *
+ * @param {JavascriptRedisParser} parser
+ * @param {any[]} array
+ * @param {number} pos
+ * @returns {undefined}
+ */
+function pushArrayCache (parser, array, pos) {
+  parser.arrayCache.push(array)
+  parser.arrayPos.push(pos)
+}
+
+/**
+ * Parse chunked redis array response
+ * @param {JavascriptRedisParser} parser
+ * @returns {undefined|any[]}
+ */
+function parseArrayChunks (parser) {
+  const tmp = parser.arrayCache.pop()
+  var pos = parser.arrayPos.pop()
+  if (parser.arrayCache.length) {
+    const res = parseArrayChunks(parser)
+    if (res === undefined) {
+      pushArrayCache(parser, tmp, pos)
+      return
+    }
+    tmp[pos++] = res
+  }
+  return parseArrayElements(parser, tmp, pos)
+}
+
+/**
+ * Parse redis array response elements
+ * @param {JavascriptRedisParser} parser
+ * @param {Array} responses
+ * @param {number} i
+ * @returns {undefined|null|any[]}
+ */
+function parseArrayElements (parser, responses, i) {
+  const bufferLength = parser.buffer.length
+  while (i < responses.length) {
+    const offset = parser.offset
+    if (parser.offset >= bufferLength) {
+      pushArrayCache(parser, responses, i)
+      return
+    }
+    const response = parseType(parser, parser.buffer[parser.offset++])
+    if (response === undefined) {
+      if (!(parser.arrayCache.length || parser.bufferCache.length)) {
+        parser.offset = offset
+      }
+      pushArrayCache(parser, responses, i)
+      return
+    }
+    responses[i] = response
+    i++
+  }
+
+  return responses
+}
+
+/**
+ * Called the appropriate parser for the specified type.
+ *
+ * 36: $
+ * 43: +
+ * 42: *
+ * 58: :
+ * 45: -
+ *
+ * @param {JavascriptRedisParser} parser
+ * @param {number} type
+ * @returns {*}
+ */
+function parseType (parser, type) {
+  switch (type) {
+    case 36:
+      return parseBulkString(parser)
+    case 43:
+      return parseSimpleString(parser)
+    case 42:
+      return parseArray(parser)
+    case 58:
+      return parseInteger(parser)
+    case 45:
+      return parseError(parser)
+    default:
+      return handleError(parser, type)
+  }
+}
+
+/**
+ * Decrease the bufferPool size over time
+ *
+ * Balance between increasing and decreasing the bufferPool.
+ * Decrease the bufferPool by 10% by removing the first 10% of the current pool.
+ * @returns {undefined}
+ */
+function decreaseBufferPool () {
+  if (bufferPool.length > 50 * 1024) {
+    if (counter === 1 || notDecreased > counter * 2) {
+      const minSliceLen = Math.floor(bufferPool.length / 10)
+      const sliceLength = minSliceLen < bufferOffset
+        ? bufferOffset
+        : minSliceLen
+      bufferOffset = 0
+      bufferPool = bufferPool.slice(sliceLength, bufferPool.length)
+    } else {
+      notDecreased++
+      counter--
+    }
+  } else {
+    clearInterval(interval)
+    counter = 0
+    notDecreased = 0
+    interval = null
+  }
+}
+
+/**
+ * Check if the requested size fits in the current bufferPool.
+ * If it does not, reset and increase the bufferPool accordingly.
+ *
+ * @param {number} length
+ * @returns {undefined}
+ */
+function resizeBuffer (length) {
+  if (bufferPool.length < length + bufferOffset) {
+    const multiplier = length > 1024 * 1024 * 75 ? 2 : 3
+    if (bufferOffset > 1024 * 1024 * 111) {
+      bufferOffset = 1024 * 1024 * 50
+    }
+    bufferPool = Buffer.allocUnsafe(length * multiplier + bufferOffset)
+    bufferOffset = 0
+    counter++
+    if (interval === null) {
+      interval = setInterval(decreaseBufferPool, 50)
+    }
+  }
+}
+
+/**
+ * Concat a bulk string containing multiple chunks
+ *
+ * Notes:
+ * 1) The first chunk might contain the whole bulk string including the \r
+ * 2) We are only safe to fully add up elements that are neither the first nor any of the last two elements
+ *
+ * @param {JavascriptRedisParser} parser
+ * @returns {String}
+ */
+function concatBulkString (parser) {
+  const list = parser.bufferCache
+  const oldOffset = parser.offset
+  var chunks = list.length
+  var offset = parser.bigStrSize - parser.totalChunkSize
+  parser.offset = offset
+  if (offset <= 2) {
+    if (chunks === 2) {
+      return list[0].toString('utf8', oldOffset, list[0].length + offset - 2)
+    }
+    chunks--
+    offset = list[list.length - 2].length + offset
+  }
+  var res = decoder.write(list[0].slice(oldOffset))
+  for (var i = 1; i < chunks - 1; i++) {
+    res += decoder.write(list[i])
+  }
+  res += decoder.end(list[i].slice(0, offset - 2))
+  return res
+}
+
+/**
+ * Concat the collected chunks from parser.bufferCache.
+ *
+ * Increases the bufferPool size beforehand if necessary.
+ *
+ * @param {JavascriptRedisParser} parser
+ * @returns {Buffer}
+ */
+function concatBulkBuffer (parser) {
+  const list = parser.bufferCache
+  const oldOffset = parser.offset
+  const length = parser.bigStrSize - oldOffset - 2
+  var chunks = list.length
+  var offset = parser.bigStrSize - parser.totalChunkSize
+  parser.offset = offset
+  if (offset <= 2) {
+    if (chunks === 2) {
+      return list[0].slice(oldOffset, list[0].length + offset - 2)
+    }
+    chunks--
+    offset = list[list.length - 2].length + offset
+  }
+  resizeBuffer(length)
+  const start = bufferOffset
+  list[0].copy(bufferPool, start, oldOffset, list[0].length)
+  bufferOffset += list[0].length - oldOffset
+  for (var i = 1; i < chunks - 1; i++) {
+    list[i].copy(bufferPool, bufferOffset)
+    bufferOffset += list[i].length
+  }
+  list[i].copy(bufferPool, bufferOffset, 0, offset - 2)
+  bufferOffset += offset - 2
+  return bufferPool.slice(start, bufferOffset)
+}
+
+class JavascriptRedisParser {
+  /**
+   * Javascript Redis Parser constructor
+   * @param {{returnError: Function, returnReply: Function, returnFatalError?: Function, returnBuffers: boolean, stringNumbers: boolean }} options
+   * @constructor
+   */
+  constructor (options) {
+    if (!options) {
+      throw new TypeError('Options are mandatory.')
+    }
+    if (typeof options.returnError !== 'function' || typeof options.returnReply !== 'function') {
+      throw new TypeError('The returnReply and returnError options have to be functions.')
+    }
+    this.setReturnBuffers(!!options.returnBuffers)
+    this.setStringNumbers(!!options.stringNumbers)
+    this.returnError = options.returnError
+    this.returnFatalError = options.returnFatalError || options.returnError
+    this.returnReply = options.returnReply
+    this.reset()
+  }
+
+  /**
+   * Reset the parser values to the initial state
+   *
+   * @returns {undefined}
+   */
+  reset () {
+    this.offset = 0
+    this.buffer = null
+    this.bigStrSize = 0
+    this.totalChunkSize = 0
+    this.bufferCache = []
+    this.arrayCache = []
+    this.arrayPos = []
+  }
+
+  /**
+   * Set the returnBuffers option
+   *
+   * @param {boolean} returnBuffers
+   * @returns {undefined}
+   */
+  setReturnBuffers (returnBuffers) {
+    if (typeof returnBuffers !== 'boolean') {
+      throw new TypeError('The returnBuffers argument has to be a boolean')
+    }
+    this.optionReturnBuffers = returnBuffers
+  }
+
+  /**
+   * Set the stringNumbers option
+   *
+   * @param {boolean} stringNumbers
+   * @returns {undefined}
+   */
+  setStringNumbers (stringNumbers) {
+    if (typeof stringNumbers !== 'boolean') {
+      throw new TypeError('The stringNumbers argument has to be a boolean')
+    }
+    this.optionStringNumbers = stringNumbers
+  }
+
+  /**
+   * Parse the redis buffer
+   * @param {Buffer} buffer
+   * @returns {undefined}
+   */
+  execute (buffer) {
+    if (this.buffer === null) {
+      this.buffer = buffer
+      this.offset = 0
+    } else if (this.bigStrSize === 0) {
+      const oldLength = this.buffer.length
+      const remainingLength = oldLength - this.offset
+      const newBuffer = Buffer.allocUnsafe(remainingLength + buffer.length)
+      this.buffer.copy(newBuffer, 0, this.offset, oldLength)
+      buffer.copy(newBuffer, remainingLength, 0, buffer.length)
+      this.buffer = newBuffer
+      this.offset = 0
+      if (this.arrayCache.length) {
+        const arr = parseArrayChunks(this)
+        if (arr === undefined) {
+          return
+        }
+        this.returnReply(arr)
+      }
+    } else if (this.totalChunkSize + buffer.length >= this.bigStrSize) {
+      this.bufferCache.push(buffer)
+      var tmp = this.optionReturnBuffers ? concatBulkBuffer(this) : concatBulkString(this)
+      this.bigStrSize = 0
+      this.bufferCache = []
+      this.buffer = buffer
+      if (this.arrayCache.length) {
+        this.arrayCache[0][this.arrayPos[0]++] = tmp
+        tmp = parseArrayChunks(this)
+        if (tmp === undefined) {
+          return
+        }
+      }
+      this.returnReply(tmp)
+    } else {
+      this.bufferCache.push(buffer)
+      this.totalChunkSize += buffer.length
+      return
+    }
+
+    while (this.offset < this.buffer.length) {
+      const offset = this.offset
+      const type = this.buffer[this.offset++]
+      const response = parseType(this, type)
+      if (response === undefined) {
+        if (!(this.arrayCache.length || this.bufferCache.length)) {
+          this.offset = offset
+        }
+        return
+      }
+
+      if (type === 45) {
+        this.returnError(response)
+      } else {
+        this.returnReply(response)
+      }
+    }
+
+    this.buffer = null
+  }
+}
+
+module.exports = JavascriptRedisParser
--- a/nginx-nodejs-redis/web/node_modules/redis-parser/package.json
+++ b/nginx-nodejs-redis/web/node_modules/redis-parser/package.json
@@ -0,0 +1,80 @@
+{
+  "_from": "redis-parser@^3.0.0",
+  "_id": "redis-parser@3.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-tm2CjNyv5rS4pCin3vTGvKwxyLQ=",
+  "_location": "/redis-parser",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "redis-parser@^3.0.0",
+    "name": "redis-parser",
+    "escapedName": "redis-parser",
+    "rawSpec": "^3.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^3.0.0"
+  },
+  "_requiredBy": [
+    "/redis"
+  ],
+  "_resolved": "https://registry.npmjs.org/redis-parser/-/redis-parser-3.0.0.tgz",
+  "_shasum": "b66d828cdcafe6b4b8a428a7def4c6bcac31c8b4",
+  "_spec": "redis-parser@^3.0.0",
+  "_where": "/Users/ajeetraina/projects/13march/awesome-compose/nginx-nodejs-redis/web/node_modules/redis",
+  "author": {
+    "name": "Ruben Bridgewater"
+  },
+  "bugs": {
+    "url": "https://github.com/NodeRedis/node-redis-parser/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "redis-errors": "^1.0.0"
+  },
+  "deprecated": false,
+  "description": "Javascript Redis protocol (RESP) parser",
+  "devDependencies": {
+    "benchmark": "^2.1.0",
+    "codeclimate-test-reporter": "^0.4.0",
+    "hiredis": "^0.5.0",
+    "istanbul": "^0.4.0",
+    "mocha": "^3.1.2",
+    "standard": "^10.0.0"
+  },
+  "directories": {
+    "test": "test",
+    "lib": "lib"
+  },
+  "engines": {
+    "node": ">=4"
+  },
+  "homepage": "https://github.com/NodeRedis/node-redis-parser#readme",
+  "keywords": [
+    "redis",
+    "protocol",
+    "parser",
+    "database",
+    "javascript",
+    "node",
+    "nodejs",
+    "resp",
+    "hiredis"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "redis-parser",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NodeRedis/node-redis-parser.git"
+  },
+  "scripts": {
+    "benchmark": "node ./benchmark",
+    "coverage": "node ./node_modules/istanbul/lib/cli.js cover --preserve-comments ./node_modules/mocha/bin/_mocha -- -R spec",
+    "coverage:check": "node ./node_modules/istanbul/lib/cli.js check-coverage --branch 100 --statement 100",
+    "lint": "standard --fix",
+    "posttest": "npm run lint && npm run coverage:check",
+    "test": "npm run coverage"
+  },
+  "version": "3.0.0"
+}