sailfork / t3code-github / .repos/ effect/ packages/ platform/ deno/ src/ DenoClusterSocket.ts

/**
 * Native Deno socket layers for Effect Cluster runners.
 *
 * The main `layer` builds a sharding layer for socket transport, choosing
 * serialization, runner health checks, runner storage, message storage, and
 * optional client-only mode from the supplied options. Unlike Node sockets,
 * Deno connections have no native idle-timeout option, so peer connections use
 * only the one-second open timeout.
 *
 * @stability unstable
 * @since 4.0.0
 */
import * as K8sHttpClient from "effect/cluster/K8sHttpClient"
import * as MessageStorage from "effect/cluster/MessageStorage"
import * as RunnerHealth from "effect/cluster/RunnerHealth"
import * as Runners from "effect/cluster/Runners"
import * as RunnerStorage from "effect/cluster/RunnerStorage"
import type { Sharding } from "effect/cluster/Sharding"
import * as ShardingConfig from "effect/cluster/ShardingConfig"
import * as SocketRunner from "effect/cluster/SocketRunner"
import * as SqlMessageStorage from "effect/cluster/SqlMessageStorage"
import * as SqlRunnerStorage from "effect/cluster/SqlRunnerStorage"
import type * as Config from "effect/Config"
import * as Digest from "effect/crypto/Digest"
import * as Effect from "effect/Effect"
import * as FileSystem from "effect/FileSystem"
import * as Layer from "effect/Layer"
import * as Option from "effect/Option"
import * as RpcClient from "effect/rpc/RpcClient"
import * as RpcSerialization from "effect/rpc/RpcSerialization"
import { Socket } from "effect/socket/Socket"
import type * as SocketServer from "effect/socket/SocketServer"
import type { SqlClient } from "effect/sql/SqlClient"
import * as DenoFileSystem from "./DenoFileSystem.ts"
import * as DenoHttpClient from "./DenoHttpClient.ts"
import * as DenoSocket from "./DenoSocket.ts"
import * as DenoSocketServer from "./DenoSocketServer.ts"

/**
 * Provides the cluster `RpcClientProtocol` using native Deno TCP sockets.
 *
 * @stability unstable
 * @category layers
 * @since 4.0.0
 */
export const layerClientProtocol: Layer.Layer<
  Runners.RpcClientProtocol,
  never,
  RpcSerialization.RpcSerialization
> = Layer.effect(Runners.RpcClientProtocol)(
  Effect.gen(function*() {
    const serialization = yield* RpcSerialization.RpcSerialization
    return {
      codecFor: serialization.codecFor,
      make: Effect.fnUntraced(function*(address) {
        const socket = yield* DenoSocket.makeTcp({
          openTimeout: 1000,
          hostname: address.host,
          port: address.port
        })
        return yield* RpcClient.makeProtocolSocket().pipe(
          Effect.provideService(Socket, socket),
          Effect.provideService(RpcSerialization.RpcSerialization, serialization)
        )
      }, Effect.orDie)
    }
  })
)

/**
 * Provides the socket server used by cluster runners, listening on
 * `ShardingConfig.runnerListenAddress` or `runnerAddress`.
 *
 * @stability unstable
 * @category layers
 * @since 4.0.0
 */
export const layerSocketServer: Layer.Layer<
  SocketServer.SocketServer,
  SocketServer.SocketServerError,
  ShardingConfig.ShardingConfig
> = Effect.gen(function*() {
  const config = yield* ShardingConfig.ShardingConfig
  const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress)
  if (Option.isNone(listenAddress)) {
    return yield* Effect.die("layerSocketServer: ShardingConfig.runnerListenAddress is None")
  }
  return DenoSocketServer.layer({
    host: listenAddress.value.host,
    port: listenAddress.value.port
  })
}).pipe(Layer.unwrap)

/**
 * Creates Deno socket cluster layers, configuring serialization, storage,
 * runner health, and optional client-only mode.
 *
 * @stability unstable
 * @category layers
 * @since 4.0.0
 */
export const layer = <
  const ClientOnly extends boolean = false,
  const Storage extends "local" | "sql" | "byo" = never
>(
  options?: {
    readonly serialization?: "binary" | "ndjson" | undefined
    readonly serializationMaxBufferSize?: number | "unbounded" | undefined
    readonly clientOnly?: ClientOnly | undefined
    readonly storage?: Storage | undefined
    readonly runnerHealth?: "ping" | "k8s" | undefined
    readonly runnerHealthK8s?: {
      readonly namespace?: string | undefined
      readonly labelSelector?: string | undefined
    } | undefined
    readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined
  }
): ClientOnly extends true ? Layer.Layer<
    Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage),
    Config.ConfigError,
    "local" extends Storage ? never
      : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
      : SqlClient
  > :
  Layer.Layer<
    Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage),
    SocketServer.SocketServerError | Config.ConfigError,
    "local" extends Storage ? never
      : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
      : SqlClient
  > =>
{
  const layer: Layer.Layer<any, any, any> = options?.clientOnly
    ? Layer.provide(SocketRunner.layerClientOnly, layerClientProtocol)
    : Layer.provide(SocketRunner.layer, [layerSocketServer, layerClientProtocol])

  const runnerHealth: Layer.Layer<any, any, any> = options?.clientOnly
    ? Layer.empty as any
    : options?.runnerHealth === "k8s"
    ? RunnerHealth.layerK8s(options.runnerHealthK8s).pipe(
      Layer.provide(layerK8sHttpClient)
    )
    : RunnerHealth.layerPing.pipe(
      Layer.provide(Runners.layerRpc),
      Layer.provide(layerClientProtocol)
    )

  return layer.pipe(
    Layer.provide(runnerHealth),
    Layer.provideMerge(
      options?.storage === "local"
        ? MessageStorage.layerNoop
        : options?.storage === "byo"
        ? Layer.empty
        : SqlMessageStorage.layer.pipe(Layer.provide(Digest.layerWebCrypto))
    ),
    Layer.provide(
      options?.storage === "local"
        ? RunnerStorage.layerMemory
        : options?.storage === "byo"
        ? Layer.empty
        : Layer.orDie(SqlRunnerStorage.layer)
    ),
    Layer.provide(ShardingConfig.layerFromEnv(options?.shardingConfig)),
    Layer.provide(
      options?.serialization === "ndjson"
        ? RpcSerialization.layerNdjsonWith({ maxBufferSize: options?.serializationMaxBufferSize })
        : RpcSerialization.layerSchemaBinary({
          maxFrameSize: options?.serializationMaxBufferSize
        })
    )
  ) as any
}

/**
 * Layer that provides `K8sHttpClient`, using a scoped native Deno HTTP client
 * with the Kubernetes service-account CA certificate when it is available.
 *
 * @stability unstable
 * @category layers
 * @since 4.0.0
 */
export const layerK8sHttpClient: Layer.Layer<K8sHttpClient.K8sHttpClient> = K8sHttpClient.layer.pipe(
  Layer.provide(Layer.unwrap(Effect.gen(function*() {
    const fs = yield* FileSystem.FileSystem
    const caCertOption = yield* fs.readFileString("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt").pipe(
      Effect.option
    )
    if (Option.isNone(caCertOption)) {
      return DenoHttpClient.layer
    }

    return DenoHttpClient.layerOptions({ caCerts: [caCertOption.value] })
  }))),
  Layer.provide(DenoFileSystem.layer)
)