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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/event-queue",
-  "version": "1.11.0-beta.0",
+  "version": "1.11.0-beta.2",
   "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

@@ -550,7 +550,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/shared/cdsHelper.js

@@ -123,7 +123,7 @@ const _getAllTenantBase = async () => {
 
   // NOTE: tmp workaround until cds-mtxs fixes the connect.to service
   for (let i = 0; i < 10; i++) {
-    if (cds.services["saas-registry"]) {
+    if (cds.services["cds.xt.SaasProvisioningService"] || cds.services["saas-registry"]) {
       break;
     }
     await new Promise((resolve) => setTimeout(resolve, 1000));

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;
 };
@@ -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,63 @@ const _generateKey = (context, tenantScoped, key) => {
   return `${keyParts.join("##")}`;
 };
 
+const getAllLocksRedis = async () => {
+  const client = await redis.createMainClientAndConnect(config.redisOptions);
+  const batchSize = 500;
+  const results = [];
+  let pipeline = client.multi();
+  const output = [];
+  let count = 0;
+
+  // NOTE: use SCAN because KEYS is not supported for cluster clients
+  for await (const key of client.scanIterator({ MATCH: "EVENT*", COUNT: 1000 })) {
+    const [, tenant, guidOrType, subType] = key.split("##");
+    if (!subType) {
+      continue;
+    }
+
+    output.push({
+      tenant: tenant,
+      type: guidOrType,
+      subType: subType,
+    });
+    pipeline.ttl(key).get(key);
+    count++;
+
+    if (count >= batchSize) {
+      const replies = await pipeline.exec();
+      results.push(...replies);
+      pipeline = client.multi();
+      count = 0;
+    }
+  }
+  if (count > 0) {
+    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 +264,5 @@ module.exports = {
   setValueWithExpire,
   shutdownHandler,
   renewLock,
+  getAllLocksRedis,
 };

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,14 +4,15 @@ 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();
 
-    this.before("*", async (req) => {
+    this.before("*", (req) => {
       if (!config.enableAdminService) {
         req.reject(403, "Admin service is disabled by configuration");
       }
@@ -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 ?? [];