@effect/cluster 0.28.4 → 0.29.1

package/src/HttpShardManager.ts

@@ -0,0 +1,273 @@
+/**
+ * @since 1.0.0
+ */
+import type * as HttpApp from "@effect/platform/HttpApp"
+import type * as HttpClient from "@effect/platform/HttpClient"
+import * as HttpRouter from "@effect/platform/HttpRouter"
+import * as HttpServer from "@effect/platform/HttpServer"
+import type * as Socket from "@effect/platform/Socket"
+import type * as RpcSerialization from "@effect/rpc/RpcSerialization"
+import * as RpcServer from "@effect/rpc/RpcServer"
+import * as Effect from "effect/Effect"
+import { identity } from "effect/Function"
+import * as Layer from "effect/Layer"
+import type { Scope } from "effect/Scope"
+import { layerClientProtocolHttp, layerClientProtocolWebsocket } from "./HttpCommon.js"
+import * as MessageStorage from "./MessageStorage.js"
+import * as RunnerHealth from "./RunnerHealth.js"
+import * as Runners from "./Runners.js"
+import type { ShardingConfig } from "./ShardingConfig.js"
+import * as ShardManager from "./ShardManager.js"
+import type { ShardStorage } from "./ShardStorage.js"
+
+/**
+ * @since 1.0.0
+ * @category Http App
+ */
+export const toHttpApp: Effect.Effect<
+  HttpApp.Default<never, Scope>,
+  never,
+  Scope | RpcSerialization.RpcSerialization | ShardManager.ShardManager
+> = Effect.gen(function*() {
+  const handlers = yield* Layer.build(ShardManager.layerServerHandlers)
+  return yield* RpcServer.toHttpApp(ShardManager.Rpcs).pipe(
+    Effect.provide(handlers)
+  )
+})
+
+/**
+ * @since 1.0.0
+ * @category Http App
+ */
+export const toHttpAppWebsocket: Effect.Effect<
+  HttpApp.Default<never, Scope>,
+  never,
+  Scope | RpcSerialization.RpcSerialization | ShardManager.ShardManager
+> = Effect.gen(function*() {
+  const handlers = yield* Layer.build(ShardManager.layerServerHandlers)
+  return yield* RpcServer.toHttpAppWebsocket(ShardManager.Rpcs).pipe(
+    Effect.provide(handlers)
+  )
+})
+
+/**
+ * A layer for the `ShardManager` service, that does not run a server.
+ *
+ * It only provides the `Runners` rpc client.
+ *
+ * You can use this with the `toHttpApp` and `toHttpAppWebsocket` apis
+ * to run a complete `ShardManager` server.
+ *
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerNoServerHttp = (
+  options: {
+    readonly runnerPath: string
+    readonly runnerHttps?: boolean | undefined
+  }
+): Layer.Layer<
+  ShardManager.ShardManager,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardStorage
+  | RunnerHealth.RunnerHealth
+  | HttpClient.HttpClient
+  | ShardManager.Config
+  | ShardingConfig
+> =>
+  ShardManager.layer.pipe(
+    Layer.provide(Runners.layerRpc.pipe(
+      Layer.provide([
+        layerClientProtocolHttp({
+          path: options.runnerPath,
+          https: options.runnerHttps
+        }),
+        MessageStorage.layerNoop
+      ])
+    ))
+  )
+
+/**
+ * A layer for the `ShardManager` service, that does not run a server.
+ *
+ * It only provides the `Runners` rpc client.
+ *
+ * You can use this with the `toHttpApp` and `toHttpAppWebsocket` apis
+ * to run a complete `ShardManager` server.
+ *
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerNoServerWebsocket = (
+  options: {
+    readonly runnerPath: string
+    readonly runnerHttps?: boolean | undefined
+  }
+): Layer.Layer<
+  ShardManager.ShardManager,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardStorage
+  | RunnerHealth.RunnerHealth
+  | Socket.WebSocketConstructor
+  | ShardManager.Config
+  | ShardingConfig
+> =>
+  ShardManager.layer.pipe(
+    Layer.provide(Runners.layerRpc.pipe(
+      Layer.provide([
+        layerClientProtocolWebsocket({
+          path: options.runnerPath,
+          https: options.runnerHttps
+        }),
+        MessageStorage.layerNoop
+      ])
+    ))
+  )
+
+/**
+ * A HTTP layer for the `ShardManager` server, that adds a route to the provided
+ * `HttpRouter.Tag`.
+ *
+ * By default, it uses the `HttpRouter.Default` tag.
+ *
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerHttpOptions = <I = HttpRouter.Default>(
+  options: {
+    readonly path: HttpRouter.PathInput
+    readonly routerTag?: HttpRouter.HttpRouter.TagClass<I, string, any, any>
+    readonly runnerPath: string
+    readonly runnerHttps?: boolean | undefined
+    readonly logAddress?: boolean | undefined
+  }
+): Layer.Layer<
+  ShardManager.ShardManager,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardStorage
+  | RunnerHealth.RunnerHealth
+  | HttpClient.HttpClient
+  | HttpServer.HttpServer
+  | ShardManager.Config
+  | ShardingConfig
+> => {
+  const routerTag = options.routerTag ?? HttpRouter.Default
+  return routerTag.serve().pipe(
+    options.logAddress ? withLogAddress : identity,
+    Layer.merge(ShardManager.layerServer),
+    Layer.provide(RpcServer.layerProtocolHttp(options)),
+    Layer.provideMerge(layerNoServerHttp(options))
+  )
+}
+
+/**
+ * A WebSocket layer for the `ShardManager` server, that adds a route to the provided
+ * `HttpRouter.Tag`.
+ *
+ * By default, it uses the `HttpRouter.Default` tag.
+ *
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerWebsocketOptions = <I = HttpRouter.Default>(
+  options: {
+    readonly path: HttpRouter.PathInput
+    readonly routerTag?: HttpRouter.HttpRouter.TagClass<I, string, any, any>
+    readonly runnerPath: string
+    readonly runnerHttps?: boolean | undefined
+    readonly logAddress?: boolean | undefined
+  }
+): Layer.Layer<
+  ShardManager.ShardManager,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardStorage
+  | RunnerHealth.RunnerHealth
+  | HttpServer.HttpServer
+  | Socket.WebSocketConstructor
+  | ShardManager.Config
+  | ShardingConfig
+> => {
+  const routerTag = options.routerTag ?? HttpRouter.Default
+  return routerTag.serve().pipe(
+    options.logAddress ? withLogAddress : identity,
+    Layer.merge(ShardManager.layerServer),
+    Layer.provide(RpcServer.layerProtocolWebsocket(options)),
+    Layer.provideMerge(layerNoServerWebsocket(options))
+  )
+}
+
+const withLogAddress = <A, E, R>(layer: Layer.Layer<A, E, R>): Layer.Layer<A, E, R | HttpServer.HttpServer> =>
+  Layer.effectDiscard(
+    HttpServer.addressFormattedWith((address) =>
+      Effect.annotateLogs(Effect.logInfo(`Listening on: ${address}`), {
+        package: "@effect/cluster",
+        service: "ShardManager"
+      })
+    )
+  ).pipe(Layer.provideMerge(layer))
+
+/**
+ * A HTTP layer for the `ShardManager` server, that adds a route to the provided
+ * `HttpRouter.Tag`.
+ *
+ * By default, it uses the `HttpRouter.Default` tag.
+ *
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerHttp: Layer.Layer<
+  ShardManager.ShardManager,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardStorage
+  | RunnerHealth.RunnerHealth
+  | HttpClient.HttpClient
+  | HttpServer.HttpServer
+  | ShardManager.Config
+  | ShardingConfig
+> = layerHttpOptions({ path: "/", runnerPath: "/" })
+
+/**
+ * A Websocket layer for the `ShardManager` server, that adds a route to the provided
+ * `HttpRouter.Tag`.
+ *
+ * By default, it uses the `HttpRouter.Default` tag.
+ *
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerWebsocket: Layer.Layer<
+  ShardManager.ShardManager,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardStorage
+  | RunnerHealth.RunnerHealth
+  | Socket.WebSocketConstructor
+  | HttpServer.HttpServer
+  | ShardManager.Config
+  | ShardingConfig
+> = layerWebsocketOptions({ path: "/", runnerPath: "/" })
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerRunnerHealthHttp: Layer.Layer<
+  RunnerHealth.RunnerHealth,
+  never,
+  RpcSerialization.RpcSerialization | HttpClient.HttpClient | ShardingConfig
+> = Layer.provide(RunnerHealth.layerRpc, layerClientProtocolHttp({ path: "/" }))
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerRunnerHealthWebsocket: Layer.Layer<
+  RunnerHealth.RunnerHealth,
+  never,
+  RpcSerialization.RpcSerialization | Socket.WebSocketConstructor | ShardingConfig
+> = Layer.provide(RunnerHealth.layerRpc, layerClientProtocolWebsocket({ path: "/" }))

package/src/MachineId.ts

@@ -0,0 +1,27 @@
+/**
+ * @since 1.0.0
+ */
+import * as Schema from "effect/Schema"
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const MachineId = Schema.Int.pipe(
+  Schema.brand("MachineId"),
+  Schema.annotations({
+    pretty: () => (machineId) => `MachineId(${machineId})`
+  })
+)
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type MachineId = typeof MachineId.Type
+
+/**
+ * @since 1.0.0
+ * @category Constructors
+ */
+export const make = (shardId: number): MachineId => MachineId.make(shardId)

