@push.rocks/taskbuffer 3.1.1 → 3.1.3

package/dist_bundle/bundle.js

@@ -6130,136 +6130,109 @@ var AbstractDistributedCoordinator = class {
 
 // ts/taskbuffer.classes.taskmanager.ts
 var TaskManager = class {
-  constructor(optionsArg = {}) {
+  constructor(options = {}) {
     this.randomId = isounique2.uni();
     this.taskMap = new dist_ts_exports5.ObjectMap();
     this.cronJobManager = new dist_ts_exports6.CronManager();
     this.options = {
       distributedCoordinator: null
     };
-    this.options = Object.assign(this.options, optionsArg);
+    this.options = Object.assign(this.options, options);
   }
-  /**
-   * checks if a task is already present
-   * @param taskNameArg
-   */
-  getTaskByName(taskNameArg) {
-    return this.taskMap.findSync((itemArg) => {
-      return itemArg.name === taskNameArg;
-    });
+  getTaskByName(taskName) {
+    return this.taskMap.findSync((task) => task.name === taskName);
   }
-  /**
-   * adds a Task to the TaskManager
-   * @param taskArg
-   */
-  addTask(taskArg) {
-    if (!taskArg.name) {
-      throw new Error("taskArg needs a name to be added to taskManager");
+  addTask(task) {
+    if (!task.name) {
+      throw new Error("Task must have a name to be added to taskManager");
     }
-    this.taskMap.add(taskArg);
+    this.taskMap.add(task);
   }
-  /**
-   * adds and schedules a task at once
-   * @param taskArg
-   * @param cronStringArg
-   */
-  addAndScheduleTask(taskArg, cronStringArg) {
-    this.addTask(taskArg);
-    this.scheduleTaskByName(taskArg.name, cronStringArg);
+  addAndScheduleTask(task, cronString) {
+    this.addTask(task);
+    this.scheduleTaskByName(task.name, cronString);
   }
-  /**
-   * triggers a task in the TaskManagerByName
-   * @param taskNameArg
-   */
-  triggerTaskByName(taskNameArg) {
-    const taskToTrigger = this.getTaskByName(taskNameArg);
+  async triggerTaskByName(taskName) {
+    const taskToTrigger = this.getTaskByName(taskName);
     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();
   }
   async triggerTask(task) {
     return task.trigger();
   }
-  /**
-   * schedules the task by name
-   * @param taskNameArg
-   */
-  scheduleTaskByName(taskNameArg, cronStringArg) {
-    const taskToSchedule = this.getTaskByName(taskNameArg);
+  scheduleTaskByName(taskName, cronString) {
+    const taskToSchedule = this.getTaskByName(taskName);
+    if (!taskToSchedule) {
+      throw new Error(`No task with the name ${taskName} found.`);
+    }
+    this.handleTaskScheduling(taskToSchedule, cronString);
+  }
+  handleTaskScheduling(task, cronString) {
     const cronJob = this.cronJobManager.addCronjob(
-      cronStringArg,
-      async (triggerTimeArg) => {
-        console.log(`taskbuffer schedule triggered task >>${taskToSchedule.name}<<`);
-        console.log(
-          `task >>${taskToSchedule.name}<< is ${taskToSchedule.buffered ? `buffered with max ${taskToSchedule.bufferMax} buffered calls` : `unbuffered`}`
-        );
+      cronString,
+      async (triggerTime) => {
+        this.logTaskState(task);
         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
-          });
+          const announcementResult = await this.performDistributedConsultation(task, triggerTime);
           if (!announcementResult.shouldTrigger) {
-            console.log("distributed coordinator result: NOT EXECUTING");
+            console.log("Distributed coordinator result: NOT EXECUTING");
             return;
           } else {
-            console.log("distributed coordinator result: CHOSEN AND EXECUTING");
+            console.log("Distributed coordinator result: CHOSEN AND EXECUTING");
           }
         }
-        await taskToSchedule.trigger();
+        await task.trigger();
       }
     );
-    taskToSchedule.cronJob = cronJob;
+    task.cronJob = cronJob;
+  }
+  logTaskState(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}`);
+  }
+  async performDistributedConsultation(task, triggerTime) {
+    console.log("Found a distributed coordinator, performing consultation.");
+    return this.options.distributedCoordinator.fireDistributedTaskRequest({
+      submitterId: this.randomId,
+      status: "requesting",
+      taskExecutionParallel: 1,
+      taskExecutionTime: triggerTime,
+      taskExecutionTimeout: task.timeout,
+      taskName: task.name,
+      taskVersion: task.version
+    });
   }
-  /**
-   * deschedules a task by name
-   * @param taskNameArg
-   */
-  descheduleTaskByName(taskNameArg) {
-    const taskToDeSchedule = this.getTaskByName(taskNameArg);
-    if (taskToDeSchedule.cronJob) {
-      this.cronJobManager.removeCronjob(taskToDeSchedule.cronJob);
-      taskToDeSchedule.cronJob = null;
+  descheduleTaskByName(taskName) {
+    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
-   */
   async descheduleTask(task) {
     await this.descheduleTaskByName(task.name);
   }
-  /**
-  * returns the schedule of a specific task
-  * @param taskNameArg
-  */
-  getScheduleForTaskName(taskNameArg) {
-    const task = this.getTaskByName(taskNameArg);
-    if (!task || !task.cronJob) {
-      return null;
-    }
-    return task.cronJob.cronExpression;
+  getScheduleForTaskName(taskName) {
+    const task = this.getTaskByName(taskName);
+    return task && task.cronJob ? task.cronJob.cronExpression : null;
   }
-  /**
-   * starts the taskmanager
-   */
-  start() {
+  async start() {
+    if (this.options.distributedCoordinator) {
+      await this.options.distributedCoordinator.start();
+    }
     this.cronJobManager.start();
   }
-  /**
-   * stops the taskmanager
-   */
-  stop() {
+  async stop() {
     this.cronJobManager.stop();
+    if (this.options.distributedCoordinator) {
+      await this.options.distributedCoordinator.stop();
+    }
   }
 };