@effect/cluster 0.0.0-snapshot-d33d8b050b8e3c87dcde9587083e6c1cf733f72b

package/src/internal/shardingConfig.ts

@@ -0,0 +1,97 @@
+import * as Config from "effect/Config"
+import type * as ConfigError from "effect/ConfigError"
+import * as Context from "effect/Context"
+import * as Duration from "effect/Duration"
+import { pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import type * as ShardingConfig from "../ShardingConfig.js"
+
+/** @internal */
+const ShardingConfigSymbolKey = "@effect/cluster/ShardingConfig"
+
+/** @internal */
+export const ShardingConfigTypeId: ShardingConfig.ShardingConfigTypeId = Symbol.for(
+  ShardingConfigSymbolKey
+) as ShardingConfig.ShardingConfigTypeId
+
+/** @internal */
+export const shardingConfigTag = Context.GenericTag<ShardingConfig.ShardingConfig>(ShardingConfigSymbolKey)
+
+/** @internal */
+const defaultValues: ShardingConfig.ShardingConfig = {
+  numberOfShards: 300,
+  selfHost: "localhost",
+  shardingPort: 54321,
+  shardManagerUri: "http://localhost:8080/api/rest",
+  serverVersion: "1.0.0",
+  entityMaxIdleTime: Duration.minutes(1),
+  entityTerminationTimeout: Duration.seconds(3),
+  refreshAssignmentsRetryInterval: Duration.seconds(5),
+  unhealthyPodReportInterval: Duration.seconds(5)
+}
+
+/** @internal */
+export const defaults = Layer.succeed(shardingConfigTag, defaultValues)
+
+/** @internal */
+export function withDefaults(customs: Partial<ShardingConfig.ShardingConfig>) {
+  return Layer.succeed(shardingConfigTag, {
+    ...defaultValues,
+    ...customs
+  })
+}
+
+/** @internal */
+const config: Config.Config<ShardingConfig.ShardingConfig> = Config.all({
+  numberOfShards: pipe(
+    Config.number("NUMBER_OF_SHARDS"),
+    Config.withDefault(defaultValues.numberOfShards),
+    Config.withDescription("Number of shards")
+  ),
+  selfHost: pipe(
+    Config.string("SELF_HOST"),
+    Config.withDefault(defaultValues.selfHost),
+    Config.withDescription("Fully qualified name of the current host address")
+  ),
+  shardingPort: pipe(
+    Config.integer("PORT"),
+    Config.withDefault(defaultValues.shardingPort),
+    Config.withDescription("Port of the Pod API service")
+  ),
+  shardManagerUri: pipe(
+    Config.string("SHARD_MANAGER_URI"),
+    Config.withDefault(defaultValues.shardManagerUri),
+    Config.withDescription("API address of the Shard Manager URI")
+  ),
+  serverVersion: pipe(
+    Config.string("SERVER_VERSION"),
+    Config.withDefault(defaultValues.serverVersion),
+    Config.withDescription("Server version")
+  ),
+  entityMaxIdleTime: pipe(
+    Config.map(Config.integer("ENTITY_MAX_IDLE_TIME"), Duration.millis),
+    Config.withDefault(defaultValues.entityMaxIdleTime),
+    Config.withDescription("Max entity idle time (millis)")
+  ),
+  entityTerminationTimeout: pipe(
+    Config.map(Config.integer("ENTITY_TERMINATION_TIMEOUT"), Duration.millis),
+    Config.withDefault(defaultValues.entityTerminationTimeout),
+    Config.withDescription("Max time to wait for entity to terminate (millis)")
+  ),
+  refreshAssignmentsRetryInterval: pipe(
+    Config.map(Config.integer("REFRESH_ASSIGNMENTS_INTERVAL"), Duration.millis),
+    Config.withDefault(defaultValues.refreshAssignmentsRetryInterval),
+    Config.withDescription("Interval on which retry getting assignments (millis)")
+  ),
+  unhealthyPodReportInterval: pipe(
+    Config.map(Config.integer("UNHEALTHY_POD_REPORT_INTERVAL"), Duration.millis),
+    Config.withDefault(defaultValues.unhealthyPodReportInterval),
+    Config.withDescription("Interval on which report unhealthy pods (millis)")
+  )
+})
+
+/** @internal */
+export const fromConfig: Layer.Layer<ShardingConfig.ShardingConfig, ConfigError.ConfigError> = Layer.effect(
+  shardingConfigTag,
+  config
+)

package/src/internal/storage.ts

@@ -0,0 +1,60 @@
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as HashMap from "effect/HashMap"
+import * as Layer from "effect/Layer"
+import type * as Option from "effect/Option"
+import * as Ref from "effect/Ref"
+import * as Stream from "effect/Stream"
+import * as SubscriptionRef from "effect/SubscriptionRef"
+import type * as Pod from "../Pod.js"
+import type * as PodAddress from "../PodAddress.js"
+import type * as ShardId from "../ShardId.js"
+import type * as Storage from "../Storage.js"
+
+/** @internal */
+const StorageSymbolKey = "@effect/cluster/StorageTypeId"
+
+/** @internal */
+export const StorageTypeId: Storage.StorageTypeId = Symbol.for(StorageSymbolKey) as Storage.StorageTypeId
+
+/** @internal */
+export const storageTag: Context.Tag<Storage.Storage, Storage.Storage> = Context.GenericTag<Storage.Storage>(
+  StorageSymbolKey
+)
+
+/** @internal */
+export function make(args: Omit<Storage.Storage, Storage.StorageTypeId>): Storage.Storage {
+  return ({ [StorageTypeId]: StorageTypeId, ...args })
+}
+
+/** @internal */
+export const memory: Layer.Layer<Storage.Storage> = Layer.effect(
+  storageTag,
+  Effect.gen(function*($) {
+    const assignmentsRef = yield* $(
+      SubscriptionRef.make(HashMap.empty<ShardId.ShardId, Option.Option<PodAddress.PodAddress>>())
+    )
+    const podsRef = yield* $(Ref.make(HashMap.empty<PodAddress.PodAddress, Pod.Pod>()))
+
+    return make({
+      getAssignments: SubscriptionRef.get(assignmentsRef),
+      saveAssignments: (assignments) => pipe(assignmentsRef, SubscriptionRef.set(assignments)),
+      assignmentsStream: assignmentsRef.changes,
+      getPods: Ref.get(podsRef),
+      savePods: (pods) => pipe(podsRef, Ref.set(pods))
+    })
+  })
+)
+
+/** @internal */
+export const noop: Layer.Layer<Storage.Storage> = Layer.effect(
+  storageTag,
+  Effect.succeed(make({
+    getAssignments: Effect.succeed(HashMap.empty()),
+    saveAssignments: () => Effect.void,
+    assignmentsStream: Stream.empty,
+    getPods: Effect.succeed(HashMap.empty()),
+    savePods: () => Effect.void
+  }))
+)

package/src/internal/utils.ts

@@ -0,0 +1,54 @@
+import * as Schema from "@effect/schema/Schema"
+import * as HashMap from "effect/HashMap"
+import * as HashSet from "effect/HashSet"
+import * as Option from "effect/Option"
+
+/** @internal */
+export function NotAMessageWithReplierDefect(message: unknown): unknown {
+  return { _tag: "./NotAMessageWithReplierDefect", message }
+}
+
+/** @internal */
+export function MessageReturnedNotingDefect(message: unknown): unknown {
+  return { _tag: "./MessageReturnedNotingDefect", message }
+}
+
+/** @internal */
+export function minByOption<A>(f: (value: A) => number) {
+  return (fa: Iterable<A>) => {
+    let current: Option.Option<A> = Option.none()
+    for (const item of fa) {
+      if (Option.isNone(current)) {
+        current = Option.some(item)
+      } else {
+        if (f(item) < f(current.value)) {
+          current = Option.some(item)
+        }
+      }
+    }
+    return current
+  }
+}
+
+/** @internal */
+export function groupBy<A, K>(f: (value: A) => K) {
+  return (fa: Iterable<A>) => {
+    let current = HashMap.empty<K, HashSet.HashSet<A>>()
+    for (const item of fa) {
+      const k = f(item)
+      if (HashMap.has(current, k)) {
+        current = HashMap.modify(current, k, HashSet.add(item))
+      } else {
+        current = HashMap.set(current, k, HashSet.fromIterable([item]))
+      }
+    }
+    return current
+  }
+}
+
+/** @internal */
+export const TypeIdSchema = <Key extends string, Symbol extends symbol>(key: Key, symbol: Symbol) =>
+  Schema.Literal(key).pipe(
+    Schema.compose(Schema.Symbol, { strict: false }),
+    Schema.compose(Schema.UniqueSymbolFromSelf(symbol), { strict: false })
+  )