package/src/Message.ts

@@ -1,133 +1,184 @@
 /**
  * @since 1.0.0
  */
-import type * as Exit_ from "effect/Exit"
-import type * as PrimaryKey from "effect/PrimaryKey"
-import type * as Schema from "effect/Schema"
-import type * as Types from "effect/Types"
-import * as internal from "./internal/message.js"
+import type * as Rpc from "@effect/rpc/Rpc"
+import { FiberRef } from "effect"
+import type { Context } from "effect/Context"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Schema from "effect/Schema"
+import type { PersistenceError } from "./ClusterError.js"
+import { MalformedMessage } from "./ClusterError.js"
+import * as Envelope from "./Envelope.js"
+import type * as Reply from "./Reply.js"
 
 /**
- * A Message is a request for an entity that will process it.
- * A Message also has a PrimaryKey so that the receiver is eventually able to detect duplicated messages.
- *
  * @since 1.0.0
- * @category models
+ * @category incoming
  */
-export interface Message<A, AI, E, EI>
-  extends Schema.SerializableWithResult<any, any, never, A, AI, E, EI, never>, PrimaryKey.PrimaryKey
-{}
+export type Incoming<R extends Rpc.Any> = IncomingRequest<R> | IncomingEnvelope
 
 /**
  * @since 1.0.0
- * @category models
+ * @category incoming
  */
