Ensure worker close gracefully with the same behaviours in both Terminal and Desktop apps

gui/gui.js

@@ -1498,15 +1498,21 @@ class PearGUI extends ReadyResource {
         evt.reply('workerPipeClose')
       })
       pipe.on('data', (data) => { evt.reply('workerPipeData', data) })
-      pipe.on('end', () => { evt.reply('workerPipeData', null) })
-      pipe.on('error', (err) => { evt.reply('pipeError', err.stack) })
+      pipe.on('end', () => { evt.reply('workerPipeEnd') })
+      pipe.on('error', (err) => { evt.reply('workerPipeError', err.stack) })
     })
 
     electron.ipcMain.on('workerPipeId', (evt) => {
       evt.returnValue = this.pipes.nextId()
       return evt.returnValue
     })
 
+    electron.ipcMain.on('workerPipeEnd', (evt, id) => {
+      const pipe = this.pipes.from(id)
+      if (!pipe) return
+      pipe.end()
+    })
+
     electron.ipcMain.on('workerPipeClose', (evt, id) => {
       const pipe = this.pipes.from(id)
       if (!pipe) return

gui/preload.js

@@ -295,19 +295,24 @@ class IPC {
     return stream
   }
 
-  workerRun (link) {
+  workerRun (link, args) {
     const id = electron.ipcRenderer.sendSync('workerPipeId')
-    electron.ipcRenderer.send('workerRun', link)
+    electron.ipcRenderer.send('workerRun', link, args)
     const stream = new streamx.Duplex({
       write (data, cb) {
         electron.ipcRenderer.send('workerPipeWrite', id, data)
         cb()
+      },
+      final (cb) {
+        electron.ipcRenderer.send('workerPipeEnd', id)
+        cb()
       }
     })
     electron.ipcRenderer.on('workerPipeError', (e, stack) => {
       stream.emit('error', new Error('Worker PipeError (from electron-main): ' + stack))
     })
-    electron.ipcRenderer.on('workerClose', () => { stream.destroy() })
+    electron.ipcRenderer.on('workerPipeClose', () => { stream.destroy() })
+    electron.ipcRenderer.on('workerPipeEnd', () => { stream.end() })
     stream.once('close', () => {
       electron.ipcRenderer.send('workerPipeClose', id)
     })

lib/worker.js

@@ -53,9 +53,13 @@ class Worker {
       this.#unref()
     })
     const pipe = sp.stdio[3]
-    pipe.on('end', () => {
-      if (pipe.ended === false) pipe.end()
-    })
+    pipe.pid = sp.pid
+    const pipeEmit = pipe.emit
+    pipe.emit = function (event, ...args) {
+      if (event === 'error' && args[0]?.code === 'ENOTCONN') return false
+      return pipeEmit.apply(this, [event, ...args])
+    }
+    pipe.on('end', () => pipe.end())
     return pipe
   }
 

test/03-worker.test.js

@@ -8,6 +8,17 @@ const helloWorld = path.join(Helper.localDir, 'test', 'fixtures', 'hello-world')
 const printArgs = path.join(Helper.localDir, 'test', 'fixtures', 'print-args')
 const workerRunner = path.join(Helper.localDir, 'test', 'fixtures', 'worker-runner')
 
+const workerParent = path.join(Helper.localDir, 'test', 'fixtures', 'worker-parent')
+const workerChild = path.join(Helper.localDir, 'test', 'fixtures', 'worker-child')
+const workerEndFromChild = path.join(Helper.localDir, 'test', 'fixtures', 'worker-end-from-child')
+const workerDestroyFromChild = path.join(Helper.localDir, 'test', 'fixtures', 'worker-destroy-from-child')
+const workerEndFromParent = path.join(Helper.localDir, 'test', 'fixtures', 'worker-end-from-parent')
+const workerDestroyFromParent = path.join(Helper.localDir, 'test', 'fixtures', 'worker-destroy-from-parent')
+
+const workerParentDesktop = path.join(Helper.localDir, 'test', 'fixtures', 'worker-parent-desktop')
+const workerEndFromParentDesktop = path.join(Helper.localDir, 'test', 'fixtures', 'worker-end-from-parent-desktop')
+const workerDestroyFromParentDesktop = path.join(Helper.localDir, 'test', 'fixtures', 'worker-destroy-from-parent-desktop')
+
 test('worker pipe', async function ({ is, plan, teardown }) {
   plan(1)
   const helper = new Helper()
@@ -99,3 +110,51 @@ test('worker should run as a link in a terminal app', async function ({ is, plan
 
   await Helper.untilClose(pipe)
 })
+
+//
+// test worker exit gracefully for terminal app
+//
+
+test('[terminal] worker exit when child calls pipe.end()', async function () {
+  const { pipe } = await Helper.run({ link: workerParent, args: [workerEndFromChild] })
+  await Helper.untilWorkerExit(pipe)
+})
+
+test('[terminal] worker exit when child calls pipe.destroy()', async function () {
+  const { pipe } = await Helper.run({ link: workerParent, args: [workerDestroyFromChild] })
+  await Helper.untilWorkerExit(pipe)
+})
+
+test('[terminal] worker exit when parent calls pipe.end()', async function () {
+  const { pipe } = await Helper.run({ link: workerEndFromParent, args: [workerChild] })
+  await Helper.untilWorkerExit(pipe)
+})
+
+test('[terminal] worker exit when parent calls pipe.destroy()', async function () {
+  const { pipe } = await Helper.run({ link: workerDestroyFromParent, args: [workerChild] })
+  await Helper.untilWorkerExit(pipe)
+})
+
+//
+// test worker exit gracefully for desktop app
+//
+
+test('[desktop] worker exit when child calls pipe.end()', async function () {
+  const { pipe } = await Helper.run({ link: workerParentDesktop, args: [workerEndFromChild] })
+  await Helper.untilWorkerExit(pipe)
+})
+
+test('[desktop] worker exit when child calls pipe.destroy()', async function () {
+  const { pipe } = await Helper.run({ link: workerParentDesktop, args: [workerDestroyFromChild] })
+  await Helper.untilWorkerExit(pipe)
+})
+
+test('[desktop] worker exit when parent calls pipe.end()', async function () {
+  const { pipe } = await Helper.run({ link: workerEndFromParentDesktop, args: [workerChild] })
+  await Helper.untilWorkerExit(pipe)
+})
+
+test('[desktop] worker exit when parent calls pipe.destroy()', async function () {
+  const { pipe } = await Helper.run({ link: workerDestroyFromParentDesktop, args: [workerChild] })
+  await Helper.untilWorkerExit(pipe)
+})

test/fixtures/worker-child/index.js

@@ -0,0 +1,2 @@
+const pipe = Pear.worker.pipe()
+pipe.resume()

test/fixtures/worker-child/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "worker-child",
+  "main": "index.js",
+  "type": "module",
+  "pear": {}
+}

test/fixtures/worker-destroy-from-child/index.js

@@ -0,0 +1,4 @@
+const pipe = Pear.worker.pipe()
+pipe.resume()
+await new Promise((resolve) => setTimeout(resolve, 1000))
+pipe.destroy()

test/fixtures/worker-destroy-from-child/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "worker-destroy-from-child",
+  "main": "index.js",
+  "type": "module",
+  "pear": {}
+}

test/fixtures/worker-destroy-from-parent-desktop/app.js

@@ -0,0 +1,23 @@
+const link = Pear.config.args[Pear.config.args.length - 1]
+const pipe = Pear.worker.run(link)
+pipe.resume()
+await new Promise((resolve) => setTimeout(resolve, 1000))
+pipe.destroy()
+await untilExit(pipe)
+Pear.Window.self.close()
+
+async function untilExit (pipe, timeout = 5000) {
+  const start = Date.now()
+  while (isRunning(pipe)) {
+    if (Date.now() - start > timeout) throw new Error('timed out')
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+}
+
+function isRunning (pipe) {
+  try {
+    return process.kill(pipe.pid, 0)
+  } catch (err) {
+    return err.code === 'EPERM'
+  }
+}

test/fixtures/worker-destroy-from-parent-desktop/index.html

@@ -0,0 +1,2 @@
+<pear-ctrl></pear-ctrl>
+<script src="./app.js" type="module"></script>

test/fixtures/worker-destroy-from-parent-desktop/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "worker-destroy-from-parent-desktop",
+  "main": "index.html",
+  "type": "module",
+  "pear": {}
+}

test/fixtures/worker-destroy-from-parent/index.js

@@ -0,0 +1,22 @@
+const link = Bare.argv[Bare.argv.length - 1]
+const pipe = Pear.worker.run(link)
+pipe.resume()
+await new Promise((resolve) => setTimeout(resolve, 1000))
+pipe.destroy()
+await untilExit(pipe)
+
+async function untilExit (pipe, timeout = 5000) {
+  const start = Date.now()
+  while (isRunning(pipe)) {
+    if (Date.now() - start > timeout) throw new Error('timed out')
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+}
+
+function isRunning (pipe) {
+  try {
+    return process.kill(pipe.pid, 0)
+  } catch (err) {
+    return err.code === 'EPERM'
+  }
+}

test/fixtures/worker-destroy-from-parent/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "worker-destroy-from-parent",
+  "main": "index.js",
+  "type": "module",
+  "pear": {}
+}

test/fixtures/worker-end-from-child/index.js

@@ -0,0 +1,4 @@
+const pipe = Pear.worker.pipe()
+pipe.resume()
+await new Promise((resolve) => setTimeout(resolve, 1000))
+pipe.end()

test/fixtures/worker-end-from-child/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "worker-end-from-child",
+  "main": "index.js",
+  "type": "module",
+  "pear": {}
+}

test/fixtures/worker-end-from-parent-desktop/app.js

@@ -0,0 +1,23 @@
+const link = Pear.config.args[Pear.config.args.length - 1]
+const pipe = Pear.worker.run(link)
+pipe.resume()
+await new Promise((resolve) => setTimeout(resolve, 1000))
+pipe.end()
+await untilExit(pipe)
+Pear.Window.self.close()
+
+async function untilExit (pipe, timeout = 5000) {
+  const start = Date.now()
+  while (isRunning(pipe)) {
+    if (Date.now() - start > timeout) throw new Error('timed out')
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+}
+
+function isRunning (pipe) {
+  try {
+    return process.kill(pipe.pid, 0)
+  } catch (err) {
+    return err.code === 'EPERM'
+  }
+}

test/fixtures/worker-end-from-parent-desktop/index.html

@@ -0,0 +1,2 @@
+<pear-ctrl></pear-ctrl>
+<script src="./app.js" type="module"></script>

test/fixtures/worker-end-from-parent-desktop/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "worker-end-from-parent-desktop",
+  "main": "index.html",
+  "type": "module",
+  "pear": {}
+}

test/fixtures/worker-end-from-parent/index.js

@@ -0,0 +1,22 @@
+const link = Bare.argv[Bare.argv.length - 1]
+const pipe = Pear.worker.run(link)
+pipe.resume()
+await new Promise((resolve) => setTimeout(resolve, 1000))
+pipe.end()
+await untilExit(pipe)
+
+async function untilExit (pipe, timeout = 5000) {
+  const start = Date.now()
+  while (isRunning(pipe)) {
+    if (Date.now() - start > timeout) throw new Error('timed out')
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+}
+
+function isRunning (pipe) {
+  try {
+    return process.kill(pipe.pid, 0)
+  } catch (err) {
+    return err.code === 'EPERM'
+  }
+}

test/fixtures/worker-end-from-parent/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "worker-end-from-parent",
+  "main": "index.js",
+  "type": "module",
+  "pear": {}
+}

test/fixtures/worker-parent-desktop/app.js

@@ -0,0 +1,21 @@
+const link = Pear.config.args[Pear.config.args.length - 1]
+const pipe = Pear.worker.run(link)
+pipe.resume()
+await untilExit(pipe)
+Pear.Window.self.close()
+
+async function untilExit (pipe, timeout = 5000) {
+  const start = Date.now()
+  while (isRunning(pipe)) {
+    if (Date.now() - start > timeout) throw new Error('timed out')
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+}
+
+function isRunning (pipe) {
+  try {
+    return process.kill(pipe.pid, 0)
+  } catch (err) {
+    return err.code === 'EPERM'
+  }
+}

test/fixtures/worker-parent-desktop/index.html

@@ -0,0 +1,2 @@
+<pear-ctrl></pear-ctrl>
+<script src="./app.js" type="module"></script>

test/fixtures/worker-parent-desktop/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "worker-parent-desktop",
+  "main": "index.html",
+  "type": "module",
+  "pear": {}
+}

test/fixtures/worker-parent/index.js

@@ -0,0 +1,20 @@
+const link = Bare.argv[Bare.argv.length - 1]
+const pipe = Pear.worker.run(link)
+pipe.resume()
+await untilExit(pipe)
+
+async function untilExit (pipe, timeout = 5000) {
+  const start = Date.now()
+  while (isRunning(pipe)) {
+    if (Date.now() - start > timeout) throw new Error('timed out')
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+}
+
+function isRunning (pipe) {
+  try {
+    return process.kill(pipe.pid, 0)
+  } catch (err) {
+    return err.code === 'EPERM'
+  }
+}

test/fixtures/worker-parent/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "worker-parent",
+  "main": "index.js",
+  "type": "module",
+  "pear": {}
+}

test/helper.js

@@ -196,6 +196,22 @@ class Helper extends IPC.Client {
     return res
   }
 
+  static async isRunning (pipe) {
+    try {
+      return process.kill(pipe.pid, 0)
+    } catch (err) {
+      return err.code === 'EPERM'
+    }
+  }
+
+  static async untilWorkerExit (pipe, timeout = 5000) {
+    const start = Date.now()
+    while (await this.isRunning(pipe)) {
+      if (Date.now() - start > timeout) throw new Error('timed out')
+      await new Promise((resolve) => setTimeout(resolve, 100))
+    }
+  }
+
   static async pick (stream, ptn = {}, by = 'tag') {
     if (Array.isArray(ptn)) return this.#untils(stream, ptn, by)
     for await (const output of stream) {