The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import { NodeRedis } from "@effect/platform-node" |
| 2 | import { describe, it } from "@effect/vitest" |
| 3 | import { Deferred, Effect, Fiber, Layer } from "effect" |
| 4 | import { Redis } from "effect/persistence" |
| 5 | import * as Net from "node:net" |
| 6 | |
| 7 | // A loopback peer that accepts a connection and, unless `onData` replies, |
| 8 | // never answers. |
| 9 | const makePeer = Effect.fnUntraced(function*(onData?: (socket: Net.Socket, data: string) => void) { |
| 10 | const received = yield* Deferred.make<void>() |
| 11 | const closed = yield* Deferred.make<void>() |
| 12 | const sockets = new Set<Net.Socket>() |
| 13 | const server = Net.createServer((socket) => { |
| 14 | sockets.add(socket) |
| 15 | socket.on("error", () => {}) |
| 16 | socket.once("data", () => Deferred.doneUnsafe(received, Effect.void)) |
| 17 | if (onData) socket.on("data", (data) => onData(socket, data.toString())) |
| 18 | socket.once("close", () => Deferred.doneUnsafe(closed, Effect.void)) |
| 19 | }) |
| 20 | yield* Effect.acquireRelease( |
| 21 | Effect.callback<void>((resume) => { |
| 22 | server.listen(0, "127.0.0.1", () => resume(Effect.void)) |
| 23 | }), |
| 24 | () => |
| 25 | Effect.callback<void>((resume) => { |
| 26 | for (const socket of sockets) socket.destroy() |
| 27 | server.close(() => resume(Effect.void)) |
| 28 | }) |
| 29 | ) |
| 30 | const port = (server.address() as Net.AddressInfo).port |
| 31 | return { port, received, closed } as const |
| 32 | }) |
| 33 | |
| 34 | // A peer that answers every command with `+OK`, except those `stall` matches, |
| 35 | // which never get a reply. Connections are numbered in the order they first |
| 36 | // send data, so the shared client is connection 0. |
| 37 | const makeStallingPeer = Effect.fnUntraced(function*(stall: (connection: number, command: string) => boolean) { |
| 38 | const stalled = yield* Deferred.make<void>() |
| 39 | const closed = yield* Deferred.make<void>() |
| 40 | const connections = new Map<Net.Socket, number>() |
| 41 | const { port } = yield* makePeer((socket, data) => { |
| 42 | if (!connections.has(socket)) connections.set(socket, connections.size) |
| 43 | for (const [, command] of data.matchAll(/\*\d+\r\n\$\d+\r\n(\w+)\r\n/g)) { |
| 44 | if (stall(connections.get(socket)!, command.toUpperCase())) { |
| 45 | socket.once("close", () => Deferred.doneUnsafe(closed, Effect.void)) |
| 46 | Deferred.doneUnsafe(stalled, Effect.void) |
| 47 | } else { |
| 48 | socket.write("+OK\r\n") |
| 49 | } |
| 50 | } |
| 51 | }) |
| 52 | const layer = NodeRedis.layer({ |
| 53 | socket: { host: "127.0.0.1", port }, |
| 54 | // Keep every connection's handshake to `SELECT`. |
| 55 | database: 1, |
| 56 | RESP: 2, |
| 57 | disableClientInfo: true, |
| 58 | maintNotifications: "disabled" |
| 59 | }) |
| 60 | return { layer, stalled, closed } as const |
| 61 | }) |
| 62 | |
| 63 | describe("NodeRedis", () => { |
| 64 | for (const tls of [false, true]) { |
| 65 | it.live(`interrupts a stalled ${tls ? "TLS" : "Redis"} handshake`, () => |
| 66 | Effect.gen(function*() { |
| 67 | const peer = yield* makePeer() |
| 68 | const fiber = yield* Layer.build(NodeRedis.layer({ |
| 69 | socket: tls ? { host: "127.0.0.1", port: peer.port, tls } : { host: "127.0.0.1", port: peer.port }, |
| 70 | // `SELECT` guarantees a handshake on every node-redis version. |
| 71 | database: 1 |
| 72 | })).pipe(Effect.scoped, Effect.forkChild) |
| 73 | yield* Deferred.await(peer.received) |
| 74 | yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds")) |
| 75 | yield* Deferred.await(peer.closed) |
| 76 | })) |
| 77 | } |
| 78 | |
| 79 | it.live("bounds shutdown while a command is stalled", () => |
| 80 | Effect.gen(function*() { |
| 81 | const stalled = yield* Deferred.make<void>() |
| 82 | const ended = yield* Deferred.make<void>() |
| 83 | const peer = yield* makePeer((socket, data) => { |
| 84 | // Complete the connection handshake, but never reply to PING. |
| 85 | for (const [, command] of data.matchAll(/\*\d+\r\n\$\d+\r\n(\w+)\r\n/g)) { |
| 86 | if (command === "PING") Deferred.doneUnsafe(stalled, Effect.void) |
| 87 | else socket.write("+OK\r\n") |
| 88 | } |
| 89 | }) |
| 90 | const fiber = yield* Effect.gen(function*() { |
| 91 | const { client } = yield* NodeRedis.NodeRedis |
| 92 | client.once("end", () => Deferred.doneUnsafe(ended, Effect.void)) |
| 93 | const redis = yield* Redis.Redis |
| 94 | yield* redis.send("PING") |
| 95 | }).pipe( |
| 96 | Effect.provide(NodeRedis.layer({ |
| 97 | socket: { host: "127.0.0.1", port: peer.port }, |
| 98 | // Keep the connection handshake to at most `HELLO`. |
| 99 | RESP: 2, |
| 100 | disableClientInfo: true, |
| 101 | maintNotifications: "disabled" |
| 102 | })), |
| 103 | Effect.forkChild |
| 104 | ) |
| 105 | yield* Deferred.await(stalled) |
| 106 | yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds")) |
| 107 | yield* Deferred.await(peer.closed) |
| 108 | // The client is fully destroyed, not just disconnected by the abort signal. |
| 109 | yield* Deferred.await(ended) |
| 110 | })) |
| 111 | |
| 112 | for (const command of ["SELECT", "SUBSCRIBE"]) { |
| 113 | it.live(`interrupts a subscriber stalled on ${command}`, () => |
| 114 | Effect.gen(function*() { |
| 115 | const peer = yield* makeStallingPeer((connection, received) => connection > 0 && received === command) |
| 116 | const fiber = yield* Effect.gen(function*() { |
| 117 | const redis = yield* Redis.Redis |
| 118 | yield* redis.subscribe("channel") |
| 119 | }).pipe(Effect.scoped, Effect.provide(peer.layer), Effect.forkChild) |
| 120 | yield* Deferred.await(peer.stalled) |
| 121 | yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds")) |
| 122 | yield* Deferred.await(peer.closed) |
| 123 | })) |
| 124 | } |
| 125 | |
| 126 | it.live("interrupts a stalled reserved connection", () => |
| 127 | Effect.gen(function*() { |
| 128 | const peer = yield* makeStallingPeer((connection, received) => connection > 0 && received === "SELECT") |
| 129 | const fiber = yield* Effect.gen(function*() { |
| 130 | const redis = yield* Redis.Redis |
| 131 | yield* redis.reserve |
| 132 | }).pipe(Effect.scoped, Effect.provide(peer.layer), Effect.forkChild) |
| 133 | yield* Deferred.await(peer.stalled) |
| 134 | yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds")) |
| 135 | // The connection attempt is aborted rather than left to open later. |
| 136 | yield* Deferred.await(peer.closed) |
| 137 | })) |
| 138 | }) |