pinokiod 8.0.16 → 8.0.17

package/kernel/bin/conda.js

@@ -185,7 +185,9 @@ report_errors: false`)
     install_path_exists = await this.kernel.exists(`bin/${CONDA_ROOT_DIR}`)
     if (install_path_exists) {
       console.log("Removing existing install path...", install_path)
+      ondata({ raw: `removing existing Miniforge installation...\r\n` })
       await this.removeInstallPath(install_path, ondata)
+      ondata({ raw: `existing Miniforge installation removed.\r\n` })
     }
 
     // 2. run the script

package/kernel/bin/index.js

@@ -715,7 +715,22 @@ class Bin {
     let res = await Util.filepicker(req, ondata, this.kernel)
     return res
   }
+  async runInstallExclusive(task) {
+    const previous = this.installQueue || Promise.resolve()
+    let release
+    const current = new Promise((resolve) => { release = resolve })
+    this.installQueue = previous.then(() => current)
+    await previous
+    try {
+      return await task()
+    } finally {
+      release()
+    }
+  }
   async install(req, ondata) {
+    return await this.runInstallExclusive(() => this.installRequirements(req, ondata))
+  }
+  async installRequirements(req, ondata) {
     /*
       req.params := {
         client: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "8.0.16",
+  "version": "8.0.17",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -16303,26 +16303,35 @@ class Server {
       }
       try {
         if (req.body.type === 'conda-runtime') {
-          for (const runtimeName of ["miniconda", "miniforge"]) {
-            const runtimePath = this.kernel.path("bin", runtimeName)
-            await removePath(runtimePath, {
+          await this.kernel.bin.runInstallExclusive(async () => {
+            for (const runtimeName of ["miniconda", "miniforge"]) {
+              const runtimePath = this.kernel.path("bin", runtimeName)
+              await removePath(runtimePath, {
+                recursive: true,
+                force: true,
+                diagnose: req.body.background !== true,
+                operation: "Updating Miniforge",
+              })
+            }
+          })
+          res.json({ success: true })
+        } else if (req.body.type === 'bin') {
+          let folderPath = this.kernel.path("bin")
+          await this.kernel.bin.runInstallExclusive(async () => {
+            const removalStartedAt = Date.now()
+            console.log(`[fresh install] removing bin: start ${folderPath}`)
+            await removePath(folderPath, {
               recursive: true,
               force: true,
               diagnose: req.body.background !== true,
-              operation: "Updating Miniforge",
+              operation: "Resetting managed tools",
             })
-          }
-          res.json({ success: true })
-        } else if (req.body.type === 'bin') {
-          let folderPath = this.kernel.path("bin")
-          await removePath(folderPath, {
-            recursive: true,
-            force: true,
-            diagnose: req.body.background !== true,
-            operation: "Resetting managed tools",
+            console.log(`[fresh install] removing bin: complete (${((Date.now() - removalStartedAt) / 1000).toFixed(1)}s)`)
+            await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
+            const refreshStartedAt = Date.now()
+            await this.kernel.bin.refreshInstalled()
+            console.log(`[fresh install] refreshing installed state: complete (${((Date.now() - refreshStartedAt) / 1000).toFixed(1)}s)`)
           })
-          await fs.promises.mkdir(folderPath, { recursive: true }).catch((e) => { })
-          await this.kernel.bin.refreshInstalled()
           res.json({ success: true })
         } else if (req.body.type === 'cache') {
           let folderPath = this.kernel.path("cache")

package/server/views/install.ejs

@@ -820,6 +820,7 @@ document.addEventListener("DOMContentLoaded", async () => {
     }
   }
   if (options && options.fresh === "1") {
+    setInstallStatus("<b>Removing existing tools...</b><br>This can take a minute on Windows.")
     try {
       const result = await PinokioPathRemoval.request((background) => fetch("/pinokio/delete", {
         method: "post",
@@ -839,6 +840,7 @@ document.addEventListener("DOMContentLoaded", async () => {
       })
       return
     }
+    setInstallStatus("<b>Installing tools...</b><br>Starting the fresh installation.")
   }
   term.onData((data) => {
     if (shell_id) {

package/test/conda-bin.test.js

@@ -425,6 +425,84 @@ test('Conda install keeps the old runtime when the replacement installer downloa
   assert.equal(await pathExists(oldRuntimeFile), true)
 })
 
+test('Conda waits for runtime removal before starting the installer', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-removal-order-'))
+  await createMiniforge(root)
+  const kernel = createKernel(root, 'win32')
+  const events = []
+  const output = []
+  let releaseRemoval
+  let removalStarted
+  const removalGate = new Promise((resolve) => { releaseRemoval = resolve })
+  const removalStartedPromise = new Promise((resolve) => { removalStarted = resolve })
+
+  kernel.bin.mods = []
+  kernel.bin.download = async () => events.push('download')
+  kernel.bin.rm = async () => events.push('installer-cleanup')
+  kernel.bin.exec = async (payload) => {
+    events.push(payload && payload.conda && payload.conda.skip ? 'installer' : 'conda-install')
+    if (payload && payload.conda && payload.conda.skip) {
+      await fs.mkdir(path.join(root, 'bin', 'miniforge', 'conda-meta'), { recursive: true })
+      await fs.writeFile(path.join(root, 'bin', 'miniforge', 'python.exe'), 'fake python\n')
+    }
+  }
+
+  const conda = createConda(kernel)
+  const removeInstallPath = conda.removeInstallPath.bind(conda)
+  conda.removeInstallPath = async (...args) => {
+    events.push('remove-start')
+    removalStarted()
+    await removalGate
+    await removeInstallPath(...args)
+    events.push('remove-complete')
+  }
+
+  const installation = conda._install({ dependencies: [] }, (data) => {
+    if (data && data.raw) output.push(data.raw)
+  })
+  await removalStartedPromise
+
+  assert.deepEqual(events, ['download', 'remove-start'])
+  assert.match(output.join(''), /removing existing Miniforge installation/)
+
+  releaseRemoval()
+  await installation
+
+  assert.ok(events.indexOf('remove-complete') < events.indexOf('installer'))
+  assert.match(output.join(''), /existing Miniforge installation removed/)
+})
+
+test('Bin serializes concurrent installs without dropping either request', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-bin-install-single-flight-'))
+  const bin = createBin(root)
+  const events = []
+  let release
+  const gate = new Promise((resolve) => { release = resolve })
+
+  bin.installRequirements = async (req) => {
+    events.push(`start:${req.id}`)
+    if (req.id === 'first') await gate
+    events.push(`finish:${req.id}`)
+    return req.id
+  }
+
+  const first = bin.install({ id: 'first' }, () => {})
+  const second = bin.install({ id: 'second' }, () => {})
+  await Promise.resolve()
+  assert.deepEqual(events, ['start:first'])
+
+  release()
+  assert.deepEqual(await Promise.all([first, second]), ['first', 'second'])
+  assert.deepEqual(events, ['start:first', 'finish:first', 'start:second', 'finish:second'])
+
+  bin.installRequirements = async (req) => {
+    if (req.id === 'failure') throw new Error('install failed')
+    return req.id
+  }
+  await assert.rejects(bin.install({ id: 'failure' }, () => {}), /install failed/)
+  assert.equal(await bin.install({ id: 'after-failure' }, () => {}), 'after-failure')
+})
+
 test('Conda install propagates bootstrap failure after replacing the runtime', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-bootstrap-fails-'))
   await createMiniforge(root)

package/test/path-removal-ui.test.js

@@ -457,3 +457,62 @@ test("successful runtime cleanup resubmits the interrupted install", async (t) =
     fields: { requirements, callback: "/tools" },
   })
 })
+
+test("fresh install shows removal status and waits for cleanup before starting", async (t) => {
+  const source = await fs.readFile(installViewPath, "utf8")
+  const html = ejs.render(source, {
+    agent: "web",
+    callback: "/tools",
+    requirements: '[{"name":"conda"}]',
+    theme: "dark",
+  }, { filename: installViewPath })
+
+  let cleanupStarted = false
+  let resolveCleanup
+  let socketStarted = false
+  const cleanup = new Promise((resolve) => { resolveCleanup = resolve })
+  const dom = new JSDOM(html, {
+    runScripts: "dangerously",
+    url: "http://localhost/pinokio/install?fresh=1",
+    beforeParse(window) {
+      window.fetch = async () => ({ json: async () => ({ config: {} }) })
+      window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} })
+      window.ResizeObserver = class { observe() {} }
+      window.N = class { Noty() {} }
+      window.Terminal = class {
+        constructor() { this.cols = 80; this.rows = 24 }
+        attachCustomKeyEventHandler() {}
+        focus() {}
+        hasSelection() { return false }
+        loadAddon() {}
+        onData() {}
+        open() {}
+        write() {}
+      }
+      window.FitAddon = { FitAddon: class { fit() {} } }
+      window.WebLinksAddon = { WebLinksAddon: class {} }
+      window.xtermTheme = { FrontEndDelight: {} }
+      window.PinokioTouch = { bindTerminalFocus() {} }
+      window.PinokioPathRemoval = {
+        request: async () => {
+          cleanupStarted = true
+          return await cleanup
+        },
+      }
+      window.Socket = class {
+        emit() {}
+        run() { socketStarted = true }
+      }
+    },
+  })
+  t.after(() => dom.window.close())
+
+  await waitFor(() => cleanupStarted, "fresh cleanup request")
+  assert.match(dom.window.document.querySelector("#status-screen").textContent, /Removing existing tools/)
+  assert.match(dom.window.document.querySelector("#status-screen").textContent, /take a minute on Windows/)
+  assert.equal(socketStarted, false)
+
+  resolveCleanup({ success: true })
+  await waitFor(() => socketStarted, "installer socket")
+  assert.match(dom.window.document.querySelector("#status-screen").textContent, /Installing tools/)
+})