Page History

...

Use Case:
- Consider the situation where:
  - A job chain is to start at a number of parallel job chains
  - Subsequent jobs in started job chains check if jobs from parallel chains completed successfully.
- Usually a split & sync pattern is used for similar use cases, however, synchronizing includes that both jobs have to be completed.
- Instead the current use case is about check and control if a job of a parallel chain has completed without forcing both jobs to run synchronously.

Solution

Download: final_chain_job_chain_historycontrolParallelExecutionOfJobChainsExample.zip
Extract the archive to a folder in your JobScheduler installation named ./config/live.
The archive will extract the files to a sub-folder parallel_job_chain_controlcontrolParallelExecutionOfJobChainsExample.
Note that you can store the sample files in any folder you like.

...

The solution contains six job chains:
- JobChain1 runs Job1 and Job2 in parallel.
  - On successful completion of Job1 then JobChain2 is run
  - On successful completion of Job2 then JobChain3 is run
- JobChain2 runs Job3 and Job4
- JobChain3 runs Job5 and Job6
- JobChain4 runs after successful completion of JobChain1
  - JobChain4 runs Job7, Job8, Job9
  - Job7 runs 1st
  - Job8 runs once Job7 and Job4 have run successfully
- JobChain5 runs after successful completion of JobChain1
  - JobChain5 runs Job10, Job11 and Job12
  - Job10 runs 1st
  - Job11 runs once Job10, Job4 and Job6 have run successfully
  - Job12 runs once Job11 has completed successfully
- JobChain6 runs once Job9 and Job12 have completed successfully

Usage

The first job split1 set some pairs parameters to control the dependencies. sets a number of parameters by use of a pre-processing Monitor for later control of successful completion of jobs. For each job to be controlled a pair of parameters is used:
- The first parameter of the pair is a flag which is used to check for later checking if the dependent jobs are job is successfully completed.
  - The value of this parameter is initialised with "0" and will be is modified by the dependent jobs with to "1".
  - In the above example
    these are
    code
    the following parameters are used:
    - job4_successfully_completed=0
    ;
    - which will
    - be
    - checked
    - by
    - Job8
    - and
    - Job11
    - job6_successfully_completed=0
    ;
    - which will
    - be
    - checked
    - by
    - Job11
    - job12_successfully_completed=0
    ;
    - which will
    - be
    - checked
    - by
    - Job13
- The second parameter of the pair describes to which job commits which job chains that it has successfully completed. job chains the information about successful completion is broadcasted.
  - The example specifies the job chains for which a suspended order is continued if the current job completes successfully.
  - You need to specify all job chains, in which the order can be located with respect to the checking jobsThe current job chain (here JobChain1) always is the first in the list.
  - The job chains can specify relative be specified by an absolute path or by a relative path to the current job chain (here Job Chain 1).
  - In the above example
    these
    the following values are used:
    Code Block
    - ```
    job4_commits_
```
finish
- ```
completion_to="/
```
    2016060710000017
    - ```
    controlParallelExecutionOfJobChainsExample/
```
Chain1
- ```
JobChain1;
```
    Chain4
    - ```
    JobChain4;
```
Chain5
- ```
JobChain5"
```
Positive Check
- Add an order to job_chain_A using JOC's Add Order context menu.
  - The order should pass through the job chain without errors.
- Add an order to job_chain_B using JOC's Add Order context menu.
  - The order should also pass through the job chain without errors.
- Add an order to job_chain_Z using JOC's Add Order context menu.
  - The order should pass through the job chain without errors as all pre-conditions are met.

job6_commits_completion_to="/controlParallelExecutionOfJobChainsExample/JobChain1;JobChain5"

job12_commits_completion_to="/controlParallelExecutionOfJobChainsExample/JobChain1;JobChain4;JobChain6"

The dependent jobs (here Job4, Job6 and Job12) use a post-processing monitor that implements commands to resume the orders
- in all job chains which are specified by the commits_completion_to parameter
- where the value of the successfully_completed parameter is set to "1".
The jobs that wait for dependent jobs make use of a pre-processing monitor that checks the corresponding successfully_completed parameters.
- These jobs use a task parameter dependent_jobs that specifies a list of dependent jobs.
- In above example these are
  - Job8 : dependent_jobs="Job4"
  - Job11: dependent_jobs="Job4;Job6"
  - Job13: dependent_jobs="Job12"

The above described pre- and post-processing monitors include the attached control_parallel_execution_of_job_chains.js JavaScript like this:

Code Block

title	pre-processing monitor for split1 job
collapse	true

<monitor  name="set_params_for_check_jobs" ordering="1">
        <script  language="java:javascript">
            <include  live_file="control_parallel_execution_of_job_chains.js"/>
            <![CDATA[
function spooler_process_before() {
    
    //Specify the list of job chains for which Job4 commits that it has run successfully
    //These job chains can specify relative to the current job chain
    
    setParams4CheckingJobs( "Job4", ["Chain4", "Chain5"] );

    //Specify the list of job chains for which Job6 commits that it has run successfully
    //These job chains can specify relative to the current job chain
    
    setParams4CheckingJobs( "Job6", ["Chain5"] );    
    
    //Specify the list of job chains for which Job12 commits that it has run successfully
    //These job chains can specify relative to the current job chain
    
    setParams4CheckingJobs( "Job12", ["Chain4", "Chain6"] );
    
    return true;
}
            ]]>
        </script>
    </monitor>

Code Block

title	post-processing monitor for jobs Job4, Job6 and Job12
collapse	true

<monitor  name="commit_successfully_run" ordering="0">
        <script  language="java:javascript">
            <include  live_file="control_parallel_execution_of_job_chains.js"/>
            <![CDATA[
function spooler_process_after(spooler_process_result) {
    return commit_successful_run(spooler_process_result);
}
            ]]>
        </script>
    </monitor>

Code Block

title	pre-processing monitor for job Job8, Job11 and Job13
collapse	true

<monitor  name="check_dependent_jobs" ordering="0">
        <script  language="java:javascript">
            <include  live_file="control_parallel_execution_of_job_chains.js"/>
            <![CDATA[
function spooler_process_before() {
    return check_dependent_jobs();
}
            ]]>
        </script>
    </monitor>

Negative Check

Modify the job do_something_job_chain_A to include an error, e.g. by adding the command exit 1 as the final line in the job script.
Add an order to job_chain_A:
- The order should proceed with an error.
Add an order to job_chain_Z
- The order should proceed with an error that is visible in the order log. This error will state that the predecessor job did not complete successfully.
- The order will be set back and will be repeated according to the setback intervals that have been specified for the job check_predecessor_job_chain_Z.

Removing the modification to job do_something_job_chain_A and adding an order to job_chain_A that then runs successfully should result in a successful run of job_chain_Z - either by a new order added to job_chain_Z or by the next execution of the previous order that has been set back.

Space shortcuts

Page tree

Versions Compared

Old Version 11

New Version Current

Key

Solution

Usage

See also