2.1.17

.gitlab-ci.yml

@@ -12,6 +12,9 @@ stages:
   - release
   - metadata
 
+before_script:
+  - npm install -g @shipzone/npmci
+
 # ====================
 # security stage
 # ====================
@@ -36,6 +39,7 @@ auditProductionDependencies:
     - npmci command npm audit --audit-level=high --only=prod --production
   tags:
     - docker
+  allow_failure: true
 
 auditDevDependencies:
   image: registry.gitlab.com/hosttoday/ht-docker-node:npmci

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
-      "type": "node",
+      "command": "npm test",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
+      "type": "node-terminal"
     }
   ]
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/taskbuffer",
-  "version": "2.1.7",
+  "version": "2.1.17",
   "private": false,
   "description": "flexible task management. TypeScript ready!",
   "main": "dist_ts/index.js",
@@ -27,20 +27,20 @@
   },
   "homepage": "https://gitlab.com/pushrocks/taskbuffer#readme",
   "dependencies": {
-    "@pushrocks/lik": "^4.0.17",
-    "@pushrocks/smartdelay": "^2.0.10",
-    "@pushrocks/smartlog": "^2.0.36",
-    "@pushrocks/smartpromise": "^3.0.6",
-    "@pushrocks/smartrx": "^2.0.18",
-    "@pushrocks/smarttime": "^3.0.24",
-    "@types/cron": "^1.7.2"
+    "@pushrocks/lik": "^5.0.0",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartlog": "^2.0.44",
+    "@pushrocks/smartpromise": "^3.1.6",
+    "@pushrocks/smartrx": "^2.0.19",
+    "@pushrocks/smarttime": "^3.0.43",
+    "@types/cron": "^1.7.3"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tsbundle": "^1.0.78",
-    "@gitzone/tstest": "^1.0.44",
-    "@pushrocks/tapbundle": "^3.2.9",
-    "@types/node": "^14.6.2",
+    "@gitzone/tsbuild": "^2.1.28",
+    "@gitzone/tsbundle": "^1.0.88",
+    "@gitzone/tstest": "^1.0.60",
+    "@pushrocks/tapbundle": "^3.2.14",
+    "@types/node": "^16.11.7",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },

test/test.4.taskmanager.both.ts

