@cap-js-community/event-queue 1.3.6 → 1.4.1

package/src/shared/redis.js

@@ -12,7 +12,7 @@ let mainClientPromise;
 const subscriberChannelClientPromise = {};
 let lastErrorLog = Date.now();
 
-const createMainClientAndConnect = () => {
+const createMainClientAndConnect = (options) => {
   if (mainClientPromise) {
     return mainClientPromise;
   }
@@ -20,14 +20,14 @@ const createMainClientAndConnect = () => {
   const errorHandlerCreateClient = (err) => {
     cds.log(COMPONENT_NAME).error("error from redis client for pub/sub failed", err);
     mainClientPromise = null;
-    setTimeout(createMainClientAndConnect, LOG_AFTER_SEC * 1000).unref();
+    setTimeout(() => createMainClientAndConnect(options), LOG_AFTER_SEC * 1000).unref();
   };
 
-  mainClientPromise = createClientAndConnect(errorHandlerCreateClient);
+  mainClientPromise = createClientAndConnect(options, errorHandlerCreateClient);
   return mainClientPromise;
 };
 
-const _createClientBase = () => {
+const _createClientBase = (redisOptions) => {
   const env = getEnvInstance();
   try {
     const credentials = env.getRedisCredentialsFromEnv();
@@ -40,18 +40,19 @@ const _createClientBase = () => {
         defaults: {
           password: credentials.password,
           socket: { tls: credentials.tls },
+          ...redisOptions,
         },
       });
     }
-    return redis.createClient({ url });
+    return redis.createClient({ url, ...redisOptions });
   } catch (err) {
     throw EventQueueError.redisConnectionFailure(err);
   }
 };
 
-const createClientAndConnect = async (errorHandlerCreateClient) => {
+const createClientAndConnect = async (options, errorHandlerCreateClient) => {
   try {
-    const client = _createClientBase();
+    const client = _createClientBase(options);
     await client.connect();
     client.on("error", (err) => {
       const dateNow = Date.now();
@@ -74,14 +75,14 @@ const createClientAndConnect = async (errorHandlerCreateClient) => {
   }
 };
 
-const subscribeRedisChannel = (channel, subscribeHandler) => {
+const subscribeRedisChannel = (options, channel, subscribeHandler) => {
   const errorHandlerCreateClient = (err) => {
     cds.log(COMPONENT_NAME).error(`error from redis client for pub/sub failed for channel ${channel}`, err);
     subscriberChannelClientPromise[channel] = null;
-    setTimeout(() => subscribeRedisChannel(channel, subscribeHandler), LOG_AFTER_SEC * 1000).unref();
+    setTimeout(() => subscribeRedisChannel(options, channel, subscribeHandler), LOG_AFTER_SEC * 1000).unref();
   };
 
-  subscriberChannelClientPromise[channel] = createClientAndConnect(errorHandlerCreateClient)
+  subscriberChannelClientPromise[channel] = createClientAndConnect(options, errorHandlerCreateClient)
     .then((client) => {
       cds.log(COMPONENT_NAME).info("subscribe redis client connected channel", { channel });
       client.subscribe(channel, subscribeHandler).catch(errorHandlerCreateClient);
@@ -93,8 +94,8 @@ const subscribeRedisChannel = (channel, subscribeHandler) => {
     });
 };
 
-const publishMessage = async (channel, message) => {
-  const client = await createMainClientAndConnect();
+const publishMessage = async (options, channel, message) => {
+  const client = await createMainClientAndConnect(options);
   return await client.publish(channel, message);
 };
 
@@ -116,9 +117,9 @@ const _resilientClientClose = async (client) => {
   }
 };
 
-const connectionCheck = async () => {
+const connectionCheck = async (options) => {
   return new Promise((resolve, reject) => {
-    createClientAndConnect(reject)
+    createClientAndConnect(options, reject)
       .then((client) => {
         if (client) {
           _resilientClientClose(client);

package/src/redisPubSub.js

@@ -1,170 +0,0 @@
-"use strict";
-
-const { promisify } = require("util");
-
-const cds = require("@sap/cds");
-
-const redis = require("./shared/redis");
-const { checkLockExistsAndReturnValue } = require("./shared/distributedLock");
-const config = require("./config");
-const runner = require("./runner");
-const { getSubdomainForTenantId } = require("./shared/cdsHelper");
-
-const EVENT_MESSAGE_CHANNEL = "EVENT_QUEUE_MESSAGE_CHANNEL";
-const COMPONENT_NAME = "/eventQueue/redisPubSub";
-const TRIES_FOR_PUBLISH_PERIODIC_EVENT = 10;
-const SLEEP_TIME_FOR_PUBLISH_PERIODIC_EVENT = 30 * 1000;
-
-const wait = promisify(setTimeout);
-let subscriberClientPromise;
-
-const initEventQueueRedisSubscribe = () => {
-  if (subscriberClientPromise || !config.redisEnabled) {
-    return;
-  }
-  redis.subscribeRedisChannel(EVENT_MESSAGE_CHANNEL, _messageHandlerProcessEvents);
-};
-
-const _messageHandlerProcessEvents = async (messageData) => {
-  const logger = cds.log(COMPONENT_NAME);
-  try {
-    const { tenantId, type, subType } = JSON.parse(messageData);
-    logger.debug("received redis event", {
-      tenantId,
-      type,
-      subType,
-    });
-    if (!config.isEventQueueActive) {
-      cds.log(COMPONENT_NAME).info("Skipping processing because runner is deactivated!", {
-        type,
-        subType,
-      });
-      return;
-    }
-
-    const subdomain = await getSubdomainForTenantId(tenantId);
-    const user = new cds.User.Privileged(config.userId);
-    const tenantContext = {
-      tenant: tenantId,
-      user,
-      // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-      http: { req: { authInfo: { getSubdomain: () => subdomain } } },
-    };
-
-    if (!config.getEventConfig(type, subType)) {
-      if (config.isCapOutboxEvent(type)) {
-        try {
-          const service = await cds.connect.to(subType);
-          cds.outboxed(service);
-        } catch (err) {
-          logger.error("could not connect to outboxed service", err, {
-            type,
-            subType,
-          });
-          return;
-        }
-      } else {
-        logger.error("cannot find configuration for published event. Event won't be processed", {
-          type,
-          subType,
-        });
-        return;
-      }
-    }
-
-    return await cds.tx(tenantContext, async ({ context }) => {
-      return await runner.runEventCombinationForTenant(context, type, subType);
-    });
-  } catch (err) {
-    logger.error("could not parse event information", {
-      messageData,
-    });
-  }
-};
-
-const broadcastEvent = async (tenantId, type, subType) => {
-  const logger = cds.log(COMPONENT_NAME);
-  try {
-    if (!config.isEventQueueActive) {
-      cds.log(COMPONENT_NAME).info("Skipping processing because runner is deactivated!", {
-        type,
-        subType,
-      });
-      return;
-    }
-    if (!config.redisEnabled) {
-      if (config.registerAsEventProcessor) {
-        let context = {};
-        if (tenantId) {
-          const subdomain = await getSubdomainForTenantId(tenantId);
-          const user = new cds.User.Privileged(config.userId);
-          context = {
-            // NOTE: we need this because of logging otherwise logs would not contain the subdomain
-            tenant: tenantId,
-            user,
-            http: { req: { authInfo: { getSubdomain: () => subdomain } } },
-          };
-        }
-
-        return await cds.tx(context, async ({ context }) => {
-          return await runner.runEventCombinationForTenant(context, type, subType);
-        });
-      }
-      return;
-    }
-    const eventConfig = config.getEventConfig(type, subType);
-    for (let i = 0; i < TRIES_FOR_PUBLISH_PERIODIC_EVENT; i++) {
-      const result = await checkLockExistsAndReturnValue(
-        new cds.EventContext({ tenant: tenantId }),
-        [type, subType].join("##")
-      );
-      if (result) {
-        logger.debug("skip publish redis event as no lock is available", {
-          type,
-          subType,
-          index: i,
-          isPeriodic: eventConfig.isPeriodic,
-          waitInterval: SLEEP_TIME_FOR_PUBLISH_PERIODIC_EVENT,
-        });
-        if (!eventConfig.isPeriodic) {
-          break;
-        }
-        await wait(SLEEP_TIME_FOR_PUBLISH_PERIODIC_EVENT);
-        continue;
-      }
-      logger.debug("publishing redis event", {
-        tenantId,
-        type,
-        subType,
-      });
-      await redis.publishMessage(EVENT_MESSAGE_CHANNEL, JSON.stringify({ tenantId, type, subType }));
-      break;
-    }
-  } catch (err) {
-    logger.error("publish event failed!", err, {
-      tenantId,
-      type,
-      subType,
-    });
-  }
-};
-
-const closeSubscribeClient = async () => {
-  try {
-    const client = await subscriberClientPromise;
-    if (client?.quit) {
-      await client.quit();
-    }
-  } catch (err) {
-    // ignore errors during shutdown
-  }
-};
-
-module.exports = {
-  initEventQueueRedisSubscribe,
-  broadcastEvent,
-  closeSubscribeClient,
-  __: {
-    _messageHandlerProcessEvents,
-  },
-};