@effect/cluster 0.28.4 → 0.29.1

package/src/internal/entityReaper.ts

@@ -0,0 +1,53 @@
+import * as Effect from "effect/Effect"
+import type { EntityNotManagedByRunner } from "../ClusterError.js"
+import type { EntityAddress } from "../EntityAddress.js"
+import type { EntityId } from "../EntityId.js"
+import type { EntityState } from "./entityManager.js"
+import type { ResourceMap } from "./resourceMap.js"
+
+/** @internal */
+export class EntityReaper extends Effect.Service<EntityReaper>()("@effect/cluster/EntityReaper", {
+  scoped: Effect.gen(function*() {
+    let currentResolution = 30_000
+    const registered: Array<{
+      readonly maxIdleTime: number
+      readonly servers: Map<EntityId, EntityState>
+      readonly entities: ResourceMap<EntityAddress, EntityState, EntityNotManagedByRunner>
+    }> = []
+    const latch = yield* Effect.makeLatch()
+
+    const register = (options: {
+      readonly maxIdleTime: number
+      readonly servers: Map<EntityId, EntityState>
+      readonly entities: ResourceMap<EntityAddress, EntityState, EntityNotManagedByRunner>
+    }) =>
+      Effect.suspend(() => {
+        currentResolution = Math.max(Math.min(currentResolution, options.maxIdleTime), 5000)
+        registered.push(options)
+        return latch.open
+      })
+
+    const clock = yield* Effect.clock
+    yield* Effect.gen(function*() {
+      while (true) {
+        yield* Effect.sleep(currentResolution)
+        const now = clock.unsafeCurrentTimeMillis()
+        for (const { entities, maxIdleTime, servers } of registered) {
+          for (const state of servers.values()) {
+            const duration = now - state.lastActiveCheck
+            if (state.activeRequests.size > 0 || duration < maxIdleTime) {
+              continue
+            }
+            yield* Effect.fork(entities.removeIgnore(state.address))
+          }
+        }
+      }
+    }).pipe(
+      latch.whenOpen,
+      Effect.interruptible,
+      Effect.forkScoped
+    )
+
+    return { register } as const
+  })
+}) {}

package/src/internal/hash.ts

@@ -0,0 +1,11 @@
+/** @internal */
+export const hashOptimize = (n: number): number => (n & 0xbfffffff) | ((n >>> 1) & 0x40000000)
+
+/** @internal */
+export const hashString = (str: string) => {
+  let h = 5381, i = str.length
+  while (i) {
+    h = (h * 33) ^ str.charCodeAt(--i)
+  }
+  return hashOptimize(h)
+}

package/src/internal/interruptors.ts

@@ -0,0 +1,4 @@
+import type { FiberId } from "effect/FiberId"
+
+/** @internal */
+export const internalInterruptors = new WeakSet<FiberId>()

package/src/internal/resourceMap.ts

@@ -0,0 +1,89 @@
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as MutableHashMap from "effect/MutableHashMap"
+import * as MutableRef from "effect/MutableRef"
+import * as Option from "effect/Option"
+import * as Scope from "effect/Scope"
+
+export class ResourceMap<K, A, E> {
+  constructor(
+    readonly lookup: (key: K, scope: Scope.Scope) => Effect.Effect<A, E>,
+    readonly entries: MutableHashMap.MutableHashMap<K, {
+      readonly scope: Scope.CloseableScope
+      readonly deferred: Deferred.Deferred<A, E>
+    }>,
+    readonly isClosed: MutableRef.MutableRef<boolean>
+  ) {}
+
+  static make = Effect.fnUntraced(function*<K, A, E, R>(lookup: (key: K) => Effect.Effect<A, E, R>) {
+    const scope = yield* Effect.scope
+    const context = yield* Effect.context<R>()
+    const isClosed = MutableRef.make(false)
+
+    const entries = MutableHashMap.empty<K, {
+      scope: Scope.CloseableScope
+      deferred: Deferred.Deferred<A, E>
+    }>()
+
+    yield* Scope.addFinalizerExit(
+      scope,
+      (exit) => {
+        MutableRef.set(isClosed, true)
+        return Effect.forEach(entries, ([key, { scope }]) => {
+          MutableHashMap.remove(entries, key)
+          return Effect.exit(Scope.close(scope, exit))
+        }, { concurrency: "unbounded", discard: true })
+      }
+    )
+
+    return new ResourceMap(
+      (key, scope) => Effect.provide(lookup(key), Context.add(context, Scope.Scope, scope)),
+      entries,
+      isClosed
+    )
+  })
+
+  get(key: K): Effect.Effect<A, E> {
+    return Effect.withFiberRuntime((fiber) => {
+      if (MutableRef.get(this.isClosed)) {
+        return Effect.interrupt
+      }
+      const existing = MutableHashMap.get(this.entries, key)
+      if (Option.isSome(existing)) {
+        return Deferred.await(existing.value.deferred)
+      }
+      const scope = Effect.runSync(Scope.make())
+      const deferred = Deferred.unsafeMake<A, E>(fiber.id())
+      MutableHashMap.set(this.entries, key, { scope, deferred })
+      return Effect.onExit(this.lookup(key, scope), (exit) => {
+        if (exit._tag === "Success") {
+          return Deferred.done(deferred, exit)
+        }
+        MutableHashMap.remove(this.entries, key)
+        return Deferred.done(deferred, exit)
+      })
+    })
+  }
+
+  remove(key: K): Effect.Effect<void> {
+    return Effect.suspend(() => {
+      const entry = MutableHashMap.get(this.entries, key)
+      if (Option.isNone(entry)) {
+        return Effect.void
+      }
+      MutableHashMap.remove(this.entries, key)
+      return Scope.close(entry.value.scope, Exit.void)
+    })
+  }
+
+  removeIgnore(key: K): Effect.Effect<void> {
+    return Effect.catchAllCause(this.remove(key), (cause) =>
+      Effect.annotateLogs(Effect.logDebug(cause), {
+        module: "ResourceMap",
+        method: "removeIgnore",
+        key
+      }))
+  }
+}

