Dokumentation   JobSchedulerSynchronizeJobChains  Synchronize Job Chains
Funktionalität
  • Synchronisierung

    Der Job synchronisiert Aufträge mehrerer Job-Ketten, die unterschiedlich lange Verarbeitungszeiten erfordern und an bestimmten Job-Knoten aufeinander warten sollen. Der Job unterstützt folgendes Szenario:

              Job-Kette   A    B    C
              ------------------------
              Job-Knoten  A1   B1   C1
              Job-Knoten     Merge
              Job-Knoten  A2   B2   C2
              

  • Split & Merge

    Einer Synchronisierung wird eine Split Operation vorangestellt, um ein split & merge Szenario herzustellen, in dem z.B. ein Job drei Aufträge für die Job-Ketten A, B und C zur parallelen Ausführung erzeugt:

              Job            Split
              ------------------------
              Auftrag     a    b    c
              ------------------------
              Job-Kette   A    B    C
              ------------------------
              Job-Knoten  A1   B1   C1
              Job-Knoten     Merge
              Job-Knoten  A2   B2   C2
              

  • Split & Merge & Split & Merge

    Einer Synchronisierung wird wie im Split & Merge Beispiel eine Split Operation vorangestellt, dann erfolgt ein weiterer Split, ein weiterer Merge und alles Endet in einem Job.

              Job            Split
              ------------------------
              Order       a    b    c
              ------------------------
              Job Chain   A    B    C
              ------------------------
              Job Node    A1   B1   C1
              Job Node       Merge1
              Job Node    A2   B2   C2
              Job Node       Merge2
              Job Node    A3
    

  • Split & Merge in one chain

    Ein Split & Merge kann auch innerhalb einer einzigen Kette durchgeführt werden, indem die beim Split neu erzeugten Aufträge in sonst nicht erreichbare Zustände der Jobkette gesetzt werden.

                      
              ------------------------
              Job Chain   A    A    A
              ------------------------
              Job Node    A1
              Job Node    B1*                  
              Job Node    C1   C2   C3
              Job Node       Merge
              Job Node    D1
              
    * Am Ende von B1 wird der Auftrag wie unten beschrieben geteilt.

Erläuterungen
  • Die Job-Ketten A, B und C verarbeiten Aufträge unterschiedlicher Dauer.
  • Die Aufträge aller drei Job-Ketten sollen in einem Job-Knoten synchronisiert werden, d.h. aufeinander warten bis jeweils ein Auftrag aus jeder Job-Kette den Job-Knoten Merge erreicht hat. Solange aus einer der Job-Ketten ein Auftrag fehlt, werden alle anderen Aufträge zurückgesetzt, d.h. sie warten vor dem Job-Knoten Merge.
  • Erst wenn aus jeder Job-Kette ein Auftrag vorhanden ist, werden alle drei Aufträge nach dem Job-Knoten Merge fortgesetzt. Dabei spielt die Reihenfolge, in der die Aufträge am Job-Knoten Merge eintreffen, keine Rolle.
  • Beachten Sie, dass mit dem JobScheduler derselbe Job in mehreren Job-Ketten verwendet werden kann.
  • Nach dem Merge werde alle parallelen Aufträge in ihren nächsten Zuständen fortgesetzt. Soll nach dem Merge nur noch sequentiell in einer einzigen Kette fortgesetzt werden, so sind die anderen Ketten mit dem Merge zu beenden.

