@cap-js-community/event-queue 1.11.0-beta.1 → 1.11.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.11.0-beta.1",
+  "version": "1.11.0-beta.3",
   "description": "An event queue that enables secure transactional processing of asynchronous and periodic events, featuring instant event processing with Redis Pub/Sub and load distribution across all application instances.",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/EventQueueProcessorBase.js

@@ -76,7 +76,7 @@ class EventQueueProcessorBase {
     this.__txMap = {};
     this.__txRollback = {};
     this.__queueEntries = [];
-    this.#keepAliveRunner = new SetIntervalDriftSafe(this.#eventConfig.keepAliveInterval);
+    this.#keepAliveRunner = new SetIntervalDriftSafe(this.#eventConfig.keepAliveInterval * 1000);
   }
 
   /**
@@ -617,7 +617,7 @@ class EventQueueProcessorBase {
                   "OR lastAttemptTimestamp IS NULL ) OR ( status =",
                   EventProcessingStatus.InProgress,
                   "AND lastAttemptTimestamp <=",
-                  new Date(baseDate - this.#eventConfig.keepAliveMaxInProgressTime).toISOString(),
+                  new Date(baseDate - this.#eventConfig.keepAliveMaxInProgressTime * 1000).toISOString(),
                   ") )",
                 ]
               : [
@@ -628,7 +628,7 @@ class EventQueueProcessorBase {
                   ") OR ( status =",
                   EventProcessingStatus.InProgress,
                   "AND lastAttemptTimestamp <=",
-                  new Date(baseDate - this.#eventConfig.keepAliveMaxInProgressTime).toISOString(),
+                  new Date(baseDate - this.#eventConfig.keepAliveMaxInProgressTime * 1000).toISOString(),
                   ") )",
                 ])
           )
@@ -868,7 +868,7 @@ class EventQueueProcessorBase {
   }
 
   continuesKeepAlive() {
-    if (Date.now() - this.lockAcquiredTime.getTime() >= this.#eventConfig.keepAliveInterval) {
+    if (Date.now() - this.lockAcquiredTime.getTime() >= this.#eventConfig.keepAliveInterval * 1000) {
       trace(this.baseContext, "keepAlive-between-iterations", async () => {
         await this.#renewDistributedLock();
       }).catch((err) => this.logger.error("renewing lock between intervals failed!", err));
@@ -961,7 +961,7 @@ class EventQueueProcessorBase {
       const lockAcquired = await distributedLock.acquireLock(
         this.__context,
         [this.#eventType, this.#eventSubType].join("##"),
-        { keepTrackOfLock: true, expiryTime: this.#eventConfig.keepAliveMaxInProgressTime }
+        { keepTrackOfLock: true, expiryTime: this.#eventConfig.keepAliveMaxInProgressTime * 1000 }
       );
       if (!lockAcquired) {
         this.logger.debug("no lock available, exit processing", {
@@ -983,7 +983,7 @@ class EventQueueProcessorBase {
     const lockAcquired = await distributedLock.renewLock(
       this.__context,
       [this.#eventType, this.#eventSubType].join("##"),
-      { expiryTime: this.#eventConfig.keepAliveMaxInProgressTime }
+      { expiryTime: this.#eventConfig.keepAliveMaxInProgressTime * 1000 }
     );
     if (!lockAcquired) {
       this.logger.error("renewing distributed lock failed!", {

package/src/config.js

@@ -28,6 +28,7 @@ const DEFAULT_CHECK_FOR_NEXT_CHUNK = true;
 const SUFFIX_PERIODIC = "_PERIODIC";
 const CAP_EVENT_TYPE = "CAP_OUTBOX";
 const CAP_PARALLEL_DEFAULT = 5;
+const CAP_MAX_ATTEMPTS_DEFAULT = 5;
 const DELETE_TENANT_BLOCK_AFTER_MS = 5 * 60 * 1000;
 const PRIORITIES = Object.values(Priorities);
 const UTC_DEFAULT = false;
@@ -387,7 +388,7 @@ class Config {
       kind: config.kind ?? "persistent-outbox",
       selectMaxChunkSize: config.selectMaxChunkSize ?? config.chunkSize,
       parallelEventProcessing: config.parallelEventProcessing ?? (config.parallel && CAP_PARALLEL_DEFAULT),
-      retryAttempts: config.retryAttempts ?? config.maxAttempts,
+      retryAttempts: config.retryAttempts ?? config.maxAttempts ?? CAP_MAX_ATTEMPTS_DEFAULT,
       ...config,
     });
     eventConfig.internalEvent = true;
@@ -550,7 +551,7 @@ class Config {
     event.load = event.load ?? DEFAULT_LOAD;
     event.priority = event.priority ?? DEFAULT_PRIORITY;
     event.increasePriorityOverTime = event.increasePriorityOverTime ?? DEFAULT_INCREASE_PRIORITY;
-    event.keepAliveInterval = (event.keepAliveInterval ?? DEFAULT_KEEP_ALIVE_INTERVAL) * 1000;
+    event.keepAliveInterval = event.keepAliveInterval ?? DEFAULT_KEEP_ALIVE_INTERVAL;
     event.keepAliveMaxInProgressTime = event.keepAliveInterval * DEFAULT_MAX_FACTOR_STUCK_2_KEEP_ALIVE_INTERVAL;
     event.checkForNextChunk = event.checkForNextChunk ?? DEFAULT_CHECK_FOR_NEXT_CHUNK;
   }

package/src/initialize.js

@@ -202,9 +202,6 @@ const mixConfigVarsWithEnv = (options) => {
 };
 
 const registerCdsShutdown = () => {
-  if (!config.developmentMode) {
-    return;
-  }
   cds.on("shutdown", async () => {
     return await new Promise((resolve) => {
       let timeoutRef;

package/src/outbox/EventQueueGenericOutboxHandler.js

@@ -61,7 +61,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
         }
       } else {
         for (const actionName in genericClusterEvents) {
-          const msg = new cds.Request({
+          const reg = new cds.Request({
             event: EVENT_QUEUE_ACTIONS.CLUSTER,
             user: this.context.user,
             eventQueue: {
@@ -74,14 +74,14 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
                 this.#clusterByDataProperty(actionName, genericClusterEvents[actionName], propertyName, cb),
             },
           });
-          const clusterResult = await this.__srvUnboxed.tx(this.context).send(msg);
+          const clusterResult = await this.__srvUnboxed.tx(this.context).send(reg);
           if (this.#validateCluster(clusterResult)) {
             Object.assign(clusterMap, clusterResult);
           } else {
             this.logger.error(
               "cluster result of handler is not valid. Check the documentation for the expected structure. Continuing without clustering!",
               {
-                handler: msg.event,
+                handler: reg.event,
                 clusterResult: JSON.stringify(clusterResult),
               }
             );
@@ -92,7 +92,7 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
     }
 
     for (const actionName in specificClusterEvents) {
-      const msg = new cds.Request({
+      const reg = new cds.Request({
         event: `${EVENT_QUEUE_ACTIONS.CLUSTER}.${actionName}`,
         user: this.context.user,
         eventQueue: {
@@ -105,14 +105,14 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
             this.#clusterByDataProperty(actionName, specificClusterEvents[actionName], propertyName, cb),
         },
       });
-      const clusterResult = await this.__srvUnboxed.tx(this.context).send(msg);
+      const clusterResult = await this.__srvUnboxed.tx(this.context).send(reg);
       if (this.#validateCluster(clusterResult)) {
         Object.assign(clusterMap, clusterResult);
       } else {
         this.logger.error(
           "cluster result of handler is not valid. Check the documentation for the expected structure. Continuing without clustering!",
           {
-            handler: msg.event,
+            handler: reg.event,
             clusterResult: JSON.stringify(clusterResult),
           }
         );
@@ -264,12 +264,12 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
       return payload;
     }
 
-    const { msg, userId } = this.#buildDispatchData(this.context, payload, {
+    const { reg, userId } = this.#buildDispatchData(this.context, payload, {
       queueEntries: [queueEntry],
     });
-    msg.event = handlerName;
-    await this.#setContextUser(this.context, userId, msg);
-    const data = await this.__srvUnboxed.tx(this.context).send(msg);
+    reg.event = handlerName;
+    await this.#setContextUser(this.context, userId, reg);
+    const data = await this.__srvUnboxed.tx(this.context).send(reg);
     if (data) {
       payload.data = data;
       return payload;
@@ -285,12 +285,12 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
       return await super.hookForExceededEvents(exceededEvent);
     }
 
-    const { msg, userId } = this.#buildDispatchData(this.context, exceededEvent.payload, {
+    const { reg, userId } = this.#buildDispatchData(this.context, exceededEvent.payload, {
       queueEntries: [exceededEvent],
     });
-    await this.#setContextUser(this.context, userId, msg);
-    msg.event = handlerName;
-    await this.__srvUnboxed.tx(this.context).send(msg);
+    await this.#setContextUser(this.context, userId, reg);
+    reg.event = handlerName;
+    await this.__srvUnboxed.tx(this.context).send(reg);
   }
 
   // NOTE: Currently not exposed to CAP service; we wait for a valid use case
@@ -310,37 +310,37 @@ class EventQueueGenericOutboxHandler extends EventQueueBaseClass {
 
   async processPeriodicEvent(processContext, key, queueEntry) {
     const [, action] = this.eventSubType.split(".");
-    const msg = new cds.Event({ event: action, eventQueue: { processor: this, key, queueEntries: [queueEntry] } });
-    await this.#setContextUser(processContext, config.userId, msg);
-    await this.__srvUnboxed.tx(processContext).emit(msg);
+    const reg = new cds.Event({ event: action, eventQueue: { processor: this, key, queueEntries: [queueEntry] } });
+    await this.#setContextUser(processContext, config.userId, reg);
+    await this.__srvUnboxed.tx(processContext).emit(reg);
   }
 
   #buildDispatchData(context, payload, { key, queueEntries } = {}) {
     const { useEventQueueUser } = this.eventConfig;
     const userId = useEventQueueUser ? config.userId : payload.contextUser;
-    const msg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
+    const reg = payload._fromSend ? new cds.Request(payload) : new cds.Event(payload);
     const invocationFn = payload._fromSend ? "send" : "emit";
-    delete msg._fromSend; // TODO: this changes the source object --> check after multiple invocations
-    delete msg.contextUser;
-    msg.eventQueue = { processor: this, key, queueEntries, payload };
-    return { msg, userId, invocationFn };
+    delete reg._fromSend;
+    delete reg.contextUser;
+    reg.eventQueue = { processor: this, key, queueEntries, payload };
+    return { reg, userId, invocationFn };
   }
 
-  async #setContextUser(context, userId, data) {
+  async #setContextUser(context, userId, reg) {
     context.user = new cds.User.Privileged({
       id: userId,
       tokenInfo: await common.getTokenInfo(this.baseContext.tenant),
     });
-    if (data) {
-      data.user = context.user;
+    if (reg) {
+      reg.user = context.user;
     }
   }
 
   async processEvent(processContext, key, queueEntries, payload) {
     try {
-      const { userId, invocationFn, msg } = this.#buildDispatchData(processContext, payload, { key, queueEntries });
-      await this.#setContextUser(processContext, userId, msg);
-      const result = await this.__srvUnboxed.tx(processContext)[invocationFn](msg);
+      const { userId, invocationFn, reg } = this.#buildDispatchData(processContext, payload, { key, queueEntries });
+      await this.#setContextUser(processContext, userId, reg);
+      const result = await this.__srvUnboxed.tx(processContext)[invocationFn](reg);
       return this.#determineResultStatus(result, queueEntries);
     } catch (err) {
       this.logger.error("error processing outboxed service call", err, {

package/src/shared/distributedLock.js

@@ -17,7 +17,7 @@ const acquireLock = async (
   if (config.redisEnabled) {
     return await _acquireLockRedis(context, fullKey, expiryTime, { keepTrackOfLock });
   } else {
-    return await _acquireLockDB(context, fullKey, expiryTime);
+    return await _acquireLockDB(context, fullKey, expiryTime, { keepTrackOfLock });
   }
 };
 
@@ -73,7 +73,7 @@ const _acquireLockRedis = async (
   context,
   fullKey,
   expiryTime,
-  { value = "true", overrideValue = false, keepTrackOfLock } = {}
+  { value = Date.now(), overrideValue = false, keepTrackOfLock } = {}
 ) => {
   const client = await redis.createMainClientAndConnect(config.redisOptions);
   const result = await client.set(fullKey, value, {
@@ -82,7 +82,7 @@ const _acquireLockRedis = async (
   });
   const isOk = result === REDIS_COMMAND_OK;
   if (isOk && keepTrackOfLock) {
-    existingLocks[fullKey] = 1;
+    existingLocks[fullKey] = context.tenant;
   }
   return isOk;
 };
@@ -108,7 +108,7 @@ const _renewLockRedis = async (context, fullKey, expiryTime, { value = "true" }
 
 const _checkLockExistsRedis = async (context, fullKey) => {
   const client = await redis.createMainClientAndConnect(config.redisOptions);
-  return await client.get(fullKey);
+  return await client.exists(fullKey);
 };
 
 const _checkLockExistsDb = async (context, fullKey) => {
@@ -129,9 +129,15 @@ const _releaseLockDb = async (context, fullKey) => {
   await cdsHelper.executeInNewTransaction(context, "distributedLock-release", async (tx) => {
     await tx.run(DELETE.from(config.tableNameEventLock).where("code =", fullKey));
   });
+  delete existingLocks[fullKey];
 };
 
-const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", overrideValue = false } = {}) => {
+const _acquireLockDB = async (
+  context,
+  fullKey,
+  expiryTime,
+  { value = "true", overrideValue = false, keepTrackOfLock } = {}
+) => {
   let result;
   await cdsHelper.executeInNewTransaction(context, "distributedLock-acquire", async (tx) => {
     try {
@@ -171,6 +177,9 @@ const _acquireLockDB = async (context, fullKey, expiryTime, { value = "true", ov
       }
     }
   });
+  if (result && keepTrackOfLock) {
+    existingLocks[fullKey] = context.tenant;
+  }
   return result;
 };
 
@@ -181,14 +190,60 @@ const _generateKey = (context, tenantScoped, key) => {
   return `${keyParts.join("##")}`;
 };
 
+const getAllLocksRedis = async () => {
+  const clientOrCluster = await redis.createMainClientAndConnect(config.redisOptions);
+  const output = [];
+  const results = [];
+
+  let clients;
+  if (redis.isClusterMode()) {
+    clients = clientOrCluster.masters.map((master) => master.client);
+  } else {
+    clients = [clientOrCluster];
+  }
+
+  // NOTE: use SCAN because KEYS is not supported for cluster clients
+  for (const client of clients) {
+    for await (const key of client.scanIterator({ MATCH: "EVENT*", COUNT: 1000 })) {
+      const [, tenant, guidOrType, subType] = key.split("##");
+      if (!subType) {
+        continue;
+      }
+
+      const pipeline = client.multi();
+      output.push({
+        tenant: tenant,
+        type: guidOrType,
+        subType: subType,
+      });
+      pipeline.ttl(key).get(key);
+      const replies = await pipeline.exec();
+      results.push(...replies);
+    }
+  }
+
+  let counter = 0;
+  for (const row of output) {
+    const ttl = results[counter];
+    const createdAt = results[counter + 1];
+    Object.assign(row, { ttl, createdAt });
+    counter = counter + 2;
+  }
+  return output;
+};
+
 const shutdownHandler = async () => {
   const logger = cds.log(COMPONENT_NAME);
   logger.info("received shutdown event, trying to release all locks", {
     numberOfLocks: Object.keys(existingLocks).length,
   });
   const result = await Promise.allSettled(
-    Object.keys(existingLocks).map(async (key) => {
-      await _releaseLockRedis(null, key);
+    Object.entries(existingLocks).map(async ([key, tenant]) => {
+      if (config.redisEnabled) {
+        await _releaseLockRedis({ tenant }, key);
+      } else {
+        await _releaseLockDb({ tenant }, key);
+      }
       logger.info("lock released", { key });
     })
   );
@@ -206,4 +261,5 @@ module.exports = {
   setValueWithExpire,
   shutdownHandler,
   renewLock,
+  getAllLocksRedis,
 };

package/src/shared/redis.js

@@ -178,6 +178,15 @@ const connectionCheck = async (options) => {
     });
 };
 
+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,
@@ -186,4 +195,5 @@ module.exports = {
   closeMainClient,
   closeSubscribeClient,
   connectionCheck,
+  isClusterMode,
 };

package/srv/service/admin-service.cds

@@ -22,6 +22,18 @@ service EventQueueAdminService {
       attempts: Integer) returns Event;
   }
 
+  @cds.persistence.skip
+  @readonly
+  entity Lock {
+    key tenant: String;
+    key type: String;
+    key subType: String;
+    landscape: String;
+    space: String;
+    ttl: Integer;
+    createdAt: Integer;
+  }
+
    @readonly
    @cds.persistence.skip
    entity Tenant {

package/srv/service/admin-service.js

@@ -4,10 +4,11 @@ const cds = require("@sap/cds");
 const cdsHelper = require("../../src/shared/cdsHelper");
 const { EventProcessingStatus } = require("../../src");
 const config = require("../../src/config");
+const distributedLock = require("../../src/shared/distributedLock");
 
 module.exports = class AdminService extends cds.ApplicationService {
   async init() {
-    const { Event: EventService, Tenant } = this.entities();
+    const { Event: EventService, Tenant, Lock: LockService } = this.entities();
     const { Event: EventDb } = cds.db.entities("sap.eventqueue");
     const { landscape, space } = this.getLandscapeAndSpace();
 
@@ -47,6 +48,18 @@ module.exports = class AdminService extends cds.ApplicationService {
       });
     });
 
+    this.on("READ", LockService, async () => {
+      if (!config.redisEnabled) {
+        return [];
+      }
+      const locks = await distributedLock.getAllLocksRedis();
+      return locks.map((lock) => ({
+        ...lock,
+        landscape: landscape,
+        space: space,
+      }));
+    });
+
     this.on("READ", Tenant, async () => {
       const tenants = await cdsHelper.getAllTenantWithSubdomain();
       return tenants ?? [];