bare-stow 0.1.8 → 0.2.0

package/lib/protocol.js

@@ -1,139 +0,0 @@
-const { Duplex, Writable } = require('bare-stream')
-const b4a = require('b4a')
-
-const CONTROL = 0x00
-const USER = 0x01
-
-exports.CONTROL = CONTROL
-exports.USER = USER
-
-exports.DEFAULT_GRACE = 5000
-
-const HEADER_LENGTH = 5
-
-class Protocol extends Duplex {
-  constructor(stream) {
-    super()
-
-    this._stream = stream
-    this._buffer = []
-    this._buffered = 0
-    this._frame = -1
-
-    stream
-      .on('data', (chunk) => this._ondata(chunk))
-      .on('end', () => this.push(null))
-      .on('close', () => this.destroy())
-      .on('error', (err) => this._onerror(err))
-  }
-
-  send(type, payload) {
-    const frame = encodeFrame(CONTROL, b4a.from(JSON.stringify({ type, ...payload })))
-
-    this._stream.write(frame)
-
-    return Writable.drained(this._stream)
-  }
-
-  _write(data, encoding, cb) {
-    const frame = encodeFrame(USER, data)
-
-    const ok = this._stream.write(frame)
-
-    if (ok) return cb(null)
-
-    this._stream.once('drain', () => cb(null))
-  }
-
-  _destroy(err, cb) {
-    this._stream.destroy()
-    cb(null)
-  }
-
-  _onerror(err) {
-    // On Linux, a peer that goes away with data still unread resets the
-    // connection rather than ending it, which is no different from it closing.
-    if (err.code === 'ECONNRESET') this.destroy()
-    else this.destroy(err)
-  }
-
-  _ondata(chunk) {
-    this._buffer.push(chunk)
-    this._buffered += chunk.byteLength
-
-    if (this._frame === -1) this._onbeforeframe()
-    else this._onafterframe()
-  }
-
-  _onbeforeframe() {
-    if (this._buffered < 4) return
-
-    const buffer = this._buffer.length === 1 ? this._buffer[0] : b4a.concat(this._buffer)
-
-    this._buffer = [buffer]
-    this._frame = 4 + b4a.readUInt32LE(buffer, 0)
-
-    this._onafterframe()
-  }
-
-  _onafterframe() {
-    if (this._buffered < this._frame) return
-
-    const buffer = this._buffer.length === 1 ? this._buffer[0] : b4a.concat(this._buffer)
-    const frame = this._frame
-
-    this._buffered -= frame
-    this._buffer = this._buffered > 0 ? [buffer.subarray(frame)] : []
-    this._frame = -1
-
-    this._onframe(buffer.subarray(0, frame))
-    this._onbeforeframe()
-  }
-
-  _onframe(frame) {
-    const tag = frame[4]
-    const payload = frame.subarray(HEADER_LENGTH)
-
-    if (tag === USER) {
-      this.push(b4a.from(payload))
-    } else if (tag === CONTROL) {
-      let message
-
-      try {
-        message = JSON.parse(b4a.toString(payload))
-      } catch {
-        return
-      }
-
-      if (message.type === 'error') {
-        const err = new Error(message.message)
-
-        if (message.stack) err.stack = message.stack
-
-        this.destroy(err)
-      } else if (message.type === 'exit') {
-        this.emit('exit', message.code)
-      } else {
-        this.emit(message.type, message)
-      }
-    }
-  }
-}
-
-exports.Protocol = Protocol
-
-exports.attach = function attach(stream) {
-  return new Protocol(stream)
-}
-
-function encodeFrame(tag, data) {
-  const length = data.length + 1
-  const frame = b4a.alloc(HEADER_LENGTH + data.length)
-
-  b4a.writeUInt32LE(frame, length, 0)
-  frame[4] = tag
-
-  b4a.copy(data, frame, HEADER_LENGTH)
-
-  return frame
-}

package/lib/runtime.d.ts

@@ -1,29 +0,0 @@
-import { Duplex } from 'bare-stream'
-import { Protocol } from './protocol'
-
-interface Runtime extends Protocol {
-  /**
-   * Load the bundle entry and start it with `arg`, signaling ready once its `start()` resolves.
-   * @param load - A function importing the bundle entry module.
-   * @param arg - The value passed to the entry's `start()`.
-   */
-  run(load: () => Promise<{ default: Function }>, arg: unknown): Promise<void>
-}
-
-declare class Runtime {
-  /**
-   * Attach the worker side of a stowed bundle's lifecycle to `stream`.
-   * @param stream - The worker side of a stowed bundle's transport, typically `Bare.IPC`.
-   */
-  constructor(stream: Duplex)
-}
-
-/**
- * Attach the worker side of a stowed bundle's lifecycle to `stream`, shutting the worker down on
- * `terminate`, `SIGTERM`, runtime exit, uncaught errors, or loss of the host.
- * @param stream - The worker side of a stowed bundle's transport, typically `Bare.IPC`.
- * @returns A `Runtime` multiplexing control and user-data frames over `stream`.
- */
-declare function attach(stream: Duplex): Runtime
-
-export { Runtime, attach }

package/lib/runtime.js

@@ -1,92 +0,0 @@
-const { Protocol, DEFAULT_GRACE } = require('./protocol')
-
-class Runtime extends Protocol {
-  constructor(stream) {
-    super(stream)
-
-    this._stop = null
-    this._grace = DEFAULT_GRACE
-    this._readied = false
-    this._exitCode = null
-    this._connected = true
-
-    const ondisconnect = () => this._ondisconnect()
-
-    this.on('configure', ({ grace }) => {
-      this._grace = grace
-    }).on('terminate', () => this._shutdown(0))
-
-    stream.on('end', ondisconnect).on('close', ondisconnect)
-
-    Bare.on('beforeExit', (code) => this._shutdown(code))
-      .on('uncaughtException', (err) => this._shutdown(1, err))
-      .on('unhandledRejection', (err) => this._shutdown(1, err))
-
-    // Signals are delivered to the whole process, so a worker thread must leave
-    // them to the host.
-    if (Bare.Thread.isMainThread) {
-      const Signal = require('bare-signals')
-
-      new Signal('SIGTERM')
-        .on('signal', () => this._onsigterm())
-        .start()
-        .unref()
-    }
-  }
-
-  async run(load, arg) {
-    try {
-      const entry = await load()
-
-      this._stop = await entry.default(arg, () => this._ready())
-
-      this._ready()
-    } catch (err) {
-      this._shutdown(1, err)
-    }
-  }
-
-  _ready() {
-    if (this._readied) return
-    this._readied = true
-
-    this.send('ready')
-  }
-
-  async _shutdown(code, err = null) {
-    if (this._exitCode !== null) return
-    this._exitCode = code
-
-    setTimeout(() => Bare.exit(code), this._grace).unref()
-
-    try {
-      if (this._stop) await this._stop()
-    } catch (e) {
-      err = err || e
-    }
-
-    if (this._connected) {
-      if (err) this.send('error', { message: err.message, stack: err.stack })
-
-      await this.send('exit', { code })
-    }
-
-    Bare.exit(code)
-  }
-
-  _ondisconnect() {
-    this._connected = false
-    this._shutdown(0)
-  }
-
-  _onsigterm() {
-    if (this._exitCode !== null) Bare.exit(this._exitCode)
-    else this._shutdown(0)
-  }
-}
-
-exports.Runtime = Runtime
-
-exports.attach = function attach(stream) {
-  return new Runtime(stream)
-}