@@ -18,8 +18,10 @@ tap.test('should run the task as expected', async () => {
   myTaskManager.addTask(
     new taskbuffer.Task({
       name: 'myTask',
+      bufferMax: 1,
+      buffered: true,
       taskFunction: async () => {
-        console.log('Task executed!');
+        console.log('Task "myTask" executed!');
         referenceBoolean = true;
         taskRunCounter++;
         if (taskRunCounter === 10) {
@@ -35,7 +37,7 @@ tap.test('should run the task as expected', async () => {
 });
 
 tap.test('should schedule task', async () => {
-  myTaskManager.scheduleTaskByName('myTask', '* * * * * *');
+  myTaskManager.scheduleTaskByName('myTask', '*/10 * * * * *');
   await taskDone.promise;
   myTaskManager.descheduleTaskByName('myTask');
 });

test/test.4.taskmanager.ts

@@ -1,47 +0,0 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import taskbuffer = require('../ts/index');
-
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartdelay from '@pushrocks/smartdelay';
-
-let myTaskManager: taskbuffer.TaskManager;
-let taskRunCounter = 0;
-const taskDone = smartpromise.defer();
-
-tap.test('should create an instance of TaskManager', async () => {
-  myTaskManager = new taskbuffer.TaskManager();
-  expect(myTaskManager).to.be.instanceof(taskbuffer.TaskManager);
-});
-
-tap.test('should run the task as expected', async () => {
-  let referenceBoolean = false;
-  myTaskManager.addTask(
-    new taskbuffer.Task({
-      name: 'myTask',
-      taskFunction: async () => {
-        console.log('Task executed!');
-        referenceBoolean = true;
-        taskRunCounter++;
-        if (taskRunCounter === 10) {
-          taskDone.resolve();
-        }
-      },
-    })
-  );
-  myTaskManager.start();
-  await myTaskManager.triggerTaskByName('myTask');
-  // tslint:disable-next-line:no-unused-expression
-  expect(referenceBoolean).to.be.true;
-});
-
-tap.test('should schedule task', async () => {
-  myTaskManager.scheduleTaskByName('myTask', '* * * * * *');
-  await taskDone.promise;
-  myTaskManager.descheduleTaskByName('myTask');
-});
-
-tap.test('should stop the taskmanager', async () => {
-  myTaskManager.stop();
-});
-
-tap.start();

test/test.8.bufferedrun.ts

@@ -0,0 +1,52 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+
+import * as taskbuffer from '../ts';
+
+let counter1 = 0;
+let counter2 = 0;
+let counter3 = 0;
+
+tap.test('should run buffered', async (tools) => {
+  const task = new taskbuffer.Task({
+    name: 'a buffered task',
+    taskFunction: async () => {
+      counter1++;
+      await tools.delayFor(2000);
+      console.log(`task 1 ran ${counter1} times`);
+    },
+    buffered: true,
+    bufferMax: 1,
+    afterTask: () => {
+      return task2;
+    },
+  });
+  const task2 = new taskbuffer.Task({
+    name: 'a buffered task',
+    taskFunction: async () => {
+      counter2++;
+      await tools.delayFor(2000);
+      console.log(`task2 ran ${counter2} times`);
+    },
+    buffered: true,
+    bufferMax: 1,
+    afterTask: () => {
+      return task3;
+    },
+  });
+  const task3 = new taskbuffer.Task({
+    name: 'a buffered task',
+    taskFunction: async () => {
+      counter3++;
+      await tools.delayFor(2000);
+      console.log(`task3 ran ${counter3} times`);
+    },
+    buffered: true,
+    bufferMax: 1,
+  });
+  while (counter1 < 10) {
+    await tools.delayFor(5000);
+    task.trigger();
+  }
+});
+
+tap.start();

ts/taskbuffer.classes.bufferrunner.ts

@@ -4,36 +4,33 @@ export class BufferRunner {
   public task: Task;
   // initialze by default
   public bufferCounter: number = 0;
-  public running: boolean = false;
   constructor(taskArg: Task) {
     this.task = taskArg;
   }
 
-  public trigger(x): Promise<any> {
+  public trigger(x: any): Promise<any> {
     if (!(this.bufferCounter >= this.task.bufferMax)) {
       this.bufferCounter++;
     }
     const returnPromise: Promise<any> = this.task.cycleCounter.getPromiseForCycle(
       this.bufferCounter + 1
     );
-    if (!this.running) {
+    if (!this.task.running) {
       this._run(x);
     }
     return returnPromise;
   }
 
-  private _run(x) {
-    const recursiveBufferRunner = (x) => {
+  private _run(x: any) {
+    const recursiveBufferRunner = (x: any) => {
       if (this.bufferCounter >= 0) {
-        this.running = true;
         this.task.running = true;
         Task.runTask(this.task, { x: x }).then((x) => {
-          this.bufferCounter--;
+          this.bufferCounter--; // this.bufferCounter drops below 0, the recursion stops.
           this.task.cycleCounter.informOfCycle(x);
           recursiveBufferRunner(x);
         });
       } else {
-        this.running = false;
         this.task.running = false;
       }
     };

ts/taskbuffer.classes.cyclecounter.ts

@@ -21,7 +21,7 @@ export class CycleCounter {
     this.cycleObjectArray.push(cycleObject);
     return done.promise;
   }
-  public informOfCycle(x) {
+  public informOfCycle(x: any) {
     const newCycleObjectArray: ICycleObject[] = [];
     this.cycleObjectArray.forEach((cycleObjectArg) => {
       cycleObjectArg.cycleCounter--;

ts/taskbuffer.classes.task.ts

@@ -56,8 +56,9 @@ export class Task {
 
   public static runTask = async (
     taskArg: Task | TPreOrAfterTaskFunction,
-    optionsArg: { x?; touchedTasksArray?: Task[] }
+    optionsArg: { x?: any; touchedTasksArray?: Task[] }
   ) => {
+    // extracts the task in case it is specified as a return value of a function
     const taskToRun = Task.extractTask(taskArg);
     const done = plugins.smartpromise.defer();
 
@@ -125,7 +126,7 @@ export class Task {
   };
 
   // INSTANCE
-  // man datory properties
+  // mandatory properties
   public name: string;
   public taskFunction: ITaskFunction;
   public buffered: boolean;
@@ -190,7 +191,7 @@ export class Task {
   /**
    * trigger the task. Will trigger buffered if this.buffered is true
    */
-  public trigger(x?): Promise<any> {
+  public trigger(x?: any): Promise<any> {
     if (this.buffered) {
       return this.triggerBuffered(x);
     } else {
@@ -202,15 +203,15 @@ export class Task {
    * trigger task unbuffered.
    * will actually run the task, not considering any buffered limits.
    */
-  public triggerUnBuffered(x?): Promise<any> {
+  public triggerUnBuffered(x?: any): Promise<any> {
     return Task.runTask(this, { x: x });
   }
 
   /**
    * trigger task buffered.
-   * will simply call task.trigger(), which respects buffering by default
+   * note: .trigger() also calls this function
    */
-  public triggerBuffered(x?): Promise<any> {
+  public triggerBuffered(x?: any): Promise<any> {
     return this.bufferRunner.trigger(x);
   }
 

ts/taskbuffer.classes.taskchain.ts

@@ -25,7 +25,7 @@ export class Taskchain extends Task {
           // this is the function that gets executed when TaskChain is triggered
           const done = plugins.smartpromise.defer(); // this is the starting Deferred object
           let taskCounter = 0; // counter for iterating async over the taskArray
-          const iterateTasks = (x) => {
+          const iterateTasks = (x: any) => {
             if (typeof this.taskArray[taskCounter] !== 'undefined') {
               console.log(this.name + ' running: Task' + this.taskArray[taskCounter].name);
               this.taskArray[taskCounter].trigger(x).then((x) => {

ts/taskbuffer.classes.taskmanager.ts

@@ -20,8 +20,8 @@ export class TaskManager {
    * checks if a task is already present
    * @param taskNameArg
    */
-  public getTaskByName(taskNameArg): Task {
-    return this.taskMap.find((itemArg) => {
+  public getTaskByName(taskNameArg: string): Task {
+    return this.taskMap.findSync((itemArg) => {
       return itemArg.name === taskNameArg;
     });
   }
@@ -70,7 +70,15 @@ export class TaskManager {
   public scheduleTaskByName(taskNameArg: string, cronStringArg: string) {
     const taskToSchedule = this.getTaskByName(taskNameArg);
     const cronJob = this.cronJobManager.addCronjob(cronStringArg, async () => {
-      await taskToSchedule.triggerBuffered();
+      console.log(`taskbuffer schedule triggered task >>${taskToSchedule.name}<<`);
+      console.log(
+        `task >>${taskToSchedule.name}<< is ${
+          taskToSchedule.buffered
+            ? `buffered with max ${taskToSchedule.bufferMax} buffered calls`
+            : `unbuffered`
+        }`
+      );
+      await taskToSchedule.trigger();
     });
     taskToSchedule.cronJob = cronJob;
   }