@bytecodealliance/preview2-shim 0.0.7 → 0.0.9

package/lib/nodejs/filesystem.js

@@ -1,150 +1,313 @@
-// export interface DescriptorStat {
-//   dev: Device,
-//   ino: Inode,
-//   type: DescriptorType,
-//   nlink: Linkcount,
-//   size: Filesize,
-//   atim: Timestamp,
-//   mtim: Timestamp,
-//   ctim: Timestamp,
-// }
-
-export function readViaStream(fd, offset) {
-  console.log(`[filesystem] READ STREAM ${fd} ${offset}`);
-}
-
-export function writeViaStream(fd, offset) {
-  console.log(`[filesystem] WRITE STREAM ${fd} ${offset}`);
-}
-
-export function appendViaStream(fd) {
-  console.log(`[filesystem] APPEND STREAM ${fd}`);
-}
-
-export function advise(fd, offset, length, advice) {
-  console.log(`[filesystem] ADVISE`, fd, offset, length, advice);
-}
-
-export function syncData(fd) {
-  console.log(`[filesystem] SYNC DATA ${fd}`);
-}
-
-export function getFlags(fd) {
-  console.log(`[filesystem] FLAGS FOR ${fd}`);
-}
-
-export function getType(fd) {
-  console.log(`[filesystem] GET TYPE ${fd}`);
-}
-
-export function setFlags(fd, flags) {
-  console.log(`[filesystem] SET FLAGS ${fd} ${JSON.stringify(flags)}`);
-}
-
-export function setSize(fd, size) {
-  console.log(`[filesystem] SET SIZE`, fd, size);
-}
-
-export function setTimes(fd, dataAccessTimestamp, dataModificationTimestamp) {
-  console.log(`[filesystem] SET TIMES`, fd, dataAccessTimestamp, dataModificationTimestamp);
-}
-
-export function read(fd, length, offset) {
-  console.log(`[filesystem] READ`, fd, length, offset);
-}
-
-export function write(fd, buffer, offset) {
-  console.log(`[filesystem] WRITE`, fd, buffer, offset);
-}
-
-export function readDirectory(fd) {
-  console.log(`[filesystem] READ DIR`, fd);
-}
-
-export function sync(fd) {
-  console.log(`[filesystem] SYNC`, fd);
-}
-
-export function createDirectoryAt(fd, path) {
-  console.log(`[filesystem] CREATE DIRECTORY`, fd, path);
-}
-
-export function stat(fd) {
-  console.log(`[filesystem] STAT`, fd);
-}
-
-export function statAt(fd, pathFlags, path) {
-  console.log(`[filesystem] STAT`, fd, pathFlags, path);
-}
-
-export function setTimesAt(fd) {
-  console.log(`[filesystem] SET TIMES AT`, fd);
-}
-
-export function linkAt(fd) {
-  console.log(`[filesystem] LINK AT`, fd);
-}
-
-export function openAt(fd) {
-  console.log(`[filesystem] OPEN AT`, fd);
-}
-
-export function readlinkAt(fd) {
-  console.log(`[filesystem] READLINK AT`, fd);
-}
-
-export function removeDirectoryAt(fd) {
-  console.log(`[filesystem] REMOVE DIR AT`, fd);
-}
-
-export function renameAt(fd) {
-  console.log(`[filesystem] RENAME AT`, fd);
-}
-
-export function symlinkAt(fd) {
-  console.log(`[filesystem] SYMLINK AT`, fd);
-}
-
-export function unlinkFileAt(fd) {
-  console.log(`[filesystem] UNLINK FILE AT`, fd);
-}
-
-export function changeFilePermissionsAt(fd) {
-  console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`, fd);
-}
-
-export function changeDirectoryPermissionsAt(fd) {
-  console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`, fd);
-}
-
-export function lockShared(fd) {
-  console.log(`[filesystem] LOCK SHARED`, fd);
-}
-
-export function lockExclusive(fd) {
-  console.log(`[filesystem] LOCK EXCLUSIVE`, fd);
-}
-
-export function tryLockShared(fd) {
-  console.log(`[filesystem] TRY LOCK SHARED`, fd);
-}
-
-export function tryLockExclusive(fd) {
-  console.log(`[filesystem] TRY LOCK EXCLUSIVE`, fd);
-}
-
-export function unlock(fd) {
-  console.log(`[filesystem] UNLOCK`, fd);
-}
-
-export function dropDescriptor(fd) {
-  console.log(`[filesystem] DROP DESCRIPTOR`, fd);
-}
-
-export function readDirectoryEntry(stream) {
-  console.log(`[filesystem] READ DIRECTRY ENTRY`, stream);
-}
-
-export function dropDirectoryEntryStream(stream) {
-  console.log(`[filesystem] DROP DIRECTORY ENTRY`, stream);
-}
+import { openSync, constants, statSync, lstatSync, fstatSync, closeSync, readdirSync } from 'node:fs';
+import { _descriptors, _addOpenedDescriptor, _removeOpenedDescriptor, _getDescriptorType, _setSubdescriptorType, _setDescriptorType, _getFullPath } from './cli-base.js';
+import { _createFileStream } from './io.js';
+
+let _dirStreams = [];
+
+const nsMagnitude = 1_000_000_000_000n;
+function nsToDateTime (ns) {
+  const seconds = ns / nsMagnitude;
+  const nanoseconds = Number(ns % seconds);
+  return { seconds, nanoseconds };
+}
+
+function _convertFsError (e) {
+  switch (e.code) {
+    case 'EACCES': throw 'access';
+    case 'EAGAIN':
+    case 'EWOULDBLOCK': throw 'would-block';
+    case 'EALREADY': throw 'already';
+    case 'EBADF': throw 'bad-descriptor';
+    case 'EBUSY': throw 'busy';
+    case 'EDEADLK': throw 'deadlock';
+    case 'EDQUOT': throw 'quota';
+    case 'EEXIST': throw 'exist';
+    case 'EFBIG': throw 'file-too-large';
+    case 'EILSEQ': throw 'illegal-byte-sequence';
+    case 'EINPROGRESS': throw 'in-progress';
+    case 'EINTR': throw 'interrupted';
+    case 'EINVAL': throw 'invalid';
+    case 'EIO': throw 'io';
+    case 'EISDIR': throw 'is-directory';
+    case 'ELOOP': throw 'loop';
+    case 'EMLINK': throw 'too-many-links';
+    case 'EMSGSIZE': throw 'message-size';
+    case 'ENAMETOOLONG': throw 'name-too-long'
+    case 'ENODEV': throw 'no-device';
+    case 'ENOENT': throw 'no-entry';
+    case 'ENOLCK': throw 'no-lock';
+    case 'ENOMEM': throw 'insufficient-memory';
+    case 'ENOSPC': throw 'insufficient-space';
+    case 'ENOTDIR': throw 'not-directory';
+    case 'ENOTEMPTY': throw 'not-empty';
+    case 'ENOTRECOVERABLE': throw 'not-recoverable';
+    case 'ENOTSUP': throw 'unsupported';
+    case 'ENOTTY': throw 'no-tty';
+    case 'ENXIO': throw 'no-such-device';
+    case 'EOVERFLOW': throw 'overflow';
+    case 'EPERM': throw 'not-permitted';
+    case 'EPIPE': throw 'pipe';
+    case 'EROFS': throw 'read-only';
+    case 'ESPIPE': throw 'invalid-seek';
+    case 'ETXTBSY': throw 'text-file-busy';
+    case 'EXDEV': throw 'cross-device';
+    default: throw e;
+  }
+}
+
+function _lookupType (obj) {
+  if (obj.isFile())
+    return 'regular-file';
+  else if (obj.isSocket())
+    return 'socket';
+  else if (obj.isSymbolicLink())
+    return 'symbolic-link';
+  else if (obj.isFIFO())
+    return 'fifo';
+  else if (obj.isDirectory())
+    return 'directory';
+  else if (obj.isCharacterDevice())
+    return 'character-device';
+  else if (obj.isBlockDevice())
+    return 'block-device';
+  return 'unknown';
+}
+
+export const filesystem = {
+  readViaStream(fd, offset) {
+    return _createFileStream(fd, offset);
+  },
+
+  writeViaStream(fd, offset) {
+    console.log(`[filesystem] WRITE STREAM ${fd} ${offset}`);
+  },
+
+  appendViaStream(fd) {
+    console.log(`[filesystem] APPEND STREAM ${fd}`);
+  },
+
+  advise(fd, offset, length, advice) {
+    console.log(`[filesystem] ADVISE`, fd, offset, length, advice);
+  },
+
+  syncData(fd) {
+    console.log(`[filesystem] SYNC DATA ${fd}`);
+  },
+
+  getFlags(fd) {
+    console.log(`[filesystem] FLAGS FOR ${fd}`);
+  },
+
+  getType(fd) {
+    let type = _getDescriptorType(fd);
+    if (type === null) {
+      filesystem.stat(fd);
+      type = _getDescriptorType(fd);
+    }
+    return type;
+  },
+
+  setFlags(fd, flags) {
+    console.log(`[filesystem] SET FLAGS ${fd} ${JSON.stringify(flags)}`);
+  },
+
+  setSize(fd, size) {
+    console.log(`[filesystem] SET SIZE`, fd, size);
+  },
+
+  setTimes(fd, dataAccessTimestamp, dataModificationTimestamp) {
+    console.log(`[filesystem] SET TIMES`, fd, dataAccessTimestamp, dataModificationTimestamp);
+  },
+
+  read(fd, length, offset) {
+    console.log(`[filesystem] READ`, fd, length, offset);
+  },
+
+  write(fd, buffer, offset) {
+    console.log(`[filesystem] WRITE`, fd, buffer, offset);
+  },
+
+  readDirectory(fd) {
+    const fullPath = _getFullPath(fd);
+    let dirs;
+    try {
+      dirs = readdirSync(fullPath, { withFileTypes: true });
+    }
+    catch (e) {
+      _convertFsError(e);
+    }
+    _dirStreams.push({ fd, dirs, cursor: 0 });
+    return _dirStreams.length - 1;
+  },
+
+  sync(fd) {
+    console.log(`[filesystem] SYNC`, fd);
+  },
+
+  createDirectoryAt(fd, path) {
+    console.log(`[filesystem] CREATE DIRECTORY`, fd, path);
+  },
+
+  stat(fd) {
+    let stats;
+    try {
+      stats = fstatSync(fd, { bigint: true });
+    }
+    catch (e) {
+      _convertFsError(e);
+    }
+    const type = _lookupType(stats);
+    _setDescriptorType(fd, type);
+    return {
+      device: stats.dev,
+      inode: stats.ino,
+      type,
+      linkCount: stats.nlink,
+      size: stats.size,
+      dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+      dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+      statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+    };
+  },
+
+  statAt(fd, { symlinkFollow }, path) {
+    const fullPath = _descriptors[fd].path + path;
+    let stats;
+    try {
+      stats = (symlinkFollow ? statSync : lstatSync)(fullPath, { bigint: true });
+    }
+    catch (e) {
+      _convertFsError(e);
+    }
+    const type = _lookupType(stats);
+    _setSubdescriptorType(fd, path, type);
+    return {
+      device: stats.dev,
+      inode: stats.ino,
+      type,
+      linkCount: stats.nlink,
+      size: stats.size,
+      dataAccessTimestamp: nsToDateTime(stats.atimeNs),
+      dataModificationTimestamp: nsToDateTime(stats.mtimeNs),
+      statusChangeTimestamp: nsToDateTime(stats.ctimeNs),
+    };
+  },
+
+  setTimesAt(fd) {
+    console.log(`[filesystem] SET TIMES AT`, fd);
+  },
+
+  linkAt(fd) {
+    console.log(`[filesystem] LINK AT`, fd);
+  },
+
+  openAt(fd, pathFlags, path, openFlags, descriptorFlags, modes) {
+    // TODO
+    // if (pathFlags.symlinkFollow) {
+    //   // resolve symlink
+    // }
+    const fullPath = _descriptors[fd].path + path;
+    let fsOpenFlags = 0x0;
+    if (openFlags.create)
+      fsOpenFlags |= constants.O_CREAT;
+    if (openFlags.directory)
+      fsOpenFlags |= constants.O_DIRECTORY;
+    if (openFlags.exclusive)
+      fsOpenFlags |= constants.O_EXCL;
+    if (openFlags.truncate)
+      fsOpenFlags |= constants.O_TRUNC;
+    if (descriptorFlags.read && descriptorFlags.write)
+      fsOpenFlags |= constants.O_RDWR;
+    else if (descriptorFlags.write)
+      fsOpenFlags |= constants.O_WRONLY;
+    // if (descriptorFlags.fileIntegritySync)
+    // if (descriptorFlags.dataIntegritySync)
+    // if (descriptorFlags.requestedWriteSync)
+    // if (descriptorFlags.mutateDirectory)
+    let fsMode = 0x0;
+    if (modes.readable)
+      fsMode |= 0o444;
+    if (modes.writeable)
+      fsMode |= 0o222;
+    if (modes.executable)
+      fsMode |= 0o111;
+    let localFd;
+    try {
+      localFd = openSync(fullPath, fsOpenFlags, fsMode);
+    }
+    catch (e) {
+      _convertFsError(e);
+    }
+    _addOpenedDescriptor(localFd, path, fd);
+    return localFd;
+  },
+
+  readlinkAt(fd) {
+    console.log(`[filesystem] READLINK AT`, fd);
+  },
+
+  removeDirectoryAt(fd) {
+    console.log(`[filesystem] REMOVE DIR AT`, fd);
+  },
+
+  renameAt(fd) {
+    console.log(`[filesystem] RENAME AT`, fd);
+  },
+
+  symlinkAt(fd) {
+    console.log(`[filesystem] SYMLINK AT`, fd);
+  },
+
+  unlinkFileAt(fd) {
+    console.log(`[filesystem] UNLINK FILE AT`, fd);
+  },
+
+  changeFilePermissionsAt(fd) {
+    console.log(`[filesystem] CHANGE FILE PERMISSIONS AT`, fd);
+  },
+
+  changeDirectoryPermissionsAt(fd) {
+    console.log(`[filesystem] CHANGE DIR PERMISSIONS AT`, fd);
+  },
+
+  lockShared(fd) {
+    console.log(`[filesystem] LOCK SHARED`, fd);
+  },
+
+  lockExclusive(fd) {
+    console.log(`[filesystem] LOCK EXCLUSIVE`, fd);
+  },
+
+  tryLockShared(fd) {
+    console.log(`[filesystem] TRY LOCK SHARED`, fd);
+  },
+
+  tryLockExclusive(fd) {
+    console.log(`[filesystem] TRY LOCK EXCLUSIVE`, fd);
+  },
+
+  unlock(fd) {
+    console.log(`[filesystem] UNLOCK`, fd);
+  },
+
+  dropDescriptor(fd) {
+    _removeOpenedDescriptor(fd);
+    closeSync(fd);
+  },
+
+  readDirectoryEntry(stream) {
+    const streamValue = _dirStreams[stream];
+    if (streamValue.cursor === streamValue.dirs.length)
+      return null;
+    const dir = streamValue.dirs[streamValue.cursor++];
+    const type = _lookupType(dir);
+    _setSubdescriptorType(streamValue.fd, '/' + dir.name, type);
+    return { inode: null, type, name: dir.name };
+  },
+
+  dropDirectoryEntryStream(stream) {
+    _dirStreams.splice(stream, 1);
+  }
+};
+
+export { filesystem as filesystemFilesystem }