Konfiguration
  • Erstellen Sie z.B. einen Job JobSynchronize aus der o.g. Implementierung mit diesem Inhalt:
    <job order="yes"
         stop_on_error="no">
        <script java_class="sos.scheduler.job.JobSchedulerSynchronizeJobChains"
                language="java"/>
        <run_time/>
    </job>
              
  • Fügen Sie jeder Job-Kette, für die Sie Aufträge synchronisieren möchten, einen Job-Knoten mit dem Synchronisierungs-Job hinzu:
    <job_chain orders_recoverable="yes" visible="yes">
        <job_chain_node state="A1"
                        job="Job1"
                        next_state="synchronize"
                        error_state="error"/>
        <job_chain_node state="synchronize"
                        job="JobSynchronize"
                        next_state="A2"
                        error_state="error"/>
        <job_chain_node state="A2"
                        job="Job2"
                        next_state="success"
                        error_state="error"/>
        <job_chain_node state="success"/>
        <job_chain_node state="error"/>
    </job_chain>
              

    Sie können den Synchronisierungs-Job in einen beliebigen Job-Knoten der jeweiligen Job-Kette platzieren. Sie müssen dazu denselben Job-Namen für den Synchronisierungs-Job verwenden, allerdings können sie den Job-Knoten an beliebigen Knoten der jeweiligen Job-Ketten einsetzen und mit beliebigen Status versehen.

  • Um den Durchsatz zu verbessern können Sie zulassen, dass der Synchronisierungs-Job in mehreren Prozessen ausgeführt werden kann:
    <job order="yes"
         tasks="3"
         stop_on_error="no">
         ...
    </job>
              
    In diesem Beispiel wird der Synchronisierungs-Job in bis zu 3 parallelen Instanzen ausgeführt.
  • Falls Sie erzwingen möchten, dass mehr als ein Auftrag aus einer Job-Kette vorhanden sein muss, um die Synchronisierungsbedingungen zu erfüllen, dann können Sie die Anzahl der erwarteten Aufträge pro Job-Kette angeben. Verwenden Sie hierzu für den Synchronisierungs-Job den Parameter [job_chain]_required_orders, z.B. A_required_orders wenn der Name der Job-Kette A lautet.
  • Falls Sie mehrere Gruppen von Job-Ketten jeweils unabhängig voneinander synchronisieren möchten, dann verwenden Sie unterschiedliche Namen für den Synchronisierungs-Job pro Gruppe.

  • Konfiguration eines Split Jobs

    Dieser Job steht am Beginn eines split & merge Szenarios und erzeugt mehrere Aufträge zur parallelen Ausführung in Job-Ketten:

    <job>
        <script language="shell"><![CDATA[
            echo %SCHEDULER_JOB_NAME%
        ]]></script>
        <run_time/>
        <commands on_exit_code="success">
            <order job_chain="ChainA" replace="yes">
                <params>
                    <copy_params from="task"/>
                </params>
            </order>
            <order job_chain="ChainB" replace="yes">
                <params>
                    <copy_params from="task"/>
                </params>
            </order>
            <order job_chain="ChainC" replace="yes">
                <params>
                    <copy_params from="task"/>
                </params>
            </order>
        </commands>
    </job>
              


Fehlerbehandlung
  • Beachten Sie bitte, dass einzelne Aufträge für eine beliebige Dauer ausgesetzt bleiben solange nicht Aufträge von allen synchronisierten Job-Ketten vorhanden sind.
  • Falls Sie veranlassen möchten, dass Aufträge nach einer bestimmten Zeitspanne mit Fehler enden sofern sie nicht synchronisiert werden konnten, dann können Sie diese Verarbeitungsweise und ein maximales Wiederholungsintervall angeben:
    <job order="yes"
         stop_on_error="no">
        <params>
          <param name="setback_type" value="setback"/>
        </params>
        <script java_class="sos.scheduler.job.JobSchedulerSynchronizeJobChains"
                language="java"/>
        <delay_order_after_setback setback_count="1"
                                   is_maximum="no"
                                   delay="00:10"/>
        <delay_order_after_setback setback_count="12"
                                   is_maximum="yes"
                                   delay="00:10"/>
        <run_time/>
    </job>
              
    Mit dieser Parametrisierung wird eine befristete Lebensdauer von Aufträgen konfiguriert. In diesem Beispiel wird der Auftrag alle 10 Minuten wiederholt vom Synchronisierungs-Job ausgeführt. Ist die 12. Wiederholung nicht erfolgreich, dann wird der Auftrag als fehlerhaft gehandhabt und mit dem Job-Knoten fortgesetzt, der dem error_state= Attribut des Synchronisierungs-Jobs zugewiesen ist.
