@effect/cluster 0.46.3 → 0.47.0

package/src/RunnerHealth.ts

@@ -4,6 +4,8 @@
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as RcMap from "effect/RcMap"
+import type * as Scope from "effect/Scope"
 import * as MessageStorage from "./MessageStorage.js"
 import type { RunnerAddress } from "./RunnerAddress.js"
 import * as Runners from "./Runners.js"
@@ -22,10 +24,46 @@ import type { ShardingConfig } from "./ShardingConfig.js"
 export class RunnerHealth extends Context.Tag("@effect/cluster/RunnerHealth")<
   RunnerHealth,
   {
+    /**
+     * Used to indicate that a Runner is connected to this host and is healthy,
+     * while the Scope is active.
+     */
+    readonly onConnection: (address: RunnerAddress) => Effect.Effect<void, never, Scope.Scope>
     readonly isAlive: (address: RunnerAddress) => Effect.Effect<boolean>
   }
 >() {}
 
+/**
+ * @since 1.0.0
+ * @category Constructors
+ */
+export const make: (
+  options: { readonly isAlive: (address: RunnerAddress) => Effect.Effect<boolean> }
+) => Effect.Effect<
+  RunnerHealth["Type"],
+  never,
+  Scope.Scope
+> = Effect.fnUntraced(function*(options: {
+  readonly isAlive: (address: RunnerAddress) => Effect.Effect<boolean>
+}) {
+  const connections = yield* RcMap.make({
+    lookup: (_address: RunnerAddress) => Effect.void
+  })
+
+  const onConnection = (address: RunnerAddress) => RcMap.get(connections, address)
+  const isAlive = Effect.fnUntraced(function*(address: RunnerAddress) {
+    if (yield* RcMap.has(connections, address)) {
+      return true
+    }
+    return yield* options.isAlive(address)
+  })
+
+  return RunnerHealth.of({
+    onConnection,
+    isAlive
+  })
+})
+
 /**
  * A layer which will **always** consider a Runner healthy.
  *
@@ -34,9 +72,9 @@ export class RunnerHealth extends Context.Tag("@effect/cluster/RunnerHealth")<
  * @since 1.0.0
  * @category layers
  */
