The building blocks of the process editor

Compose your own business process using a combination of the building blocks listed in this topic.

There are several kinds of building blocks:

Partners

These are the external users or services that interact with the process.

There are two kinds of partners:

Variables

Variables store the messages that are exchanged between the partners in a process and the data that is used in its business logic.

A variable belongs to the scope in which it is declared. If it is created in the global process scope then it is a global variable, and thus visible to the process as a whole. Those that are created within nested scopes can only be seen by objects within that scope.

There are two choices available:

Correlation sets

Activities, elements, and handlers

When you work on the canvas, you will be working with a combination of the three following types of objects:

What follows is a description of all the activities, elements, and handlers that are available in the palette to the left of the canvas, the submenus that are nested behind the dark grey arrows in the palette, and the action bars that appear when you hover over an activity on the canvas.

First submenu

The fully expanded first submenu.
Empty action activity
Use this activity as an undefined object to act as a placeholder within your process. You might do this if you were designing a process that you expected somebody else to implement, or if you were trying to synchronize the activities within a parallel activity.
Invoke activity
Use this activity to call an operation on a specific partner. Operations can be either one-way (asynchronous) or request/response (synchronous).
Receive activity
The receive activity waits for external input, and channels it into the process.
Reply activity
Use this activity in a synchronous (request/response) operation to return the output or fault to the partner that initiated the operation. This activity specifies the same partner implementation as the corresponding receive activity. A reply is always sent to the same partner from which a message was previously received
Assign activity
Use this activity to copy some form of information from one part of your process to another. For example, it could be used to update the values of your variables or partner links.
Human task activity
Use the human task activity to send a process-related task out to a human for completion. This activity is used in conjunction with the human task editor.
Snippet activity
Use this activity to compose visual expressions and Java™ code and thereby insert custom behavior into your process.

Second submenu

The fully expanded second submenu.
Choice activity
This is a structured activity, in that it contains other activities that are organized onto individual control paths. During execution, the choice activity evaluates the conditions on the paths in order, and follows the first one that evaluates to True. You can embed as many paths as you want, each containing one case element followed by any other activities that are necessary. If none of the control paths evaluate to true, then the otherwise path is chosen.
Receive choice activity
This is also a structured activity, and it halts execution of the process in order to wait for an operation to be called on it, and then follows the control path that is appropriate to the first message it receives. Th first activity in that path, can be either a receive element or a timeout element.
While loop activity
Use this structured activity to repeat one or more activities as long as specific success criteria or conditions are being met. If the condition that leads to the activity evaluates to false, then none of the activities within will be executed.
Wait activity
Use this to stop the process for a specified period of time. You configure this activity either by telling it how long it should hold up the process, or by specifying when it has waited long enough.
Sequence activity
Use this structured activity to nest a series of activities into your process that will be executed in the order in which they are placed. Execution returns to the business process when the last activity within the nest has completed.
Scope activity
Use this to act as a behavioral container for one or more activities in your process. By definition, your process as a whole is contained within a single global scope, and you can nest other scopes within it, forming a hierarchy.
A variable is visible only in the scope in which it is declared. If it is created in the global process scope then it is a global variable, and thus visible to the process as a whole. Those that are created within nested scopes can only be seen by objects within that scope.
Each scope has a primary activity that defines its normal behavior, and you can associate a scope with fault, event or compensation handlers.
You can configure a scope in one of two ways:
  1. Choose isolated when you want to control simultaneous access to shared variables.
  2. Choose compensable if you want to allow compensation related activities on this scope. If this check box is clear, then this scope will be transparent to all compensation logic.
Parallel activity
Use this activity to nest other activities that will execute concurrently. This is a structured activity, in that it contains other activities separated into individual control paths that are dictated by links and transition conditions. You can embed as many paths in the activity as you want, and they will all be executed simultaneously.

Third submenu

The fully expanded third submenu.
Terminate activity
Use this activity to halt the execution of a process. When used, all activities that are currently active are halted without any fault handling or compensation behavior. In each of these cases, when the terminate activity has been invoked, its own fault handler is executed.
Throw activity
Use this activity to signal an internal fault. In defining the properties of this activity, you can specify a name and a message in the properties area of the process editor. These details can then be passed onto a fault handler that presumably is configured to deal with this kind of exception.
Re-throw activity
Use this activity to forward a fault from inside a fault handler.
Compensate activity
Use this activity within a scope's fault or compensation handler to invoke a specific compensation handler within the scope.

