@effect/cluster 0.52.6 → 0.52.7

package/src/Sharding.ts

@@ -42,6 +42,7 @@ import { make as makeEntityId } from "./EntityId.js"
 import * as Envelope from "./Envelope.js"
 import * as EntityManager from "./internal/entityManager.js"
 import { EntityReaper } from "./internal/entityReaper.js"
+import { joinAllDiscard } from "./internal/fiber.js"
 import { hashString } from "./internal/hash.js"
 import { internalInterruptors } from "./internal/interruptors.js"
 import { ResourceMap } from "./internal/resourceMap.js"
@@ -263,45 +264,37 @@ const make = Effect.gen(function*() {
     const releaseShardsMap = yield* FiberMap.make<ShardId>()
     const releaseShard = Effect.fnUntraced(
       function*(shardId: ShardId) {
-        yield* Effect.forEach(
-          entityManagers.values(),
-          (state) =>
-            state.status === "closed" ? Effect.void : state.manager.interruptShard(shardId).pipe(
-              Effect.withSpan("EntityManager.interruptShard", {
-                captureStackTrace: false,
-                attributes: { entityType: state.entity.type }
-              })
-            ),
-          { concurrency: "unbounded", discard: true }
-        ).pipe(
-          Effect.timeout(config.entityTerminationTimeout)
-        )
+        const fibers = Arr.empty<Fiber.RuntimeFiber<void>>()
+        for (const state of entityManagers.values()) {
+          if (state.status === "closed") continue
+          fibers.push(yield* Effect.fork(state.manager.interruptShard(shardId)))
+        }
+        yield* joinAllDiscard(fibers)
         yield* runnerStorage.release(selfAddress, shardId)
         MutableHashSet.remove(releasingShards, shardId)
         yield* storage.unregisterShardReplyHandlers(shardId)
       },
       Effect.sandbox,
-      Effect.tapError((cause) => Effect.logDebug(`Could not release shard, retrying`, cause)),
-      Effect.eventually,
       (effect, shardId) =>
         effect.pipe(
-          Effect.annotateLogs({
-            package: "@effect/cluster",
-            module: "Sharding",
-            fiber: "releaseShard",
-            runner: selfAddress,
-            shardId
-          }),
-          Effect.withSpan("Sharding.releaseShard", { captureStackTrace: false }),
-          Effect.annotateSpans({
-            shardId,
-            runner: selfAddress
-          }),
+          Effect.tapError((cause) =>
+            Effect.logDebug(`Could not release shard, retrying`, cause).pipe(
+              Effect.annotateLogs({
+                package: "@effect/cluster",
+                module: "Sharding",
+                fiber: "releaseShard",
+                runner: selfAddress,
+                shardId
+              })
+            )
+          ),
+          Effect.eventually,
           FiberMap.run(releaseShardsMap, shardId, { onlyIfMissing: true })
         )
     )
     const releaseShards = Effect.gen(function*() {
       for (const shardId of releasingShards) {
+        if (FiberMap.unsafeHas(releaseShardsMap, shardId)) continue
         yield* releaseShard(shardId)
       }
     })
@@ -1115,8 +1108,8 @@ const make = Effect.gen(function*() {
 
     yield* Scope.addFinalizer(
       yield* Effect.scope,
-      Effect.withFiberRuntime((fiber) => {
-        internalInterruptors.add(fiber.id())
+      Effect.fiberIdWith((fiberId) => {
+        internalInterruptors.add(fiberId)
         return Effect.void
       })
     )
@@ -1384,8 +1377,7 @@ const make = Effect.gen(function*() {
       )
     }
 
-    const fiberId = yield* Effect.fiberId
-    internalInterruptors.add(fiberId)
+    internalInterruptors.add(yield* Effect.fiberId)
     if (isShutdown.current) return
 
     MutableRef.set(isShutdown, true)

package/src/internal/entityManager.ts

@@ -9,12 +9,13 @@ import type { DurationInput } from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Equal from "effect/Equal"
 import * as Exit from "effect/Exit"
-import * as FiberMap from "effect/FiberMap"
+import type * as Fiber from "effect/Fiber"
 import * as FiberRef from "effect/FiberRef"
 import { identity } from "effect/Function"
 import * as HashMap from "effect/HashMap"
 import * as Metric from "effect/Metric"
 import * as Option from "effect/Option"
+import * as Runtime from "effect/Runtime"
 import * as Schedule from "effect/Schedule"
 import * as Schema from "effect/Schema"
 import * as Scope from "effect/Scope"
@@ -35,6 +36,7 @@ import type { Sharding } from "../Sharding.js"
 import { ShardingConfig } from "../ShardingConfig.js"
 import * as Snowflake from "../Snowflake.js"
 import { EntityReaper } from "./entityReaper.js"
+import { joinAllDiscard } from "./fiber.js"
 import { internalInterruptors } from "./interruptors.js"
 import { ResourceMap } from "./resourceMap.js"
 import { ResourceRef } from "./resourceRef.js"
@@ -435,44 +437,31 @@ export const make = Effect.fnUntraced(function*<
     )
   }
 
-  const entityRemovalMap = yield* FiberMap.make<EntityAddress>()
-
-  const interruptShard = (shardId: ShardId) =>
-    Effect.suspend(function loop(): Effect.Effect<void> {
-      const toAwait = Arr.empty<Effect.Effect<void>>()
-      activeServers.forEach((state) => {
-        if (shardId[Equal.symbol](state.address.shardId)) {
-          toAwait.push(
-            FiberMap.run(
-              entityRemovalMap,
-              state.address,
-              entities.removeIgnore(state.address),
-              { onlyIfMissing: true }
-            )
-          )
-        }
-      })
-      serverCloseLatches.forEach((latch, address) => {
-        if (shardId[Equal.symbol](address.shardId)) {
-          toAwait.push(latch.await)
-        }
-      })
-      if (toAwait.length === 0) {
-        return Effect.void
-      }
-      return Effect.flatMap(
-        Effect.all(toAwait, {
-          concurrency: "unbounded",
-          discard: true
-        }),
-        loop
-      )
-    })
-
   const decodeMessage = Schema.decode(makeMessageSchema(entity))
 
+  const runFork = Runtime.runFork(
+    yield* Effect.runtime<never>().pipe(
+      Effect.interruptible
+    )
+  )
+
   return identity<EntityManager>({
-    interruptShard,
+    interruptShard: (shardId: ShardId) =>
+      Effect.suspend(function loop(): Effect.Effect<void> {
+        const fibers = Arr.empty<Fiber.RuntimeFiber<void>>()
+        activeServers.forEach((state) => {
+          if (shardId[Equal.symbol](state.address.shardId)) {
+            fibers.push(runFork(entities.removeIgnore(state.address)))
+          }
+        })
+        serverCloseLatches.forEach((latch, address) => {
+          if (shardId[Equal.symbol](address.shardId)) {
+            fibers.push(runFork(latch.await))
+          }
+        })
+        if (fibers.length === 0) return Effect.void
+        return Effect.flatMap(joinAllDiscard(fibers), loop)
+      }),
     isProcessingFor(message, options) {
       if (options?.excludeReplies !== true && processedRequestIds.has(message.envelope.requestId)) {
         return true

package/src/internal/fiber.ts

@@ -0,0 +1,35 @@
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import type * as Exit from "effect/Exit"
+import type * as Fiber from "effect/Fiber"
+
+/** @internal */
+export const joinAllDiscard = <A, E>(fibers: ReadonlyArray<Fiber.RuntimeFiber<A, E>>) =>
+  Effect.async<void, E>((resume) => {
+    let cause: Cause.Cause<E> | undefined = undefined
+    let i = 0
+    function loop() {
+      while (i < fibers.length) {
+        const fiber = fibers[i]
+        const exit = fiber.unsafePoll()
+        if (exit) {
+          i++
+          if (exit._tag === "Success") continue
+          cause = cause ? Cause.parallel(cause, exit.cause) : exit.cause
+          continue
+        }
+        fiber.addObserver(onExit)
+        return
+      }
+      resume(cause ? Effect.failCause(cause) : Effect.void)
+    }
+    function onExit(exit: Exit.Exit<A, E>) {
+      i++
+      if (exit._tag === "Failure") {
+        cause = cause ? Cause.parallel(cause, exit.cause) : exit.cause
+      }
+      loop()
+    }
+    loop()
+    return Effect.sync(() => fibers[i].removeObserver(onExit))
+  })