Class Name/ Titel JobSchedulerSynchronizeJobChains  Synchronize Job Chains
  AuftragssteuerungEin Auftrag aktiviert die Verarbeitung einer Job-Kette. Er enthält Parameter für einen oder mehrere Jobs einer Job-Kette. Dieser Job läuft auftragsgesteuert ab.
  Tasks zeigt die maximale Anzahl der Tasks an, die ein Job parallel ausführen kann 1
  SkriptEin Skript enthält die Implementierung eines Jobs. Skripte können mit den Methoden des Job Scheduler API in den Sprachen Java, Javascript, Perlscript und VBScript implementiert werden. Alternativ zur Implementierung mit Skripten können Jobs zur Ausführung beliebiger Programme und Kommandodateien konfiguriert werden.
  • Sprache: java
  • Name der Java-Klasse: sos.scheduler.job.JobSchedulerSynchronizeJobChains
  •  Ressource:
Konfiguration    
  Parameter
job_chain_state_required_orders No of required orders
[optional] No of required orders

Der Parameter benennt für einen State einer Job-Kette die Anzahl eingereihter Aufträge, die verlangt wird, um die Bedingungen einer Synchronisierung zu erfüllen. Ohne Angabe des Parameters wird ein Auftrag erwartet.

Werden zum Beispiel drei Aufträge erwartet, dann werden nach Vorliegen dieser Anzahl alle drei Aufträge simultan fortgesetzt.

Der Name des Parameters setzt sich aus dem Namen der jeweiligen Job-Kette, einem ";", dem Namen des Jobknoten und dem Suffix _required_orders zusammen.

Default-Value: 1

job_chain_required_orders No of required orders
[optional] No of required orders

Der Parameter benennt für eine Job-Kette die Anzahl eingereihter Aufträge, die verlangt wird, um die Bedingungen einer Synchronisierung zu erfüllen. Ohne Angabe des Parameters wird ein Auftrag erwartet.

Werden zum Beispiel drei Aufträge erwartet, dann werden nach Vorliegen dieser Anzahl alle drei Aufträge simultan fortgesetzt.

Der Name des Parameters setzt sich aus dem Namen der jeweiligen Job-Kette und dem Suffix _required_orders zusammen.

DataType: SOSOptionInteger
Default-Value: 1

required_orders No of required orders
[optional] No of required orders

Der Parameter benennt für alle Job-Ketten die Anzahl eingereihter Aufträge pro Job-Kette, die verlangt wird, um die Bedingungen einer Synchronisierung zu erfüllen. Ohne Angabe des Parameters wird ein Auftrag erwartet.

Werden zum Beispiel drei Aufträge erwartet, dann werden nach Vorliegen dieser Anzahl alle drei Aufträge simultan fortgesetzt.

Der Parameter wird nur ausgewertet, falls kein Parameter [job_chain]_required_orders für die aktuelle Job-Kette benannt wurde.

Default-Value: 1

setback_type SetBack Typ
[optional] SetBack Typ

Dieser Parameter kann verwendet werden, um zwischen suspend und setback für die Behandlung wartender Aufträge auszuwählen:

  • suspend

    Aufträge werden ausgesetzt, d.h. falls die Synchronisierungsbedingungen nicht erfüllt sind, verbleiben die Aufträge für unbestimmte Dauer in diesem Zustand bis sie durch den Synchronisierungs-Job fortgesetzt werden.

    Alternativ können solche Aufträge manuell in der Web-Oberfläche fortgesetzt werden.

  • setback

    Aufträge werden für das mit den Parametern setback_interval und setback_count bestimmte Intervall und dessen maximale Häufigkeit wiederholt und gehen nach Überschreiten des Maximums in einen Fehlerzustand über.

    Alternativ können solche Aufträge manuell in der Web-Oberfläche fortgesetzt werden.

DataType: SOSOptionSetBack
Default-Value: suspend

setback_interval SetBack Intervall
[optional] SetBack Intervall

