pinokiod 8.0.3 → 8.0.4

package/kernel/bin/caddy.js

@@ -8,6 +8,7 @@ const Util = require('../util')
 const ADMIN_READY_TIMEOUT_MS = 30000
 const ADMIN_START_TIMEOUT_MS = 5000
 const ADMIN_POLL_INTERVAL_MS = 250
+const ADMIN_STOP_TIMEOUT_MS = 5000
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 
@@ -29,6 +30,35 @@ class Caddy {
       return false
     }
   }
+  async waitForStopped(timeout = ADMIN_STOP_TIMEOUT_MS, interval = ADMIN_POLL_INTERVAL_MS) {
+    const started = Date.now()
+    while ((Date.now() - started) < timeout) {
+      if (!(await this.running())) {
+        return true
+      }
+      await sleep(interval)
+    }
+    return !(await this.running())
+  }
+  async stop() {
+    if (!(await this.running())) {
+      return false
+    }
+    try {
+      await axios.post('http://127.0.0.1:2019/stop', null, {
+        timeout: ADMIN_STOP_TIMEOUT_MS
+      })
+    } catch (error) {
+      if (await this.running()) {
+        throw error
+      }
+    }
+    const stopped = await this.waitForStopped()
+    if (!stopped) {
+      throw new Error("Pinokio could not stop Caddy before replacing the managed Conda runtime.")
+    }
+    return true
+  }
   async start() {
     // if peer.https_active is true,
     // 1. kill existing caddy

package/kernel/bin/conda.js

@@ -170,6 +170,16 @@ report_errors: false`)
     ondata({ raw: `downloading installer: ${installer_url}...\r\n` })
     await this.kernel.bin.download(installer_url, installer, ondata)
 
+    const caddy = this.kernel.bin.mod && this.kernel.bin.mod.caddy
+    let caddyWasRunning = false
+    if (caddy && typeof caddy.running === "function") {
+      caddyWasRunning = await caddy.running()
+    }
+    if (caddyWasRunning) {
+      ondata({ raw: `stopping Home Server before replacing Miniforge...\r\n` })
+      await caddy.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)
@@ -202,8 +212,12 @@ report_errors: false`)
       await fs.promises.writeFile(this.kernel.path(`bin/${CONDA_ROOT_DIR}/conda-meta/pinned`), this.pinnedPackages())
     }
 
+    const dependencies = new Set(Array.isArray(req.dependencies) ? req.dependencies : [])
+    if (caddyWasRunning) {
+      dependencies.add("caddy")
+    }
     let mods = this.kernel.bin.mods.filter((m) => {
-      return req.dependencies.includes(m.name)
+      return dependencies.has(m.name)
     }).map((m) => {
       if (m.mod.cmd) {
         return m.mod.cmd()
@@ -241,6 +255,10 @@ report_errors: false`)
     await this.ensureCompatibilityAlias()
     ondata({ raw: `Install finished\r\n` })
     await this.kernel.bin.rm(installer, ondata)
+    if (caddyWasRunning) {
+      ondata({ raw: `restarting Home Server after replacing Miniforge...\r\n` })
+      await caddy.start()
+    }
   }
   async removeInstallPath(target) {
     try {

package/package.json

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

package/test/caddy-install.test.js

@@ -51,3 +51,68 @@ test('caddy admin wait returns true when admin responds', async () => {
   assert.equal(ready, true)
   assert.equal(checks, 2)
 })
+
+test('caddy start uses the normal shell execution contract', async () => {
+  const caddy = new Caddy()
+  let running = false
+  let launch
+  caddy.kernel = {
+    homedir: '/tmp/pinokio',
+    peer: {
+      https_active: true,
+      announce() {}
+    },
+    processes: {},
+    exec(params, ondata) {
+      launch = params
+      running = true
+      ondata({ raw: '', cleaned: 'admin endpoint started' })
+    }
+  }
+  caddy.running = async () => running
+  caddy.installed = async () => true
+
+  await caddy.start()
+
+  assert.equal(launch.message, 'caddy run --watch')
+  assert.deepEqual(Object.keys(launch).sort(), ['message', 'path'])
+})
+
+test('caddy stop uses the native admin API only when Caddy is running', async () => {
+  const caddy = new Caddy()
+  let running = true
+  caddy.running = async () => running
+  const originalPost = require('axios').post
+  const calls = []
+  require('axios').post = async (...args) => {
+    calls.push(args)
+    running = false
+  }
+
+  try {
+    assert.equal(await caddy.stop(), true)
+    assert.equal(await caddy.stop(), false)
+  } finally {
+    require('axios').post = originalPost
+  }
+
+  assert.equal(calls.length, 1)
+  assert.equal(calls[0][0], 'http://127.0.0.1:2019/stop')
+})
+
+test('caddy stop refuses to continue when native shutdown is not confirmed', async () => {
+  const caddy = new Caddy()
+  caddy.running = async () => true
+  caddy.waitForStopped = async () => false
+  const originalPost = require('axios').post
+  require('axios').post = async () => {}
+
+  try {
+    await assert.rejects(
+      caddy.stop(),
+      /could not stop Caddy/
+    )
+  } finally {
+    require('axios').post = originalPost
+  }
+})

package/test/conda-bin.test.js

@@ -262,6 +262,60 @@ test('Conda install replaces the stale runtime and rebuilds declared Conda modul
   )
 })
 
+test('Conda replacement stops, preserves, and restarts a running managed Caddy', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-conda-caddy-lifecycle-'))
+  await createMiniforge(root)
+  const kernel = createKernel(root, 'win32')
+  const events = []
+  let caddyRunning = true
+  let condaInstall
+
+  const caddy = {
+    cmd: () => 'caddy=2.9.1',
+    running: async () => caddyRunning,
+    stop: async () => {
+      events.push('caddy-stop')
+      caddyRunning = false
+    },
+    start: async () => {
+      events.push('caddy-start')
+      caddyRunning = true
+    },
+  }
+  kernel.bin.installed.conda = new Set(['caddy'])
+  kernel.bin.mod = { caddy }
+  kernel.bin.mods = [{ name: 'caddy', mod: caddy }]
+  kernel.bin.download = async () => events.push('download')
+  kernel.bin.rm = async () => events.push('installer-cleanup')
+  kernel.bin.exec = async (payload) => {
+    if (payload && payload.conda && payload.conda.skip) {
+      events.push('bootstrap')
+      const miniforge = path.join(root, 'bin', 'miniforge')
+      await fs.mkdir(path.join(miniforge, 'conda-meta'), { recursive: true })
+      await fs.writeFile(path.join(miniforge, 'python.exe'), 'fake python\n')
+      return
+    }
+    events.push('conda-install')
+    condaInstall = payload
+  }
+
+  const conda = createConda(kernel)
+  const removeInstallPath = conda.removeInstallPath.bind(conda)
+  conda.removeInstallPath = async (target) => {
+    assert.equal(caddyRunning, false)
+    events.push('remove-miniforge')
+    await removeInstallPath(target)
+  }
+
+  await conda._install({ dependencies: [] }, () => {})
+
+  assert.ok(events.indexOf('caddy-stop') < events.indexOf('remove-miniforge'))
+  assert.ok(events.indexOf('remove-miniforge') < events.indexOf('bootstrap'))
+  assert.ok(events.indexOf('conda-install') < events.indexOf('caddy-start'))
+  assert.match(condaInstall.message[1], / caddy=2\.9\.1$/)
+  assert.equal(caddyRunning, true)
+})
+
 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)