@lvce-editor/server 0.108.11 → 0.108.13

package/ThirdPartyNotices.txt

@@ -2,7 +2,7 @@ This project incorporates components from the projects listed below, that may ha
 differing from this project:
 
 
-1) License Notice for static/dd9c918/icons (from https://github.com/microsoft/vscode-codicons)
+1) License Notice for static/241d72e/icons (from https://github.com/microsoft/vscode-codicons)
 ---------------------------------------
 
 Attribution 4.0 International
@@ -402,7 +402,7 @@ public licenses.
 Creative Commons may be contacted at creativecommons.org.
 
 
-2) License Notice for static/dd9c918/fonts/FiraCode-VariableFont.ttf (from https://github.com/tonsky/FiraCode)
+2) License Notice for static/241d72e/fonts/FiraCode-VariableFont.ttf (from https://github.com/tonsky/FiraCode)
 ---------------------------------------
 
 Copyright (c) 2014, The Fira Code Project Authors (https://github.com/tonsky/FiraCode)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/server",
-  "version": "0.108.11",
+  "version": "0.108.13",
   "description": "Run LVCE Editor as a server.",
   "main": "index.js",
   "bin": "bin/server.js",
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "@lvce-editor/jsonc-parser": "^1.5.0",
-    "@lvce-editor/shared-process": "0.108.11",
-    "@lvce-editor/static-server": "0.108.11"
+    "@lvce-editor/shared-process": "0.108.13",
+    "@lvce-editor/static-server": "0.108.13"
   }
 }

package/src/server.js

@@ -63,6 +63,7 @@ const ErrorCodes = {
   ERR_STREAM_PREMATURE_CLOSE: 'ERR_STREAM_PREMATURE_CLOSE',
   EISDIR: 'EISDIR',
   ECONNRESET: 'ECONNRESET',
+  EPIPE: 'EPIPE',
   ENOENT: 'ENOENT',
   EADDRINUSE: 'EADDRINUSE',
 }