Dieser Parameter kann in Verbindung mit dem Parameter setback_type und dessen Wert setback verwendet werden, um das Intervall in Sekunden zu bestimmen, für das Aufträge zurückgestellt werden, für die die Synchronisierungsbedingungen nicht erfüllt sind.

Per Voreinstellung wird der setback_type suspend verwendet, der Aufträge aussetzt und daher kein Wiederholungsintervall benötigt.

Aus Gründen der Sichtbarkeit wird empfohlen diesen Wert anhand der Job-Konfiguration mit dem Element <delay _order_after_setback> zu bestimmen.

DataType: SOSOptionInteger
Default-Value: 600

setback_count
[optional]

Der Parameter kann in Verbindung mit dem Parameter setback_type und dessen Wert setback verwendet werden, um die max. Anzahl wiederholter Ausführungen von Aufträgen zu bestimmen, für die die Synchronisierungsbedingungen nicht erfüllt sind.

Per Voreinstellung wird der setback_type suspend verwendet, der Aufträge aussetzt und daher kein Wiederholungsintervall benötigt.

Aus Gründen der Sichtbarkeit wird empfohlen diesen Wert anhand der Job-Konfiguration mit dem Element <delay _order_after_setback> zu bestimmen.

DataType: SOSOptionInteger
Default-Value: unbounded

XML Code zur Konfiguration des Jobs
  <job
    title = "Synchronize Job Chains"
    order = " yes "
    tasks = "1" >
    <description>
        <include file = "jobs/JobSchedulerSynchronizeJobChains.xml">
    </description>
    <params>
        <param name="job_chain_state_required_orders" value="1">
        <param name="job_chain_required_orders" value="1">
        <param name="required_orders" value="1">
        <param name="setback_type" value="suspend">
        <param name="setback_interval" value="600">
        <param name="setback_count" value="unbounded">
    </params>

     <script language   = " java "
             java_class = " sos.scheduler.job.JobSchedulerSynchronizeJobChains " >
     </script>
</job>
Releases 1.0 Version 1.0
2009-09-12 [ letzte Änderung 2009-09-12 ]
Autor Andreas Püschel andreas.pueschel@sos-berlin.com
Kommentar

Initiale Auslieferung

Ressourcen Dateien

Documentation   JobSchedulerSynchronizeJobChains  Synchronize Job Chains
Functionality
  • Synchronization

    This job synchronizes orders from multiple job chains that require different time consumption and should be synchronized at specific job nodes, i.e. should wait until one order from each job chain arrives. This job supports the following scenario for synchronization:

              Job Chain   A    B    C
              ------------------------
              Job Node    A1   B1   C1
              Job Node       Merge
              Job Node    A2   B2   C2
              

  • Split & Merge

    You could preceed synchronization with a split operation to achieve a split & merge scenario where one job creates three orders for the job chains A, B and C with parallel execution:

              Job            Split
              ------------------------
              Order       a    b    c
              ------------------------
              Job Chain   A    B    C
              ------------------------
              Job Node    A1   B1   C1
              Job Node       Merge
              Job Node    A2   B2   C2
              

  • Split & Merge & Split & Merge

    You could preceed synchronization with a split as in the Split & Merge example, then split again to run in three parallel jobs and then merge again to finish in just one job.

              Job            Split
              ------------------------
              Order       a    b    c
              ------------------------
              Job Chain   A    B    C
              ------------------------
              Job Node    A1   B1   C1
              Job Node       Merge1
              Job Node    A2   B2   C2
              Job Node       Merge2
              Job Node    A3
    

  • Split & Merge in one chain

    A split & merge can also be performed in only one chain, by setting the split order to otherwise unreachable states in the job chain.

                      
              ------------------------
              Job Chain   A    A    A
              ------------------------
              Job Node    A1
              Job Node    B1*                  
              Job Node    C1   C2   C3
              Job Node       Merge
              Job Node    D1
              
    * At the end of B1 the order is split a described below.