Information service activity

The information service activity is an optional feature for WebSphere Integration Developer that enables you to discover and invoke operations on an IBM Information Server, as well as offering direct access to relational database management systems through full SQL support.

If the icon for this activity ( ) appears on the first submenu of the palette, then the Information service activity for business processes feature has been installed, and instructions on how to use it can be found under the Adding an information service activity to a business process heading within the process editor documentation. If the icon does not appear, then the feature is not installed, and the documentation will not appear in the navigation.

To install the information service activity, use the Rational Product Updater, and look for IBM Information Server Plug-In for WebSphere Integration Developer in the optional feature tab. For general information about optional feature installation, refer to Finding and installing product updates.

Action bar

The elements and handlers that appear in the action bar will vary according to what activity is currently selected. Here is a list, in alphabetical order, of the elements that you might see.

Table 1. The various elements and handlers that can appear in the action bar.
Element Icon Description
Case element The case activity icon Used within a choice activity, this element is used to create a control path and define the conditions that will cause this path to be executed. During execution, the process will evaluate the conditions in each of the case elements, and follow the first one that evaluates to true.
Catch element The Catch element ity icon Use this element within a fault handler to intercept, and deal with a specific kind of fault. The catch element is always the first element on a fault handler's control path, and the activities that follow it are executed should the fault conditions you specify occur. You can catch a built-in fault type, or define one yourself. On the canvas, each catch shows the name of the fault type that it will catch, and each is associated with a variable.
Catch all element The Catch all element icon Use this element within a fault handler to intercept, and deal with any fault that is not already defined in an existing catch element. The catch all element is the first object on a control path, and the activities the follow it are executed should the fault conditions you specify occur.
Compensation handler The compensation handler activity icon Use the compensation handler on either an invoke or a scope activity, and within a long-running process to define logic that will execute when a fault is thrown after the parent activity has already been committed. Compensation is used when the activity cannot simply be reversed or undone, but another operation must be executed in order to return the failed process to a balanced state.
Link The link activity graphic Use the link within a parallel activity to connect nested activities and form individual control paths. The link is used to express a synchronization dependency. In other words, it is execution under constraint because the link creates a dependency of one activity and the variables it uses on another activity. You can specify a transition condition on the link in the properties area of the process editor.
Event handler The event handler icon Use the event handler to associate either a process of a scope activity with an external stimulus. They can respond to events that happen at any time during an application's lifetime, or as many times as those events repeat. There can be several paths within the handler, and they determine how the process should proceed based on the nature of the data received. Each path is preceded by either an OnEvent or a Timeout element.
OnEvent element The OnEvent activity icon Use this element within an event handler to create a control path and specify the operation that will cause this path to be executed.
Fault handler The fault handler activity icon A fault handler is a collection of specific activities that will run when a fault is thrown on the activity with which the handler is associated. Fault handlers can be used on both invoke and scope activities, and will run either when a fault is thrown by the invoke activity, or by an activity inside the scope activity. You can place activities on paths within the handler to either deal with anticipated faults, or attempt to find another way to complete the operation. Each path within the fault handler is preceded by either a catch, or a catch all element.
Otherwise element The otherwise element icon Use this element within a choice activity to to create a control path that will execute when none of the other cases evaluate to true. Use this element on only one of the paths within a choice activity. During execution, the process will evaluate the conditions in each of the case elements, and should none of them evaluate to true, it will execute the activities in this path.
Receive element The receive element icon Use this element within a receive choice activity to create a control path and specify the operation that will execute it. There is at least one receive element path nested within a receive choice activity. During execution, the process halts at the receive choice activity and listens for a message from its operations. The first message that comes in determines which path is executed.
Add compensation handler The compensate link element icon Use this element with a compensate activity to call a compensation handler on nested scopes.
Timeout element The timeout element icon Use this element within either a receive choice activity or an event handler to create a control path that is executed when a specified time has either been reached or has elapsed. This element is used on a single path, and is configured to specify either a specific date, or period of time. During execution, this path is chosen when no input is received within this time period, or by the specified date.

Feedback
(C) Copyright IBM Corporation 2005, 2006. All Rights Reserved.