Revision as of 10:40, 14 September 2011

Available since SMILA 0.9.0!

PipelineProcessingWorker (bundle org.eclipse.smila.processing.worker)

The PipelineProcessingWorker is a worker designed to process synchronous pipelines inside a asynchronous workflow. The worker in principal is independent of a dedicated pipeline processing implementation. However, in SMILA we use BPEL pipelines for synchronous workflows, so in common speech the worker is also called BPEL worker.

The BPEL pipelines that can be used for execution are those defined in SMILA for BPEL processing. So there's no need to copy or configure them separately to use them with the PipelineProcessingWorker.

BPEL pipelines resp. pipelets are able to process records in parallel. Therefore the PipelineProcessingWorker can divide the records of the input bulk in bunches of records to be processed in parallel. This can be configured via numberOfParallelRecords parameter (see below).

JavaDoc

This page gives only a rough overview of the service. Please refer to the JavaDoc for detailed information about the Java components.

Configuration

The PipelineProcessingWorker is configured via incoming task parameters. These parameters could have been set e.g. in a job definition.

Sample job definition that sets the parameters:

{
  "name":"myJob",
  "parameters":{
    "pipelineName": "myBpelPipeline",
    "numberOfParallelRecords": "10",
    ...
   },
  "workflow":"myWorkflow"
}

PipelineProcessingWorker definition in workers.json

GET /smila/jobmanager/workers/pipelineProcessingWorker/

HTTP/1.x 200 OK

{
  "name" : "pipelineProcessingWorker",
  "readOnly" : true,
  "parameters" : [ {
    "name" : "pipelineName"
  }, {
    "name" : "numberOfParallelRecords",
    "optional" : true
  } ],
  "input" : [ {
    "name" : "input",
    "type" : "recordBulks"
  } ],
  "output" : [ {
    "name" : "output",
    "type" : "recordBulks",
    "modes" : [ "optional" ]
  } ]
}

The output bucket of the worker is optional, hence in an asynchronous workflow the worker does not need to have a successor. If the output bucket is not defined, the result records of the pipeline processing are not persisted to a bulk, but thrown away. This makes sense if the pipeline stores the records somewhere itself, e.g. adds them to an index.

Access task parameters in pipelets

The worker adds all task parameters to a map in attribute _parameters in each record before giving it to the workflow processor, so each pipelet can access them. The helper class org.eclipse.smila.processing.parameters.ParameterAccesssor supports this by checking for requested parameters first in this _parameters map, then at the top-level of a record and then in the pipelet configuration. Therefore it's possible to override properties from the pipelet configuration by setting them as task parameters, if the pipelet uses the ParameterAccessor to access parameters in records and configuration. This is done for example by the Lucene indexing and Sesame pipelets. If the internal parameter _failOnError is not set in the worker _failOnError=false is set. This means that called pipelets should continue processing records and not stop when defect records are processed. The pipelet should implement this behaviour. How this is done you can find in [1]

Error handling

The following errors may occur when a task for the PipelineProcessingWorker is processed:

• Pipeline parameter missing or invalid parameter
  • If the given pipeline parameter is not set (or invalid) the task will fail with a non-recoverable error.
• ProcessingException while processing a bunch of parallel records.
  • Recoverable ProcessingException: The current task will fail with a recoverable error, so the whole task (with all records) will be repeated.
  • Non-recoverable ProcessingException: An error will be logged and the worker will continue with the next bunch of records. The records of the current bunch will be lost. (This is implemented in a way as to not fail the whole task with all its input records in case of a single record defect.)