@push.rocks/taskbuffer 3.1.1 → 3.1.3

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/taskbuffer',
-    version: '3.1.1',
+    version: '3.1.3',
     description: 'flexible task management. TypeScript ready!'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDZDQUE2QztDQUMzRCxDQUFBIn0=

package/dist_ts/taskbuffer.classes.distributedcoordinator.d.ts

@@ -1,11 +1,8 @@
 /**
- * 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 {
-    /**
-     * this needs to correlate to the consultationResult
-     */
-    submitterRandomId: string;
+    submitterId: string;
     taskName: string;
     taskVersion: string;
     taskExecutionTime: number;
@@ -14,19 +11,15 @@ export interface IDistributedTaskRequest {
     status: 'requesting' | 'gotRejected' | 'failed' | 'succeeded';
 }
 export interface IDistributedTaskRequestResult {
-    /**
-     * this needs to correlate to the decisionInfoBasis
-     */
-    submitterRandomId: string;
-    /**
-     * can be used while debugging
-     */
+    submitterId: string;
     considered: boolean;
-    rank: string;
+    rank: number;
     reason: string;
     shouldTrigger: boolean;
 }
 export declare abstract class AbstractDistributedCoordinator {
-    abstract fireDistributedTaskRequest(infoBasisArg: IDistributedTaskRequest): Promise<IDistributedTaskRequestResult>;
-    abstract updateDistributedTaskRequest(infoBasisArg: IDistributedTaskRequest): Promise<void>;
+    abstract fireDistributedTaskRequest(infoBasis: IDistributedTaskRequest): Promise<IDistributedTaskRequestResult>;
+    abstract updateDistributedTaskRequest(infoBasis: IDistributedTaskRequest): Promise<void>;
+    abstract start(): Promise<void>;
+    abstract stop(): Promise<void>;
 }

package/dist_ts/taskbuffer.classes.distributedcoordinator.js

