velocious 1.0.107 → 1.0.109

package/src/http-server/index.js

@@ -1,180 +0,0 @@
-// @ts-check
-
-import {digg} from "diggerize"
-import EventEmitter from "events"
-import {Logger} from "../logger.js"
-import Net from "net"
-import ServerClient from "./server-client.js"
-import WorkerHandler from "./worker-handler/index.js"
-
-export default class VelociousHttpServer {
-  clientCount = 0
-
-  /** @type {Record<string, ServerClient>}  */
-  clients = {}
-
-  events = new EventEmitter()
-  workerCount = 0
-
-  /** @type {WorkerHandler[]} */
-  workerHandlers = []
-
-  /**
-   * @param {object} args
-   * @param {import("../configuration.js").default} args.configuration
-   * @param {string} [args.host]
-   * @param {number} [args.port]
-   * @param {number} [args.maxWorkers]
-   */
-  constructor({configuration, host, maxWorkers, port}) {
-    this.configuration = configuration
-    this.logger = new Logger(this)
-    this.host = host || "0.0.0.0"
-    this.port = port || 3006
-    this.maxWorkers = maxWorkers || 16
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async start() {
-    await this._ensureAtLeastOneWorker()
-    this.netServer = new Net.Server()
-    this.netServer.on("close", this.onClose)
-    this.netServer.on("connection", this.onConnection)
-    await this._netServerListen()
-  }
-
-  _netServerListen() {
-    return new Promise((resolve, reject) => {
-      if (!this.netServer) throw new Error("No netServer")
-
-      try {
-        this.netServer.listen(this.port, this.host, () => {
-          this.logger.debug(`Velocious listening on ${this.host}:${this.port}`)
-          resolve(null)
-        })
-      } catch (error) {
-        reject(error)
-      }
-    })
-  }
-
-  async _ensureAtLeastOneWorker() {
-    if (this.workerHandlers.length == 0) {
-      await this.spawnWorker()
-    }
-  }
-
-  /**
-   * @returns {boolean}
-   */
-  isActive() {
-    if (this.netServer) {
-      return this.netServer.listening
-    }
-
-    return false
-  }
-
-  async stopClients() {
-    const promises = []
-
-    for (const clientCount in this.clients) {
-      const client = this.clients[clientCount]
-
-      promises.push(client.end())
-    }
-
-    await Promise.all(promises)
-  }
-
-  stopServer() {
-    return new Promise((resolve, reject) => {
-      if (!this.netServer) throw new Error("No netServer to stop")
-
-      this.netServer.close((error) => {
-        if (error) {
-          reject(error)
-        } else {
-          resolve(null)
-        }
-      })
-    })
-  }
-
-  async stop() {
-    await this.stopClients()
-    await this.stopServer()
-  }
-
-  onClose = () => {
-    this.events.emit("close")
-  }
-
-  /**
-   * @param {import("net").Socket} socket
-   */
-  onConnection = (socket) => {
-    const clientCount = this.clientCount
-
-    this.logger.debug(`New client ${clientCount}`)
-    this.clientCount++
-
-    const workerHandler = this.workerHandlerToUse()
-    const client = new ServerClient({
-      clientCount,
-      configuration: this.configuration,
-      socket
-    })
-
-    client.events.on("close", this.onClientClose)
-
-    this.logger.debug(`Gave client ${clientCount} to worker ${workerHandler.workerCount}`)
-    workerHandler.addSocketConnection(client)
-    this.clients[clientCount] = client
-  }
-
-  /**
-   * @param {ServerClient} client
-   */
-  onClientClose = (client) => {
-    const clientCount = digg(client, "clientCount")
-    const oldClientsLength = Object.keys(this.clients).length
-
-    delete this.clients[clientCount]
-
-    const newClientsLength = Object.keys(this.clients).length
-
-    if (newClientsLength != (oldClientsLength - 1)) {
-      console.error(`Expected client to have been removed but length didn't change from ${oldClientsLength} to ${oldClientsLength - 1}`)
-    }
-  }
-
-  async spawnWorker() {
-    const workerCount = this.workerCount
-
-    this.workerCount++
-
-    const workerHandler = new WorkerHandler({
-      configuration: this.configuration,
-      workerCount
-    })
-
-    await workerHandler.start()
-    this.workerHandlers.push(workerHandler)
-  }
-
-  workerHandlerToUse() {
-    this.logger.debug(`Worker handlers length: ${this.workerHandlers.length}`)
-
-    const randomWorkerNumber = Math.floor(Math.random() * this.workerHandlers.length)
-    const workerHandler = this.workerHandlers[randomWorkerNumber]
-
-    if (!workerHandler) {
-      throw new Error(`No workerHandler by that number: ${randomWorkerNumber}`)
-    }
-
-    return workerHandler
-  }
-}

package/src/http-server/server-client.js

@@ -1,81 +0,0 @@
-// @ts-check
-
-import EventEmitter from "events"
-import {Logger} from "../logger.js"
-
-export default class ServerClient {
-  events = new EventEmitter()
-
-  /**
-   * @param {object} args
-   * @param {import("../configuration.js").default} args.configuration
-   * @param {import("net").Socket} args.socket
-   * @param {number} args.clientCount
-   */
-  constructor({configuration, socket, clientCount}) {
-    if (!configuration) throw new Error("No configuration given")
-
-    this.configuration = configuration
-    this.logger = new Logger(this)
-    this.socket = socket
-    this.clientCount = clientCount
-
-    socket.on("end", this.onSocketEnd)
-  }
-
-  listen() {
-    this.socket.on("data", this.onSocketData)
-  }
-
-  end() {
-    return new Promise((resolve) => {
-      this.socket.once("close", () => resolve(null))
-      this.socket.end()
-    })
-  }
-
-  /**
-   * @param {Buffer} chunk
-   * @returns {void}
-   */
-  onSocketData = (chunk) => {
-    this.logger.debug(() => [`Socket ${this.clientCount}: ${chunk}`])
-
-    if (!this.worker) throw new Error("No worker")
-
-    this.worker.postMessage({
-      command: "clientWrite",
-      chunk,
-      clientCount: this.clientCount
-    })
-  }
-
-  /**
-   * @returns {void}
-   */
-  onSocketEnd = () => {
-    this.logger.debug(`Socket ${this.clientCount} end`)
-    this.events.emit("close", this)
-  }
-
-  /**
-   * @param {string} data
-   * @returns {Promise<void>}
-   */
-  async send(data) {
-    return new Promise((resolve) => {
-      this.logger.debug("Send", data)
-      this.socket.write(data, () => {
-        resolve()
-      })
-    })
-  }
-
-  /**
-   * @param {import("worker_threads").Worker} newWorker
-   * @returns {void}
-   */
-  setWorker(newWorker) {
-    this.worker = newWorker
-  }
-}

package/src/http-server/worker-handler/index.js

@@ -1,120 +0,0 @@
-// @ts-check
-
-import {Logger} from "../../logger.js"
-import {Worker} from "worker_threads"
-import ensureError from "../../utils/ensure-error.js"
-
-export default class VelociousHttpServerWorker {
-  /**
-   * @param {object} args
-   * @param {import("../../configuration.js").default} args.configuration
-   * @param {number} args.workerCount
-   */
-  constructor({configuration, workerCount}) {
-    this.configuration = configuration
-
-    /** @type {Record<number, import("../server-client.js").default>} */
-    this.clients = {}
-
-    this.logger = new Logger(this)
-    this.workerCount = workerCount
-  }
-
-  start() {
-    return new Promise((resolve) => {
-      this.onStartCallback = resolve
-      this._spawnWorker()
-    })
-  }
-
-  async _spawnWorker() {
-    const debug = this.configuration.debug
-    const directory = this.configuration.getDirectory()
-    const velociousPath = await this.configuration.getEnvironmentHandler().getVelociousPath()
-
-    this.worker = new Worker(`${velociousPath}/src/http-server/worker-handler/worker-script.js`, {
-      workerData: {
-        debug,
-        directory,
-        environment: this.configuration.getEnvironment(),
-        workerCount: this.workerCount
-      }
-    })
-    this.worker.on("error", this.onWorkerError)
-    this.worker.on("exit", this.onWorkerExit)
-    this.worker.on("message", this.onWorkerMessage)
-  }
-
-  /**
-   * @param {import("../server-client.js").default} client
-   * @returns {void}
-   */
-  addSocketConnection(client) {
-    const clientCount = client.clientCount
-
-    client.socket.on("end", () => {
-      this.logger.debug(`Removing ${clientCount} from clients`)
-      delete this.clients[clientCount]
-    })
-
-    if (!this.worker) throw new Error("Worker not initialized")
-
-    client.setWorker(this.worker)
-    client.listen()
-
-    this.clients[clientCount] = client
-    this.worker.postMessage({command: "newClient", clientCount})
-  }
-
-  /**
-   * @param {any} error
-   */
-  onWorkerError = (error) => {
-    throw ensureError(error) // Throws original error with backtrace and everything into the console
-  }
-
-  /**
-   * @param {number} code
-   * @returns {void}
-   */
-  onWorkerExit = (code) => {
-    if (code !== 0) {
-      throw new Error(`Client worker stopped with exit code ${code}`)
-    } else {
-      this.logger.debug(() => [`Client worker stopped with exit code ${code}`])
-    }
-  }
-
-  /**
-   * @param {object} data
-   * @param {string} data.command
-   * @param {number} data.clientCount
-   * @param {string} data.output
-   * @returns {void}
-   */
-  onWorkerMessage = (data) => {
-    this.logger.debug(`Worker message`, data)
-
-    const {command} = data
-
-    if (command == "started") {
-      if (this.onStartCallback) {
-        this.onStartCallback(null)
-      }
-
-      this.onStartCallback = null
-    } else if (command == "clientOutput") {
-      this.logger.debug("CLIENT OUTPUT", data)
-
-      const {clientCount, output} = data
-
-      this.clients[clientCount]?.send(output)
-    } else if (command == "clientClose") {
-      const {clientCount} = data
-
-      this.clients[clientCount]?.end()
-    } else {
-      throw new Error(`Unknown command: ${command}`)
-    }
-  }
-}

package/src/http-server/worker-handler/worker-script.js

@@ -1,6 +0,0 @@
-// @ts-check
-
-import {workerData, parentPort} from "worker_threads"
-import WorkerThread from "./worker-thread.js"
-
-new WorkerThread({parentPort, workerData})

package/src/http-server/worker-handler/worker-thread.js

@@ -1,106 +0,0 @@
-// @ts-check
-
-import Application from "../../application.js"
-import Client from "../client/index.js"
-import {digg} from "diggerize"
-import errorLogger from "../../error-logger.js"
-import {Logger} from "../../logger.js"
-
-export default class VelociousHttpServerWorkerHandlerWorkerThread {
-  /**
-   * @param {object} args
-   * @param {import("worker_threads").parentPort} args.parentPort
-   * @param {{directory: string, environment: string, workerCount: number}} args.workerData
-   */
-  constructor({parentPort, workerData}) {
-    if (!parentPort) throw new Error("parentPort is required")
-
-    const {workerCount} = workerData
-
-    /** @type {Record<number, Client>} */
-    this.clients = {}
-
-    this.logger = new Logger(this, {debug: false})
-    this.parentPort = parentPort
-    this.workerData = workerData
-    this.workerCount = workerCount
-
-    parentPort.on("message", errorLogger(this.onCommand))
-
-    this.initialize().then(() => {
-      if (!this.application) throw new Error("Application not initialized")
-
-      this.application.initialize().then(() => {
-        this.logger.debug(`Worker ${workerCount} started`)
-        parentPort.postMessage({command: "started"})
-      })
-    })
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async initialize() {
-    const {directory, environment} = this.workerData
-    const configurationPath = `${directory}/src/config/configuration.js`
-    const configurationImport = await import(configurationPath)
-
-    /** @type {import("../../configuration.js").default} */
-    this.configuration = configurationImport.default
-
-    if (!this.configuration) throw new Error(`Configuration couldn't be loaded from: ${configurationPath}`)
-
-    this.configuration.setEnvironment(environment)
-    this.configuration.setCurrent()
-
-    this.application = new Application({configuration: this.configuration, type: "worker-handler"})
-
-    if (this.configuration.isInitialized()) {
-      await this.configuration.initialize({type: "worker-handler"})
-    }
-  }
-
-  /**
-   * @param {object} data
-   * @param {string} data.command
-   * @param {string} [data.chunk]
-   * @param {number} data.clientCount
-   */
-  onCommand = async (data) => {
-    await this.logger.debug(() => [`Worker ${this.workerCount} received command`, data])
-
-    const command = data.command
-
-    if (command == "newClient") {
-      if (!this.configuration) throw new Error("Configuration not initialized")
-
-      const {clientCount} = data
-      const client = new Client({
-        clientCount,
-        configuration: this.configuration
-      })
-
-      client.events.on("output", (output) => {
-        this.parentPort.postMessage({command: "clientOutput", clientCount, output})
-      })
-
-      client.events.on("close", (output) => {
-        this.logger.log("Close received from client in worker - forwarding to worker parent")
-        this.parentPort.postMessage({command: "clientClose", clientCount, output})
-      })
-
-      this.clients[clientCount] = client
-    } else if (command == "clientWrite") {
-      await this.logger.debug("Looking up client")
-
-      const {chunk, clientCount} = data
-      const client = digg(this.clients, clientCount)
-
-      await this.logger.debug(`Sending to client ${clientCount}`)
-
-      client.onWrite(chunk)
-    } else {
-      throw new Error(`Unknown command: ${command}`)
-    }
-  }
-}

package/src/initializer.js

@@ -1,35 +0,0 @@
-// @ts-check
-
-import restArgsError from "./utils/rest-args-error.js"
-
-export default class VelociousInitializer {
-  /**
-   * @param {object} args
-   * @param {import("./configuration.js").default} args.configuration
-   * @param {string} args.type
-   */
-  constructor({configuration, type, ...restArgs}) {
-    restArgsError(restArgs)
-
-    this._configuration = configuration
-    this._type = type
-  }
-
-  /**
-   * @returns {import("./configuration.js").default}
-   */
-  getConfiguration() { return this._configuration }
-
-  /**
-   * @returns {string}
-   */
-  getType() { return this._type }
-
-  /**
-   * @abstract
-   * @returns {Promise<void>}
-   */
-  run() {
-    throw new Error(`'run' hasn't been implemented on ${this.constructor.name})`)
-  }
-}

package/src/logger.js

@@ -1,174 +0,0 @@
-// @ts-check
-
-import Configuration from "./configuration.js"
-import restArgsError from "./utils/rest-args-error.js"
-
-/**
- * @param {string} message
- * @returns {Promise<void>}
- */
-function consoleLog(message) {
-  return new Promise((resolve) => {
-    if (process.stdout) {
-      process.stdout.write(`${message}\n`, "utf8", () => resolve())
-    } else {
-      console.log(message)
-      resolve()
-    }
-  })
-}
-
-/**
- * @param {string} message
- * @returns {Promise<void>}
- */
-function consoleError(message) {
-  return new Promise((resolve) => {
-    if (process.stderr) {
-      process.stderr.write(`${message}\n`, "utf8", () => resolve())
-    } else {
-      console.error(message)
-      resolve()
-    }
-  })
-}
-
-/**
- * @param {string} message
- * @returns {Promise<void>}
- */
-function consoleWarn(message) {
-  return new Promise((resolve) => {
-    if (process.stderr) {
-      process.stderr.write(`${message}\n`, "utf8", () => resolve())
-    } else {
-      console.warn(message)
-      resolve()
-    }
-  })
-}
-
-/**
- * @param {...any|function() : Array<any>} messages
- * @returns {Array<any>} - Either the function result or the messages
- */
-function functionOrMessages(...messages) {
-  if (messages.length === 1 && typeof messages[0] == "function") {
-    messages = messages[0]()
-  }
-
-  return messages
-}
-
-/**
- * Converts multiple message parts into a single string.
- * @param {...any} messages - Parts to combine into a message
- * @returns {string}
- */
-function messagesToMessage(...messages) {
-  let message = ""
-
-  for (const messagePartIndex in messages) {
-    const messagePart = messages[messagePartIndex]
-
-    if (typeof messagePartIndex == "number" && messagePartIndex > 0) {
-      message += " "
-    }
-
-    if (typeof messagePart == "object") {
-      message += JSON.stringify(messagePart)
-    } else {
-      message += messagePart
-    }
-  }
-
-  return message
-}
-
-class Logger {
-  /**
-   * @param {any} object
-   * @param {object} args
-   * @param {boolean} args.debug
-   */
-  constructor(object, {debug, ...restArgs} = {debug: false}) {
-    restArgsError(restArgs)
-
-    this._debug = debug
-
-    if (typeof object == "string") {
-      this._subject = object
-    } else {
-      this._object = object
-      this._subject = object.constructor.name
-    }
-
-    if (!this._subject) {
-      throw new Error(`No subject given`)
-    }
-  }
-
-  /**
-   * @returns {import("./configuration.js").default}
-   */
-  getConfiguration() {
-    if (!this._configuration) {
-      this._configuration = this._object?.configuration || Configuration.current()
-    }
-
-    return this._configuration
-  }
-
-  /**
-   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
-   */
-  async debug(...messages) {
-    if (this._debug || this.getConfiguration()?.debug) {
-      await this.log(...messages)
-    }
-  }
-
-  /**
-   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
-   */
-  async log(...messages) {
-    await consoleLog(messagesToMessage(this._subject, ...functionOrMessages(...messages)))
-  }
-
-  /**
-   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
-   */
-  async error(...messages) {
-    await consoleError(messagesToMessage(this._subject, ...functionOrMessages(...messages)))
-  }
-
-  /**
-   * @param {boolean} newValue
-   * @returns {void}
-   */
-  setDebug(newValue) {
-    this._debug = newValue
-  }
-
-  /**
-   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
-   */
-  async warn(...messages) {
-    await consoleWarn(messagesToMessage(this._subject, ...functionOrMessages(...messages)))
-  }
-}
-
-export {Logger}
-
-/**
- * @param {any} object
- * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
- */
-export default async function logger(object, ...messages) {
-  const className = object.constructor.name
-  const configuration = object.configuration || Configuration.current()
-
-  if (configuration.debug) {
-    await consoleLog(messagesToMessage(className, ...functionOrMessages(...messages)))
-  }
-}