@threadedstack/wmd-web 0.0.0-stage → 0.1.12

package/src/net/wisp-transport.js

@@ -0,0 +1,196 @@
+// W71: TCP streams over a Wisp relay for code in the page itself (no guest network stack), with
+// the Transport interface wmn's createRelayFetch takes (TLS runs in the page; the relay carries
+// ciphertext only):
+//
+//   const t = createWispTransport({ url: 'local' })            // or 'hosted', or a ws(s):// URL
+//   const fetch = createRelayFetch({ transport: t })            // wmn: packages/ai/src/relay/fetch.ts
+//   const s = await t.connect('registry-1.docker.io', 443, signal)
+//   s.write(bytes); const b = await s.read(n); s.end(); s.abort()
+//   t.close()
+//
+// WispClient (wisp-client.js) does the protocol, as it does for the guest's stack; this file is the
+// stack it calls back into. read(n) waits for n bytes (fewer at a clean end, undefined when nothing
+// is left; with mode 1, PEEK, the bytes stay queued); a reset or a dropped relay is an error. Bytes
+// taken by the reader go back to the relay as credit (wmd-credit), so a slow reader slows the relay.
+
+import { E } from './proto.js'
+import { WispClient } from './wisp-client.js'
+
+const PEEK = 1
+
+class StreamQueue {
+  constructor(onTaken) {
+    this.onTaken = onTaken
+    this.q = []
+    this.n = 0
+    this.ended = false
+    this.failure = null
+    this.want = null
+  }
+  push(b) {
+    if (this.ended) return
+    this.q.push(b)
+    this.n += b.length
+    this.#serve()
+  }
+  finish() {
+    this.ended = true
+    this.#serve()
+  }
+  fail(e) {
+    if (this.ended && !this.failure && !this.want) return
+    this.failure ??= e
+    this.ended = true
+    this.#serve()
+  }
+  read(bytes, mode = 0) {
+    if (this.want) return Promise.reject(new Error('a read is already waiting on this stream'))
+    return new Promise((resolve, reject) => {
+      this.want = { bytes, mode, resolve, reject }
+      this.#serve()
+    })
+  }
+  #serve() {
+    const w = this.want
+    if (!w || (this.n < w.bytes && !this.ended)) return
+    this.want = null
+    const k = Math.min(w.bytes, this.n)
+    if (k === 0) return this.failure ? w.reject(this.failure) : w.resolve(undefined)
+    const out = new Uint8Array(k)
+    let o = 0
+    let i = 0
+    while (o < k) {
+      const b = this.q[i]
+      const take = Math.min(b.length, k - o)
+      out.set(b.subarray(0, take), o)
+      o += take
+      if (w.mode !== PEEK) {
+        if (take === b.length) i++
+        else this.q[i] = b.subarray(take)
+      } else i++
+    }
+    if (w.mode !== PEEK) {
+      this.q.splice(0, i)
+      this.n -= k
+      this.onTaken(k)
+    }
+    w.resolve(out)
+  }
+}
+
+/**
+ * @param {object} o
+ * @param {string} o.url  'local', 'hosted' or a ws(s):// Wisp URL
+ * @param {WispClient} [o.client]  a client to use instead (its stack is set to this transport)
+ * @param {(line: string) => void} [o.log]
+ * @returns {{connect(host: string, port: number, signal?: AbortSignal): Promise<object>, close(): void, client: WispClient}}
+ */
+export function createWispTransport(o = {}) {
+  const client = o.client || new WispClient({ url: o.url, log: o.log, instance: o.instance })
+  const streams = new Map() // id -> {queue, opened}
+  let nextId = 1
+  let closed = false
+  const stack = {
+    onConnected(id, code, _window, why) {
+      const s = streams.get(id)
+      if (!s?.opened) return
+      const { resolve, reject } = s.opened
+      s.opened = null
+      if (code === E.OK) resolve()
+      else {
+        streams.delete(id)
+        reject(new Error(why || `the relay could not open the stream (code ${code})`))
+      }
+    },
+    onRelayData(id, b) {
+      streams.get(id)?.queue.push(b)
+    },
+    onRelayEnd(id) {
+      const s = streams.get(id)
+      if (!s) return
+      s.queue.finish()
+      s.remoteEnded = true
+      if (s.localEnded) {
+        streams.delete(id)
+        client.closed(id)
+      }
+    },
+    onRelayAbort(id, _code, why) {
+      const s = streams.get(id)
+      if (!s) return
+      streams.delete(id)
+      const e = new Error(why || 'the relay reset the stream')
+      if (s.opened) s.opened.reject(e)
+      s.queue.fail(e)
+    },
+    onRelayCredit() {},
+    onDnsReply() {},
+    onRelayDown(why) {
+      const e = new Error(`the relay connection dropped${why ? `: ${why}` : ''}`)
+      for (const [id, s] of streams) {
+        streams.delete(id)
+        if (s.opened) s.opened.reject(e)
+        s.queue.fail(e)
+      }
+    },
+  }
+  client.attach(stack)
+
+  return {
+    client,
+    async connect(host, port, signal) {
+      if (closed) throw new Error('the transport is closed')
+      signal?.throwIfAborted()
+      const id = nextId++
+      const s = {
+        queue: new StreamQueue(n => client.credit(id, n)),
+        opened: null,
+        localEnded: false,
+        remoteEnded: false,
+      }
+      streams.set(id, s)
+      const opened = new Promise((resolve, reject) => (s.opened = { resolve, reject }))
+      const onAbort = () => {
+        if (!s.opened) return
+        const { reject } = s.opened
+        s.opened = null
+        streams.delete(id)
+        client.abort(id)
+        reject(signal.reason ?? new Error('aborted'))
+      }
+      signal?.addEventListener('abort', onAbort, { once: true })
+      client.connect(id, host, port)
+      try {
+        await opened
+      } finally {
+        signal?.removeEventListener('abort', onAbort)
+      }
+      return {
+        read: (n, mode) => s.queue.read(n, mode),
+        write(b) {
+          if (streams.get(id) === s && !s.localEnded) client.data(id, b.slice())
+        },
+        end() {
+          if (s.localEnded || streams.get(id) !== s) return
+          s.localEnded = true
+          client.end(id)
+          if (s.remoteEnded) {
+            streams.delete(id)
+            client.closed(id)
+          }
+        },
+        abort() {
+          if (streams.get(id) !== s) return
+          streams.delete(id)
+          client.abort(id)
+          s.queue.fail(new Error('the stream was reset'))
+        },
+      }
+    },
+    close() {
+      closed = true
+      stack.onRelayDown('closed by the page')
+      client.ws?.close(1000)
+    },
+  }
+}