@devries-cameron20 / t3code Mirror · read-only
Fork 0

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, 04:45 UTC

main
ts 323 lines 11 KB
Raw
1 import { NodeClusterSocket, NodeSocketServer } from "@effect/platform-node"
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 const HOST = "127.0.0.1"
19
20 class TestPayload extends Schema.Class<TestPayload>("TestPayload")({
21 id: Schema.String,
22 amount: Schema.BigDecimal
23 }) {
24 [PrimaryKey.symbol]() {
25 return this.id
26 }
27 }
28
29 const TestEntity = Entity
30 .make("TestEntity", [
31 Rpc.make("Process", {
32 payload: TestPayload,
33 success: Schema.Void
34 }).annotate(ClusterSchema.Persisted, true),
35 Rpc.make("ProcessVolatile", {
36 payload: TestPayload,
37 success: Schema.Void
38 }).annotate(ClusterSchema.Persisted, false)
39 ])
40 .annotateRpcs(ClusterSchema.Uninterruptible, true)
41
42 // Build shared storage instances once, so runner and client see the same state.
43 // MessageStorage.layerMemory requires ShardingConfig, so we provide a minimal one.
44 const SharedStorage = Layer.mergeAll(
45 RunnerStorage.layerMemory,
46 MessageStorage.layerMemory
47 ).pipe(
48 Layer.provide(ShardingConfig.layerDefaults)
49 )
50
51 const startRunner = Effect.fnUntraced(function*(
52 entities: Layer.Layer<never, never, Sharding.Sharding>,
53 serialization: Layer.Layer<RpcSerialization.RpcSerialization> = RpcSerialization.layerSchemaBinary()
54 ) {
55 const socketServer = yield* NodeSocketServer.make({ host: HOST, port: 0 })
56 if (socketServer.address._tag !== "InetAddressV4") {
57 return yield* Effect.die("Expected a TCP socket server")
58 }
59 const port = socketServer.address.port
60 yield* entities.pipe(
61 Layer.provideMerge(SocketRunner.layer),
62 Layer.provide(RunnerHealth.layerNoop),
63 Layer.provide(Layer.succeed(SocketServer.SocketServer, socketServer)),
64 Layer.provide(NodeClusterSocket.layerClientProtocol),
65 Layer.provide(ShardingConfig.layer({
66 runnerAddress: Option.some(RunnerAddress.make(HOST, port)),
67 entityTerminationTimeout: 0,
68 entityMessagePollInterval: 5000,
69 sendRetryInterval: 100
70 })),
71 Layer.provide(serialization),
72 Layer.build
73 )
74 return port
75 })
76
77 const makeClientLayer = (port: number) =>
78 SocketRunner.layerClientOnly.pipe(
79 Layer.provide(NodeClusterSocket.layerClientProtocol),
80 Layer.provide(ShardingConfig.layer({
81 runnerAddress: Option.some(RunnerAddress.make(HOST, port)),
82 runnerListenAddress: Option.some(RunnerAddress.make(HOST, port)),
83 entityTerminationTimeout: 0,
84 entityMessagePollInterval: 5000,
85 sendRetryInterval: 100
86 })),
87 Layer.provide(RpcSerialization.layerSchemaBinary())
88 )
89
90 const makeConfiguredClientLayer = (
91 port: number,
92 serialization?: "binary" | "ndjson",
93 serializationMaxBufferSize?: number | "unbounded"
94 ) =>
95 NodeClusterSocket.layer({
96 clientOnly: true,
97 storage: "byo",
98 ...(serialization === undefined ? undefined : { serialization }),
99 ...(serializationMaxBufferSize === undefined ? undefined : { serializationMaxBufferSize }),
100 shardingConfig: {
101 runnerAddress: Option.some(RunnerAddress.make(HOST, port)),
102 runnerListenAddress: Option.some(RunnerAddress.make(HOST, port)),
103 entityTerminationTimeout: 0,
104 entityMessagePollInterval: 5000,
105 sendRetryInterval: 100
106 }
107 })
108
109 const SerializationEntity = Entity
110 .make("SerializationEntity", [
111 Rpc.make("Ping", {
112 success: Schema.String
113 })
114 ])
115 .annotateRpcs(ClusterSchema.Persisted, false)
116
117 const SerializationEntityLayer = SerializationEntity.toLayer(
118 Effect.succeed({ Ping: () => Effect.succeed("pong") })
119 )
120
121 const assertSerialization = Effect.fnUntraced(function*(
122 serverSerialization: Layer.Layer<RpcSerialization.RpcSerialization>,
123 clientSerialization?: "binary" | "ndjson"
124 ) {
125 const port = yield* startRunner(SerializationEntityLayer, serverSerialization)
126
127 const result = yield* Effect.gen(function*() {
128 const makeClient = yield* SerializationEntity.client
129 return yield* makeClient("serialization-entity").Ping()
130 }).pipe(
131 Effect.provide(makeConfiguredClientLayer(port, clientSerialization)),
132 Effect.scoped
133 )
134
135 assert.strictEqual(result, "pong")
136 }, Effect.provide(SharedStorage))
137
138 // An entity whose reply cannot be serialized: the handler returns a
139 // non-integer for a `Schema.Int` success schema, so `Reply.serialize` fails
140 // on the host runner when encoding the reply for the wire.
141 const IsolationEntity = Entity
142 .make("IsolationEntity", [
143 Rpc.make("BadReply", {
144 payload: { id: Schema.Number },
145 success: Schema.Int
146 }),
147 Rpc.make("Slow", {
148 success: Schema.String
149 })
150 ])
151 .annotateRpcs(ClusterSchema.Persisted, false)
152
153 // BigDecimal.normalize creates a circular `normalized` self-reference.
154 // When a persisted message is sent with discard: true, the notify path in Runners.makeRpc
155 // passes the raw envelope (with circular BigDecimal payload) to the runner,
156 // causing RangeError: Maximum call stack size exceeded.
157 //
158 // Volatile discard should complete after the request is sent, without waiting for the
159 // host runner to finish handling it.
160 describe("SocketRunner", () => {
161 it.live(
162 "uses SchemaBinary by default for TCP connections",
163 () => assertSerialization(RpcSerialization.layerSchemaBinary()),
164 15_000
165 )
166
167 it.live(
168 "preserves an explicit binary selection",
169 () => assertSerialization(RpcSerialization.layerSchemaBinary(), "binary"),
170 15_000
171 )
172
173 it.live(
174 "applies serializationMaxBufferSize to the default SchemaBinary parser",
175 () =>
176 Effect.gen(function*() {
177 const port = yield* startRunner(SerializationEntityLayer)
178
179 yield* Effect.gen(function*() {
180 const makeClient = yield* SerializationEntity.client
181 assert.strictEqual(yield* makeClient("serialization-limit-entity").Ping(), "pong")
182 }).pipe(
183 Effect.provide(makeConfiguredClientLayer(port)),
184 Effect.scoped
185 )
186
187 const exit = yield* Effect.gen(function*() {
188 const makeClient = yield* SerializationEntity.client
189 return yield* makeClient("serialization-limit-entity").Ping().pipe(Effect.timeout("1 second"))
190 }).pipe(
191 Effect.provide(makeConfiguredClientLayer(port, undefined, 1)),
192 Effect.scoped,
193 Effect.exit
194 )
195
196 assert.isTrue(Exit.isFailure(exit), "the configured frame limit must reject the response")
197 }).pipe(Effect.provide(SharedStorage)),
198 15_000
199 )
200
201 it.live(
202 "discarded persisted requests serialize circular values and volatile requests do not wait for replies",
203 () =>
204 Effect.gen(function*() {
205 const volatileStarted = yield* Deferred.make<void>()
206 const releaseVolatile = yield* Deferred.make<void>()
207 const TestEntityLayer = TestEntity.toLayer(
208 Effect.succeed({
209 Process: () => Effect.void,
210 ProcessVolatile: () =>
211 Deferred.succeed(volatileStarted, void 0).pipe(
212 Effect.andThen(Deferred.await(releaseVolatile))
213 )
214 })
215 )
216
217 // Start the runner (with socket server and entity handler)
218 const port = yield* startRunner(TestEntityLayer)
219 yield* Effect.log("Before starting the client")
220
221 // Send a message from the client with discard: true.
222 // The BigDecimal is normalized to trigger the circular `normalized` self-reference.
223 yield* Effect.gen(function*() {
224 yield* Effect.log("Starting the client")
225 const makeClient = yield* TestEntity.client
226 const client = makeClient("entity-1")
227
228 const amount = BigDecimal.fromStringUnsafe("123.45")
229
230 yield* client.Process(
231 TestPayload.make({ id: "req-1", amount }),
232 { discard: true }
233 )
234
235 const volatileFiber = yield* client.ProcessVolatile(
236 TestPayload.make({ id: "req-2", amount }),
237 { discard: true }
238 ).pipe(Effect.forkChild)
239
240 yield* Deferred.await(volatileStarted).pipe(
241 Effect.timeoutOrElse({
242 duration: "5 seconds",
243 orElse: () => Effect.die("the volatile request never reached its handler")
244 })
245 )
246 yield* Fiber.join(volatileFiber).pipe(
247 Effect.timeoutOrElse({
248 duration: "1 second",
249 orElse: () => Effect.die("volatile discard waited for the entity reply")
250 })
251 )
252 yield* Deferred.succeed(releaseVolatile, void 0)
253 }).pipe(
254 Effect.provide(makeClientLayer(port)),
255 Effect.scoped
256 )
257 }).pipe(Effect.provide(
258 SharedStorage
259 )),
260 30_000
261 )
262
263 it.live(
264 "a reply serialization failure fails only its own request",
265 () =>
266 Effect.gen(function*() {
267 const slowStarted = yield* Deferred.make<void>()
268 const releaseSlow = yield* Deferred.make<void>()
269 const IsolationEntityLayer = IsolationEntity.toLayer(
270 Effect.succeed({
271 BadReply: () => Effect.succeed(1.5),
272 Slow: () =>
273 Deferred.succeed(slowStarted, void 0).pipe(
274 Effect.andThen(Deferred.await(releaseSlow)),
275 Effect.as("done")
276 )
277 })
278 )
279 const port = yield* startRunner(IsolationEntityLayer)
280
281 yield* Effect.gen(function*() {
282 const makeClient = yield* IsolationEntity.client
283
284 // a sibling request in flight on the same runner-to-runner connection
285 const slowFiber = yield* makeClient("slow-entity").Slow().pipe(Effect.forkChild)
286 yield* Deferred.await(slowStarted).pipe(
287 Effect.timeoutOrElse({
288 duration: "5 seconds",
289 orElse: () => Effect.die("the Slow request never reached its handler")
290 })
291 )
292
293 const badExit = yield* makeClient("bad-entity").BadReply({ id: 1 }).pipe(
294 Effect.exit,
295 Effect.ensuring(Deferred.succeed(releaseSlow, void 0))
296 )
297 assert.isTrue(Exit.isFailure(badExit), "the unencodable reply must fail the request")
298 const failure = Exit.isFailure(badExit) ? String(Cause.squash(badExit.cause)) : ""
299 assert.include(failure, "MalformedMessage", "the caller must receive the real encode error")
300 assert.notInclude(
301 failure,
302 "AlreadyProcessingMessage",
303 "the request must not be re-sent into the entity's dedup guard"
304 )
305
306 const slowExit = yield* Fiber.await(slowFiber)
307 assert.isTrue(
308 Exit.isSuccess(slowExit),
309 "a sibling in-flight request on the same connection must be unaffected"
310 )
311 if (Exit.isSuccess(slowExit)) {
312 assert.strictEqual(slowExit.value, "done")
313 }
314 }).pipe(
315 Effect.provide(makeClientLayer(port)),
316 Effect.scoped
317 )
318 }).pipe(Effect.provide(
319 SharedStorage
320 )),
321 30_000
322 )
323 })