Merge pull request #163 from drktfl/feat/redis-sentinel-support

Add Redis Sentinel support

Author: oklemenz2

README.md

@@ -399,6 +399,31 @@ const mainClient = await RedisClient.create().createMainClientAndConnect(options
 
 For details on Redis `createClient` configuration options see [Redis Client Configuration](https://github.com/redis/node-redis/blob/master/docs/client-configuration.md).
 
+### Redis Sentinel Support
+
+Redis Sentinel mode is activated when `credentials.sentinel_nodes` is present and takes priority over cluster mode.
+
+```json
+{
+  "cds": {
+    "requires": {
+      "redis": {
+        "credentials": {
+          "sentinel_nodes": [
+            { "host": "sentinel1.example.com", "port": 26379 },
+            { "host": "sentinel2.example.com", "port": 26379 }
+          ],
+          "master_name": "myprimary"
+        }
+      }
+    }
+  }
+}
+```
+
+The `master_name` identifies which Redis master the Sentinels monitor. Alternatively, the master name can be provided as a URI fragment in `credentials.uri` (e.g., `redis://host#myprimary`).
+If `sentinel_nodes[].port` is omitted, it defaults to `26379`. Both `host` and `hostname` are accepted for node addresses.
+
 ## Local HTML5 Repository
 
 Developing HTML5 apps against hybrid environments including Approuter component requires a local HTML5 repository to directly test the changes to UI5 applications without deployment to a remote HTML5 repository.

src/redis-client/RedisClient.js

@@ -9,6 +9,7 @@ const TIMEOUT_SHUTDOWN = 2500;
 
 class RedisClient {
   #clusterClient = false;
+  #sentinelClient = false;
   #beforeCloseHandler;
   constructor(name, env) {
     this.name = name;
@@ -105,20 +106,25 @@ class RedisClient {
   createClientBase(redisOptions = {}) {
     const { credentials, options } =
       (this.env ? cds.env.requires[`redis-${this.env}`] : undefined) || cds.env.requires["redis"] || {};
-    const socket = {
-      host: credentials?.hostname ?? "127.0.0.1",
-      tls: !!credentials?.tls,
-      port: credentials?.port ?? 6379,
-      ...options?.socket,
-      ...redisOptions.socket,
-    };
-    const socketOptions = {
-      ...options,
-      ...redisOptions,
-      password: redisOptions?.password ?? options?.password ?? credentials?.password,
-      socket,
-    };
+
     try {
+      if (credentials?.sentinel_nodes?.length > 0) {
+        return this.createSentinelClient(credentials, options, redisOptions);
+      }
+
+      const socket = {
+        host: credentials?.hostname ?? "127.0.0.1",
+        tls: !!credentials?.tls,
+        port: credentials?.port ?? 6379,
+        ...options?.socket,
+        ...redisOptions.socket,
+      };
+      const socketOptions = {
+        ...options,
+        ...redisOptions,
+        password: redisOptions?.password ?? options?.password ?? credentials?.password,
+        socket,
+      };
       if (credentials?.cluster_mode) {
         this.#clusterClient = true;
         return redis.createCluster({
@@ -132,6 +138,59 @@ class RedisClient {
     }
   }
 
+  createSentinelClient(credentials, options, redisOptions) {
+    const masterName = this.extractMasterName(credentials);
+    const sentinelNodes = credentials.sentinel_nodes.map((node) => ({
+      host: node.host ?? node.hostname,
+      port: node.port ?? 26379,
+    }));
+    const clientOptions = {
+      ...options,
+      ...redisOptions,
+      password: redisOptions?.password ?? options?.password ?? credentials?.password,
+      socket: {
+        tls: !!credentials?.tls,
+        ...options?.socket,
+        ...redisOptions?.socket,
+      },
+    };
+    this.#sentinelClient = true;
+    this.log.info("Creating Redis Sentinel client", { masterName, nodeCount: sentinelNodes.length });
+    return redis.createSentinel({
+      name: masterName,
+      sentinelRootNodes: sentinelNodes,
+      nodeClientOptions: clientOptions,
+      sentinelClientOptions: clientOptions,
+      passthroughClientErrorEvents: true,
+    });
+  }
+
+  /**
+   * Extracts the Sentinel master name from credentials.
+   * Priority: master_name field > URI fragment
+   * @param {Object} credentials - Redis credentials
+   * @returns {string} Master name
+   * @throws {Error} If master name cannot be determined
+   */
+  extractMasterName(credentials) {
+    if (credentials?.master_name) {
+      return credentials.master_name;
+    }
+    if (credentials?.uri) {
+      try {
+        const url = new URL(credentials.uri);
+        if (url.hash && url.hash.length > 1) {
+          return url.hash.slice(1);
+        }
+      } catch (e) {
+        this.log.warn("Failed to parse master name from URI", e.message);
+      }
+    }
+    throw new Error(
+      "Redis Sentinel master name not found. Provide credentials.master_name or include #mastername in credentials.uri",
+    );
+  }
+
   subscribeChannel(options, channel, subscribeHandler) {
     this.subscribedChannels[channel] = subscribeHandler;
     const errorHandlerCreateClient = (err) => {
@@ -251,6 +310,10 @@ class RedisClient {
     return this.#clusterClient;
   }
 
+  get isSentinel() {
+    return this.#sentinelClient;
+  }
+
   static create(name = "default", env) {
     env ??= name;
     RedisClient._create ??= {};

test/mocks/redis.js

@@ -118,6 +118,14 @@ module.exports = {
     client.options = options;
     return client;
   }),
+  createSentinel: jest.fn((options) => {
+    if (createClientError) {
+      createClientError = false;
+      throw new Error("create sentinel error");
+    }
+    client.options = options;
+    return client;
+  }),
   commandOptions: jest.fn(() => {
     return {};
   }),

test/redis-client/redis-client.test.js

@@ -123,4 +123,111 @@ describe("Redis Client", () => {
     const result = await redisClient.publishMessage({}, "test", "message");
     expect(result).toBeUndefined();
   });
+
+  describe("Sentinel Mode", () => {
+    beforeEach(async () => {
+      jest.clearAllMocks();
+      await RedisClient.closeAllClients();
+    });
+
+    it("creates Sentinel client when sentinel_nodes configured", async () => {
+      cds.env.requires.redis = {
+        credentials: {
+          sentinel_nodes: [
+            { hostname: "sentinel1.example.com", port: 26379 },
+            { hostname: "sentinel2.example.com", port: 26379 },
+          ],
+          uri: "redis://:secret@sentinel1.example.com:26379#mymaster",
+          password: "secret",
+          tls: true,
+        },
+      };
+
+      const redisClient = RedisClient.create("sentinel-test");
+      const client = await redisClient.createMainClientAndConnect();
+
+      expect(client).toBeDefined();
+      expect(redis.createSentinel).toHaveBeenCalledWith({
+        name: "mymaster",
+        sentinelRootNodes: [
+          { host: "sentinel1.example.com", port: 26379 },
+          { host: "sentinel2.example.com", port: 26379 },
+        ],
+        nodeClientOptions: expect.objectContaining({
+          password: "secret",
+          socket: expect.objectContaining({ tls: true }),
+        }),
+        sentinelClientOptions: expect.objectContaining({
+          password: "secret",
+        }),
+        passthroughClientErrorEvents: true,
+      });
+      expect(redisClient.isSentinel).toBe(true);
+      expect(redisClient.isCluster).toBe(false);
+    });
+
+    it("prefers master_name field over URI fragment", async () => {
+      cds.env.requires.redis = {
+        credentials: {
+          sentinel_nodes: [{ host: "sentinel.local", port: 26379 }],
+          master_name: "explicit-master",
+          uri: "redis://sentinel.local#uri-master",
+        },
+      };
+
+      const redisClient = RedisClient.create("master-name-test");
+      await redisClient.createMainClientAndConnect();
+
+      expect(redis.createSentinel).toHaveBeenCalledWith(expect.objectContaining({ name: "explicit-master" }));
+    });
+
+    it("uses default port 26379 when not specified", async () => {
+      cds.env.requires.redis = {
+        credentials: {
+          sentinel_nodes: [{ hostname: "sentinel.local" }],
+          master_name: "mymaster",
+        },
+      };
+
+      const redisClient = RedisClient.create("default-port-test");
+      await redisClient.createMainClientAndConnect();
+
+      expect(redis.createSentinel).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sentinelRootNodes: [{ host: "sentinel.local", port: 26379 }],
+        }),
+      );
+    });
+
+    it("returns undefined if master name not found", async () => {
+      cds.env.requires.redis = {
+        credentials: {
+          sentinel_nodes: [{ hostname: "sentinel.local" }],
+        },
+      };
+
+      const redisClient = RedisClient.create("no-master-test");
+      const client = await redisClient.createMainClientAndConnect();
+      expect(client).toBeUndefined();
+    });
+
+    it("prioritizes sentinel over cluster mode", async () => {
+      cds.env.requires.redis = {
+        credentials: {
+          sentinel_nodes: [{ hostname: "sentinel.local" }],
+          master_name: "mymaster",
+          cluster_mode: true,
+        },
+      };
+
+      const redisClient = RedisClient.create("priority-test");
+      await redisClient.createMainClientAndConnect();
+
+      expect(redis.createSentinel).toHaveBeenCalled();
+      expect(redis.createCluster).not.toHaveBeenCalled();
+      expect(redisClient.isSentinel).toBe(true);
+    });
+  });
 });
+
+