@@ -76,7 +77,7 @@ const isStatic = (url) => {
   if (url === '/index.html' || url.startsWith('/index.html?')) {
     return !hasLinkedExtensions
   }
-  if (url.startsWith('/dd9c918')) {
+  if (url.startsWith('/241d72e')) {
     return true
   }
   if (url.startsWith('/favicon.ico')) {
@@ -98,9 +99,9 @@ const handleRequest = (req, res) => {
     return
   }
   if (isStatic(req.url)) {
-    return handleResponseViaStaticServer(req, res, 'StaticServer.getResponse')
+    return handleResponseViaProcess(req, res, getOrCreateStaticServerPathProcess, 'StaticServer.getResponse')
   }
-  return sendHandleSharedProcess(req, res.socket, 'HandleRequest.handleRequest')
+  return handleResponseViaProcess(req, res, getOrCreateSharedProcess, 'HandleRequest.handleRequest')
 }
 
 const state = {
@@ -189,6 +190,7 @@ const launchProcess = async (processPath, execArgv) => {
         ...process.env,
       },
       execArgv: [],
+      serialization: 'advanced',
     })
     childProcess.on('exit', handleExit)
     childProcess.on('disconnect', handleSharedProcessDisconnect)
@@ -204,7 +206,9 @@ const launchProcess = async (processPath, execArgv) => {
 const launchSharedProcess = async () => {
   const sharedProcessUrl = new URL('src/sharedProcessMain.js', import.meta.resolve('@lvce-editor/shared-process')).toString()
   const sharedProcessPath = fileURLToPath(sharedProcessUrl)
-  return launchProcess(sharedProcessPath, ['--enable-source-maps', '--ipc-type=node-forked-process', ...argvSliced])
+  const ipc = await launchProcess(sharedProcessPath, ['--enable-source-maps', '--ipc-type=node-forked-process', ...argvSliced])
+  ipc.on('message', handleMessage)
+  return ipc
 }
 
 /**
@@ -256,25 +260,21 @@ const getHandleMessage = (request) => {
   }
 }
 
-const handleRequestError = (error) => {
-  if (error && error.code === 'ECONNRESET') {
-    // ignore
-    return
-  }
-  console.info('[info]: request upgrade error', error)
+const isExpectedConnectionError = (error) => {
+  return error && (error.code === ErrorCodes.ECONNRESET || error.code === ErrorCodes.EPIPE)
 }
 
-const handleSocketUpgradeError = (error) => {
-  // @ts-ignore
-  console.info('[info] request socket upgrade error', error)
+const handleRequestError = (error) => {
+  if (!isExpectedConnectionError(error)) {
+    console.info('[info]: request error', error)
+  }
 }
 
 const handleSocketError = (error) => {
-  if (error && error.code === 'ECONNRESET') {
-    return
+  if (!isExpectedConnectionError(error)) {
+    // @ts-ignore
+    console.info('[info] request socket error', error)
   }
-  // @ts-ignore
-  console.info('[info] request socket error', error)
 }
 
 const sendHandleSharedProcess = async (request, socket, method, ...params) => {
@@ -282,7 +282,7 @@ const sendHandleSharedProcess = async (request, socket, method, ...params) => {
   if (!socket) {
     return
   }
-  socket.on('error', handleSocketUpgradeError)
+  socket.on('error', handleSocketError)
   const sharedProcess = await getOrCreateSharedProcess()
   sharedProcess.send(
     {
@@ -331,27 +331,29 @@ const handleMessage = (message) => {
 
 const hasErrorListener = new WeakSet()
 
-const handleResponseViaStaticServer = async (request, res, method, ...params) => {
-  request.on('error', handleRequestError)
-  if (res.socket && !hasErrorListener.has(res.socket)) {
-    res.socket.on('error', handleSocketError)
-    hasErrorListener.add(res.socket)
-  }
-  const staticServerProcess = await getOrCreateStaticServerPathProcess()
+const invoke = async (ipc, method, ...params) => {
   const { id, promise } = registerCallback()
-  // TODO use rpc and invoke
-  staticServerProcess.send({
+  ipc.send({
     jsonrpc: '2.0',
     id,
     method,
-    params: [getHandleMessage(request), ...params],
+    params,
   })
   const response = await promise
-  const { result } = response
+  if (response.error) {
+    throw new Error(response.error.message)
+  }
+  return response.result
+}
+
+const sendResponse = (res, result) => {
   const { status, headers, body, hasBody } = result
   if (!status) {
     throw new Error('invalid status')
   }
+  if (res.destroyed) {
+    return
+  }
   res.statusCode = status
   setHeaders(res, headers)
   if (hasBody) {
@@ -361,6 +363,18 @@ const handleResponseViaStaticServer = async (request, res, method, ...params) =>
   }
 }
 
+const handleResponseViaProcess = async (request, res, getProcess, method, ...params) => {
+  request.on('error', handleRequestError)
+  res.on('error', handleSocketError)
+  if (res.socket && !hasErrorListener.has(res.socket)) {
+    res.socket.on('error', handleSocketError)
+    hasErrorListener.add(res.socket)
+  }
+  const ipc = await getProcess()
+  const result = await invoke(ipc, method, getHandleMessage(request), ...params)
+  sendResponse(res, result)
+}
+
 /**
  *
  * @param {import('http').IncomingMessage} request

package/test/httpResponse.integration.test.js

@@ -0,0 +1,100 @@
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { once } from 'node:events'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+
+const serverPath = path.join(import.meta.dirname, '..', 'src', 'server.js')
+
+const waitForListeningPort = (child) => {
+  return new Promise((resolve, reject) => {
+    let output = ''
+    const timeout = setTimeout(() => reject(new Error(`Timed out waiting for server\n${output}`)), 30_000)
+    const onData = (chunk) => {
+      output += chunk.toString('utf8')
+      const match = output.match(/listening on http:\/\/localhost:(\d+)/)
+      if (match) {
+        clearTimeout(timeout)
+        child.stdout.off('data', onData)
+        resolve(Number.parseInt(match[1], 10))
+      }
+    }
+    child.stdout.on('data', onData)
+    child.stderr.on('data', (chunk) => {
+      output += chunk.toString('utf8')
+    })
+    child.once('error', reject)
+    child.once('exit', (code) => reject(new Error(`Server exited with code ${code}\n${output}`)))
+  })
+}
+
+const killProcessGroup = (child, signal) => {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return
+  }
+  try {
+    process.kill(process.platform === 'win32' ? child.pid : -child.pid, signal)
+  } catch {
+    child.kill(signal)
+  }
+}
+
+const stopProcessGroup = async (child) => {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return
+  }
+  const exited = once(child, 'exit')
+  killProcessGroup(child, 'SIGTERM')
+  let timeout
+  const timedOut = new Promise((resolve) => {
+    timeout = setTimeout(resolve, 5_000, 'timeout')
+  })
+  const result = await Promise.race([exited.then(() => 'exited'), timedOut])
+  clearTimeout(timeout)
+  if (result === 'timeout') {
+    killProcessGroup(child, 'SIGKILL')
+    await exited
+  }
+}
+
+test('serves binary and partial responses returned by the shared process', async (context) => {
+  const directory = await mkdtemp(path.join(tmpdir(), 'lvce-http-response-'))
+  const file = path.join(directory, 'video.bin')
+  const content = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+  await writeFile(file, content)
+
+  const child = spawn(process.execPath, [serverPath], {
+    detached: true,
+    env: {
+      ...process.env,
+      PORT: '0',
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+  context.after(async () => {
+    await stopProcessGroup(child)
+    await rm(directory, { force: true, recursive: true })
+  })
+  const port = await waitForListeningPort(child)
+  const url = `http://localhost:${port}/remote${encodeURI(file)}`
+
+  const response = await fetch(url)
+  assert.equal(response.status, 200)
+  assert.deepEqual(Buffer.from(await response.arrayBuffer()), content)
+
+  const partialResponse = await fetch(url, {
+    headers: {
+      Range: 'bytes=2-5',
+    },
+  })
+  assert.equal(partialResponse.status, 206)
+  assert.equal(partialResponse.headers.get('accept-ranges'), 'bytes')
+  assert.equal(partialResponse.headers.get('content-range'), 'bytes 2-5/10')
+  assert.deepEqual(Buffer.from(await partialResponse.arrayBuffer()), Buffer.from([2, 3, 4, 5]))
+
+  const headResponse = await fetch(url, { method: 'HEAD' })
+  assert.equal(headResponse.status, 200)
+  assert.equal((await headResponse.arrayBuffer()).byteLength, 0)
+})