Explanations
  • The job chains A, B and C process orders with different time consumtion.
  • Orders from all three job chains should be synchronized at one job node, i.e. they should wait until one order from each job chain is present. As long as an order from any of the job chains is missing any existing orders are being suspended or set back, i.e. they are waiting in front of the Merge job node until the expected orders are complete.
  • Only if one order from each job chain is present then all orders are continued by the Merge job node. The sequence in which these orders arrive at the Merge job node is irrelevant.
  • Keep in mind that for JobScheduler the same job can be used in multiple job chains.
  • After the merge, all parallel orders will continue to their next states. If you want to merge into just one line of execution again, discontinue all but one Job Chain after the synchronization job.

Configuration
  • Create e.g. a job JobSynchronize from the above implementation like this:
    <job order="yes"
         stop_on_error="no">
        <script java_class="sos.scheduler.job.JobSchedulerSynchronizeJobChains"
                language="java"/>
        <run_time/>
    </job>
              
  • Add a job node for this synchronization job to each of your job chains like this:
    <job_chain orders_recoverable="yes" visible="yes">
        <job_chain_node state="A1"
                        job="Job1"
                        next_state="synchronize"
                        error_state="error"/>
        <job_chain_node state="synchronize"
                        job="JobSynchronize"
                        next_state="A2"
                        error_state="error"/>
        <job_chain_node state="A2"
                        job="Job2"
                        next_state="success"
                        error_state="error"/>
        <job_chain_node state="success"/>
        <job_chain_node state="error"/>
    </job_chain>
              
    You can put the synchronization job into an arbitrary job node of each job chain. You have to use the same job name for the synchronization job in all job chains, however, the job could be placed at different job nodes and associated with different states.
  • For better throughput you could allow the synchronization job to be executed in multiple tasks by specifying:
    <job order="yes"
         tasks="3"
         stop_on_error="no">
         ...
    </job>
              
    In this sample the synchronization job can be executed with up to 3 instances in parallel.
  • Should you want to force more than one order to be present for one job chain in order to match the synchronization criteria then you could specify the number of required orders for that job chain by the parameter [job_chain]_required_orders, e.g. A_required_orders should the job chain be named A.
  • Should you want different sets of job chains to be synchronized independently then use a different synchronization job name for each set of job chains.
  • Configuration of a split job

    Such a job is used at the beginning of a split & merge scenario and would create multiple orders for parallel execution in subsequent job chains like this:

    <job>
        <script language="shell"><![CDATA[
            echo %SCHEDULER_JOB_NAME%
        ]]></script>
        <run_time/>
        <commands on_exit_code="success">
            <order job_chain="ChainA" replace="yes">
                <params>
                    <copy_params from="task"/>
                </params>
            </order>
            <order job_chain="ChainB" replace="yes">
                <params>
                    <copy_params from="task"/>
                </params>
            </order>
            <order job_chain="ChainC" replace="yes">
                <params>
                    <copy_params from="task"/>
                </params>
            </order>
        </commands>
    </job>
              


Error Handling
  • Keep in mind that orders are suspended for an unlimited duration by the synchronization job until orders from all synchronized job chains are present.
  • Should you want orders to fail after a specific delay without being continued then you could add that delay to the synchronization job like this:
    <job order="yes"
         stop_on_error="no">
        <params>
          <param name="setback_type" value="setback"/>
        </params>
        <script java_class="sos.scheduler.job.JobSchedulerSynchronizeJobChains"
                language="java"/>
        <delay_order_after_setback setback_count="1"
                                   is_maximum="no"
                                   delay="00:10"/>
        <delay_order_after_setback setback_count="12"
                                   is_maximum="yes"
                                   delay="00:10"/>
        <run_time/>
    </job>
              
    With this parameterization the lifetime of an order is restricted to the maximum number of setbacks. In this example an order is repeatedly processed by the synchronization job after 10 minutes. With the 12th repetition being unsuccessful the order will fail and will be continued with the job node that is specified by the error_state= attribute of the synchronization job node.
