mirror of
https://github.com/Effect-TS/effect.git
synced 2026-11-21 02:01:57 +08:00
139 lines
5.8 KiB
TypeScript
139 lines
5.8 KiB
TypeScript
import { NodeRedis } from "@effect/platform-node"
|
|
import { describe, it } from "@effect/vitest"
|
|
import { Deferred, Effect, Fiber, Layer } from "effect"
|
|
import { Redis } from "effect/persistence"
|
|
import * as Net from "node:net"
|
|
|
|
// A loopback peer that accepts a connection and, unless `onData` replies,
|
|
// never answers.
|
|
const makePeer = Effect.fnUntraced(function*(onData?: (socket: Net.Socket, data: string) => void) {
|
|
const received = yield* Deferred.make<void>()
|
|
const closed = yield* Deferred.make<void>()
|
|
const sockets = new Set<Net.Socket>()
|
|
const server = Net.createServer((socket) => {
|
|
sockets.add(socket)
|
|
socket.on("error", () => {})
|
|
socket.once("data", () => Deferred.doneUnsafe(received, Effect.void))
|
|
if (onData) socket.on("data", (data) => onData(socket, data.toString()))
|
|
socket.once("close", () => Deferred.doneUnsafe(closed, Effect.void))
|
|
})
|
|
yield* Effect.acquireRelease(
|
|
Effect.callback<void>((resume) => {
|
|
server.listen(0, "127.0.0.1", () => resume(Effect.void))
|
|
}),
|
|
() =>
|
|
Effect.callback<void>((resume) => {
|
|
for (const socket of sockets) socket.destroy()
|
|
server.close(() => resume(Effect.void))
|
|
})
|
|
)
|
|
const port = (server.address() as Net.AddressInfo).port
|
|
return { port, received, closed } as const
|
|
})
|
|
|
|
// A peer that answers every command with `+OK`, except those `stall` matches,
|
|
// which never get a reply. Connections are numbered in the order they first
|
|
// send data, so the shared client is connection 0.
|
|
const makeStallingPeer = Effect.fnUntraced(function*(stall: (connection: number, command: string) => boolean) {
|
|
const stalled = yield* Deferred.make<void>()
|
|
const closed = yield* Deferred.make<void>()
|
|
const connections = new Map<Net.Socket, number>()
|
|
const { port } = yield* makePeer((socket, data) => {
|
|
if (!connections.has(socket)) connections.set(socket, connections.size)
|
|
for (const [, command] of data.matchAll(/\*\d+\r\n\$\d+\r\n(\w+)\r\n/g)) {
|
|
if (stall(connections.get(socket)!, command.toUpperCase())) {
|
|
socket.once("close", () => Deferred.doneUnsafe(closed, Effect.void))
|
|
Deferred.doneUnsafe(stalled, Effect.void)
|
|
} else {
|
|
socket.write("+OK\r\n")
|
|
}
|
|
}
|
|
})
|
|
const layer = NodeRedis.layer({
|
|
socket: { host: "127.0.0.1", port },
|
|
// Keep every connection's handshake to `SELECT`.
|
|
database: 1,
|
|
RESP: 2,
|
|
disableClientInfo: true,
|
|
maintNotifications: "disabled"
|
|
})
|
|
return { layer, stalled, closed } as const
|
|
})
|
|
|
|
describe("NodeRedis", () => {
|
|
for (const tls of [false, true]) {
|
|
it.live(`interrupts a stalled ${tls ? "TLS" : "Redis"} handshake`, () =>
|
|
Effect.gen(function*() {
|
|
const peer = yield* makePeer()
|
|
const fiber = yield* Layer.build(NodeRedis.layer({
|
|
socket: tls ? { host: "127.0.0.1", port: peer.port, tls } : { host: "127.0.0.1", port: peer.port },
|
|
// `SELECT` guarantees a handshake on every node-redis version.
|
|
database: 1
|
|
})).pipe(Effect.scoped, Effect.forkChild)
|
|
yield* Deferred.await(peer.received)
|
|
yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds"))
|
|
yield* Deferred.await(peer.closed)
|
|
}))
|
|
}
|
|
|
|
it.live("bounds shutdown while a command is stalled", () =>
|
|
Effect.gen(function*() {
|
|
const stalled = yield* Deferred.make<void>()
|
|
const ended = yield* Deferred.make<void>()
|
|
const peer = yield* makePeer((socket, data) => {
|
|
// Complete the connection handshake, but never reply to PING.
|
|
for (const [, command] of data.matchAll(/\*\d+\r\n\$\d+\r\n(\w+)\r\n/g)) {
|
|
if (command === "PING") Deferred.doneUnsafe(stalled, Effect.void)
|
|
else socket.write("+OK\r\n")
|
|
}
|
|
})
|
|
const fiber = yield* Effect.gen(function*() {
|
|
const { client } = yield* NodeRedis.NodeRedis
|
|
client.once("end", () => Deferred.doneUnsafe(ended, Effect.void))
|
|
const redis = yield* Redis.Redis
|
|
yield* redis.send("PING")
|
|
}).pipe(
|
|
Effect.provide(NodeRedis.layer({
|
|
socket: { host: "127.0.0.1", port: peer.port },
|
|
// Keep the connection handshake to at most `HELLO`.
|
|
RESP: 2,
|
|
disableClientInfo: true,
|
|
maintNotifications: "disabled"
|
|
})),
|
|
Effect.forkChild
|
|
)
|
|
yield* Deferred.await(stalled)
|
|
yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds"))
|
|
yield* Deferred.await(peer.closed)
|
|
// The client is fully destroyed, not just disconnected by the abort signal.
|
|
yield* Deferred.await(ended)
|
|
}))
|
|
|
|
for (const command of ["SELECT", "SUBSCRIBE"]) {
|
|
it.live(`interrupts a subscriber stalled on ${command}`, () =>
|
|
Effect.gen(function*() {
|
|
const peer = yield* makeStallingPeer((connection, received) => connection > 0 && received === command)
|
|
const fiber = yield* Effect.gen(function*() {
|
|
const redis = yield* Redis.Redis
|
|
yield* redis.subscribe("channel")
|
|
}).pipe(Effect.scoped, Effect.provide(peer.layer), Effect.forkChild)
|
|
yield* Deferred.await(peer.stalled)
|
|
yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds"))
|
|
yield* Deferred.await(peer.closed)
|
|
}))
|
|
}
|
|
|
|
it.live("interrupts a stalled reserved connection", () =>
|
|
Effect.gen(function*() {
|
|
const peer = yield* makeStallingPeer((connection, received) => connection > 0 && received === "SELECT")
|
|
const fiber = yield* Effect.gen(function*() {
|
|
const redis = yield* Redis.Redis
|
|
yield* redis.reserve
|
|
}).pipe(Effect.scoped, Effect.provide(peer.layer), Effect.forkChild)
|
|
yield* Deferred.await(peer.stalled)
|
|
yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds"))
|
|
// The connection attempt is aborted rather than left to open later.
|
|
yield* Deferred.await(peer.closed)
|
|
}))
|
|
})
|