@effect/cluster 0.33.3 → 0.34.1

package/src/Sharding.ts

@@ -29,9 +29,14 @@ import * as Schedule from "effect/Schedule"
 import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type { MailboxFull, PersistenceError } from "./ClusterError.js"
-import { AlreadyProcessingMessage, EntityNotManagedByRunner, RunnerUnavailable } from "./ClusterError.js"
+import {
+  AlreadyProcessingMessage,
+  EntityNotAssignedToRunner,
+  EntityNotManagedByRunner,
+  RunnerUnavailable
+} from "./ClusterError.js"
 import { Persisted } from "./ClusterSchema.js"
-import type { CurrentAddress, Entity, HandlersFrom } from "./Entity.js"
+import type { CurrentAddress, CurrentRunnerAddress, Entity, HandlersFrom } from "./Entity.js"
 import { EntityAddress } from "./EntityAddress.js"
 import { EntityId } from "./EntityId.js"
 import type { EntityType } from "./EntityType.js"
@@ -83,7 +88,9 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
   readonly makeClient: <Rpcs extends Rpc.Any>(
     entity: Entity<Rpcs>
   ) => Effect.Effect<
-    (entityId: string) => RpcClient.RpcClient<Rpcs, MailboxFull | AlreadyProcessingMessage | PersistenceError>
+    (
+      entityId: string
+    ) => RpcClient.RpcClient<Rpcs, MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotManagedByRunner>
   >
 
   /**
@@ -97,7 +104,11 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
       readonly concurrency?: number | "unbounded" | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
     }
-  ) => Effect.Effect<void, never, Rpc.Context<Rpcs> | Rpc.Middleware<Rpcs> | Exclude<RX, Scope.Scope | CurrentAddress>>
+  ) => Effect.Effect<
+    void,
+    never,
+    Rpc.Context<Rpcs> | Rpc.Middleware<Rpcs> | Exclude<RX, Scope.Scope | CurrentAddress | CurrentRunnerAddress>
+  >
 
   /**
    * Registers a new singleton with the runner.
@@ -112,7 +123,7 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
    */
   readonly send: (message: Message.Incoming<any>) => Effect.Effect<
     void,
-    EntityNotManagedByRunner | MailboxFull | AlreadyProcessingMessage
+    EntityNotManagedByRunner | EntityNotAssignedToRunner | MailboxFull | AlreadyProcessingMessage
   >
 
   /**
@@ -120,7 +131,7 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
    */
   readonly notify: (message: Message.Incoming<any>) => Effect.Effect<
     void,