Class Name/ Title JobSchedulerSynchronizeJobChains  Synchronize Job Chains
  Order ControlAn order activates the processing of a job chain and contains parameters for one or more jobs in the job chain. This job is executed order driven, i.e. it starts automatically if an order is received.
  Tasks shows the maximum number of tasks that a job can operate in parallel 1
  ScriptA script contains the implementation of one or more jobs. Scripts make optional use of the Job Scheduler API methods and are implemented in Java,Javascript, PerlScript or VBScript. Jobs are an alternative to scripts, and can be configured to start programs and executable files.
  • Language: java
  • Name of Java Class: sos.scheduler.job.JobSchedulerSynchronizeJobChains
  •  Resource:
Configuration    
  Parameters
job_chain_state_required_orders No of required orders
[optional] No of required orders

This parameter specifies the number of orders that are required to be present for certain state a job chain to make orders proceed. Without specification one order is expected to be present.

If e.g. three orders are specified then three orders from that chain have to be present and these three orders will simultaneously proceed having matched the synchronization criteria.

The name of this parameter is created from the name of the respective job chain, a ";", the name of the state and the suffix _required_orders.

Default-Value: 1

job_chain_required_orders No of required orders
[optional] No of required orders

This parameter specifies the number of orders that are required to be present for a job chain to make orders proceed. Without specification one order is expected to be present.

If e.g. three orders are specified then three orders from that chain have to be present and these three orders will simultaneously proceed having matched the synchronization criteria.

The name of this parameter is created from the name of the respective job chain and the suffix _required_orders.

DataType: SOSOptionInteger
Default-Value: 1

required_orders No of required orders
[optional] No of required orders

This parameter specifies the number of orders that are required to be present for each job chain to make orders proceed. Without specification one order is expected to be present.

If e.g. three orders are specified then three orders from that chain have to be present and these three orders will simultaneously proceed having matched the synchronization criteria.

This parameter is considered only if no parameter [job_chain]_required_orders has been specified for the current job chain.

Default-Value: 1

setback_type SetBack Typ
[optional] SetBack Typ

This parameter can be used in order to choose between suspend and setback for the handling of waiting orders:

  • suspend

    Orders are suspended if the synchronization criteria were not matched. Such orders remain in this state for an arbitrary duration provided that they were not continued by the synchronization job.

    Alternatively such orders can be continued manually in the Web GUI.

  • setback

    Orders are repeatedly executed as specified by the parameters setback_interval and setback_count. Should the specified interval and frequency be exceeded then the order enters an error state and might leave the job chain.

    Alternatively such orders can be continued manually in the Web GUI.

DataType: SOSOptionSetBack
Default-Value: suspend

setback_interval SetBack Intervall
[optional] SetBack Intervall

This parameter can be used with the parameter setback_type and its value setback to specify the interval in seconds, for which orders are being set back that do not match the synchronization criteria.

By default the setback_type suspend will be used that suspends orders and therefore would not require an interval.

For better visibility it is recommended to set this value using the element <delay _order_after_setback> instead.

DataType: SOSOptionInteger
Default-Value: 600

setback_count
[optional]

This parameter can be used with the parameter setback_type and its value setback to specify the maximum number of trials to set back orders that do not match the synchronization criteria.

By default the setback_type suspend will be used that suspends orders and therefore would not require an interval.

For better visibility it is recommended to set this value using the element <delay _order_after_setback> instead.

DataType: SOSOptionInteger
Default-Value: unbounded

XML Code to configurate the job
  <job
    title = "Synchronize Job Chains"
    order = " yes "
    tasks = "1" >
    <description>
        <include file = "jobs/JobSchedulerSynchronizeJobChains.xml">
    </description>
    <params>
        <param name="job_chain_state_required_orders" value="1">
        <param name="job_chain_required_orders" value="1">
        <param name="required_orders" value="1">
        <param name="setback_type" value="suspend">
        <param name="setback_interval" value="600">
        <param name="setback_count" value="unbounded">
    </params>

     <script language   = " java "
             java_class = " sos.scheduler.job.JobSchedulerSynchronizeJobChains " >
     </script>
</job>
Releases 1.0 Version 1.0
2009-09-12 [ last Changes 2009-09-12 ]
Author Andreas Püschel andreas.pueschel@sos-berlin.com
Comment

Initial release

Resources Files