socketduct 0.1.17 → 0.1.19

package/test/integration/reverse-route-class.test.js

@@ -132,8 +132,8 @@ test("route-class clients fail closed per OPEN while unaffected routes and legac
     hub: {host: "127.0.0.1", port: hub.port, token: "gateway-a-token"},
     tls,
     authorizeTarget: (target) => target.host === targetA.host && target.port === targetA.port,
-    reconnectDelayMs: 10_000,
-    maxReconnectDelayMs: 10_000
+    reconnectDelayMs: 10,
+    maxReconnectDelayMs: 20
   })
   const gatewayB = new OutboundReverseGateway({
     gatewayId: "server-b-starlink",
@@ -141,8 +141,8 @@ test("route-class clients fail closed per OPEN while unaffected routes and legac
     hub: {host: "127.0.0.1", port: hub.port, token: "gateway-b-token"},
     tls,
     authorizeTarget: (target) => target.host === targetB.host && target.port === targetB.port,
-    reconnectDelayMs: 10_000,
-    maxReconnectDelayMs: 10_000
+    reconnectDelayMs: 10,
+    maxReconnectDelayMs: 20
   })
   t.after(() => gatewayA.close())
   t.after(() => gatewayB.close())
@@ -206,18 +206,22 @@ test("route-class clients fail closed per OPEN while unaffected routes and legac
   await Promise.all([onceEvent(streamA, "connect"), onceEvent(streamB, "connect")])
   assert.deepEqual(await Promise.all([exchange(streamA, "one"), exchange(streamB, "two")]), ["a:one", "b:two"])
 
-  const streamAError = nextError(streamA)
+  const resumed = Promise.all([onceEvent(streamA, "ready"), onceEvent(streamB, "ready")])
   await hub.closeActiveGateway("server-a-starlink")
-  assert.equal((await streamAError).code, "GATEWAY_DISCONNECTED")
-  await waitUntil(() => hub.status().healthyGateways === 1, "gateway A disconnect")
-
-  const disconnected = client.createConnection({host: targetA.host, port: targetA.port})
-  assert.equal((await nextError(disconnected)).code, "GATEWAY_UNAVAILABLE")
+  await withTimeout(resumed, "route-class streams resume after gateway transport replacement")
+  await waitUntil(() => hub.status().healthyGateways === 2, "gateway A re-registration")
+  assert.equal(await exchange(streamA, "resumed"), "a:resumed")
   assert.equal(await exchange(streamB, "still-open"), "b:still-open")
+
+  const anotherA = client.createConnection({host: targetA.host, port: targetA.port})
+  await onceEvent(anotherA, "connect")
+  assert.equal(await exchange(anotherA, "new-a"), "a:new-a")
   const anotherB = client.createConnection({host: targetB.host, port: targetB.port})
   await onceEvent(anotherB, "connect")
   assert.equal(await exchange(anotherB, "new"), "b:new")
 
+  streamA.destroy()
+  anotherA.destroy()
   await gatewayA.close()
   const replacementA = new OutboundReverseGateway({
     gatewayId: "server-a-starlink",
@@ -232,7 +236,7 @@ test("route-class clients fail closed per OPEN while unaffected routes and legac
   const rejoinedA = client.createConnection({host: targetA.host, port: targetA.port})
   await onceEvent(rejoinedA, "connect")
   assert.equal(await exchange(rejoinedA, "rejoined"), "a:rejoined")
-  assert.equal(client.status().physicalConnects, 1)
+  assert(client.status().physicalConnects >= 2)
   assert.equal(hub.status().clientPhysicalConnections, 1)
   streamB.destroy()
   anotherB.destroy()
@@ -360,7 +364,7 @@ test("a backpressured gateway does not block DATA or a new OPEN for another rout
     t.after(() => socket.destroy())
     return nextError(socket)
   })
-  assert.equal((await withTimeout(streamAError, "gateway A output limit")).code, "GATEWAY_DISCONNECTED")
+  assert.equal((await withTimeout(streamAError, "gateway A output limit")).code, "OUTPUT_BACKPRESSURE_LIMIT")
   await withTimeout(Promise.all(queuedAErrors), "queued gateway A stream cleanup")
   assert.equal(await exchange(streamB, "after-limit"), "b:after-limit")
   assert.equal(hub.status().healthyGateways, 1)

package/test/unit/client/multiplexed-transport-set.test.js

@@ -289,6 +289,17 @@ test("route-class members are first-class reverse transports with route-class al
   assert(connectionIds.every((connectionId) => typeof connectionId === "string"))
   assert.equal(new Set(connectionIds).size, 2)
 
+  assert.throws(() => set.recoverConnection(/** @type {Parameters<MultiplexedSocketductTransportSet['recoverConnection']>[0]} */ (/** @type {unknown} */ ({host: "target.internal", port: 443, identifier: "route_stream_01"}))), /exactly one.*gatewayId.*routeClass/i)
+  assert.throws(() => set.recoverConnection(/** @type {Parameters<MultiplexedSocketductTransportSet['recoverConnection']>[0]} */ (/** @type {unknown} */ ({gatewayId: "starlink", routeClass: "zyxel", host: "target.internal", port: 443, identifier: "route_stream_01"}))), /exactly one.*gatewayId.*routeClass/i)
+  assert.throws(() => set.recoverConnection({routeClass: "missing", host: "target.internal", port: 443, identifier: "route_stream_01"}), /unknown routeClass/i)
+  const recovered = set.recoverConnection({routeClass: "zyxel", host: "target.internal", port: 443, identifier: "route_stream_01", sessionName: "durable-route"})
+  assert.equal(/** @type {{gatewayId?: string}} */ (recovered).gatewayId, undefined)
+  assert.equal(/** @type {{routeClass?: string}} */ (recovered).routeClass, "zyxel")
+  assert.equal(Object.getOwnPropertyDescriptor(recovered, "routeClass")?.writable, false)
+  assert.deepEqual(members.map((member) => member.opens), [0, 1])
+  assert.equal(/** @type {{recover?: unknown}} */ (at(members, 1).recoveryConnectionCalls[0]).recover, true)
+  assert.equal(Object.hasOwn(/** @type {object} */ (at(members, 1).recoveryConnectionCalls[0]), "routeClass"), false)
+
   const started = set.start()
   at(members, 0).ready()
   await started
@@ -845,7 +856,7 @@ test("pending socket end reserves and sends DataView bytes", async () => {
   await set.close()
 })
 
-test("recovery requires an original configured gateway and registration before start", async () => {
+test("recovery requires one original configured selector and registration before start", async () => {
   const {set, members} = fixture()
   assert.throws(() => set.recoverConnection(/** @type {Parameters<MultiplexedSocketductTransportSet['recoverConnection']>[0]} */ (/** @type {unknown} */ ({host: "target.internal", port: 443, identifier: "stable_stream_01"}))), /gatewayId/i)
   assert.throws(() => set.recoverConnection({gatewayId: "unknown", host: "target.internal", port: 443, identifier: "stable_stream_01"}), /unknown gatewayId/i)

package/test/unit/spool/spool-file.test.js

@@ -191,6 +191,139 @@ test("SessionSpool synchronously rejects expired durable recovery state", async
   })
 })
 
+test("SessionSpool loadChunksSync restores only unacknowledged owned chunks", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_recovery_chunks"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("old")})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("new")})
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 3, 6)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [6])
+    assert.equal(chunks[0]?.data.toString(), "new")
+    assert.equal(spool.getUsedBytes(sessionId), 3)
+    assert.throws(
+      () => spool.loadChunksSync(sessionId, "other-owner", 3, 6),
+      /Invalid Socketduct recovery chunks/
+    )
+  })
+})
+
+test("SessionSpool recovery repairs interruption after chunk append before usage update", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_append_interruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    const committed = await readFile(chunksPath, "utf8")
+    await writeFile(chunksPath, `${committed}${JSON.stringify({sequence: 6, dataBase64: Buffer.from("two").toString("base64")})}\n`)
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [3])
+    assert.equal(await readFile(chunksPath, "utf8"), committed)
+    assert.deepEqual(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8")), {totalBytes: 3})
+    assert.equal((await stat(chunksPath)).mode & 0o777, 0o600)
+    assert.equal((await stat(join(root, sessionId, "usage.json"))).mode & 0o777, 0o600)
+  })
+})
+
+test("SessionSpool recovery repairs interruption after usage update before recovery commit", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_usage_interruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [3])
+    assert.deepEqual(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8")), {totalBytes: 3})
+  })
+})
+
+test("SessionSpool recovery repairs interruption after acknowledged chunk truncation", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_truncate_interruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    await writeFile(chunksPath, `${JSON.stringify({sequence: 6, dataBase64: Buffer.from("two").toString("base64")})}\n`)
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 3, 6)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [6])
+    assert.deepEqual(JSON.parse(await readFile(join(root, sessionId, "usage.json"), "utf8")), {totalBytes: 3})
+  })
+})
+
+test("SessionSpool recovery repairs a partial trailing JSONL record after committed chunks", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_partial_interruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 6, data: Buffer.from("two")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    const committed = await readFile(chunksPath, "utf8")
+    await writeFile(chunksPath, `${committed}{"sequence":9,"dataBase64":"thr`)
+
+    const chunks = spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 6)
+
+    assert.deepEqual(chunks.map((chunk) => chunk.sequence), [3, 6])
+    assert.equal(await readFile(chunksPath, "utf8"), committed)
+  })
+})
+
+test("SessionSpool recovery rejects corruption before or outside a partial uncommitted tail", async () => {
+  await withTempDir(async (root) => {
+    const sessionId = "session_committed_corruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    await writeFile(chunksPath, `${await readFile(chunksPath, "utf8")}{"sequence":6,"dataBase64":"tw`)
+
+    assert.throws(
+      () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 6),
+      /Invalid Socketduct recovery chunks/
+    )
+  })
+
+  await withTempDir(async (root) => {
+    const sessionId = "session_tail_corruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    const chunksPath = join(root, sessionId, "chunks.jsonl")
+    await writeFile(chunksPath, `${await readFile(chunksPath, "utf8")}{not-json}\n`)
+
+    assert.throws(
+      () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3),
+      /Invalid Socketduct recovery chunks/
+    )
+  })
+
+  await withTempDir(async (root) => {
+    const sessionId = "session_usage_corruption"
+    const spool = new SessionSpool({rootDir: root, maxBytes: 16})
+    await spool.createNew({sessionId, ownerId: "reverse-client-v3"})
+    await spool.appendChunk({sessionId, ownerId: "reverse-client-v3", sequence: 3, data: Buffer.from("one")})
+    await writeFile(join(root, sessionId, "usage.json"), "{not-json\n")
+
+    assert.throws(
+      () => spool.loadChunksSync(sessionId, "reverse-client-v3", 0, 3),
+      /Invalid Socketduct recovery chunks/
+    )
+  })
+})
+
 test("SessionSpool cleans expired abandoned entries so their stable IDs can be reused", async () => {
   await withTempDir(async (root) => {
     let now = 1_000_000