3.1.7

.gitea/workflows/default_tags.yaml

@@ -119,6 +119,6 @@ jobs:
         run: |
           npmci node install stable
           npmci npm install
-          pnpm install -g @gitzone/tsdoc
+          pnpm install -g @git.zone/tsdoc
           npmci command tsdoc
         continue-on-error: true

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/taskbuffer",
-  "version": "3.1.0",
+  "version": "3.1.7",
   "private": false,
   "description": "flexible task management. TypeScript ready!",
   "main": "dist_ts/index.js",
@@ -29,21 +29,21 @@
   },
   "homepage": "https://gitlab.com/pushrocks/taskbuffer#readme",
   "dependencies": {
-    "@push.rocks/isounique": "^1.0.5",
+    "@push.rocks/lik": "^6.0.5",
-    "@push.rocks/lik": "^6.0.3",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartlog": "^3.0.3",
     "@push.rocks/smartpromise": "^4.0.3",
     "@push.rocks/smartrx": "^3.0.6",
-    "@push.rocks/smarttime": "^4.0.4"
+    "@push.rocks/smarttime": "^4.0.6",
+    "@push.rocks/smartunique": "^3.0.6"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.66",
+    "@git.zone/tsbuild": "^2.1.66",
-    "@gitzone/tsbundle": "^2.0.8",
+    "@git.zone/tsbundle": "^2.0.8",
-    "@gitzone/tsrun": "^1.2.44",
+    "@git.zone/tsrun": "^1.2.44",
-    "@gitzone/tstest": "^1.0.77",
+    "@git.zone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^5.0.12",
+    "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.4.5"
+    "@types/node": "^20.8.7"
   },
   "files": [
     "ts/**/*",

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/taskbuffer',
-  version: '3.1.0',
+  version: '3.1.7',
   description: 'flexible task management. TypeScript ready!'
 }

ts/taskbuffer.classes.distributedcoordinator.ts

