@hotmeshio/hotmesh 0.0.35 → 0.0.37

package/services/activities/hook.ts

@@ -1,9 +1,12 @@
-import { GetStateError, InactiveJobError } from '../../modules/errors';
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
 import { Pipe } from '../pipe';
-import { StoreSignaler } from '../signaler/store';
+import { TaskService } from '../task';
 import { TelemetryService } from '../telemetry';
 import { 
   ActivityData,
@@ -19,7 +22,7 @@ import { StringScalarType } from '../../types/serializer';
 import { StreamCode, StreamStatus } from '../../types/stream';
 
 /**
- * Listens for `webhook`, `timehook`, and `cycle` (repeat) signals
+ * Supports `signal hook`, `time hook`, and `cycle hook` patterns
  */
 class Hook extends Activity {
   config: HookActivity;
@@ -36,48 +39,25 @@ class Hook extends Activity {
 
   //********  INITIAL ENTRY POINT (A)  ********//
   async process(): Promise<string> {
-    this.logger.debug('hook-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('hook-process', {
+      jid: this.context.metadata.jid,
+      gid: this.context.metadata.gid,
+      aid: this.metadata.aid,
+    });
     let telemetry: TelemetryService;
+
     try {
-      this.setLeg(1);
-      await CollatorService.notarizeEntry(this);
+      await this.verifyEntry();
 
-      await this.getState();
-      CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startActivitySpan(this.leg);
-      let multiResponse: MultiResponseFlags;
 
-      const multi = this.store.getMulti();
       if (this.doesHook()) {
         //sleep and wait to awaken upon a signal
-        await this.registerHook(multi);
-        this.mapOutputData();
-        this.mapJobData();
-        await this.setState(multi);
-        await CollatorService.authorizeReentry(this, multi);
-
-        await this.setStatus(0, multi);
-        await multi.exec();
-        telemetry.mapActivityAttributes();
+        await this.doHook(telemetry);
       } else {
         //end the activity and transition to its children
-        this.adjacencyList = await this.filterAdjacent();
-        this.mapOutputData();
-        this.mapJobData();
-        await this.setState(multi);
-        await CollatorService.notarizeEarlyCompletion(this, multi);
-
-        await this.setStatus(this.adjacencyList.length - 1, multi);
-        multiResponse = await multi.exec() as MultiResponseFlags;
-        telemetry.mapActivityAttributes();
-        const jobStatus = this.resolveStatus(multiResponse);
-        const attrs: StringScalarType = { 'app.job.jss': jobStatus };
-        const messageIds = await this.transition(this.adjacencyList, jobStatus);
-        if (messageIds.length) {
-          attrs['app.activity.mids'] = messageIds.join(',')
-        }
-        telemetry.setActivityAttributes(attrs);
+        await this.doPassThrough(telemetry);
       }
 
       return this.context.metadata.aid;
@@ -85,6 +65,9 @@ class Hook extends Activity {
       if (error instanceof InactiveJobError) {
         this.logger.error('hook-inactive-job-error', { error });
         return;
+      } else if (error instanceof GenerationalError) {
+        this.logger.info('process-event-generational-job-error', { error });
+        return;
       } else if (error instanceof GetStateError) {
         this.logger.error('hook-get-state-error', { error });
         return;
@@ -95,16 +78,52 @@ class Hook extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('hook-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('hook-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
-  //********  SIGNAL RE-ENTRY POINT  ********//
+  /**
+   * does this activity use a time-hook or web-hook
+   */
   doesHook(): boolean {
-    //does this activity use a time-hook or web-hook
     return !!(this.config.hook?.topic || this.config.sleep);
   }
 
+  async doHook(telemetry: TelemetryService) {
+    const multi = this.store.getMulti();
+    await this.registerHook(multi);
+    this.mapOutputData();
+    this.mapJobData();
+    await this.setState(multi);
+    await CollatorService.authorizeReentry(this, multi);
+
+    await this.setStatus(0, multi);
+    await multi.exec();
+    telemetry.mapActivityAttributes();
+  }
+
+  async doPassThrough(telemetry: TelemetryService) {
+    const multi = this.store.getMulti();
+    let multiResponse: MultiResponseFlags;
+    
+    this.adjacencyList = await this.filterAdjacent();
+    this.mapOutputData();
+    this.mapJobData();
+    await this.setState(multi);
+    await CollatorService.notarizeEarlyCompletion(this, multi);
+
+    await this.setStatus(this.adjacencyList.length - 1, multi);
+    multiResponse = await multi.exec() as MultiResponseFlags;
+    telemetry.mapActivityAttributes();
+    const jobStatus = this.resolveStatus(multiResponse);
+    const attrs: StringScalarType = { 'app.job.jss': jobStatus };
+    const messageIds = await this.transition(this.adjacencyList, jobStatus);
+    if (messageIds.length) {
+      attrs['app.activity.mids'] = messageIds.join(',')
+    }
+    telemetry.setActivityAttributes(attrs);
+  }
+
   async getHookRule(topic: string): Promise<HookRule | undefined> {
     const rules = await this.store.getHookRules();
     return rules?.[topic]?.[0] as HookRule;
@@ -112,18 +131,20 @@ class Hook extends Activity {
 
   async registerHook(multi?: RedisMulti): Promise<string | void> {
     if (this.config.hook?.topic) {
-      const signaler = new StoreSignaler(this.store, this.logger);
-      return await signaler.registerWebHook(this.config.hook.topic, this.context, this.resolveDad(), multi);
+      const taskService = new TaskService(this.store, this.logger);
+      return await taskService.registerWebHook(this.config.hook.topic, this.context, this.resolveDad(), multi);
     } else if (this.config.sleep) {
       const durationInSeconds = Pipe.resolve(this.config.sleep, this.context);
       const jobId = this.context.metadata.jid;
+      const gId = this.context.metadata.gid;
       const activityId = this.metadata.aid;
       const dId = this.metadata.dad;
-      await this.engine.task.registerTimeHook(jobId, `${activityId}${dId||''}`, 'sleep', durationInSeconds);
+      await this.engine.taskService.registerTimeHook(jobId, gId, `${activityId}${dId||''}`, 'sleep', durationInSeconds);
       return jobId;
     }
   }
 
+  //********  SIGNAL RE-ENTRY POINT  ********//
   async processWebHookEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200): Promise<JobStatus | void> {
     this.logger.debug('hook-process-web-hook-event', {
       topic: this.config.hook.topic,
@@ -131,23 +152,25 @@ class Hook extends Activity {
       status,
       code,
     });
-    const signaler = new StoreSignaler(this.store, this.logger);
+    const taskService = new TaskService(this.store, this.logger);
     const data = { ...this.data };
-    const signal = await signaler.processWebHookSignal(this.config.hook.topic, data);
+    const signal = await taskService.processWebHookSignal(this.config.hook.topic, data);
     if (signal) {
-      const [jobId, aid, dad] = signal;
+      const [jobId, _aid, dad, gId] = signal;
       this.context.metadata.jid = jobId;
+      this.context.metadata.gid = gId;
       this.context.metadata.dad = dad;
       await this.processEvent(status, code, 'hook');
-      if (code === 200) { //otherwise 202 for pending/keepalive
-        await signaler.deleteWebHookSignal(this.config.hook.topic, data);
-      }
+      if (code === 200) {
+        await taskService.deleteWebHookSignal(this.config.hook.topic, data);
+      } //else => 202/keep alive
     } //else => already resolved
   }
 
   async processTimeHookEvent(jobId: string): Promise<JobStatus | void> {
     this.logger.debug('hook-process-time-hook-event', {
       jid: jobId,
+      gid: this.context.metadata.gid,
       aid: this.metadata.aid
     });
     await this.processEvent(StreamStatus.SUCCESS, 200, 'hook');

package/services/activities/interrupt.ts

@@ -1,10 +1,13 @@
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { EngineService } from '../engine';
 import { Activity, ActivityType } from './activity';
 import {
   ActivityData,
   ActivityMetadata,
   InterruptActivity } from '../../types/activity';
-import { GetStateError, InactiveJobError } from '../../modules/errors';
 import { MultiResponseFlags } from '../../types';
 import { CollatorService } from '../collator';
 import { JobInterruptOptions, JobState } from '../../types/job';
@@ -28,25 +31,26 @@ class Interrupt extends Activity {
 
   //********  LEG 1 ENTRY  ********//
   async process(): Promise<string> {
-    this.logger.debug('interrupt-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('interrupt-process', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     let telemetry: TelemetryService;
     try {
-      this.setLeg(1);
-      await CollatorService.notarizeEntry(this);
-      await this.getState();
-      CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid); // Ensure job active
+      await this.verifyEntry();
+
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startActivitySpan(this.leg);
   
       if (this.isInterruptingSelf()) {
-        return await this.interruptSelf(telemetry);
+        await this.interruptSelf(telemetry);
       } else {
-        return await this.interruptAnother(telemetry);
+        await this.interruptAnother(telemetry);
       }
     } catch (error) {
       if (error instanceof InactiveJobError) {
         this.logger.error('interrupt-inactive-job-error', { error });
         return;
+      } else if (error instanceof GenerationalError) {
+        this.logger.info('process-event-generational-job-error', { error });
+        return;
       } else if (error instanceof GetStateError) {
         this.logger.error('interrupt-get-state-error', { error });
         return;
@@ -57,7 +61,7 @@ class Interrupt extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('interrupt-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('interrupt-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
@@ -118,7 +122,6 @@ class Interrupt extends Activity {
   
     return this.context.metadata.aid;
   }
-  
 
   isInterruptingSelf(): boolean {
     if (!this.config.target) {

package/services/activities/signal.ts

@@ -1,4 +1,7 @@
-import { GetStateError, InactiveJobError } from '../../modules/errors';
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { Activity, ActivityType } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
@@ -30,14 +33,11 @@ class Signal extends Activity {
 
   //********  LEG 1 ENTRY  ********//
   async process(): Promise<string> {
-    this.logger.debug('signal-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('signal-process', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     let telemetry: TelemetryService;
     try {
-      //verify entry is allowed
-      this.setLeg(1);
-      await CollatorService.notarizeEntry(this);
-      await this.getState();
-      CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
+      await this.verifyEntry();
+
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startActivitySpan(this.leg);
 
@@ -73,6 +73,9 @@ class Signal extends Activity {
       if (error instanceof InactiveJobError) {
         this.logger.error('signal-inactive-job-error', { error });
         return;
+      } else if (error instanceof GenerationalError) {
+        this.logger.info('process-event-generational-job-error', { error });
+        return;
       } else if (error instanceof GetStateError) {
         this.logger.error('signal-get-state-error', { error });
         return;
@@ -83,7 +86,7 @@ class Signal extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('signal-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('signal-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 

package/services/activities/trigger.ts

@@ -35,6 +35,7 @@ class Trigger extends Activity {
     try {
       this.setLeg(2);
       await this.getState();
+
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startJobSpan();
       telemetry.startActivitySpan(this.leg);
@@ -70,7 +71,7 @@ class Trigger extends Activity {
     } finally {
       telemetry?.endJobSpan();
       telemetry?.endActivitySpan();
-      this.logger.debug('trigger-process-end', { subscribes: this.config.subscribes, jid: this.context.metadata.jid });
+      this.logger.debug('trigger-process-end', { subscribes: this.config.subscribes, jid: this.context.metadata.jid, gid: this.context.metadata.gid });
     }
   }
 
@@ -108,8 +109,10 @@ class Trigger extends Activity {
     this.context = {
       metadata: {
         ...this.metadata,
+        gid: guid(),
         ngn: this.context.metadata.ngn,
         pj: this.context.metadata.pj,
+        pg: this.context.metadata.pg,
         pd: this.context.metadata.pd,
         pa: this.context.metadata.pa,
         app: id,
@@ -187,6 +190,7 @@ class Trigger extends Activity {
         resolvedDepKey,
         this.context.metadata.tpc,
         this.context.metadata.jid,
+        this.context.metadata.gid,
         multi,
       );
     }

package/services/activities/worker.ts

@@ -1,4 +1,7 @@
-import { GetStateError, InactiveJobError } from '../../modules/errors';
+import {
+  GenerationalError,
+  GetStateError,
+  InactiveJobError } from '../../modules/errors';
 import { Activity } from './activity';
 import { CollatorService } from '../collator';
 import { EngineService } from '../engine';
@@ -29,14 +32,11 @@ class Worker extends Activity {
 
   //********  INITIAL ENTRY POINT (A)  ********//
   async process(): Promise<string> {
-    this.logger.debug('worker-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+    this.logger.debug('worker-process', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     let telemetry: TelemetryService;
     try {
-      //confirm entry is allowed and restore state
-      this.setLeg(1);
-      await CollatorService.notarizeEntry(this);
-      await this.getState();
-      CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
+      await this.verifyEntry();
+
       telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
       telemetry.startActivitySpan(this.leg);
       this.mapInputData();
@@ -63,6 +63,9 @@ class Worker extends Activity {
       if (error instanceof InactiveJobError) {
         this.logger.error('await-inactive-job-error', { error });
         return;
+      } else if (error instanceof GenerationalError) {
+        this.logger.info('process-event-generational-job-error', { error });
+        return;
       } else if (error instanceof GetStateError) {
         this.logger.error('worker-get-state-error', { error });
         return;
@@ -73,7 +76,7 @@ class Worker extends Activity {
       throw error;
     } finally {
       telemetry?.endActivitySpan();
-      this.logger.debug('worker-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+      this.logger.debug('worker-process-end', { jid: this.context.metadata.jid, gid: this.context.metadata.gid, aid: this.metadata.aid });
     }
   }
 
@@ -83,6 +86,7 @@ class Worker extends Activity {
       metadata: {
         guid: guid(),
         jid: this.context.metadata.jid,
+        gid: this.context.metadata.gid,
         dad: this.metadata.dad,
         aid: this.metadata.aid,
         topic,
@@ -96,7 +100,7 @@ class Worker extends Activity {
         retry: this.config.retry
       };
     }
-    return (await this.engine.streamSignaler?.publishMessage(topic, streamData, multi)) as string;
+    return (await this.engine.router?.publishMessage(topic, streamData, multi)) as string;
   }
 }
 

package/services/durable/meshos.ts

@@ -1,5 +1,5 @@
 import { Durable } from '.';
-import { asyncLocalStorage } from './asyncLocalStorage';
+import { asyncLocalStorage } from '../../modules/storage';
 import { ClientService as Client } from './client';
 import { WorkflowHandleService } from './handle';
 import { Search } from './search';

package/services/durable/worker.ts

@@ -7,7 +7,7 @@ import {
   DurableSleepForError,
   DurableTimeoutError, 
   DurableWaitForSignalError} from '../../modules/errors';
-import { asyncLocalStorage } from './asyncLocalStorage';
+import { asyncLocalStorage } from '../../modules/storage';
 import { APP_ID, APP_VERSION, getWorkflowYAML } from './factory';
 import { HotMeshService as HotMesh } from '../hotmesh';
 import {

package/services/durable/workflow.ts

@@ -6,7 +6,7 @@ import {
   DurableSleepForError,
   DurableWaitForSignalError } from '../../modules/errors';
 import { KeyService, KeyType } from '../../modules/key';
-import { asyncLocalStorage } from './asyncLocalStorage';
+import { asyncLocalStorage } from '../../modules/storage';
 import { ClientService as Client } from './client';
 import { ConnectionService as Connection } from './connection';
 import { DEFAULT_COEFFICIENT } from './factory';