@effect/cluster 0.52.5 → 0.52.7

package/dist/esm/internal/fiber.js

@@ -0,0 +1,32 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+/** @internal */
+export const joinAllDiscard = fibers => Effect.async(resume => {
+  let cause = 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) {
+    i++;
+    if (exit._tag === "Failure") {
+      cause = cause ? Cause.parallel(cause, exit.cause) : exit.cause;
+    }
+    loop();
+  }
+  loop();
+  return Effect.sync(() => fibers[i].removeObserver(onExit));
+});
+//# sourceMappingURL=fiber.js.map

package/dist/esm/internal/fiber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fiber.js","names":["Cause","Effect","joinAllDiscard","fibers","async","resume","cause","undefined","i","loop","length","fiber","exit","unsafePoll","_tag","parallel","addObserver","onExit","failCause","void","sync","removeObserver"],"sources":["../../../src/internal/fiber.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,cAAc;AACrC,OAAO,KAAKC,MAAM,MAAM,eAAe;AAIvC;AACA,OAAO,MAAMC,cAAc,GAAUC,MAA+C,IAClFF,MAAM,CAACG,KAAK,CAAWC,MAAM,IAAI;EAC/B,IAAIC,KAAK,GAA+BC,SAAS;EACjD,IAAIC,CAAC,GAAG,CAAC;EACT,SAASC,IAAIA,CAAA;IACX,OAAOD,CAAC,GAAGL,MAAM,CAACO,MAAM,EAAE;MACxB,MAAMC,KAAK,GAAGR,MAAM,CAACK,CAAC,CAAC;MACvB,MAAMI,IAAI,GAAGD,KAAK,CAACE,UAAU,EAAE;MAC/B,IAAID,IAAI,EAAE;QACRJ,CAAC,EAAE;QACH,IAAII,IAAI,CAACE,IAAI,KAAK,SAAS,EAAE;QAC7BR,KAAK,GAAGA,KAAK,GAAGN,KAAK,CAACe,QAAQ,CAACT,KAAK,EAAEM,IAAI,CAACN,KAAK,CAAC,GAAGM,IAAI,CAACN,KAAK;QAC9D;MACF;MACAK,KAAK,CAACK,WAAW,CAACC,MAAM,CAAC;MACzB;IACF;IACAZ,MAAM,CAACC,KAAK,GAAGL,MAAM,CAACiB,SAAS,CAACZ,KAAK,CAAC,GAAGL,MAAM,CAACkB,IAAI,CAAC;EACvD;EACA,SAASF,MAAMA,CAACL,IAAqB;IACnCJ,CAAC,EAAE;IACH,IAAII,IAAI,CAACE,IAAI,KAAK,SAAS,EAAE;MAC3BR,KAAK,GAAGA,KAAK,GAAGN,KAAK,CAACe,QAAQ,CAACT,KAAK,EAAEM,IAAI,CAACN,KAAK,CAAC,GAAGM,IAAI,CAACN,KAAK;IAChE;IACAG,IAAI,EAAE;EACR;EACAA,IAAI,EAAE;EACN,OAAOR,MAAM,CAACmB,IAAI,CAAC,MAAMjB,MAAM,CAACK,CAAC,CAAC,CAACa,cAAc,CAACJ,MAAM,CAAC,CAAC;AAC5D,CAAC,CAAC","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/cluster",
-  "version": "0.52.5",
+  "version": "0.52.7",
   "description": "Unified interfaces for common cluster-specific services",
   "license": "MIT",
   "repository": {
@@ -12,10 +12,10 @@
   "homepage": "https://effect.website",
   "peerDependencies": {
     "@effect/platform": "^0.93.0",
+    "@effect/rpc": "^0.72.1",
     "@effect/sql": "^0.48.0",
     "@effect/workflow": "^0.12.2",
-    "@effect/rpc": "^0.72.1",
-    "effect": "^3.19.2"
+    "effect": "^3.19.3"
   },
   "publishConfig": {
     "provenance": true

package/src/Sharding.ts

@@ -8,12 +8,12 @@ import * as Arr from "effect/Array"
 import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import type { DurationInput } from "effect/Duration"
+import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import * as Equal from "effect/Equal"
 import type * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
-import * as FiberHandle from "effect/FiberHandle"
 import * as FiberMap from "effect/FiberMap"
 import * as FiberRef from "effect/FiberRef"
 import * as FiberSet from "effect/FiberSet"
@@ -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"
@@ -260,36 +261,43 @@ const make = Effect.gen(function*() {
       return Effect.ignore(runnerStorage.releaseAll(selfAddress))
     })
 
-    const releaseShardsHandle = yield* FiberHandle.make()
-    const releaseShards = Effect.suspend(function loop(): Effect.Effect<void, PersistenceError> {
-      return Effect.flatMap(
-        Effect.forEach(
-          releasingShards,
-          (shardId) =>
-            Effect.forEach(
-              entityManagers.values(),
-              (state) => state.status === "closed" ? Effect.void : state.manager.interruptShard(shardId),
-              { concurrency: "unbounded", discard: true }
-            ).pipe(
-              Effect.andThen(runnerStorage.release(selfAddress, shardId)),
-              Effect.annotateLogs({ runner: selfAddress }),
-              Effect.flatMap(() => {
-                MutableHashSet.remove(releasingShards, shardId)
-                return storage.unregisterShardReplyHandlers(shardId)
-              })
-            ),
-          { concurrency: "unbounded", discard: true }
-        ),
-        () => {
-          if (MutableHashSet.size(releasingShards) === 0) {
-            return Effect.void
-          }
-          return loop()
+    const releaseShardsMap = yield* FiberMap.make<ShardId>()
+    const releaseShard = Effect.fnUntraced(
+      function*(shardId: ShardId) {
+        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)))
         }
-      )
-    }).pipe(
-      FiberHandle.run(releaseShardsHandle, { onlyIfMissing: true })
+        yield* joinAllDiscard(fibers)
+        yield* runnerStorage.release(selfAddress, shardId)
+        MutableHashSet.remove(releasingShards, shardId)
+        yield* storage.unregisterShardReplyHandlers(shardId)
+      },
+      Effect.sandbox,
+      (effect, shardId) =>
+        effect.pipe(
+          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)
+      }
+    })
 
     yield* Effect.gen(function*() {
       activeShardsLatch.unsafeOpen()
@@ -873,16 +881,17 @@ const make = Effect.gen(function*() {
     const hashRings = new Map<string, HashRing.HashRing<RunnerAddress>>()
     let nextRunners = MutableHashMap.empty<Runner, boolean>()
     const healthyRunners = MutableHashSet.empty<Runner>()
+    const withTimeout = Effect.timeout(Duration.seconds(5))
 
     while (true) {
       // Ensure the current runner is registered
       if (selfRunner && !isShutdown.current && !MutableHashMap.has(allRunners, selfRunner)) {
         yield* Effect.logDebug("Registering runner", selfRunner)
-        const machineId = yield* runnerStorage.register(selfRunner, true)
+        const machineId = yield* withTimeout(runnerStorage.register(selfRunner, true))
         yield* snowflakeGen.setMachineId(machineId)
       }
 
-      const runners = yield* runnerStorage.getRunners
+      const runners = yield* withTimeout(runnerStorage.getRunners)
       let changed = false
       for (let i = 0; i < runners.length; i++) {
         const [runner, healthy] = runners[i]
@@ -965,7 +974,7 @@ const make = Effect.gen(function*() {
         yield* Effect.logWarning("No healthy runners available")
         // to prevent a deadlock, we will mark the current node as healthy to
         // start the health check singleton again
-        yield* runnerStorage.setRunnerHealth(selfRunner.address, true)
+        yield* withTimeout(runnerStorage.setRunnerHealth(selfRunner.address, true))
       }
 
       yield* Effect.sleep(config.refreshAssignmentsInterval)
@@ -1099,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
       })
     )
@@ -1368,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/SqlRunnerStorage.ts

@@ -8,8 +8,9 @@ import * as Arr from "effect/Array"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
-import * as Resource from "effect/Resource"
+import * as Scope from "effect/Scope"
 import { PersistenceError } from "./ClusterError.js"
+import { ResourceRef } from "./internal/resourceRef.js"
 import * as RunnerStorage from "./RunnerStorage.js"
 import * as ShardId from "./ShardId.js"
 import * as ShardingConfig from "./ShardingConfig.js"
@@ -27,22 +28,27 @@ export const make = Effect.fnUntraced(function*(options: {
   const sql = (yield* SqlClient.SqlClient).withoutTransforms()
   const prefix = options?.prefix ?? "cluster"
   const table = (name: string) => `${prefix}_${name}`
+
   const acquireLockConn = sql.onDialectOrElse({
     pg: () =>
-      Effect.gen(function*() {
-        const conn = yield* Effect.orDie(sql.reserve)
-        yield* Effect.addFinalizer(() => Effect.orDie(conn.executeRaw("SELECT pg_advisory_unlock_all()", [])))
+      Effect.fnUntraced(function*(scope: Scope.Scope) {
+        const conn = yield* Effect.orDie(sql.reserve).pipe(
+          Scope.extend(scope)
+        )
+        yield* Scope.addFinalizerExit(scope, () => Effect.orDie(conn.executeRaw("SELECT pg_advisory_unlock_all()", [])))
         return conn
       }),
     mysql: () =>
-      Effect.gen(function*() {
-        const conn = yield* Effect.orDie(sql.reserve)
-        yield* Effect.addFinalizer(() => Effect.orDie(conn.executeRaw("SELECT RELEASE_ALL_LOCKS()", [])))
+      Effect.fnUntraced(function*(scope: Scope.Scope) {
+        const conn = yield* Effect.orDie(sql.reserve).pipe(
+          Scope.extend(scope)
+        )
+        yield* Scope.addFinalizerExit(scope, () => Effect.orDie(conn.executeRaw("SELECT RELEASE_ALL_LOCKS()", [])))
         return conn
       }),
     orElse: () => undefined
   })
-  const lockConnRef = acquireLockConn && (yield* Resource.manual(acquireLockConn))
+  const lockConn = acquireLockConn && (yield* ResourceRef.from(yield* Effect.scope, acquireLockConn))
 
   const runnersTable = table("runners")
   const runnersTableSql = sql(runnersTable)
@@ -206,28 +212,28 @@ export const make = Effect.fnUntraced(function*(options: {
   })
 
   const execWithLockConn = <A>(effect: Statement.Statement<A>): Effect.Effect<unknown, SqlError> => {
-    if (!lockConnRef) return effect
+    if (!lockConn) return effect
     const [query, params] = effect.compile()
-    return Resource.get(lockConnRef).pipe(
+    return lockConn.await.pipe(
       Effect.flatMap((conn) => conn.executeRaw(query, params)),
-      Effect.onError(() => Resource.refresh(lockConnRef!))
+      Effect.onError(() => lockConn.unsafeRebuild())
     )
   }
   const execWithLockConnValues = <A>(
     effect: Statement.Statement<A>
   ): Effect.Effect<ReadonlyArray<ReadonlyArray<any>>, SqlError> => {
-    if (!lockConnRef) return effect.values
+    if (!lockConn) return effect.values
     const [query, params] = effect.compile()
-    return Resource.get(lockConnRef).pipe(
+    return lockConn.await.pipe(
       Effect.flatMap((conn) => conn.executeValues(query, params)),
-      Effect.onError(() => Resource.refresh(lockConnRef!))
+      Effect.onError(() => lockConn.unsafeRebuild())
     )
   }
 
   const acquireLock = sql.onDialectOrElse({
     pg: () =>
       Effect.fnUntraced(function*(_address: string, shardIds: ReadonlyArray<string>) {
-        const conn = yield* Resource.get(lockConnRef!)
+        const conn = yield* lockConn!.await
         const acquiredShardIds: Array<string> = []
         const toAcquire = new Map(shardIds.map((shardId) => [lockNumbers.get(shardId)!, shardId]))
         const takenLocks = yield* conn.executeValues(
@@ -250,11 +256,11 @@ export const make = Effect.fnUntraced(function*(options: {
           }
         }
         return acquiredShardIds
-      }, Effect.onError(() => Resource.refresh(lockConnRef!))),
+      }, Effect.onError(() => lockConn!.unsafeRebuild())),
 
     mysql: () =>
       Effect.fnUntraced(function*(_address: string, shardIds: ReadonlyArray<string>) {
-        const conn = yield* Resource.get(lockConnRef!)
+        const conn = yield* lockConn!.await
         const takenLocks = (yield* conn.executeUnprepared(`SELECT ${allMySqlTakenLocks}`, [], undefined))[0] as Record<
           string,
           1 | null
@@ -281,7 +287,7 @@ export const make = Effect.fnUntraced(function*(options: {
           }
         }
         return acquiredShardIds
-      }, Effect.onError(() => Resource.refresh(lockConnRef!))),
+      }, Effect.onError(() => lockConn!.unsafeRebuild())),
 
     mssql: () => (address: string, shardIds: ReadonlyArray<string>) => {
       const values = shardIds.map((shardId) => sql`(${stringLiteral(shardId)}, ${stringLiteral(address)}, ${sqlNow})`)
@@ -446,48 +452,43 @@ export const make = Effect.fnUntraced(function*(options: {
         Effect.fnUntraced(
           function*(_address, shardId) {
             const lockNum = lockNumbers.get(shardId)!
-            const conn = yield* Resource.get(lockConnRef!)
-            const release = conn.executeRaw(`SELECT pg_advisory_unlock(${lockNum})`, [])
-            const check = conn.executeValues(
-              `SELECT 1 FROM pg_locks WHERE locktype = 'advisory' AND granted = true AND pid = pg_backend_pid() AND objid = ${lockNum}`,
-              []
-            )
-            while (true) {
-              yield* release
-              const takenLocks = yield* check
+            for (let i = 0; i < 5; i++) {
+              const conn = yield* lockConn!.await
+              yield* conn.executeRaw(`SELECT pg_advisory_unlock(${lockNum})`, [])
+              const takenLocks = yield* conn.executeValues(
+                `SELECT 1 FROM pg_locks WHERE locktype = 'advisory' AND granted = true AND pid = pg_backend_pid() AND objid = ${lockNum}`,
+                []
+              )
               if (takenLocks.length === 0) return
             }
+            const conn = yield* lockConn!.await
+            yield* conn.executeRaw(`SELECT pg_advisory_unlock_all()`, [])
           },
-          Effect.onError(() => Resource.refresh(lockConnRef!)),
+          Effect.onError(() => lockConn!.unsafeRebuild()),
           Effect.asVoid,
-          PersistenceError.refail,
-          withTracerDisabled
+          PersistenceError.refail
         ),
       mysql: () =>
         Effect.fnUntraced(
           function*(_address, shardId) {
-            const conn = yield* Resource.get(lockConnRef!)
             const lockName = lockNames.get(shardId)!
-            const release = conn.executeRaw(`SELECT RELEASE_LOCK('${lockName}')`, [])
-            const check = conn.executeValues(
-              `SELECT IS_USED_LOCK('${lockName}') = CONNECTION_ID() AS is_taken`,
-              []
-            )
             while (true) {
-              yield* release
-              const takenLocks = yield* check
+              const conn = yield* lockConn!.await
+              yield* conn.executeRaw(`SELECT RELEASE_LOCK('${lockName}')`, [])
+              const takenLocks = yield* conn.executeValues(
+                `SELECT IS_USED_LOCK('${lockName}') = CONNECTION_ID() AS is_taken`,
+                []
+              )
               if (takenLocks.length === 0 || takenLocks[0][0] !== 1) return
             }
           },
-          Effect.onError(() => Resource.refresh(lockConnRef!)),
+          Effect.onError(() => lockConn!.unsafeRebuild()),
           Effect.asVoid,
-          PersistenceError.refail,
-          withTracerDisabled
+          PersistenceError.refail
         ),
       orElse: () => (address, shardId) =>
         sql`DELETE FROM ${locksTableSql} WHERE address = ${address} AND shard_id = ${shardId}`.pipe(
-          PersistenceError.refail,
-          withTracerDisabled
+          PersistenceError.refail
         )
     }),
 

package/src/internal/entityManager.ts

@@ -9,11 +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 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"
@@ -34,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"
@@ -434,35 +437,31 @@ export const make = Effect.fnUntraced(function*<
     )
   }
 
-  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(entities.removeIgnore(state.address))
-        }
-      })
-      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))
+  })