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

package/src/runner/openEvents.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const cds = require("@sap/cds");
+
+const eventConfig = require("../config");
+const { EventProcessingStatus } = require("../constants");
+
+const getOpenQueueEntries = async (tx) => {
+  const startTime = new Date();
+  const refDateStartAfter = new Date(startTime.getTime() + eventConfig.runInterval * 1.2);
+  const entries = await tx.run(
+    SELECT.from(eventConfig.tableNameEventQueue)
+      .where(
+        "( startAfter IS NULL OR startAfter <=",
+        refDateStartAfter.toISOString(),
+        " ) AND ( status =",
+        EventProcessingStatus.Open,
+        "OR ( status =",
+        EventProcessingStatus.Error,
+        ") OR ( status =",
+        EventProcessingStatus.InProgress,
+        "AND lastAttemptTimestamp <=",
+        new Date(startTime.getTime() - eventConfig.globalTxTimeout).toISOString(),
+        ") )"
+      )
+      .columns("type", "subType")
+      .groupBy("type", "subType")
+  );
+
+  const result = [];
+  for (const { type, subType } of entries) {
+    if (type.startsWith("CAP_OUTBOX")) {
+      if (cds.requires[subType]) {
+        result.push({ type, subType });
+      } else {
+        const service = await cds.connect.to(subType).catch(() => {});
+        if (service) {
+          result.push({ type, subType });
+        }
+      }
+    } else {
+      if (eventConfig.getEventConfig(type, subType)) {
+        result.push({ type, subType });
+      }
+    }
+  }
+  return result;
+};
+
+module.exports = {
+  getOpenQueueEntries,
+};

package/src/{runner.js → runner/runner.js}

@@ -1,32 +1,32 @@
 "use strict";
 
 const { randomUUID } = require("crypto");
-const { AsyncResource } = require("async_hooks");
 
 const cds = require("@sap/cds");
 
-const eventQueueConfig = require("./config");
-const { processEventQueue } = require("./processEventQueue");
-const WorkerQueue = require("./shared/WorkerQueue");
-const cdsHelper = require("./shared/cdsHelper");
-const distributedLock = require("./shared/distributedLock");
-const SetIntervalDriftSafe = require("./shared/SetIntervalDriftSafe");
-const { getSubdomainForTenantId } = require("./shared/cdsHelper");
-const periodicEvents = require("./periodicEvents");
-const { hashStringTo32Bit } = require("./shared/common");
-const config = require("./config");
-const { Priorities } = require("./constants");
+const eventQueueConfig = require("../config");
+const WorkerQueue = require("../shared/WorkerQueue");
+const cdsHelper = require("../shared/cdsHelper");
+const distributedLock = require("../shared/distributedLock");
+const SetIntervalDriftSafe = require("../shared/SetIntervalDriftSafe");
+const periodicEvents = require("../periodicEvents");
+const common = require("../shared/common");
+const config = require("../config");
+const redisPub = require("../redis/redisPub");
+const openEvents = require("./openEvents");
+const { runEventCombinationForTenant } = require("./runnerHelper");
 
 const COMPONENT_NAME = "/eventQueue/runner";
 const EVENT_QUEUE_RUN_ID = "EVENT_QUEUE_RUN_ID";
 const EVENT_QUEUE_RUN_TS = "EVENT_QUEUE_RUN_TS";
-const EVENT_QUEUE_RUN_PERIODIC_EVENT = "EVENT_QUEUE_RUN_PERIODIC_EVENT";
+const EVENT_QUEUE_RUN_REDIS_CHECK = "EVENT_QUEUE_RUN_REDIS_CHECK";
+const EVENT_QUEUE_UPDATE_PERIODIC_EVENTS = "EVENT_QUEUE_UPDATE_PERIODIC_EVENTS";
 const OFFSET_FIRST_RUN = 10 * 1000;
 
 let tenantIdHash;
 let singleRunDone;
 
