You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
428 lines
16 KiB
428 lines
16 KiB
'use strict';
|
|
|
|
function JobManager(agent) {
|
|
this.agent = agent;
|
|
this.jobs = {
|
|
id:{},
|
|
type:{
|
|
open:{},
|
|
closed:{}
|
|
}
|
|
};
|
|
this.openJobs = {};
|
|
}
|
|
|
|
JobManager.prototype.add = function(id, type, time, prerequisites) {
|
|
var me = this;
|
|
|
|
// create job agent. This agent will keep track of the global job stats. Jobs per type.
|
|
this.agent.rpc.request('jobAgentGenerator',{method:'createJob', params:{type:type}}).done();
|
|
|
|
this.jobs.id[id] = {
|
|
type: type,
|
|
startTime: time,
|
|
prediction: null,
|
|
predictionCounter: 0,
|
|
elapsedTime: 0,
|
|
elapsedTimeWithPause: 0,
|
|
pauseCount: 0,
|
|
endOfDay: false,
|
|
paused: false,
|
|
pauseAreaID: ""
|
|
};
|
|
|
|
// assign agent to job.
|
|
this.agent.rpc.request(type, {method:'add', params:{
|
|
agentId: this.agent.id,
|
|
time:time,
|
|
jobId: id,
|
|
prerequisites: prerequisites
|
|
}})
|
|
.done(function (prediction) {
|
|
if (prediction.duration.mean != 0) {
|
|
me.agent.timelineDataset.update({
|
|
id: id + "_predMean0",
|
|
start: time,
|
|
end: new Date(time).getTime() + prediction.duration.mean,
|
|
group: me.agent.id,
|
|
type: 'range',
|
|
content: "",
|
|
subgroup: me.agent.usedSubgroups[type],
|
|
className: 'prediction'
|
|
});
|
|
}
|
|
me.jobs.id[id].prediction = prediction;
|
|
});
|
|
|
|
if (this.jobs.type.open[type] === undefined) {this.jobs.type.open[type] = {}}
|
|
this.jobs.type.open[type][id] = time;
|
|
this.openJobs[id] = this.jobs.id[id];
|
|
|
|
|
|
var addQuery = [{id:id, start:time, content:"started: "+ type, group:this.agent.id, subgroup: this.agent.usedSubgroups[type]}];
|
|
this.agent.timelineDataset.add(addQuery);
|
|
this.agent.rpc.request("agentGenerator", {method: 'updateOpenJobs', params:{jobId: id, time: time}}).done();
|
|
};
|
|
|
|
JobManager.prototype.finish = function(id, type, time) {
|
|
var me = this;
|
|
// finish the job.
|
|
this.agent.rpc.request(type, {method:'finish', params:{
|
|
agentId: this.agent.id,
|
|
time: time,
|
|
jobId: id
|
|
}})
|
|
.done(function (reply) {
|
|
var prediction = reply.prediction;
|
|
var originalPrediction = me.jobs.id[id].prediction;
|
|
me.jobs.id[id].elapsedTime = reply.elapsedTime;
|
|
me.jobs.id[id].elapsedTimeWithPause = reply.elapsedTimeWithPause;
|
|
me.updateDataSetsFinish(id, type, time, me.jobs.id[id].prediction);
|
|
|
|
graph2dDataset.push({x: time, y: reply.duration.duration/3600000 ,group: type + '_duration', type: type});
|
|
graph2dDataset.push({x: time, y: reply.duration.durationWithPause/3600000 ,group: type + '_durationWithPause', type: type});
|
|
graph2dDataset.push({x: time, y: reply.duration.durationWithStartup/3600000 ,group: type + '_durationWithStartup', type: type});
|
|
graph2dDataset.push({x: time, y: reply.duration.durationWithBoth/3600000 ,group: type + '_durationWithBoth', type: type});
|
|
graph2dDataset.push({x: time, y: prediction.duration.mean/3600000 ,group: type + '_pred_duration', type: type});
|
|
graph2dDataset.push({x: time, y: prediction.durationWithPause.mean/3600000 ,group: type + '_pred_durationWithPause', type: type});
|
|
graph2dDataset.push({x: time, y: prediction.durationWithStartup.mean/3600000 ,group: type + '_pred_durationWithStartup', type: type});
|
|
graph2dDataset.push({x: time, y: prediction.durationWithBoth.mean/3600000 ,group: type + '_pred_durationWithBoth', type: type});
|
|
graph2dDataset.push({x: time, y: (prediction.duration.mean + prediction.duration.std)/3600000 ,group: type + '_pred_duration_std_higher', type: type});
|
|
graph2dDataset.push({x: time, y: (prediction.durationWithPause.mean + prediction.durationWithPause.std)/3600000 ,group: type + '_pred_durationWithPause_std_higher', type: type});
|
|
graph2dDataset.push({x: time, y: (prediction.durationWithStartup.mean + prediction.durationWithStartup.std)/3600000 ,group: type + '_pred_durationWithStartup_std_higher', type: type});
|
|
graph2dDataset.push({x: time, y: (prediction.durationWithBoth.mean + prediction.durationWithBoth.std)/3600000 ,group: type + '_pred_durationWithBoth_std_higher', type: type});
|
|
graph2dDataset.push({x: time, y: (prediction.duration.mean - prediction.duration.std)/3600000 ,group: type + '_pred_duration_std_lower', type: type});
|
|
graph2dDataset.push({x: time, y: (prediction.durationWithPause.mean - prediction.durationWithPause.std)/3600000 ,group: type + '_pred_durationWithPause_std_lower', type: type});
|
|
graph2dDataset.push({x: time, y: (prediction.durationWithStartup.mean - prediction.durationWithStartup.std)/3600000 ,group: type + '_pred_durationWithStartup_std_lower', type: type});
|
|
graph2dDataset.push({x: time, y: (prediction.durationWithBoth.mean - prediction.durationWithBoth.std)/3600000 ,group: type + '_pred_durationWithBoth_std_lower', type: type});
|
|
graph2dDataset.push({x: time, y: originalPrediction.duration.mean/3600000 ,group: type + '_pred_duration_original', type: type});
|
|
graph2dDataset.push({x: time, y: originalPrediction.durationWithPause.mean/3600000 ,group: type + '_pred_durationWithPause_original', type: type});
|
|
graph2dDataset.push({x: time, y: originalPrediction.durationWithStartup.mean/3600000 ,group: type + '_pred_durationWithStartup_original', type: type});
|
|
graph2dDataset.push({x: time, y: originalPrediction.durationWithBoth.mean/3600000 ,group: type + '_pred_durationWithBoth_original', type: type});
|
|
});
|
|
|
|
delete this.jobs.type.open[type][id];
|
|
delete this.openJobs[id];
|
|
if (this.jobs.type.closed[type] === undefined) {this.jobs.type.closed[type] = {}}
|
|
this.jobs.type.closed[type][id] = time;
|
|
};
|
|
|
|
JobManager.prototype.update = function(id, type, time, operation) {
|
|
var me = this;
|
|
var eventId = uuid();
|
|
if (operation == 'endOfDay' || operation == 'startOfDay') {
|
|
for (var jobId in this.openJobs) {
|
|
if (this.openJobs.hasOwnProperty(jobId)) {
|
|
var type = this.openJobs[jobId].type;
|
|
this.agent.rpc.request(type, {method:'update', params:{
|
|
agentId: this.agent.id,
|
|
time: time,
|
|
jobId: jobId,
|
|
operation: operation
|
|
}})
|
|
.done(function (reply) {
|
|
me.jobs.id[reply.jobId].elapsedTime = reply.elapsedTime;
|
|
me.jobs.id[reply.jobId].elapsedTimeWithPause = reply.elapsedTimeWithPause;
|
|
me.updateDataSetsOperation(reply.jobId, reply.type, time, operation, eventId);
|
|
});
|
|
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
this.agent.rpc.request(type, {method:'update', params:{
|
|
agentId: this.agent.id,
|
|
time: time,
|
|
jobId: id,
|
|
operation: operation
|
|
}})
|
|
.done(function (reply) {
|
|
me.jobs.id[id].elapsedTime = reply.elapsedTime;
|
|
me.jobs.id[id].elapsedTimeWithPause = reply.elapsedTimeWithPause;
|
|
me.updateDataSetsOperation(id, type, time, operation, eventId);
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
JobManager.prototype.updateDataSetsOperation = function(id, type, time, operation, eventId) {
|
|
switch (operation) {
|
|
case 'pause':
|
|
this.updateDataSetsPause(id, type, time, operation, this.jobs.id[id].prediction, eventId);
|
|
break;
|
|
case 'endOfDay':
|
|
this.updateDataSetsPause(id, type, time, operation, this.jobs.id[id].prediction, eventId);
|
|
break;
|
|
case 'startOfDay':
|
|
this.updateDataSetsResume(id, type, time, operation, this.jobs.id[id].prediction, eventId);
|
|
break;
|
|
case 'resume':
|
|
this.updateDataSetsResume(id, type, time, operation, this.jobs.id[id].prediction, eventId);
|
|
break;
|
|
}
|
|
};
|
|
|
|
JobManager.prototype.updateDataSetsFinish = function(id, type, time, prediction) {
|
|
var updateQuery = [];
|
|
var field = 'duration';
|
|
var elapsedTime = this.jobs.id[id].elapsedTime;
|
|
|
|
// gather statistic indicator data
|
|
if (this.jobs.id[id].pauseCount > 0) {
|
|
field = 'durationWithPause';
|
|
elapsedTime = this.jobs.id[id].elapsedTimeWithPause;
|
|
}
|
|
|
|
// generate indicator
|
|
var predictedTimeLeft = 0;
|
|
if (prediction[field].mean != 0) {
|
|
predictedTimeLeft = prediction[field].mean - elapsedTime;
|
|
this.updatePredictionOnFinish(id, type, time, prediction[field], elapsedTime);
|
|
}
|
|
|
|
updateQuery.push({
|
|
id: id,
|
|
end: time,
|
|
content: type,
|
|
type: 'range',
|
|
className: 'finished',
|
|
style: 'background-color: ' + this.generateColors(predictedTimeLeft, elapsedTime) + ' !important;'
|
|
});
|
|
|
|
this.agent.freeSubgroup(type);
|
|
this.agent.timelineDataset.update(updateQuery);
|
|
this.agent.rpc.request("agentGenerator", {method: 'updateOpenJobs', params:{jobId: id, time: time}}).done();
|
|
};
|
|
|
|
JobManager.prototype.updateDataSetsPause = function(id, type, time, operation, prediction, eventId) {
|
|
var updateQuery = [];
|
|
var image = '<img src="./images/control_pause.png" class="icon"/>';
|
|
var flagId = id + "_pauseNotifier" + eventId;
|
|
var title = 'Calling RAO for possible NC';
|
|
|
|
// this causes there to be only one flag for the end of day as well as a moon icon
|
|
if (operation == 'endOfDay') {
|
|
// don't end-of-day jobs twice
|
|
if (this.jobs.id[id].endOfDay == true) {
|
|
return;
|
|
}
|
|
this.jobs.id[id].endOfDay = true;
|
|
image = '<img src="./images/moon.png" class="icon"/>';
|
|
flagId = id + "endOfDayNotifier" + eventId;
|
|
title = "End of working day"
|
|
}
|
|
else {
|
|
this.jobs.id[id].pauseCount += 1;
|
|
this.jobs.id[id].pauseAreaID = this.agent.id + "_" + "_pauseArea_" + eventId;
|
|
var shadedPauseArea = {
|
|
id: this.jobs.id[id].pauseAreaID,
|
|
start: time,
|
|
end: time,
|
|
content: '',
|
|
group: this.agent.id,
|
|
subgroup: this.agent.usedSubgroups[type],
|
|
className: 'pausedArea',
|
|
title: 'Job paused.'
|
|
};
|
|
updateQuery.push(shadedPauseArea);
|
|
}
|
|
|
|
var field = 'duration';
|
|
var elapsedTime = this.jobs.id[id].elapsedTime;
|
|
if (this.jobs.id[id].pauseCount > 0) {
|
|
field = 'durationWithPause';
|
|
elapsedTime = this.jobs.id[id].elapsedTimeWithPause;
|
|
}
|
|
|
|
updateQuery.push({id: id, end: time, content: type, type: 'range'});
|
|
var imageUpdate = {
|
|
id: flagId,
|
|
start: time,
|
|
end: time,
|
|
content: image,
|
|
group: this.agent.id,
|
|
subgroup: this.agent.usedSubgroups[type],
|
|
className: 'pause',
|
|
title: title
|
|
};
|
|
|
|
|
|
if (this.agent.id == "Paolo") {
|
|
imageUpdate.title = "Going to inspect possible NC.";
|
|
}
|
|
updateQuery.push(imageUpdate);
|
|
|
|
var predictedTimeLeft = prediction[field].mean - elapsedTime;
|
|
var predictionExists = prediction[field].mean != 0;
|
|
|
|
// update the predicted line if the job is not ALREADY pauseds
|
|
if (predictedTimeLeft > 0 && predictionExists == true && this.jobs.id[id].paused != true) {
|
|
updateQuery.push({
|
|
id: id + "_predMean" + this.jobs.id[id].predictionCounter,
|
|
end: time,
|
|
group: this.agent.id,
|
|
className: 'prediction'
|
|
})
|
|
}
|
|
|
|
// set the status to paused if needed
|
|
if (operation != 'endOfDay') {
|
|
this.jobs.id[id].paused = true;
|
|
}
|
|
this.agent.timelineDataset.update(updateQuery);
|
|
this.agent.rpc.request("agentGenerator", {method: 'updateOpenJobs', params:{jobId: id, time: time}})
|
|
};
|
|
|
|
JobManager.prototype.updateDataSetsResume = function(id, type, time, operation, prediction, eventId) {
|
|
var updateQuery = [];
|
|
var image = '<img src="./images/control_play.png" class="icon"/>';
|
|
var flagId = id + "_resumeNotifier" + eventId;
|
|
|
|
// this causes there to be only one flag for the start of day as well as a sun icon
|
|
if (operation == 'startOfDay') {
|
|
// don't start-of-day jobs twice
|
|
if (this.jobs.id[id].endOfDay == false) {
|
|
return;
|
|
}
|
|
this.jobs.id[id].endOfDay = false;
|
|
image = '<img src="./images/sun.png" class="icon"/>';
|
|
flagId = id + "startOfDayNotifier_" + eventId;
|
|
}
|
|
else {
|
|
updateQuery.push({id: this.jobs.id[id].pauseAreaID, end: time, content: '', type: 'range'});
|
|
this.jobs.id[id].pauseAreaID = "";
|
|
this.jobs.id[id].pauseCount += 1;
|
|
}
|
|
|
|
var field = 'duration';
|
|
var elapsedTime = this.jobs.id[id].elapsedTime;
|
|
if (this.jobs.id[id].pauseCount > 0) {
|
|
field = 'durationWithPause';
|
|
elapsedTime = this.jobs.id[id].elapsedTimeWithPause;
|
|
}
|
|
|
|
updateQuery.push({id: id, end: time, content: type, type: 'range'});
|
|
updateQuery.push({
|
|
id: flagId,
|
|
start: time,
|
|
end: time,
|
|
content: image,
|
|
group: this.agent.id,
|
|
subgroup: this.agent.usedSubgroups[type],
|
|
className: 'pause',
|
|
title: 'Resuming job'
|
|
});
|
|
|
|
var predictedTimeLeft = prediction[field].mean - elapsedTime;
|
|
// no not increase the prediction line at the start of the day if the job is PAUSED
|
|
if (predictedTimeLeft > 0 && !(operation == 'startOfDay' && this.jobs.id[id].paused == true)) {
|
|
this.jobs.id[id].predictionCounter += 1;
|
|
updateQuery.push({
|
|
id: id + "_predMean" + this.jobs.id[id].predictionCounter,
|
|
start: time,
|
|
end: new Date(time).getTime() + predictedTimeLeft,
|
|
group: this.agent.id,
|
|
content: "",
|
|
subgroup: this.agent.usedSubgroups[type],
|
|
type: 'range',
|
|
className: 'prediction'
|
|
});
|
|
}
|
|
|
|
// resume if needed
|
|
if (operation != 'startOfDay'){
|
|
this.jobs.id[id].paused = false;
|
|
}
|
|
this.agent.timelineDataset.update(updateQuery);
|
|
this.agent.rpc.request("agentGenerator", {method: 'updateOpenJobs', params:{jobId: id, time: time}})
|
|
};
|
|
|
|
JobManager.prototype.updatePredictionOnFinish = function(id,type,time,prediction,elapsedTime) {
|
|
if (prediction.mean != 0) {
|
|
var predictedTimeLeft = prediction.mean - elapsedTime;
|
|
if (predictedTimeLeft > 0) {
|
|
this.agent.timelineDataset.remove({id: id + "_predMean" + this.jobs.id[id].predictionCounter})
|
|
}
|
|
}
|
|
};
|
|
|
|
JobManager.prototype.updateJobs = function(time, skipId) {
|
|
var updateQuery = [];
|
|
for (var jobId in this.openJobs) {
|
|
if (this.openJobs.hasOwnProperty(jobId) && jobId != skipId) {
|
|
var type = this.openJobs[jobId].type;
|
|
var prediction = this.openJobs[jobId].prediction;
|
|
var predictedTimeLeft = 0;
|
|
// never been paused before
|
|
if (this.jobs.id[jobId].pauseCount == 0) {
|
|
if (prediction !== null && prediction.duration !== null) {
|
|
predictedTimeLeft = prediction.duration.mean - this.jobs.id[jobId].elapsedTime;
|
|
}
|
|
}
|
|
else {
|
|
if (prediction !== null && prediction.durationWithPause !== null) {
|
|
predictedTimeLeft = prediction.durationWithPause.mean - this.jobs.id[jobId].elapsedTimeWithPause;
|
|
}
|
|
}
|
|
updateQuery.push({id: jobId, end: time, content: type, type: 'range'});
|
|
if (this.openJobs[jobId].paused == true) {
|
|
updateQuery.push({id: this.openJobs[jobId].pauseAreaID, end: time});
|
|
}
|
|
}
|
|
}
|
|
|
|
this.agent.timelineDataset.update(updateQuery);
|
|
};
|
|
|
|
|
|
JobManager.prototype.generateColors = function(predictedTime, elapsedTime) {
|
|
var ratio = (elapsedTime + predictedTime) / elapsedTime;
|
|
if (ratio > 1) {
|
|
ratio = Math.min(2,ratio) - 1; // 2 -- 1
|
|
var rgb = HSVToRGB(94/360,ratio*0.6 + 0.2,1);
|
|
}
|
|
else {
|
|
ratio = Math.max(0.5,ratio) - 0.5; // 1 -- 0.5
|
|
var rgb = HSVToRGB(40/360,(1-(2*ratio))*0.6 + 0.1 ,1);
|
|
}
|
|
return "rgb(" + rgb.r + "," + rgb.g + "," + rgb.b + ")";
|
|
};
|
|
|
|
function HSVToRGB(h, s, v) {
|
|
var r, g, b;
|
|
|
|
var i = Math.floor(h * 6);
|
|
var f = h * 6 - i;
|
|
var p = v * (1 - s);
|
|
var q = v * (1 - f * s);
|
|
var t = v * (1 - (1 - f) * s);
|
|
|
|
switch (i % 6) {
|
|
case 0: r = v, g = t, b = p; break;
|
|
case 1: r = q, g = v, b = p; break;
|
|
case 2: r = p, g = v, b = t; break;
|
|
case 3: r = p, g = q, b = v; break;
|
|
case 4: r = t, g = p, b = v; break;
|
|
case 5: r = v, g = p, b = q; break;
|
|
}
|
|
|
|
return {r:Math.floor(r * 255), g:Math.floor(g * 255), b:Math.floor(b * 255) };
|
|
}
|
|
function RGBToHSV (red,green,blue) {
|
|
red=red/255; green=green/255; blue=blue/255;
|
|
var minRGB = Math.min(red,Math.min(green,blue));
|
|
var maxRGB = Math.max(red,Math.max(green,blue));
|
|
|
|
// Black-gray-white
|
|
if (minRGB == maxRGB) {
|
|
return {h:0,s:0,v:minRGB};
|
|
}
|
|
|
|
// Colors other than black-gray-white:
|
|
var d = (red==minRGB) ? green-blue : ((blue==minRGB) ? red-green : blue-red);
|
|
var h = (red==minRGB) ? 3 : ((blue==minRGB) ? 1 : 5);
|
|
var hue = 60*(h - d/(maxRGB - minRGB))/360;
|
|
var saturation = (maxRGB - minRGB)/maxRGB;
|
|
var value = maxRGB;
|
|
return {h:hue,s:saturation,v:value};
|
|
}
|