package/lib/nodejs/http.js

@@ -17,3 +17,123 @@ export function send(req) {
   }
   throw new UnexpectedError(response);
 }
+
+export const httpIncomingHandler = {
+  handle () {
+
+  }
+};
+
+export const httpOutgoingHandler = {
+  handle () {
+
+  }
+};
+
+export const httpTypes = {
+  dropFields(_fields) {
+    console.log("[types] Drop fields");
+  },
+  newFields(_entries) {
+    console.log("[types] New fields");
+  },
+  fieldsGet(_fields, _name) {
+    console.log("[types] Fields get");
+  },
+  fieldsSet(_fields, _name, _value) {
+    console.log("[types] Fields set");
+  },
+  fieldsDelete(_fields, _name) {
+    console.log("[types] Fields delete");
+  },
+  fieldsAppend(_fields, _name, _value) {
+    console.log("[types] Fields append");
+  },
+  fieldsEntries(_fields) {
+    console.log("[types] Fields entries");
+  },
+  fieldsClone(_fields) {
+    console.log("[types] Fields clone");
+  },
+  finishIncomingStream(s) {
+    console.log(`[types] Finish incoming stream ${s}`);
+  },
+  finishOutgoingStream(s, _trailers) {
+    console.log(`[types] Finish outgoing stream ${s}`);
+  },
+  dropIncomingRequest(_req) {
+    console.log("[types] Drop incoming request");
+  },
+  dropOutgoingRequest(_req) {
+    console.log("[types] Drop outgoing request");
+  },
+  incomingRequestMethod(_req) {
+    console.log("[types] Incoming request method");
+  },
+  incomingRequestPath(_req) {
+    console.log("[types] Incoming request path");
+  },
+  incomingRequestQuery(_req) {
+    console.log("[types] Incoming request query");
+  },
+  incomingRequestScheme(_req) {
+    console.log("[types] Incoming request scheme");
+  },
+  incomingRequestAuthority(_req) {
+    console.log("[types] Incoming request authority");
+  },
+  incomingRequestHeaders(_req) {
+    console.log("[types] Incoming request headers");
+  },
+  incomingRequestConsume(_req) {
+    console.log("[types] Incoming request consume");
+  },
+  newOutgoingRequest(_method, _path, _query, _scheme, _authority, _headers) {
+    console.log("[types] New outgoing request");
+  },
+  outgoingRequestWrite(_req) {
+    console.log("[types] Outgoing request write");
+  },
+  dropResponseOutparam(_res) {
+    console.log("[types] Drop response outparam");
+  },
+  setResponseOutparam(_response) {
+    console.log("[types] Drop fields");
+  },
+  dropIncomingResponse(_res) {
+    console.log("[types] Drop incoming response");
+  },
+  dropOutgoingResponse(_res) {
+    console.log("[types] Drop outgoing response");
+  },
+  incomingResponseStatus(_res) {
+    console.log("[types] Incoming response status");
+  },
+  incomingResponseHeaders(_res) {
+    console.log("[types] Incoming response headers");
+  },
+  incomingResponseConsume(_res) {
+    console.log("[types] Incoming response consume");
+  },
+  newOutgoingResponse(_statusCode, _headers) {
+    console.log("[types] New outgoing response");
+  },
+  outgoingResponseWrite(_res) {
+    console.log("[types] Outgoing response write");
+  },
+  dropFutureIncomingResponse(_f) {
+    console.log("[types] Drop future incoming response");
+  },
+  futureIncomingResponseGet(_f) {
+    console.log("[types] Future incoming response get");
+  },
+  listenToFutureIncomingResponse(_f) {
+    console.log("[types] Listen to future incoming response");
+  }
+};
+
+export {
+  httpIncomingHandler as incomingHandler,
+  httpOutgoingHandler as outgoingHandler,
+  httpTypes as types
+}