package/src/internal/resourceRef.ts

@@ -0,0 +1,88 @@
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as MutableRef from "effect/MutableRef"
+import * as Option from "effect/Option"
+import * as Scope from "effect/Scope"
+import { internalInterruptors } from "./interruptors.js"
+
+export type State<A> = {
+  readonly _tag: "Closed"
+} | {
+  readonly _tag: "Acquiring"
+  readonly scope: Scope.CloseableScope
+} | {
+  readonly _tag: "Acquired"
+  readonly scope: Scope.CloseableScope
+  readonly value: A
+}
+
+export class ResourceRef<A, E = never> {
+  static from = Effect.fnUntraced(function*<A, E>(
+    parentScope: Scope.Scope,
+    acquire: (scope: Scope.Scope) => Effect.Effect<A, E>
+  ) {
+    const state = MutableRef.make<State<A>>({ _tag: "Closed" })
+
+    yield* Scope.addFinalizerExit(parentScope, (exit) => {
+      const s = MutableRef.get(state)
+      if (s._tag === "Closed") {
+        return Effect.void
+      }
+      const scope = s.scope
+      MutableRef.set(state, { _tag: "Closed" })
+      return Scope.close(scope, exit)
+    })
+
+    const scope = yield* Scope.make()
+    MutableRef.set(state, { _tag: "Acquiring", scope })
+    const value = yield* acquire(scope)
+    MutableRef.set(state, { _tag: "Acquired", scope, value })
+
+    return new ResourceRef(state, acquire)
+  })
+
+  constructor(
+    readonly state: MutableRef.MutableRef<State<A>>,
+    readonly acquire: (scope: Scope.Scope) => Effect.Effect<A, E>
+  ) {}
+
+  latch = Effect.unsafeMakeLatch(true)
+
+  unsafeGet(): Option.Option<A> {
+    if (this.state.current._tag === "Acquired") {
+      return Option.some(this.state.current.value)
+    }
+    return Option.none()
+  }
+
+  unsafeRebuild(): Effect.Effect<void, E> {
+    const s = this.state.current
+    if (s._tag === "Closed") {
+      return Effect.interrupt
+    }
+    const prevScope = s.scope
+    const scope = Effect.runSync(Scope.make())
+    this.latch.unsafeClose()
+    MutableRef.set(this.state, { _tag: "Acquiring", scope })
+    return Effect.fiberIdWith((fiberId) => {
+      internalInterruptors.add(fiberId)
+      return Scope.close(prevScope, Exit.void)
+    }).pipe(
+      Effect.andThen(this.acquire(scope)),
+      Effect.flatMap((value) => {
+        MutableRef.set(this.state, { _tag: "Acquired", scope, value })
+        return this.latch.open
+      })
+    )
+  }
+
+  await: Effect.Effect<A> = Effect.suspend(() => {
+    const s = this.state.current
+    if (s._tag === "Closed") {
+      return Effect.interrupt
+    } else if (s._tag === "Acquired") {
+      return Effect.succeed(s.value)
+    }
+    return Effect.zipRight(this.latch.await, this.await)
+  })
+}