@effect/cluster 0.28.4 → 0.29.1

package/src/internal/shardingConfig.ts

@@ -1,97 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,54 +0,0 @@
-import * as HashMap from "effect/HashMap"
-import * as HashSet from "effect/HashSet"
-import * as Option from "effect/Option"
-import * as Schema from "effect/Schema"
-
-/** @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 })
-  )