ioredis 4.27.4 → 4.27.8

package/Changelog.md

@@ -1,3 +1,31 @@
+## [4.27.8](https://github.com/luin/ioredis/compare/v4.27.7...v4.27.8) (2021-08-18)
+
+
+### Bug Fixes
+
+* handle malicious keys for hgetall ([#1416](https://github.com/luin/ioredis/issues/1416)) ([7d73b9d](https://github.com/luin/ioredis/commit/7d73b9d07b52ec077f235292aa15c7aca203bba9)), closes [#1267](https://github.com/luin/ioredis/issues/1267)
+
+## [4.27.7](https://github.com/luin/ioredis/compare/v4.27.6...v4.27.7) (2021-08-01)
+
+
+### Bug Fixes
+
+* **cluster:** fix autopipeline with keyPrefix or arg array ([#1391](https://github.com/luin/ioredis/issues/1391)) ([d7477aa](https://github.com/luin/ioredis/commit/d7477aa5853388b51037210542372131919ddfb2)), closes [#1264](https://github.com/luin/ioredis/issues/1264) [#1248](https://github.com/luin/ioredis/issues/1248) [#1392](https://github.com/luin/ioredis/issues/1392)
+
+## [4.27.6](https://github.com/luin/ioredis/compare/v4.27.5...v4.27.6) (2021-06-13)
+
+
+### Bug Fixes
+
+* fixed autopipeline performances. ([#1226](https://github.com/luin/ioredis/issues/1226)) ([42f1ee1](https://github.com/luin/ioredis/commit/42f1ee107174366a79ff94bec8a7a1ac353e035c))
+
+## [4.27.5](https://github.com/luin/ioredis/compare/v4.27.4...v4.27.5) (2021-06-05)
+
+
+### Bug Fixes
+
+* **SENTINEL:** actively failover detection under an option ([#1363](https://github.com/luin/ioredis/issues/1363)) ([f02e383](https://github.com/luin/ioredis/commit/f02e383996310adaefc2b4c40d946b76e450e5c7))
+
 ## [4.27.4](https://github.com/luin/ioredis/compare/v4.27.3...v4.27.4) (2021-06-04)
 
 

package/README.md

@@ -755,7 +755,7 @@ const redis = new Redis({
 
 This feature is useful when using Amazon ElastiCache instances with Auto-failover disabled. On these instances, test your `reconnectOnError` handler by manually promoting the replica node to the primary role using the AWS console. The following writes fail with the error `READONLY`. Using `reconnectOnError`, we can force the connection to reconnect on this error in order to connect to the new master. Furthermore, if the `reconnectOnError` returns `2`, ioredis will resend the failed command after reconnecting.
 
-On ElastiCache insances with Auto-failover enabled, `reconnectOnError` does not execute. Instead of returning a Redis error, AWS closes all connections to the master endpoint until the new primary node is ready. ioredis reconnects via `retryStrategy` instead of `reconnectOnError` after about a minute. On ElastiCache insances with Auto-failover enabled, test failover events with the `Failover primary` option in the AWS console.
+On ElastiCache instances with Auto-failover enabled, `reconnectOnError` does not execute. Instead of returning a Redis error, AWS closes all connections to the master endpoint until the new primary node is ready. ioredis reconnects via `retryStrategy` instead of `reconnectOnError` after about a minute. On ElastiCache instances with Auto-failover enabled, test failover events with the `Failover primary` option in the AWS console.
 
 ## Connection Events
 

package/built/autoPipelining.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const PromiseContainer = require("./promiseContainer");
+const lodash_1 = require("./utils/lodash");
 const calculateSlot = require("cluster-key-slot");
 const standard_as_callback_1 = require("standard-as-callback");
 exports.kExec = Symbol("exec");
@@ -18,13 +19,6 @@ exports.notAllowedAutoPipelineCommands = [
     "unsubscribe",
     "unpsubscribe",
 ];
-function findAutoPipeline(client, _commandName, ...args) {
-    if (!client.isCluster) {
-        return "main";
-    }
-    // We have slot information, we can improve routing by grouping slots served by the same subset of nodes
-    return client.slots[calculateSlot(args[0])].join(",");
-}
 function executeAutoPipeline(client, slotKey) {
     /*
       If a pipeline is already executing, keep queueing up commands
@@ -69,6 +63,29 @@ function shouldUseAutoPipelining(client, functionName, commandName) {
         !client.options.autoPipeliningIgnoredCommands.includes(commandName));
 }
 exports.shouldUseAutoPipelining = shouldUseAutoPipelining;
+/**
+ * @private
+ */
+function getFirstValueInFlattenedArray(args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (typeof arg === "string") {
+            return arg;
+        }
+        else if (Array.isArray(arg) || lodash_1.isArguments(arg)) {
+            if (arg.length === 0) {
+                continue;
+            }
+            return arg[0];
+        }
+        const flattened = lodash_1.flatten([arg]);
+        if (flattened.length > 0) {
+            return flattened[0];
+        }
+    }
+    return undefined;
+}
+exports.getFirstValueInFlattenedArray = getFirstValueInFlattenedArray;
 function executeWithAutoPipelining(client, functionName, commandName, args, callback) {
     const CustomPromise = PromiseContainer.get();
     // On cluster mode let's wait for slots to be available
@@ -83,7 +100,13 @@ function executeWithAutoPipelining(client, functionName, commandName, args, call
             });
         });
     }
-    const slotKey = findAutoPipeline(client, commandName, ...args);
+    // If we have slot information, we can improve routing by grouping slots served by the same subset of nodes
+    // Note that the first value in args may be a (possibly empty) array.
+    // ioredis will only flatten one level of the array, in the Command constructor.
+    const prefix = client.options.keyPrefix || "";
+    const slotKey = client.isCluster
+        ? client.slots[calculateSlot(`${prefix}${getFirstValueInFlattenedArray(args)}`)].join(",")
+        : "main";
     if (!client._autoPipelines.has(slotKey)) {
         const pipeline = client.pipeline();
         pipeline[exports.kExec] = false;

package/built/cluster/index.js

@@ -42,6 +42,8 @@ class Cluster extends events_1.EventEmitter {
         this.isRefreshing = false;
         this.isCluster = true;
         this._autoPipelines = new Map();
+        this._groupsIds = {};
+        this._groupsBySlot = Array(16384);
         this._runningAutoPipelines = new Set();
         this._readyDelayedCallbacks = [];
         this._addedScriptHashes = {};
@@ -127,7 +129,9 @@ class Cluster extends events_1.EventEmitter {
                 reject(new Error("Redis is already connecting/connected"));
                 return;
             }
+            // Make sure only one timer is active at a time
             clearInterval(this._addedScriptHashesCleanInterval);
+            // Start the script cache cleaning
             this._addedScriptHashesCleanInterval = setInterval(() => {
                 this._addedScriptHashes = {};
             }, this.options.maxScriptsCachingTime);
@@ -491,6 +495,7 @@ class Cluster extends events_1.EventEmitter {
                         else {
                             _this.slots[slot] = [key];
                         }
+                        _this._groupsBySlot[slot] = _this._groupsIds[_this.slots[slot].join(';')];
                         _this.connectionPool.findOrCreate(_this.natMapper(key));
                         tryConnection();
                         debug("refreshing slot caches... (triggered by MOVED error)");
@@ -693,6 +698,20 @@ class Cluster extends events_1.EventEmitter {
                     this.slots[slot] = keys;
                 }
             }
+            // Assign to each node keys a numeric value to make autopipeline comparison faster.
+            this._groupsIds = Object.create(null);
+            let j = 0;
+            for (let i = 0; i < 16384; i++) {
+                const target = (this.slots[i] || []).join(';');
+                if (!target.length) {
+                    this._groupsBySlot[i] = undefined;
+                    continue;
+                }
+                if (!this._groupsIds[target]) {
+                    this._groupsIds[target] = ++j;
+                }
+                this._groupsBySlot[i] = this._groupsIds[target];
+            }
             this.connectionPool.reset(nodes);
             callback();
         }, this.options.slotsRefreshTimeout));

package/built/command.js

@@ -313,7 +313,21 @@ Command.setReplyTransformer("hgetall", function (result) {
     if (Array.isArray(result)) {
         const obj = {};
         for (let i = 0; i < result.length; i += 2) {
-            obj[result[i]] = result[i + 1];
+            const key = result[i];
+            const value = result[i + 1];
+            if (obj[key]) {
+                // can only be truthy if the property is special somehow, like '__proto__' or 'constructor'
+                // https://github.com/luin/ioredis/issues/1267
+                Object.defineProperty(obj, key, {
+                    value,
+                    configurable: true,
+                    enumerable: true,
+                    writable: true,
+                });
+            }
+            else {
+                obj[key] = value;
+            }
         }
         return obj;
     }

package/built/connectors/SentinelConnector/index.js

@@ -205,6 +205,9 @@ class SentinelConnector extends AbstractConnector_1.default {
     initFailoverDetector() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.options.failoverDetector) {
+                return;
+            }
             // Move the current sentinel to the first position
             this.sentinelIterator.reset(true);
             const sentinels = [];

package/built/pipeline.js

@@ -15,10 +15,9 @@ const commander_1 = require("./commander");
 */
 function generateMultiWithNodes(redis, keys) {
     const slot = calculateSlot(keys[0]);
-    const target = redis.slots[slot].join(",");
+    const target = redis._groupsBySlot[slot];
     for (let i = 1; i < keys.length; i++) {
-        const currentTarget = redis.slots[calculateSlot(keys[i])].join(",");
-        if (currentTarget !== target) {
+        if (redis._groupsBySlot[calculateSlot(keys[i])] !== target) {
             return -1;
         }
     }
@@ -141,6 +140,7 @@ Pipeline.prototype.fillResult = function (value, position) {
                 moved: function (slot, key) {
                     _this.preferKey = key;
                     _this.redis.slots[errv[1]] = [key];
+                    _this.redis._groupsBySlot[errv[1]] = _this.redis._groupsIds[_this.redis.slots[errv[1]].join(";")];
                     _this.redis.refreshSlotsCache();
                     _this.exec();
                 },

package/built/redis/RedisOptions.js

@@ -31,6 +31,7 @@ exports.DEFAULT_REDIS_OPTIONS = {
     natMap: null,
     enableTLSForSentinelMode: false,
     updateSentinels: true,
+    failoverDetector: false,
     // Status
     username: null,
     password: null,

package/built/redis/index.js

@@ -93,6 +93,11 @@ const debug = utils_1.Debug("redis");
  * @param {NatMap} [options.natMap=null] NAT map for sentinel connector.
  * @param {boolean} [options.updateSentinels=true] - Update the given `sentinels` list with new IP
  * addresses when communicating with existing sentinels.
+ * @param {boolean} [options.failoverDetector=false] - Detect failover actively by subscribing to the
+ * related channels. With this option disabled, ioredis is still able to detect failovers because Redis
+ * Sentinel will disconnect all clients whenever a failover happens, so ioredis will reconnect to the new
+ * master. This option is useful when you want to detect failover quicker, but it will create more TCP
+ * connections to Redis servers in order to subscribe to related channels.
 * @param {boolean} [options.enableAutoPipelining=false] - When enabled, all commands issued during an event loop
  * iteration are automatically wrapped in a pipeline and sent to the server at the same time.
  * This can dramatically improve performance.
@@ -257,7 +262,9 @@ Redis.prototype.connect = function (callback) {
             reject(new Error("Redis is already connecting/connected"));
             return;
         }
+        // Make sure only one timer is active at a time
         clearInterval(this._addedScriptHashesCleanInterval);
+        // Start the script cache cleaning
         this._addedScriptHashesCleanInterval = setInterval(() => {
             this._addedScriptHashes = {};
         }, this.options.maxScriptsCachingTime);

package/built/utils/lodash.js

@@ -4,5 +4,7 @@ const defaults = require("lodash.defaults");
 exports.defaults = defaults;
 const flatten = require("lodash.flatten");
 exports.flatten = flatten;
+const isArguments = require("lodash.isarguments");
+exports.isArguments = isArguments;
 function noop() { }
 exports.noop = noop;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ioredis",
-  "version": "4.27.4",
+  "version": "4.27.8",
   "description": "A robust, performance-focused and full-featured Redis client for Node.js.",
   "main": "built/index.js",
   "files": [
@@ -38,6 +38,7 @@
     "denque": "^1.1.0",
     "lodash.defaults": "^4.2.0",
     "lodash.flatten": "^4.4.0",
+    "lodash.isarguments": "^3.1.0",
     "p-map": "^2.1.0",
     "redis-commands": "1.7.0",
     "redis-errors": "^1.2.0",
@@ -53,6 +54,7 @@
     "@types/debug": "^4.1.5",
     "@types/lodash.defaults": "^4.2.6",
     "@types/lodash.flatten": "^4.4.6",
+    "@types/lodash.isarguments": "^3.1.6",
     "@types/mocha": "^7.0.2",
     "@types/node": "^13.11.0",
     "@types/redis-errors": "1.2.0",