@hotmeshio/hotmesh 0.0.6 → 0.0.8

package/services/activities/worker.ts

@@ -43,7 +43,7 @@ class Worker extends Activity {
       this.mapInputData();
 
       const multi = this.store.getMulti();
-      //await this.registerTimeout();
+      //todo: await this.registerTimeout();
       await CollatorService.authorizeReentry(this, multi);
       await this.setState(multi);
       await this.setStatus(0, multi);
@@ -56,13 +56,12 @@ class Worker extends Activity {
         'app.activity.mid': messageId,
         'app.job.jss': jobStatus
       });
-      //TODO: UPDATE ACTIVITY STATE (LEG 1 EXIT)
+
       return this.context.metadata.aid;
     } catch (error) {
       if (error instanceof GetStateError) {
         this.logger.error('worker-get-state-error', error);
       } else {
-        console.error(error);
         this.logger.error('worker-process-error', error);
       }
       telemetry.setActivityError(error.message);
@@ -92,100 +91,6 @@ class Worker extends Activity {
     }
     return (await this.engine.streamSignaler?.publishMessage(this.config.subtype, streamData)) as string;
   }
-
-
-  //********  SIGNAL RE-ENTRY POINT (DUPLEX LEG 2 of 2)  ********//
-  async processEvent(status: StreamStatus = StreamStatus.SUCCESS, code: StreamCode = 200): Promise<void> {
-    this.setLeg(2);
-    const jid = this.context.metadata.jid;
-    const aid = this.metadata.aid;
-    this.status = status;
-    this.code = code;
-    this.logger.debug('worker-process-event', { topic: this.config.subtype, jid, aid, status, code });
-    let telemetry: TelemetryService;
-    try {
-      await this.getState();
-      const aState = await CollatorService.notarizeReentry(this);
-      this.adjacentIndex = CollatorService.getDimensionalIndex(aState);
-
-      telemetry = new TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-      let isComplete = CollatorService.isActivityComplete(this.context.metadata.js);
-      if (isComplete) {
-        this.logger.warn('worker-process-event-duplicate', { jid, aid });
-        this.logger.debug('worker-process-event-duplicate-resolution', { resolution: 'Increase HotMesh config `reclaimDelay` timeout.' });
-        return;
-      }
-      telemetry.startActivitySpan(this.leg);
-      if (status === StreamStatus.PENDING) {
-        await this.processPending(telemetry);
-      } else if (status === StreamStatus.SUCCESS) {
-        await this.processSuccess(telemetry);
-      } else {
-        await this.processError(telemetry);
-      }
-    } catch (error) {
-      this.logger.error('worker-process-event-error', error);
-      telemetry.setActivityError(error.message);
-      throw error;
-    } finally {
-      telemetry.endActivitySpan();
-      this.logger.debug('worker-process-event-end', { jid, aid });
-    }
-  }
-
-  async processPending(telemetry: TelemetryService): Promise<void> {
-    this.bindActivityData('output');
-    this.adjacencyList = await this.filterAdjacent();
-    this.mapJobData();
-    const multi = this.store.getMulti();
-    await this.setState(multi);
-    await CollatorService.notarizeContinuation(this, multi);
-
-    await this.setStatus(0, multi);
-    const multiResponse = await multi.exec() as MultiResponseFlags;
-    telemetry.mapActivityAttributes();
-    const jobStatus = this.resolveStatus(multiResponse);
-    telemetry.setActivityAttributes({ 'app.job.jss': jobStatus });
-  }
-
-  async processSuccess(telemetry: TelemetryService): Promise<void> {
-    this.bindActivityData('output');
-    this.adjacencyList = await this.filterAdjacent();
-    this.mapJobData();
-    const multi = this.store.getMulti();
-    await this.setState(multi);
-    await CollatorService.notarizeCompletion(this, multi);
-
-    await this.setStatus(this.adjacencyList.length - 1, multi);
-    const 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 processError(telemetry: TelemetryService): Promise<void> {
-    this.bindActivityError(this.data);
-    this.adjacencyList = await this.filterAdjacent();
-    const multi = this.store.getMulti();
-    await this.setState(multi);
-    await CollatorService.notarizeCompletion(this, multi);
-
-    await this.setStatus(this.adjacencyList.length - 1, multi);
-    const 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);
-  }
 }
 
 export { Worker };