-export namespace Message {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Any =
-    | Message<any, any, any, any>
-    | Message<any, any, never, never>
+export type IncomingLocal<R extends Rpc.Any> = IncomingRequestLocal<R> | IncomingEnvelope
 
-  /**
-   * Extracts the success type from a `Message`.
-   *
-   * @since 1.0.0
-   * @category utils
-   */
-  export type Success<S> = S extends Message<infer A, infer _AI, infer _E, infer _EI> ? A : never
+/**
+ * @since 1.0.0
+ * @category incoming
+ */
+export const incomingLocalFromOutgoing = <R extends Rpc.Any>(self: Outgoing<R>): IncomingLocal<R> => {
+  if (self._tag === "OutgoingEnvelope") {
+    return new IncomingEnvelope({ envelope: self.envelope })
+  }
+  return new IncomingRequestLocal({
+    envelope: self.envelope,
+    respond: self.respond,
+    lastSentReply: Option.none()
+  })
+}
 
-  /**
-   * Extracts the success type from a `Message`.
-   *
-   * @since 1.0.0
-   * @category utils
-   */
-  export type SuccessEncoded<S> = S extends Message<infer _A, infer _AI, infer _E, infer _EI> ? _AI : never
+/**
+ * @since 1.0.0
+ * @category incoming
+ */
+export class IncomingRequest<R extends Rpc.Any> extends Data.TaggedClass("IncomingRequest")<{
+  readonly envelope: Envelope.Request.PartialEncoded
+  readonly lastSentReply: Option.Option<Reply.ReplyEncoded<R>>
+  readonly respond: (reply: Reply.ReplyWithContext<R>) => Effect.Effect<void, MalformedMessage | PersistenceError>
+}> {}
 
-  /**
-   * Extracts the error type from a `Message`.
-   *
-   * @since 1.0.0
-   * @category utils
-   */
-  export type Error<S> = S extends Message<infer _A, infer _AI, infer E, infer _EI> ? E : never
+/**
+ * @since 1.0.0
+ * @category outgoing
+ */
+export class IncomingRequestLocal<R extends Rpc.Any> extends Data.TaggedClass("IncomingRequestLocal")<{
+  readonly envelope: Envelope.Request<R>
+  readonly lastSentReply: Option.Option<Reply.Reply<R>>
+  readonly respond: (reply: Reply.Reply<R>) => Effect.Effect<void, MalformedMessage | PersistenceError>
+}> {}
 
-  /**
-   * Extracts the error type from a `Message`.
-   *
-   * @since 1.0.0
-   * @category utils
-   */
-  export type ErrorEncoded<S> = S extends Message<infer _A, infer _AI, infer _E, infer _EI> ? _EI : never
+/**
+ * @since 1.0.0
+ * @category incoming
+ */
+export class IncomingEnvelope extends Data.TaggedClass("IncomingEnvelope")<{
+  readonly _tag: "IncomingEnvelope"
+  readonly envelope: Envelope.AckChunk | Envelope.Interrupt
+}> {}
 
-  /**
-   * Extracts the exit type from a `Message`.
-   *
-   * @since 1.0.0
-   * @category utils
-   */
-  export type Exit<S> = S extends Schema.WithResult<infer A, infer _AI, infer E, infer _EI, infer _R> ? Exit_.Exit<A, E>
-    : never
-}
+/**
+ * @since 1.0.0
+ * @category outgoing
+ */
+export type Outgoing<R extends Rpc.Any> = OutgoingRequest<R> | OutgoingEnvelope
 
 /**
  * @since 1.0.0
- * @category schemas
+ * @category outgoing
  */
