@effect/cluster 0.38.2 → 0.38.4

package/src/ClusterWorkflowEngine.ts

@@ -42,6 +42,7 @@ export const make = Effect.gen(function*() {
     string,
     Entity.Entity<
       | Rpc.Rpc<"run", Schema.Struct<{}>, Schema.Schema<Workflow.Result<any, any>>>
+      | Rpc.Rpc<"deferred", Schema.Struct<{ name: typeof Schema.String; exit: typeof ExitUnknown }>, typeof ExitUnknown>
       | Rpc.Rpc<
         "activity",
         Schema.Struct<{ name: typeof Schema.String; attempt: typeof Schema.Number }>,
@@ -65,7 +66,6 @@ export const make = Effect.gen(function*() {
     idleTimeToLive: "5 minutes"
   })
   const clockClient = yield* ClockEntity.client
-  const deferredClient = yield* DeferredEntity.client
 
   const requestIdFor = Effect.fnUntraced(function*(options: {
     readonly workflow: Workflow.Any
@@ -151,6 +151,23 @@ export const make = Effect.gen(function*() {
     yield* storage.clearAddress(clockAddress)
   })
 
+  const resume = Effect.fnUntraced(function*(workflow: Workflow.Any, executionId: string) {
+    const maybeReply = yield* requestReply({
+      workflow,
+      entityType: `Workflow/${workflow.name}`,
+      executionId,
+      tag: "run",
+      id: ""
+    })
+    const maybeSuspended = Option.filter(
+      maybeReply,
+      (reply) => reply.exit._tag === "Success" && reply.exit.value._tag === "Suspended"
+    )
+    if (Option.isNone(maybeSuspended)) return
+    yield* sharding.reset(Snowflake.Snowflake(maybeSuspended.value.requestId))
+    yield* sharding.pollStorage
+  })
+
   return WorkflowEngine.of({
     register(workflow, execute) {
       // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -198,6 +215,7 @@ export const make = Effect.gen(function*() {
                   Effect.provideService(WorkflowInstance, instance)
                 ) as any
               },
+
               activity: Effect.fnUntraced(function*(request: Entity.Request<any>) {
                 const activityId = `${executionId}/${request.payload.name}`
                 let entry = activities.get(activityId)
@@ -224,7 +242,12 @@ export const make = Effect.gen(function*() {
                     activities.delete(activityId)
                   }))
                 )
-              }, Rpc.fork)
+              }, Rpc.fork),
+
+              deferred: Effect.fnUntraced(function*(request: Entity.Request<any>) {
+                yield* ensureSuccess(resume(workflow, executionId))
+                return request.payload.exit
+              })
             }
           })
         ) as Effect.Effect<void>
