mirror of
https://gitlab.com/futo-org/fcast.git
synced 2025-06-24 21:25:23 +00:00
431 lines
18 KiB
TypeScript
431 lines
18 KiB
TypeScript
import * as fs from 'fs';
|
|
import * as https from 'https';
|
|
import * as path from 'path';
|
|
import * as crypto from 'crypto';
|
|
import { app } from 'electron';
|
|
import { Store } from './Store';
|
|
import sudo from 'sudo-prompt';
|
|
import { Logger, LoggerType } from 'common/Logger';
|
|
import { fetchJSON } from './Main';
|
|
|
|
const cp = require('child_process');
|
|
const extract = require('extract-zip');
|
|
const logger = new Logger('Updater', LoggerType.BACKEND);
|
|
|
|
enum UpdateState {
|
|
Copy = 'copy',
|
|
Cleanup = 'cleanup',
|
|
Error = 'error',
|
|
};
|
|
|
|
interface ReleaseInfo {
|
|
previousVersions: [string];
|
|
currentVersion: string;
|
|
currentReleases: [
|
|
string: [ // channel
|
|
string: [ // os
|
|
string: [ // arch
|
|
string: []
|
|
]
|
|
]
|
|
]
|
|
];
|
|
channelCurrentVersions: [string: number];
|
|
allVersions: [string];
|
|
fileVersion: string;
|
|
}
|
|
|
|
interface UpdateInfo {
|
|
updateState: UpdateState;
|
|
installPath: string;
|
|
tempPath: string;
|
|
currentVersion: string;
|
|
downloadFile: string;
|
|
error?: string
|
|
}
|
|
|
|
interface UpdateConditions {
|
|
newVersion: boolean,
|
|
newChannelVersion: boolean,
|
|
newCommit: boolean,
|
|
}
|
|
|
|
export class Updater {
|
|
private static readonly supportedReleasesJsonVersion = '1';
|
|
|
|
private static appPath: string = app.getAppPath();
|
|
private static installPath: string = process.platform === 'darwin' ? path.join(Updater.appPath, '../../../') : path.join(Updater.appPath, '../../');
|
|
private static updateDataPath: string = path.join(app.getPath('userData'), 'updater');
|
|
private static updateMetadataPath = path.join(Updater.updateDataPath, './update.json');
|
|
private static baseUrl: string = 'https://dl.fcast.org/electron';
|
|
private static isRestarting: boolean = false;
|
|
private static updateConditions: UpdateConditions;
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
private static localPackageJson: any = null;
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
private static releasesJson: any = null;
|
|
|
|
public static isDownloading: boolean = false;
|
|
public static updateError: boolean = false;
|
|
public static updateDownloaded: boolean = false;
|
|
public static updateProgress: number = 0;
|
|
public static checkForUpdatesOnStart: boolean = true;
|
|
public static releaseChannel = 'stable';
|
|
public static updateChannel = 'stable';
|
|
|
|
static {
|
|
Updater.localPackageJson = JSON.parse(fs.readFileSync(path.join(Updater.appPath, './package.json'), 'utf8'));
|
|
|
|
let updaterSettings = Store.get('updater');
|
|
if (updaterSettings !== null) {
|
|
Updater.updateChannel = updaterSettings.channel === undefined ? Updater.localPackageJson.channel : updaterSettings.channel;
|
|
Updater.checkForUpdatesOnStart = updaterSettings.checkForUpdatesOnStart === undefined ? true : updaterSettings.checkForUpdatesOnStart;
|
|
}
|
|
|
|
updaterSettings = {
|
|
'channel': Updater.updateChannel,
|
|
'checkForUpdatesOnStart': Updater.checkForUpdatesOnStart,
|
|
}
|
|
|
|
Updater.releaseChannel = Updater.localPackageJson.channel;
|
|
Store.set('updater', updaterSettings);
|
|
}
|
|
|
|
private static async downloadFile(url: string, destination: string): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
const file = fs.createWriteStream(destination);
|
|
https.get(url, (response) => {
|
|
const downloadSize = Number(response.headers['content-length']);
|
|
logger.info(`Update size: ${downloadSize} bytes`);
|
|
response.pipe(file);
|
|
let downloadedBytes = 0;
|
|
|
|
response.on('data', (chunk) => {
|
|
downloadedBytes += chunk.length;
|
|
Updater.updateProgress = downloadedBytes / downloadSize;
|
|
});
|
|
file.on('finish', () => {
|
|
file.close();
|
|
resolve();
|
|
});
|
|
}).on('error', (err) => {
|
|
file.close();
|
|
reject(err);
|
|
});
|
|
});
|
|
}
|
|
|
|
private static async applyUpdate(src: string, dst: string) {
|
|
try {
|
|
fs.accessSync(dst, fs.constants.F_OK | fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
|
|
|
|
// Electron runtime sees .asar file as directory and causes errors during copy/remove operations
|
|
process.noAsar = true
|
|
if (process.platform === 'win32') {
|
|
// Cannot remove top-level directory since it might still be locked...
|
|
fs.rmSync(`${dst}\\*`, { maxRetries: 5, retryDelay: 1000, recursive: true, force: true });
|
|
}
|
|
else {
|
|
fs.rmSync(dst, { maxRetries: 5, retryDelay: 1000, recursive: true, force: true });
|
|
}
|
|
|
|
if (process.platform === 'darwin') {
|
|
// Electron framework libraries break otherwise on Mac
|
|
fs.cpSync(src, dst, { recursive: true, force: true, verbatimSymlinks: true });
|
|
}
|
|
else {
|
|
fs.cpSync(src, dst, { recursive: true, force: true });
|
|
}
|
|
}
|
|
catch (err) {
|
|
if (err.code === 'EACCES' || err.code === 'EPERM') {
|
|
logger.info('Update requires admin privileges. Escalating...');
|
|
|
|
await new Promise<void>((resolve, reject) => {
|
|
let command: string;
|
|
if (process.platform === 'win32') {
|
|
// Using native cmd.exe seems to create less issues than using powershell...
|
|
command = `rmdir /S /Q "${dst}" & xcopy /Y /E "${src}" "${dst}"`;
|
|
}
|
|
else {
|
|
command = `rm -rf '${dst}'; cp -rf '${src}' '${dst}'; chmod 755 '${dst}'`;
|
|
}
|
|
|
|
sudo.exec(command, { name: 'FCast Receiver' }, (error, stdout, stderr) => {
|
|
if (error) {
|
|
logger.error(error);
|
|
logger.warn(`stdout: ${stdout}`);
|
|
logger.warn(`stderr: ${stderr}`);
|
|
reject('User did not authorize the operation...');
|
|
}
|
|
|
|
logger.info('stdout', stdout);
|
|
logger.info('stderr', stderr);
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
else {
|
|
logger.error(err);
|
|
throw err;
|
|
}
|
|
}
|
|
finally {
|
|
process.noAsar = false;
|
|
}
|
|
}
|
|
|
|
// Cannot use app.relaunch(...) since it breaks privilege escalation on Linux...
|
|
// Also does not work very well on Mac...
|
|
private static relaunch(binPath: string) {
|
|
logger.info(`Relaunching app binary: ${binPath}`);
|
|
logger.shutdown();
|
|
|
|
let proc;
|
|
if (process.platform === 'win32') {
|
|
// cwd is bugged on Windows, perhaps due to needing to be in system32 to launch cmd.exe
|
|
proc = cp.spawn(`"${binPath}"`, [], { stdio: 'ignore', shell: true, detached: true, windowsHide: true });
|
|
}
|
|
else if (process.platform === 'darwin') {
|
|
proc = cp.spawn(`open '${binPath}'`, [], { cwd: path.dirname(binPath), shell: true, stdio: 'ignore', detached: true });
|
|
}
|
|
else {
|
|
proc = cp.spawn(binPath, [], { cwd: path.dirname(binPath), shell: true, stdio: 'ignore', detached: true });
|
|
}
|
|
|
|
proc.unref();
|
|
app.exit();
|
|
return;
|
|
}
|
|
|
|
private static compareVersions(v1: string, v2: string): number {
|
|
const v1Parts = v1.split('.').map(Number);
|
|
const v2Parts = v2.split('.').map(Number);
|
|
|
|
for (let i = 0; i < v1Parts.length; i++) {
|
|
if (v1Parts[i] > v2Parts[i]) {
|
|
return 1;
|
|
}
|
|
else if (v1Parts[i] < v2Parts[i]) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public static restart() {
|
|
if (!Updater.isRestarting) {
|
|
Updater.isRestarting = true;
|
|
const updateInfo: UpdateInfo = JSON.parse(fs.readFileSync(Updater.updateMetadataPath, 'utf8'));
|
|
const extractionDir = process.platform === 'darwin' ? 'FCast Receiver.app' : `fcast-receiver-${process.platform}-${process.arch}`;
|
|
const binaryName = process.platform === 'win32' ? 'fcast-receiver.exe' : 'fcast-receiver';
|
|
const updateBinPath = process.platform === 'darwin' ? path.join(updateInfo.tempPath, extractionDir) : path.join(updateInfo.tempPath, extractionDir, binaryName);
|
|
|
|
Updater.relaunch(updateBinPath);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
public static isUpdating(): boolean {
|
|
try {
|
|
const updateInfo: UpdateInfo = JSON.parse(fs.readFileSync(Updater.updateMetadataPath, 'utf8'));
|
|
Updater.updateError = true;
|
|
return updateInfo.updateState !== 'error';
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static getChannelVersion(): string {
|
|
Updater.localPackageJson.channelVersion = Updater.localPackageJson.channelVersion ? Updater.localPackageJson.channelVersion : 0
|
|
return Updater.localPackageJson.channelVersion;
|
|
}
|
|
|
|
public static getCommit(): string {
|
|
Updater.localPackageJson.commit = Updater.localPackageJson.commit ? Updater.localPackageJson.commit : null
|
|
return Updater.localPackageJson.commit;
|
|
}
|
|
|
|
public static async processUpdate(): Promise<void> {
|
|
try {
|
|
const updateInfo: UpdateInfo = JSON.parse(fs.readFileSync(Updater.updateMetadataPath, 'utf8'));
|
|
const extractionDir = process.platform === 'darwin' ? 'FCast Receiver.app' : `fcast-receiver-${process.platform}-${process.arch}`;
|
|
const binaryName = process.platform === 'win32' ? 'fcast-receiver.exe' : 'fcast-receiver';
|
|
const installBinPath = process.platform === 'darwin' ? updateInfo.installPath : path.join(updateInfo.installPath, binaryName);
|
|
|
|
switch (updateInfo.updateState) {
|
|
case UpdateState.Copy: {
|
|
try {
|
|
logger.info('Updater process started...');
|
|
const src = path.join(updateInfo.tempPath, extractionDir);
|
|
logger.info(`Copying files from update directory ${src} to install directory ${updateInfo.installPath}`);
|
|
|
|
await Updater.applyUpdate(src, updateInfo.installPath);
|
|
updateInfo.updateState = UpdateState.Cleanup;
|
|
fs.writeFileSync(Updater.updateMetadataPath, JSON.stringify(updateInfo));
|
|
}
|
|
catch (err) {
|
|
logger.error('Error while applying update...');
|
|
logger.error(err);
|
|
|
|
updateInfo.updateState = UpdateState.Error;
|
|
updateInfo.error = JSON.stringify(err);
|
|
fs.writeFileSync(Updater.updateMetadataPath, JSON.stringify(updateInfo));
|
|
}
|
|
|
|
Updater.relaunch(installBinPath);
|
|
return;
|
|
}
|
|
|
|
case UpdateState.Cleanup: {
|
|
try {
|
|
logger.info('Performing update cleanup...')
|
|
// Electron runtime sees .asar file as directory and causes errors during copy
|
|
process.noAsar = true
|
|
logger.info(`rm dir ${path.join(Updater.updateDataPath, extractionDir)}`)
|
|
fs.rmSync(path.join(Updater.updateDataPath, extractionDir), { recursive: true, force: true });
|
|
process.noAsar = false
|
|
|
|
fs.rmSync(path.join(Updater.updateDataPath, updateInfo.downloadFile));
|
|
fs.rmSync(Updater.updateMetadataPath);
|
|
|
|
// Removing the install directory causes an 'ENOENT: no such file or directory, uv_cwd' when calling process.cwd()
|
|
// Need to fix the working directory to the update directory that overwritten the install directory
|
|
process.chdir(Updater.installPath);
|
|
}
|
|
catch (err) {
|
|
logger.error('Error while performing update cleanup...');
|
|
logger.error(err);
|
|
|
|
updateInfo.updateState = UpdateState.Error;
|
|
updateInfo.error = JSON.stringify(err);
|
|
fs.writeFileSync(Updater.updateMetadataPath, JSON.stringify(updateInfo));
|
|
}
|
|
|
|
Updater.relaunch(installBinPath);
|
|
return;
|
|
}
|
|
|
|
case UpdateState.Error:
|
|
logger.warn(`Update operation did not complete successfully: ${updateInfo.error}`);
|
|
break;
|
|
}
|
|
}
|
|
catch (err) {
|
|
logger.warn(`Error reading update metadata file, ignoring pending update: ${err}`);
|
|
}
|
|
}
|
|
|
|
public static async checkForUpdates(): Promise<boolean> {
|
|
logger.info('Checking for updates...');
|
|
|
|
try {
|
|
Updater.releasesJson = await fetchJSON(`${Updater.baseUrl}/releases_v${Updater.supportedReleasesJsonVersion}.json`.toString()) as ReleaseInfo;
|
|
|
|
const localChannelVersion: number = Updater.localPackageJson.channelVersion ? Updater.localPackageJson.channelVersion : 0;
|
|
const currentChannelVersion: number = Updater.releasesJson.channelCurrentVersions[Updater.updateChannel] ? Updater.releasesJson.channelCurrentVersions[Updater.updateChannel] : 0;
|
|
logger.info('Update check', {
|
|
updateChannel: Updater.updateChannel,
|
|
channel_version: localChannelVersion,
|
|
localVersion: Updater.localPackageJson.version,
|
|
currentVersion: Updater.releasesJson.currentVersion,
|
|
currentCommit: Updater.releasesJson.currentCommit,
|
|
currentChannelVersion: currentChannelVersion
|
|
});
|
|
|
|
const newVersion = Updater.compareVersions(Updater.localPackageJson.version, Updater.releasesJson.currentVersion) < 0;
|
|
|
|
// Note: Major version updates are not captured in this check (e.g. 1.0.0-beta-4 -> 2.0.0-beta-1 being a valid update yet rejected)
|
|
const newChannelVersion = (Updater.updateChannel !== 'stable' && localChannelVersion < currentChannelVersion);
|
|
|
|
// Allow for update promotion to stable, while still getting updates from the subscribed channel
|
|
const newCommit = (
|
|
Updater.updateChannel !== 'stable' &&
|
|
Updater.localPackageJson.commit !== Updater.releasesJson.currentCommit &&
|
|
Updater.localPackageJson.version === Updater.releasesJson.currentVersion &&
|
|
localChannelVersion === currentChannelVersion
|
|
);
|
|
|
|
Updater.updateConditions = {
|
|
newVersion: newVersion,
|
|
newChannelVersion: newChannelVersion,
|
|
newCommit: newCommit,
|
|
};
|
|
|
|
// Prevent downgrading to sub channel if on stable
|
|
const isUpdateToStable = newVersion || newCommit;
|
|
const isDowngrade = Updater.releaseChannel === 'stable' && !isUpdateToStable && newChannelVersion;
|
|
|
|
if ((newVersion || newChannelVersion || newCommit) && !isDowngrade) {
|
|
logger.info('Update available...', Updater.updateConditions);
|
|
return true;
|
|
}
|
|
}
|
|
catch (err) {
|
|
logger.error(`Failed to check for updates: ${err}`);
|
|
throw 'Please try again later or visit https://fcast.org for updates.';
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static async downloadUpdate(): Promise<boolean> {
|
|
try {
|
|
fs.accessSync(Updater.updateDataPath, fs.constants.F_OK);
|
|
}
|
|
catch (err) {
|
|
logger.info(`Directory does not exist: ${err}`);
|
|
fs.mkdirSync(Updater.updateDataPath);
|
|
}
|
|
|
|
try {
|
|
const channel = (Updater.updateConditions.newVersion || Updater.updateConditions.newCommit) ? 'stable' : Updater.updateChannel;
|
|
const fileInfo = Updater.releasesJson.currentReleases[channel][process.platform][process.arch]
|
|
const file = fileInfo.url.toString().split('/').pop();
|
|
|
|
const destination = path.join(Updater.updateDataPath, file);
|
|
logger.info(`Downloading '${fileInfo.url}' to '${destination}'.`);
|
|
Updater.isDownloading = true;
|
|
await Updater.downloadFile(fileInfo.url.toString(), destination);
|
|
|
|
const downloadedFile = await fs.promises.readFile(destination);
|
|
const hash = crypto.createHash('sha256').end(downloadedFile).digest('hex');
|
|
if (fileInfo.sha256Digest !== hash) {
|
|
const message = 'Update failed integrity check. Please try again later or visit https://fcast.org to for updates.';
|
|
logger.error(`Update failed integrity check. Expected hash: ${fileInfo.sha256Digest}, actual hash: ${hash}`);
|
|
throw message;
|
|
}
|
|
|
|
// Electron runtime sees .asar file as directory and causes errors during extraction
|
|
logger.info('Extracting update...');
|
|
process.noAsar = true;
|
|
await extract(destination, { dir: path.dirname(destination) });
|
|
process.noAsar = false;
|
|
|
|
logger.info('Extraction complete.');
|
|
const updateInfo: UpdateInfo = {
|
|
updateState: UpdateState.Copy,
|
|
installPath: Updater.installPath,
|
|
tempPath: path.dirname(destination),
|
|
currentVersion: Updater.releasesJson.currentVersion,
|
|
downloadFile: file,
|
|
};
|
|
|
|
fs.writeFileSync(Updater.updateMetadataPath, JSON.stringify(updateInfo));
|
|
logger.info('Written update metadata.');
|
|
Updater.isDownloading = false;
|
|
Updater.updateDownloaded = true;
|
|
return true;
|
|
}
|
|
catch (err) {
|
|
Updater.isDownloading = false;
|
|
process.noAsar = false;
|
|
logger.error(`Failed to download update: ${err}`);
|
|
throw 'Failed to download update. Please try again later or visit https://fcast.org to download.';
|
|
}
|
|
}
|
|
}
|