Class TaskManager

java.lang.Object
de.bsvrz.ars.ars.mgmt.tasks.base.TaskManager

public class TaskManager extends Object
Task-Verwaltung im Datenverteiler. Ein Task ist eine Operation, die im Hintergrund im Archivsystem ausgeführt wird, und insbesondere alte (bereits archivierte) Daten betrifft. Die laufende Archivierung von neuen Daten ist kein Task.

Diese Klasse erfüllt primär die Aufgabe, zu überwachen, welche Tasks gerade laufen, und exklusive Tasks von der Ausführung von anderen Tasks zu trennen. Exklusive Tasks werden nur ausgeführt, wenn gerade keine anderen Tasks laufen, was bei bestimmten Operationen erforderlich ist. Tasks, die z. B. alte Archivverzeichnisse löschen oder anderweitig strukturell verändern dürfen nicht nebenläufig mit anderen Tasks ausgeführt werden.

Die Methoden in dieser Klassen führen Tasks aus und besitzen optional ein Task-Argument, bit dem bereits vorhandene Task-Implementierungen übergeben werden können (siehe z. B. ArchiveLongTermTaskStatePublisher.registerTask(String)). Dadurch wird der Task-Fortschritt sowohl diesem TaskManager als auch dem LongTermTaskStatePublisher bekannt gemacht.

Für temporäre, kurzzeitige Tasks kann die compute(String, TaskProducer)-Methode jedoch auch ohne Task-Argument ausgeführt werden.

