pinokiod 8.0.15 → 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.15",
+  "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")
@@ -16619,7 +16628,7 @@ class Server {
     this.app.post("/pinokio/install", ex((req, res) => {
       req.session.requirements = req.body.requirements
       req.session.callback = req.body.callback
-      res.redirect("/pinokio/install")
+      res.redirect(req.query.fresh === "1" ? "/pinokio/install?fresh=1" : "/pinokio/install")
     }))
     this.app.post("/pinokio/install/validate", ex(async (req, res) => {
       res.json({

package/server/views/install.ejs

@@ -819,6 +819,29 @@ document.addEventListener("DOMContentLoaded", async () => {
       options[key] = value;
     }
   }
+  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",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ type: "bin", background })
+      }))
+      if (result.cancelled) {
+        navigateToCallback()
+        return
+      }
+      if (result.error) throw new Error(result.error)
+    } catch (error) {
+      ModalInput({
+        title: "Error",
+        type: "modal",
+        description: error && error.message ? error.message : "Unable to reset managed tools."
+      })
+      return
+    }
+    setInstallStatus("<b>Installing tools...</b><br>Starting the fresh installation.")
+  }
   term.onData((data) => {
     if (shell_id) {
       socket.emit({

package/server/views/setup.ejs

@@ -179,7 +179,7 @@
 
                   <div class="setup-secondary-actions">
                     <span class="task-inline-help">Not working?</span>
-                    <button class="task-button" type="submit" form="install-form">
+                    <button class="task-button" type="submit" form="install-form" formaction="/pinokio/install?fresh=1">
                       <i class="fa-solid fa-trash" aria-hidden="true"></i>
                       <span>Try a fresh install</span>
                     </button>

package/server/views/tools.ejs

@@ -495,7 +495,7 @@
                             <span>Install</span>
                           </a>
                         <% } else { %>
-                          <form method="post" action="/pinokio/install">
+                          <form method="post" action="/pinokio/install?fresh=1">
                             <input type="hidden" name="requirements" value="<%= JSON.stringify(bundle.requirements) %>">
                             <input type="hidden" name="callback" value="/tools">
                             <button class="task-link-button" type="submit">

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/)
+})

package/test/tools-reinstall-ui.test.js

@@ -36,11 +36,11 @@ test("Tools reinstall immediately submits a fresh install request", async (t) =>
   })
   t.after(() => dom.window.close())
 
-  const form = dom.window.document.querySelector('.tools-bundle-actions form[action="/pinokio/install"]')
+  const form = dom.window.document.querySelector('.tools-bundle-actions form[action="/pinokio/install?fresh=1"]')
   form.addEventListener("submit", (event) => {
     event.preventDefault()
     submission = {
-      action: new URL(form.action).pathname,
+      action: `${new URL(form.action).pathname}${new URL(form.action).search}`,
       fields: Object.fromEntries(new dom.window.FormData(form)),
     }
   })
@@ -48,7 +48,7 @@ test("Tools reinstall immediately submits a fresh install request", async (t) =>
   button.click()
 
   assert.deepEqual(submission, {
-    action: "/pinokio/install",
+    action: "/pinokio/install?fresh=1",
     fields: {
       requirements: '[{"name":"conda","type":"bin","installed":true}]',
       callback: "/tools",
@@ -58,6 +58,6 @@ test("Tools reinstall immediately submits a fresh install request", async (t) =>
 
 test("setup fresh install immediately submits the existing install form", async () => {
   const source = await fs.readFile(setupViewPath, "utf8")
-  assert.match(source, /<button class="task-button" type="submit" form="install-form">/)
+  assert.match(source, /<button class="task-button" type="submit" form="install-form" formaction="\/pinokio\/install\?fresh=1">/)
   assert.doesNotMatch(source, /id="del-bin"|setup-reset-loading/)
 })