@hotmeshio/hotmesh 0.0.36 → 0.0.38

package/build/services/store/index.js

@@ -99,10 +99,19 @@ class StoreService {
     invalidateCache() {
         this.cache.invalidate();
     }
-    async reserveEngineId(engineId) {
-        const key = this.mintKey(key_1.KeyType.ENGINE_ID, { engineId });
-        const success = await this.redisClient[this.commands.setnx](key, 'id', 1);
-        return this.isSuccessful(success);
+    /**
+     * At any given time only a single engine will
+     * check for and process work items in the
+     * time and signal task queues.
+     */
+    async reserveScoutRole(scoutType, delay = enums_1.SCOUT_INTERVAL_SECONDS) {
+        const key = this.mintKey(key_1.KeyType.WORK_ITEMS, { appId: this.appId, scoutType });
+        const success = await this.redisClient[this.commands.setnx](key, `${scoutType}:${(0, utils_1.formatISODate)(new Date())}`);
+        if (this.isSuccessful(success)) {
+            await this.redisClient[this.commands.expire](key, delay - 1);
+            return true;
+        }
+        return false;
     }
     async getSettings(bCreate = false) {
         let settings = this.cache?.getSettings();
@@ -304,11 +313,11 @@ class StoreService {
      * list (added via RPUSH) are LPOPed. If origin was expired, then
      * LPOPed items from the list are likewise expired;
      */
-    async setDependency(originJobId, topic, jobId, multi) {
+    async setDependency(originJobId, topic, jobId, gId, multi) {
         const privateMulti = multi || this.getMulti();
         const depParams = { appId: this.appId, jobId: originJobId };
         const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, depParams);
-        privateMulti[this.commands.rpush](depKey, `expire::${topic}::${jobId}`);
+        privateMulti[this.commands.rpush](depKey, `expire::${topic}::${gId}::${jobId}`);
         if (!multi) {
             return await privateMulti.exec();
         }
@@ -682,9 +691,9 @@ class StoreService {
      * for the given sleep group. Sleep groups are
      * organized into 'n'-second blocks (LISTS))
      */
-    async registerTimeHook(jobId, activityId, type, deletionTime, multi) {
+    async registerTimeHook(jobId, gId, activityId, type, deletionTime, multi) {
         const listKey = this.mintKey(key_1.KeyType.TIME_RANGE, { appId: this.appId, timeValue: deletionTime });
-        const timeEvent = `${type}::${activityId}::${jobId}`;
+        const timeEvent = `${type}::${activityId}::${gId}::${jobId}`;
         const len = await (multi || this.redisClient)[this.commands.rpush](listKey, timeEvent);
         if (multi || len === 1) {
             const zsetKey = this.mintKey(key_1.KeyType.TIME_RANGE, { appId: this.appId });
@@ -692,6 +701,7 @@ class StoreService {
         }
     }
     async getNextTimeJob(listKey) {
+        const existing = Boolean(listKey);
         const zsetKey = this.mintKey(key_1.KeyType.TIME_RANGE, { appId: this.appId });
         listKey = listKey || await this.zRangeByScore(zsetKey, 0, Date.now());
         if (listKey) {
@@ -699,11 +709,12 @@ class StoreService {
             const timeEvent = await this.redisClient[this.commands.lpop](pKey);
             if (timeEvent) {
                 //there are 3 time-related event triggers: sleep, expire, interrupt
-                const [_type, activityId, ...jobId] = timeEvent.split('::');
-                return [listKey, jobId.join('::'), activityId, pType];
+                const [_type, activityId, gId, ...jobId] = timeEvent.split('::');
+                return [listKey, jobId.join('::'), gId, activityId, pType];
             }
             await this.redisClient[this.commands.zrem](zsetKey, listKey);
         }
+        return existing;
     }
     /**
      * when processing time jobs, the target LIST ID returned

package/build/services/stream/clients/ioredis.d.ts

@@ -19,5 +19,6 @@ declare class IORedisStreamService extends StreamService<RedisClientType, RedisM
     xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
     xack(key: string, group: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
     xdel(key: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+    xlen(key: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
 }
 export { IORedisStreamService };

package/build/services/stream/clients/ioredis.js

@@ -25,18 +25,18 @@ class IORedisStreamService extends index_1.StreamService {
             try {
                 return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
             }
-            catch (err) {
+            catch (error) {
                 this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
-                throw err;
+                throw error;
             }
         }
         else {
             try {
                 return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
             }
-            catch (err) {
+            catch (error) {
                 this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
-                throw err;
+                throw error;
             }
         }
     }
@@ -44,9 +44,9 @@ class IORedisStreamService extends index_1.StreamService {
         try {
             return await (multi || this.redisClient).xadd(key, id, messageId, messageValue);
         }
-        catch (err) {
-            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, { error });
+            throw error;
         }
     }
     async xreadgroup(command, groupName, consumerName, blockOption, blockTime, streamsOption, streamName, id) {
@@ -56,9 +56,9 @@ class IORedisStreamService extends index_1.StreamService {
             // @ts-ignore
             blockOption, blockTime, streamsOption, streamName, id);
         }
-        catch (err) {
-            this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, { error });
+            throw error;
         }
     }
     async xpending(key, group, start, end, count, consumer) {
@@ -75,40 +75,49 @@ class IORedisStreamService extends index_1.StreamService {
             try {
                 return await this.redisClient.call('XPENDING', ...args);
             }
-            catch (err) {
-                this.logger.error('err, args', err, args);
+            catch (error) {
+                this.logger.error('err, args', { error }, args);
             }
         }
-        catch (err) {
-            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, { error });
+            throw error;
         }
     }
     async xclaim(key, group, consumer, minIdleTime, id, ...args) {
         try {
             return await this.redisClient.xclaim(key, group, consumer, minIdleTime, id, ...args);
         }
-        catch (err) {
-            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, { error });
+            throw error;
         }
     }
     async xack(key, group, id, multi) {
         try {
             return await (multi || this.redisClient).xack(key, group, id);
         }
-        catch (err) {
-            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, { error });
+            throw error;
         }
     }
     async xdel(key, id, multi) {
         try {
             return await (multi || this.redisClient).xdel(key, id);
         }
-        catch (err) {
-            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async xlen(key, multi) {
+        try {
+            return await (multi || this.redisClient).xlen(key);
+        }
+        catch (error) {
+            this.logger.error(`Error getting stream depth: ${key}`, { error });
+            throw error;
         }
     }
 }

package/build/services/stream/clients/redis.d.ts

@@ -19,5 +19,6 @@ declare class RedisStreamService extends StreamService<RedisClientType, RedisMul
     xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
     xack(key: string, group: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
     xdel(key: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+    xlen(key: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
 }
 export { RedisStreamService };

package/build/services/stream/clients/redis.js

@@ -115,5 +115,20 @@ class RedisStreamService extends index_1.StreamService {
             throw err;
         }
     }
+    async xlen(key, multi) {
+        try {
+            if (multi) {
+                multi.XLEN(key);
+                return multi;
+            }
+            else {
+                return await this.redisClient.XLEN(key);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error getting stream depth: ${key}`, { error });
+            throw error;
+        }
+    }
 }
 exports.RedisStreamService = RedisStreamService;

package/build/services/stream/index.d.ts

@@ -17,5 +17,6 @@ declare abstract class StreamService<T, U> {
     abstract xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
     abstract xack(key: string, group: string, id: string, multi?: U): Promise<number | U>;
     abstract xdel(key: string, id: string, multi?: U): Promise<number | U>;
+    abstract xlen(key: string, multi?: U): Promise<number | U>;
 }
 export { StreamService };

package/build/services/task/index.d.ts

@@ -1,19 +1,28 @@
 /// <reference types="node" />
 import { ILogger } from '../logger';
 import { StoreService } from '../store';
-import { HookInterface } from '../../types/hook';
-import { JobCompletionOptions } from '../../types/job';
+import { HookInterface, HookRule } from '../../types/hook';
+import { JobCompletionOptions, JobState } from '../../types/job';
 import { RedisClient, RedisMulti } from '../../types/redis';
 declare class TaskService {
     store: StoreService<RedisClient, RedisMulti>;
     logger: ILogger;
     cleanupTimeout: NodeJS.Timeout | null;
+    isScout: boolean;
     constructor(store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
     processWebHooks(hookEventCallback: HookInterface): Promise<void>;
     enqueueWorkItems(keys: string[]): Promise<void>;
     registerJobForCleanup(jobId: string, inSeconds: number, options: JobCompletionOptions): Promise<void>;
-    registerTimeHook(jobId: string, activityId: string, type: 'sleep' | 'expire' | 'interrupt', inSeconds?: number, multi?: RedisMulti): Promise<void>;
-    processTimeHooks(timeEventCallback: (jobId: string, activityId: string, type: 'sleep' | 'expire' | 'interrupt') => Promise<void>, listKey?: string): Promise<void>;
+    registerTimeHook(jobId: string, gId: string, activityId: string, type: 'sleep' | 'expire' | 'interrupt', inSeconds?: number, multi?: RedisMulti): Promise<void>;
+    /**
+     * Should this engine instance play the role of 'scout' for the quorum.
+     */
+    shouldScout(): Promise<boolean>;
+    processTimeHooks(timeEventCallback: (jobId: string, gId: string, activityId: string, type: 'sleep' | 'expire' | 'interrupt') => Promise<void>, listKey?: string): Promise<void>;
     cancelCleanup(): void;
+    getHookRule(topic: string): Promise<HookRule | undefined>;
+    registerWebHook(topic: string, context: JobState, dad: string, multi?: RedisMulti): Promise<string>;
+    processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<[string, string, string, string] | undefined>;
+    deleteWebHookSignal(topic: string, data: Record<string, unknown>): Promise<number>;
 }
 export { TaskService };

package/build/services/task/index.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskService = void 0;
 const enums_1 = require("../../modules/enums");
 const utils_1 = require("../../modules/utils");
+const pipe_1 = require("../pipe");
 class TaskService {
     constructor(store, logger) {
         this.cleanupTimeout = null;
+        this.isScout = false;
         this.logger = logger;
         this.store = store;
     }
@@ -36,29 +38,61 @@ class TaskService {
             await this.store.registerExpireJob(jobId, expireTimeSlot, options);
         }
     }
-    async registerTimeHook(jobId, activityId, type, inSeconds = enums_1.FIDELITY_SECONDS, multi) {
+    async registerTimeHook(jobId, gId, activityId, type, inSeconds = enums_1.FIDELITY_SECONDS, multi) {
         const awakenTimeSlot = Math.floor((Date.now() + (inSeconds * 1000)) / (enums_1.FIDELITY_SECONDS * 1000)) * (enums_1.FIDELITY_SECONDS * 1000); //n second awaken groups
-        await this.store.registerTimeHook(jobId, activityId, type, awakenTimeSlot, multi);
+        await this.store.registerTimeHook(jobId, gId, activityId, type, awakenTimeSlot, multi);
+    }
+    /**
+     * Should this engine instance play the role of 'scout' for the quorum.
+     */
+    async shouldScout() {
+        const wasScout = this.isScout;
+        const isScout = wasScout || (this.isScout = await this.store.reserveScoutRole('time'));
+        if (isScout) {
+            if (!wasScout) {
+                setTimeout(() => {
+                    this.isScout = false;
+                }, enums_1.SCOUT_INTERVAL_SECONDS * 1000);
+            }
+            return true;
+        }
+        return false;
     }
     async processTimeHooks(timeEventCallback, listKey) {
-        try {
-            const timeJob = await this.store.getNextTimeJob(listKey);
-            if (timeJob) {
-                const [listKey, jobId, activityId, type] = timeJob;
-                await timeEventCallback(jobId, activityId, type);
-                await (0, utils_1.sleepFor)(0);
-                this.processTimeHooks(timeEventCallback, listKey);
+        if (await this.shouldScout()) {
+            try {
+                const timeJob = await this.store.getNextTimeJob(listKey);
+                if (Array.isArray(timeJob)) {
+                    //a queue had a job; try again immediately
+                    const [listKey, jobId, gId, activityId, type] = timeJob;
+                    await timeEventCallback(jobId, gId, activityId, type);
+                    await (0, utils_1.sleepFor)(0);
+                    this.processTimeHooks(timeEventCallback, listKey);
+                }
+                else if (timeJob) {
+                    //a queue was just emptied; try again immediately
+                    await (0, utils_1.sleepFor)(0);
+                    this.processTimeHooks(timeEventCallback);
+                }
+                else {
+                    //all queues are empty; sleep before checking
+                    let sleep = (0, utils_1.XSleepFor)(enums_1.FIDELITY_SECONDS * 1000);
+                    this.cleanupTimeout = sleep.timerId;
+                    await sleep.promise;
+                    this.processTimeHooks(timeEventCallback);
+                }
             }
-            else {
-                let sleep = (0, utils_1.XSleepFor)(enums_1.FIDELITY_SECONDS * 1000);
-                this.cleanupTimeout = sleep.timerId;
-                await sleep.promise;
-                this.processTimeHooks(timeEventCallback);
+            catch (err) {
+                //todo: retry connect to redis
+                this.logger.error('task-process-timehooks-error', err);
             }
         }
-        catch (err) {
-            //todo: retry connect to redis
-            this.logger.error('task-process-timehooks-error', err);
+        else {
+            //didn't get the scout role; try again in 'one-ish' minutes
+            let sleep = (0, utils_1.XSleepFor)(enums_1.SCOUT_INTERVAL_SECONDS * 1000 * 2 * Math.random());
+            this.cleanupTimeout = sleep.timerId;
+            await sleep.promise;
+            this.processTimeHooks(timeEventCallback);
         }
     }
     cancelCleanup() {
@@ -67,5 +101,69 @@ class TaskService {
             this.cleanupTimeout = undefined;
         }
     }
+    async getHookRule(topic) {
+        const rules = await this.store.getHookRules();
+        return rules?.[topic]?.[0];
+    }
+    async registerWebHook(topic, context, dad, multi) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            const mapExpression = hookRule.conditions.match[0].expected;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            const jobId = context.metadata.jid;
+            const gId = context.metadata.gid;
+            const activityId = hookRule.to;
+            const hook = {
+                topic,
+                resolved,
+                jobId: `${activityId}::${dad}::${gId}::${jobId}`,
+            };
+            await this.store.setHookSignal(hook, multi);
+            return jobId;
+        }
+        else {
+            throw new Error('signaler.registerWebHook:error: hook rule not found');
+        }
+    }
+    async processWebHookSignal(topic, data) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            //NOTE: both formats are supported by the mapping engine:
+            //      `$self.hook.data` OR `$hook.data`
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            const hookSignalId = await this.store.getHookSignal(topic, resolved);
+            if (!hookSignalId) {
+                //messages can be double-processed; not an issue; return undefined
+                //users can also provide a bogus topic; not an issue; return undefined
+                return undefined;
+            }
+            //`aid` is part of composit key, but the hook `topic` is its public interface;
+            // this means that a new version of the graph can be deployed and the
+            // topic can be re-mapped to a different activity id. Outside callers
+            // can adhere to the unchanged contract (calling the same topic),
+            // while the internal system can be updated in real time as necessary.
+            const [_aid, dad, gid, ...jid] = hookSignalId.split('::');
+            return [jid.join('::'), hookRule.to, dad, gid];
+        }
+        else {
+            throw new Error('signal-not-found');
+        }
+    }
+    async deleteWebHookSignal(topic, data) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            //NOTE: both formats are supported by the mapping engine:
+            //      `$self.hook.data` OR `$hook.data`
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            return await this.store.deleteHookSignal(topic, resolved);
+        }
+        else {
+            throw new Error('signaler.process:error: hook rule not found');
+        }
+    }
 }
 exports.TaskService = TaskService;

package/build/services/telemetry/index.js

@@ -93,17 +93,17 @@ class TelemetryService {
                     return result;
                 }, {})
             };
-            this.span.setAttributes(namespacedAtts);
+            this.span?.setAttributes(namespacedAtts);
         }
     }
     setActivityAttributes(attributes) {
-        this.span.setAttributes(attributes);
+        this.span?.setAttributes(attributes);
     }
     setStreamAttributes(attributes) {
-        this.span.setAttributes(attributes);
+        this.span?.setAttributes(attributes);
     }
     setJobAttributes(attributes) {
-        this.jobSpan.setAttributes(attributes);
+        this.jobSpan?.setAttributes(attributes);
     }
     endJobSpan() {
         this.endSpan(this.jobSpan);
@@ -174,10 +174,10 @@ class TelemetryService {
         }
     }
     setActivityError(message) {
-        this.span.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
+        this.span?.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
     }
     setStreamError(message) {
-        this.span.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
+        this.span?.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
     }
     /**
      * Adds the paths (HGET) necessary to restore telemetry state for an activity

package/build/services/worker/index.d.ts

@@ -1,5 +1,5 @@
 import { ILogger } from "../logger";
-import { StreamSignaler } from "../signaler/stream";
+import { Router } from "../router";
 import { StoreService } from '../store';
 import { StreamService } from '../stream';
 import { SubService } from '../sub';
@@ -15,7 +15,7 @@ declare class WorkerService {
     store: StoreService<RedisClient, RedisMulti> | null;
     stream: StreamService<RedisClient, RedisMulti> | null;
     subscribe: SubService<RedisClient, RedisMulti> | null;
-    streamSignaler: StreamSignaler | null;
+    router: Router | null;
     logger: ILogger;
     reporting: boolean;
     static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, logger: ILogger): Promise<WorkerService[]>;
@@ -23,8 +23,9 @@ declare class WorkerService {
     initStoreChannel(service: WorkerService, store: RedisClient): Promise<void>;
     initSubChannel(service: WorkerService, sub: RedisClient): Promise<void>;
     initStreamChannel(service: WorkerService, stream: RedisClient): Promise<void>;
-    initStreamSignaler(worker: HotMeshWorker, logger: ILogger): StreamSignaler;
+    initRouter(worker: HotMeshWorker, logger: ILogger): Router;
     subscriptionHandler(): SubscriptionCallback;
+    sayPong(appId: string, guid: string, originator: string, details?: boolean): Promise<void>;
     throttle(delayInMillis: number): Promise<void>;
 }
 export { WorkerService };

package/build/services/worker/index.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerService = void 0;
 const key_1 = require("../../modules/key");
-const stream_1 = require("../signaler/stream");
+const router_1 = require("../router");
 const redis_1 = require("../store/clients/redis");
 const ioredis_1 = require("../store/clients/ioredis");
 const redis_2 = require("../stream/clients/redis");
 const ioredis_2 = require("../stream/clients/ioredis");
 const ioredis_3 = require("../sub/clients/ioredis");
 const redis_3 = require("../sub/clients/redis");
-const stream_2 = require("../../types/stream");
+const stream_1 = require("../../types/stream");
 const utils_1 = require("../../modules/utils");
 const connector_1 = require("../connector");
 class WorkerService {
@@ -35,9 +35,9 @@ class WorkerService {
                 await service.subscribe.subscribe(key_1.KeyType.QUORUM, service.subscriptionHandler(), appId, service.topic);
                 await service.subscribe.subscribe(key_1.KeyType.QUORUM, service.subscriptionHandler(), appId, service.guid);
                 await service.initStreamChannel(service, worker.stream);
-                service.streamSignaler = service.initStreamSignaler(worker, logger);
+                service.router = service.initRouter(worker, logger);
                 const key = service.stream.mintKey(key_1.KeyType.STREAMS, { appId: service.appId, topic: worker.topic });
-                await service.streamSignaler.consumeMessages(key, 'WORKER', service.guid, worker.callback);
+                await service.router.consumeMessages(key, 'WORKER', service.guid, worker.callback);
                 services.push(service);
             }
         }
@@ -78,12 +78,12 @@ class WorkerService {
         }
         await service.stream.init(service.namespace, service.appId, service.logger);
     }
-    initStreamSignaler(worker, logger) {
-        return new stream_1.StreamSignaler({
+    initRouter(worker, logger) {
+        return new router_1.Router({
             namespace: this.namespace,
             appId: this.appId,
             guid: this.guid,
-            role: stream_2.StreamRole.WORKER,
+            role: stream_1.StreamRole.WORKER,
             topic: worker.topic,
             reclaimDelay: worker.reclaimDelay,
             reclaimCount: worker.reclaimCount,
@@ -96,10 +96,34 @@ class WorkerService {
             if (message.type === 'throttle') {
                 self.throttle(message.throttle);
             }
+            else if (message.type === 'ping') {
+                self.sayPong(self.appId, self.guid, message.originator, message.details);
+            }
         };
     }
+    async sayPong(appId, guid, originator, details = false) {
+        let profile;
+        if (details) {
+            const params = {
+                appId: this.appId,
+                topic: this.topic,
+            };
+            profile = {
+                engine_id: this.guid,
+                namespace: this.namespace,
+                app_id: this.appId,
+                worker_topic: this.topic,
+                stream: this.stream.mintKey(key_1.KeyType.STREAMS, params),
+            };
+        }
+        this.store.publish(key_1.KeyType.QUORUM, {
+            type: 'pong',
+            guid, originator,
+            profile,
+        }, appId);
+    }
     async throttle(delayInMillis) {
-        this.streamSignaler.setThrottle(delayInMillis);
+        this.router.setThrottle(delayInMillis);
     }
 }
 exports.WorkerService = WorkerService;

package/build/types/job.d.ts

@@ -6,10 +6,12 @@ type ActivityData = {
 };
 type JobMetadata = {
     key?: string;
+    gid: string;
     jid: string;
     dad: string;
     aid: string;
     pj?: string;
+    pg?: string;
     pd?: string;
     pa?: string;
     ngn?: string;

package/build/types/quorum.d.ts

@@ -1,7 +1,16 @@
 import { JobOutput } from "./job";
+export interface QuorumProfile {
+    namespace: string;
+    app_id: string;
+    engine_id: string;
+    worker_topic?: string;
+    stream?: string;
+    stream_depth?: number;
+}
 export interface PingMessage {
     type: 'ping';
     originator: string;
+    details?: boolean;
 }
 export interface WorkMessage {
     type: 'work';
@@ -13,8 +22,9 @@ export interface CronMessage {
 }
 export interface PongMessage {
     type: 'pong';
-    originator: string;
     guid: string;
+    originator: string;
+    profile?: QuorumProfile;
 }
 export interface ActivateMessage {
     type: 'activate';

package/build/types/redisclient.d.ts

@@ -4,6 +4,7 @@ interface RedisMultiType {
     XADD(key: string, id: string, fields: any): this;
     XACK(key: string, group: string, id: string): this;
     XDEL(key: string, id: string): this;
+    XLEN(key: string): this;
     HDEL(key: string, itemId: string): this;
     HGET(key: string, itemId: string): this;
     HGETALL(key: string): this;

package/build/types/stream.d.ts

@@ -31,6 +31,7 @@ export interface StreamData {
         guid: string;
         topic?: string;
         jid?: string;
+        gid?: string;
         dad?: string;
         aid: string;
         trc?: string;

package/modules/enums.ts

@@ -30,3 +30,6 @@ export const FIDELITY_SECONDS = process.env.NODE_ENV === 'test' ? TEST_FIDELITY_
 
 // DURABLE CONSTANTS
 export const DURABLE_EXPIRE_SECONDS = 1;
+
+// TASK CONSTANTS
+export const SCOUT_INTERVAL_SECONDS = 60;