@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 804 lines 34 KB
Raw
1 import { NodeCrypto, NodeFileSystem } from "@effect/platform-node"
2 import { SqliteClient } from "@effect/sql-sqlite-node"
3 import { assert, describe, expect, it } from "@effect/vitest"
4 import { Effect, Exit, Fiber, FileSystem, Latch, Layer, Option } from "effect"
5 import {
6 Entity,
7 EntityAddress,
8 EntityId,
9 EntityType,
10 Envelope,
11 Message,
12 MessageStorage,
13 RunnerHealth,
14 Runners,
15 RunnerStorage,
16 ShardId,
17 Sharding,
18 ShardingConfig,
19 Snowflake,
20 SqlMessageStorage
21 } from "effect/cluster"
22 import { Reactivity } from "effect/reactivity"
23 import { SqlClient, Statement } from "effect/sql"
24 import { TestClock } from "effect/testing"
25 import { MssqlContainer } from "../fixtures/mssql-utils.ts"
26 import { MysqlContainer } from "../fixtures/mysql2-utils.ts"
27 import { PgContainer } from "../fixtures/pg-utils.ts"
28 import {
29 GetUserRpc,
30 LongKeyRpc,
31 makeAckChunk,
32 makeChunkReply,
33 makeReply,
34 makeRequest,
35 PrimaryKeyTest,
36 StreamRpc
37 } from "./MessageStorageTest.ts"
38
39 const TestEntity = Entity.make("test", [GetUserRpc])
40 const TestEntityLayer = TestEntity.toLayer({
41 GetUser: () => Effect.void
42 })
43
44 const StorageLayer = SqlMessageStorage.layer.pipe(
45 Layer.provideMerge(Snowflake.layerGenerator),
46 Layer.provide([ShardingConfig.layerDefaults, NodeCrypto.layerDigest])
47 )
48
49 const truncate = Effect.gen(function*() {
50 const sql = yield* SqlClient.SqlClient
51 yield* sql`DELETE FROM cluster_replies`
52 yield* sql`DELETE FROM cluster_messages`
53 })
54
55 describe("SqlMessageStorage", () => {
56 it.effect("preserves ids above 2^53 with a number-returning SQLite driver", () => {
57 let id = 9007199254740993n
58 return Effect.gen(function*() {
59 const storage = yield* MessageStorage.MessageStorage
60 const request = yield* makeRequest({
61 rpc: PrimaryKeyTest,
62 payload: PrimaryKeyTest.payloadSchema.make({ id: 123 })
63 })
64 const requestId = request.envelope.requestId
65 yield* storage.saveRequest(request)
66 const shards = [request.envelope.address.shardId]
67 const messages = yield* storage.unprocessedMessages(shards)
68 assert.strictEqual(messages.length, 1)
69 assert.strictEqual(messages[0].envelope.requestId, requestId)
70 assert.deepStrictEqual(yield* storage.unprocessedMessages(shards), [])
71
72 const reply = yield* makeReply(request)
73 yield* storage.saveReply(reply)
74 assert.deepStrictEqual(yield* storage.repliesFor([request]), [reply.reply])
75 yield* storage.resetShards(shards)
76 assert.deepStrictEqual(yield* storage.unprocessedMessages(shards), [])
77
78 const duplicate = yield* storage.saveRequest(
79 yield* makeRequest({ rpc: PrimaryKeyTest, payload: request.envelope.payload })
80 )
81 assert(duplicate._tag === "Duplicate")
82 assert.strictEqual(duplicate.originalId, requestId)
83 assert.deepStrictEqual(duplicate.lastReceivedReply, Option.some(reply.reply))
84 assert.deepStrictEqual(
85 yield* storage.requestIdForPrimaryKey({
86 address: request.envelope.address,
87 tag: request.envelope.tag,
88 id: "123"
89 }),
90 Option.some(requestId)
91 )
92 }).pipe(
93 Effect.provide(SqlMessageStorage.layer.pipe(
94 Layer.provide(NumberSqliteLayer),
95 Layer.provide([ShardingConfig.layerDefaults, NodeCrypto.layer])
96 )),
97 Effect.provideService(Snowflake.Generator, {
98 nextUnsafe: () => {
99 const next = Snowflake.Snowflake(id)
100 id += 2n
101 return next
102 },
103 setMachineId: () => Effect.void
104 })
105 )
106 })
107 ;([
108 ["pg", Layer.orDie(PgContainer.layerClient)],
109 ["mysql", Layer.orDie(MysqlContainer.layerClient)],
110 ["mssql", Layer.orDie(MssqlContainer.layerClient)],
111 ["sqlite", Layer.orDie(SqliteLayer)]
112 ] as const).forEach(([label, layer]) => {
113 // Tests truncate this backend's shared tables.
114 it.layer(StorageLayer.pipe(Layer.provideMerge(layer)), {
115 concurrent: false,
116 timeout: 120000
117 })(label, (it) => {
118 if (label === "pg") {
119 for (const reset of ["resetShards", "resetAddresses"] as const) {
120 it.effect(`${reset} does not deadlock with a concurrent message claim`, () =>
121 Effect.gen(function*() {
122 yield* truncate
123 const sql = yield* SqlClient.SqlClient
124 const storage = yield* SqlMessageStorage.makeEncoded().pipe(Effect.provide(NodeCrypto.layerDigest))
125 // Heap order is the reverse of the claim query's rowid order.
126 yield* sql`
127 INSERT INTO cluster_messages
128 (id, rowid, shard_id, entity_type, entity_id, kind, tag, payload, headers, processed, request_id)
129 VALUES
130 (2, 2, 'default:1', 'test', '1', 0, 'GetUser', '{}', '{}', FALSE, 2),
131 (1, 1, 'default:1', 'test', '1', 0, 'GetUser', '{}', '{}', FALSE, 1)
132 `
133 // Pause after the reset locks row 2, so the claim can lock row 1.
134 yield* sql`
135 CREATE FUNCTION cluster_test_slow_reset() RETURNS trigger AS $$
136 BEGIN
137 IF NEW.last_read IS NULL AND NEW.rowid = 2 THEN
138 PERFORM pg_sleep(2);
139 END IF;
140 RETURN NEW;
141 END $$ LANGUAGE plpgsql
142 `
143 yield* sql`
144 CREATE TRIGGER cluster_test_slow_reset BEFORE UPDATE ON cluster_messages
145 FOR EACH ROW EXECUTE FUNCTION cluster_test_slow_reset()
146 `
147 yield* Effect.gen(function*() {
148 const resetFiber = yield* Effect.gen(function*() {
149 // Make the unordered UPDATE use heap order regardless of indexes.
150 yield* sql`SET LOCAL enable_indexscan = off`
151 yield* sql`SET LOCAL enable_bitmapscan = off`
152 yield* reset === "resetShards"
153 ? storage.resetShards(["default:1"])
154 : storage.resetAddresses([EntityAddress.make({
155 shardId: ShardId.make("default", 1),
156 entityType: EntityType.make("test"),
157 entityId: EntityId.make("1")
158 })])
159 }).pipe(sql.withTransaction, Effect.exit, Effect.forkChild)
160 yield* Effect.gen(function*() {
161 while (true) {
162 const waiting = yield* sql`
163 SELECT 1 FROM pg_stat_activity
164 WHERE pid <> pg_backend_pid() AND wait_event = 'PgSleep'
165 AND query LIKE '%cluster_messages%'
166 `
167 if (waiting.length > 0) return
168 yield* Effect.sleep("10 millis")
169 }
170 }).pipe(Effect.timeout("5 seconds"))
171 const claim = yield* Effect.exit(storage.unprocessedMessages(["default:1"], Date.now()))
172 const resetResult = yield* Fiber.join(resetFiber)
173 expect(Exit.isSuccess(resetResult)).toBe(true)
174 assert(Exit.isSuccess(claim), String(claim))
175 expect(claim.value.map((message) => message.envelope.requestId)).toEqual(["1", "2"])
176 expect(yield* storage.unprocessedMessages(["default:1"], Date.now())).toHaveLength(0)
177 }).pipe(Effect.ensuring(
178 Effect.gen(function*() {
179 yield* sql`DROP TRIGGER cluster_test_slow_reset ON cluster_messages`
180 yield* sql`DROP FUNCTION cluster_test_slow_reset()`
181 yield* truncate
182 }).pipe(Effect.orDie)
183 ))
184 }).pipe(TestClock.withLive))
185 }
186
187 it.effect("creates an index for insertion-ordered message reads", () =>
188 Effect.gen(function*() {
189 const sql = yield* SqlClient.SqlClient
190 const indexes = yield* sql<{ indexname: string }>`
191 SELECT indexname
192 FROM pg_indexes
193 WHERE tablename = 'cluster_messages'
194 AND indexname = 'cluster_messages_rowid_idx'
195 `
196 expect(indexes).toHaveLength(1)
197 }))
198 }
199
200 if (label === "mssql") {
201 it.effect("rejects duplicate exit replies when another table has the same index name", () =>
202 Effect.gen(function*() {
203 const sql = yield* SqlClient.SqlClient
204 yield* sql`CREATE TABLE collision_other (id INT)`
205 yield* sql`CREATE INDEX collision_replies_one_exit ON collision_other (id)`
206 const storage = yield* SqlMessageStorage.makeEncoded({ prefix: "collision" }).pipe(
207 Effect.provide(NodeCrypto.layer)
208 )
209 const exit = { _tag: "WithExit", requestId: "1", exit: { _tag: "Success", value: null } } as const
210 yield* storage.saveReply({ ...exit, id: "1" })
211 const error = yield* Effect.flip(storage.saveReply({ ...exit, id: "2" }))
212 expect(error._tag).toEqual("PersistenceError")
213 }))
214 }
215
216 it.effect("resetRequests with no IDs leaves existing claims untouched", () =>
217 Effect.gen(function*() {
218 yield* truncate
219 const storage = yield* MessageStorage.MessageStorage
220 const request = yield* makeRequest()
221 yield* storage.saveRequest(request)
222 expect(yield* storage.unprocessedMessages([request.envelope.address.shardId])).toHaveLength(1)
223 yield* storage.resetRequests([])
224 expect(yield* storage.unprocessedMessages([request.envelope.address.shardId])).toHaveLength(0)
225 }))
226
227 it.effect("resetRequests releases only the selected request at a shared address", () =>
228 Effect.gen(function*() {
229 yield* truncate
230 const storage = yield* MessageStorage.MessageStorage
231 const selected = yield* makeRequest()
232 const unrelated = yield* makeRequest()
233 yield* storage.saveRequest(selected)
234 yield* storage.saveRequest(unrelated)
235 const shards = [selected.envelope.address.shardId]
236 expect(yield* storage.unprocessedMessages(shards)).toHaveLength(2)
237 yield* storage.resetRequests([selected.envelope.requestId])
238 const messages = yield* storage.unprocessedMessages(shards)
239 expect(messages.map((message) => message.envelope.requestId)).toEqual([selected.envelope.requestId])
240 expect(yield* storage.unprocessedMessages(shards)).toHaveLength(0)
241 }))
242
243 it.effect("resetRequests preserves chunk replies, exit replies, and completed state", () =>
244 Effect.gen(function*() {
245 yield* truncate
246 const storage = yield* MessageStorage.MessageStorage
247 const streaming = yield* makeRequest({ rpc: StreamRpc, payload: StreamRpc.payloadSchema.make({ id: 123 }) })
248 const completed = yield* makeRequest()
249 yield* storage.saveRequest(streaming)
250 yield* storage.saveRequest(completed)
251 const shards = [streaming.envelope.address.shardId]
252 expect(yield* storage.unprocessedMessages(shards)).toHaveLength(2)
253 yield* storage.saveReply(yield* makeChunkReply(streaming))
254 yield* storage.saveReply(yield* makeReply(completed))
255 const replies = yield* storage.repliesFor([streaming, completed])
256 expect(replies).toHaveLength(2)
257 expect(yield* storage.unprocessedMessages(shards)).toHaveLength(0)
258 const sql = yield* SqlClient.SqlClient
259 const processed = yield* sql`SELECT processed FROM cluster_messages ORDER BY rowid`
260 yield* storage.resetRequests([streaming.envelope.requestId, completed.envelope.requestId])
261 const messages = yield* storage.unprocessedMessages(shards)
262 // Replies keep both requests out of the SQL read loop.
263 expect(messages).toHaveLength(0)
264 expect(yield* storage.repliesFor([streaming, completed])).toEqual(replies)
265 expect(yield* sql`SELECT processed FROM cluster_messages ORDER BY rowid`).toEqual(processed)
266 yield* truncate
267 }))
268
269 it.effect("clearReplies requeues when the expected reply is current", () =>
270 Effect.gen(function*() {
271 yield* truncate
272 const storage = yield* MessageStorage.MessageStorage
273 const request = yield* makeRequest()
274 const reply = yield* makeReply(request)
275 yield* storage.saveRequest(request)
276 yield* storage.saveReply(reply)
277 yield* storage.clearReplies(request.envelope.requestId, { expectedReplyId: reply.reply.id })
278 expect(yield* storage.repliesFor([request])).toHaveLength(0)
279 expect(yield* storage.unprocessedMessages([request.envelope.address.shardId])).toHaveLength(1)
280 }))
281
282 it.effect("clearReplies with a stale expected reply preserves a newer completion and processed state", () =>
283 Effect.gen(function*() {
284 yield* truncate
285 const sql = yield* SqlClient.SqlClient
286 const storage = yield* MessageStorage.MessageStorage
287 const request = yield* makeRequest({ rpc: StreamRpc, payload: StreamRpc.payloadSchema.make({ id: 123 }) })
288 const oldReply = yield* makeChunkReply(request)
289 const completed = yield* makeReply(request)
290 yield* storage.saveRequest(request)
291 yield* storage.saveReply(oldReply)
292 yield* storage.saveReply(completed)
293 const before = yield* sql`SELECT processed, last_reply_id FROM cluster_messages WHERE id = ${
294 String(request.envelope.requestId)
295 }`.pipe(Effect.provideService(SqlClient.SafeIntegers, true))
296 yield* storage.clearReplies(request.envelope.requestId, { expectedReplyId: oldReply.reply.id })
297 expect((yield* storage.repliesFor([request])).map((r) => r.id)).toEqual([
298 oldReply.reply.id,
299 completed.reply.id
300 ])
301 expect(
302 yield* sql`SELECT processed, last_reply_id FROM cluster_messages WHERE id = ${
303 String(request.envelope.requestId)
304 }`.pipe(Effect.provideService(SqlClient.SafeIntegers, true))
305 ).toEqual(before)
306 expect(yield* storage.unprocessedMessages([request.envelope.address.shardId])).toHaveLength(0)
307 yield* truncate
308 }))
309
310 it.effect("saveRequest", () =>
311 Effect.gen(function*() {
312 const storage = yield* MessageStorage.MessageStorage
313 const request = yield* makeRequest({ payload: { id: 1 } })
314 const result = yield* storage.saveRequest(request)
315 expect(result._tag).toEqual("Success")
316
317 for (let i = 2; i <= 5; i++) {
318 yield* storage.saveRequest(yield* makeRequest({ payload: { id: i } }))
319 }
320
321 yield* storage.saveReply(yield* makeReply(request))
322
323 let messages = yield* storage.unprocessedMessages([request.envelope.address.shardId])
324 expect(messages).toHaveLength(4)
325 expect(messages.map((m: any) => m.envelope.payload.id)).toEqual([2, 3, 4, 5])
326
327 for (let i = 6; i <= 10; i++) {
328 yield* storage.saveRequest(yield* makeRequest({ payload: { id: i } }))
329 }
330 messages = yield* storage.unprocessedMessages([request.envelope.address.shardId])
331 expect(messages).toHaveLength(5)
332 expect(messages.map((m: any) => m.envelope.payload.id)).toEqual([6, 7, 8, 9, 10])
333 }))
334
335 it.effect("saveReply + saveRequest duplicate", () =>
336 Effect.gen(function*() {
337 const sql = yield* SqlClient.SqlClient
338 const storage = yield* MessageStorage.MessageStorage
339 const request = yield* makeRequest({
340 rpc: StreamRpc,
341 payload: StreamRpc.payloadSchema.make({ id: 123 })
342 })
343 let result = yield* storage.saveRequest(request)
344 expect(result._tag).toEqual("Success")
345
346 let chunk = yield* makeChunkReply(request, 0)
347 yield* storage.saveReply(chunk)
348 const ackChunk = yield* makeAckChunk(request, chunk)
349 yield* storage.saveEnvelope(ackChunk)
350
351 chunk = yield* makeChunkReply(request, 1)
352 yield* storage.saveReply(chunk)
353
354 result = yield* storage.saveRequest(
355 yield* makeRequest({
356 rpc: StreamRpc,
357 payload: StreamRpc.payloadSchema.make({ id: 123 })
358 })
359 )
360 assert(result._tag === "Duplicate" && Option.isSome(result.lastReceivedReply))
361 expect(result.lastReceivedReply.value._tag).toEqual("Chunk")
362
363 // get the un-acked chunk
364 const replies = yield* storage.repliesFor([request])
365 expect(replies).toHaveLength(1)
366
367 yield* storage.saveReply(yield* makeReply(request))
368
369 result = yield* storage.saveRequest(
370 yield* makeRequest({
371 rpc: StreamRpc,
372 payload: StreamRpc.payloadSchema.make({ id: 123 })
373 })
374 )
375 assert(result._tag === "Duplicate" && Option.isSome(result.lastReceivedReply))
376 expect(result.lastReceivedReply.value._tag).toEqual("WithExit")
377
378 // duplicate WithExit
379 const fiber = yield* storage.saveReply(yield* makeReply(request)).pipe(Effect.forkChild)
380 yield* TestClock.adjust(1)
381 while (!fiber.pollUnsafe()) {
382 yield* sql`SELECT 1`
383 yield* TestClock.adjust(1000)
384 }
385 const error = yield* Effect.flip(Fiber.join(fiber))
386 expect(error._tag).toEqual("PersistenceError")
387 }))
388
389 it.effect("detects duplicates", () =>
390 Effect.gen(function*() {
391 yield* truncate
392
393 const storage = yield* MessageStorage.MessageStorage
394 yield* storage.saveRequest(
395 yield* makeRequest({
396 rpc: PrimaryKeyTest,
397 payload: PrimaryKeyTest.payloadSchema.make({ id: 123 })
398 })
399 )
400 const result = yield* storage.saveRequest(
401 yield* makeRequest({
402 rpc: PrimaryKeyTest,
403 payload: PrimaryKeyTest.payloadSchema.make({ id: 123 })
404 })
405 )
406 expect(result._tag).toEqual("Duplicate")
407 }))
408
409 it.effect("hashes primary keys longer than the message_id column", () =>
410 Effect.gen(function*() {
411 yield* truncate
412
413 const storage = yield* MessageStorage.MessageStorage
414 const longId = "long-key-".repeat(50)
415 const request = yield* makeRequest({
416 rpc: LongKeyRpc,
417 payload: LongKeyRpc.payloadSchema.make({ id: longId })
418 })
419 const result = yield* storage.saveRequest(request)
420 expect(result._tag).toEqual("Success")
421
422 const duplicate = yield* storage.saveRequest(
423 yield* makeRequest({
424 rpc: LongKeyRpc,
425 payload: LongKeyRpc.payloadSchema.make({ id: longId })
426 })
427 )
428 expect(duplicate._tag).toEqual("Duplicate")
429
430 const requestId = yield* storage.requestIdForPrimaryKey({
431 address: request.envelope.address,
432 tag: request.envelope.tag,
433 id: longId
434 })
435 expect(requestId).toEqual(Option.some(request.envelope.requestId))
436
437 const sql = yield* SqlClient.SqlClient
438 const rows = yield* sql<{ message_id: string }>`SELECT message_id FROM cluster_messages`
439 expect(rows).toHaveLength(1)
440 expect(rows[0].message_id).toMatch(/^[0-9a-f]{64}$/)
441 }))
442
443 it.effect("keeps primary keys within the column width as plaintext", () =>
444 Effect.gen(function*() {
445 yield* truncate
446
447 const sql = yield* SqlClient.SqlClient
448 const storage = yield* MessageStorage.MessageStorage
449 const request = yield* makeRequest({
450 rpc: PrimaryKeyTest,
451 payload: PrimaryKeyTest.payloadSchema.make({ id: 456 })
452 })
453 yield* storage.saveRequest(request)
454
455 // rows written by previous versions store the plaintext composed
456 // key, so short keys must stay byte-identical to keep deduplicating
457 const plaintext = Envelope.primaryKey(request.envelope)!
458 const rows = yield* sql<{ message_id: string }>`SELECT message_id FROM cluster_messages`
459 expect(rows).toHaveLength(1)
460 expect(rows[0].message_id).toEqual(plaintext)
461
462 const result = yield* storage.saveRequest(
463 yield* makeRequest({
464 rpc: PrimaryKeyTest,
465 payload: PrimaryKeyTest.payloadSchema.make({ id: 456 })
466 })
467 )
468 assert(result._tag === "Duplicate")
469 expect(result.originalId).toEqual(request.envelope.requestId)
470
471 const requestId = yield* storage.requestIdForPrimaryKey({
472 address: request.envelope.address,
473 tag: request.envelope.tag,
474 id: "456"
475 })
476 expect(requestId).toEqual(Option.some(request.envelope.requestId))
477 }))
478
479 if (label === "sqlite") {
480 // sqlite's TEXT message_id column stored over-long plaintext keys
481 // before hashing, so the legacy fallback must also cover keys longer
482 // than the 255-character limit of the width-enforcing dialects
483 it.effect("detects duplicates for legacy long-key plaintext rows", () =>
484 Effect.gen(function*() {
485 yield* truncate
486
487 const sql = yield* SqlClient.SqlClient
488 const storage = yield* MessageStorage.MessageStorage
489 const longId = "legacy-long-key-".repeat(30)
490 const request = yield* makeRequest({
491 rpc: LongKeyRpc,
492 payload: LongKeyRpc.payloadSchema.make({ id: longId })
493 })
494 yield* storage.saveRequest(request)
495
496 // simulate a row written before message_id values were hashed
497 const plaintext = Envelope.primaryKey(request.envelope)!
498 expect(plaintext.length).toBeGreaterThan(255)
499 yield* sql`UPDATE cluster_messages SET message_id = ${plaintext} WHERE id = ${
500 String(request.envelope.requestId)
501 }`
502
503 const result = yield* storage.saveRequest(
504 yield* makeRequest({
505 rpc: LongKeyRpc,
506 payload: LongKeyRpc.payloadSchema.make({ id: longId })
507 })
508 )
509 assert(result._tag === "Duplicate")
510 expect(result.originalId).toEqual(request.envelope.requestId)
511
512 const requestId = yield* storage.requestIdForPrimaryKey({
513 address: request.envelope.address,
514 tag: request.envelope.tag,
515 id: longId
516 })
517 expect(requestId).toEqual(Option.some(request.envelope.requestId))
518 }))
519 }
520
521 it.effect("unprocessedMessages", () =>
522 Effect.gen(function*() {
523 yield* truncate
524
525 const storage = yield* MessageStorage.MessageStorage
526 const request = yield* makeRequest()
527 yield* storage.saveRequest(request)
528 let messages = yield* storage.unprocessedMessages([request.envelope.address.shardId])
529 expect(messages).toHaveLength(1)
530 messages = yield* storage.unprocessedMessages([request.envelope.address.shardId])
531 expect(messages).toHaveLength(0)
532 yield* storage.saveRequest(yield* makeRequest())
533 messages = yield* storage.unprocessedMessages([request.envelope.address.shardId])
534 expect(messages).toHaveLength(1)
535 }))
536
537 it.effect("unprocessedMessages honors the limit and claims only returned rows", () =>
538 Effect.gen(function*() {
539 yield* truncate
540
541 const storage = yield* MessageStorage.MessageStorage
542 const shardId = ShardId.make("default", 1)
543 for (let i = 1; i <= 5; i++) {
544 yield* storage.saveRequest(yield* makeRequest({ payload: { id: i }, entityId: String(i) }))
545 }
546 const limited = yield* storage.unprocessedMessages([shardId], { limit: 3 })
547 expect(limited).toHaveLength(3)
548 expect(limited.map((m: any) => m.envelope.payload.id)).toEqual([1, 2, 3])
549
550 // rows beyond the limit were not claimed and are returned by the
551 // next read
552 const rest = yield* storage.unprocessedMessages([shardId])
553 expect(rest.map((m: any) => m.envelope.payload.id)).toEqual([4, 5])
554 }))
555
556 it.effect("unprocessedMessages filters by address", () =>
557 Effect.gen(function*() {
558 yield* truncate
559
560 const storage = yield* MessageStorage.MessageStorage
561 const shardId = ShardId.make("default", 1)
562 const address = (entityId: string) =>
563 EntityAddress.make({
564 shardId,
565 entityType: EntityType.make("test"),
566 entityId: EntityId.make(entityId)
567 })
568 for (let i = 1; i <= 4; i++) {
569 yield* storage.saveRequest(yield* makeRequest({ payload: { id: i }, entityId: String(i) }))
570 }
571 const filtered = yield* storage.unprocessedMessages([shardId], {
572 addresses: [address("2"), address("4")]
573 })
574 expect(filtered.map((m: any) => m.envelope.payload.id)).toEqual([2, 4])
575
576 // the filtered read must not claim the other addresses
577 const rest = yield* storage.unprocessedMessages([shardId])
578 expect(rest.map((m: any) => m.envelope.payload.id)).toEqual([1, 3])
579 }))
580
581 it.effect("unprocessedMessages filters addresses by shard", () =>
582 Effect.gen(function*() {
583 yield* truncate
584
585 const storage = yield* MessageStorage.MessageStorage
586 const shardOne = ShardId.make("default", 1)
587 const shardTwo = ShardId.make("default", 2)
588 yield* storage.saveRequest(yield* makeRequest({ payload: { id: 1 }, shardId: shardOne }))
589 yield* storage.saveRequest(yield* makeRequest({ payload: { id: 2 }, shardId: shardTwo }))
590
591 const messages = yield* storage.unprocessedMessages([shardOne, shardTwo], {
592 addresses: [EntityAddress.make({
593 shardId: shardOne,
594 entityType: EntityType.make("test"),
595 entityId: EntityId.make("1")
596 })]
597 })
598 expect(messages.map((message: any) => message.envelope.payload.id)).toEqual([1])
599
600 const rest = yield* storage.unprocessedMessages([shardOne, shardTwo])
601 expect(rest.map((message: any) => message.envelope.payload.id)).toEqual([2])
602 }))
603
604 it.effect("encoded unprocessedMessages fails closed for empty addresses", () =>
605 Effect.gen(function*() {
606 yield* truncate
607
608 const storage = yield* MessageStorage.MessageStorage
609 const request = yield* makeRequest()
610 yield* storage.saveRequest(request)
611 const encoded = yield* SqlMessageStorage.makeEncoded().pipe(Effect.provide(NodeCrypto.layerDigest))
612 const shardId = request.envelope.address.shardId.toString()
613 const messages = yield* encoded.unprocessedMessages([shardId], Date.now(), { addresses: [] })
614 expect(messages).toHaveLength(0)
615
616 const unfiltered = yield* encoded.unprocessedMessages([shardId], Date.now())
617 expect(unfiltered).toHaveLength(1)
618 }))
619
620 it.effect("encoded resetAddresses fails closed for an empty address list", () =>
621 Effect.gen(function*() {
622 yield* truncate
623
624 const storage = yield* MessageStorage.MessageStorage
625 const request = yield* makeRequest()
626 yield* storage.saveRequest(request)
627 const encoded = yield* SqlMessageStorage.makeEncoded().pipe(Effect.provide(NodeCrypto.layerDigest))
628 const shardId = request.envelope.address.shardId.toString()
629 const claimed = yield* encoded.unprocessedMessages([shardId], Date.now())
630 expect(claimed).toHaveLength(1)
631
632 yield* encoded.resetAddresses([])
633 const messages = yield* encoded.unprocessedMessages([shardId], Date.now())
634 expect(messages).toHaveLength(0)
635 }))
636
637 it.effect("resetAddresses releases claims in one batch", () =>
638 Effect.gen(function*() {
639 yield* truncate
640
641 const storage = yield* MessageStorage.MessageStorage
642 const shardId = ShardId.make("default", 1)
643 const address = (entityId: string) =>
644 EntityAddress.make({
645 shardId,
646 entityType: EntityType.make("test"),
647 entityId: EntityId.make(entityId)
648 })
649 for (let i = 1; i <= 4; i++) {
650 yield* storage.saveRequest(yield* makeRequest({ payload: { id: i }, entityId: String(i) }))
651 }
652 yield* storage.unprocessedMessages([shardId], { limit: 3 })
653 yield* storage.resetAddresses([address("1"), address("3")])
654
655 const messages = yield* storage.unprocessedMessages([shardId])
656 expect(messages.map((m: any) => m.envelope.payload.id)).toEqual([1, 3, 4])
657 }))
658
659 it.effect("unprocessedMessages excludes complete requests", () =>
660 Effect.gen(function*() {
661 yield* truncate
662
663 const storage = yield* MessageStorage.MessageStorage
664 const request = yield* makeRequest()
665 yield* storage.saveRequest(request)
666 yield* storage.saveReply(yield* makeReply(request))
667 const messages = yield* storage.unprocessedMessages([request.envelope.address.shardId])
668 expect(messages).toHaveLength(0)
669 }))
670
671 it.effect("repliesFor", () =>
672 Effect.gen(function*() {
673 yield* truncate
674
675 const storage = yield* MessageStorage.MessageStorage
676 const request = yield* makeRequest()
677 yield* storage.saveRequest(request)
678 let replies = yield* storage.repliesFor([request])
679 expect(replies).toHaveLength(0)
680 yield* storage.saveReply(yield* makeReply(request))
681 replies = yield* storage.repliesFor([request])
682 expect(replies).toHaveLength(1)
683 expect(replies[0].requestId).toEqual(request.envelope.requestId)
684 }))
685
686 it.effect("registerReplyHandler", () =>
687 Effect.gen(function*() {
688 const storage = yield* MessageStorage.MessageStorage
689 const latch = yield* Latch.make()
690 const request = yield* makeRequest()
691 yield* storage.saveRequest(request)
692 const fiber = yield* storage.registerReplyHandler(
693 new Message.OutgoingRequest({
694 ...request,
695 respond: () => latch.open
696 })
697 ).pipe(Effect.forkChild)
698 yield* TestClock.adjust(1)
699 yield* storage.saveReply(yield* makeReply(request))
700 yield* latch.await
701 yield* Fiber.await(fiber)
702 }))
703
704 it.effect("unprocessedMessagesById", () =>
705 Effect.gen(function*() {
706 yield* truncate
707
708 const storage = yield* MessageStorage.MessageStorage
709 const request = yield* makeRequest({
710 rpc: StreamRpc,
711 payload: StreamRpc.payloadSchema.make({ id: 123 })
712 })
713 yield* storage.saveRequest(request)
714 let messages = yield* storage.unprocessedMessagesById([request.envelope.requestId])
715 expect(messages).toHaveLength(1)
716
717 const chunk = yield* makeChunkReply(request)
718 yield* storage.saveReply(chunk)
719 const ack = yield* makeAckChunk(request, chunk)
720 yield* storage.saveEnvelope(ack)
721
722 const encoded = yield* SqlMessageStorage.makeEncoded().pipe(Effect.provide(NodeCrypto.layerDigest))
723 const acknowledgements = yield* encoded.unprocessedMessagesById([ack.envelope.id], 0)
724 expect(acknowledgements).toHaveLength(1)
725 assert(acknowledgements[0].envelope._tag === "AckChunk")
726 expect(acknowledgements[0].envelope.replyId).toEqual(String(chunk.reply.id))
727
728 yield* storage.saveReply(yield* makeReply(request))
729 messages = yield* storage.unprocessedMessagesById([request.envelope.requestId])
730 expect(messages).toHaveLength(0)
731 }))
732 })
733 })
734
735 it.effect("keeps held messages readable while entity layers build", () =>
736 Effect.gen(function*() {
737 const config = ShardingConfig.layer({
738 entityRegistrationTimeout: 6000,
739 entityTerminationTimeout: 0,
740 entityMessagePollInterval: 100,
741 refreshAssignmentsInterval: 0
742 })
743 const delayedEnv = TestEntityLayer.pipe(
744 Layer.provide(Layer.effectDiscard(Effect.sleep(10_000))),
745 Layer.provideMerge(Sharding.layer),
746 Layer.provide(RunnerStorage.layerMemory),
747 Layer.provide(RunnerHealth.layerNoop),
748 Layer.provide(Runners.layerNoop),
749 Layer.provide(config)
750 )
751 const storage = yield* MessageStorage.MessageStorage
752 const request = yield* makeRequest()
753 yield* storage.saveRequest(request)
754
755 const fiber = yield* Effect.never.pipe(
756 Effect.provide(delayedEnv),
757 Effect.scoped,
758 Effect.forkChild({ startImmediately: true })
759 )
760
761 yield* TestClock.adjust(7500)
762 expect(yield* storage.repliesFor([request])).toHaveLength(0)
763
764 yield* TestClock.adjust(2500)
765 yield* TestClock.adjust(100)
766 expect(yield* storage.repliesFor([request])).toHaveLength(1)
767 yield* Fiber.interrupt(fiber)
768 }).pipe(Effect.provide(StorageLayer.pipe(
769 Layer.provideMerge(SqliteLayer)
770 ))), { timeout: 15_000 })
771 })
772
773 const SqliteLayer = Effect.gen(function*() {
774 const fs = yield* FileSystem.FileSystem
775 const dir = yield* fs.makeTempDirectoryScoped()
776 return SqliteClient.layer({
777 filename: dir + "/test.db"
778 })
779 }).pipe(Layer.unwrap, Layer.provide(NodeFileSystem.layer))
780
781 const NumberSqliteLayer = Layer.effect(
782 SqlClient.SqlClient,
783 Effect.gen(function*() {
784 const sqlite = yield* SqliteClient.make({ filename: ":memory:" })
785 const connection = yield* sqlite.reserve
786 // Model drivers such as Durable Objects that return INTEGERs as numbers, even with SafeIntegers.
787 const roundRows = (rows: ReadonlyArray<Record<string, unknown>>) =>
788 rows.map((row) =>
789 Object.fromEntries(
790 Object.entries(row).map(([key, value]) => [key, typeof value === "bigint" ? Number(value) : value])
791 )
792 )
793 return yield* SqlClient.make({
794 driver: "sqlite-number",
795 compiler: Statement.makeCompilerSqlite(),
796 spanAttributes: [],
797 acquirer: Effect.succeed({
798 ...connection,
799 execute: (...args) => connection.execute(...args).pipe(Effect.map(roundRows)),
800 executeUnprepared: (...args) => connection.executeUnprepared(...args).pipe(Effect.map(roundRows))
801 })
802 })
803 })
804 ).pipe(Layer.provide(Reactivity.layer))