Es ist wichtig, dass alle Operationen, die auf alte Archivdaten irgendwie zugreifen, als Task ausgeführt werden. Nur so ist sichergestellt, dass kein nebenläufiger exklusiver Task zwischenzeitlich Daten verändert oder löscht. Dies wird jedoch nicht im Code überprüft, da viele Operationen über mehrere Threads laufen, und so eine Zuordnung von Thread zu Task nicht trivial ist, und die Weitergabe von Task-Objekten, Zugrifftokens o.ä. den Code sehr unübersichtlich machen würde.

  • Constructor Details

    • TaskManager

      public TaskManager()
  • Method Details

    • compute

      public static <R, T extends Exception> R compute(Task task, TaskProducer<R,T> executor) throws T, InterruptedException
      Sorgt dafür, dass ein Task ausgeführt wird. Nebenläufige andere Tasks sind möglich, sofern diese nicht als exklusiver Task gestartet worden sind.
      Type Parameters:
      T - generischer Exception-Typ, der von der Funktion geworfen werden kann (wird an Aufrufer weitergegeben)
      R - Typ des Ergebnisses
      Parameters:
      task - Optional: Task-Objekt (falls ein bestehender Task genutzt werden soll)
      executor - Funktionales Interface, das die eigentliche implementierung des Tasks enthält.
      Returns:
      Ergebnis der executor-Funktion
      Throws:
      T - Fehler, die von der Funktion generiert werden, werde an den Aufrufer weitergegeben
      InterruptedException - Wenn die Funktion beim Warten auf exklusive Task-Ausführung unterbrochen wurde
    • computeExclusively

      public static <R, T extends Exception> R computeExclusively(Task task, TaskProducer<R,T> executor) throws T, InterruptedException
      Sorgt dafür, dass ein Task exklusiv, also ohne nebenläufige andere Tasks zu beeinflussen, ausgeführt wird.
      Type Parameters:
      T - generischer Exception-Typ, der von der Funktion geworfen werden kann (wird an Aufrufer weitergegeben)
      R - Typ des Ergebnisses
      Parameters:
      task - Optional: Task-Objekt (falls ein bestehender Task genutzt werden soll)
      executor - Funktionales Interface, das die eigentliche implementierung des Tasks enthält.
      Returns:
      Ergebnis der executor-Funktion
      Throws:
      T - Fehler, die von der Funktion generiert werden, werde an den Aufrufer weitergegeben
      InterruptedException - Wenn die Funktion beim Warten auf exklusive Task-Ausführung unterbrochen wurde
    • compute

      public static <R, T extends Exception> R compute(String name, TaskProducer<R,T> executor) throws T, InterruptedException
      Sorgt dafür, dass ein Task ausgeführt wird. Nebenläufige andere Tasks sind möglich, sofern diese nicht als exklusiver Task gestartet worden sind.
      Type Parameters:
      T - generischer Exception-Typ, der von der Funktion geworfen werden kann (wird an Aufrufer weitergegeben)
      R - Typ des Ergebnisses
      Parameters:
      name - Beschreibender deutscher Name des Tasks (für Debug-Ausgaben, Task-Übersicht etc.)
      executor - Funktionales Interface, das die eigentliche implementierung des Tasks enthält.
      Returns:
      Ergebnis der executor-Funktion
      Throws:
      T - Fehler, die von der Funktion generiert werden, werde an den Aufrufer weitergegeben
      InterruptedException - Wenn die Funktion beim Warten auf exklusive Task-Ausführung unterbrochen wurde
    • computeExclusively

      public static <R, T extends Exception> R computeExclusively(String name, TaskProducer<R,T> executor) throws T, InterruptedException
      Sorgt dafür, dass ein Task exklusiv, also ohne nebenläufige andere Tasks zu beeinflussen, ausgeführt wird.
      Type Parameters:
      T - generischer Exception-Typ, der von der Funktion geworfen werden kann (wird an Aufrufer weitergegeben)
      R - Typ des Ergebnisses
      Parameters:
      name - Beschreibender deutscher Name des Tasks (für Debug-Ausgaben, Task-Übersicht etc.)
      executor - Funktionales Interface, das die eigentliche implementierung des Tasks enthält.
      Returns:
      Ergebnis der executor-Funktion
      Throws:
      T - Fehler, die von der Funktion generiert werden, werde an den Aufrufer weitergegeben
      InterruptedException - Wenn die Funktion beim Warten auf exklusive Task-Ausführung unterbrochen wurde
    • run

      public static <T extends Exception> void run(Task task, TaskExecutor<T> executor) throws T
      Sorgt dafür, dass ein Task ausgeführt wird. Nebenläufige andere Tasks sind möglich, sofern diese nicht als exklusiver Task gestartet worden sind.
      Type Parameters:
      T - generischer Exception-Typ, der von der Funktion geworfen werden kann (wird an Aufrufer weitergegeben)
      Parameters:
      task - Optional: Task-Objekt (falls ein bestehender Task genutzt werden soll)
      executor - Funktionales Interface, das die eigentliche implementierung des Tasks enthält.
      Throws:
      T - Fehler, die von der Funktion generiert werden, werde an den Aufrufer weitergegeben
    • runExclusively

      public static <T extends Exception> void runExclusively(Task task, TaskExecutor<T> executor) throws T
      Sorgt dafür, dass ein Task exklusiv, also ohne nebenläufige andere Tasks zu beeinflussen, ausgeführt wird.
      Type Parameters:
      T - generischer Exception-Typ, der von der Funktion geworfen werden kann (wird an Aufrufer weitergegeben)
      Parameters:
      task - Optional: Task-Objekt (falls ein bestehender Task genutzt werden soll)
      executor - Funktionales Interface, das die eigentliche implementierung des Tasks enthält.
      Throws:
      T - Fehler, die von der Funktion generiert werden, werde an den Aufrufer weitergegeben
    • run

      public static <T extends Exception> void run(String name, TaskExecutor<T> executor) throws T
      Sorgt dafür, dass ein Task ausgeführt wird. Nebenläufige andere Tasks sind möglich, sofern diese nicht als exklusiver Task gestartet worden sind.
      Type Parameters:
      T - generischer Exception-Typ, der von der Funktion geworfen werden kann (wird an Aufrufer weitergegeben)
      Parameters:
      name - Beschreibender deutscher Name des Tasks (für Debug-Ausgaben, Task-Übersicht etc.)
      executor - Funktionales Interface, das die eigentliche implementierung des Tasks enthält.
      Throws:
      T - Fehler, die von der Funktion generiert werden, werde an den Aufrufer weitergegeben
    • runExclusively

      public static <T extends Exception> void runExclusively(String name, TaskExecutor<T> executor) throws T
      Sorgt dafür, dass ein Task exklusiv, also ohne nebenläufige andere Tasks zu beeinflussen, ausgeführt wird.
      Type Parameters:
      T - generischer Exception-Typ, der von der Funktion geworfen werden kann (wird an Aufrufer weitergegeben)
      Parameters:
      name - Beschreibender deutscher Name des Tasks (für Debug-Ausgaben, Task-Übersicht etc.)
      executor - Funktionales Interface, das die eigentliche implementierung des Tasks enthält.
      Throws:
      T - Fehler, die von der Funktion generiert werden, werde an den Aufrufer weitergegeben
    • getActiveTasks

      public static Set<Task> getActiveTasks()
      Gibt alle aktuell laufenden tasks zurück (z. B. für Debug-Ausgaben)
      Returns:
      alle aktuell laufenden Tasks