The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 06:00 UTC
| 1 | import { DenoClusterSocket, DenoSocketServer } from "@effect/platform-deno" |
| 2 | import { assert, describe, it } from "@effect/vitest" |
| 3 | import { BigDecimal, Cause, Deferred, Effect, Exit, Fiber, Layer, Option, PrimaryKey, Schema } from "effect" |
| 4 | import type { Sharding } from "effect/cluster" |
| 5 | import { |
| 6 | ClusterSchema, |
| 7 | Entity, |
| 8 | MessageStorage, |
| 9 | RunnerAddress, |
| 10 | RunnerHealth, |
| 11 | RunnerStorage, |
| 12 | ShardingConfig, |
| 13 | SocketRunner |
| 14 | } from "effect/cluster" |
| 15 | import { Rpc, RpcSerialization } from "effect/rpc" |
| 16 | import * as SocketServer from "effect/socket/SocketServer" |
| 17 | |
| 18 | class TestPayload extends Schema.Class<TestPayload>("TestPayload")({ |
| 19 | id: Schema.String, |
| 20 | amount: Schema.BigDecimal |
| 21 | }) { |
| 22 | [PrimaryKey.symbol]() { |
| 23 | return this.id |
| 24 | } |
| 25 | } |
| 26 | |
| 27 | const TestEntity = Entity |
| 28 | .make("TestEntity", [ |
| 29 | Rpc.make("Process", { |
| 30 | payload: TestPayload, |
| 31 | success: Schema.Void |
| 32 | }).annotate(ClusterSchema.Persisted, true), |
| 33 | Rpc.make("ProcessVolatile", { |
| 34 | payload: TestPayload, |
| 35 | success: Schema.Void |
| 36 | }).annotate(ClusterSchema.Persisted, false) |
| 37 | ]) |
| 38 | .annotateRpcs(ClusterSchema.Uninterruptible, true) |
| 39 | |
| 40 | const SharedStorage = Layer.mergeAll( |
| 41 | RunnerStorage.layerMemory, |
| 42 | MessageStorage.layerMemory |
| 43 | ).pipe( |
| 44 | Layer.provide(ShardingConfig.layerDefaults) |
| 45 | ) |
| 46 | |
| 47 | const startRunner = Effect.fnUntraced(function*(entities: Layer.Layer<never, never, Sharding.Sharding>) { |
| 48 | const socketServer = yield* DenoSocketServer.make({ host: "127.0.0.1", port: 0 }) |
| 49 | if (socketServer.address._tag !== "InetAddressV4") { |
| 50 | return yield* Effect.die("Expected a TCP socket server") |
| 51 | } |
| 52 | const port = socketServer.address.port |
| 53 | yield* entities.pipe( |
| 54 | Layer.provideMerge(SocketRunner.layer), |
| 55 | Layer.provide(RunnerHealth.layerNoop), |
| 56 | Layer.provide(Layer.succeed(SocketServer.SocketServer, socketServer)), |
| 57 | Layer.provide(DenoClusterSocket.layerClientProtocol), |
| 58 | Layer.provide(ShardingConfig.layer({ |
| 59 | runnerAddress: Option.some(RunnerAddress.make("127.0.0.1", port)), |
| 60 | entityTerminationTimeout: 0, |
| 61 | entityMessagePollInterval: 5000, |
| 62 | sendRetryInterval: 100 |
| 63 | })), |
| 64 | Layer.provide(RpcSerialization.layerSchemaBinary()), |
| 65 | Layer.build |
| 66 | ) |
| 67 | return port |
| 68 | }) |
| 69 | |
| 70 | const makeClientLayer = (port: number) => |
| 71 | SocketRunner.layerClientOnly.pipe( |
| 72 | Layer.provide(DenoClusterSocket.layerClientProtocol), |
| 73 | Layer.provide(ShardingConfig.layer({ |
| 74 | runnerAddress: Option.some(RunnerAddress.make("127.0.0.1", port)), |
| 75 | runnerListenAddress: Option.some(RunnerAddress.make("127.0.0.1", port)), |
| 76 | entityTerminationTimeout: 0, |
| 77 | entityMessagePollInterval: 5000, |
| 78 | sendRetryInterval: 100 |
| 79 | })), |
| 80 | Layer.provide(RpcSerialization.layerSchemaBinary()) |
| 81 | ) |
| 82 | |
| 83 | const IsolationEntity = Entity |
| 84 | .make("IsolationEntity", [ |
| 85 | Rpc.make("BadReply", { |
| 86 | payload: { id: Schema.Number }, |
| 87 | success: Schema.Int |
| 88 | }), |
| 89 | Rpc.make("Slow", { |
| 90 | success: Schema.String |
| 91 | }) |
| 92 | ]) |
| 93 | .annotateRpcs(ClusterSchema.Persisted, false) |
| 94 | |
| 95 | // BigDecimal.normalize creates a circular `normalized` self-reference. |
| 96 | // When a persisted message is sent with discard: true, the notify path in Runners.makeRpc |
| 97 | // passes the raw envelope (with circular BigDecimal payload) to the runner, |
| 98 | // causing RangeError: Maximum call stack size exceeded. |
| 99 | // |
| 100 | // Volatile discard should complete after the request is sent, without waiting for the |
| 101 | // host runner to finish handling it. |
| 102 | describe("SocketRunner", () => { |
| 103 | it.live( |
| 104 | "discarded persisted requests serialize circular values and volatile requests do not wait for replies", |
| 105 | () => |
| 106 | Effect.gen(function*() { |
| 107 | const volatileStarted = yield* Deferred.make<void>() |
| 108 | const releaseVolatile = yield* Deferred.make<void>() |
| 109 | const TestEntityLayer = TestEntity.toLayer( |
| 110 | Effect.succeed({ |
| 111 | Process: () => Effect.void, |
| 112 | ProcessVolatile: () => |
| 113 | Deferred.succeed(volatileStarted, void 0).pipe( |
| 114 | Effect.andThen(Deferred.await(releaseVolatile)) |
| 115 | ) |
| 116 | }) |
| 117 | ) |
| 118 | |
| 119 | const port = yield* startRunner(TestEntityLayer) |
| 120 | yield* Effect.gen(function*() { |
| 121 | const makeClient = yield* TestEntity.client |
| 122 | const client = makeClient("entity-1") |
| 123 | |
| 124 | const amount = BigDecimal.fromStringUnsafe("123.45") |
| 125 | yield* client.Process( |
| 126 | TestPayload.make({ id: "req-1", amount }), |
| 127 | { discard: true } |
| 128 | ) |
| 129 | |
| 130 | const volatileFiber = yield* client.ProcessVolatile( |
| 131 | TestPayload.make({ id: "req-2", amount }), |
| 132 | { discard: true } |
| 133 | ).pipe(Effect.forkChild) |
| 134 | |
| 135 | yield* Deferred.await(volatileStarted).pipe( |
| 136 | Effect.timeoutOrElse({ |
| 137 | duration: "5 seconds", |
| 138 | orElse: () => Effect.die("the volatile request never reached its handler") |
| 139 | }) |
| 140 | ) |
| 141 | yield* Fiber.join(volatileFiber).pipe( |
| 142 | Effect.timeoutOrElse({ |
| 143 | duration: "1 second", |
| 144 | orElse: () => Effect.die("volatile discard waited for the entity reply") |
| 145 | }) |
| 146 | ) |
| 147 | yield* Deferred.succeed(releaseVolatile, void 0) |
| 148 | }).pipe( |
| 149 | Effect.provide(makeClientLayer(port)), |
| 150 | Effect.scoped |
| 151 | ) |
| 152 | }).pipe(Effect.provide(SharedStorage)), |
| 153 | 30_000 |
| 154 | ) |
| 155 | |
| 156 | it.live( |
| 157 | "a reply serialization failure fails only its own request", |
| 158 | () => |
| 159 | Effect.gen(function*() { |
| 160 | const slowStarted = yield* Deferred.make<void>() |
| 161 | const releaseSlow = yield* Deferred.make<void>() |
| 162 | const IsolationEntityLayer = IsolationEntity.toLayer( |
| 163 | Effect.succeed({ |
| 164 | BadReply: () => Effect.succeed(1.5), |
| 165 | Slow: () => |
| 166 | Deferred.succeed(slowStarted, void 0).pipe( |
| 167 | Effect.andThen(Deferred.await(releaseSlow)), |
| 168 | Effect.as("done") |
| 169 | ) |
| 170 | }) |
| 171 | ) |
| 172 | |
| 173 | const port = yield* startRunner(IsolationEntityLayer) |
| 174 | |
| 175 | yield* Effect.gen(function*() { |
| 176 | const makeClient = yield* IsolationEntity.client |
| 177 | |
| 178 | const slowFiber = yield* makeClient("slow-entity").Slow().pipe(Effect.forkChild) |
| 179 | yield* Deferred.await(slowStarted).pipe( |
| 180 | Effect.timeoutOrElse({ |
| 181 | duration: "5 seconds", |
| 182 | orElse: () => Effect.die("the Slow request never reached its handler") |
| 183 | }) |
| 184 | ) |
| 185 | |
| 186 | const badExit = yield* makeClient("bad-entity").BadReply({ id: 1 }).pipe( |
| 187 | Effect.exit, |
| 188 | Effect.ensuring(Deferred.succeed(releaseSlow, void 0)) |
| 189 | ) |
| 190 | assert.isTrue(Exit.isFailure(badExit), "the unencodable reply must fail the request") |
| 191 | const failure = Exit.isFailure(badExit) ? String(Cause.squash(badExit.cause)) : "" |
| 192 | assert.include(failure, "MalformedMessage", "the caller must receive the real encode error") |
| 193 | assert.notInclude( |
| 194 | failure, |
| 195 | "AlreadyProcessingMessage", |
| 196 | "the request must not be re-sent into the entity's dedup guard" |
| 197 | ) |
| 198 | |
| 199 | const slowExit = yield* Fiber.await(slowFiber) |
| 200 | assert.isTrue( |
| 201 | Exit.isSuccess(slowExit), |
| 202 | "a sibling in-flight request on the same connection must be unaffected" |
| 203 | ) |
| 204 | if (Exit.isSuccess(slowExit)) { |
| 205 | assert.strictEqual(slowExit.value, "done") |
| 206 | } |
| 207 | }).pipe( |
| 208 | Effect.provide(makeClientLayer(port)), |
| 209 | Effect.scoped |
| 210 | ) |
| 211 | }).pipe(Effect.provide(SharedStorage)), |
| 212 | 30_000 |
| 213 | ) |
| 214 | }) |