package/lib/nodejs/index.js

@@ -1,29 +1,23 @@
-import * as logging from "./logging.js";
-import * as defaultOutgoingHttp from "./default-outgoing-HTTP.js";
-import * as environment from "./environment.js";
-import * as exit from "./exit.js";
+import * as clocks from "./clocks.js";
 import * as filesystem from "./filesystem.js";
 import * as http from "./http.js";
-import * as monotonicClock from "./monotonic-clock.js";
+import * as io from "./io.js";
+import * as logging from "./logging.js";
 import * as poll from "./poll.js";
-import * as preopens from "./preopens.js";
 import * as random from "./random.js";
-import * as streams from "./streams.js";
-import * as wallClock from "./wall-clock.js";
+import * as sockets from "./sockets.js";
+import * as cliBase from "./cli-base.js";
 
 export const importObject = {
-    "default-outgoing-HTTP": defaultOutgoingHttp,
-    "environment": environment,
-    "exit": exit,
-    "filesystem": filesystem,
-    "http": http,
-    "logging": logging,
-    "monotonic-clock": monotonicClock,
-    "poll": poll,
-    "preopens": preopens,
-    "random": random,
-    "streams": streams,
-    "wall-clock": wallClock,
+  clocks,
+  filesystem,
+  http,
+  io,
+  logging,
+  poll,
+  random,
+  sockets,
+  cliBase,
 };
 
 export { WasiHttp } from "../http/wasi-http.js";