fix(sentinel): Migrated to the new testing framework, fixed issues that were discovered during transition

* [CAE-342] Fix a couple of bugs

* Fixed issue with nodes masterauth persistency, changed docker container

* [CAE-342] Fixed a couple of sentinel issues, enabled most tests

* [CAE-342] Added comment

* [CAE-342] Migrate majority of tests to testUtils

* [CAE-342] Minor refactor

* .

* [CAE-342] Using cae containers for sentinel

* [CAE-342] Improved resiliency of the legacy tests, added TSdoc comment

* [CAE-342] Some extra logging, removed unneeded changes

* [CAE-342] Moved docker env as optional part of redisserverdockerconfig

* [CAE-342] Move password to serverArguments

* [CAE-342] Moved ts-node to devDependencies

* [CAE-342] Reverted legacy testing framework improvements

packages/test-utils/lib/dockers.ts

@@ -4,9 +4,11 @@ import { once } from 'node:events';
 import { createClient } from '@redis/client/index';
 import { setTimeout } from 'node:timers/promises';
 // import { ClusterSlotsReply } from '@redis/client/dist/lib/commands/CLUSTER_SLOTS';
-
 import { execFile as execFileCallback } from 'node:child_process';
 import { promisify } from 'node:util';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
 
 const execAsync = promisify(execFileCallback);
 
@@ -38,37 +40,64 @@ const portIterator = (async function* (): AsyncIterableIterator<number> {
   throw new Error('All ports are in use');
 })();
 
