ioredis 4.24.4 → 4.26.0

package/Changelog.md

@@ -1,3 +1,36 @@
+# [4.26.0](https://github.com/luin/ioredis/compare/v4.25.0...v4.26.0) (2021-04-08)
+
+
+### Bug Fixes
+
+* **cluster:** subscriber connection leaks ([81b9be0](https://github.com/luin/ioredis/commit/81b9be021d471796bba00ee7b08768df9d7e2689)), closes [#1325](https://github.com/luin/ioredis/issues/1325)
+
+
+### Features
+
+* **cluster:** apply provided connection name to internal connections ([2e388db](https://github.com/luin/ioredis/commit/2e388dbaa528d009b97b82c4dc362377165670a4))
+
+# [4.25.0](https://github.com/luin/ioredis/compare/v4.24.6...v4.25.0) (2021-04-02)
+
+
+### Features
+
+* added commandTimeout option ([#1320](https://github.com/luin/ioredis/issues/1320)) ([56f0272](https://github.com/luin/ioredis/commit/56f02729958545e5b7e713436181b0dd46f8803a))
+
+## [4.24.6](https://github.com/luin/ioredis/compare/v4.24.5...v4.24.6) (2021-03-31)
+
+
+### Bug Fixes
+
+* force disconnect after a timeout if socket is still half-open ([#1318](https://github.com/luin/ioredis/issues/1318)) ([6cacd17](https://github.com/luin/ioredis/commit/6cacd17e6ac4d9f995728ee09777e0a7f3b739d7))
+
+## [4.24.5](https://github.com/luin/ioredis/compare/v4.24.4...v4.24.5) (2021-03-27)
+
+
+### Bug Fixes
+
+* select db in cluster mode causes unhandled errors ([#1311](https://github.com/luin/ioredis/issues/1311)) ([da3ec92](https://github.com/luin/ioredis/commit/da3ec92a406ab6c2f1517810f29f55a0c12712dc)), closes [#1310](https://github.com/luin/ioredis/issues/1310)
+
 ## [4.24.4](https://github.com/luin/ioredis/compare/v4.24.3...v4.24.4) (2021-03-24)
 
 

package/README.md

@@ -11,7 +11,7 @@
 
 A robust, performance-focused and full-featured [Redis](http://redis.io) client for [Node.js](https://nodejs.org).
 
-Supports Redis >= 2.6.12 and (Node.js >= 6).
+Supports Redis >= 2.6.12 and (Node.js >= 6). Completely compatible with Redis 6.x.
 
 # Features
 
@@ -206,12 +206,12 @@ It worth noticing that a connection (aka `Redis` instance) can't play both roles
 If you want to do pub/sub in the same file/process, you should create a separate connection:
 
 ```javascript
-const Redis = require('ioredis');
+const Redis = require("ioredis");
 const sub = new Redis();
 const pub = new Redis();
 
 sub.subscribe(/* ... */); // From now, `sub` enters the subscriber mode.
-sub.on("message", /* ... */);
+sub.on("message" /* ... */);
 
 setInterval(() => {
   // `pub` can be used to publish messages, or send other regular commands (e.g. `hgetall`)
@@ -230,6 +230,34 @@ redis.on("pmessage", (pattern, channel, message) => {});
 redis.on("pmessageBuffer", (pattern, channel, message) => {});
 ```
 
+## Streams
+
+Redis v5 introduces a new data type called streams. It doubles as a communication channel for building streaming architectures and as a log-like data structure for persisting data. With ioredis, the usage can be pretty straightforward. Say we have a producer publishes messages to a stream with `redis.xadd("mystream", "*", "randomValue", Math.random())` (You may find the [official documentation of Streams](https://redis.io/topics/streams-intro) as a starter to understand the parameters used), to consume the messages, we'll have a consumer with the following code:
+
+```javascript
+const Redis = require("ioredis");
+const redis = new Redis();
+
+const processMessage = (message) => {
+  console.log("Id: %s. Data: %O", message[0], message[1]);
+};
+
+async function listenForMessage(lastId = "$") {
+  // `results` is an array, each element of which corresponds to a key.
+  // Because we only listen to one key (mystream) here, `results` only contains
+  // a single element. See more: https://redis.io/commands/xread#return-value
+  const results = await redis.xread("block", 0, "STREAMS", "mystream", lastId);
+  const [key, messages] = results[0]; // `key` equals to "mystream"
+
+  messages.forEach(processMessage);
+
+  // Pass the last id of the results to the next round.
+  await listenForMessage(messages[messages.length - 1][0]);
+}
+
+listenForMessage();
+```
+
 ## Handle Binary Data
 
 Arguments can be buffers:
@@ -741,7 +769,7 @@ The Redis instance will emit some events about the state of the connection to th
 | close        | emits when an established Redis server connection has closed.                                                                                                                                                                                   |
 | reconnecting | emits after `close` when a reconnection will be made. The argument of the event is the time (in ms) before reconnecting.                                                                                                                        |
 | end          | emits after `close` when no more reconnections will be made, or the connection is failed to establish.                                                                                                                                          |
-| wait          | emits when `lazyConnect` is set and will wait for the first command to be called before connecting.                                                                                                                                          |
+| wait         | emits when `lazyConnect` is set and will wait for the first command to be called before connecting.                                                                                                                                             |
 
 You can also check out the `Redis#status` property to get the current connection status.
 

package/built/cluster/ClusterSubscriber.js

@@ -4,7 +4,6 @@ const util_1 = require("./util");
 const utils_1 = require("../utils");
 const redis_1 = require("../redis");
 const debug = utils_1.Debug("cluster:subscriber");
-const SUBSCRIBER_CONNECTION_NAME = "ioredisClusterSubscriber";
 class ClusterSubscriber {
     constructor(connectionPool, emitter) {
         this.connectionPool = connectionPool;
@@ -38,6 +37,9 @@ class ClusterSubscriber {
         if (lastActiveSubscriber) {
             lastActiveSubscriber.disconnect();
         }
+        if (this.subscriber) {
+            this.subscriber.disconnect();
+        }
         const sampleNode = utils_1.sample(this.connectionPool.getNodes());
         if (!sampleNode) {
             debug("selecting subscriber failed since there is no node discovered in the cluster yet");
@@ -61,7 +63,7 @@ class ClusterSubscriber {
             username: options.username,
             password: options.password,
             enableReadyCheck: true,
-            connectionName: SUBSCRIBER_CONNECTION_NAME,
+            connectionName: util_1.getConnectionName("subscriber", options.connectionName),
             lazyConnect: true,
             tls: options.tls,
         });
@@ -90,7 +92,10 @@ class ClusterSubscriber {
                             this.lastActiveSubscriber = this.subscriber;
                         }
                     })
-                        .catch(utils_1.noop);
+                        .catch(() => {
+                        // TODO: should probably disconnect the subscriber and try again.
+                        debug("failed to %s %d channels", type, channels.length);
+                    });
                 }
             }
         }

package/built/cluster/index.js

@@ -652,7 +652,7 @@ class Cluster extends events_1.EventEmitter {
             enableOfflineQueue: true,
             enableReadyCheck: false,
             retryStrategy: null,
-            connectionName: "ioredisClusterRefresher",
+            connectionName: util_1.getConnectionName("refresher", this.options.redisOptions && this.options.redisOptions.connectionName),
         });
         // Ignore error events since we will handle
         // exceptions for the CLUSTER SLOTS command.

package/built/cluster/util.js

@@ -92,3 +92,8 @@ function weightSrvRecords(recordsGroup) {
     }
 }
 exports.weightSrvRecords = weightSrvRecords;
+function getConnectionName(component, nodeConnectionName) {
+    const prefix = `ioredis-cluster(${component})`;
+    return nodeConnectionName ? `${prefix}:${nodeConnectionName}` : prefix;
+}
+exports.getConnectionName = getConnectionName;

package/built/command.js

@@ -46,6 +46,7 @@ class Command {
         this.transformed = false;
         this.isCustomCommand = false;
         this.inTransaction = false;
+        this.isResolved = false;
         this.replyEncoding = options.replyEncoding;
         this.errorStack = options.errorStack;
         this.args = lodash_1.flatten(args);
@@ -220,6 +221,7 @@ class Command {
         return (value) => {
             try {
                 resolve(this.transformReply(value));
+                this.isResolved = true;
             }
             catch (err) {
                 this.reject(err);

package/built/connectors/AbstractConnector.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const debug = utils_1.Debug("AbstractConnector");
 class AbstractConnector {
-    constructor() {
+    constructor(disconnectTimeout) {
         this.connecting = false;
+        this.disconnectTimeout = disconnectTimeout;
     }
     check(info) {
         return true;
@@ -10,7 +13,13 @@ class AbstractConnector {
     disconnect() {
         this.connecting = false;
         if (this.stream) {
-            this.stream.end();
+            const stream = this.stream; // Make sure callbacks refer to the same instance
+            const timeout = setTimeout(() => {
+                debug("stream %s:%s still open, destroying it", stream.remoteAddress, stream.remotePort);
+                stream.destroy();
+            }, this.disconnectTimeout);
+            stream.on("close", () => clearTimeout(timeout));
+            stream.end();
         }
     }
 }

package/built/connectors/SentinelConnector/index.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const net_1 = require("net");
 const utils_1 = require("../../utils");
@@ -11,7 +20,7 @@ const redis_1 = require("../../redis");
 const debug = utils_1.Debug("SentinelConnector");
 class SentinelConnector extends AbstractConnector_1.default {
     constructor(options) {
-        super();
+        super(options.disconnectTimeout);
         this.options = options;
         if (!this.options.sentinels.length) {
             throw new Error("Requires at least one sentinel to connect to.");
@@ -38,7 +47,7 @@ class SentinelConnector extends AbstractConnector_1.default {
         this.connecting = true;
         this.retryAttempts = 0;
         let lastError;
-        const connectToNext = () => new Promise((resolve, reject) => {
+        const connectToNext = () => __awaiter(this, void 0, void 0, function* () {
             const endpoint = this.sentinelIterator.next();
             if (endpoint.done) {
                 this.sentinelIterator.reset(false);
@@ -54,69 +63,69 @@ class SentinelConnector extends AbstractConnector_1.default {
                 debug(errorMsg);
                 const error = new Error(errorMsg);
                 if (typeof retryDelay === "number") {
-                    setTimeout(() => {
-                        resolve(connectToNext());
-                    }, retryDelay);
                     eventEmitter("error", error);
+                    yield new Promise((resolve) => setTimeout(resolve, retryDelay));
+                    return connectToNext();
                 }
                 else {
-                    reject(error);
+                    throw error;
                 }
-                return;
             }
-            this.resolve(endpoint.value, (err, resolved) => {
-                if (!this.connecting) {
-                    reject(new Error(utils_1.CONNECTION_CLOSED_ERROR_MSG));
-                    return;
-                }
-                if (resolved) {
-                    debug("resolved: %s:%s", resolved.host, resolved.port);
-                    if (this.options.enableTLSForSentinelMode && this.options.tls) {
-                        Object.assign(resolved, this.options.tls);
-                        this.stream = tls_1.connect(resolved);
-                    }
-                    else {
-                        this.stream = net_1.createConnection(resolved);
-                    }
-                    this.stream.once("error", (err) => {
-                        this.firstError = err;
-                    });
-                    this.sentinelIterator.reset(true);
-                    resolve(this.stream);
+            let resolved = null;
+            let err = null;
+            try {
+                resolved = yield this.resolve(endpoint.value);
+            }
+            catch (error) {
+                err = error;
+            }
+            if (!this.connecting) {
+                throw new Error(utils_1.CONNECTION_CLOSED_ERROR_MSG);
+            }
+            if (resolved) {
+                debug("resolved: %s:%s", resolved.host, resolved.port);
+                if (this.options.enableTLSForSentinelMode && this.options.tls) {
+                    Object.assign(resolved, this.options.tls);
+                    this.stream = tls_1.connect(resolved);
                 }
                 else {
-                    const endpointAddress = endpoint.value.host + ":" + endpoint.value.port;
-                    const errorMsg = err
-                        ? "failed to connect to sentinel " +
-                            endpointAddress +
-                            " because " +
-                            err.message
-                        : "connected to sentinel " +
-                            endpointAddress +
-                            " successfully, but got an invalid reply: " +
-                            resolved;
-                    debug(errorMsg);
-                    eventEmitter("sentinelError", new Error(errorMsg));
-                    if (err) {
-                        lastError = err;
-                    }
-                    resolve(connectToNext());
+                    this.stream = net_1.createConnection(resolved);
                 }
-            });
+                this.stream.once("error", (err) => {
+                    this.firstError = err;
+                });
+                this.sentinelIterator.reset(true);
+                return this.stream;
+            }
+            else {
+                const endpointAddress = endpoint.value.host + ":" + endpoint.value.port;
+                const errorMsg = err
+                    ? "failed to connect to sentinel " +
+                        endpointAddress +
+                        " because " +
+                        err.message
+                    : "connected to sentinel " +
+                        endpointAddress +
+                        " successfully, but got an invalid reply: " +
+                        resolved;
+                debug(errorMsg);
+                eventEmitter("sentinelError", new Error(errorMsg));
+                if (err) {
+                    lastError = err;
+                }
+                return connectToNext();
+            }
         });
         return connectToNext();
     }
-    updateSentinels(client, callback) {
-        if (!this.options.updateSentinels) {
-            return callback(null);
-        }
-        client.sentinel("sentinels", this.options.name, (err, result) => {
-            if (err) {
-                client.disconnect();
-                return callback(err);
+    updateSentinels(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.options.updateSentinels) {
+                return;
             }
+            const result = yield client.sentinel("sentinels", this.options.name);
             if (!Array.isArray(result)) {
-                return callback(null);
+                return;
             }
             result
                 .map(utils_1.packObject)
@@ -132,39 +141,27 @@ class SentinelConnector extends AbstractConnector_1.default {
                 }
             });
             debug("Updated internal sentinels: %s", this.sentinelIterator);
-            callback(null);
         });
     }
-    resolveMaster(client, callback) {
-        client.sentinel("get-master-addr-by-name", this.options.name, (err, result) => {
-            if (err) {
-                client.disconnect();
-                return callback(err);
-            }
-            this.updateSentinels(client, (err) => {
-                client.disconnect();
-                if (err) {
-                    return callback(err);
-                }
-                callback(null, this.sentinelNatResolve(Array.isArray(result)
-                    ? { host: result[0], port: Number(result[1]) }
-                    : null));
-            });
+    resolveMaster(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield client.sentinel("get-master-addr-by-name", this.options.name);
+            yield this.updateSentinels(client);
+            return this.sentinelNatResolve(Array.isArray(result)
+                ? { host: result[0], port: Number(result[1]) }
+                : null);
         });
     }
-    resolveSlave(client, callback) {
-        client.sentinel("slaves", this.options.name, (err, result) => {
-            client.disconnect();
-            if (err) {
-                return callback(err);
-            }
+    resolveSlave(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield client.sentinel("slaves", this.options.name);
             if (!Array.isArray(result)) {
-                return callback(null, null);
+                return null;
             }
             const availableSlaves = result
                 .map(utils_1.packObject)
                 .filter((slave) => slave.flags && !slave.flags.match(/(disconnected|s_down|o_down)/));
-            callback(null, this.sentinelNatResolve(selectPreferredSentinel(availableSlaves, this.options.preferredSlaves)));
+            return this.sentinelNatResolve(selectPreferredSentinel(availableSlaves, this.options.preferredSlaves));
         });
     }
     sentinelNatResolve(item) {
@@ -172,30 +169,38 @@ class SentinelConnector extends AbstractConnector_1.default {
             return item;
         return this.options.natMap[`${item.host}:${item.port}`] || item;
     }
-    resolve(endpoint, callback) {
-        const client = new redis_1.default({
-            port: endpoint.port || 26379,
-            host: endpoint.host,
-            username: this.options.sentinelUsername || null,
-            password: this.options.sentinelPassword || null,
-            family: endpoint.family ||
-                (StandaloneConnector_1.isIIpcConnectionOptions(this.options)
-                    ? undefined
-                    : this.options.family),
-            tls: this.options.sentinelTLS,
-            retryStrategy: null,
-            enableReadyCheck: false,
-            connectTimeout: this.options.connectTimeout,
-            dropBufferSupport: true,
+    resolve(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = new redis_1.default({
+                port: endpoint.port || 26379,
+                host: endpoint.host,
+                username: this.options.sentinelUsername || null,
+                password: this.options.sentinelPassword || null,
+                family: endpoint.family ||
+                    (StandaloneConnector_1.isIIpcConnectionOptions(this.options)
+                        ? undefined
+                        : this.options.family),
+                tls: this.options.sentinelTLS,
+                retryStrategy: null,
+                enableReadyCheck: false,
+                connectTimeout: this.options.connectTimeout,
+                commandTimeout: this.options.sentinelCommandTimeout,
+                dropBufferSupport: true,
+            });
+            // ignore the errors since resolve* methods will handle them
+            client.on("error", noop);
+            try {
+                if (this.options.role === "slave") {
+                    return yield this.resolveSlave(client);
+                }
+                else {
+                    return yield this.resolveMaster(client);
+                }
+            }
+            finally {
+                client.disconnect();
+            }
         });
-        // ignore the errors since resolve* methods will handle them
-        client.on("error", noop);
-        if (this.options.role === "slave") {
-            this.resolveSlave(client, callback);
-        }
-        else {
-            this.resolveMaster(client, callback);
-        }
     }
 }
 exports.default = SentinelConnector;

package/built/connectors/StandaloneConnector.js

@@ -10,7 +10,7 @@ function isIIpcConnectionOptions(value) {
 exports.isIIpcConnectionOptions = isIIpcConnectionOptions;
 class StandaloneConnector extends AbstractConnector_1.default {
     constructor(options) {
-        super();
+        super(options.disconnectTimeout);
         this.options = options;
     }
     connect(_) {

package/built/redis/RedisOptions.js

@@ -6,6 +6,7 @@ exports.DEFAULT_REDIS_OPTIONS = {
     host: "localhost",
     family: 4,
     connectTimeout: 10000,
+    disconnectTimeout: 2000,
     retryStrategy: function (times) {
         return Math.min(times * 50, 2000);
     },

package/built/redis/event_handler.js

@@ -36,7 +36,11 @@ function connectHandler(self) {
             });
         }
         if (self.condition.select) {
-            self.select(self.condition.select);
+            self.select(self.condition.select).catch((err) => {
+                // If the node is in cluster mode, select is disallowed.
+                // In this case, reconnect won't help.
+                self.silentEmit("error", err);
+            });
         }
         if (!self.options.enableReadyCheck) {
             exports.readyHandler(self)();

package/built/redis/index.js

@@ -623,6 +623,13 @@ Redis.prototype.sendCommand = function (command, stream) {
         command.reject(new Error("Connection in subscriber mode, only subscriber commands may be used"));
         return command.promise;
     }
+    if (typeof this.options.commandTimeout === "number") {
+        setTimeout(() => {
+            if (!command.isResolved) {
+                command.reject(new Error("Command timed out"));
+            }
+        }, this.options.commandTimeout);
+    }
     if (command.name === "quit") {
         clearInterval(this._addedScriptHashesCleanInterval);
         this._addedScriptHashesCleanInterval = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ioredis",
-  "version": "4.24.4",
+  "version": "4.26.0",
   "description": "A robust, performance-focused and full-featured Redis client for Node.js.",
   "main": "built/index.js",
   "files": [
@@ -58,17 +58,17 @@
     "@types/redis-errors": "1.2.0",
     "@types/sinon": "^9.0.0",
     "@types/uuid": "^8.3.0",
-    "@typescript-eslint/eslint-plugin": "^2.26.0",
+    "@typescript-eslint/eslint-plugin": "^1.13.0",
     "@typescript-eslint/parser": "^2.26.0",
     "bluebird": "^3.7.2",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
     "cronometro": "^0.6.0",
     "cz-conventional-changelog": "^3.1.0",
-    "eslint": "^6.8.0",
+    "eslint": "^5.16.0",
     "eslint-config-prettier": "^6.10.1",
     "husky": "^4.2.3",
-    "mocha": "^7.1.1",
+    "mocha": "^6.2.3",
     "prettier": "^2.0.2",
     "pretty-quick": "^2.0.1",
     "server-destroy": "^1.0.1",