Skirda/SkirdaElectronLauncher
4
0
Fork 0
Code Issues Pull Requests Projects Releases 2 Wiki Activity

AssetGuard module being finalized, documentation in progress.

Browse Source
This commit is contained in:
Daniel Scalzi 2017-05-14 04:37:38 -04:00
parent 0dfb26f8fa
commit 460c6c19fa
3 changed files with 224 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

281
app/assets/js/assetguard.js
View File

@ -1,4 +1,27 @@
/* Requirements */
/**
* AssetGuard
*
* This module aims to provide a comprehensive and stable method for processing
* and downloading game assets for the WesterosCraft server. A central object
* stores download meta for several identifiers (categories). This meta data
* is initially empty until one of the module's processing functions are called.
* That function will process the corresponding asset index and validate any exisitng
* local files. If a file is missing or fails validation, it will be placed into an
* array which acts as a queue. This queue is wrapped in a download tracker object
* so that essential information can be cached. The download tracker object is then
* assigned as the value of the identifier in the central object. These download
* trackers will remain idle until an async process is started to process them.
*
* Once the async process is started, any enqueued assets will be downloaded. The central
* object will emit events throughout the download whose name correspond to the identifier
* being processed. For example, if the 'assets' identifier was being processed, whenever
* the download stream recieves data, the event 'assetsdlprogress' will be emitted off of
* the central object instance. This can be listened to by external modules allowing for
* categorical tracking of the downloading process.
*
* @module assetguard
*/
//Requirements
const fs = require('fs')
const request = require('request')
const path = require('path')
@ -10,7 +33,17 @@ const {remote} = require('electron')
/* Classes */
/** Class representing a base asset. */
class Asset{
/**
* Create an asset.
*
* @param {any} id - id of the asset.
* @param {String} hash - hash value of the asset.
* @param {Number} size - size in bytes of the asset.
* @param {String} from - url where the asset can be found.
* @param {String} to - absolute local file path of the asset.
*/
constructor(id, hash, size, from, to){
this.id = id
this.hash = hash
@ -20,8 +53,12 @@ class Asset{
}
}
/** Class representing a mojang library. */
class Library extends Asset{
/**
* Converts the process.platform OS names to match mojang's OS names.
*/
static mojangFriendlyOS(){
const opSys = process.platform
if (opSys === 'darwin') {
@ -35,6 +72,16 @@ class Library extends Asset{
}
}
/**
* Checks whether or not a library is valid for download on a particular OS, following
* the rule format specified in the mojang version data index. If the allow property has
* an OS specified, then the library can ONLY be downloaded on that OS. If the disallow
* property has instead specified an OS, the library can be downloaded on any OS EXCLUDING
* the one specified.
*
* @param {Object} rules - the Library's download rules.
* @returns {Boolean} - true if the Library follows the specified rules, otherwise false.
*/
static validateRules(rules){
if(rules == null) return true
@ -60,14 +107,37 @@ class Library extends Asset{
}
}
/**
* Class representing a download tracker. This is used to store meta data
* about a download queue, including the queue itself.
*/
class DLTracker {
/**
* Create a DLTracker
*
* @param {Array.<Asset>} dlqueue - an array containing assets queued for download.
* @param {Number} dlsize - the combined size of each asset in the download queue array.
*/
constructor(dlqueue, dlsize){
this.dlqueue = dlqueue
this.dlsize = dlsize
}
}
/**
* Central object class used for control flow. This object stores data about
* categories of downloads. Each category is assigned an identifier with a
* DLTracker object as its value. Combined information is also stored, such as
* the total size of all the queued files in each category. This event is used
* to emit events so that external modules can listen into processing done in
* this module.
*/
class AssetGuard extends EventEmitter{
/**
* AssetGuard class should only ever have one instance which is defined in
* this module. On creation the object's properties are never-null default
* values. Each identifier is resolved to an empty DLTracker.
*/
constructor(){
super()
this.totaldlsize = 0;
@ -79,11 +149,18 @@ class AssetGuard extends EventEmitter{
}
//Instance of AssetGuard
const instance = new AssetGuard()
/* Utility Functions */
// Utility Functions
/**
* Validate that a file exists and matches a given hash value.
*
* @param {String} filePath - the path of the file to validate.
* @param {String} algo - the hash algorithm to check against.
* @param {String} hash - the existing hash to check against.
* @returns {Boolean} - true if the file exists and calculated hash matches the given hash, otherwise false.
*/
validateLocal = function(filePath, algo, hash){
if(fs.existsSync(filePath)){
let fileName = path.basename(filePath)
@ -96,12 +173,64 @@ validateLocal = function(filePath, algo, hash){
return false;
}
/**
* Initiate an async download process for an AssetGuard DLTracker.
*
* @param {String} identifier - the identifier of the AssetGuard DLTracker.
* @param {Number} limit - optional. The number of async processes to run in parallel.
* @returns {Boolean} - true if the process began, otherwise false.
*/
function startAsyncProcess(identifier, limit = 5){
let win = remote.getCurrentWindow()
let acc = 0
const concurrentDlQueue = instance[identifier].dlqueue.slice(0)
if(concurrentDlQueue.length === 0){
return false
} else {
async.eachLimit(concurrentDlQueue, limit, function(asset, cb){
mkpath.sync(path.join(asset.to, ".."))
let req = request(asset.from)
let writeStream = fs.createWriteStream(asset.to)
req.pipe(writeStream)
req.on('data', function(chunk){
instance.progress += chunk.length
acc += chunk.length
instance.emit(identifier + 'dlprogress', acc)
//console.log(identifier + ' Progress', acc/instance[identifier].dlsize)
win.setProgressBar(instance.progress/instance.totaldlsize)
})
writeStream.on('close', cb)
}, function(err){
if(err){
instance.emit(identifier + 'dlerror')
console.log('An item in ' + identifier + ' failed to process');
} else {
instance.emit(identifier + 'dlcomplete')
console.log('All ' + identifier + ' have been processed successfully')
}
instance.totaldlsize -= instance[identifier].dlsize
instance[identifier] = new DLTracker([], 0)
if(instance.totaldlsize === 0) {
win.setProgressBar(-1)
instance.emit('dlcomplete')
}
})
return true
}
}
/* Validation Functions */
/**
* Load version asset index.
* Loads the version data for a given minecraft version.
*
* @param {String} version - the game version for which to load the index data.
* @param {String} basePath - the absolute file path which will be prepended to the given relative paths.
* @param {Boolean} force - optional. If true, the version index will be downloaded even if it exists locally. Defaults to false.
* @returns {Promise.<Object>} - Promise which resolves to the version data object.
*/
loadVersionData = function(version, basePath, force = false){
function loadVersionData(version, basePath, force = false){
return new Promise(function(fulfill, reject){
const name = version + '.json'
const url = 'https://s3.amazonaws.com/Minecraft.Download/versions/' + version + '/' + name
@ -124,11 +253,14 @@ loadVersionData = function(version, basePath, force = false){
}
/**
* Public asset validation method.
* Public asset validation function. This function will handle the validation of assets.
* It will parse the asset index specified in the version data, analyzing each
* asset entry. In this analysis it will check {todo finish later i'm tired ZZzzzz}
*
*/
validateAssets = function(versionData, basePath, force = false){
function validateAssets(versionData, basePath, force = false){
return new Promise(function(fulfill, reject){
assetChainIndexData(versionData, basePath, force).then(() => {
_assetChainIndexData(versionData, basePath, force).then(() => {
fulfill()
})
})
@ -136,7 +268,7 @@ validateAssets = function(versionData, basePath, force = false){
//Chain the asset tasks to provide full async. The below functions are private.
assetChainIndexData = function(versionData, basePath, force = false){
function _assetChainIndexData(versionData, basePath, force = false){
return new Promise(function(fulfill, reject){
//Asset index constants.
const assetIndex = versionData.assetIndex
@ -151,20 +283,20 @@ assetChainIndexData = function(versionData, basePath, force = false){
const stream = request(assetIndex.url).pipe(fs.createWriteStream(assetIndexLoc))
stream.on('finish', function() {
data = JSON.parse(fs.readFileSync(assetIndexLoc, 'utf-8'))
assetChainValidateAssets(versionData, basePath, data).then(() => {
_assetChainValidateAssets(versionData, basePath, data).then(() => {
fulfill()
})
})
} else {
data = JSON.parse(fs.readFileSync(assetIndexLoc, 'utf-8'))
assetChainValidateAssets(versionData, basePath, data).then(() => {
_assetChainValidateAssets(versionData, basePath, data).then(() => {
fulfill()
})
}
})
}
assetChainValidateAssets = function(versionData, basePath, indexData){
_assetChainValidateAssets = function(versionData, basePath, indexData){
return new Promise(function(fulfill, reject){
//Asset constants
@ -225,75 +357,80 @@ validateLibraries = function(versionData, basePath){
})
}
runQueue = function(){
/**
* Public miscellaneous mojang file validation function.
*/
validateMiscellaneous = function(versionData, basePath){
return new Promise(async function(fulfill, reject){
await validateClient(versionData, basePath)
await validateLogConfig(versionData, basePath)
fulfill()
})
}
//Validate client - artifact renamed from client.jar to '{version}'.jar.
validateClient = function(versionData, basePath, force = false){
return new Promise(function(fulfill, reject){
const clientData = versionData.downloads.client
const version = versionData.id
const targetPath = path.join(basePath, 'versions', version)
const targetFile = version + '.jar'
let client = new Asset(version + ' client', clientData.sha1, clientData.size, clientData.url, path.join(targetPath, targetFile))
if(!validateLocal(client.to, 'sha1', client.hash) || force){
instance.files.dlqueue.push(client)
instance.files.dlsize += client.size*1
fulfill()
} else {
fulfill()
}
})
}
//Validate log config.
validateLogConfig = function(versionData, basePath){
return new Promise(function(fulfill, reject){
const client = versionData.logging.client
const file = client.file
const targetPath = path.join(basePath, 'assets', 'log_configs')
let logConfig = new Asset(file.id, file.sha1, file.size, file.url, path.join(targetPath, file.id))
if(!validateLocal(logConfig.to, 'sha1', logConfig.hash)){
instance.files.dlqueue.push(logConfig)
instance.files.dlsize += client.size*1
fulfill()
} else {
fulfill()
}
})
}
processDlQueues = function(identifiers = [{id:'assets', limit:20}, {id:'libraries', limit:5}, {id:'files', limit:5}]){
this.progress = 0;
let win = remote.getCurrentWindow()
//Start asset download
let assetacc = 0;
const concurrentAssetDlQueue = instance.assets.dlqueue.slice(0)
async.eachLimit(concurrentAssetDlQueue, 20, function(asset, cb){
mkpath.sync(path.join(asset.to, ".."))
let req = request(asset.from)
let writeStream = fs.createWriteStream(asset.to)
req.pipe(writeStream)
req.on('data', function(chunk){
instance.progress += chunk.length
assetacc += chunk.length
instance.emit('assetdata', assetacc)
console.log('Asset Progress', assetacc/instance.assets.dlsize)
win.setProgressBar(instance.progress/instance.totaldlsize)
//console.log('Total Progress', instance.progress/instance.totaldlsize)
})
writeStream.on('close', cb)
}, function(err){
if(err){
instance.emit('asseterr')
console.log('An asset failed to process');
} else {
instance.emit('assetdone')
console.log('All assets have been processed successfully')
}
instance.totaldlsize -= instance.assets.dlsize
instance.assets = new DLTracker([], 0)
win.setProgressBar(-1)
})
let shouldFire = true
//Start library download
let libacc = 0
const concurrentLibraryDlQueue = instance.libraries.dlqueue.slice(0)
async.eachLimit(concurrentLibraryDlQueue, 1, function(lib, cb){
mkpath.sync(path.join(lib.to, '..'))
let req = request(lib.from)
let writeStream = fs.createWriteStream(lib.to)
req.pipe(writeStream)
for(let i=0; i<identifiers.length; i++){
let iden = identifiers[i]
let r = startAsyncProcess(iden.id, iden.limit)
if(r) shouldFire = false
}
req.on('data', function(chunk){
instance.progress += chunk.length
libacc += chunk.length
instance.emit('librarydata', libacc)
console.log('Library Progress', libacc/instance.libraries.dlsize)
win.setProgressBar(instance.progress/instance.totaldlsize)
})
writeStream.on('close', cb)
}, function(err){
if(err){
instance.emit('libraryerr')
console.log('A library failed to process');
} else {
instance.emit('librarydone')
console.log('All libraries have been processed successfully');
}
instance.totaldlsize -= instance.libraries.dlsize
instance.libraries = new DLTracker([], 0)
win.setProgressBar(-1)
})
if(shouldFire){
instance.emit('dlcomplete')
}
}
module.exports = {
loadVersionData,
validateAssets,
validateLibraries,
runQueue,
instance
validateMiscellaneous,
processDlQueues,
instance,
Asset,
Library
}

14
app/assets/js/launchprocess.js
View File

@ -2,18 +2,17 @@ const mojang = require('mojang')
const uuidV4 = require('uuid/v4')
const path = require('path')
const child_process = require('child_process')
const library = require('./library.js')
const ag = require('./assetguard.js')
const fs = require('fs')
const unzip = require('unzip')
const mkpath = require('mkdirp');
exports.launchMinecraft = function(versionData, basePath){
launchMinecraft = function(versionData, basePath){
const authPromise = mojang.auth('EMAIL', 'PASS', uuidV4(), {
name: 'Minecraft',
version: 1
})
authPromise.then(function(data){
const hardcodedargs = ''
const args = finalizeArguments(versionData, data, basePath)
//TODO make this dynamic
const child = child_process.spawn('C:\\Program Files\\Java\\jre1.8.0_131\\bin\\javaw.exe', args)
@ -22,7 +21,6 @@ exports.launchMinecraft = function(versionData, basePath){
finalizeArguments = function(versionData, authData, basePath){
const mcArgs = versionData['minecraftArguments']
console.log(authData)
const gameProfile = authData['selectedProfile']
const regex = new RegExp('\\${*(.*)}')
const argArr = mcArgs.split(' ')
@ -82,7 +80,7 @@ classpathArg = function(versionData, basePath){
const version = versionData['id']
const cpArgs = [path.join(basePath, 'versions', version, version + '.jar')]
libArr.forEach(function(lib){
if(library.validateRules(lib['rules'])){
if(ag.Library.validateRules(lib['rules'])){
if(lib['natives'] == null){
const dlInfo = lib['downloads']
const artifact = dlInfo['artifact']
@ -93,7 +91,7 @@ classpathArg = function(versionData, basePath){
const natives = lib['natives']
const extractInst = lib['extract']
const exclusionArr = extractInst['exclude']
const opSys = library.mojangFriendlyOS()
const opSys = ag.Library.mojangFriendlyOS()
const indexId = natives[opSys]
const dlInfo = lib['downloads']
const classifiers = dlInfo['classifiers']
@ -131,4 +129,8 @@ classpathArg = function(versionData, basePath){
})
return cpArgs.join(';')
}
module.exports = {
launchMinecraft
}

8
app/assets/js/script.js
View File

@ -12,13 +12,19 @@ $(document).on('click', 'a[href^="http"]', function(event) {
testdownloads = async function(){
const ag = require(path.join(__dirname, 'assets', 'js', 'assetguard.js'))
const lp = require(path.join(__dirname, 'assets', 'js', 'launchprocess.js'))
const basePath = path.join(__dirname, '..', 'mcfiles')
let versionData = await ag.loadVersionData('1.11.2', basePath)
await ag.validateAssets(versionData, basePath)
console.log('assets done')
await ag.validateLibraries(versionData, basePath)
console.log('libs done')
ag.runQueue()
await ag.validateMiscellaneous(versionData, basePath)
console.log('files done')
ag.instance.on('dlcomplete', function(){
lp.launchMinecraft(versionData, basePath)
})
ag.processDlQueues()
}
/*Opens DevTools window if you type "wcdev" in sequence.