-export const layerNoop = Layer.succeed(
+export const layerNoop = Layer.scoped(
   RunnerHealth,
-  RunnerHealth.of({
+  make({
     isAlive: () => Effect.succeed(true)
   })
 )
@@ -45,10 +83,10 @@ export const layerNoop = Layer.succeed(
  * @since 1.0.0
  * @category Constructors
  */
-export const make: Effect.Effect<
+export const makePing: Effect.Effect<
   RunnerHealth["Type"],
   never,
-  Runners.Runners
+  Runners.Runners | Scope.Scope
 > = Effect.gen(function*() {
   const runners = yield* Runners.Runners
 
@@ -60,7 +98,7 @@ export const make: Effect.Effect<
     )
   }
 
-  return RunnerHealth.of({ isAlive })
+  return yield* make({ isAlive })
 })
 
 /**
@@ -73,7 +111,7 @@ export const layer: Layer.Layer<
   RunnerHealth,
   never,
   Runners.Runners
-> = Layer.effect(RunnerHealth, make)
+> = Layer.scoped(RunnerHealth, makePing)
 
 /**
  * A layer which will ping a Runner directly to check if it is healthy.

package/src/ShardManager.ts

@@ -57,7 +57,9 @@ export class ShardManager extends Context.Tag("@effect/cluster/ShardManager")<Sh
   /**
    * Get a stream of sharding events emit by the shard manager.
    */
-  readonly shardingEvents: Effect.Effect<Queue.Dequeue<ShardingEvent>, never, Scope>
+  readonly shardingEvents: (
+    address: Option.Option<RunnerAddress>
+  ) => Effect.Effect<Queue.Dequeue<ShardingEvent>, never, Scope>
   /**
    * Register a new runner with the cluster.
    */
@@ -236,7 +238,9 @@ export class ShardManagerClient
     /**
      * Get a stream of sharding events emit by the shard manager.
      */
-    readonly shardingEvents: Effect.Effect<Mailbox.ReadonlyMailbox<ShardingEvent>, never, Scope>
+    readonly shardingEvents: (
+      address: Option.Option<RunnerAddress>
+    ) => Effect.Effect<Mailbox.ReadonlyMailbox<ShardingEvent>, never, Scope>
     /**
      * Get the current time on the shard manager.
      */
@@ -287,6 +291,7 @@ export class Rpcs extends RpcGroup.make(
     success: Schema.Array(Schema.Tuple(ShardId, Schema.Option(RunnerAddress)))
   }),
   Rpc.make("ShardingEvents", {
+    payload: { address: Schema.Option(RunnerAddress) },
     success: ShardingEventSchema,
     stream: true
   }),
@@ -347,7 +352,7 @@ export const makeClientLocal = Effect.gen(function*() {
     unregister: () => Effect.void,
     notifyUnhealthyRunner: () => Effect.void,
     getAssignments: Effect.succeed(shards),
-    shardingEvents: Effect.gen(function*() {
+    shardingEvents: Effect.fnUntraced(function*(_address) {
       const mailbox = yield* Mailbox.make<ShardingEvent>()
       yield* mailbox.offer(ShardingEvent.StreamStarted())
       return mailbox
@@ -379,19 +384,20 @@ export const makeClientRpc: Effect.Effect<
     unregister: (address) => Effect.orDie(client.Unregister({ address })),
     notifyUnhealthyRunner: (address) => Effect.orDie(client.NotifyUnhealthyRunner({ address })),
     getAssignments: Effect.orDie(client.GetAssignments()),
-    shardingEvents: Mailbox.make<ShardingEvent>().pipe(
-      Effect.tap(Effect.fnUntraced(
-        function*(mailbox) {
-          const events = yield* client.ShardingEvents(void 0, { asMailbox: true })
-          const take = Effect.orDie(events.takeAll)
-          while (true) {
-            mailbox.unsafeOfferAll((yield* take)[0])
-          }
-        },
-        (effect, mb) => Mailbox.into(effect, mb),
-        Effect.forkScoped
-      ))
-    ),
+    shardingEvents: (address) =>
+      Mailbox.make<ShardingEvent>().pipe(
+        Effect.tap(Effect.fnUntraced(
+          function*(mailbox) {
+            const events = yield* client.ShardingEvents({ address }, { asMailbox: true })
+            const take = Effect.orDie(events.takeAll)
+            while (true) {
+              mailbox.unsafeOfferAll((yield* take)[0])
+            }
+          },
+          (effect, mb) => Mailbox.into(effect, mb),
+          Effect.forkScoped
+        ))
+      ),
     getTime: Effect.orDie(client.GetTime())
   })
 })
@@ -738,7 +744,11 @@ export const make = Effect.gen(function*() {
 
   return ShardManager.of({
     getAssignments,
-    shardingEvents: PubSub.subscribe(events),
+    shardingEvents: (address) =>
+      Effect.zipRight(
+        Option.isSome(address) ? runnerHealthApi.onConnection(address.value) : Effect.void,
+        PubSub.subscribe(events)
+      ),
     register,
     unregister,
     rebalance,
@@ -773,8 +783,8 @@ export const layerServerHandlers = Rpcs.toLayer(Effect.gen(function*() {
         shardManager.getAssignments,
         (assignments) => Array.from(assignments)
       ),
-    ShardingEvents: Effect.fnUntraced(function*() {
-      const queue = yield* shardManager.shardingEvents
+    ShardingEvents: Effect.fnUntraced(function*({ address }) {
+      const queue = yield* shardManager.shardingEvents(address)
       const mailbox = yield* Mailbox.make<ShardingEvent>()
 
       yield* mailbox.offer(ShardingEvent.StreamStarted())

package/src/Sharding.ts

@@ -829,7 +829,7 @@ const make = Effect.gen(function*() {
     yield* stopShardManagerTimeout
 
     yield* Effect.logDebug("Subscribing to sharding events")
-    const mailbox = yield* shardManager.shardingEvents
+    const mailbox = yield* shardManager.shardingEvents(config.runnerAddress)
     const startedLatch = yield* Deferred.make<void>()
 
     const eventsFiber = yield* Effect.gen(function*() {