@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 138 lines 5.75 KB
Raw
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 })