@@ -240,17 +263,13 @@ export const make = Effect.gen(function*() {
 
     interrupt: Effect.fnUntraced(
       function*(this: WorkflowEngine["Type"], workflow, executionId) {
-        const requestId = yield* requestIdFor({
+        const reply = yield* requestReply({
           workflow,
           entityType: `Workflow/${workflow.name}`,
           executionId,
           tag: "run",
           id: ""
         })
-        if (Option.isNone(requestId)) {
-          return
-        }
-        const reply = yield* replyForRequestId(requestId.value)
         const nonSuspendedReply = reply.pipe(
           Option.filter((reply) => reply.exit._tag !== "Success" || reply.exit.value._tag !== "Suspended")
         )
@@ -273,34 +292,6 @@ export const make = Effect.gen(function*() {
       Effect.orDie
     ),
 
-    resume: Effect.fnUntraced(
-      function*(workflowName: string, executionId: string) {
-        const workflow = workflows.get(workflowName)
-        if (!workflow) {
-          return yield* Effect.dieMessage(`WorkflowEngine.resume: ${workflowName} not registered`)
-        }
-        const maybeReply = yield* requestReply({
-          workflow,
-          entityType: `Workflow/${workflowName}`,
-          executionId,
-          tag: "run",
-          id: ""
-        })
-        const maybeSuspended = Option.filter(
-          maybeReply,
-          (reply) => reply.exit._tag === "Success" && reply.exit.value._tag === "Suspended"
-        )
-        if (Option.isNone(maybeSuspended)) return
-        yield* sharding.reset(Snowflake.Snowflake(maybeSuspended.value.requestId))
-      },
-      Effect.retry({
-        while: (e) => e._tag === "PersistenceError",
-        times: 3,
-        schedule: Schedule.exponential(250)
-      }),
-      Effect.orDie
-    ),
-
     activityExecute: Effect.fnUntraced(function*({ activity, attempt }) {
       const context = yield* Effect.context<WorkflowInstance>()
       const instance = Context.get(context, WorkflowInstance)
@@ -335,9 +326,9 @@ export const make = Effect.gen(function*() {
         Effect.flatMap((instance) =>
           requestReply({
             workflow: instance.workflow,
-            entityType: DeferredEntity.type,
+            entityType: `Workflow/${instance.workflow.name}`,
             executionId: instance.executionId,
-            tag: "set",
+            tag: "deferred",
             id: deferred.name
           })
         ),
@@ -350,14 +341,15 @@ export const make = Effect.gen(function*() {
         Effect.orDie
       ),
 
-    deferredDone({ deferred, executionId, exit, workflowName }) {
-      const client = deferredClient(executionId)
-      return Effect.orDie(client.set({
-        workflowName,
-        name: deferred.name,
-        exit
-      }))
-    },
+    deferredDone: Effect.fnUntraced(function*({ deferred, executionId, exit, workflowName }) {
+      const client = yield* RcMap.get(clients, workflowName)
+      return yield* Effect.orDie(
+        client(executionId).deferred({
+          name: deferred.name,
+          exit
+        })
+      )
+    }, Effect.scoped),
 
     scheduleClock(options) {
       const client = clockClient(options.executionId)
@@ -396,7 +388,7 @@ const ActivityRpc = Rpc.make("activity", {
     success: Schema.Unknown,
     error: Schema.Unknown
   })
-})
+}).annotate(ClusterSchema.Persisted, true)
 
 const makeWorkflowEntity = (workflow: Workflow.Any) =>
   Entity.make(`Workflow/${workflow.name}`, [
@@ -407,12 +399,23 @@ const makeWorkflowEntity = (workflow: Workflow.Any) =>
         success: workflow.successSchema,
         error: workflow.errorSchema
       })
-    }),
+    })
+      .annotate(ClusterSchema.Persisted, true)
+      .annotate(ClusterSchema.Uninterruptible, true),
+
+    Rpc.make("deferred", {
+      payload: {
+        name: Schema.String,
+        exit: ExitUnknown
+      },
+      primaryKey: ({ name }) => name,
+      success: ExitUnknown
+    })
+      .annotate(ClusterSchema.Persisted, true)
+      .annotate(ClusterSchema.Uninterruptible, true),
+
     ActivityRpc
-  ])
-    .annotateContext(workflow.annotations)
-    .annotateRpcs(ClusterSchema.Persisted, true)
-    .annotateRpcs(ClusterSchema.Uninterruptible, true)
+  ]).annotateContext(workflow.annotations)
 
 const activityPrimaryKey = (activity: string, attempt: number) => `${activity}/${attempt}`
 
@@ -422,42 +425,6 @@ const ExitUnknown = Schema.encodedSchema(Schema.Exit({
   defect: Schema.Defect
 }))
 
-const DeferredEntity = Entity.make("Workflow/-/DurableDeferred", [
-  Rpc.make("set", {
-    payload: {
-      workflowName: Schema.String,
-      name: Schema.String,
-      exit: ExitUnknown
-    },
-    primaryKey: ({ name }) => name,
-    success: ExitUnknown
-  }),
-  Rpc.make("resume", {
-    payload: {
-      workflowName: Schema.String,
-      name: Schema.String
-    },
-    primaryKey: ({ name }) => name
-  })
-])
-  .annotateRpcs(ClusterSchema.Persisted, true)
-  .annotateRpcs(ClusterSchema.Uninterruptible, true)
-
-const DeferredEntityLayer = DeferredEntity.toLayer(Effect.gen(function*() {
-  const engine = yield* WorkflowEngine
-  const address = yield* Entity.CurrentAddress
-  const executionId = address.entityId
-  const client = (yield* DeferredEntity.client)(executionId)
-  return {
-    set: (request) =>
-      Effect.as(
-        ensureSuccess(client.resume(request.payload, { discard: true })),
-        request.payload.exit
-      ),
-    resume: (request) => engine.resume(request.payload.workflowName, executionId)
-  }
-}))
-
 class ClockPayload extends Schema.Class<ClockPayload>(`Workflow/DurableClock/Run`)({
   name: Schema.String,
   workflowName: Schema.String,
@@ -504,7 +471,6 @@ export const layer: Layer.Layer<
   WorkflowEngine,
   never,
   Sharding.Sharding | MessageStorage
-> = DeferredEntityLayer.pipe(
-  Layer.merge(ClockEntityLayer),
+> = ClockEntityLayer.pipe(
   Layer.provideMerge(Layer.scoped(WorkflowEngine, make))
 )

package/src/Sharding.ts

@@ -154,6 +154,11 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
    */
   readonly reset: (requestId: Snowflake.Snowflake) => Effect.Effect<boolean>
 
+  /**
+   * Trigger a storage read, which will read all unprocessed messages.
+   */
+  readonly pollStorage: Effect.Effect<void>
+
   /**
    * Retrieves the active entity count for the current runner.
    */
@@ -1191,6 +1196,7 @@ const make = Effect.gen(function*() {
     sendOutgoing: (message, discard) => sendOutgoing(message, discard),
     notify: (message) => notifyLocal(message, false),
     activeEntityCount,
+    pollStorage: storageReadLatch.open,
     reset
   })