-export interface TaggedMessageConstructor<Tag extends string, Self, R, IS, S, IE, E, IA, A>
-  extends Schema.Schema<Self, Types.Simplify<IS & { readonly _tag: Tag }>, R>
-{
-  new(
-    props: Types.Equals<S, {}> extends true ? void : S,
-    disableValidation?: boolean
-  ):
-    & Schema.TaggedRequest<Tag, S, IS & { readonly _tag: Tag }, never, A, IA, E, IE, never>
-    & S
-    & PrimaryKey.PrimaryKey
+export class OutgoingRequest<R extends Rpc.Any> extends Data.TaggedClass("OutgoingRequest")<{
+  readonly envelope: Envelope.Request<R>
+  readonly context: Context<Rpc.Context<R>>
+  readonly lastReceivedReply: Option.Option<Reply.Reply<R>>
+  readonly rpc: R
+  readonly respond: (reply: Reply.Reply<R>) => Effect.Effect<void, PersistenceError>
+}> {
+  /**
+   * @since 1.0.0
+   */
+  public encodedCache?: Envelope.Request.PartialEncoded
 }
 
 /**
  * @since 1.0.0
- * @category schemas
+ * @category outgoing
  */
-export const TaggedMessage = internal.TaggedMessage_
+export class OutgoingEnvelope extends Data.TaggedClass("OutgoingEnvelope")<{
+  readonly envelope: Envelope.AckChunk | Envelope.Interrupt
+  readonly rpc: Rpc.AnyWithProps
+}> {}
 
 /**
  * @since 1.0.0
- * @category utils
+ * @category serialization / deserialization
  */
-export const isMessageWithResult: (value: unknown) => value is Message<unknown, unknown, unknown, unknown> =
-  internal.isMessageWithResult
+export const serialize = <Rpc extends Rpc.Any>(
+  message: Outgoing<Rpc>
+): Effect.Effect<Envelope.Envelope.PartialEncoded, MalformedMessage> => {
+  if (message._tag !== "OutgoingRequest") {
+    return Effect.succeed(message.envelope)
+  }
+  return Effect.suspend(() =>
+    message.encodedCache
+      ? Effect.succeed(message.encodedCache)
+      : serializeRequest(message)
+  )
+}
 
 /**
- * Extracts the exit schema from a Message. This schema will be used to encode the remote exit of the Message processor.
- *
  * @since 1.0.0
- * @category utils
+ * @category serialization / deserialization
  */
-export const exitSchema: <A extends Message.Any>(
-  message: A
-) => Schema.Schema<Message.Exit<A>, unknown> = internal.exitSchema
+export const serializeEnvelope = <Rpc extends Rpc.Any>(
+  message: Outgoing<Rpc>
+): Effect.Effect<Envelope.Envelope.Encoded, MalformedMessage> =>
+  Effect.flatMap(
+    serialize(message),
+    (envelope) => MalformedMessage.refail(Schema.encode(Envelope.PartialEncoded)(envelope))
+  )
 
 /**
- * Extracts the failure schema from a Message. This schema will be used to encode remote failures of the Message processor.
- *
  * @since 1.0.0
- * @category utils
+ * @category serialization / deserialization
  */
-export const failureSchema: <A extends Message.Any>(
-  message: A
-) => Schema.Schema<Message.Error<A>, unknown> = internal.failureSchema
+export const serializeRequest = <Rpc extends Rpc.Any>(
+  self: OutgoingRequest<Rpc>
+): Effect.Effect<Envelope.Request.PartialEncoded, MalformedMessage> => {
+  const rpc = self.rpc as any as Rpc.AnyWithProps
+  return Schema.encode(rpc.payloadSchema)(self.envelope.payload).pipe(
+    Effect.locally(FiberRef.currentContext, self.context),
+    MalformedMessage.refail,
+    Effect.map((payload) => ({
+      ...self.envelope,
+      payload
+    }))
+  ) as any as Effect.Effect<Envelope.Request.PartialEncoded, MalformedMessage>
+}
 
 /**
- * Extracts the success schema from a Message. This schema will be used to encode the remote success of the Message processor.
- *
  * @since 1.0.0
- * @category utils
+ * @category serialization / deserialization
  */
-export const successSchema: <A extends Message.Any>(
-  message: A
-) => Schema.Schema<Message.Success<A>, unknown> = internal.successSchema
+export const deserializeLocal = <Rpc extends Rpc.Any>(
+  self: Outgoing<Rpc>,
+  encoded: Envelope.Envelope.PartialEncoded
+): Effect.Effect<
+  IncomingLocal<Rpc>,
+  MalformedMessage
+> => {
+  if (encoded._tag !== "Request") {
+    return Effect.succeed(new IncomingEnvelope({ envelope: encoded }))
+  } else if (self._tag !== "OutgoingRequest") {
+    return Effect.fail(
+      new MalformedMessage({ cause: new Error("Can only deserialize a Request with an OutgoingRequest message") })
+    )
+  }
+  const rpc = self.rpc as any as Rpc.AnyWithProps
+  return Schema.decode(rpc.payloadSchema)(encoded.payload).pipe(
+    Effect.locally(FiberRef.currentContext, self.context),
+    MalformedMessage.refail,
+    Effect.map((payload) =>
+      new IncomingRequestLocal({
+        envelope: Envelope.makeRequest({
+          ...encoded,
+          payload
+        } as any),
+        lastSentReply: Option.none(),
+        respond: self.respond
+      })
+    )
+  ) as Effect.Effect<IncomingRequestLocal<Rpc>, MalformedMessage>
+}