@bytecodealliance/preview2-shim 0.14.1 → 0.15.0

package/lib/io/worker-io.js

@@ -2,8 +2,10 @@ import { fileURLToPath } from "node:url";
 import { createSyncFn } from "../synckit/index.js";
 import {
   CALL_MASK,
-  CALL_SHIFT,
   CALL_TYPE_MASK,
+  FILE,
+  HTTP_SERVER_INCOMING_HANDLER,
+  HTTP,
   INPUT_STREAM_BLOCKING_READ,
   INPUT_STREAM_BLOCKING_SKIP,
   INPUT_STREAM_DISPOSE,
@@ -23,28 +25,62 @@ import {
   OUTPUT_STREAM_WRITE,
   POLL_POLL_LIST,
   POLL_POLLABLE_BLOCK,
+  POLL_POLLABLE_DISPOSE,
   POLL_POLLABLE_READY,
+  SOCKET_TCP,
+  STDERR,
+  STDIN,
+  STDOUT,
+  reverseMap,
 } from "./calls.js";
-import { STDERR } from "./calls.js";
-
-const DEBUG = false;
+import { _rawDebug, exit, stderr, stdout, env } from "node:process";
 
 const workerPath = fileURLToPath(
   new URL("./worker-thread.js", import.meta.url)
 );
 
+const httpIncomingHandlers = new Map();
+export function registerIncomingHttpHandler(id, handler) {
+  httpIncomingHandlers.set(id, handler);
+}
+
+const instanceId = Math.round(Math.random() * 1000).toString();
+const DEBUG_DEFAULT = false;
+const DEBUG =
+  env.PREVIEW2_SHIM_DEBUG === "0"
+    ? false
+    : env.PREVIEW2_SHIM_DEBUG === "1"
+    ? true
+    : DEBUG_DEFAULT;
+
 /**
  * @type {(call: number, id: number | null, payload: any) -> any}
  */
-export let ioCall = createSyncFn(workerPath);
+export let ioCall = createSyncFn(workerPath, DEBUG, (type, id, payload) => {
+  // 'callbacks' from the worker
+  // ONLY happens for an http server incoming handler, and NOTHING else (not even sockets, since accept is sync!)
+  if (type !== HTTP_SERVER_INCOMING_HANDLER)
+    throw new Error(
+      "Internal error: only incoming handler callback is permitted"
+    );
+  const handler = httpIncomingHandlers.get(id);
+  if (!handler)
+    throw new Error(
+      `Internal error: no incoming handler registered for server ${id}`
+    );
+  handler(payload);
+});
 if (DEBUG) {
   const _ioCall = ioCall;
   ioCall = function ioCall(num, id, payload) {
+    if (typeof id !== "number" && id !== null)
+      throw new Error("id must be a number or null");
     let ret;
     try {
-      process._rawDebug(
-        (num & CALL_MASK) >> CALL_SHIFT,
-        num & CALL_TYPE_MASK,
+      _rawDebug(
+        instanceId,
+        reverseMap[num & CALL_MASK],
+        reverseMap[num & CALL_TYPE_MASK],
         id,
         payload
       );
@@ -54,15 +90,56 @@ if (DEBUG) {
       ret = e;
       throw ret;
     } finally {
-      process._rawDebug("->", ret);
+      _rawDebug(instanceId, "->", ret);
     }
   };
 }
 
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
+const finalizationRegistry = new FinalizationRegistry(
+  (dispose) => void dispose()
+);
+
+const dummySymbol = Symbol();
+
+/**
+ *
+ * @param {any} resource
+ * @param {any} parentResource
+ * @param {number} id
+ * @param {(number) => void} disposeFn
+ */
+export function registerDispose(resource, parentResource, id, disposeFn) {
+  // While strictly speaking all components should handle their disposal,
+  // this acts as a last-resort to catch all missed drops through the JS GC.
+  // Mainly for two cases - (1) components which are long lived, that get shut
+  // down and (2) users that interface with low-level WASI APIs directly in JS
+  // for various reasons may end up leaning on JS GC inadvertantly.
+  function finalizer() {
+    // This has no functional purpose other than to pin a strong reference
+    // from the child resource's finalizer to the parent resource, to ensure
+    // that we can never finalize a parent resource before a child resource.
+    // This makes the generational JS GC become piecewise over child resource
+    // graphs (generational at each resource hierarchy level at least).
+    if (parentResource?.[dummySymbol]) return;
+    disposeFn(id);
+  }
+  finalizationRegistry.register(resource, finalizer, finalizer);
+  return finalizer;
+}
+
+export function earlyDispose(finalizer) {
+  finalizationRegistry.unregister(finalizer);
+  finalizer();
+}
+
 const _Error = Error;
 const IoError = class Error extends _Error {
+  constructor(payload) {
+    super(payload);
+    this.payload = payload;
+  }
   toDebugString() {
     return this.message;
   }
@@ -72,24 +149,21 @@ function streamIoErrorCall(call, id, payload) {
   try {
     return ioCall(call, id, payload);
   } catch (e) {
-    if (e.tag === 'closed')
-      throw e;
+    if (e.tag === "closed") throw e;
     if (e.tag === "last-operation-failed") {
-      e.val = new IoError(e.val);
+      e.val = new IoError(Object.assign(new Error(e.val.message), e.val));
       throw e;
     }
     // any invalid error is a trap
     console.trace(e);
-    process.exit(1);
+    exit(1);
   }
 }
 
 class InputStream {
   #id;
   #streamType;
-  get _id() {
-    return this.#id;
-  }
+  #finalizer;
   read(len) {
     return streamIoErrorCall(
       INPUT_STREAM_READ | this.#streamType,
@@ -120,24 +194,65 @@ class InputStream {
   }
   subscribe() {
     return pollableCreate(
-      ioCall(INPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id)
+      ioCall(INPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id),
+      this
     );
   }
-  [symbolDispose]() {
-    ioCall(INPUT_STREAM_DISPOSE | this.#streamType, this.#id);
-  }
   static _id(stream) {
     return stream.#id;
   }
   /**
-   * @param {InputStreamType} streamType
+   * @param {FILE | SOCKET_TCP | STDIN | HTTP} streamType
    */
   static _create(streamType, id) {
     const stream = new InputStream();
     stream.#id = id;
     stream.#streamType = streamType;
+    let disposeFn;
+    switch (streamType) {
+      case FILE:
+        disposeFn = fileInputStreamDispose;
+        break;
+      case SOCKET_TCP:
+        disposeFn = socketTcpInputStreamDispose;
+        break;
+      case STDIN:
+        disposeFn = stdinInputStreamDispose;
+        break;
+      case HTTP:
+        disposeFn = httpInputStreamDispose;
+        break;
+      default:
+        throw new Error(
+          "wasi-io trap: Dispose function not created for stream type " +
+            reverseMap[streamType]
+        );
+    }
+    stream.#finalizer = registerDispose(stream, null, id, disposeFn);
     return stream;
   }
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
+  }
+}
+
+function fileInputStreamDispose(id) {
+  ioCall(INPUT_STREAM_DISPOSE | FILE, id, null);
+}
+
+function socketTcpInputStreamDispose(id) {
+  ioCall(INPUT_STREAM_DISPOSE | SOCKET_TCP, id, null);
+}
+
+function stdinInputStreamDispose(id) {
+  ioCall(INPUT_STREAM_DISPOSE | STDIN, id, null);
+}
+
+function httpInputStreamDispose(id) {
+  ioCall(INPUT_STREAM_DISPOSE | HTTP, id, null);
 }
 
 export const inputStreamCreate = InputStream._create;
@@ -149,9 +264,7 @@ delete InputStream._id;
 class OutputStream {
   #id;
   #streamType;
-  get _id() {
-    return this.#id;
-  }
+  #finalizer;
   checkWrite(len) {
     return streamIoErrorCall(
       OUTPUT_STREAM_CHECK_WRITE | this.#streamType,
@@ -169,8 +282,7 @@ class OutputStream {
   }
   blockingWriteAndFlush(buf) {
     if (this.#streamType <= STDERR) {
-      const stream =
-        this.#streamType === STDERR ? process.stderr : process.stdout;
+      const stream = this.#streamType === STDERR ? stderr : stdout;
       return void stream.write(buf);
     }
     return streamIoErrorCall(
@@ -206,16 +318,14 @@ class OutputStream {
     return streamIoErrorCall(
       OUTPUT_STREAM_SPLICE | this.#streamType,
       this.#id,
-      src.#id,
-      len
+      { src: src.#id, len }
     );
   }
   blockingSplice(src, len) {
     return streamIoErrorCall(
       OUTPUT_STREAM_BLOCKING_SPLICE | this.#streamType,
       this.#id,
-      src.#id,
-      len
+      { src: inputStreamId(src), len }
     );
   }
   subscribe() {
@@ -223,9 +333,6 @@ class OutputStream {
       ioCall(OUTPUT_STREAM_SUBSCRIBE | this.#streamType, this.#id)
     );
   }
-  [symbolDispose]() {
-    ioCall(OUTPUT_STREAM_DISPOSE | this.#streamType, this.#id);
-  }
 
   static _id(outputStream) {
     return outputStream.#id;
@@ -238,8 +345,54 @@ class OutputStream {
     const stream = new OutputStream();
     stream.#id = id;
     stream.#streamType = streamType;
+    let disposeFn;
+    switch (streamType) {
+      case STDOUT:
+        disposeFn = stdoutOutputStreamDispose;
+        break;
+      case STDERR:
+        disposeFn = stderrOutputStreamDispose;
+        break;
+      case SOCKET_TCP:
+        disposeFn = socketTcpOutputStreamDispose;
+        break;
+      case FILE:
+        disposeFn = fileOutputStreamDispose;
+        break;
+      case HTTP:
+        return stream;
+      default:
+        throw new Error(
+          "wasi-io trap: Dispose function not created for stream type " +
+            reverseMap[streamType]
+        );
+    }
+    stream.#finalizer = registerDispose(stream, null, id, disposeFn);
     return stream;
   }
+
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
+  }
+}
+
+function stdoutOutputStreamDispose(id) {
+  ioCall(OUTPUT_STREAM_DISPOSE | STDOUT, id);
+}
+
+function stderrOutputStreamDispose(id) {
+  ioCall(OUTPUT_STREAM_DISPOSE | STDERR, id);
+}
+
+function socketTcpOutputStreamDispose(id) {
+  ioCall(OUTPUT_STREAM_DISPOSE | SOCKET_TCP, id);
+}
+
+function fileOutputStreamDispose(id) {
+  ioCall(OUTPUT_STREAM_DISPOSE | FILE, id);
 }
 
 export const outputStreamCreate = OutputStream._create;
@@ -252,71 +405,57 @@ export const error = { Error: IoError };
 
 export const streams = { InputStream, OutputStream };
 
+function pollableDispose(id) {
+  ioCall(POLL_POLLABLE_DISPOSE, id);
+}
+
 class Pollable {
   #id;
-  #ready = false;
-  get _id() {
-    return this.#id;
-  }
+  #finalizer;
   ready() {
-    if (this.#ready) return true;
-    const ready = ioCall(POLL_POLLABLE_READY, this.#id);
-    if (ready) this.#ready = true;
-    return ready;
+    if (this.#id === 0) return true;
+    return ioCall(POLL_POLLABLE_READY, this.#id);
   }
   block() {
-    if (!this.#ready) {
+    if (this.#id !== 0) {
       ioCall(POLL_POLLABLE_BLOCK, this.#id);
-      this.#ready = true;
     }
   }
   static _getId(pollable) {
     return pollable.#id;
   }
-  static _create(id) {
+  static _create(id, parent) {
     const pollable = new Pollable();
     pollable.#id = id;
-    if (id === 0) pollable.#ready = true;
+    pollable.#finalizer = registerDispose(
+      pollable,
+      parent,
+      id,
+      pollableDispose
+    );
     return pollable;
   }
-  static _listToIds(list) {
-    return list.map((pollable) => pollable.#id);
-  }
-  static _markReady(pollable) {
-    pollable.#ready = true;
+  [symbolDispose]() {
+    if (this.#finalizer) {
+      earlyDispose(this.#finalizer);
+      this.#finalizer = null;
+    }
   }
 }
 
 export const pollableCreate = Pollable._create;
 delete Pollable._create;
 
-const pollableListToIds = Pollable._listToIds;
-delete Pollable._listToIds;
-
-const pollableMarkReady = Pollable._markReady;
-delete Pollable._markReady;
-
 const pollableGetId = Pollable._getId;
 delete Pollable._getId;
 
 export const poll = {
   Pollable,
   poll(list) {
-    const includeList = ioCall(POLL_POLL_LIST, null, pollableListToIds(list));
-    return list.filter((pollable) => {
-      if (includeList.includes(pollableGetId(pollable))) {
-        pollableMarkReady(pollable);
-        return true;
-      }
-      return false;
-    });
+    return ioCall(POLL_POLL_LIST, null, list.map(pollableGetId));
   },
 };
 
-export function resolvedPoll() {
-  return pollableCreate(0);
-}
-
 export function createPoll(call, id, initPayload) {
   return pollableCreate(ioCall(call, id, initPayload));
 }

package/lib/io/worker-socket-tcp.js

@@ -0,0 +1,285 @@
+import {
+  createFuture,
+  createReadableStream,
+  createReadableStreamPollState,
+  createWritableStream,
+  futureDispose,
+  futureTakeValue,
+  pollStateReady,
+  verifyPollsDroppedForDrop,
+} from "./worker-thread.js";
+const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
+import {
+  convertSocketError,
+  convertSocketErrorCode,
+  ipSocketAddress,
+  isIPv4MappedAddress,
+  isMulticastIpAddress,
+  isUnicastIpAddress,
+  isWildcardAddress,
+  noLookup,
+  serializeIpAddress,
+  SOCKET_STATE_BIND,
+  SOCKET_STATE_BOUND,
+  SOCKET_STATE_CLOSED,
+  SOCKET_STATE_CONNECT,
+  SOCKET_STATE_CONNECTION,
+  SOCKET_STATE_INIT,
+  SOCKET_STATE_LISTEN,
+  SOCKET_STATE_LISTENER,
+} from "./worker-sockets.js";
+import { Socket, Server } from "node:net";
+
+/**
+ * @typedef {import("../../types/interfaces/wasi-sockets-network.js").IpSocketAddress} IpSocketAddress
+ * @typedef {import("../../../types/interfaces/wasi-sockets-tcp.js").IpAddressFamily} IpAddressFamily
+ * @typedef {import("node:net").Socket} TcpSocket
+ *
+ * @typedef {{
+ *   tcpSocket: number,
+ *   err: Error | null,
+ *   pollState: PollState,
+ * }} PendingAccept
+ *
+ * @typedef {{
+ *   state: number,
+ *   future: number | null,
+ *   socket: TcpSocket | null,
+ *   listenBacklogSize: number,
+ *   handle: TCP,
+ *   pendingAccepts: PendingAccept[],
+ *   pollState: PollState,
+ * }} TcpSocketRecord
+ */
+
+/**
+ * @type {Map<number, TcpSocketRecord>}
+ */
+export const tcpSockets = new Map();
+
+let tcpSocketCnt = 0;
+
+/**
+ * @param {IpAddressFamily} addressFamily
+ */
+export function createTcpSocket() {
+  const handle = new TCP(TCPConstants.SOCKET);
+  tcpSockets.set(++tcpSocketCnt, {
+    state: SOCKET_STATE_INIT,
+    future: null,
+    listenBacklogSize: 128,
+    handle,
+    pendingAccepts: [],
+    pollState: { ready: true, listener: null, polls: [], parentStream: null },
+  });
+  return tcpSocketCnt;
+}
+
+export function socketTcpFinish(id, fromState, toState) {
+  const socket = tcpSockets.get(id);
+  if (socket.state !== fromState) throw "not-in-progress";
+  if (!socket.pollState.ready) throw "would-block";
+  const { tag, val } = futureTakeValue(socket.future).val;
+  futureDispose(socket.future, false);
+  socket.future = null;
+  if (tag === "err") {
+    socket.state = SOCKET_STATE_CLOSED;
+    throw val;
+  } else {
+    socket.state = toState;
+    // for the listener, we must immediately transition back to unresolved
+    if (toState === SOCKET_STATE_LISTENER) socket.pollState.ready = false;
+    return val;
+  }
+}
+
+export function socketTcpBindStart(id, localAddress, family) {
+  const socket = tcpSockets.get(id);
+  if (socket.state !== SOCKET_STATE_INIT) throw "invalid-state";
+  if (
+    family !== localAddress.tag ||
+    !isUnicastIpAddress(localAddress) ||
+    isIPv4MappedAddress(localAddress)
+  )
+    throw "invalid-argument";
+  socket.state = SOCKET_STATE_BIND;
+  const { handle } = socket;
+  socket.future = createFuture(
+    (async () => {
+      const address = serializeIpAddress(localAddress);
+      const port = localAddress.val.port;
+      const code =
+        localAddress.tag === "ipv6"
+          ? handle.bind6(address, port, TCPConstants.UV_TCP_IPV6ONLY)
+          : handle.bind(address, port);
+      if (code !== 0) throw convertSocketErrorCode(-code);
+      // This is a Node.js / libuv quirk to force the bind error to be thrown
+      // (specifically address-in-use).
+      {
+        const out = {};
+        const code = handle.getsockname(out);
+        if (code !== 0) throw convertSocketErrorCode(-code);
+      }
+    })(),
+    socket.pollState
+  );
+}
+
+export function socketTcpConnectStart(id, remoteAddress, family) {
+  const socket = tcpSockets.get(id);
+  if (socket.state !== SOCKET_STATE_INIT && socket.state !== SOCKET_STATE_BOUND)
+    throw "invalid-state";
+  if (
+    isWildcardAddress(remoteAddress) ||
+    family !== remoteAddress.tag ||
+    !isUnicastIpAddress(remoteAddress) ||
+    isMulticastIpAddress(remoteAddress) ||
+    remoteAddress.val.port === 0 ||
+    isIPv4MappedAddress(remoteAddress)
+  ) {
+    throw "invalid-argument";
+  }
+  socket.state = SOCKET_STATE_CONNECT;
+  socket.future = createFuture(
+    new Promise((resolve, reject) => {
+      const tcpSocket = (socket.tcpSocket = new Socket({
+        handle: socket.handle,
+        pauseOnCreate: true,
+        allowHalfOpen: true,
+      }));
+      function handleErr(err) {
+        tcpSocket.off("connect", handleConnect);
+        reject(convertSocketError(err));
+      }
+      function handleConnect() {
+        tcpSocket.off("error", handleErr);
+        resolve([
+          createReadableStream(tcpSocket),
+          createWritableStream(tcpSocket),
+        ]);
+      }
+      tcpSocket.once("connect", handleConnect);
+      tcpSocket.once("error", handleErr);
+      tcpSocket.connect({
+        port: remoteAddress.val.port,
+        host: serializeIpAddress(remoteAddress),
+        lookup: noLookup,
+      });
+    }),
+    socket.pollState
+  );
+}
+
+export function socketTcpListenStart(id) {
+  const socket = tcpSockets.get(id);
+  if (socket.state !== SOCKET_STATE_BOUND) throw "invalid-state";
+  const { handle } = socket;
+  socket.state = SOCKET_STATE_LISTEN;
+  socket.future = createFuture(
+    new Promise((resolve, reject) => {
+      const server = new Server({ pauseOnConnect: true, allowHalfOpen: true });
+      function handleErr(err) {
+        server.off("listening", handleListen);
+        reject(convertSocketError(err));
+      }
+      function handleListen() {
+        server.off("error", handleErr);
+        server.on("connection", (tcpSocket) => {
+          pollStateReady(socket.pollState);
+          const pollState = createReadableStreamPollState(tcpSocket);
+          socket.pendingAccepts.push({ tcpSocket, err: null, pollState });
+        });
+        server.on("error", (err) => {
+          pollStateReady(socket.pollState);
+          socket.pendingAccepts.push({ tcpSocket: null, err, pollState: null });
+        });
+        resolve();
+      }
+      server.once("listening", handleListen);
+      server.once("error", handleErr);
+      server.listen(handle, socket.listenBacklogSize);
+    }),
+    socket.pollState
+  );
+}
+
+export function socketTcpAccept(id) {
+  const socket = tcpSockets.get(id);
+  if (socket.state !== SOCKET_STATE_LISTENER) throw "invalid-state";
+  if (socket.pendingAccepts.length === 0) throw "would-block";
+  const accept = socket.pendingAccepts.shift();
+  if (accept.err) {
+    socket.state = SOCKET_STATE_CLOSED;
+    throw convertSocketError(accept.err);
+  }
+  if (socket.pendingAccepts.length === 0) socket.pollState.ready = false;
+  tcpSockets.set(++tcpSocketCnt, {
+    state: SOCKET_STATE_CONNECTION,
+    future: null,
+    listenBacklogSize: 128,
+    handle: accept.tcpSocket._handle,
+    pendingAccepts: [],
+    pollState: accept.pollState,
+  });
+  return [
+    tcpSocketCnt,
+    createReadableStream(accept.tcpSocket, accept.pollState),
+    createWritableStream(accept.tcpSocket),
+  ];
+}
+
+export function socketTcpSetListenBacklogSize(id, backlogSize) {
+  const socket = tcpSockets.get(id);
+  if (
+    socket.state === SOCKET_STATE_LISTEN ||
+    socket.state === SOCKET_STATE_LISTENER
+  )
+    throw "not-supported";
+  if (
+    socket.state !== SOCKET_STATE_INIT &&
+    socket.state !== SOCKET_STATE_BIND &&
+    socket.state !== SOCKET_STATE_BOUND
+  )
+    throw "invalid-state";
+  socket.listenBacklogSize = Number(backlogSize);
+}
+
+export function socketTcpGetLocalAddress(id) {
+  const { handle } = tcpSockets.get(id);
+  const out = {};
+  const code = handle.getsockname(out);
+  if (code !== 0) throw convertSocketErrorCode(-code);
+  return ipSocketAddress(out.family.toLowerCase(), out.address, out.port);
+}
+
+export function socketTcpGetRemoteAddress(id) {
+  const { handle } = tcpSockets.get(id);
+  const out = {};
+  const code = handle.getpeername(out);
+  if (code !== 0) throw convertSocketErrorCode(-code);
+  return ipSocketAddress(out.family.toLowerCase(), out.address, out.port);
+}
+
+export function socketTcpShutdown(id, shutdownType) {
+  const socket = tcpSockets.get(id);
+  if (socket.state !== SOCKET_STATE_CONNECTION) throw "invalid-state";
+  // Node.js only supports a write shutdown, which is triggered on end
+  if (shutdownType === "send" || shutdownType === "both")
+    socket.tcpSocket.end();
+}
+
+export function socketTcpSetKeepAlive(id, { keepAlive, keepAliveIdleTime }) {
+  const { handle } = tcpSockets.get(id);
+  const code = handle.setKeepAlive(
+    keepAlive,
+    Number(keepAliveIdleTime / 1_000_000_000n)
+  );
+  if (code !== 0) throw convertSocketErrorCode(-code);
+}
+
+export function socketTcpDispose(id) {
+  const socket = tcpSockets.get(id);
+  verifyPollsDroppedForDrop(socket.pollState, "tcp socket");
+  socket.handle.close();
+  tcpSockets.delete(id);
+}