effect 4.0.2 → 4.0.4

package/src/cluster/ClusterWorkflowEngine.ts

@@ -15,7 +15,6 @@ import * as Effect from "../Effect.ts"
 import * as Exit from "../Exit.ts"
 import * as Fiber from "../Fiber.ts"
 import * as Headers from "../http/Headers.ts"
-import * as Latch from "../Latch.ts"
 import * as Layer from "../Layer.ts"
 import * as Option from "../Option.ts"
 import * as PrimaryKey from "../PrimaryKey.ts"
@@ -132,7 +131,6 @@ export const make = Effect.gen(function*() {
     readonly context: Context.Context<any>
   }>()
   const interruptedActivities = new Set<string>()
-  const activityLatches = new Map<string, Latch.Latch>()
   const deferredState = WorkflowEngine.makeDeferredState()
   // Rebuilds share an activation; overlapping activations have separate results.
   // Weak keys do not retain scopes, but contexts captured by clients, activities,
@@ -293,10 +291,7 @@ export const make = Effect.gen(function*() {
       id: ""
     })
 
-    const maybeSuspended = Option.filter(
-      maybeReply,
-      (reply) => reply.exit._tag === "Success" && reply.exit.value._tag === "Suspended"
-    )
+    const maybeSuspended = Option.filter(maybeReply, isSuspendedReply)
 
     if (Option.isNone(maybeSuspended)) return
     if (
@@ -330,10 +325,14 @@ export const make = Effect.gen(function*() {
     yield* sharding.reset(requestId.value)
   }, Effect.scoped)
 
-  // A child or deferred may complete while a run is still unwinding. Subscribe
-  // to the run's reply before reading storage so the wake cannot fall between
-  // the run's last read and its suspended reply.
-  const waitForRunReply = Effect.fnUntraced(function*(workflow: Workflow.Any, request: Entity.Request<any>) {
+  // Subscribe to the run's next reply before reading storage, so a reply
+  // cannot fall between the read and the subscription. Returns `true` when the
+  // stored reply already settles the wait, `false` when a new reply arrived.
+  const awaitRunReply = Effect.fnUntraced(function*(
+    workflow: Workflow.Any,
+    request: Envelope.Request<any>,
+    isSettled: (reply: WithExitEncoded<Workflow.ResultEncoded<any, any>>) => boolean
+  ) {
     const waiter = yield* storage.registerReplyHandler(
       new Message.OutgoingRequest<any>({
         envelope: request,
@@ -345,12 +344,45 @@ export const make = Effect.gen(function*() {
       })
     ).pipe(Effect.forkScoped({ startImmediately: true }))
     const reply = yield* replyForRequestId(request.requestId)
-    if (Option.isSome(reply)) return
-    yield* Fiber.join(waiter).pipe(
+    if (Option.isSome(reply) && isSettled(reply.value)) return true
+    yield* Fiber.join(waiter)
+    return false
+  }, Effect.scoped)
+
+  // A child or deferred may complete while a run is still unwinding. Wait for
+  // the run's reply so the wake cannot fall between the run's last read and
+  // its suspended reply.
+  const waitForRunReply = (workflow: Workflow.Any, request: Entity.Request<any>) =>
+    awaitRunReply(workflow, request, () => true).pipe(
+      Effect.asVoid,
       Effect.catchTag("EntityNotAssignedToRunner", () => ClusterAbandon.interrupt),
       Effect.catchCause((cause) => ClusterAbandon.isCause(cause) ? ClusterAbandon.interrupt : Effect.failCause(cause))
     )
-  }, Effect.scoped)
+
+  // Wake an external caller once its run publishes a reply other than
+  // `Suspended`. Replies are only observed on the runner that saves them, so
+  // callers on other runners, and any failure here, leave delivery to the
+  // caller's retry schedule.
+  const awaitComplete = (workflow: Workflow.Any, executionId: string) =>
+    Effect.gen(function*() {
+      const address = entityAddressFor({ workflow, entityType: `Workflow/${workflow._tag}`, executionId })
+      if (!sharding.hasShardId(address.shardId)) return yield* Effect.never
+      const requestId = yield* storage.requestIdForPrimaryKey({ address, tag: "run", id: "" })
+      if (Option.isNone(requestId)) return yield* Effect.never
+      const request = Envelope.makeRequest<any>({
+        requestId: requestId.value,
+        address,
+        tag: "run",
+        payload: {},
+        headers: Headers.empty
+      })
+      // A replay that suspends again re-arms the wait, so it does not spend a
+      // step of the caller's retry schedule.
+      let settled = false
+      while (!settled) {
+        settled = yield* awaitRunReply(workflow, request, (reply) => !isSuspendedReply(reply))
+      }
+    }).pipe(Effect.catchCause(() => Effect.never))
 
   const interrupt = Effect.fnUntraced(
     function*(workflow: Workflow.Any, executionId: string) {
@@ -369,7 +401,7 @@ export const make = Effect.gen(function*() {
 
       const nonSuspendedReply = Option.filter(
         reply,
-        (reply) => reply.exit._tag !== "Success" || reply.exit.value._tag !== "Suspended"
+        (reply) => !isSuspendedReply(reply)
       )
       if (Option.isSome(nonSuspendedReply)) {
         return Option.none()
@@ -476,23 +508,19 @@ export const make = Effect.gen(function*() {
                 const activityId = `${executionId}/${payload.name}`
                 const instance = WorkflowEngine.WorkflowInstance.initial(workflow, executionId)
                 interruptedActivities.delete(activityId)
-                return Effect.gen(function*() {
-                  let entry = activities.get(activityId)
-                  while (!entry) {
-                    const latch = Latch.makeUnsafe()
-                    activityLatches.set(activityId, latch)
-                    yield* latch.await
-                    entry = activities.get(activityId)
-                  }
-                  const context = entry.context.pipe(
-                    Context.add(WorkflowEngine.WorkflowInstance, instance),
-                    Context.add(CurrentActivationScope, activation),
-                    Context.add(Activity.CurrentAttempt, payload.attempt)
-                  )
-                  return yield* entry.activity.executeEncoded.pipe(
-                    Effect.provideContext(context)
-                  )
-                }).pipe(
+                const entry = activities.get(activityId)
+                if (!entry) {
+                  // Replay may never register a losing race activity. Answer it
+                  // without waiting; a later registration can reset this reply.
+                  return Effect.succeed(new Workflow.Suspended({})).pipe(Rpc.wrap({ fork: true }))
+                }
+                const context = entry.context.pipe(
+                  Context.add(WorkflowEngine.WorkflowInstance, instance),
+                  Context.add(CurrentActivationScope, activation),
+                  Context.add(Activity.CurrentAttempt, payload.attempt)
+                )
+                return entry.activity.executeEncoded.pipe(
+                  Effect.provideContext(context),
                   Workflow.intoResult,
                   Effect.catchCause((cause) => {
                     // we only want to store interrupts as suspends when the
@@ -623,6 +651,8 @@ export const make = Effect.gen(function*() {
 
     resume: (workflow, executionId) => ensureSuccess(resume(workflow, executionId)),
 
+    awaitComplete,
+
     activityExecute: Effect.fnUntraced(
       function*(activity, attempt) {
         const services = yield* Effect.context<WorkflowEngine.WorkflowInstance>()
@@ -633,11 +663,6 @@ export const make = Effect.gen(function*() {
         while (true) {
           if (!activities.has(activityId)) {
             activities.set(activityId, { activity, context: services })
-            const latch = activityLatches.get(activityId)
-            if (latch) {
-              yield* latch.open
-              activityLatches.delete(activityId)
-            }
           }
           const result = yield* Effect.orDie(
             client.activity({
@@ -820,6 +845,9 @@ const DeferredRpc = Rpc.make("deferred", {
   .annotate(ClusterSchema.Persisted, true)
   .annotate(ClusterSchema.Uninterruptible, true)
 
+const isSuspendedReply = (reply: WithExitEncoded<Workflow.ResultEncoded<any, any>>) =>
+  reply.exit._tag === "Success" && reply.exit.value._tag === "Suspended"
+
 const decodeDeferredWithExit = Schema.decodeSync(Schema.toCodecJson(Reply.WithExit.schema(DeferredRpc)))
 
 const ResumeRpc = Rpc.make("resume", {

package/src/cluster/MessageStorage.ts

@@ -207,7 +207,12 @@ export class MessageStorage extends Context.Service<MessageStorage, {
   ) => Effect.Effect<void, PersistenceError>
 
   /**
-   * Used to wrap requests with transactions.
+   * Wraps requests in storage transactions.
+   *
+   * `WithExit` replies saved in a transaction notify callers after the outermost
+   * commit; stream chunks notify immediately. Replies saved in a failed
+   * transaction must be discarded. The wrapper may fail only with the wrapped
+   * effect's own failure or a defect.
    */
   readonly withTransaction: <A, E, R>(
     effect: Effect.Effect<A, E, R>
@@ -513,6 +518,10 @@ export type EncodedRepliesOptions<A> = {
   readonly cursor: Option.Option<A>
 }
 
+const TransactionNotifications = Context.Reference<
+  Array<Effect.Effect<void, PersistenceError | MalformedMessage>> | undefined
+>("effect/cluster/MessageStorage/TransactionNotifications", { defaultValue: () => undefined })
+
 /**
  * Wraps a concrete message storage implementation with reply-handler management.
  *
@@ -555,6 +564,20 @@ export const make = (
     const replyHandlersShard = new Map<string, Set<ReplyHandler>>()
     return MessageStorage.of({
       ...storage,
+      // Nested transactions defer notifications to the outermost commit.
+      withTransaction: (effect) =>
+        TransactionNotifications.use((outer) => {
+          const notifications: Array<Effect.Effect<void, PersistenceError | MalformedMessage>> = []
+          return storage.withTransaction(Effect.provideService(effect, TransactionNotifications, notifications)).pipe(
+            Effect.tap(() =>
+              outer
+                ? Effect.sync(() => {
+                  outer.push(...notifications)
+                })
+                : Effect.orDie(Effect.forEach(notifications, identity, { discard: true }))
+            )
+          )
+        }),
       registerReplyHandler: (message) => {
         const requestId = message.envelope.requestId
         return Effect.callback<void, EntityNotAssignedToRunner>((resume) => {
@@ -619,20 +642,28 @@ export const make = (
       saveReply(reply) {
         const requestId = reply.reply.requestId
         return Effect.flatMap(storage.saveReply(reply), (persisted) => {
-          const handlers = replyHandlers.get(requestId)
-          if (!handlers) {
-            return Effect.void
-          } else if (persisted.reply._tag === "WithExit") {
-            replyHandlers.delete(requestId)
-            for (let i = 0; i < handlers.length; i++) {
-              const handler = handlers[i]
-              handler.shardSet.delete(handler)
-              handler.resume(Effect.void)
+          const notify = Effect.suspend(() => {
+            const handlers = replyHandlers.get(requestId)
+            if (!handlers) {
+              return Effect.void
+            } else if (persisted.reply._tag === "WithExit") {
+              replyHandlers.delete(requestId)
+              for (let i = 0; i < handlers.length; i++) {
+                const handler = handlers[i]
+                handler.shardSet.delete(handler)
+                handler.resume(Effect.void)
+              }
             }
-          }
-          return handlers.length === 1
-            ? handlers[0].respond(persisted)
-            : Effect.forEach(handlers, (handler) => handler.respond(persisted))
+            return handlers.length === 1
+              ? handlers[0].respond(persisted)
+              : Effect.forEach(handlers, (handler) => handler.respond(persisted), { discard: true })
+          })
+          if (persisted.reply._tag !== "WithExit") return notify
+          return TransactionNotifications.use((notifications) =>
+            notifications === undefined ? notify : Effect.sync(() => {
+              notifications.push(notify)
+            })
+          )
         })
       }
     })

package/src/cluster/Runners.ts

@@ -282,6 +282,10 @@ export const make: (
           const reply = entry.replies[i]
           // we have reached the end
           if (reply._tag === "WithExit") {
+            // A reply can immediately reset and resend the same request. Do not
+            // let that sender attach to this completed reply loop.
+            storageRequests.delete(message.envelope.requestId)
+            waitingStorageRequests.delete(message.envelope.requestId)
             for (const message of entry.messages) {
               yield* message.respond(reply)
             }
@@ -304,8 +308,10 @@ export const make: (
         effect,
         Effect.sync(() => {
           const entry = storageRequests.get(message.envelope.requestId)
-          if (!entry || entry.messages.size > 1) {
-            entry?.messages.delete(message)
+          // An old waiter must not clean up a reset request's new reply loop.
+          if (!entry?.messages.has(message)) return
+          if (entry.messages.size > 1) {
+            entry.messages.delete(message)
             return
           }
           storageRequests.delete(message.envelope.requestId)