-export interface RedisServerDockerConfig {
+interface RedisServerDockerConfig {
   image: string;
   version: string;
 }
 
+interface SentinelConfig {
+  mode: "sentinel";
+  mounts: Array<string>;
+  port: number;
+}
+
+interface ServerConfig {
+  mode: "server";
+}
+
+export type RedisServerDockerOptions = RedisServerDockerConfig & (SentinelConfig | ServerConfig)
+
 export interface RedisServerDocker {
   port: number;
   dockerId: string;
 }
 
-async function spawnRedisServerDocker({
-  image,
-  version
-}: RedisServerDockerConfig, serverArguments: Array<string>): Promise<RedisServerDocker> {
-  const port = (await portIterator.next()).value;
+async function spawnRedisServerDocker(
+options: RedisServerDockerOptions, serverArguments: Array<string>): Promise<RedisServerDocker> {
+  let port;
+  if (options.mode == "sentinel") {
+    port = options.port;
+  } else {
+    port = (await portIterator.next()).value;
+  }
+
   const portStr = port.toString();
 
   const dockerArgs = [
     'run',
-    '-e', `PORT=${portStr}`,
-    '-d',
-    '--network', 'host',
-    `${image}:${version}`,
-    '--port', portStr
+    '--init',
+    '-e', `PORT=${portStr}`
   ];
 
-  if (serverArguments.length > 0) {
-    dockerArgs.push(...serverArguments);
+  if (options.mode == "sentinel") {
+    options.mounts.forEach(mount => {
+      dockerArgs.push('-v', mount);
+    });
   }
 
-  console.log(`[Docker] Spawning Redis container - Image: ${image}:${version}, Port: ${port}`);
+  dockerArgs.push(
+    '-d',
+    '--network', 'host',
+    `${options.image}:${options.version}`
+  );
+
+  if (serverArguments.length > 0) {
+    for (let i = 0; i < serverArguments.length; i++) {
+      dockerArgs.push(serverArguments[i])
+    }
+  }
+
+  console.log(`[Docker] Spawning Redis container - Image: ${options.image}:${options.version}, Port: ${port}, Mode: ${options.mode}`);
 
   const { stdout, stderr } = await execAsync('docker', dockerArgs);
 
@@ -87,7 +116,7 @@ async function spawnRedisServerDocker({
 }
 const RUNNING_SERVERS = new Map<Array<string>, ReturnType<typeof spawnRedisServerDocker>>();
 
-export function spawnRedisServer(dockerConfig: RedisServerDockerConfig, serverArguments: Array<string>): Promise<RedisServerDocker> {
+export function spawnRedisServer(dockerConfig: RedisServerDockerOptions, serverArguments: Array<string>): Promise<RedisServerDocker> {
   const runningServer = RUNNING_SERVERS.get(serverArguments);
   if (runningServer) {
     return runningServer;
@@ -113,7 +142,7 @@ after(() => {
   );
 });
 
-export interface RedisClusterDockersConfig extends RedisServerDockerConfig {
+export type RedisClusterDockersConfig = RedisServerDockerOptions & {
   numberOfMasters?: number;
   numberOfReplicas?: number;
 }
@@ -178,7 +207,7 @@ async function spawnRedisClusterNodeDockers(
 }
 
 async function spawnRedisClusterNodeDocker(
-  dockersConfig: RedisClusterDockersConfig,
+  dockersConfig: RedisServerDockerOptions,
   serverArguments: Array<string>,
   clientConfig?: Partial<RedisClusterClientOptions>
 ) {
@@ -291,3 +320,107 @@ after(() => {
     })
   );
 });
+
+
+const RUNNING_NODES = new Map<Array<string>, Array<RedisServerDocker>>();
+const RUNNING_SENTINELS = new Map<Array<string>, Array<RedisServerDocker>>();
+
+export async function spawnRedisSentinel(
+  dockerConfigs: RedisServerDockerOptions,
+  serverArguments: Array<string>,
+): Promise<Array<RedisServerDocker>> {
+    const runningNodes = RUNNING_SENTINELS.get(serverArguments);
+    if (runningNodes) {
+      return runningNodes;
+    }
+    
+    const passIndex = serverArguments.indexOf('--requirepass')+1;
+    let password: string | undefined = undefined;
+    if (passIndex != 0) {
+      password = serverArguments[passIndex];
+    }
+
+    const master = await spawnRedisServerDocker(dockerConfigs, serverArguments);
+    const redisNodes: Array<RedisServerDocker> = [master];
+    const replicaPromises: Array<Promise<RedisServerDocker>> = [];
+    
+    const replicasCount = 2;
+    for (let i = 0; i < replicasCount; i++) {
+      replicaPromises.push((async () => {
+        const replica = await spawnRedisServerDocker(dockerConfigs, serverArguments);
+        const client = createClient({
+          socket: {
+            port: replica.port
+          },
+          password: password
+        });
+
+        await client.connect();
+        await client.replicaOf("127.0.0.1", master.port);
+        await client.close();
+        
+        return replica;
+      })());
+    }
+    
+    const replicas = await Promise.all(replicaPromises);
+    redisNodes.push(...replicas);
+    RUNNING_NODES.set(serverArguments, redisNodes);
+
+    const sentinelPromises: Array<Promise<RedisServerDocker>> = [];
+    const sentinelCount = 3;
+    
+    const appPrefix = 'sentinel-config-dir';
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), appPrefix));
+
+    for (let i = 0; i < sentinelCount; i++) {
+      sentinelPromises.push((async () => {
+        const port = (await portIterator.next()).value;
+
+        let sentinelConfig = `port ${port}
+sentinel monitor mymaster 127.0.0.1 ${master.port} 2
+sentinel down-after-milliseconds mymaster 5000
+sentinel failover-timeout mymaster 6000
+`;
+        if (password !== undefined) {
+          sentinelConfig += `requirepass ${password}\n`;
+          sentinelConfig += `sentinel auth-pass mymaster ${password}\n`;
+        }
+
+        const dir = fs.mkdtempSync(path.join(tmpDir, i.toString()));
+        fs.writeFile(`${dir}/redis.conf`, sentinelConfig, err => {
+          if (err) {
+            console.error("failed to create temporary config file", err);
+          }
+        });
+
+        return await spawnRedisServerDocker(
+          {
+            image: dockerConfigs.image, 
+            version: dockerConfigs.version, 
+            mode: "sentinel",
+             mounts: [`${dir}/redis.conf:/redis/config/node-sentinel-1/redis.conf`], 
+             port: port,
+            }, serverArguments);
+      })());
+    }
+    
+    const sentinelNodes = await Promise.all(sentinelPromises);
+    RUNNING_SENTINELS.set(serverArguments, sentinelNodes);
+    
+    if (tmpDir) {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+
+    return sentinelNodes;
+}
+
+after(() => {
+  return Promise.all(
+    [...RUNNING_NODES.values(), ...RUNNING_SENTINELS.values()].map(async dockersPromise => {
+      return Promise.all(
+        dockersPromise.map(({ dockerId }) => dockerRemove(dockerId))
+      );
+    })
+  );
+});