@@ -2,13 +2,11 @@ import { Task } from './taskbuffer.classes.task.js';
 import * as plugins from './taskbuffer.plugins.js';
 
 /**
- * constains all data for the final coordinator to actually make an informed decision
+ * Contains all data for the final coordinator to make an informed decision.
  */
 export interface IDistributedTaskRequest {
-  /**
+  submitterId: string;
-   * this needs to correlate to the consultationResult
+  requestResponseId: string;
-   */
-  submitterRandomId: string;
   taskName: string;
   taskVersion: string;
   taskExecutionTime: number;
@@ -18,24 +16,23 @@ export interface IDistributedTaskRequest {
 }
 
 export interface IDistributedTaskRequestResult {
-  /**
+  submitterId: string;
-   * this needs to correlate to the decisionInfoBasis
+  requestResponseId: string;
-   */
-  submitterRandomId: string;
-  /**
-   * can be used while debugging
-   */
   considered: boolean;
-  rank: string;
+  rank: number;
   reason: string;
   shouldTrigger: boolean;
 }
 
 export abstract class AbstractDistributedCoordinator {
   public abstract fireDistributedTaskRequest(
-    infoBasisArg: IDistributedTaskRequest
+    infoBasis: IDistributedTaskRequest
   ): Promise<IDistributedTaskRequestResult>;
+
   public abstract updateDistributedTaskRequest(
-    infoBasisArg: IDistributedTaskRequest
+    infoBasis: IDistributedTaskRequest
   ): Promise<void>;
+
+  public abstract start(): Promise<void>;
+  public abstract stop(): Promise<void>;
 }

ts/taskbuffer.classes.taskmanager.ts

@@ -1,10 +1,10 @@
 import * as plugins from './taskbuffer.plugins.js';
 import { Task } from './taskbuffer.classes.task.js';
-import { AbstractDistributedCoordinator } from './taskbuffer.classes.distributedcoordinator.js';
+import { AbstractDistributedCoordinator, type IDistributedTaskRequestResult } from './taskbuffer.classes.distributedcoordinator.js';
 
 export interface ICronJob {
   cronString: string;
-  taskNameArg: string;
+  taskName: string;
   job: any;
 }
 
@@ -13,57 +13,37 @@ export interface ITaskManagerConstructorOptions {
 }
 
 export class TaskManager {
-  public randomId = plugins.isounique.uni();
+  public randomId = plugins.smartunique.shortId();
   public taskMap = new plugins.lik.ObjectMap<Task>();
   private cronJobManager = new plugins.smarttime.CronManager();
-
   public options: ITaskManagerConstructorOptions = {
     distributedCoordinator: null,
   };
 
-  constructor(optionsArg: ITaskManagerConstructorOptions = {}) {
+  constructor(options: ITaskManagerConstructorOptions = {}) {
-    this.options = Object.assign(this.options, optionsArg);
+    this.options = Object.assign(this.options, options);
   }
 
-  /**
+  public getTaskByName(taskName: string): Task {
-   * checks if a task is already present
+    return this.taskMap.findSync((task) => task.name === taskName);
-   * @param taskNameArg
-   */
-  public getTaskByName(taskNameArg: string): Task {
-    return this.taskMap.findSync((itemArg) => {
-      return itemArg.name === taskNameArg;
-    });
   }
 
-  /**
+  public addTask(task: Task): void {
-   * adds a Task to the TaskManager
+    if (!task.name) {
-   * @param taskArg
+      throw new Error('Task must have a name to be added to taskManager');
-   */
-  public addTask(taskArg: Task): void {
-    if (!taskArg.name) {
-      throw new Error('taskArg needs a name to be added to taskManager');
     }
-    this.taskMap.add(taskArg);
+    this.taskMap.add(task);
   }
 
-  /**
+  public addAndScheduleTask(task: Task, cronString: string) {
-   * adds and schedules a task at once
+    this.addTask(task);
-   * @param taskArg
+    this.scheduleTaskByName(task.name, cronString);
-   * @param cronStringArg
-   */
-  public addAndScheduleTask(taskArg: Task, cronStringArg: string) {
-    this.addTask(taskArg);
-    this.scheduleTaskByName(taskArg.name, cronStringArg);
   }
 
-  /**
+  public async triggerTaskByName(taskName: string): Promise<any> {
-   * triggers a task in the TaskManagerByName
+    const taskToTrigger = this.getTaskByName(taskName);
-   * @param taskNameArg
-   */
-  public triggerTaskByName(taskNameArg: string): Promise<any> {
-    const taskToTrigger = this.getTaskByName(taskNameArg);
     if (!taskToTrigger) {
-      throw new Error(`There is no task with the name of ${taskNameArg}`);
+      throw new Error(`No task with the name ${taskName} found.`);
     }
     return taskToTrigger.trigger();
   }
@@ -72,96 +52,88 @@ export class TaskManager {
     return task.trigger();
   }
 
-  /**
+  public scheduleTaskByName(taskName: string, cronString: string) {
-   * schedules the task by name
+    const taskToSchedule = this.getTaskByName(taskName);
-   * @param taskNameArg
+    if (!taskToSchedule) {
-   */
+      throw new Error(`No task with the name ${taskName} found.`);
-  public scheduleTaskByName(taskNameArg: string, cronStringArg: string) {
+    }
-    const taskToSchedule = this.getTaskByName(taskNameArg);
+    this.handleTaskScheduling(taskToSchedule, cronString);
-    const cronJob = this.cronJobManager.addCronjob(
-      cronStringArg,
-      async (triggerTimeArg: number) => {
-        console.log(`taskbuffer schedule triggered task >>${taskToSchedule.name}<<`);
-        console.log(
-          `task >>${taskToSchedule.name}<< is ${
-            taskToSchedule.buffered
-              ? `buffered with max ${taskToSchedule.bufferMax} buffered calls`
-              : `unbuffered`
-          }`
-        );
-        if (this.options.distributedCoordinator) {
-          console.log(`Found a distrubuted coordinator, performing distributed consultation.`);
-          const announcementResult =
-            await this.options.distributedCoordinator.fireDistributedTaskRequest({
-              submitterRandomId: this.randomId,
-              status: 'requesting',
-              taskExecutionParallel: 1,
-              taskExecutionTime: triggerTimeArg,
-              taskExecutionTimeout: taskToSchedule.timeout,
-              taskName: taskToSchedule.name,
-              taskVersion: taskToSchedule.version,
-            });
-
-          if (!announcementResult.shouldTrigger) {
-            console.log('distributed coordinator result: NOT EXECUTING');
-            return;
-          } else {
-            console.log('distributed coordinator result: CHOSEN AND EXECUTING');
-          }
-        }
-        await taskToSchedule.trigger();
-      }
-    );
-    taskToSchedule.cronJob = cronJob;
   }
 
-  /**
+  private handleTaskScheduling(task: Task, cronString: string) {
-   * deschedules a task by name
+    const cronJob = this.cronJobManager.addCronjob(
-   * @param taskNameArg
+      cronString,
-   */
+      async (triggerTime: number) => {
-  public descheduleTaskByName(taskNameArg: string) {
+        this.logTaskState(task);
-    const taskToDeSchedule = this.getTaskByName(taskNameArg);
+        if (this.options.distributedCoordinator) {
-    if (taskToDeSchedule.cronJob) {
+          const announcementResult = await this.performDistributedConsultation(task, triggerTime);
-      this.cronJobManager.removeCronjob(taskToDeSchedule.cronJob);
+          if (!announcementResult.shouldTrigger) {
-      taskToDeSchedule.cronJob = null;
+            console.log('Distributed coordinator result: NOT EXECUTING');
+            return;
+          } else {
+            console.log('Distributed coordinator result: CHOSEN AND EXECUTING');
+          }
+        }
+        await task.trigger();
+      }
+    );
+    task.cronJob = cronJob;
+  }
+
+  private logTaskState(task: Task) {
+    console.log(`Taskbuffer schedule triggered task >>${task.name}<<`);
+    const bufferState = task.buffered
+      ? `buffered with max ${task.bufferMax} buffered calls`
+      : `unbuffered`;
+    console.log(`Task >>${task.name}<< is ${bufferState}`);
+  }
+
+  private async performDistributedConsultation(task: Task, triggerTime: number): Promise<IDistributedTaskRequestResult> {
+    console.log('Found a distributed coordinator, performing consultation.');
+
+    return this.options.distributedCoordinator.fireDistributedTaskRequest({
+      submitterId: this.randomId,
+      requestResponseId: plugins.smartunique.shortId(),
+      status: 'requesting',
+      taskExecutionParallel: 1,
+      taskExecutionTime: triggerTime,
+      taskExecutionTimeout: task.timeout,
+      taskName: task.name,
+      taskVersion: task.version,
+    });
+  }
+
+  public descheduleTaskByName(taskName: string) {
+    const task = this.getTaskByName(taskName);
+    if (task && task.cronJob) {
+      this.cronJobManager.removeCronjob(task.cronJob);
+      task.cronJob = null;
     }
     if (this.cronJobManager.cronjobs.isEmpty) {
       this.cronJobManager.stop();
     }
   }
 
-  /**
-   * deschedules a task
-   * @param task
-   */
   public async descheduleTask(task: Task) {
     await this.descheduleTaskByName(task.name);
   }
 
-  /**
+  public getScheduleForTaskName(taskName: string): string | null {
- * returns the schedule of a specific task
+    const task = this.getTaskByName(taskName);
- * @param taskNameArg
+    return task && task.cronJob ? task.cronJob.cronExpression : null;
- */
-public getScheduleForTaskName(taskNameArg: string): string | null {
-  const task = this.getTaskByName(taskNameArg);
-  if (!task || !task.cronJob) {
-    return null;
   }
-  return task.cronJob.cronExpression;
-}
 
-
+  public async start() {
-  /**
+    if (this.options.distributedCoordinator) {
-   * starts the taskmanager
+      await this.options.distributedCoordinator.start();
-   */
+    }
-  public start() {
     this.cronJobManager.start();
   }
 
-  /**
+  public async stop() {
-   * stops the taskmanager
-   */
-  public stop() {
     this.cronJobManager.stop();
+    if (this.options.distributedCoordinator) {
+      await this.options.distributedCoordinator.stop();
+    }
   }
 }

ts/taskbuffer.plugins.ts

@@ -1,9 +1,9 @@
-import * as isounique from '@push.rocks/isounique';
 import * as lik from '@push.rocks/lik';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartrx from '@push.rocks/smartrx';
 import * as smarttime from '@push.rocks/smarttime';
+import * as smartunique from '@push.rocks/smartunique';
 
-export { isounique, lik, smartlog, smartpromise, smartdelay, smartrx, smarttime };
+export { lik, smartlog, smartpromise, smartdelay, smartrx, smarttime, smartunique };

tsconfig.json

@@ -3,9 +3,12 @@
     "experimentalDecorators": true,
     "useDefineForClassFields": false,
     "target": "ES2022",
-    "module": "ES2022",
+    "module": "NodeNext",
-    "moduleResolution": "nodenext",
+    "moduleResolution": "NodeNext",
     "esModuleInterop": true,
-    "verbatimModuleSyntax": true,
+    "verbatimModuleSyntax": true
-  }
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
 }