-    EntityNotManagedByRunner | AlreadyProcessingMessage
+    EntityNotManagedByRunner | EntityNotAssignedToRunner | AlreadyProcessingMessage
   >
 
   /**
@@ -422,8 +433,18 @@ const make = Effect.gen(function*() {
               currentSentRequestIds.add(message.envelope.requestId)
             }
             const address = message.envelope.address
+            if (!acquiredShards.has(address.shardId)) {
+              return Effect.void
+            }
             const state = entityManagers.get(address.entityType)
-            if (!state || !acquiredShards.has(address.shardId)) {
+            if (!state) {
+              if (message._tag === "IncomingRequest") {
+                return Effect.orDie(message.respond(Reply.ReplyWithContext.fromDefect({
+                  id: snowflakeGen.unsafeNext(),
+                  requestId: message.envelope.requestId,
+                  defect: new EntityNotManagedByRunner({ address })
+                })))
+              }
               return Effect.void
             }
 
@@ -563,11 +584,11 @@ const make = Effect.gen(function*() {
 
           const sendWithRetry: Effect.Effect<
             void,
-            EntityNotManagedByRunner
+            EntityNotManagedByRunner | EntityNotAssignedToRunner
           > = Effect.catchTags(
             Effect.suspend(() => {
               if (!acquiredShards.has(address.shardId)) {
-                return Effect.fail(new EntityNotManagedByRunner({ address }))
+                return Effect.fail(new EntityNotAssignedToRunner({ address }))
               }
 
               const message = messages[index]
@@ -632,16 +653,20 @@ const make = Effect.gen(function*() {
 
   // --- Sending messages ---
 
-  const sendLocal = (
-    message: Message.Outgoing<any> | Message.Incoming<any>
+  const sendLocal = <M extends Message.Outgoing<any> | Message.Incoming<any>>(
+    message: M
   ): Effect.Effect<
     void,
-    EntityNotManagedByRunner | MailboxFull | AlreadyProcessingMessage
+    | EntityNotAssignedToRunner
+    | EntityNotManagedByRunner
+    | MailboxFull
+    | AlreadyProcessingMessage
+    | (M extends Message.Incoming<any> ? never : PersistenceError)
   > =>
     Effect.suspend(() => {
       const address = message.envelope.address
       if (!isEntityOnLocalShards(address)) {
-        return Effect.fail(new EntityNotManagedByRunner({ address }))
+        return Effect.fail(new EntityNotAssignedToRunner({ address }))
       }
       const state = entityManagers.get(address.entityType)
       if (!state) {
@@ -654,39 +679,52 @@ const make = Effect.gen(function*() {
           message,
           send: state.manager.sendLocal,
           simulateRemoteSerialization: config.simulateRemoteSerialization
-        })
+        }) as any
     })
 
-  const notifyLocal = (
-    message: Message.Outgoing<any> | Message.Incoming<any>,
+  const notifyLocal = <M extends Message.Outgoing<any> | Message.Incoming<any>>(
+    message: M,
     discard: boolean
   ) =>
-    Effect.suspend((): Effect.Effect<void, EntityNotManagedByRunner | AlreadyProcessingMessage> => {
-      const address = message.envelope.address
-      if (!isEntityOnLocalShards(address)) {
-        return Effect.fail(new EntityNotManagedByRunner({ address }))
-      }
+    Effect.suspend(
+      (): Effect.Effect<
+        void,
+        | EntityNotManagedByRunner
+        | EntityNotAssignedToRunner
+        | AlreadyProcessingMessage
+        | (M extends Message.Incoming<any> ? never : PersistenceError)
+      > => {
+        const address = message.envelope.address
+        if (!isEntityOnLocalShards(address)) {
+          return Effect.fail(new EntityNotAssignedToRunner({ address }))
+        } else if (!entityManagers.has(address.entityType)) {
+          return Effect.fail(new EntityNotManagedByRunner({ address }))
+        }
 
-      const notify = storageEnabled
-        ? openStorageReadLatch
-        : () => Effect.dieMessage("Sharding.notifyLocal: storage is disabled")
+        const notify = storageEnabled
+          ? openStorageReadLatch
+          : () => Effect.dieMessage("Sharding.notifyLocal: storage is disabled")
 
-      if (message._tag === "IncomingRequest" || message._tag === "IncomingEnvelope") {
-        if (message._tag === "IncomingRequest" && storageAlreadyProcessed(message)) {
-          return Effect.fail(new AlreadyProcessingMessage({ address, envelopeId: message.envelope.requestId }))
+        if (message._tag === "IncomingRequest" || message._tag === "IncomingEnvelope") {
+          if (message._tag === "IncomingRequest" && storageAlreadyProcessed(message)) {
+            return Effect.fail(new AlreadyProcessingMessage({ address, envelopeId: message.envelope.requestId }))
+          }
+          return notify()
         }
-        return notify()
-      }
 
-      return runners.notifyLocal({ message, notify, discard })
-    })
+        return runners.notifyLocal({ message, notify, discard }) as any
+      }
+    )
 
-  const isTransientError = Predicate.or(RunnerUnavailable.is, EntityNotManagedByRunner.is)
+  const isTransientError = Predicate.or(RunnerUnavailable.is, EntityNotAssignedToRunner.is)
   function sendOutgoing(
     message: Message.Outgoing<any>,
     discard: boolean,
     retries?: number
-  ): Effect.Effect<void, MailboxFull | AlreadyProcessingMessage | PersistenceError> {
+  ): Effect.Effect<
+    void,
+    EntityNotManagedByRunner | MailboxFull | AlreadyProcessingMessage | PersistenceError
+  > {
     return Effect.catchIf(
       Effect.suspend(() => {
         const address = message.envelope.address
@@ -701,7 +739,7 @@ const make = Effect.gen(function*() {
             ? notifyLocal(message, discard)
             : runners.notify({ address: maybeRunner, message, discard })
         } else if (Option.isNone(maybeRunner)) {
-          return Effect.fail(new EntityNotManagedByRunner({ address }))
+          return Effect.fail(new EntityNotAssignedToRunner({ address }))
         }
         return runnerIsLocal
           ? sendLocal(message)
@@ -858,13 +896,19 @@ const make = Effect.gen(function*() {
 
   const clients: ResourceMap<
     Entity<any>,
-    (entityId: string) => RpcClient.RpcClient<any, MailboxFull | AlreadyProcessingMessage>,
+    (entityId: string) => RpcClient.RpcClient<
+      any,
+      MailboxFull | AlreadyProcessingMessage | EntityNotManagedByRunner
+    >,
     never
   > = yield* ResourceMap.make(Effect.fnUntraced(function*(entity: Entity<any>) {
     const client = yield* RpcClient.makeNoSerialization(entity.protocol, {
       supportsAck: true,
       generateRequestId: () => RequestId(snowflakeGen.unsafeNext()),
-      onFromClient(options): Effect.Effect<void, MailboxFull | AlreadyProcessingMessage | PersistenceError> {
+      onFromClient(options): Effect.Effect<
+        void,
+        MailboxFull | AlreadyProcessingMessage | EntityNotManagedByRunner | PersistenceError
+      > {
         const address = Context.unsafeGet(options.context, ClientAddressTag)
         switch (options.message._tag) {
           case "Request": {
@@ -985,7 +1029,7 @@ const make = Effect.gen(function*() {
   }))
 
   const makeClient = <Rpcs extends Rpc.Any>(entity: Entity<Rpcs>): Effect.Effect<
-    (entityId: string) => RpcClient.RpcClient<Rpcs, MailboxFull | AlreadyProcessingMessage>
+    (entityId: string) => RpcClient.RpcClient<Rpcs, MailboxFull | AlreadyProcessingMessage | EntityNotManagedByRunner>
   > => clients.get(entity)
 
   const clientRespondDiscard = (_reply: Reply.Reply<any>) => Effect.void

package/src/ShardingConfig.ts

@@ -70,7 +70,7 @@ export class ShardingConfig extends Context.Tag("@effect/cluster/ShardingConfig"
   readonly entityReplyPollInterval: DurationInput
   readonly refreshAssignmentsInterval: DurationInput
   /**
-   * The interval to retry a send if EntityNotManagedByRunner is returned.
+   * The interval to retry a send if EntityNotAssignedToRunner is returned.
    */
   readonly sendRetryInterval: DurationInput
   // readonly unhealthyRunnerReportInterval: Duration.Duration

