@cap-js-community/event-queue 1.11.0 → 2.0.0-beta.0

package/src/shared/distributedLock.js

@@ -84,7 +84,7 @@ const _acquireLockRedis = async (
   expiryTime,
   { value = Date.now(), overrideValue = false, keepTrackOfLock } = {}
 ) => {
-  const client = await redis.createMainClientAndConnect(config.redisOptions);
+  const client = await redis.createMainClientAndConnect();
   const result = await client.set(fullKey, value, {
     PX: Math.round(expiryTime),
     ...(overrideValue ? null : { NX: true }),
@@ -97,7 +97,7 @@ const _acquireLockRedis = async (
 };
 
 const _renewLockRedis = async (context, fullKey, expiryTime, { value = "true" } = {}) => {
-  const client = await redis.createMainClientAndConnect(config.redisOptions);
+  const client = await redis.createMainClientAndConnect();
   let result = await client.set(fullKey, value, {
     PX: Math.round(expiryTime),
     XX: true,
@@ -116,7 +116,7 @@ const _renewLockRedis = async (context, fullKey, expiryTime, { value = "true" }
 };
 
 const _getLockValueRedis = async (context, fullKey) => {
-  const client = await redis.createMainClientAndConnect(config.redisOptions);
+  const client = await redis.createMainClientAndConnect();
   return await client.get(fullKey);
 };
 
@@ -129,7 +129,7 @@ const _getLockValueDb = async (context, fullKey) => {
 };
 
 const _releaseLockRedis = async (context, fullKey) => {
-  const client = await redis.createMainClientAndConnect(config.redisOptions);
+  const client = await redis.createMainClientAndConnect();
   const result = await client.del(fullKey);
   delete existingLocks[fullKey];
   return result === 1;
@@ -195,14 +195,14 @@ const _acquireLockDB = async (
 };
 
 const _generateKey = (context, tenantScoped, key) => {
-  const keyParts = [config.redisOptions.redisNamespace];
+  const keyParts = [config.redisNamespace];
   tenantScoped && keyParts.push(context.tenant);
   keyParts.push(key);
   return `${keyParts.join("##")}`;
 };
 
 const getAllLocksRedis = async () => {
-  const clientOrCluster = await redis.createMainClientAndConnect(config.redisOptions);
+  const clientOrCluster = await redis.createMainClientAndConnect();
   const output = [];
   const results = [];
 

package/src/shared/eventScheduler.js

@@ -15,9 +15,9 @@ class EventScheduler {
     config.attachUnsubscribeHandler(this.clearForTenant.bind(this));
   }
 
-  scheduleEvent(tenantId, type, subType, startAfter) {
+  scheduleEvent(tenantId, type, subType, namespace, startAfter) {
     const { date, relative } = this.calculateOffset(type, subType, startAfter);
-    const key = [tenantId, type, subType, date.toISOString()].join("##");
+    const key = [tenantId, type, subType, namespace, date.toISOString()].join("##");
     if (this.#scheduledEvents[key]) {
       return; // event combination already scheduled
     }
@@ -34,7 +34,7 @@ class EventScheduler {
       clearTimeout(timeout);
       delete this.#eventsByTenants[tenantId][timeout];
       delete this.#scheduledEvents[key];
-      redisPub.broadcastEvent(tenantId, { type, subType }).catch((err) => {
+      redisPub.broadcastEvent(tenantId, { type, subType, namespace }).catch((err) => {
         cds.log(COMPONENT_NAME).error("could not execute scheduled event", err, {
           tenantId,
           type,

package/src/shared/redis/client.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const { RedisClient } = require("@cap-js-community/common");
+
+const config = require("../../config");
+
+const REDIS_CLIENT_NAME = "eventQueue";
+
+const createMainClientAndConnect = async () => {
+  const redisClient = RedisClient.create(REDIS_CLIENT_NAME);
+  return await redisClient.createMainClientAndConnect(config.redisOptions);
+};
+
+const subscribeRedisChannel = async (channel, subscribeHandler) => {
+  const redisClient = RedisClient.create(REDIS_CLIENT_NAME);
+  const channelWithNamespace = [config.redisNamespace, channel].join("##");
+  return await redisClient.subscribeChannel(config.redisOptions, channelWithNamespace, subscribeHandler);
+};
+
+const publishMessage = async (channel, message) => {
+  const redisClient = RedisClient.create(REDIS_CLIENT_NAME);
+  const channelWithNamespace = [config.redisNamespace, channel].join("##");
+  return await redisClient.publishMessage(config.redisOptions, channelWithNamespace, message);
+};
+
+const connectionCheck = async () => {
+  const redisClient = RedisClient.create(REDIS_CLIENT_NAME);
+  return await redisClient.connectionCheck(config.redisOptions);
+};
+
+const isClusterMode = () => {
+  return RedisClient.create(REDIS_CLIENT_NAME).isCluster;
+};
+
+const registerShutdownHandler = (cb) => {
+  RedisClient.create(REDIS_CLIENT_NAME).beforeCloseHandler = cb;
+};
+
+module.exports = {
+  createMainClientAndConnect,
+  subscribeRedisChannel,
+  publishMessage,
+  connectionCheck,
+  isClusterMode,
+  registerShutdownHandler,
+};

package/src/shared/redis/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const cds = require("@sap/cds");
+
+const client = require("./client");
+const config = require("../../config");
+
+const COMPONENT_NAME = "/eventQueue/redis";
+const REDIS_OFFBOARD_TENANT_CHANNEL = "REDIS_OFFBOARD_TENANT_CHANNEL";
+
+const attachRedisUnsubscribeHandler = () => {
+  cds.log(COMPONENT_NAME).info("attached redis handle for unsubscribe events");
+  client
+    .subscribeRedisChannel(REDIS_OFFBOARD_TENANT_CHANNEL, (messageData) => {
+      try {
+        const { tenantId } = JSON.parse(messageData);
+        cds.log(COMPONENT_NAME).info("received unsubscribe broadcast event", { tenantId });
+        this.executeUnsubscribeHandlers(tenantId);
+      } catch (err) {
+        cds.log(COMPONENT_NAME).error("could not parse unsubscribe broadcast event", err, {
+          messageData,
+        });
+      }
+    })
+    .catch((err) => _errorHandlerSubscribeChannel(REDIS_OFFBOARD_TENANT_CHANNEL, err));
+};
+
+const handleUnsubscribe = (tenantId) => {
+  if (config.redisEnabled) {
+    client.publishMessage(REDIS_OFFBOARD_TENANT_CHANNEL, JSON.stringify({ tenantId })).catch((error) => {
+      cds.log(COMPONENT_NAME).error(`publishing tenant unsubscribe failed. tenantId: ${tenantId}`, error);
+    });
+  } else {
+    config.executeUnsubscribeHandlers(tenantId);
+  }
+};
+
+const _errorHandlerSubscribeChannel = (channelName, err) =>
+  cds.log(COMPONENT_NAME).error("error subscribing to channel", err, { channelName });
+
+module.exports = {
+  ...client,
+  attachRedisUnsubscribeHandler,
+  handleUnsubscribe,
+};

package/srv/service/admin-service.js

@@ -8,7 +8,7 @@ const redisPub = require("../../src/redis/redisPub");
 
 module.exports = class AdminService extends cds.ApplicationService {
   async init() {
-    const { Event: EventService, Lock: LockService } = this.entities();
+    const { Event: EventService, Lock: LockService } = this.entities;
     const { Event: EventDb } = cds.db.entities("sap.eventqueue");
     const { landscape, space } = this.getLandscapeAndSpace();
 

package/src/shared/redis.js

@@ -1,199 +0,0 @@
-"use strict";
-
-const redis = require("redis");
-
-const { getEnvInstance } = require("./env");
-const EventQueueError = require("../EventQueueError");
-
-const COMPONENT_NAME = "/eventQueue/shared/redis";
-const LOG_AFTER_SEC = 5;
-
-let mainClientPromise;
-let subscriberClientPromise;
-const subscribedChannels = {};
-let lastErrorLog = Date.now();
-
-const createMainClientAndConnect = (options) => {
-  if (mainClientPromise) {
-    return mainClientPromise;
-  }
-
-  const errorHandlerCreateClient = (err) => {
-    mainClientPromise?.then?.(_resilientClientClose);
-    cds.log(COMPONENT_NAME).error("error from redis main client:", err);
-    mainClientPromise = null;
-    setTimeout(() => createMainClientAndConnect(options), LOG_AFTER_SEC * 1000).unref();
-  };
-
-  mainClientPromise = createClientAndConnect(options, errorHandlerCreateClient);
-  return mainClientPromise;
-};
-
-const _createClientBase = (redisOptions = {}) => {
-  const env = getEnvInstance();
-  try {
-    const { credentials, options } = env.redisRequires;
-    const socket = Object.assign(
-      {
-        host: credentials.hostname,
-        tls: !!credentials.tls,
-        port: credentials.port,
-      },
-      options?.socket,
-      redisOptions.socket
-    );
-    const socketOptions = Object.assign({}, options, redisOptions, {
-      password: redisOptions.password ?? options.password ?? credentials.password,
-      socket,
-    });
-    delete socketOptions.redisNamespace;
-    if (credentials.cluster_mode) {
-      return redis.createCluster({
-        rootNodes: [socketOptions],
-        defaults: socketOptions,
-      });
-    }
-    return redis.createClient(socketOptions);
-  } catch (err) {
-    throw EventQueueError.redisConnectionFailure(err);
-  }
-};
-
-const createClientAndConnect = async (options, errorHandlerCreateClient, isConnectionCheck) => {
-  try {
-    const client = _createClientBase(options);
-    if (!isConnectionCheck) {
-      client.on("error", (err) => {
-        const dateNow = Date.now();
-        if (dateNow - lastErrorLog > LOG_AFTER_SEC * 1000) {
-          cds.log(COMPONENT_NAME).error("error redis client:", err);
-          lastErrorLog = dateNow;
-        }
-      });
-
-      client.on("reconnecting", () => {
-        const dateNow = Date.now();
-        if (dateNow - lastErrorLog > LOG_AFTER_SEC * 1000) {
-          cds.log(COMPONENT_NAME).info("redis client trying reconnect...");
-          lastErrorLog = dateNow;
-        }
-      });
-    }
-    await client.connect();
-    return client;
-  } catch (err) {
-    errorHandlerCreateClient(err);
-  }
-};
-
-const subscribeRedisChannel = (options, channel, subscribeHandler) => {
-  subscribedChannels[channel] = subscribeHandler;
-  const errorHandlerCreateClient = (err) => {
-    cds.log(COMPONENT_NAME).error(`error from redis client for pub/sub failed for channel ${channel}`, err);
-    subscriberClientPromise?.then?.(_resilientClientClose);
-    subscriberClientPromise = null;
-    setTimeout(() => _subscribeChannels(options, subscribedChannels, subscribeHandler), LOG_AFTER_SEC * 1000).unref();
-  };
-
-  _subscribeChannels(options, { [channel]: subscribeHandler }, errorHandlerCreateClient);
-};
-
-const _subscribeChannels = (options, subscribedChannels, errorHandlerCreateClient) => {
-  subscriberClientPromise = createClientAndConnect(options, errorHandlerCreateClient)
-    .then((client) => {
-      for (const channel in subscribedChannels) {
-        const fn = subscribedChannels[channel];
-        client._subscribedChannels ??= {};
-        if (client._subscribedChannels[channel]) {
-          continue;
-        }
-        const prefixedChannelName = [options.redisNamespace, channel].join("_");
-        cds.log(COMPONENT_NAME).info("subscribe redis client connected channel", { channel: prefixedChannelName });
-        client
-          .subscribe(prefixedChannelName, fn)
-          .then(() => {
-            client._subscribedChannels ??= {};
-            client._subscribedChannels[channel] = 1;
-          })
-          .catch(() => {
-            cds.log(COMPONENT_NAME).error("error subscribe to channel - retrying...");
-            setTimeout(() => _subscribeChannels(options, [channel], fn), LOG_AFTER_SEC * 1000).unref();
-          });
-      }
-    })
-    .catch((err) => {
-      cds
-        .log(COMPONENT_NAME)
-        .error(
-          `error from redis client for pub/sub failed during startup - trying to reconnect - ${Object.keys(
-            subscribedChannels
-          ).join(", ")}`,
-          err
-        );
-    });
-};
-
-const publishMessage = async (options, channel, message) => {
-  const client = await createMainClientAndConnect(options);
-  return await client.publish([options.redisNamespace, channel].join("_"), message);
-};
-
-const closeMainClient = async () => {
-  await _resilientClientClose(await mainClientPromise);
-  cds.log(COMPONENT_NAME).info("main redis client closed!");
-};
-
-const closeSubscribeClient = async () => {
-  await _resilientClientClose(await subscriberClientPromise);
-  cds.log(COMPONENT_NAME).info("subscribe redis client closed!");
-};
-
-const _resilientClientClose = async (client) => {
-  try {
-    if (client?.quit) {
-      await client.quit();
-    }
-  } catch (err) {
-    cds.log(COMPONENT_NAME).info("error during redis close - continuing...", err);
-  }
-};
-
-const connectionCheck = async (options) => {
-  return new Promise((resolve, reject) => {
-    createClientAndConnect(options, reject, true)
-      .then((client) => {
-        if (client) {
-          _resilientClientClose(client);
-          resolve();
-        } else {
-          reject(new Error());
-        }
-      })
-      .catch(reject);
-  })
-    .then(() => true)
-    .catch((err) => {
-      cds.log(COMPONENT_NAME).error("Redis connection check failed! Falling back to NO_REDIS mode", err);
-      return false;
-    });
-};
-
-const isClusterMode = () => {
-  if (!("__clusterMode" in isClusterMode)) {
-    const env = getEnvInstance();
-    const { credentials } = env.redisRequires;
-    isClusterMode.__clusterMode = credentials.cluster_mode;
-  }
-  return isClusterMode.__clusterMode;
-};
-
-module.exports = {
-  createClientAndConnect,
-  createMainClientAndConnect,
-  subscribeRedisChannel,
-  publishMessage,
-  closeMainClient,
-  closeSubscribeClient,
-  connectionCheck,
-  isClusterMode,
-};