mirror of
https://github.com/Pax1601/DCSOlympus.git
synced 2025-10-29 16:56:34 +00:00
331 lines
11 KiB
JavaScript
331 lines
11 KiB
JavaScript
const contextBridge = require("electron").contextBridge;
|
|
const ipcRenderer = require("electron").ipcRenderer;
|
|
const { exec, spawn } = require("child_process");
|
|
const { showConfirmPopup, showWaitPopup, showErrorPopup } = require("./popup");
|
|
const path = require("path");
|
|
const os = require("os");
|
|
const https = require("follow-redirects").https;
|
|
const fs = require("fs");
|
|
const AdmZip = require("adm-zip");
|
|
const { Octokit } = require("octokit");
|
|
const { logger } = require("./filesystem");
|
|
const { getManager } = require("./managerfactory");
|
|
const { sleep } = require("./utils");
|
|
|
|
const VERSION = "{{OLYMPUS_VERSION_NUMBER}}";
|
|
logger.log(`Running in ${__dirname}`);
|
|
function checkVersion(forceBeta) {
|
|
/* Check if we are running the latest version */
|
|
const request = new Request("https://raw.githubusercontent.com/Pax1601/DCSOlympus/main/version.json");
|
|
fetch(request)
|
|
.then((response) => {
|
|
if (response.status === 200) {
|
|
return response.json();
|
|
} else {
|
|
throw new Error("Error connecting to Github to retrieve latest version");
|
|
}
|
|
})
|
|
.then((res) => {
|
|
/* If we are running a development version of the script (not from a compiled package), skip version checking */
|
|
if (VERSION.includes("OLYMPUS_VERSION_NUMBER")) {
|
|
logger.log("Development build detected, skipping version checks...");
|
|
} else {
|
|
/* Check if there is a newer version available */
|
|
var reg1 = res["version"].match(/\d+/g).map((str) => {
|
|
return Number(str);
|
|
});
|
|
var reg2 = VERSION.match(/\d+/g).map((str) => {
|
|
return Number(str);
|
|
});
|
|
|
|
/* If a newer version is available update Olympus in Release mode */
|
|
if (
|
|
reg1[0] > reg2[0] ||
|
|
(reg1[0] == reg2[0] && reg1[1] > reg2[1]) ||
|
|
(reg1[0] == reg2[0] && reg1[1] == reg2[1] && reg1[2] > reg2[2])
|
|
) {
|
|
logger.log(`New version available: ${res["version"]}`);
|
|
showConfirmPopup(
|
|
`<div class='main-message'>You are currently running DCS Olympus ${VERSION}, but ${res["version"]} is available. </div><div class='sub-message'> Do you want to update DCS Olympus automatically? </div> <div style="max-width: 100%; color: orange">Note: DCS and Olympus MUST be stopped before proceeding.</div>`,
|
|
async () => {
|
|
/* Nested popup calls need to wait for animation to complete */
|
|
await sleep(300);
|
|
|
|
updateOlympusRelease();
|
|
},
|
|
() => {
|
|
logger.log("Update canceled");
|
|
}
|
|
);
|
|
} else if (
|
|
/* If the current version is newer than the latest release, the user is probably a developer. Ask for a beta update */
|
|
reg2[0] > reg1[0] ||
|
|
(reg2[0] == reg1[0] && reg2[1] > reg1[1]) ||
|
|
(reg2[0] == reg1[0] && reg2[1] == reg1[1] && reg2[2] > reg1[2])
|
|
) {
|
|
logger.log(`Beta version detected: ${res["version"]} vs ${VERSION}`);
|
|
updateOlympusBeta();
|
|
}
|
|
else {
|
|
logger.log("Running latest version...");
|
|
|
|
if (forceBeta) {
|
|
logger.log(`Beta version forced: ${res["version"]} vs ${VERSION}`);
|
|
updateOlympusBeta();
|
|
}
|
|
}
|
|
|
|
}
|
|
});
|
|
}
|
|
|
|
/** Update Olympus in "beta" mode. The user will be provided with the option to update from a build artifact
|
|
*
|
|
*/
|
|
async function updateOlympusBeta() {
|
|
/* Get a list of build artifacts */
|
|
const octokit = new Octokit({});
|
|
const res = await octokit.request("GET /repos/{owner}/{repo}/actions/artifacts", {
|
|
owner: "Pax1601",
|
|
repo: "DCSOlympus",
|
|
headers: {
|
|
"X-GitHub-Api-Version": "2022-11-28",
|
|
},
|
|
});
|
|
const artifacts = res.data.artifacts;
|
|
|
|
/* Select the newest artifact */
|
|
var artifact = artifacts.find((artifact) => {
|
|
return artifact.name === "development_build_not_a_release";
|
|
});
|
|
|
|
const date1 = new Date(artifact.updated_at);
|
|
const date2 = fs.statSync(".").mtime;
|
|
if (date1 > date2) {
|
|
showConfirmPopup(
|
|
`<div class='main-message'> Looks like you are running a beta version of Olympus!</div><div class='sub-message'> Latest beta artifact timestamp of: <b style="color: orange">${date1.toLocaleString()}</b> <br> Your installation timestamp: <b style="color: orange">${date2.toLocaleString()}</b> <br><br> Do you want to update to the newest beta version?</div>`,
|
|
async () => {
|
|
/* Nested popup calls need to wait for animation to complete */
|
|
await sleep(300);
|
|
|
|
/* Run the update process */
|
|
updateOlympus(
|
|
"https://nightly.link/Pax1601/DCSOlympus/workflows/build_package/release-candidate/development_build_not_a_release.zip"
|
|
);
|
|
},
|
|
() => {
|
|
logger.log("Update canceled");
|
|
}
|
|
);
|
|
} else {
|
|
logger.log("Build is latest");
|
|
}
|
|
}
|
|
|
|
/** Update Olympus to the lastest release
|
|
*
|
|
*/
|
|
async function updateOlympusRelease() {
|
|
const octokit = new Octokit({});
|
|
|
|
const res = await octokit.request("GET /repos/{owner}/{repo}/releases/latest", {
|
|
owner: "Pax1601",
|
|
repo: "DCSOlympus",
|
|
headers: {
|
|
"X-GitHub-Api-Version": "2022-11-28",
|
|
},
|
|
});
|
|
|
|
/* Select the newest artifact */
|
|
var asset = res.data.assets.find((asset) => {
|
|
return asset.name.includes("manager");
|
|
});
|
|
|
|
/* Run the update process */
|
|
updateOlympus(asset.browser_download_url);
|
|
}
|
|
|
|
function updateOlympus(location) {
|
|
showWaitPopup(
|
|
"<div class='main-message'>Please wait while Olympus is being updated. </div><div class='sub-message'> The Manager will be closed and reopened automatically when updating is completed.</div>"
|
|
);
|
|
|
|
/* If the location is a string, it is interpreted as a download url. Else, it is interpreted as a File (on disk)*/
|
|
if (typeof location === "string") {
|
|
logger.log(`Updating Olympus with package from ${location}`);
|
|
} else {
|
|
logger.log(`Updating Olympus with package from ${location.path}`);
|
|
}
|
|
|
|
let tmpDir;
|
|
const appPrefix = "dcs-olympus-";
|
|
try {
|
|
/* Create a temporary folder */
|
|
const folder = path.join(os.tmpdir(), appPrefix);
|
|
tmpDir = fs.mkdtempSync(folder);
|
|
|
|
if (typeof location === "string") {
|
|
/* Download the file */
|
|
const file = fs.createWriteStream(path.join(tmpDir, "temp.zip"));
|
|
logger.log(`Downloading update package in ${path.join(tmpDir, "temp.zip")}`);
|
|
const request = https.get(location, (response) => {
|
|
if (response.statusCode === 200) {
|
|
response.pipe(file);
|
|
|
|
/* Either on success or on error close the file stream */
|
|
file.on("finish", () => {
|
|
file.close();
|
|
logger.log("Download completed");
|
|
|
|
/* Extract and copy the files */
|
|
extractAndCopy(tmpDir);
|
|
});
|
|
file.on("error", (err) => {
|
|
file.close();
|
|
logger.error(err);
|
|
throw Error(err);
|
|
});
|
|
} else {
|
|
failUpdate();
|
|
throw Error("Failed to download resource.");
|
|
}
|
|
});
|
|
} else {
|
|
/* Copy the archive to the temporary folder */
|
|
fs.copyFileSync(location.path, path.join(tmpDir, "temp.zip"));
|
|
|
|
/* Extract and copy the files */
|
|
extractAndCopy(tmpDir);
|
|
}
|
|
} catch (err) {
|
|
/* Show the failed update message */
|
|
failUpdate();
|
|
logger.error(err);
|
|
}
|
|
}
|
|
|
|
/** Extract the contents of the zip and update Olympus by deleting all files from the current installation and copying the new files over.
|
|
*
|
|
*/
|
|
function extractAndCopy(folder) {
|
|
/* Extract all the files */
|
|
const zip = new AdmZip(path.join(folder, "temp.zip"));
|
|
zip.extractAllTo(path.join(folder, "temp"));
|
|
|
|
/* Create a batch file that:
|
|
1) waits for 5 seconds to allow the old process to close;
|
|
2) deletes the existing installation;
|
|
3) copies the new installation;
|
|
4) cds into the new installation;
|
|
5) runs the installer.bat script */
|
|
fs.writeFileSync(
|
|
path.join(folder, "update.bat"),
|
|
`timeout /t 5 \necho D|xcopy /Y /S /E "${path.join(folder, "temp")}" "${path.join(
|
|
__dirname,
|
|
"..",
|
|
".."
|
|
)}" \ncd "${path.join(__dirname, "..", "..")}" \ncall installer.bat`
|
|
);
|
|
|
|
/* Launch the update script then close gracefully */
|
|
var proc = spawn("cmd.exe", ["/c", path.join(folder, "update.bat")], { cwd: folder, shell: true, detached: true });
|
|
proc.unref();
|
|
ipcRenderer.send("window:close");
|
|
}
|
|
|
|
/** Something went wrong. Tell the user to update manually.
|
|
*
|
|
*/
|
|
function failUpdate() {
|
|
showErrorPopup(
|
|
`<div class='main-message'>An error has occurred while updating Olympus. </div><div class='sub-message'> Please delete Olympus and update it manually. A browser window will open automatically on the download page. <br><br> You can find more info in ${path.join(
|
|
__dirname,
|
|
"..",
|
|
"manager.log"
|
|
)}</div>`,
|
|
() => {
|
|
exec(`start https://github.com/Pax1601/DCSOlympus/releases`, () => {
|
|
ipcRenderer.send("window:close");
|
|
});
|
|
}
|
|
);
|
|
}
|
|
|
|
/* White-listed channels. */
|
|
const ipc = {
|
|
render: {
|
|
/* From render to main. */
|
|
send: ["window:minimize", "window:maximize", "window:restore", "window:close"],
|
|
/* From main to render. */
|
|
receive: ["event:maximized", "event:unmaximized"],
|
|
/* From render to main and back again. */
|
|
sendReceive: [],
|
|
},
|
|
};
|
|
|
|
/* Exposed protected methods in the render process. */
|
|
contextBridge.exposeInMainWorld(
|
|
/* Allowed 'ipcRenderer' methods. */
|
|
"ipcRender",
|
|
{
|
|
/* From render to main. */
|
|
send: (channel, args) => {
|
|
let validChannels = ipc.render.send;
|
|
if (validChannels.includes(channel)) {
|
|
ipcRenderer.send(channel, args);
|
|
}
|
|
},
|
|
/* From main to render. */
|
|
receive: (channel, listener) => {
|
|
let validChannels = ipc.render.receive;
|
|
if (validChannels.includes(channel)) {
|
|
/* Deliberately strip event as it includes `sender`. */
|
|
ipcRenderer.on(channel, (event, ...args) => listener(...args));
|
|
}
|
|
},
|
|
/* From render to main and back again. */
|
|
invoke: (channel, args) => {
|
|
let validChannels = ipc.render.sendReceive;
|
|
if (validChannels.includes(channel)) {
|
|
return ipcRenderer.invoke(channel, args);
|
|
}
|
|
},
|
|
}
|
|
);
|
|
|
|
/* On content loaded */
|
|
window.addEventListener("DOMContentLoaded", async () => {
|
|
document.getElementById("loader").classList.remove("hide");
|
|
await getManager().start();
|
|
|
|
await checkVersion(getManager().options.forceBeta);
|
|
});
|
|
|
|
window.addEventListener("resize", () => {
|
|
/* Compute the height of the content page */
|
|
computePagesHeight();
|
|
});
|
|
|
|
window.addEventListener("DOMContentLoaded", () => {
|
|
/* Compute the height of the content page */
|
|
computePagesHeight();
|
|
});
|
|
|
|
document.addEventListener("managerStarted", () => {
|
|
/* Compute the height of the content page */
|
|
computePagesHeight();
|
|
});
|
|
|
|
/** Computes the height of the content area
|
|
*
|
|
*/
|
|
function computePagesHeight() {
|
|
var pages = document.querySelectorAll(".manager-page");
|
|
var titleBar = document.querySelector("#title-bar");
|
|
var header = document.querySelector("#header");
|
|
|
|
for (let i = 0; i < pages.length; i++) {
|
|
pages[i].style.height = window.innerHeight - (titleBar.clientHeight + header.clientHeight) + "px";
|
|
}
|
|
}
|