pinokiod 8.2.20 → 8.2.21

package/kernel/bin/conda.js

@@ -273,6 +273,11 @@ report_errors: false`)
       await caddy.stop()
     }
 
+    if (this.kernel.anywhere) {
+      ondata({ raw: `stopping Pinokio Anywhere before replacing Miniforge...\r\n` })
+      await this.kernel.anywhere.stop()
+    }
+
     legacy_path_exists = await this.kernel.exists(`bin/${LEGACY_CONDA_ROOT_DIR}`)
     if (legacy_path_exists) {
       console.log("Removing legacy install path...", legacy_path)

package/package.json

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

package/test/conda-bin.test.js

@@ -471,6 +471,65 @@ test('Conda replacement stops a running managed Caddy without restoring it', asy
   assert.equal(caddyRunning, false)
 })
 
+test('Conda replacement waits for Anywhere shutdown before deleting either runtime', async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-anywhere-stop-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  const miniforge = await createMiniforge(root)
+  const miniconda = await createLegacyMiniconda(root)
+  const kernel = createKernel(root, 'win32')
+  let finishStop
+  let enteredStop
+  const stopping = new Promise(resolve => { enteredStop = resolve })
+  const stopped = new Promise(resolve => { finishStop = resolve })
+  kernel.anywhere = { stop: async () => { enteredStop(); await stopped } }
+  kernel.bin.mods = []
+  kernel.bin.download = async () => {}
+  kernel.bin.rm = async () => {}
+  let bootstrapped = false
+  kernel.bin.exec = async payload => {
+    if (payload.conda?.skip) {
+      bootstrapped = true
+      assert.equal(await pathExists(miniforge), false)
+      assert.equal(await pathExists(miniconda), false)
+      await fs.mkdir(path.join(miniforge, 'conda-meta'), { recursive: true })
+      await fs.writeFile(path.join(miniforge, 'python.exe'), 'fake python\n')
+    }
+  }
+
+  const conda = createConda(kernel)
+  const installing = conda._install({ dependencies: [] }, () => {})
+  try {
+    await stopping
+    await new Promise(setImmediate)
+    assert.equal(await pathExists(path.join(miniforge, 'Scripts/conda.exe')), true)
+    assert.equal(await pathExists(path.join(miniconda, 'Scripts/conda.exe')), true)
+    assert.equal(bootstrapped, false)
+  } finally {
+    finishStop()
+    await installing
+  }
+  assert.equal(bootstrapped, true)
+})
+
+test('Conda replacement preserves both runtimes when Anywhere shutdown fails', async t => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-anywhere-failure-'))
+  t.after(() => fs.rm(root, { recursive: true, force: true }))
+  const miniforge = await createMiniforge(root)
+  const miniconda = await createLegacyMiniconda(root)
+  const kernel = createKernel(root, 'win32')
+  const failure = new Error('tailscaled did not stop')
+  kernel.anywhere = { stop: async () => { throw failure } }
+  kernel.bin.download = async () => {}
+  kernel.bin.exec = async () => assert.fail('installer must not run after shutdown failure')
+  const conda = createConda(kernel)
+  conda.removeInstallPath = async () => assert.fail('runtime deletion must not start after shutdown failure')
+
+  await assert.rejects(conda._install({ dependencies: [] }, () => {}), error => error === failure)
+
+  assert.equal(await fs.readFile(path.join(miniforge, 'Scripts/conda.exe'), 'utf8'), 'fake conda\n')
+  assert.equal(await fs.readFile(path.join(miniconda, 'Scripts/conda.exe'), 'utf8'), 'fake conda\n')
+})
+
 test('Conda install replaces legacy miniconda with a compatibility alias to miniforge', async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-miniforge-alias-'))
   const legacy = await createLegacyMiniconda(root)