BinaryManager support for libraries and downloading from github release assets

server/Server.js

@@ -108,6 +108,8 @@ class Server {
 
     await this.playbackSessionManager.removeOrphanStreams()
 
+    await this.binaryManager.init()
+
     await Database.init(false)
 
     await Logger.logManager.init()
@@ -128,11 +130,6 @@ class Server {
     await this.cronManager.init(libraries)
     this.apiCacheManager.init()
 
-    // Download ffmpeg & ffprobe if not found (Currently only in use for Windows installs)
-    if (global.isWin || Logger.isDev) {
-      await this.binaryManager.init()
-    }
-
     if (Database.serverSettings.scannerDisableWatcher) {
       Logger.info(`[Server] Watcher is disabled`)
       this.watcher.disabled = true

server/libs/ffbinaries/index.js

@@ -1,315 +0,0 @@
-const os = require('os')
-const path = require('path')
-const axios = require('axios')
-const fse = require('../fsExtra')
-const async = require('../async')
-const StreamZip = require('../nodeStreamZip')
-const { finished } = require('stream/promises')
-
-var API_URL = 'https://ffbinaries.com/api/v1'
-
-var RUNTIME_CACHE = {}
-var errorMsgs = {
-  connectionIssues: 'Couldn\'t connect to ffbinaries.com API. Check your Internet connection.',
-  parsingVersionData: 'Couldn\'t parse retrieved version data.',
-  parsingVersionList: 'Couldn\'t parse the list of available versions.',
-  notFound: 'Requested data not found.',
-  incorrectVersionParam: '"version" parameter must be a string.'
-}
-
-function ensureDirSync(dir) {
-  try {
-    fse.accessSync(dir)
-  } catch (e) {
-    fse.mkdirSync(dir)
-  }
-}
-
-/**
- * Resolves the platform key based on input string
- */
-function resolvePlatform(input) {
-  var rtn = null
-
-  switch (input) {
-    case 'mac':
-    case 'osx':
-    case 'mac-64':
-    case 'osx-64':
-      rtn = 'osx-64'
-      break
-
-    case 'linux':
-    case 'linux-32':
-      rtn = 'linux-32'
-      break
-
-    case 'linux-64':
-      rtn = 'linux-64'
-      break
-
-    case 'linux-arm':
-    case 'linux-armel':
-      rtn = 'linux-armel'
-      break
-
-    case 'linux-armhf':
-      rtn = 'linux-armhf'
-      break
-
-    case 'win':
-    case 'win-32':
-    case 'windows':
-    case 'windows-32':
-      rtn = 'windows-32'
-      break
-
-    case 'win-64':
-    case 'windows-64':
-      rtn = 'windows-64'
-      break
-
-    default:
-      rtn = null
-  }
-
-  return rtn
-}
-/**
- * Detects the platform of the machine the script is executed on.
- * Object can be provided to detect platform from info derived elsewhere.
- *
- * @param {object} osinfo Contains "type" and "arch" properties
- */
-function detectPlatform(osinfo) {
-  var inputIsValid = typeof osinfo === 'object' && typeof osinfo.type === 'string' && typeof osinfo.arch === 'string'
-  var type = (inputIsValid ? osinfo.type : os.type()).toLowerCase()
-  var arch = (inputIsValid ? osinfo.arch : os.arch()).toLowerCase()
-
-  if (type === 'darwin') {
-    return 'osx-64'
-  }
-
-  if (type === 'windows_nt') {
-    return arch === 'x64' ? 'windows-64' : 'windows-32'
-  }
-
-  if (type === 'linux') {
-    if (arch === 'arm' || arch === 'arm64') {
-      return 'linux-armel'
-    }
-    return arch === 'x64' ? 'linux-64' : 'linux-32'
-  }
-
-  return null
-}
-/**
- * Gets the binary filename (appends exe in Windows)
- *
- * @param {string} component "ffmpeg", "ffplay", "ffprobe" or "ffserver"
- * @param {platform} platform "ffmpeg", "ffplay", "ffprobe" or "ffserver"
- */
-function getBinaryFilename(component, platform) {
-  var platformCode = resolvePlatform(platform)
-  if (platformCode === 'windows-32' || platformCode === 'windows-64') {
-    return component + '.exe'
-  }
-  return component
-}
-
-function listPlatforms() {
-  return ['osx-64', 'linux-32', 'linux-64', 'linux-armel', 'linux-armhf', 'windows-32', 'windows-64']
-}
-
-/**
- * 
- * @returns {Promise<string[]>} array of version strings
- */
-function listVersions() {
-  if (RUNTIME_CACHE.versionsAll) {
-    return RUNTIME_CACHE.versionsAll
-  }
-  return axios.get(API_URL).then((res) => {
-    if (!res.data?.versions || !Object.keys(res.data.versions)?.length) {
-      throw new Error(errorMsgs.parsingVersionList)
-    }
-    const versionKeys = Object.keys(res.data.versions)
-    RUNTIME_CACHE.versionsAll = versionKeys
-    return versionKeys
-  })
-}
-/**
- * Gets full data set from ffbinaries.com
- */
-function getVersionData(version) {
-  if (RUNTIME_CACHE[version]) {
-    return RUNTIME_CACHE[version]
-  }
-
-  if (version && typeof version !== 'string') {
-    throw new Error(errorMsgs.incorrectVersionParam)
-  }
-
-  var url = version ? '/version/' + version : '/latest'
-
-  return axios.get(`${API_URL}${url}`).then((res) => {
-    RUNTIME_CACHE[version] = res.data
-    return res.data
-  }).catch((error) => {
-    if (error.response?.status == 404) {
-      throw new Error(errorMsgs.notFound)
-    } else {
-      throw new Error(errorMsgs.connectionIssues)
-    }
-  })
-}
-
-/**
- * Download file(s) and save them in the specified directory
- */
-async function downloadUrls(components, urls, opts) {
-  const destinationDir = opts.destination
-  const results = []
-  const remappedUrls = []
-
-  if (components && !Array.isArray(components)) {
-    components = [components]
-  } else if (!components || !Array.isArray(components)) {
-    components = []
-  }
-
-  // returns an array of objects like this: {component: 'ffmpeg', url: 'https://...'}
-  if (typeof urls === 'object') {
-    for (const key in urls) {
-      if (components.includes(key) && urls[key]) {
-        remappedUrls.push({
-          component: key,
-          url: urls[key]
-        })
-      }
-    }
-  }
-
-
-  async function extractZipToDestination(zipFilename) {
-    const oldpath = path.join(destinationDir, zipFilename)
-    const zip = new StreamZip.async({ file: oldpath })
-    const count = await zip.extract(null, destinationDir)
-    await zip.close()
-  }
-
-
-  await async.each(remappedUrls, async function (urlObject) {
-    try {
-      const url = urlObject.url
-
-      const zipFilename = url.split('/').pop()
-      const binFilenameBase = urlObject.component
-      const binFilename = getBinaryFilename(binFilenameBase, opts.platform || detectPlatform())
-      
-      let runningTotal = 0
-      let totalFilesize
-      let interval
-
-      
-      if (typeof opts.tickerFn === 'function') {
-        opts.tickerInterval = parseInt(opts.tickerInterval, 10)
-        const tickerInterval = (!Number.isNaN(opts.tickerInterval)) ? opts.tickerInterval : 1000
-        const tickData = { filename: zipFilename, progress: 0 }
-
-        // Schedule next ticks
-        interval = setInterval(function () {
-          if (totalFilesize && runningTotal == totalFilesize) {
-            return clearInterval(interval)
-          }
-          tickData.progress = totalFilesize > -1 ? runningTotal / totalFilesize : 0
-
-          opts.tickerFn(tickData)
-        }, tickerInterval)
-      }
-      
-
-      // Check if file already exists in target directory
-      const binPath = path.join(destinationDir, binFilename)
-      if (!opts.force && await fse.pathExists(binPath)) {
-        // if the accessSync method doesn't throw we know the binary already exists
-        results.push({
-          filename: binFilename,
-          path: destinationDir,
-          status: 'File exists',
-          code: 'FILE_EXISTS'
-        })
-        clearInterval(interval)
-        return
-      }
-
-      if (opts.quiet) clearInterval(interval)
-
-      const zipPath = path.join(destinationDir, zipFilename)
-      const zipFileTempName = zipPath + '.part'
-      const zipFileFinalName = zipPath
-
-      const response = await axios({
-        url,
-        method: 'GET',
-        responseType: 'stream'
-      })
-      totalFilesize = response.headers?.['content-length'] || []
-
-      const writer = fse.createWriteStream(zipFileTempName)
-      response.data.on('data', (chunk) => {        
-        runningTotal += chunk.length
-      }) 
-      response.data.pipe(writer)
-      await finished(writer)
-      await fse.rename(zipFileTempName, zipFileFinalName)
-      await extractZipToDestination(zipFilename)
-      await fse.remove(zipFileFinalName)
-
-      results.push({
-        filename: binFilename,
-        path: destinationDir,
-        size: Math.floor(totalFilesize / 1024 / 1024 * 1000) / 1000 + 'MB',
-        status: 'File extracted to destination (downloaded from "' + url + '")',
-        code: 'DONE_CLEAN'
-      })
-    } catch (err) {
-      console.error(`Failed to download or extract file for component: ${urlObject.component}`, err)
-    }
-  })
-
-  return results
-}
-
-/**
- * Gets binaries for the platform
- * It will get the data from ffbinaries, pick the correct files
- * and save it to the specified directory
- *
- * @param {Array} components
- * @param {Object} [opts]
- */
-async function downloadBinaries(components, opts = {}) {
-  var platform = resolvePlatform(opts.platform) || detectPlatform()
-
-  opts.destination = path.resolve(opts.destination || '.')
-  ensureDirSync(opts.destination)
-
-  const versionData = await getVersionData(opts.version)
-  const urls = versionData?.bin?.[platform]
-  if (!urls) {
-    throw new Error('No URLs!')
-  }
-
-  return await downloadUrls(components, urls, opts)
-}
-
-module.exports = {
-  downloadBinaries: downloadBinaries,
-  getVersionData: getVersionData,
-  listVersions: listVersions,
-  listPlatforms: listPlatforms,
-  detectPlatform: detectPlatform,
-  resolvePlatform: resolvePlatform,
-  getBinaryFilename: getBinaryFilename
-}

server/managers/BinaryManager.js

@@ -2,25 +2,267 @@ const child_process = require('child_process')
 const { promisify } = require('util')
 const exec = promisify(child_process.exec)
 const path = require('path')
+const axios = require('axios')
 const which = require('../libs/which')
 const fs = require('../libs/fsExtra')
-const ffbinaries = require('../libs/ffbinaries')
 const Logger = require('../Logger')
 const fileUtils = require('../utils/fileUtils')
+const StreamZip = require('../libs/nodeStreamZip')
+
+class GithubAssetDownloader {
+  constructor(owner, repo) {
+    this.owner = owner
+    this.repo = repo
+    this.assetCache = {}
+  }
+
+  async getAssetUrl(releaseTag, assetName) {
+    // Check if the assets information is already cached for the release tag
+    if (this.assetCache[releaseTag]) {
+      Logger.debug(`[GithubAssetDownloader] Repo ${this.repo} release ${releaseTag}: assets found in cache.`)
+    } else {
+      // Get the release information
+      const releaseUrl = `https://api.github.com/repos/${this.owner}/${this.repo}/releases/tags/${releaseTag}`
+      const releaseResponse = await axios.get(releaseUrl, {
+        headers: {
+          Accept: 'application/vnd.github.v3+json',
+          'User-Agent': 'axios'
+        }
+      })
+
+      // Cache the assets information for the release tag
+      this.assetCache[releaseTag] = releaseResponse.data.assets
+      Logger.debug(`[GithubAssetDownloader] Repo ${this.repo} release ${releaseTag}: assets fetched from API.`)
+    }
+
+    // Find the asset URL
+    const assets = this.assetCache[releaseTag]
+    const asset = assets.find((asset) => asset.name === assetName)
+    if (!asset) {
+      throw new Error(`[GithubAssetDownloader] Repo ${this.repo} release ${releaseTag}: asset ${assetName} not found`)
+    }
+
+    return asset.browser_download_url
+  }
+
+  async downloadAsset(assetUrl, destDir) {
+    const zipPath = path.join(destDir, 'temp.zip')
+    const writer = fs.createWriteStream(zipPath)
+
+    const assetResponse = await axios({
+      url: assetUrl,
+      method: 'GET',
+      responseType: 'stream'
+    })
+
+    assetResponse.data.pipe(writer)
+
+    await new Promise((resolve, reject) => {
+      writer.on('finish', () => {
+        Logger.debug(`[GithubAssetDownloader] Downloaded asset ${assetUrl} to ${zipPath}`)
+        resolve()
+      })
+      writer.on('error', (err) => {
+        Logger.error(`[GithubAssetDownloader] Error downloading asset ${assetUrl}: ${err.message}`)
+        reject(err)
+      })
+    })
+
+    return zipPath
+  }
+
+  async extractFiles(zipPath, filesToExtract, destDir) {
+    const zip = new StreamZip.async({ file: zipPath })
+
+    for (const file of filesToExtract) {
+      const outputPath = path.join(destDir, file.outputFileName)
+      await zip.extract(file.pathInsideZip, outputPath)
+      Logger.debug(`[GithubAssetDownloader] Extracted file ${file.pathInsideZip} to ${outputPath}`)
+    }
+
+    await zip.close()
+  }
+
+  async downloadAndExtractFiles(releaseTag, assetName, filesToExtract, destDir) {
+    let zipPath
+    try {
+      await fs.ensureDir(destDir)
+      const assetUrl = await this.getAssetUrl(releaseTag, assetName)
+      zipPath = await this.downloadAsset(assetUrl, destDir)
+      await this.extractFiles(zipPath, filesToExtract, destDir)
+    } catch (error) {
+      Logger.error(`[GithubAssetDownloader] Error downloading or extracting files: ${error.message}`)
+      throw error
+    } finally {
+      if (zipPath) await fs.remove(zipPath)
+    }
+  }
+}
+
+class FFBinariesDownloader extends GithubAssetDownloader {
+  constructor() {
+    super('ffbinaries', 'ffbinaries-prebuilt')
+  }
+
+  getPlatformSuffix() {
+    const platform = process.platform
+    const arch = process.arch
+
+    switch (platform) {
+      case 'win32':
+        return 'win-64'
+      case 'darwin':
+        return 'macos-64'
+      case 'linux':
+        switch (arch) {
+          case 'x64':
+            return 'linux-64'
+          case 'x32':
+          case 'ia32':
+            return 'linux-32'
+          case 'arm64':
+            return 'linux-arm-64'
+          case 'arm':
+            return 'linux-armhf-32'
+          default:
+            throw new Error(`Unsupported architecture: ${arch}`)
+        }
+      default:
+        throw new Error(`Unsupported platform: ${platform}`)
+    }
+  }
+
+  async downloadBinary(binaryName, releaseTag, destDir) {
+    const platformSuffix = this.getPlatformSuffix()
+    const assetName = `${binaryName}-${releaseTag}-${platformSuffix}.zip`
+    const fileName = process.platform === 'win32' ? `${binaryName}.exe` : binaryName
+    const filesToExtract = [{ pathInsideZip: fileName, outputFileName: fileName }]
+    releaseTag = `v${releaseTag}`
+
+    await this.downloadAndExtractFiles(releaseTag, assetName, filesToExtract, destDir)
+  }
+}
+
+class SQLeanDownloader extends GithubAssetDownloader {
+  constructor() {
+    super('nalgeon', 'sqlean')
+  }
+
+  getPlatformSuffix() {
+    const platform = process.platform
+    const arch = process.arch
+
+    switch (platform) {
+      case 'win32':
+        return arch === 'x64' ? 'win-x64' : 'win-x86'
+      case 'darwin':
+        return arch === 'arm64' ? 'macos-arm64' : 'macos-x86'
+      case 'linux':
+        return arch === 'arm64' ? 'linux-arm64' : 'linux-x86'
+      default:
+        throw new Error(`Unsupported platform or architecture: ${platform}, ${arch}`)
+    }
+  }
+
+  getLibraryName(binaryName) {
+    const platform = process.platform
+
+    switch (platform) {
+      case 'win32':
+        return `${binaryName}.dll`
+      case 'darwin':
+        return `${binaryName}.dylib`
+      case 'linux':
+        return `${binaryName}.so`
+      default:
+        throw new Error(`Unsupported platform: ${platform}`)
+    }
+  }
+
+  async downloadBinary(binaryName, releaseTag, destDir) {
+    const platformSuffix = this.getPlatformSuffix()
+    const assetName = `sqlean-${platformSuffix}.zip`
+    const fileName = this.getLibraryName(binaryName)
+    const filesToExtract = [{ pathInsideZip: fileName, outputFileName: fileName }]
+
+    await this.downloadAndExtractFiles(releaseTag, assetName, filesToExtract, destDir)
+  }
+}
+
+class Binary {
+  constructor(name, type, envVariable, validVersions, source) {
+    this.name = name
+    this.type = type
+    this.envVariable = envVariable
+    this.validVersions = validVersions
+    this.source = source
+    this.fileName = this.getFileName()
+    this.exec = exec
+  }
+
+  async find(mainInstallDir, altInstallDir) {
+    // 1. check path specified in environment variable
+    const defaultPath = process.env[this.envVariable]
+    if (await this.isGood(defaultPath)) return defaultPath
+    // 2. find the first instance of the binary in the PATH environment variable
+    if (this.type === 'executable') {
+      const whichPath = which.sync(this.fileName, { nothrow: true })
+      if (await this.isGood(whichPath)) return whichPath
+    }
+    // 3. check main install path (binary root dir)
+    const mainInstallPath = path.join(mainInstallDir, this.fileName)
+    if (await this.isGood(mainInstallPath)) return mainInstallPath
+    // 4. check alt install path (/config)
+    const altInstallPath = path.join(altInstallDir, this.fileName)
+    if (await this.isGood(altInstallPath)) return altInstallPath
+    return null
+  }
+
+  getFileName() {
+    if (this.type === 'executable') {
+      return this.name + (process.platform == 'win32' ? '.exe' : '')
+    } else if (this.type === 'library') {
+      return this.name + (process.platform == 'win32' ? '.dll' : '.so')
+    } else {
+      return this.name
+    }
+  }
+
+  async isGood(binaryPath) {
+    if (!binaryPath || !(await fs.pathExists(binaryPath))) return false
+    if (!this.validVersions.length) return true
+    if (this.type === 'library') return true
+    try {
+      const { stdout } = await this.exec('"' + binaryPath + '"' + ' -version')
+      const version = stdout.match(/version\s([\d\.]+)/)?.[1]
+      if (!version) return false
+      return this.validVersions.some((validVersion) => version.startsWith(validVersion))
+    } catch (err) {
+      Logger.error(`[Binary] Failed to check version of ${binaryPath}`)
+      return false
+    }
+  }
+
+  async download(destination) {
+    await this.source.downloadBinary(this.name, this.validVersions[0], destination)
+  }
+}
+
+const ffbinaries = new FFBinariesDownloader()
+const sqlean = new SQLeanDownloader()
 
 class BinaryManager {
-
   defaultRequiredBinaries = [
-    { name: 'ffmpeg', envVariable: 'FFMPEG_PATH', validVersions: ['5.1'] },
+    new Binary('ffmpeg', 'executable', 'FFMPEG_PATH', ['5.1'], ffbinaries), // ffmpeg executable
-    { name: 'ffprobe', envVariable: 'FFPROBE_PATH', validVersions: ['5.1'] }
+    new Binary('ffprobe', 'executable', 'FFPROBE_PATH', ['5.1'], ffbinaries), // ffprobe executable
+    new Binary('unicode', 'library', 'SQLEAN_UNICODE_PATH', ['0.24.2'], sqlean) // sqlean unicode extension
   ]
 
   constructor(requiredBinaries = this.defaultRequiredBinaries) {
     this.requiredBinaries = requiredBinaries
-    this.mainInstallPath = process.pkg ? path.dirname(process.execPath) : global.appRoot
+    this.mainInstallDir = process.pkg ? path.dirname(process.execPath) : global.appRoot
-    this.altInstallPath = global.ConfigPath
+    this.altInstallDir = global.ConfigPath
     this.initialized = false
-    this.exec = exec
   }
 
   async init() {
@@ -44,24 +286,18 @@ class BinaryManager {
     this.initialized = true
   }
 
-  /**
+  async removeBinary(destination, binary) {
-   * Remove old/invalid binaries in main or alt install path
+    const binaryPath = path.join(destination, binary.fileName)
-   * 
+    if (await fs.pathExists(binaryPath)) {
-   * @param {string[]} binaryNames 
+      Logger.debug(`[BinaryManager] Removing binary: ${binaryPath}`)
-   */
+      await fs.remove(binaryPath)
-  async removeOldBinaries(binaryNames) {
-    for (const binaryName of binaryNames) {
-      const executable = this.getExecutableFileName(binaryName)
-      const mainInstallPath = path.join(this.mainInstallPath, executable)
-      if (await fs.pathExists(mainInstallPath)) {
-        Logger.debug(`[BinaryManager] Removing old binary: ${mainInstallPath}`)
-        await fs.remove(mainInstallPath)
     }
-      const altInstallPath = path.join(this.altInstallPath, executable)
-      if (await fs.pathExists(altInstallPath)) {
-        Logger.debug(`[BinaryManager] Removing old binary: ${altInstallPath}`)
-        await fs.remove(altInstallPath)
   }
+
+  async removeOldBinaries(binaries) {
+    for (const binary of binaries) {
+      await this.removeBinary(this.mainInstallDir, binary)
+      await this.removeBinary(this.altInstallDir, binary)
     }
   }
 
@@ -73,7 +309,7 @@ class BinaryManager {
   async findRequiredBinaries() {
     const missingBinaries = []
     for (const binary of this.requiredBinaries) {
-      const binaryPath = await this.findBinary(binary.name, binary.envVariable, binary.validVersions)
+      const binaryPath = await binary.find(this.mainInstallDir, this.altInstallDir)
       if (binaryPath) {
         Logger.info(`[BinaryManager] Found valid binary ${binary.name} at ${binaryPath}`)
         if (process.env[binary.envVariable] !== binaryPath) {
@@ -82,79 +318,22 @@ class BinaryManager {
         }
       } else {
         Logger.info(`[BinaryManager] ${binary.name} not found or version too old`)
-        missingBinaries.push(binary.name)
+        missingBinaries.push(binary)
       }
     }
     return missingBinaries
   }
 
-  /**
-   * Find absolute path for binary
-   * 
-   * @param {string} name 
-   * @param {string} envVariable 
-   * @param {string[]} [validVersions]
-   * @returns {Promise<string>} Path to binary
-   */
-  async findBinary(name, envVariable, validVersions = []) {
-    const executable = this.getExecutableFileName(name)
-    // 1. check path specified in environment variable
-    const defaultPath = process.env[envVariable]
-    if (await this.isBinaryGood(defaultPath, validVersions)) return defaultPath
-    // 2. find the first instance of the binary in the PATH environment variable
-    const whichPath = which.sync(executable, { nothrow: true })
-    if (await this.isBinaryGood(whichPath, validVersions)) return whichPath
-    // 3. check main install path (binary root dir)
-    const mainInstallPath = path.join(this.mainInstallPath, executable)
-    if (await this.isBinaryGood(mainInstallPath, validVersions)) return mainInstallPath
-    // 4. check alt install path (/config)
-    const altInstallPath = path.join(this.altInstallPath, executable)
-    if (await this.isBinaryGood(altInstallPath, validVersions)) return altInstallPath
-    return null
-  }
-
-  /**
-   * Check binary path exists and optionally check version is valid
-   * 
-   * @param {string} binaryPath 
-   * @param {string[]} [validVersions]
-   * @returns {Promise<boolean>}
-   */
-  async isBinaryGood(binaryPath, validVersions = []) {
-    if (!binaryPath || !await fs.pathExists(binaryPath)) return false
-    if (!validVersions.length) return true
-    try {
-      const { stdout } = await this.exec('"' + binaryPath + '"' + ' -version')
-      const version = stdout.match(/version\s([\d\.]+)/)?.[1]
-      if (!version) return false
-      return validVersions.some(validVersion => version.startsWith(validVersion))
-    } catch (err) {
-      Logger.error(`[BinaryManager] Failed to check version of ${binaryPath}`)
-      return false
-    }
-  }
-
-  /**
-   * 
-   * @param {string[]} binaries 
-   */
   async install(binaries) {
     if (!binaries.length) return
-    Logger.info(`[BinaryManager] Installing binaries: ${binaries.join(', ')}`)
+    Logger.info(`[BinaryManager] Installing binaries: ${binaries.map((binary) => binary.name).join(', ')}`)
-    let destination = await fileUtils.isWritable(this.mainInstallPath) ? this.mainInstallPath : this.altInstallPath
+    let destination = (await fileUtils.isWritable(this.mainInstallDir)) ? this.mainInstallDir : this.altInstallDir
-    await ffbinaries.downloadBinaries(binaries, { destination, version: '5.1', force: true })
+    for (const binary of binaries) {
-    Logger.info(`[BinaryManager] Binaries installed to ${destination}`)
+      await binary.download(destination)
     }
-
+    Logger.info(`[BinaryManager] Binaries installed to ${destination}`)
-  /**
-   * Append .exe to binary name for Windows
-   * 
-   * @param {string} name 
-   * @returns {string}
-   */
-  getExecutableFileName(name) {
-    return name + (process.platform == 'win32' ? '.exe' : '')
   }
 }
 
 module.exports = BinaryManager
+module.exports.Binary = Binary // for testing

test/server/managers/BinaryManager.test.js

@@ -6,6 +6,7 @@ const which = require('../../../server/libs/which')
 const ffbinaries = require('../../../server/libs/ffbinaries')
 const path = require('path')
 const BinaryManager = require('../../../server/managers/BinaryManager')
+const { Binary } = require('../../../server/managers/BinaryManager')
 
 const expect = chai.expect
 
@@ -49,10 +50,14 @@ describe('BinaryManager', () => {
     })
 
     it('should install missing binaries', async () => {
-      const missingBinaries = ['ffmpeg', 'ffprobe']
+      const ffmpegBinary = new Binary('ffmpeg', 'executable', 'FFMPEG_PATH', ['5.1'], ffbinaries)
+      const ffprobeBinary = new Binary('ffprobe', 'executable', 'FFPROBE_PATH', ['5.1'], ffbinaries)
+      const requiredBinaries = [ffmpegBinary, ffprobeBinary]
+      const missingBinaries = [ffprobeBinary]
       const missingBinariesAfterInstall = []
       findStub.onFirstCall().resolves(missingBinaries)
       findStub.onSecondCall().resolves(missingBinariesAfterInstall)
+      binaryManager.requiredBinaries = requiredBinaries
 
       await binaryManager.init()
 
@@ -64,8 +69,11 @@ describe('BinaryManager', () => {
     })
 
     it('exit if binaries are not found after installation', async () => {
-      const missingBinaries = ['ffmpeg', 'ffprobe']
+      const ffmpegBinary = new Binary('ffmpeg', 'executable', 'FFMPEG_PATH', ['5.1'], ffbinaries)
-      const missingBinariesAfterInstall = ['ffmpeg', 'ffprobe']
+      const ffprobeBinary = new Binary('ffprobe', 'executable', 'FFPROBE_PATH', ['5.1'], ffbinaries)
+      const requiredBinaries = [ffmpegBinary, ffprobeBinary]
+      const missingBinaries = [ffprobeBinary]
+      const missingBinariesAfterInstall = [ffprobeBinary]
       findStub.onFirstCall().resolves(missingBinaries)
       findStub.onSecondCall().resolves(missingBinariesAfterInstall)
 
@@ -80,14 +88,15 @@ describe('BinaryManager', () => {
     })
   })
 
-  
   describe('findRequiredBinaries', () => {
     let findBinaryStub
+    let ffmpegBinary
 
     beforeEach(() => {
-      const requiredBinaries = [{ name: 'ffmpeg', envVariable: 'FFMPEG_PATH' }]
+      ffmpegBinary = new Binary('ffmpeg', 'executable', 'FFMPEG_PATH', ['5.1'], ffbinaries)
+      const requiredBinaries = [ffmpegBinary]
       binaryManager = new BinaryManager(requiredBinaries)
-      findBinaryStub = sinon.stub(binaryManager, 'findBinary')
+      findBinaryStub = sinon.stub(ffmpegBinary, 'find')
     })
 
     afterEach(() => {
@@ -108,7 +117,7 @@ describe('BinaryManager', () => {
     })
 
     it('should add missing binaries to result', async () => {
-      const missingBinaries = ['ffmpeg']
+      const missingBinaries = [ffmpegBinary]
       delete process.env.FFMPEG_PATH
       findBinaryStub.resolves(null)
 
@@ -122,19 +131,22 @@ describe('BinaryManager', () => {
 
   describe('install', () => {
     let isWritableStub
-    let downloadBinariesStub
+    let downloadBinaryStub
+    let ffmpegBinary
 
     beforeEach(() => {
-      binaryManager = new BinaryManager()
+      ffmpegBinary = new Binary('ffmpeg', 'executable', 'FFMPEG_PATH', ['5.1'], ffbinaries)
+      const requiredBinaries = [ffmpegBinary]
+      binaryManager = new BinaryManager(requiredBinaries)
       isWritableStub = sinon.stub(fileUtils, 'isWritable')
-      downloadBinariesStub = sinon.stub(ffbinaries, 'downloadBinaries')
+      downloadBinaryStub = sinon.stub(ffmpegBinary, 'download')
-      binaryManager.mainInstallPath = '/path/to/main/install'
+      binaryManager.mainInstallDir = '/path/to/main/install'
-      binaryManager.altInstallPath = '/path/to/alt/install'
+      binaryManager.altInstallDir = '/path/to/alt/install'
     })
 
     afterEach(() => {
       isWritableStub.restore()
-      downloadBinariesStub.restore()
+      downloadBinaryStub.restore()
     })
 
     it('should not install binaries if no binaries are passed', async () => {
@@ -143,41 +155,42 @@ describe('BinaryManager', () => {
       await binaryManager.install(binaries)
 
       expect(isWritableStub.called).to.be.false
-      expect(downloadBinariesStub.called).to.be.false
+      expect(downloadBinaryStub.called).to.be.false
     })
 
     it('should install binaries in main install path if has access', async () => {
-      const binaries = ['ffmpeg']
+      const binaries = [ffmpegBinary]
-      const destination = binaryManager.mainInstallPath
+      const destination = binaryManager.mainInstallDir
       isWritableStub.withArgs(destination).resolves(true)
-      downloadBinariesStub.resolves()
+      downloadBinaryStub.resolves()
 
       await binaryManager.install(binaries)
 
       expect(isWritableStub.calledOnce).to.be.true
-      expect(downloadBinariesStub.calledOnce).to.be.true
+      expect(downloadBinaryStub.calledOnce).to.be.true
-      expect(downloadBinariesStub.calledWith(binaries, sinon.match({ destination: destination }))).to.be.true  
+      expect(downloadBinaryStub.calledWith(destination)).to.be.true
     })
 
     it('should install binaries in alt install path if has no access to main', async () => {
-      const binaries = ['ffmpeg']
+      const binaries = [ffmpegBinary]
-      const mainDestination = binaryManager.mainInstallPath
+      const mainDestination = binaryManager.mainInstallDir
-      const destination = binaryManager.altInstallPath
+      const destination = binaryManager.altInstallDir
       isWritableStub.withArgs(mainDestination).resolves(false)
-      downloadBinariesStub.resolves()
+      downloadBinaryStub.resolves()
 
       await binaryManager.install(binaries)
 
       expect(isWritableStub.calledOnce).to.be.true
-      expect(downloadBinariesStub.calledOnce).to.be.true
+      expect(downloadBinaryStub.calledOnce).to.be.true
-      expect(downloadBinariesStub.calledWith(binaries, sinon.match({ destination: destination }))).to.be.true  
+      expect(downloadBinaryStub.calledWith(destination)).to.be.true
     })
   })
 })
 
-describe('findBinary', () => {
+describe('Binary', () => {
-  let binaryManager
+  describe('find', () => {
-  let isBinaryGoodStub
+    let binary
+    let isGoodStub
     let whichSyncStub
     let mainInstallPath
     let altInstallPath
@@ -188,115 +201,112 @@ describe('findBinary', () => {
     const executable = name + (process.platform == 'win32' ? '.exe' : '')
     const whichPath = '/usr/bin/ffmpeg'
 
-
     beforeEach(() => {
-    binaryManager = new BinaryManager()
+      binary = new Binary(name, 'executable', envVariable, ['5.1'], ffbinaries)
-    isBinaryGoodStub = sinon.stub(binaryManager, 'isBinaryGood')
+      isGoodStub = sinon.stub(binary, 'isGood')
       whichSyncStub = sinon.stub(which, 'sync')
-    binaryManager.mainInstallPath = '/path/to/main/install'
+      binary.mainInstallDir = '/path/to/main/install'
-    mainInstallPath = path.join(binaryManager.mainInstallPath, executable)
+      mainInstallPath = path.join(binary.mainInstallDir, executable)
-    binaryManager.altInstallPath = '/path/to/alt/install'
+      binary.altInstallDir = '/path/to/alt/install'
-    altInstallPath = path.join(binaryManager.altInstallPath, executable)
+      altInstallPath = path.join(binary.altInstallDir, executable)
     })
 
     afterEach(() => {
-    isBinaryGoodStub.restore()
+      isGoodStub.restore()
       whichSyncStub.restore()
     })
 
     it('should return the defaultPath if it exists and is a good binary', async () => {
       process.env[envVariable] = defaultPath
-    isBinaryGoodStub.withArgs(defaultPath).resolves(true)
+      isGoodStub.withArgs(defaultPath).resolves(true)
 
-    const result = await binaryManager.findBinary(name, envVariable)
+      const result = await binary.find(binary.mainInstallDir, binary.altInstallDir)
 
       expect(result).to.equal(defaultPath)
-    expect(isBinaryGoodStub.calledOnce).to.be.true
+      expect(isGoodStub.calledOnce).to.be.true
-    expect(isBinaryGoodStub.calledWith(defaultPath)).to.be.true
+      expect(isGoodStub.calledWith(defaultPath)).to.be.true
     })
 
     it('should return the whichPath if it exists and is a good binary', async () => {
       delete process.env[envVariable]
-    isBinaryGoodStub.withArgs(undefined).resolves(false)
+      isGoodStub.withArgs(undefined).resolves(false)
-    isBinaryGoodStub.withArgs(whichPath).resolves(true)
       whichSyncStub.returns(whichPath)
+      isGoodStub.withArgs(whichPath).resolves(true)
 
-    const result = await binaryManager.findBinary(name, envVariable)
+      const result = await binary.find(binary.mainInstallDir, binary.altInstallDir)
 
       expect(result).to.equal(whichPath)
-    expect(isBinaryGoodStub.calledTwice).to.be.true
+      expect(isGoodStub.calledTwice).to.be.true
-    expect(isBinaryGoodStub.calledWith(undefined)).to.be.true
+      expect(isGoodStub.calledWith(undefined)).to.be.true
-    expect(isBinaryGoodStub.calledWith(whichPath)).to.be.true
+      expect(isGoodStub.calledWith(whichPath)).to.be.true
     })
 
     it('should return the mainInstallPath if it exists and is a good binary', async () => {
       delete process.env[envVariable]
-    isBinaryGoodStub.withArgs(undefined).resolves(false)
+      isGoodStub.withArgs(undefined).resolves(false)
-    isBinaryGoodStub.withArgs(null).resolves(false)
-    isBinaryGoodStub.withArgs(mainInstallPath).resolves(true)
       whichSyncStub.returns(null)
+      isGoodStub.withArgs(null).resolves(false)
+      isGoodStub.withArgs(mainInstallPath).resolves(true)
 
-    const result = await binaryManager.findBinary(name, envVariable)
+      const result = await binary.find(binary.mainInstallDir, binary.altInstallDir)
 
       expect(result).to.equal(mainInstallPath)
-    expect(isBinaryGoodStub.callCount).to.be.equal(3)
+      expect(isGoodStub.callCount).to.be.equal(3)
-    expect(isBinaryGoodStub.calledWith(undefined)).to.be.true
+      expect(isGoodStub.calledWith(undefined)).to.be.true
-    expect(isBinaryGoodStub.calledWith(null)).to.be.true
+      expect(isGoodStub.calledWith(null)).to.be.true
-    expect(isBinaryGoodStub.calledWith(mainInstallPath)).to.be.true
+      expect(isGoodStub.calledWith(mainInstallPath)).to.be.true
     })
 
     it('should return the altInstallPath if it exists and is a good binary', async () => {
       delete process.env[envVariable]
-    isBinaryGoodStub.withArgs(undefined).resolves(false)
+      isGoodStub.withArgs(undefined).resolves(false)
-    isBinaryGoodStub.withArgs(null).resolves(false)
-    isBinaryGoodStub.withArgs(mainInstallPath).resolves(false)
-    isBinaryGoodStub.withArgs(altInstallPath).resolves(true)
       whichSyncStub.returns(null)
+      isGoodStub.withArgs(null).resolves(false)
+      isGoodStub.withArgs(mainInstallPath).resolves(false)
+      isGoodStub.withArgs(altInstallPath).resolves(true)
 
-    const result = await binaryManager.findBinary(name, envVariable)
+      const result = await binary.find(binary.mainInstallDir, binary.altInstallDir)
 
       expect(result).to.equal(altInstallPath)
-    expect(isBinaryGoodStub.callCount).to.be.equal(4)
+      expect(isGoodStub.callCount).to.be.equal(4)
-    expect(isBinaryGoodStub.calledWith(undefined)).to.be.true
+      expect(isGoodStub.calledWith(undefined)).to.be.true
-    expect(isBinaryGoodStub.calledWith(null)).to.be.true
+      expect(isGoodStub.calledWith(null)).to.be.true
-    expect(isBinaryGoodStub.calledWith(mainInstallPath)).to.be.true
+      expect(isGoodStub.calledWith(mainInstallPath)).to.be.true
-    expect(isBinaryGoodStub.calledWith(altInstallPath)).to.be.true
+      expect(isGoodStub.calledWith(altInstallPath)).to.be.true
     })
 
     it('should return null if no good binary is found', async () => {
       delete process.env[envVariable]
-    isBinaryGoodStub.withArgs(undefined).resolves(false)
+      isGoodStub.withArgs(undefined).resolves(false)
-    isBinaryGoodStub.withArgs(null).resolves(false)
-    isBinaryGoodStub.withArgs(mainInstallPath).resolves(false)
-    isBinaryGoodStub.withArgs(altInstallPath).resolves(false)
       whichSyncStub.returns(null)
+      isGoodStub.withArgs(null).resolves(false)
+      isGoodStub.withArgs(mainInstallPath).resolves(false)
+      isGoodStub.withArgs(altInstallPath).resolves(false)
 
-    const result = await binaryManager.findBinary(name, envVariable)
+      const result = await binary.find(binary.mainInstallDir, binary.altInstallDir)
 
       expect(result).to.be.null
-    expect(isBinaryGoodStub.callCount).to.be.equal(4)
+      expect(isGoodStub.callCount).to.be.equal(4)
-    expect(isBinaryGoodStub.calledWith(undefined)).to.be.true
+      expect(isGoodStub.calledWith(undefined)).to.be.true
-    expect(isBinaryGoodStub.calledWith(null)).to.be.true
+      expect(isGoodStub.calledWith(null)).to.be.true
-    expect(isBinaryGoodStub.calledWith(mainInstallPath)).to.be.true
+      expect(isGoodStub.calledWith(mainInstallPath)).to.be.true
-    expect(isBinaryGoodStub.calledWith(altInstallPath)).to.be.true
+      expect(isGoodStub.calledWith(altInstallPath)).to.be.true
+    })
   })
-})
 
-describe('isBinaryGood', () => {
+  describe('isGood', () => {
-  let binaryManager
+    let binary
     let fsPathExistsStub
     let execStub
-  let loggerInfoStub
-  let loggerErrorStub
 
     const binaryPath = '/path/to/binary'
     const execCommand = '"' + binaryPath + '"' + ' -version'
     const goodVersions = ['5.1', '6']
 
     beforeEach(() => {
-    binaryManager = new BinaryManager()
+      binary = new Binary('ffmpeg', 'executable', 'FFMPEG_PATH', goodVersions, ffbinaries)
       fsPathExistsStub = sinon.stub(fs, 'pathExists')
-    execStub = sinon.stub(binaryManager, 'exec')
+      execStub = sinon.stub(binary, 'exec')
     })
 
     afterEach(() => {
@@ -307,7 +317,7 @@ describe('isBinaryGood', () => {
     it('should return false if binaryPath is falsy', async () => {
       fsPathExistsStub.resolves(true)
 
-    const result = await binaryManager.isBinaryGood(null, goodVersions)
+      const result = await binary.isGood(null)
 
       expect(result).to.be.false
       expect(fsPathExistsStub.called).to.be.false
@@ -317,7 +327,7 @@ describe('isBinaryGood', () => {
     it('should return false if binaryPath does not exist', async () => {
       fsPathExistsStub.resolves(false)
 
-    const result = await binaryManager.isBinaryGood(binaryPath, goodVersions)
+      const result = await binary.isGood(binaryPath)
 
       expect(result).to.be.false
       expect(fsPathExistsStub.calledOnce).to.be.true
@@ -329,7 +339,7 @@ describe('isBinaryGood', () => {
       fsPathExistsStub.resolves(true)
       execStub.rejects(new Error('Failed to execute command'))
 
-    const result = await binaryManager.isBinaryGood(binaryPath, goodVersions)
+      const result = await binary.isGood(binaryPath)
 
       expect(result).to.be.false
       expect(fsPathExistsStub.calledOnce).to.be.true
@@ -343,7 +353,7 @@ describe('isBinaryGood', () => {
       fsPathExistsStub.resolves(true)
       execStub.resolves({ stdout })
 
-    const result = await binaryManager.isBinaryGood(binaryPath, goodVersions)
+      const result = await binary.isGood(binaryPath)
 
       expect(result).to.be.false
       expect(fsPathExistsStub.calledOnce).to.be.true
@@ -357,7 +367,7 @@ describe('isBinaryGood', () => {
       fsPathExistsStub.resolves(true)
       execStub.resolves({ stdout })
 
-    const result = await binaryManager.isBinaryGood(binaryPath, goodVersions)
+      const result = await binary.isGood(binaryPath)
 
       expect(result).to.be.false
       expect(fsPathExistsStub.calledOnce).to.be.true
@@ -371,7 +381,7 @@ describe('isBinaryGood', () => {
       fsPathExistsStub.resolves(true)
       execStub.resolves({ stdout })
 
-    const result = await binaryManager.isBinaryGood(binaryPath, goodVersions)
+      const result = await binary.isGood(binaryPath)
 
       expect(result).to.be.true
       expect(fsPathExistsStub.calledOnce).to.be.true
@@ -379,4 +389,68 @@ describe('isBinaryGood', () => {
       expect(execStub.calledOnce).to.be.true
       expect(execStub.calledWith(execCommand)).to.be.true
     })
+  })
+
+  describe('getFileName', () => {
+    let originalPlatform
+
+    const mockPlatform = (platform) => {
+      Object.defineProperty(process, 'platform', { value: platform })
+    }
+
+    beforeEach(() => {
+      // Save the original process.platform descriptor
+      originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform')
+    })
+
+    afterEach(() => {
+      // Restore the original process.platform descriptor
+      Object.defineProperty(process, 'platform', originalPlatform)
+    })
+
+    it('should return the executable file name with .exe extension on Windows', () => {
+      const binary = new Binary('ffmpeg', 'executable', 'FFMPEG_PATH', ['5.1'], ffbinaries)
+      mockPlatform('win32')
+
+      const result = binary.getFileName()
+
+      expect(result).to.equal('ffmpeg.exe')
+    })
+
+    it('should return the executable file name without extension on linux', () => {
+      const binary = new Binary('ffmpeg', 'executable', 'FFMPEG_PATH', ['5.1'], ffbinaries)
+      mockPlatform('linux')
+
+      const result = binary.getFileName()
+
+      expect(result).to.equal('ffmpeg')
+    })
+
+    it('should return the library file name with .dll extension on Windows', () => {
+      const binary = new Binary('ffmpeg', 'library', 'FFMPEG_PATH', ['5.1'], ffbinaries)
+      mockPlatform('win32')
+
+      const result = binary.getFileName()
+
+      expect(result).to.equal('ffmpeg.dll')
+    })
+
+    it('should return the library file name with .so extension on linux', () => {
+      const binary = new Binary('ffmpeg', 'library', 'FFMPEG_PATH', ['5.1'], ffbinaries)
+      mockPlatform('linux')
+
+      const result = binary.getFileName()
+
+      expect(result).to.equal('ffmpeg.so')
+    })
+
+    it('should return the file name without extension for other types', () => {
+      const binary = new Binary('ffmpeg', 'other', 'FFMPEG_PATH', ['5.1'], ffbinaries)
+      mockPlatform('win32')
+
+      const result = binary.getFileName()
+
+      expect(result).to.equal('ffmpeg')
+    })
+  })
 })