pimi-launcher-core/components/handler.js
2019-12-10 08:16:12 -05:00

556 lines
22 KiB
JavaScript

const fs = require('fs');
const shelljs = require('shelljs');
const path = require('path');
const request = require('request');
const checksum = require('checksum');
const zip = require('adm-zip');
const child = require('child_process');
let counter = 0;
class Handler {
constructor(client) {
this.client = client;
this.options = client.options;
this.version = undefined;
this.baseRequest = request.defaults({
pool: {maxSockets: this.options.overrides.maxSockets || 2},
timeout: this.options.timeout || 10000
});
}
checkJava(java) {
return new Promise(resolve => {
child.exec(`"${java}" -version`, (error, stdout, stderr) => {
if (error) {
resolve({
run: false,
message: error
})
} else {
this.client.emit('debug', `[MCLC]: Using Java version ${stderr.match(/"(.*?)"/).pop()} ${stderr.includes('64-Bit') ? '64-bit': '32-Bit'}`);
resolve({
run: true
});
}
});
});
}
downloadAsync(url, directory, name, retry, type) {
return new Promise(resolve => {
shelljs.mkdir('-p', directory);
const _request = this.baseRequest(url);
let received_bytes = 0;
let total_bytes = 0;
_request.on('response', (data) => {
if (data.statusCode === 404) {
this.client.emit('debug', `[MCLC]: Failed to download ${url} due to: File not found...`);
resolve(false);
}
total_bytes = parseInt(data.headers['content-length']);
});
_request.on('error', async (error) => {
this.client.emit('debug', `[MCLC]: Failed to download asset to ${path.join(directory, name)} due to\n${error}.` +
` Retrying... ${retry}`);
if (retry) await this.downloadAsync(url, directory, name, false, type);
resolve();
});
_request.on('data', (data) => {
received_bytes += data.length;
this.client.emit('download-status', {
"name": name,
"type": type,
"current": received_bytes,
"total": total_bytes
})
});
const file = fs.createWriteStream(path.join(directory, name));
_request.pipe(file);
file.once('finish', () => {
this.client.emit('download', name);
resolve({
failed: false,
asset: null
});
});
file.on('error', async (e) => {
this.client.emit('debug', `[MCLC]: Failed to download asset to ${path.join(directory, name)} due to\n${e}.` +
` Retrying... ${retry}`);
if (fs.existsSync(path.join(directory, name))) shelljs.rm(path.join(directory, name));
if (retry) await this.downloadAsync(url, directory, name, false, type);
resolve();
});
});
}
checkSum(hash, file) {
return new Promise(resolve => {
checksum.file(file, (err, sum) => resolve(hash === sum));
});
}
getVersion() {
return new Promise(resolve => {
const versionJsonPath = this.options.overrides.versionJson || path.join(this.options.directory, `${this.options.version.number}.json`);
if (fs.existsSync(versionJsonPath)) {
this.version = JSON.parse(fs.readFileSync(versionJsonPath));
resolve(this.version);
return;
}
const manifest = `${this.options.overrides.url.meta}/mc/game/version_manifest.json`;
request.get(manifest, (error, response, body) => {
if (error) resolve(error);
const parsed = JSON.parse(body);
for (const desiredVersion in parsed.versions) {
if (parsed.versions[desiredVersion].id === this.options.version.number) {
request.get(parsed.versions[desiredVersion].url, (error, response, body) => {
if (error) resolve(error);
this.client.emit('debug', `[MCLC]: Parsed version from version manifest`);
this.version = JSON.parse(body);
resolve(this.version);
});
}
}
});
});
}
getJar() {
return new Promise(async (resolve) => {
await this.downloadAsync(this.version.downloads.client.url, this.options.directory, `${this.options.version.number}.jar`, true, 'version-jar');
fs.writeFileSync(path.join(this.options.directory, `${this.options.version.number}.json`), JSON.stringify(this.version, null, 4));
this.client.emit('debug', '[MCLC]: Downloaded version jar and wrote version json');
resolve();
});
}
getAssets() {
return new Promise(async(resolve) => {
if(!fs.existsSync(path.join(this.options.root, 'assets', 'indexes', `${this.version.assetIndex.id}.json`))) {
await this.downloadAsync(this.version.assetIndex.url, path.join(this.options.root, 'assets', 'indexes'),
`${this.version.assetIndex.id}.json`, true, 'asset-json');
}
const index = require(path.join(this.options.root, 'assets', 'indexes',`${this.version.assetIndex.id}.json`));
this.client.emit('progress', {
type: 'assets',
task: 0,
total: Object.keys(index.objects).length
});
await Promise.all(Object.keys(index.objects).map(async asset => {
const hash = index.objects[asset].hash;
const subhash = hash.substring(0,2);
const assetDirectory = this.options.overrides.assetRoot || path.join(this.options.root, 'assets');
const subAsset = path.join(assetDirectory, 'objects', subhash);
if(!fs.existsSync(path.join(subAsset, hash)) || !await this.checkSum(hash, path.join(subAsset, hash))) {
await this.downloadAsync(`${this.options.overrides.url.resource}/${subhash}/${hash}`, subAsset, hash,
true, 'assets');
counter = counter + 1;
this.client.emit('progress', {
type: 'assets',
task: counter,
total: Object.keys(index.objects).length
})
}
}));
counter = 0;
// Copy assets to legacy if it's an older Minecraft version.
if(this.version.assets === "legacy" || this.version.assets === "pre-1.6") {
const assetDirectory = this.options.overrides.assetRoot || path.join(this.options.root, 'assets');
this.client.emit('debug', `[MCLC]: Copying assets over to ${path.join(assetDirectory, 'legacy')}`);
this.client.emit('progress', {
type: 'assets-copy',
task: 0,
total: Object.keys(index.objects).length
});
await Promise.all(Object.keys(index.objects).map(async asset => {
const hash = index.objects[asset].hash;
const subhash = hash.substring(0,2);
const subAsset = path.join(assetDirectory, 'objects', subhash);
let legacyAsset = asset.split('/');
legacyAsset.pop();
if(!fs.existsSync(path.join(assetDirectory, 'legacy', legacyAsset.join('/')))) {
shelljs.mkdir('-p', path.join(assetDirectory, 'legacy', legacyAsset.join('/')));
}
if (!fs.existsSync(path.join(assetDirectory, 'legacy', asset))) {
fs.copyFileSync(path.join(subAsset, hash), path.join(assetDirectory, 'legacy', asset))
}
counter = counter + 1;
this.client.emit('progress', {
type: 'assets-copy',
task: counter,
total: Object.keys(index.objects).length
})
}));
}
counter = 0;
this.client.emit('debug', '[MCLC]: Downloaded assets');
resolve();
});
}
parseRule(lib) {
if(lib.rules) {
if (lib.rules.length > 1) {
if (lib.rules[0].action === 'allow' &&
lib.rules[1].action === 'disallow' &&
lib.rules[1].os.name === 'osx') {
return this.getOS() === 'osx';
} else {
return true;
}
} else {
if (lib.rules[0].action === 'allow' && lib.rules[0].os) return this.getOS() !== 'osx';
}
} else {
return false
}
}
getNatives() {
return new Promise(async(resolve) => {
const nativeDirectory = this.options.overrides.natives || path.join(this.options.root, 'natives', this.version.id);
if(!fs.existsSync(nativeDirectory) || !fs.readdirSync(nativeDirectory).length) {
shelljs.mkdir('-p', nativeDirectory);
const natives = () => {
return new Promise(async resolve => {
const natives = [];
await Promise.all(this.version.libraries.map(async (lib) => {
if (!lib.downloads.classifiers) return;
if (this.parseRule(lib)) return;
const native = this.getOS() === 'osx' ?
lib.downloads.classifiers['natives-osx'] || lib.downloads.classifiers['natives-macos'] :
lib.downloads.classifiers[`natives-${this.getOS()}`];
natives.push(native);
}));
resolve (natives);
})
};
const stat = await natives();
this.client.emit('progress', {
type: 'natives',
task: 0,
total: stat.length
});
await Promise.all(stat.map(async (native) => {
const name = native.path.split('/').pop();
await this.downloadAsync(native.url, nativeDirectory, name, true, 'natives');
if (!await this.checkSum(native.sha1, path.join(nativeDirectory, name))) {
await this.downloadAsync(native.url, nativeDirectory, name, true, 'natives');
}
try {
new zip(path.join(nativeDirectory, name)).extractAllTo(nativeDirectory, true);
} catch (e) {
// Only doing a console.warn since a stupid error happens. You can basically ignore this.
// if it says Invalid file name, just means two files were downloaded and both were deleted.
// All is well.
console.warn(e);
}
shelljs.rm(path.join(nativeDirectory, name));
counter = counter + 1;
this.client.emit('progress', {
type: 'natives',
task: counter,
total: stat.length
})
}));
this.client.emit('debug', '[MCLC]: Downloaded and extracted natives');
}
counter = 0;
this.client.emit('debug', `[MCLC]: Set native path to ${nativeDirectory}`);
resolve(nativeDirectory);
});
}
async getForgeDependenciesLegacy() {
if(!fs.existsSync(path.join(this.options.root, 'forge'))) {
shelljs.mkdir('-p', path.join(this.options.root, 'forge'));
}
try {
await new zip(this.options.forge).extractEntryTo('version.json', path.join(this.options.root, 'forge', `${this.version.id}`), false, true);
} catch(e) {
this.client.emit('debug', `[MCLC]: Unable to extract version.json from the forge jar due to ${e}`);
return null;
}
const forge = require(path.join(this.options.root, 'forge', `${this.version.id}`, 'version.json'));
const paths = [];
this.client.emit('progress', {
type: 'forge',
task: 0,
total: forge.libraries.length
});
await Promise.all(forge.libraries.map(async library => {
const lib = library.name.split(':');
if(lib[0] === 'net.minecraftforge' && lib[1].includes('forge')) return;
let url = this.options.overrides.url.mavenForge;
const jarPath = path.join(this.options.root, 'libraries', `${lib[0].replace(/\./g, '/')}/${lib[1]}/${lib[2]}`);
const name = `${lib[1]}-${lib[2]}.jar`;
if(!library.url) {
if(library.serverreq || library.clientreq) {
url = this.options.overrides.url.defaultRepoForge;
} else {
return
}
}
const downloadLink = `${url}${lib[0].replace(/\./g, '/')}/${lib[1]}/${lib[2]}/${name}`;
if(fs.existsSync(path.join(jarPath, name))) {
paths.push(`${jarPath}${path.sep}${name}`);
counter = counter + 1;
this.client.emit('progress', { type: 'forge', task: counter, total: forge.libraries.length});
return;
}
if(!fs.existsSync(jarPath)) shelljs.mkdir('-p', jarPath);
const download = await this.downloadAsync(downloadLink, jarPath, name, true, 'forge');
if(!download) await this.downloadAsync(`${this.options.overrides.url.fallbackMaven}${lib[0].replace(/\./g, '/')}/${lib[1]}/${lib[2]}/${name}`, jarPath, name, true, 'forge');
paths.push(`${jarPath}${path.sep}${name}`);
counter = counter + 1;
this.client.emit('progress', {
type: 'forge',
task: counter,
total: forge.libraries.length
})
}));
counter = 0;
this.client.emit('debug', '[MCLC]: Downloaded Forge dependencies');
return {paths, forge};
}
runInstaller(path) {
return new Promise(resolve => {
const installer = child.exec(path);
installer.on('close', (code) => resolve());
})
}
getClasses() {
return new Promise(async (resolve) => {
const libs = [];
if(this.options.version.custom) {
const customJarJson = require(path.join(this.options.root, 'versions', this.options.version.custom, `${this.options.version.custom}.json`));
this.client.emit('progress', {
type: 'classes-custom',
task: 0,
total: customJarJson.libraries.length
});
await Promise.all(customJarJson.libraries.map(async library => {
const lib = library.name.split(':');
const jarPath = path.join(this.options.root, 'libraries', `${lib[0].replace(/\./g, '/')}/${lib[1]}/${lib[2]}`);
const name = `${lib[1]}-${lib[2]}.jar`;
if(!fs.existsSync(path.join(jarPath, name))) {
if(library.url) {
const url = `${library.url}${lib[0].replace(/\./g, '/')}/${lib[1]}/${lib[2]}/${lib[1]}-${lib[2]}.jar`;
await this.downloadAsync(url, jarPath, name, true, 'classes-custom');
}
}
counter = counter + 1;
this.client.emit('progress', {
type: 'classes-custom',
task: counter,
total: customJarJson.libraries.length
});
libs.push(`${jarPath}${path.sep}${name}`);
}));
counter = 0;
}
const parsedClasses = () => {
return new Promise(async resolve => {
const classes = [];
await Promise.all(this.version.libraries.map(async (_lib) => {
if(!_lib.downloads.artifact) return;
if(this.parseRule(_lib)) return;
classes.push(_lib);
}));
resolve(classes);
})
};
const parsed = await parsedClasses();
this.client.emit('progress', {
type: 'classes',
task: 0,
total: parsed.length
});
await Promise.all(parsed.map(async (_lib) => {
const libraryPath = _lib.downloads.artifact.path;
const libraryUrl = _lib.downloads.artifact.url;
const libraryHash = _lib.downloads.artifact.sha1;
const libraryDirectory = path.join(this.options.root, 'libraries', libraryPath);
if(!fs.existsSync(libraryDirectory) || !await this.checkSum(libraryHash, libraryDirectory)) {
let directory = libraryDirectory.split(path.sep);
const name = directory.pop();
directory = directory.join(path.sep);
await this.downloadAsync(libraryUrl, directory, name, true, 'classes');
}
counter = counter + 1;
this.client.emit('progress', {
type: 'classes',
task: counter,
total: parsed.length
});
libs.push(libraryDirectory);
}));
counter = 0;
this.client.emit('debug', '[MCLC]: Collected class paths');
resolve(libs)
});
}
static cleanUp(array) {
return new Promise(resolve => {
const newArray = [];
for(let classPath in array) {
if(newArray.includes(array[classPath])) continue;
newArray.push(array[classPath]);
}
resolve(newArray);
})
}
getLaunchOptions(modification) {
return new Promise(async resolve => {
let type = modification || this.version;
let args = type.minecraftArguments ? type.minecraftArguments.split(' ') : type.arguments.game;
const assetRoot = this.options.overrides.assetRoot || path.join(this.options.root, 'assets');
const assetPath = this.version.assets === "legacy" || this.version.assets === "pre-1.6" ? path.join(assetRoot, 'legacy') : path.join(assetRoot);
const minArgs = this.options.overrides.minArgs || 5;
if(args.length < minArgs) args = args.concat(this.version.minecraftArguments ? this.version.minecraftArguments.split(' ') : this.version.arguments.game);
this.options.authorization = await Promise.resolve(this.options.authorization);
const fields = {
'${auth_access_token}': this.options.authorization.access_token,
'${auth_session}': this.options.authorization.access_token,
'${auth_player_name}': this.options.authorization.name,
'${auth_uuid}': this.options.authorization.uuid,
'${user_properties}': this.options.authorization.user_properties,
'${user_type}': 'mojang',
'${version_name}': this.options.version.number,
'${assets_index_name}': this.version.assetIndex.id,
'${game_directory}': this.options.root,
'${assets_root}': assetPath,
'${game_assets}': assetPath,
'${version_type}': this.options.version.type
};
for (let index = 0; index < args.length; index++) {
if(typeof args[index] === 'object') args.splice(index, 2);
if (Object.keys(fields).includes(args[index])) {
args[index] = fields[args[index]];
}
}
if(this.options.window) this.options.window.fullscreen ? args.push('--fullscreen') : args.push('--width', this.options.window.width, '--height', this.options.window.height);
if(this.options.server) args.push('--server', this.options.server.host, '--port', this.options.server.port || "25565");
if(this.options.proxy) args.push(
'--proxyHost',
this.options.proxy.host,
'--proxyPort',
this.options.proxy.port || "8080",
'--proxyUser',
this.options.proxy.username,
'--proxyPass',
this.options.proxy.password
);
this.client.emit('debug', '[MCLC]: Set launch options');
resolve(args);
});
}
async getJVM() {
const opts = {
"windows": "-XX:HeapDumpPath=MojangTricksIntelDriversForPerformance_javaw.exe_minecraft.exe.heapdump",
"osx": "-XstartOnFirstThread",
"linux": "-Xss1M"
};
return opts[this.getOS()]
}
getOS() {
if(this.options.os) {
return this.options.os;
} else {
switch(process.platform) {
case "win32": return "windows";
case "darwin": return "osx";
default: return "linux";
}
}
}
extractPackage(options = this.options) {
return new Promise(async resolve => {
if(options.clientPackage.startsWith('http')) {
await this.downloadAsync(options.clientPackage, options.root, "clientPackage.zip", true, 'client-package');
options.clientPackage = path.join(options.root, "clientPackage.zip")
}
new zip(options.clientPackage).extractAllTo(options.root, true);
this.client.emit('package-extract', true);
if(options.removePackage) shelljs.rm(options.clientPackage);
resolve();
});
}
}
module.exports = Handler;