push.rocks/taskbuffer
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

values now flow correctly between tasks

Browse Source
This commit is contained in:
Philipp Kunz
2016-08-02 11:09:42 +02:00
parent 5dca9a9460
commit 76c57451b3
11 changed files with 199 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
ts/taskbuffer.classes.helpers.ts
View File

@ -1,7 +1,7 @@
import plugins = require("./taskbuffer.plugins");
import { Task, ITaskFunction } from "./taskbuffer.classes.task";
export let emptyTaskFunction: ITaskFunction = function () {
export let emptyTaskFunction: ITaskFunction = function (x) {
let done = plugins.Q.defer();
done.resolve();
return done.promise;
@ -29,42 +29,49 @@ export let isTaskTouched = (taskArg: Task, touchedTasksArray: Task[]): boolean =
return result;
}
export let runTask = function (taskArg: Task, optionsArg: { touchedTasksArray: Task[] } = { touchedTasksArray: [] }) {
export let runTask = function (taskArg: Task, optionsArg: {x?, touchedTasksArray?: Task[] }) {
let done = plugins.Q.defer();
// set running params
taskArg.running = true;
done.promise.then(function () { taskArg.running = false });
let localDeferred = plugins.Q.defer();
let touchedTasksArray: Task[];
if (optionsArg.touchedTasksArray) {
touchedTasksArray = optionsArg.touchedTasksArray;
} else {
touchedTasksArray = [];
}
// handle options
let options = plugins.lodash.merge(
{x:undefined,touchedTasksArray: []},
optionsArg
)
let x = options.x;
let touchedTasksArray: Task[] = options.touchedTasksArray;
touchedTasksArray.push(taskArg);
// run the task cascade
let localDeferred = plugins.Q.defer();
localDeferred.promise
.then(() => {
if (taskArg.preTask && !isTaskTouched(taskArg.preTask, touchedTasksArray)) {
return runTask(taskArg.preTask, { touchedTasksArray: touchedTasksArray })
return runTask(taskArg.preTask, {x:x, touchedTasksArray: touchedTasksArray })
} else {
let done2 = plugins.Q.defer();
done2.resolve();
done2.resolve(x);
return done2.promise;
}
})
.then(() => {
return taskArg.task();
.then(x => {
return taskArg.taskFunction(x);
})
.then(() => {
.then(x => {
if (taskArg.afterTask && !isTaskTouched(taskArg.afterTask, touchedTasksArray)) {
return runTask(taskArg.afterTask, { touchedTasksArray: touchedTasksArray })
return runTask(taskArg.afterTask, {x:x, touchedTasksArray: touchedTasksArray });
} else {
let done2 = plugins.Q.defer();
done2.resolve();
done2.resolve(x);
return done2.promise;
}
})
.then(() => {
done.resolve();
.then(x => {
done.resolve(x);
});
localDeferred.resolve();
return done.promise;
@ -114,34 +121,34 @@ export class BufferRunner {
constructor(taskArg: Task) {
this.task = taskArg;
};
private _run() {
let recursiveBufferRunner = () => {
private _run(x) {
let recursiveBufferRunner = (x) => {
if (this.bufferCounter >= 0) {
this.running = true;
this.task.running = true;
runTask(this.task)
.then(() => {
runTask(this.task,{x:x})
.then((x) => {
this.bufferCounter--;
this.task.cycleCounter.informOfCycle();
recursiveBufferRunner();
recursiveBufferRunner(x);
});
} else {
this.running = false;
this.task.running = false;
}
};
recursiveBufferRunner();
recursiveBufferRunner(x);
};
setBufferMax(bufferMaxArg:number){
this.bufferMax = bufferMaxArg;
};
trigger(): PromiseLike<any> {
trigger(x): PromiseLike<any> {
if(!(this.bufferCounter >= this.bufferMax)){
this.bufferCounter++
};
let returnPromise:PromiseLike<any> = this.task.cycleCounter.getPromiseForCycle(this.bufferCounter + 1);
if(!this.running){
this._run();
this._run(x);
}
return returnPromise;
};

24
ts/taskbuffer.classes.task.ts
View File

@ -3,12 +3,12 @@ import * as helpers from "./taskbuffer.classes.helpers"
export interface ITaskFunction {
():PromiseLike<any>;
(x?:any):PromiseLike<any>;
}
export class Task {
name:string;
task:any;
taskFunction:ITaskFunction;
buffered:boolean;
preTask:Task;
afterTask:Task;
@ -29,7 +29,7 @@ export class Task {
name?:string
}){
var options = optionsArg;
this.task = optionsArg.taskFunction;
this.taskFunction = optionsArg.taskFunction;
this.preTask = options.preTask;
this.afterTask = options.afterTask;
this.idle = !this.running;
@ -41,31 +41,27 @@ export class Task {
/**
* trigger the task. Will trigger buffered if this.buffered is true
*/
trigger(){
let done = plugins.Q.defer();
trigger(x?):PromiseLike<any> {
if(this.buffered) {
this.triggerBuffered()
.then(done.resolve);
return this.triggerBuffered(x)
}
else {
this.triggerUnBuffered()
.then(done.resolve);
return this.triggerUnBuffered(x);
};
return done.promise;
};
/**
* trigger task unbuffered.
*/
triggerUnBuffered():PromiseLike<any>{
return helpers.runTask(this);
triggerUnBuffered(x?):PromiseLike<any>{
return helpers.runTask(this,{x:x});
}
/**
* trigger task buffered.
*/
triggerBuffered():PromiseLike<any>{
return this.bufferRunner.trigger();
triggerBuffered(x?):PromiseLike<any>{
return this.bufferRunner.trigger(x);
}
get state():string {

24
ts/taskbuffer.classes.taskchain.ts
View File

@ -6,9 +6,11 @@ export class Taskchain extends Task {
taskArray:Task[];
private _oraObject:plugins.beautylog.Ora;
constructor(optionsArg:{
taskArray:Task[],
name?:string,
log?:boolean,
taskArray:Task[]
buffered?:boolean,
bufferMax?:number
}){
let options = plugins.lodash.merge(
{
@ -17,24 +19,24 @@ export class Taskchain extends Task {
},
optionsArg,
{
taskFunction: () => { // this is the function that gets executed when TaskChain is triggered
taskFunction: (x:any) => { // this is the function that gets executed when TaskChain is triggered
let done = plugins.Q.defer(); // this is the starting Deferred object
let taskCounter = 0;
let iterateTasks = () => {
let taskCounter = 0; // counter for iterating async over the taskArray
let iterateTasks = (x) => {
if(typeof this.taskArray[taskCounter] != "undefined"){
this._oraObject.text(this.name + " running: Task" + this.taskArray[taskCounter].name);
this.taskArray[taskCounter].trigger()
.then(()=>{
this.taskArray[taskCounter].trigger(x)
.then((x)=>{
plugins.beautylog.ok(this.taskArray[taskCounter].name);
taskCounter++;
iterateTasks();
iterateTasks(x);
});
} else {
this._oraObject.endOk("Taskchain \"" + this.name + "\" completed successfully");
done.resolve();
done.resolve(x);
}
};
iterateTasks();
iterateTasks(x);
return done.promise;
}
}
@ -55,8 +57,4 @@ export class Taskchain extends Task {
shiftTask(){
};
trigger(){
this._oraObject.start(this.name + " running...");
return helpers.runTask(this);
}
};