package/services/collator/index.ts

@@ -4,22 +4,45 @@ import { CollationFaultType, CollationStage } from '../../types/collator';
 import { ActivityDuplex } from '../../types/activity';
 import { HotMeshGraph } from '../../types/hotmesh';
 import { Activity } from '../activities/activity';
+import { Cycle } from '../activities/cycle';
 
 class CollatorService {
 
   //max int digit count that supports `hincrby`
   static targetLength = 15;
 
-  static getDimensionalAddress(activity: Activity): Record<string, string> {
+  /**
+   * returns the dimensional address (dad) for the target; due
+   * to the nature of the notary system, the dad for leg 2 entry
+   * must target the `0` index while leg 2 exit must target the
+   * current index (0)
+   */
+  static getDimensionalAddress(activity: Activity, isEntry = false): Record<string, string> {
     let dad = activity.context.metadata.dad || activity.metadata.dad;
-    //todo: unsure about this reset
-    // if (dad && activity.leg === 2) {
-    //   console.log('setting dad index back to 0=>', dad);
-    //   dad = `${dad.substring(0, dad.lastIndexOf(','))},0`;
-    // }
+    if (isEntry && dad && activity.leg === 2) {
+      dad = `${dad.substring(0, dad.lastIndexOf(','))},0`;
+    }
     return CollatorService.getDimensionsById([...activity.config.ancestors, activity.metadata.aid], dad);
   }
 
+  /**
+   * resolves the dimensional address for the
+   * ancestor in the graph to go back to. this address
+   * is determined by trimming the last digits from
+   * the `dad` (including the target).
+   * the target activity index is then set to `0`, so that
+   * the origin node can be queried for approval/entry.
+   */
+  static resolveReentryDimension(activity: Cycle) {
+    const targetActivityId = activity.config.ancestor;
+    const ancestors = activity.config.ancestors;
+    const ancestorIndex = ancestors.indexOf(targetActivityId);
+    const dimensions = activity.metadata.dad.split(','); //e.g., `,0,0,1,0`
+    dimensions.length = ancestorIndex + 1;
+    dimensions.push('0');
+    return dimensions.join(',');
+  }
+
   static async notarizeEntry(activity: Activity, multi?: RedisMulti): Promise<number> {
     //decrement by -100_000_000_000_000
     const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -100_000_000_000_000, this.getDimensionalAddress(activity), multi);
@@ -35,14 +58,21 @@ class CollatorService {
     return amount;
   }
 
+  static async notarizeEarlyExit(activity: Activity, multi?: RedisMulti): Promise<number> {
+    //decrement the 2nd and 3rd digits to fully deactivate (`cycle` activities use this command to fully exit after leg 1) (should result in `888000000000000`)
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -11_000_000_000_000, this.getDimensionalAddress(activity), multi);
+  };
+
   static async notarizeEarlyCompletion(activity: Activity, multi?: RedisMulti): Promise<number> {
-    //initialize both `possible` (1m) and `actualized` (1) zero dimension, while decrementing the 2nd and 3rd digits to deactivate the activity
-    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_001 - 11_000_000_000_000, this.getDimensionalAddress(activity), multi);
+    //initialize both `possible` (1m) and `actualized` (1) zero dimension, while decrementing the 2nd
+    //3rd digit is optionally kept open if the activity might be used in a cycle
+    const decrement = activity.config.cycle ? 10_000_000_000_000 : 11_000_000_000_000;
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_001 - decrement, this.getDimensionalAddress(activity), multi);
   };
 
   static async notarizeReentry(activity: Activity, multi?: RedisMulti): Promise<number> {
     //increment by 1_000_000 (indicates re-entry and is used to drive the 'dimensional address' for adjacent activities (minus 1))
-    const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_000, this.getDimensionalAddress(activity), multi);
+    const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1_000_000, this.getDimensionalAddress(activity, true), multi);
     this.verifyInteger(amount, 2, 'enter');
     return amount;
   };
