Add BinaryManager

This commit is contained in:
mikiher 2023-12-05 21:19:17 +02:00
parent b1b325d00b
commit 2e989fbe83
4 changed files with 346 additions and 0 deletions

2
.gitignore vendored
View File

@ -13,6 +13,8 @@
/deploy/
/coverage/
/.nyc_output/
/ffmpeg*
/ffprobe*
sw.*
.DS_STORE

View File

@ -33,6 +33,7 @@ const AudioMetadataMangaer = require('./managers/AudioMetadataManager')
const RssFeedManager = require('./managers/RssFeedManager')
const CronManager = require('./managers/CronManager')
const ApiCacheManager = require('./managers/ApiCacheManager')
const BinaryManager = require('./managers/BinaryManager')
const LibraryScanner = require('./scanner/LibraryScanner')
//Import the main Passport and Express-Session library
@ -74,6 +75,7 @@ class Server {
this.rssFeedManager = new RssFeedManager()
this.cronManager = new CronManager(this.podcastManager)
this.apiCacheManager = new ApiCacheManager()
this.binaryManager = new BinaryManager()
// Routers
this.apiRouter = new ApiRouter(this)
@ -119,6 +121,7 @@ class Server {
const libraries = await Database.libraryModel.getAllOldLibraries()
await this.cronManager.init(libraries)
this.apiCacheManager.init()
await this.binaryManager.init()
if (Database.serverSettings.scannerDisableWatcher) {
Logger.info(`[Server] Watcher is disabled`)

View File

@ -0,0 +1,79 @@
const path = require('path')
const which = require('../libs/which')
const fs = require('../libs/fsExtra')
const Logger = require('../Logger')
const ffbinaries = require('ffbinaries')
const { promisify } = require('util')
class BinaryManager {
downloadBinaries = promisify(ffbinaries.downloadBinaries)
defaultRequiredBinaries = [
{ name: 'ffmpeg', envVariable: 'FFMPEG_PATH' },
{ name: 'ffprobe', envVariable: 'FFPROBE_PATH' }
]
constructor(requiredBinaries = this.defaultRequiredBinaries) {
this.requiredBinaries = requiredBinaries
this.mainInstallPath = process.pkg ? path.dirname(process.execPath) : global.appRoot
this.altInstallPath = global.ConfigPath
}
async init() {
if (this.initialized) return
const missingBinaries = await this.findRequiredBinaries()
if (missingBinaries.length == 0) return
await this.install(missingBinaries)
const missingBinariesAfterInstall = await this.findRequiredBinaries()
if (missingBinariesAfterInstall.length != 0) {
Logger.error(`[BinaryManager] Failed to find or install required binaries: ${missingBinariesAfterInstall.join(', ')}`)
process.exit(1)
}
this.initialized = true
}
async findRequiredBinaries() {
const missingBinaries = []
for (const binary of this.requiredBinaries) {
const binaryPath = await this.findBinary(binary.name, binary.envVariable)
if (binaryPath) {
Logger.info(`[BinaryManager] Found ${binary.name} at ${binaryPath}`)
Logger.info(`[BinaryManager] Updating process.env.${binary.envVariable}`)
process.env[binary.envVariable] = binaryPath
} else {
Logger.info(`[BinaryManager] ${binary.name} not found`)
missingBinaries.push(binary.name)
}
}
return missingBinaries
}
async findBinary(name, envVariable) {
const executable = name + (process.platform == 'win32' ? '.exe' : '')
const defaultPath = process.env[envVariable]
if (defaultPath && await fs.pathExists(defaultPath)) return defaultPath
const whichPath = which.sync(executable, { nothrow: true })
if (whichPath) return whichPath
const mainInstallPath = path.join(this.mainInstallPath, executable)
if (await fs.pathExists(mainInstallPath)) return mainInstallPath
const altInstallPath = path.join(this.altInstallPath, executable)
if (await fs.pathExists(altInstallPath)) return altInstallPath
return null
}
async install(binaries) {
if (binaries.length == 0) return
Logger.info(`[BinaryManager] Installing binaries: ${binaries.join(', ')}`)
let destination = this.mainInstallPath
try {
await fs.access(destination, fs.constants.W_OK)
} catch (err) {
destination = this.altInstallPath
}
await this.downloadBinaries(binaries, { destination })
Logger.info(`[BinaryManager] Binaries installed to ${destination}`)
}
}
module.exports = BinaryManager

View File

@ -0,0 +1,262 @@
const chai = require('chai');
const sinon = require('sinon');
const fs = require('../../../server/libs/fsExtra');
const which = require('../../../server/libs/which');
const path = require('path');
const BinaryManager = require('../../../server/managers/BinaryManager');
const expect = chai.expect;
describe('BinaryManager', () => {
let binaryManager;
describe('init', () => {
let findStub;
let installStub;
let errorStub;
let exitStub;
beforeEach(() => {
binaryManager = new BinaryManager();
findStub = sinon.stub(binaryManager, 'findRequiredBinaries');
installStub = sinon.stub(binaryManager, 'install');
errorStub = sinon.stub(console, 'error');
exitStub = sinon.stub(process, 'exit');
});
afterEach(() => {
findStub.restore();
installStub.restore();
errorStub.restore();
exitStub.restore();
});
it('should not install binaries if they are already found', async () => {
findStub.resolves([]);
await binaryManager.init();
expect(installStub.called).to.be.false;
expect(findStub.calledOnce).to.be.true;
expect(errorStub.called).to.be.false;
expect(exitStub.called).to.be.false;
});
it('should install missing binaries', async () => {
const missingBinaries = ['ffmpeg', 'ffprobe'];
const missingBinariesAfterInstall = [];
findStub.onFirstCall().resolves(missingBinaries);
findStub.onSecondCall().resolves(missingBinariesAfterInstall);
await binaryManager.init();
expect(findStub.calledTwice).to.be.true;
expect(installStub.calledOnce).to.be.true;
expect(errorStub.called).to.be.false;
expect(exitStub.called).to.be.false;
});
it('exit if binaries are not found after installation', async () => {
const missingBinaries = ['ffmpeg', 'ffprobe'];
const missingBinariesAfterInstall = ['ffmpeg', 'ffprobe'];
findStub.onFirstCall().resolves(missingBinaries);
findStub.onSecondCall().resolves(missingBinariesAfterInstall);
await binaryManager.init();
expect(findStub.calledTwice).to.be.true;
expect(installStub.calledOnce).to.be.true;
expect(errorStub.calledOnce).to.be.true;
expect(exitStub.calledOnce).to.be.true;
expect(exitStub.calledWith(1)).to.be.true;
});
});
describe('findRequiredBinaries', () => {
let findBinaryStub;
beforeEach(() => {
const requiredBinaries = [{ name: 'ffmpeg', envVariable: 'FFMPEG_PATH' }];
binaryManager = new BinaryManager(requiredBinaries);
findBinaryStub = sinon.stub(binaryManager, 'findBinary');
});
afterEach(() => {
findBinaryStub.restore();
});
it('should put found paths in the correct environment variables', async () => {
const pathToFFmpeg = '/path/to/ffmpeg';
const missingBinaries = [];
delete process.env.FFMPEG_PATH;
findBinaryStub.resolves(pathToFFmpeg);
const result = await binaryManager.findRequiredBinaries();
expect(result).to.deep.equal(missingBinaries);
expect(findBinaryStub.calledOnce).to.be.true;
expect(process.env.FFMPEG_PATH).to.equal(pathToFFmpeg);
});
it('should add missing binaries to result', async () => {
const missingBinaries = ['ffmpeg'];
delete process.env.FFMPEG_PATH;
findBinaryStub.resolves(null);
const result = await binaryManager.findRequiredBinaries();
expect(result).to.deep.equal(missingBinaries);
expect(findBinaryStub.calledOnce).to.be.true;
expect(process.env.FFMPEG_PATH).to.be.undefined;
});
});
describe('install', () => {
let accessStub;
let downloadBinariesStub;
beforeEach(() => {
binaryManager = new BinaryManager();
accessStub = sinon.stub(fs, 'access');
downloadBinariesStub = sinon.stub(binaryManager, 'downloadBinaries');
binaryManager.mainInstallPath = '/path/to/main/install'
binaryManager.altInstallPath = '/path/to/alt/install'
});
afterEach(() => {
accessStub.restore();
downloadBinariesStub.restore();
});
it('should not install binaries if no binaries are passed', async () => {
const binaries = [];
await binaryManager.install(binaries);
expect(accessStub.called).to.be.false;
expect(downloadBinariesStub.called).to.be.false;
});
it('should install binaries in main install path if has access', async () => {
const binaries = ['ffmpeg'];
const destination = binaryManager.mainInstallPath;
accessStub.withArgs(destination, fs.constants.W_OK).resolves();
downloadBinariesStub.resolves();
await binaryManager.install(binaries);
expect(accessStub.calledOnce).to.be.true;
expect(downloadBinariesStub.calledOnce).to.be.true;
expect(downloadBinariesStub.calledWith(binaries, sinon.match({ destination: destination }))).to.be.true;
});
it('should install binaries in alt install path if has no access to main', async () => {
const binaries = ['ffmpeg'];
const mainDestination = binaryManager.mainInstallPath;
const destination = binaryManager.altInstallPath;
accessStub.withArgs(mainDestination, fs.constants.W_OK).rejects();
downloadBinariesStub.resolves();
await binaryManager.install(binaries);
expect(accessStub.calledOnce).to.be.true;
expect(downloadBinariesStub.calledOnce).to.be.true;
expect(downloadBinariesStub.calledWith(binaries, sinon.match({ destination: destination }))).to.be.true;
});
});
});
describe('findBinary', () => {
let binaryManager;
let fsPathExistsStub;
let whichSyncStub;
let mainInstallPath;
let altInstallPath;
const name = 'ffmpeg';
const envVariable = 'FFMPEG_PATH';
const defaultPath = '/path/to/ffmpeg';
const executable = name + (process.platform == 'win32' ? '.exe' : '');
const whichPath = '/usr/bin/ffmpeg';
beforeEach(() => {
binaryManager = new BinaryManager();
fsPathExistsStub = sinon.stub(fs, 'pathExists');
whichSyncStub = sinon.stub(which, 'sync');
binaryManager.mainInstallPath = '/path/to/main/install'
mainInstallPath = path.join(binaryManager.mainInstallPath, executable);
binaryManager.altInstallPath = '/path/to/alt/install'
altInstallPath = path.join(binaryManager.altInstallPath, executable);
});
afterEach(() => {
fsPathExistsStub.restore();
whichSyncStub.restore();
});
it('should return defaultPath if it exists', async () => {
process.env[envVariable] = defaultPath;
fsPathExistsStub.withArgs(defaultPath).resolves(true);
const result = await binaryManager.findBinary(name, envVariable);
expect(result).to.equal(defaultPath);
expect(fsPathExistsStub.calledOnceWith(defaultPath)).to.be.true;
expect(whichSyncStub.notCalled).to.be.true;
});
it('should return whichPath if it exists', async () => {
delete process.env[envVariable];
whichSyncStub.returns(whichPath);
const result = await binaryManager.findBinary(name, envVariable);
expect(result).to.equal(whichPath);
expect(fsPathExistsStub.notCalled).to.be.true;
expect(whichSyncStub.calledOnce).to.be.true;
});
it('should return mainInstallPath if it exists', async () => {
delete process.env[envVariable];
whichSyncStub.returns(null);
fsPathExistsStub.withArgs(mainInstallPath).resolves(true);
const result = await binaryManager.findBinary(name, envVariable);
expect(result).to.equal(mainInstallPath);
expect(whichSyncStub.calledOnce).to.be.true;
expect(fsPathExistsStub.calledOnceWith(mainInstallPath)).to.be.true;
});
it('should return altInstallPath if it exists', async () => {
delete process.env[envVariable];
whichSyncStub.returns(null);
fsPathExistsStub.withArgs(mainInstallPath).resolves(false);
fsPathExistsStub.withArgs(altInstallPath).resolves(true);
const result = await binaryManager.findBinary(name, envVariable);
expect(result).to.equal(altInstallPath);
expect(whichSyncStub.calledOnce).to.be.true;
expect(fsPathExistsStub.calledTwice).to.be.true;
expect(fsPathExistsStub.calledWith(mainInstallPath)).to.be.true;
expect(fsPathExistsStub.calledWith(altInstallPath)).to.be.true;
});
it('should return null if binary is not found', async () => {
delete process.env[envVariable];
whichSyncStub.returns(null);
fsPathExistsStub.withArgs(mainInstallPath).resolves(false);
fsPathExistsStub.withArgs(altInstallPath).resolves(false);
const result = await binaryManager.findBinary(name, envVariable);
expect(result).to.be.null;
expect(whichSyncStub.calledOnce).to.be.true;
expect(fsPathExistsStub.calledTwice).to.be.true;
expect(fsPathExistsStub.calledWith(mainInstallPath)).to.be.true;
expect(fsPathExistsStub.calledWith(altInstallPath)).to.be.true;
});
});