@@ -2,4 +2,4 @@ import { Task } from './taskbuffer.classes.task.js';
 import * as plugins from './taskbuffer.plugins.js';
 export class AbstractDistributedCoordinator {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLmRpc3RyaWJ1dGVkY29vcmRpbmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90YXNrYnVmZmVyLmNsYXNzZXMuZGlzdHJpYnV0ZWRjb29yZGluYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDcEQsT0FBTyxLQUFLLE9BQU8sTUFBTSx5QkFBeUIsQ0FBQztBQWdDbkQsTUFBTSxPQUFnQiw4QkFBOEI7Q0FPbkQifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza2J1ZmZlci5jbGFzc2VzLmRpc3RyaWJ1dGVkY29vcmRpbmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy90YXNrYnVmZmVyLmNsYXNzZXMuZGlzdHJpYnV0ZWRjb29yZGluYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDcEQsT0FBTyxLQUFLLE9BQU8sTUFBTSx5QkFBeUIsQ0FBQztBQXVCbkQsTUFBTSxPQUFnQiw4QkFBOEI7Q0FXbkQifQ==

package/dist_ts/taskbuffer.classes.taskmanager.d.ts

@@ -3,7 +3,7 @@ import { Task } from './taskbuffer.classes.task.js';
 import { AbstractDistributedCoordinator } from './taskbuffer.classes.distributedcoordinator.js';
 export interface ICronJob {
     cronString: string;
-    taskNameArg: string;
+    taskName: string;
     job: any;
 }
 export interface ITaskManagerConstructorOptions {
@@ -14,55 +14,19 @@ export declare class TaskManager {
     taskMap: plugins.lik.ObjectMap<Task<undefined>>;
     private cronJobManager;
     options: ITaskManagerConstructorOptions;
-    constructor(optionsArg?: ITaskManagerConstructorOptions);
-    /**
-     * checks if a task is already present
-     * @param taskNameArg
-     */
-    getTaskByName(taskNameArg: string): Task;
-    /**
-     * adds a Task to the TaskManager
-     * @param taskArg
-     */
-    addTask(taskArg: Task): void;
-    /**
-     * adds and schedules a task at once
-     * @param taskArg
-     * @param cronStringArg
-     */
-    addAndScheduleTask(taskArg: Task, cronStringArg: string): void;
-    /**
-     * triggers a task in the TaskManagerByName
-     * @param taskNameArg
-     */
-    triggerTaskByName(taskNameArg: string): Promise<any>;
+    constructor(options?: ITaskManagerConstructorOptions);
+    getTaskByName(taskName: string): Task;
+    addTask(task: Task): void;
+    addAndScheduleTask(task: Task, cronString: string): void;
+    triggerTaskByName(taskName: string): Promise<any>;
     triggerTask(task: Task): Promise<any>;
-    /**
-     * schedules the task by name
-     * @param taskNameArg
-     */
-    scheduleTaskByName(taskNameArg: string, cronStringArg: string): void;
-    /**
-     * deschedules a task by name
-     * @param taskNameArg
-     */
-    descheduleTaskByName(taskNameArg: string): void;
-    /**
-     * deschedules a task
-     * @param task
-     */
+    scheduleTaskByName(taskName: string, cronString: string): void;
+    private handleTaskScheduling;
+    private logTaskState;
+    private performDistributedConsultation;
+    descheduleTaskByName(taskName: string): void;
     descheduleTask(task: Task): Promise<void>;
-    /**
-   * returns the schedule of a specific task
-   * @param taskNameArg
-   */
-    getScheduleForTaskName(taskNameArg: string): string | null;
-    /**
-     * starts the taskmanager
-     */
-    start(): void;
-    /**
-     * stops the taskmanager
-     */
-    stop(): void;
+    getScheduleForTaskName(taskName: string): string | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
 }

package/dist_ts/taskbuffer.classes.taskmanager.js

@@ -2,134 +2,109 @@ import * as plugins from './taskbuffer.plugins.js';
 import { Task } from './taskbuffer.classes.task.js';
 import { AbstractDistributedCoordinator } from './taskbuffer.classes.distributedcoordinator.js';
 export class TaskManager {
-    constructor(optionsArg = {}) {
+    constructor(options = {}) {
         this.randomId = plugins.isounique.uni();
         this.taskMap = new plugins.lik.ObjectMap();
         this.cronJobManager = new plugins.smarttime.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);
-        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`}`);
+    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(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;
     }
-    /**
-     * 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;
+    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,
+        });
+    }
+    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();
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/taskbuffer",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "private": false,
   "description": "flexible task management. TypeScript ready!",
   "main": "dist_ts/index.js",

package/ts/00_commitinfo_data.ts

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

package/ts/taskbuffer.classes.distributedcoordinator.ts

@@ -2,13 +2,10 @@ 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 {
-  /**
-   * this needs to correlate to the consultationResult
-   */
-  submitterRandomId: string;
+  submitterId: string;
   taskName: string;
   taskVersion: string;
   taskExecutionTime: number;
@@ -18,24 +15,22 @@ export interface IDistributedTaskRequest {
 }
 
 export interface IDistributedTaskRequestResult {
-  /**
-   * this needs to correlate to the decisionInfoBasis
-   */
-  submitterRandomId: string;
-  /**
-   * can be used while debugging
-   */
+  submitterId: string;
   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>;
 }

package/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;
 }
 
@@ -16,54 +16,34 @@ export class TaskManager {
   public randomId = plugins.isounique.uni();
   public taskMap = new plugins.lik.ObjectMap<Task>();
   private cronJobManager = new plugins.smarttime.CronManager();
-
   public options: ITaskManagerConstructorOptions = {
     distributedCoordinator: null,
   };
 
-  constructor(optionsArg: ITaskManagerConstructorOptions = {}) {
-    this.options = Object.assign(this.options, optionsArg);
+  constructor(options: ITaskManagerConstructorOptions = {}) {
+    this.options = Object.assign(this.options, options);
   }
 
-  /**
-   * checks if a task is already present
-   * @param taskNameArg
-   */
-  public getTaskByName(taskNameArg: string): Task {
-    return this.taskMap.findSync((itemArg) => {
-      return itemArg.name === taskNameArg;
-    });
+  public getTaskByName(taskName: string): Task {
+    return this.taskMap.findSync((task) => task.name === taskName);
   }
 
-  /**
-   * adds a Task to the TaskManager
-   * @param taskArg
-   */
-  public addTask(taskArg: Task): void {
-    if (!taskArg.name) {
-      throw new Error('taskArg needs a name to be added to taskManager');
+  public addTask(task: Task): void {
+    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
-   */
-  public addAndScheduleTask(taskArg: Task, cronStringArg: string) {
-    this.addTask(taskArg);
-    this.scheduleTaskByName(taskArg.name, cronStringArg);
+  public addAndScheduleTask(task: Task, cronString: string) {
+    this.addTask(task);
+    this.scheduleTaskByName(task.name, cronString);
   }
 
-  /**
-   * triggers a task in the TaskManagerByName
-   * @param taskNameArg
-   */
-  public triggerTaskByName(taskNameArg: string): Promise<any> {
-    const taskToTrigger = this.getTaskByName(taskNameArg);
+  public async triggerTaskByName(taskName: string): Promise<any> {
+    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();
   }
@@ -72,96 +52,86 @@ export class TaskManager {
     return task.trigger();
   }
 
-  /**
-   * schedules the task by name
-   * @param taskNameArg
-   */
-  public scheduleTaskByName(taskNameArg: string, cronStringArg: string) {
-    const taskToSchedule = this.getTaskByName(taskNameArg);
+  public scheduleTaskByName(taskName: string, cronString: string) {
+    const taskToSchedule = this.getTaskByName(taskName);
+    if (!taskToSchedule) {
+      throw new Error(`No task with the name ${taskName} found.`);
+    }
+    this.handleTaskScheduling(taskToSchedule, cronString);
+  }
+
+  private handleTaskScheduling(task: Task, cronString: string) {
     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`
-          }`
-        );
+      cronString,
+      async (triggerTime: number) => {
+        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;
+  }
+
+  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}`);
   }
 
-  /**
-   * deschedules a task by name
-   * @param taskNameArg
-   */
-  public descheduleTaskByName(taskNameArg: string) {
-    const taskToDeSchedule = this.getTaskByName(taskNameArg);
-    if (taskToDeSchedule.cronJob) {
-      this.cronJobManager.removeCronjob(taskToDeSchedule.cronJob);
-      taskToDeSchedule.cronJob = null;
+  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,
+      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);
   }
 
-  /**
- * returns the schedule of a specific task
- * @param taskNameArg
- */
-public getScheduleForTaskName(taskNameArg: string): string | null {
-  const task = this.getTaskByName(taskNameArg);
-  if (!task || !task.cronJob) {
-    return null;
+  public getScheduleForTaskName(taskName: string): string | null {
+    const task = this.getTaskByName(taskName);
+    return task && task.cronJob ? task.cronJob.cronExpression : null;
   }
-  return task.cronJob.cronExpression;
-}
 
-
-  /**
-   * starts the taskmanager
-   */
-  public start() {
+  public async start() {
+    if (this.options.distributedCoordinator) {
+      await this.options.distributedCoordinator.start();
+    }
     this.cronJobManager.start();
   }
 
-  /**
-   * stops the taskmanager
-   */
-  public stop() {
+  public async stop() {
     this.cronJobManager.stop();
+    if (this.options.distributedCoordinator) {
+      await this.options.distributedCoordinator.stop();
+    }
   }
 }