pinokiod 7.4.3 → 7.5.1

package/kernel/legacy_cleanup/index.js

@@ -1,47 +0,0 @@
-const path = require('path')
-const ffmpeg = require('./ffmpeg')
-
-const CLEANUPS = [
-  ffmpeg,
-]
-
-class LegacyCleanup {
-  constructor(kernel) {
-    this.kernel = kernel
-    this.promises = new Map()
-  }
-
-  async runOnce(ondata) {
-    const home = this.kernel && this.kernel.homedir ? path.resolve(this.kernel.homedir) : ''
-    if (this.promises.has(home)) {
-      return this.promises.get(home)
-    }
-    const promise = this.run(ondata).catch((error) => {
-      this.promises.delete(home)
-      throw error
-    })
-    this.promises.set(home, promise)
-    return promise
-  }
-
-  async run(ondata) {
-    if (!this.kernel || !this.kernel.homedir) {
-      return { skipped: true, results: [] }
-    }
-
-    const cleanupResults = []
-    for (const cleanup of CLEANUPS) {
-      if (await cleanup.hasCleanupTargets(this.kernel)) {
-        cleanupResults.push({
-          name: cleanup.name || 'legacy',
-          results: await cleanup.run(this.kernel, ondata),
-        })
-      }
-    }
-
-    return { skipped: false, results: cleanupResults }
-  }
-}
-
-module.exports = LegacyCleanup
-module.exports.ffmpeg = ffmpeg

package/test/legacy-cleanup.test.js