@@ -53,8 +83,10 @@ class CollatorService {
   };
 
   static async notarizeCompletion(activity: Activity, multi?: RedisMulti): Promise<number> {
-    //close out; actualize leg2 dimension (+1) and decrement the 3rd digit (-1_000_000_000_000)
-    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - 1_000_000_000_000, this.getDimensionalAddress(activity), multi);
+    //1) ALWAYS actualize leg2 dimension (+1)
+    //2) IF the activity is used in a cycle, don't close leg 2!
+    const decrement = activity.config.cycle ? 0 : -1_000_000_000_000;
+    return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - decrement, this.getDimensionalAddress(activity), multi);
   };
 
   static getDigitAtIndex(num: number, targetDigitIndex: number): number | null {

package/services/durable/factory.ts

@@ -26,7 +26,12 @@ const getWorkflowYAML = (topic: string, version = '1') => {
           type: trigger
           stats:
             id: '{$self.input.data.workflowId}'
+
         a1:
+          type: activity
+          cycle: true
+  
+        w1:
           type: worker
           topic: ${topic}
           input:
@@ -49,9 +54,20 @@ const getWorkflowYAML = (topic: string, version = '1') => {
           job:
             maps:
               response: '{$self.output.data.response}'
+
+        c1:
+          type: cycle
+          ancestor: a1
       transitions:
         t1:
-          - to: a1`;
+          - to: a1
+        a1:
+          - to: w1
+        w1:
+          - to: c1
+            conditions:
+              code: 500
+`;
 }
 
 const getActivityYAML = (topic: string, version = '1') => {

package/services/durable/worker.ts

@@ -44,6 +44,7 @@ export class WorkerService {
   static connection: Connection;
   static instances = new Map<string, HotMesh | Promise<HotMesh>>();
   workflowRunner: HotMesh;
+  activityRunner: HotMesh;
 
   static getHotMesh = async (worflowTopic: string) => {
     if (WorkerService.instances.has(worflowTopic)) {
@@ -92,17 +93,20 @@ export class WorkerService {
    * allowing proxyActivities to succeed.
    */
   static registerActivities<ACT>(activities: ACT): Registry  {
-    Object.keys(activities).forEach(key => {
-      WorkerService.activityRegistry[key] = (activities as any)[key];
-    });
+    if (typeof activities === 'function') {
+      WorkerService.activityRegistry[activities.name] = activities as Function;
+    } else {
+      Object.keys(activities).forEach(key => {
+        WorkerService.activityRegistry[activities[key].name] = (activities as any)[key] as Function;
+      });
+    }
     return WorkerService.activityRegistry;
   }
 
   static async create(config: WorkerConfig) {
+    //always call `registerActivities` before `import`
     WorkerService.connection = config.connection;
-    //pre-cache user activity functions
     WorkerService.registerActivities<typeof config.activities>(config.activities);
-    //import the user's workflow file (triggers activity functions to be wrapped)
     const workflow = await import(config.workflowsPath);
     const [workflowFunctionName, workflowFunction] = WorkerService.resolveWorkflowTarget(workflow);
     const baseTopic = `${config.taskQueue}-${workflowFunctionName}`;
@@ -111,9 +115,8 @@ export class WorkerService {
 
     //initialize supporting workflows
     const worker = new WorkerService();
-
-    const activityRunner = await worker.initActivityWorkflow(config, activityTopic);
-    await WorkerService.activateWorkflow(activityRunner, activityTopic, getActivityYAML);
+    worker.activityRunner = await worker.initActivityWorkflow(config, activityTopic);
+    await WorkerService.activateWorkflow(worker.activityRunner, activityTopic, getActivityYAML);
     worker.workflowRunner = await worker.initWorkerWorkflow(config, workflowTopic, workflowFunction);
     await WorkerService.activateWorkflow(worker.workflowRunner, workflowTopic, getWorkflowYAML);
     return worker;
@@ -132,11 +135,7 @@ export class WorkerService {
   }
 
   async run() {
-    if (this.workflowRunner) {
-      this.workflowRunner.engine.logger.info('WorkerService is running');
-    } else {
-      console.log('WorkerService is running');
-    }
+    this.workflowRunner.engine.logger.info('WorkerService is running');
   }
 
   async initActivityWorkflow(config: WorkerConfig, activityTopic: string): Promise<HotMesh> {
@@ -173,10 +172,11 @@ export class WorkerService {
           data: { response: pojoResponse }
         };
       } catch (err) {
-        console.error(err);
-        //todo (make retry configurable)
+        this.activityRunner.engine.logger.error('durable-worker-activity-err', err);
         return {
-          status: StreamStatus.PENDING,
+          status: StreamStatus.ERROR,
+          code: 500,
+          message: err.message,
           metadata: { ...data.metadata },
           data: { error: err }
         } as StreamDataResponse;
@@ -193,7 +193,7 @@ export class WorkerService {
         await hotMesh.deploy(getActivityYAML(activityTopic, version));
         await hotMesh.activate(version);
       } catch (err) {
-        console.log('durable-worker-activity-deploy-activate-error', err);
+        hotMesh.engine.logger.error('durable-worker-activity-deploy-activate-error', err);
         throw err;
       }
     } else if(app && !app.active) {
@@ -258,10 +258,9 @@ export class WorkerService {
           data: { response: workflowResponse }
         };
       } catch (err) {
-        //todo: (retryable error types)
         return {
+          status: StreamStatus.ERROR,
           code: 500,
-          status: StreamStatus.PENDING,
           metadata: { ...data.metadata },
           data: { error: err }
         } as StreamDataResponse;

package/services/durable/workflow.ts

@@ -103,7 +103,10 @@ export class WorkflowService {
       try {
         const hmshInstance = await WorkerService.getHotMesh(activityTopic);
         activityState = await hmshInstance.getState(activityTopic, activityJobId);
-        if (activityState.metadata.js == 1) {
+        if (activityState.metadata.err) {
+          await hmshInstance.scrub(activityJobId);
+          throw new Error(activityState.metadata.err);
+        } else if (activityState.metadata.js === 0) {
           //return immediately
           return activityState.data?.response as T;
         }

package/services/mapper/index.ts

@@ -60,6 +60,9 @@ class MapperService {
       return transitionRule;
     }
     if (code.toString() === (transitionRule.code || 200).toString()) {
+      if (!transitionRule.match) {
+        return true;
+      }
       const orGate = transitionRule.gate === 'or';
       let allAreTrue = true;
       let someAreTrue = false;

package/services/signaler/stream.ts

@@ -150,7 +150,6 @@ class StreamSignaler {
     try {
       output = await callback(input);
     } catch (err) {
-      console.error(err);
       this.logger.error(`stream-call-function-error`, { stream, id, err });
       output = this.structureUnhandledError(input, err);
     }

package/types/activity.ts

@@ -1,7 +1,7 @@
 import { MetricTypes } from "./stats";
 import { StreamRetryPolicy } from "./stream";
 
-type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'iterate';
+type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'iterate' | 'cycle';
 
 type Consumes = Record<string, string[]>;
 
@@ -18,6 +18,7 @@ interface BaseActivity {
   sleep?: number;                      //@pipe /in seconds
   expire?: number;                     //-1 forever (15 seconds default); todo: make globally configurable
   retry?: StreamRetryPolicy
+  cycle?: boolean;                     //if true, the `notary` will leave leg 2 open, so it can be re/cycled
   collationInt?: number;               //compiler
   consumes?: Consumes;                 //compiler
   PRODUCES?: string[];                 //compiler
@@ -61,6 +62,11 @@ interface EmitActivity extends BaseActivity {
   type: 'emit';
 }
 
+interface CycleActivity extends BaseActivity {
+  type: 'cycle';
+  ancestor: string; //ancestor activity id
+}
+
 interface IterateActivity extends BaseActivity {
   type: 'iterate';
 }
@@ -108,6 +114,7 @@ export {
   Consumes,
   TriggerActivityStats,
   AwaitActivity,
+  CycleActivity,
   BaseActivity,
   EmitActivity,
   IterateActivity,

package/types/index.ts

@@ -9,6 +9,7 @@ export {
   Consumes,
   AwaitActivity,
   BaseActivity,
+  CycleActivity,
   EmitActivity,
   WorkerActivity,
   IterateActivity,