package/src/internal/entityManager.ts

@@ -16,7 +16,7 @@ import * as Option from "effect/Option"
 import * as Schedule from "effect/Schedule"
 import * as Schema from "effect/Schema"
 import * as Scope from "effect/Scope"
-import { AlreadyProcessingMessage, EntityNotManagedByRunner, MailboxFull, MalformedMessage } from "../ClusterError.js"
+import { AlreadyProcessingMessage, EntityNotAssignedToRunner, MailboxFull, MalformedMessage } from "../ClusterError.js"
 import * as ClusterMetrics from "../ClusterMetrics.js"
 import { Persisted } from "../ClusterSchema.js"
 import type { Entity, HandlersFrom } from "../Entity.js"
@@ -41,11 +41,11 @@ import { ResourceRef } from "./resourceRef.js"
 export interface EntityManager {
   readonly sendLocal: <R extends Rpc.Any>(
     message: Message.IncomingLocal<R>
-  ) => Effect.Effect<void, EntityNotManagedByRunner | MailboxFull | AlreadyProcessingMessage>
+  ) => Effect.Effect<void, EntityNotAssignedToRunner | MailboxFull | AlreadyProcessingMessage>
 
   readonly send: (
     message: Message.Incoming<any>
-  ) => Effect.Effect<void, EntityNotManagedByRunner | MailboxFull | AlreadyProcessingMessage>
+  ) => Effect.Effect<void, EntityNotAssignedToRunner | MailboxFull | AlreadyProcessingMessage>
 
   readonly isProcessingFor: (message: Message.Incoming<any>, options?: {
     readonly excludeReplies?: boolean
@@ -102,10 +102,10 @@ export const make = Effect.fnUntraced(function*<
   const entities: ResourceMap<
     EntityAddress,
     EntityState,
-    EntityNotManagedByRunner
+    EntityNotAssignedToRunner
   > = yield* ResourceMap.make(Effect.fnUntraced(function*(address) {
     if (yield* options.sharding.isShutdown) {
-      return yield* new EntityNotManagedByRunner({ address })
+      return yield* new EntityNotAssignedToRunner({ address })
     }
 
     const scope = yield* Effect.scope
@@ -317,11 +317,11 @@ export const make = Effect.fnUntraced(function*<
 
   function sendLocal<R extends Rpc.Any>(
     message: Message.IncomingLocal<R>
-  ): Effect.Effect<void, EntityNotManagedByRunner | MailboxFull | AlreadyProcessingMessage> {
+  ): Effect.Effect<void, EntityNotAssignedToRunner | MailboxFull | AlreadyProcessingMessage> {
     return Effect.locally(
       Effect.flatMap(
         entities.get(message.envelope.address),
-        (server): Effect.Effect<void, EntityNotManagedByRunner | MailboxFull | AlreadyProcessingMessage> => {
+        (server): Effect.Effect<void, EntityNotAssignedToRunner | MailboxFull | AlreadyProcessingMessage> => {
           switch (message._tag) {
             case "IncomingRequestLocal": {
               // If the request is already running, then we might have more than
@@ -371,7 +371,7 @@ export const make = Effect.fnUntraced(function*<
             case "IncomingEnvelope": {
               const entry = server.activeRequests.get(message.envelope.requestId)
               if (!entry) {
-                return Effect.fail(new EntityNotManagedByRunner({ address: message.envelope.address }))
+                return Effect.fail(new EntityNotAssignedToRunner({ address: message.envelope.address }))
               } else if (
                 message.envelope._tag === "AckChunk" &&
                 Option.isSome(entry.lastSentChunk) &&

package/src/internal/entityReaper.ts

@@ -1,5 +1,5 @@
 import * as Effect from "effect/Effect"
-import type { EntityNotManagedByRunner } from "../ClusterError.js"
+import type { EntityNotAssignedToRunner } from "../ClusterError.js"
 import type { EntityAddress } from "../EntityAddress.js"
 import type { EntityId } from "../EntityId.js"
 import type { EntityState } from "./entityManager.js"
@@ -12,14 +12,14 @@ export class EntityReaper extends Effect.Service<EntityReaper>()("@effect/cluste
     const registered: Array<{
       readonly maxIdleTime: number
       readonly servers: Map<EntityId, EntityState>
-      readonly entities: ResourceMap<EntityAddress, EntityState, EntityNotManagedByRunner>
+      readonly entities: ResourceMap<EntityAddress, EntityState, EntityNotAssignedToRunner>
     }> = []
     const latch = yield* Effect.makeLatch()
 
     const register = (options: {
       readonly maxIdleTime: number
       readonly servers: Map<EntityId, EntityState>
-      readonly entities: ResourceMap<EntityAddress, EntityState, EntityNotManagedByRunner>
+      readonly entities: ResourceMap<EntityAddress, EntityState, EntityNotAssignedToRunner>
     }) =>
       Effect.suspend(() => {
         currentResolution = Math.max(Math.min(currentResolution, options.maxIdleTime), 5000)