@@ -1,161 +0,0 @@
-const assert = require('node:assert/strict')
-const fsSync = require('node:fs')
-const fs = require('node:fs/promises')
-const os = require('node:os')
-const path = require('node:path')
-const test = require('node:test')
-
-const LegacyCleanup = require('../kernel/legacy_cleanup')
-
-function createKernel(root) {
-  return {
-    homedir: root,
-    bin: {
-      path: (...parts) => path.join(root, 'bin', ...parts),
-    },
-  }
-}
-
-async function writeFixtureFile(filepath) {
-  await fs.mkdir(path.dirname(filepath), { recursive: true })
-  await fs.writeFile(filepath, 'legacy\n')
-}
-
-async function exists(filepath) {
-  try {
-    await fs.access(filepath)
-    return true
-  } catch (_) {
-    return false
-  }
-}
-
-async function createLegacyFfmpegState(root) {
-  const activate = path.join(root, 'bin', 'miniconda', 'etc', 'conda', 'activate.d')
-  const deactivate = path.join(root, 'bin', 'miniconda', 'etc', 'conda', 'deactivate.d')
-  const hooks = [
-    path.join(activate, 'zz_pinokio_ffmpeg.sh'),
-    path.join(activate, 'zz_pinokio_ffmpeg.bat'),
-    path.join(activate, 'zz_pinokio_ffmpeg.ps1'),
-    path.join(deactivate, 'zz_pinokio_ffmpeg.sh'),
-    path.join(deactivate, 'zz_pinokio_ffmpeg.bat'),
-    path.join(deactivate, 'zz_pinokio_ffmpeg.ps1'),
-  ]
-  for (const hook of hooks) {
-    await writeFixtureFile(hook)
-  }
-
-  const dirs = [
-    path.join(root, 'bin', 'ffmpeg-env'),
-    path.join(root, 'bin', 'ffmpeg-pkgs'),
-    path.join(root, 'bin', 'ffmpeg'),
-    path.join(root, 'bin', 'ffmpeg-tmp'),
-  ]
-  for (const dir of dirs) {
-    await fs.mkdir(dir, { recursive: true })
-    await fs.writeFile(path.join(dir, 'marker.txt'), 'legacy\n')
-  }
-
-  return { hooks, dirs }
-}
-
-test('LegacyCleanup removes stale FFmpeg Conda hooks and old runtime paths once at startup', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-legacy-cleanup-'))
-  const { hooks, dirs } = await createLegacyFfmpegState(root)
-  const packets = []
-  const cleanup = new LegacyCleanup(createKernel(root))
-
-  const result = await cleanup.runOnce((packet) => packets.push(packet))
-
-  assert.equal(result.skipped, false)
-  assert.ok(result.results.some((cleanupResult) => {
-    return cleanupResult.name === 'ffmpeg' &&
-      cleanupResult.results.some((item) => item.found && item.removed)
-  }))
-  for (const hook of hooks) {
-    assert.equal(await exists(hook), false, `${hook} should be removed`)
-  }
-  for (const dir of dirs) {
-    assert.equal(await exists(dir), false, `${dir} should be removed`)
-  }
-  assert.ok(packets.some((packet) => /removed legacy path:/.test(packet.raw || '')))
-})
-
-test('LegacyCleanup runOnce does not repeat work in the same process', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-legacy-once-'))
-  const kernel = createKernel(root)
-  const cleanup = new LegacyCleanup(kernel)
-  const first = await cleanup.runOnce(() => {})
-
-  const lateHook = path.join(root, 'bin', 'miniconda', 'etc', 'conda', 'activate.d', 'zz_pinokio_ffmpeg.bat')
-  await writeFixtureFile(lateHook)
-  const second = await cleanup.runOnce(() => {})
-
-  assert.strictEqual(second, first)
-  assert.equal(await exists(lateHook), true)
-})
-
-test('LegacyCleanup tells the user which stale FFmpeg hooks to delete when removal fails', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-legacy-locked-'))
-  await createLegacyFfmpegState(root)
-  const kernel = createKernel(root)
-  const originalRm = fsSync.promises.rm
-  const lockedHook = path.join(root, 'bin', 'miniconda', 'etc', 'conda', 'activate.d', 'zz_pinokio_ffmpeg.bat')
-  const packets = []
-
-  fsSync.promises.rm = async (target, options) => {
-    if (target === lockedHook) {
-      const error = new Error('locked')
-      error.code = 'EPERM'
-      throw error
-    }
-    return originalRm(target, options)
-  }
-
-  try {
-    await assert.rejects(
-      new LegacyCleanup(kernel).runOnce((packet) => packets.push(packet)),
-      (error) => {
-        assert.equal(error.name, 'LegacyFfmpegCleanupError')
-        assert.match(error.message, /Close all Pinokio windows/)
-        assert.match(error.message, /delete these files/)
-        assert.match(error.message, /zz_pinokio_ffmpeg\.bat/)
-        assert.ok(error.failures.some((failure) => failure.target === lockedHook))
-        return true
-      }
-    )
-    assert.ok(packets.some((packet) => /could not remove legacy path:/.test(packet.raw || '')))
-  } finally {
-    fsSync.promises.rm = originalRm
-  }
-})
-
-test('LegacyCleanup does not block startup when only an old FFmpeg runtime directory is locked', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'pinokio-legacy-runtime-locked-'))
-  const runtimeDir = path.join(root, 'bin', 'ffmpeg-env')
-  await fs.mkdir(runtimeDir, { recursive: true })
-  await fs.writeFile(path.join(runtimeDir, 'marker.txt'), 'legacy\n')
-  const kernel = createKernel(root)
-  const originalRm = fsSync.promises.rm
-  const packets = []
-
-  fsSync.promises.rm = async (target, options) => {
-    if (target === runtimeDir) {
-      const error = new Error('locked')
-      error.code = 'EPERM'
-      throw error
-    }
-    return originalRm(target, options)
-  }
-
-  try {
-    const result = await new LegacyCleanup(kernel).runOnce((packet) => packets.push(packet))
-    assert.ok(result.results.some((cleanupResult) => {
-      return cleanupResult.name === 'ffmpeg' &&
-        cleanupResult.results.some((item) => item.target === runtimeDir && item.removed === false)
-    }))
-    assert.ok(packets.some((packet) => /could not remove legacy path:/.test(packet.raw || '')))
-  } finally {
-    fsSync.promises.rm = originalRm
-  }
-})