-const singleTenant = () => _scheduleFunction(_checkPeriodicEventsSingleTenant, _singleTenantDb);
+const singleTenant = () => _scheduleFunction(_checkPeriodicEventsSingleTenantOneTime, _singleTenantDb);
 
 const multiTenancyDb = () => _scheduleFunction(async () => {}, _multiTenancyDb);
 
@@ -69,26 +69,17 @@ const _scheduleFunction = async (singleRunFn, periodicFn) => {
 const _multiTenancyRedis = async () => {
   const logger = cds.log(COMPONENT_NAME);
   try {
-    const emptyContext = new cds.EventContext({});
     logger.info("executing event queue run for multi instance and tenant");
     const tenantIds = await cdsHelper.getAllTenantIds();
     await _checkPeriodicEventUpdate(tenantIds);
-
-    const runId = await _acquireRunId(emptyContext);
-
-    if (!runId) {
-      logger.error("could not acquire runId, skip processing events!");
-      return;
-    }
-
-    return await _executeEventsAllTenants(tenantIds, runId);
+    return await _executeEventsAllTenantsRedis(tenantIds);
   } catch (err) {
     logger.info("executing event queue run for multi instance and tenant failed", err);
   }
 };
 
 const _checkPeriodicEventUpdate = async (tenantIds) => {
-  const hash = hashStringTo32Bit(JSON.stringify(tenantIds));
+  const hash = common.hashStringTo32Bit(JSON.stringify(tenantIds));
   if (!tenantIdHash) {
     tenantIdHash = hash;
     return await _multiTenancyPeriodicEvents(tenantIds).catch((err) => {
@@ -104,80 +95,113 @@ const _checkPeriodicEventUpdate = async (tenantIds) => {
   }
 };
 
-const _executeEventsAllTenants = (tenantIds, runId) => {
-  const events = eventQueueConfig.allEvents;
-  const product = tenantIds.reduce((result, tenantId) => {
-    events.forEach((event) => {
-      result.push([tenantId, event]);
+const _executeEventsAllTenantsRedis = async (tenantIds) => {
+  const logger = cds.log(COMPONENT_NAME);
+  try {
+    // NOTE: do checks for all tenants on the same app instance --> acquire lock tenant independent
+    //       distribute from this instance to all others
+    const dummyContext = new cds.EventContext({});
+    const couldAcquireLock = await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_RUN_REDIS_CHECK, {
+      expiryTime: eventQueueConfig.runInterval * 0.95,
+      tenantScoped: false,
     });
-    return result;
-  }, []);
+    if (!couldAcquireLock) {
+      return;
+    }
 
-  return Promise.allSettled(
-    product.map(async ([tenantId, eventConfig]) => {
-      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 } } },
-      };
-      const label = `${eventConfig.type}_${eventConfig.subType}`;
-      return await WorkerQueue.instance.addToQueue(eventConfig.load, label, eventConfig.priority, async () => {
-        return await cds.tx(tenantContext, async ({ context }) => {
-          try {
-            const lockId = `${runId}_${label}`;
-            const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
-              expiryTime: eventQueueConfig.runInterval * 0.95,
-            });
-            if (!couldAcquireLock) {
-              return;
-            }
-            await runEventCombinationForTenant(context, eventConfig.type, eventConfig.subType, true);
-          } catch (err) {
-            cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
-              tenantId,
-            });
-          }
+    for (const tenantId of tenantIds) {
+      await cds.tx({ tenant: tenantId }, async (tx) => {
+        const entries = await openEvents.getOpenQueueEntries(tx);
+        logger.info("broadcasting events for run", {
+          tenantId,
+          entries: entries.length,
+        });
+        if (!entries.length) {
+          return;
+        }
+        await redisPub.broadcastEvent(tenantId, entries).catch((err) => {
+          logger.error("broadcasting event failed", err, {
+            tenantId,
+            entries: entries.length,
+          });
         });
       });
-    })
-  );
+    }
+  } catch (err) {
+    logger.info("executing event queue run for multi instance and tenant failed", err);
+  }
 };
 
-const _executePeriodicEventsAllTenants = async (tenantIds, runId) => {
-  return await Promise.allSettled(
-    tenantIds.map(async (tenantId) => {
-      const label = `UPDATE_PERIODIC_EVENTS_${tenantId}`;
-      return await WorkerQueue.instance.addToQueue(1, label, Priorities.Low, async () => {
-        try {
-          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 } } },
-          };
+const _executeEventsAllTenants = async (tenantIds, runId) => {
+  const promises = [];
+
+  for (const tenantId of tenantIds) {
+    const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+    const tenantContext = {
+      tenant: tenantId,
+      user,
+    };
+    const events = await cds.tx(tenantContext, async (tx) => {
+      return await openEvents.getOpenQueueEntries(tx);
+    });
+
+    if (!events.length) {
+      continue;
+    }
 
+    promises.concat(
+      events.map(async (openEvent) => {
+        const eventConfig = config.getEventConfig(openEvent.type, openEvent.subType);
+        const label = `${eventConfig.type}_${eventConfig.subType}`;
+        return await WorkerQueue.instance.addToQueue(eventConfig.load, label, eventConfig.priority, async () => {
           return await cds.tx(tenantContext, async ({ context }) => {
-            const couldAcquireLock = await distributedLock.acquireLock(context, runId, {
-              expiryTime: eventQueueConfig.runInterval * 0.95,
-            });
-            if (!couldAcquireLock) {
-              return;
+            try {
+              const lockId = `${runId}_${label}`;
+              const couldAcquireLock = await distributedLock.acquireLock(context, lockId, {
+                expiryTime: eventQueueConfig.runInterval * 0.95,
+              });
+              if (!couldAcquireLock) {
+                return;
+              }
+              await runEventCombinationForTenant(context, eventConfig.type, eventConfig.subType, true);
+            } catch (err) {
+              cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
+                tenantId,
+              });
             }
-            await _checkPeriodicEventsSingleTenant(context);
           });
-        } catch (err) {
-          cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
-            tenantId,
+        });
+      })
+    );
+  }
+  return Promise.allSettled(promises);
+};
+
+const _executePeriodicEventsAllTenants = async (tenantIds) => {
+  for (const tenantId of tenantIds) {
+    try {
+      const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(tenantId) });
+      const tenantContext = {
+        tenant: tenantId,
+        user,
+      };
+      await cds.tx(tenantContext, async ({ context }) => {
+        if (!config.redisEnabled) {
+          const couldAcquireLock = await distributedLock.acquireLock(context, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
+            expiryTime: eventQueueConfig.runInterval * 0.95,
           });
+          if (!couldAcquireLock) {
+            return;
+          }
         }
+        await _checkPeriodicEventsSingleTenant(context);
       });
-    })
-  );
+    } catch (err) {
+      cds.log(COMPONENT_NAME).error("executing event-queue run for tenant failed", {
+        tenantId,
+      });
+    }
+  }
 };
 
 const _singleTenantDb = async (tenantId) => {
@@ -269,30 +293,6 @@ const _calculateOffsetForFirstRun = async () => {
   return offsetDependingOnLastRun;
 };
 
-const runEventCombinationForTenant = async (context, type, subType, skipWorkerPool) => {
-  try {
-    if (skipWorkerPool) {
-      return await processEventQueue(context, type, subType);
-    } else {
-      const eventConfig = eventQueueConfig.getEventConfig(type, subType);
-      const label = `${type}_${subType}`;
-      return await WorkerQueue.instance.addToQueue(
-        eventConfig.load,
-        label,
-        eventConfig.priority,
-        AsyncResource.bind(async () => await processEventQueue(context, type, subType))
-      );
-    }
-  } catch (err) {
-    const logger = cds.log(COMPONENT_NAME);
-    logger.error("error executing event combination for tenant", err, {
-      tenantId: context.tenant,
-      type,
-      subType,
-    });
-  }
-};
-
 const _multiTenancyDb = async () => {
   const logger = cds.log(COMPONENT_NAME);
   try {
@@ -309,14 +309,29 @@ const _multiTenancyPeriodicEvents = async (tenantIds) => {
   const logger = cds.log(COMPONENT_NAME);
   try {
     logger.info("executing event queue update periodic events");
+
+    if (config.redisEnabled) {
+      const dummyContext = new cds.EventContext({});
+      const couldAcquireLock = await distributedLock.acquireLock(dummyContext, EVENT_QUEUE_UPDATE_PERIODIC_EVENTS, {
+        expiryTime: 60 * 1000, // short living lock --> assume we do not have 2 onboards within 1 minute
+        tenantScoped: false,
+      });
+      if (!couldAcquireLock) {
+        return;
+      }
+    }
+
     tenantIds = tenantIds ?? (await cdsHelper.getAllTenantIds());
-    return await _executePeriodicEventsAllTenants(tenantIds, EVENT_QUEUE_RUN_PERIODIC_EVENT);
+    return await _executePeriodicEventsAllTenants(tenantIds);
   } catch (err) {
     logger.error("Couldn't fetch tenant ids for updating periodic event processing!", err);
   }
 };
 
-const _checkPeriodicEventsSingleTenant = async (context = {}) => {
+const _checkPeriodicEventsSingleTenantOneTime = () =>
+  cds.tx({}, async (tx) => await periodicEvents.checkAndInsertPeriodicEvents(tx.context));
+
+const _checkPeriodicEventsSingleTenant = async (context) => {
   const logger = cds.log(COMPONENT_NAME);
   if (!eventQueueConfig.updatePeriodicEvents || !eventQueueConfig.periodicEvents.length) {
     logger.info("updating of periodic events is disabled or no periodic events configured", {
@@ -328,11 +343,9 @@ const _checkPeriodicEventsSingleTenant = async (context = {}) => {
   try {
     logger.info("executing updating periodic events", {
       tenantId: context.tenant,
-      subdomain: context.http?.req.authInfo.getSubdomain(),
-    });
-    await cdsHelper.executeInNewTransaction(context, "update-periodic-events", async (tx) => {
-      await periodicEvents.checkAndInsertPeriodicEvents(tx.context);
+      subdomain: context.user?.authInfo?.getSubdomain(),
     });
+    await periodicEvents.checkAndInsertPeriodicEvents(context);
   } catch (err) {
     logger.error("Couldn't update periodic events for tenant! Next try after defined interval.", err, {
       tenantId: context.tenant,
@@ -345,7 +358,6 @@ module.exports = {
   singleTenant,
   multiTenancyDb,
   multiTenancyRedis,
-  runEventCombinationForTenant,
   __: {
     _singleTenantDb,
     _multiTenancyRedis,

package/src/runner/runnerHelper.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const { AsyncResource } = require("async_hooks");
+
+const cds = require("@sap/cds");
+
+const { processEventQueue } = require("../processEventQueue");
+const eventQueueConfig = require("../config");
+const WorkerQueue = require("../shared/WorkerQueue");
+
+const COMPONENT_NAME = "/eventQueue/runnerHelper";
+
+const runEventCombinationForTenant = async (context, type, subType, skipWorkerPool) => {
+  try {
+    if (skipWorkerPool) {
+      return await processEventQueue(context, type, subType);
+    } else {
+      const eventConfig = eventQueueConfig.getEventConfig(type, subType);
+      const label = `${type}_${subType}`;
+      return await WorkerQueue.instance.addToQueue(
+        eventConfig.load,
+        label,
+        eventConfig.priority,
+        AsyncResource.bind(async () => await processEventQueue(context, type, subType))
+      );
+    }
+  } catch (err) {
+    const logger = cds.log(COMPONENT_NAME);
+    logger.error("error executing event combination for tenant", err, {
+      tenantId: context.tenant,
+      type,
+      subType,
+    });
+  }
+};
+
+module.exports = { runEventCombinationForTenant };

package/src/shared/cdsHelper.js

@@ -4,8 +4,7 @@ const VError = require("verror");
 const cds = require("@sap/cds");
 
 const config = require("../config");
-
-const subdomainCache = {};
+const common = require("./common");
 
 const VERROR_CLUSTER_NAME = "ExecuteInNewTransactionError";
 const COMPONENT_NAME = "/eventQueue/cdsHelper";
@@ -24,7 +23,7 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
   const parameters = Array.isArray(args) ? args : [args];
   const logger = cds.log(COMPONENT_NAME);
   try {
-    const user = new cds.User.Privileged(config.userId);
+    const user = new cds.User.Privileged({ id: config.userId, authInfo: await common.getAuthInfo(context.tenant) });
     if (cds.db.kind === "hana") {
       await cds.tx(
         {
@@ -33,7 +32,6 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
           locale: context.locale,
           user,
           headers: context.headers,
-          http: context.http,
         },
         async (tx) => {
           tx.context._ = context._ ?? {};
@@ -51,7 +49,6 @@ async function executeInNewTransaction(context = {}, transactionTag, fn, args, {
             locale: context.locale,
             user,
             headers: context.headers,
-            http: context.http,
           },
           async (tx) => fn(tx, ...parameters)
         );
@@ -102,33 +99,19 @@ class TriggerRollback extends VError {
   }
 }
 
-const getSubdomainForTenantId = async (tenantId) => {
+const getAllTenantIds = async () => {
   if (!config.isMultiTenancy) {
     return null;
   }
-  if (subdomainCache[tenantId]) {
-    return await subdomainCache[tenantId];
-  }
-  subdomainCache[tenantId] = new Promise((resolve) => {
-    cds.connect
-      .to("cds.xt.SaasProvisioningService")
-      .then((ssp) => {
-        ssp
-          .get("/tenant", { subscribedTenantId: tenantId })
-          .then((response) => {
-            resolve(response.subscribedSubdomain);
-          })
-          .catch(() => resolve(null));
-      })
-      .catch(() => resolve(null));
-  });
-  return await subdomainCache[tenantId];
-};
 
-const getAllTenantIds = async () => {
-  if (!config.isMultiTenancy) {
-    return null;
+  // NOTE: tmp workaround until cds-mtxs fixes the connect.to service
+  for (let i = 0; i < 10; i++) {
+    if (cds.services["saas-registry"]) {
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
   }
+
   const ssp = await cds.connect.to("cds.xt.SaasProvisioningService");
   const response = await ssp.get("/tenant");
   return response
@@ -141,6 +124,5 @@ const isFakeTenant = (tenantId) => /00000000-0000-4000-8000-\d{12}/.test(tenantI
 module.exports = {
   executeInNewTransaction,
   TriggerRollback,
-  getSubdomainForTenantId,
   getAllTenantIds,
 };

package/src/shared/common.js

@@ -1,6 +1,18 @@
 "use strict";
 
 const crypto = require("crypto");
+const { promisify } = require("util");
+
+const cds = require("@sap/cds");
+const xssec = require("@sap/xssec");
+
+const getAuthTokenAsync = promisify(xssec.requests.requestClientCredentialsToken);
+const getCreateSecurityContextAsync = promisify(xssec.createSecurityContext);
+
+let authInfoCache = {};
+const MARGIN_AUTH_INFO_EXPIRY = 60 * 1000;
+const COMPONENT_NAME = "/eventQueue/common";
+
 const arrayToFlatMap = (array, key = "ID") => {
   return array.reduce((result, element) => {
     result[element[key]] = element;
@@ -61,4 +73,43 @@ const processChunkedSync = (inputs, chunkSize, chunkHandler) => {
 
 const hashStringTo32Bit = (value) => crypto.createHash("sha256").update(String(value)).digest("base64").slice(0, 32);
 
-module.exports = { arrayToFlatMap, limiter, isValidDate, processChunkedSync, hashStringTo32Bit };
+const _getNewAuthInfo = async (tenantId) => {
+  try {
+    const token = await getAuthTokenAsync(null, cds.requires.auth.credentials, null, tenantId);
+    const authInfo = await getCreateSecurityContextAsync(token, cds.requires.auth.credentials);
+    authInfoCache[tenantId].expireTs = authInfo.getExpirationDate().getTime() - MARGIN_AUTH_INFO_EXPIRY;
+    return authInfo;
+  } catch (err) {
+    authInfoCache[tenantId] = null;
+    cds.log(COMPONENT_NAME).warn("failed to request authInfo", err);
+  }
+};
+
+const getAuthInfo = async (tenantId) => {
+  if (!cds.requires?.auth?.credentials) {
+    return null; // no credentials not authInfo
+  }
+
+  // not existing or existing but expired
+  if (
+    !authInfoCache[tenantId] ||
+    (authInfoCache[tenantId] && authInfoCache[tenantId].expireTs && Date.now() > authInfoCache[tenantId].expireTs)
+  ) {
+    authInfoCache[tenantId] ??= {};
+    authInfoCache[tenantId].value = _getNewAuthInfo(tenantId);
+    authInfoCache[tenantId].expireTs = null;
+  }
+  return await authInfoCache[tenantId].value;
+};
+
+module.exports = {
+  arrayToFlatMap,
+  limiter,
+  isValidDate,
+  processChunkedSync,
+  hashStringTo32Bit,
+  getAuthInfo,
+  __: {
+    clearAuthInfoCache: () => (authInfoCache = {}),
+  },
+};

package/src/shared/distributedLock.js

@@ -54,7 +54,7 @@ const checkLockExistsAndReturnValue = async (context, key, { tenantScoped = true
 };
 
 const _acquireLockRedis = async (context, fullKey, expiryTime, { value = "true", overrideValue = false } = {}) => {
-  const client = await redis.createMainClientAndConnect();
+  const client = await redis.createMainClientAndConnect(config.redisOptions);
   const result = await client.set(fullKey, value, {
     PX: expiryTime,
     ...(overrideValue ? null : { NX: true }),
@@ -63,7 +63,7 @@ const _acquireLockRedis = async (context, fullKey, expiryTime, { value = "true",
 };
 
 const _checkLockExistsRedis = async (context, fullKey) => {
-  const client = await redis.createMainClientAndConnect();
+  const client = await redis.createMainClientAndConnect(config.redisOptions);
   return await client.get(fullKey);
 };
 
@@ -76,7 +76,7 @@ const _checkLockExistsDb = async (context, fullKey) => {
 };
 
 const _releaseLockRedis = async (context, fullKey) => {
-  const client = await redis.createMainClientAndConnect();
+  const client = await redis.createMainClientAndConnect(config.redisOptions);
   await client.del(fullKey);
 };
 

package/src/shared/eventScheduler.js

@@ -2,7 +2,7 @@
 
 const cds = require("@sap/cds");
 
-const { broadcastEvent } = require("../redisPubSub");
+const redisPub = require("../redis/redisPub");
 const config = require("./../config");
 
 const COMPONENT_NAME = "/eventQueue/shared/eventScheduler";
@@ -26,7 +26,7 @@ class EventScheduler {
     });
     setTimeout(() => {
       delete this.#scheduledEvents[key];
-      broadcastEvent(tenantId, type, subType).catch((err) => {
+      redisPub.broadcastEvent(tenantId, { type, subType }).catch((err) => {
         cds.log(COMPONENT_NAME).error("could not execute scheduled event", err, {
           tenantId,
           type,