I Came,I Learned,I Experienced....

Solution Architect Show - What Solution Architect Does In a Project

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 26 Mar 2020 12:56:00 +0530

Listen to "What Solution Architect Does In a Project" on Spreaker.

Solution Architect Show - What skills required to become an excellent solution architect?

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 26 Mar 2020 12:55:00 +0530

Listen to "What skills required to become an excellent solution architect?" on Spreaker.

Why You Want To Become A Solution Architect

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 26 Mar 2020 12:54:00 +0530

Listen to "Why You Want To Become A Solution Architect" on Spreaker.

How To Become A Solution Architect

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 26 Mar 2020 12:54:00 +0530

Listen to "How To Become A Solution Architect" on Spreaker.

Solution Architect Show - The 7 HABITS OF HIGHLY EFFECTIVE SOLUTION ARCHITECT

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 26 Mar 2020 12:53:00 +0530

Listen to " The 7 HABITS OF HIGHLY EFFECTIVE SOLUTION ARCHITECT" on Spreaker.

Solution Architect Show

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 26 Mar 2020 12:52:00 +0530

Listen to "8 Common Mistakes For New Solution Architect And How To Avoid Them." on Spreaker.

Solution Architect Show

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 26 Mar 2020 12:51:00 +0530

Listen to "The disruption to your IT Career is coming , are you ready?" on Spreaker.

Solution Architect Show

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 26 Mar 2020 12:50:00 +0530

Listen to "The fundamental skills" on Spreaker.

Fetching Task PendingWith ( User / Team ) - BPM

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 21 Nov 2019 12:05:00 +0530

Limitations in IBM BPM document store

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Wed, 22 Jun 2016 11:00:00 +0530

There are some limitations in administering the IBM BPM document store. In most situations, you can successfully work around these limitations.

The following list contains some known limitations of the IBM BPM document store:

The document store must be enabled at configuration time for an IBM BPM installation that is configured to use DB2 on z/OS
The document store is only available when Federated Repositories is used as the user registry
An exception occurs when you are logging or tracing document store operations
Defining too many properties can exceed the table row size limit

These limitations are described in the following sections.

Although the IBM BPM document store is not available in these situations, you can continue to work with your document attachments in the IBM BPM database. Alternatively, you can configure an external Enterprise Content Manager (ECM) system for storing your documents. In either situation, the legacy document APIs continue to be used. Any ECM operations that specify the IBM BPM document store as a server will fail.

The document store must be enabled at configuration time for an IBM BPM installation that is configured to use DB2 on z/OS

At configuration time, you decide whether you want to enable the IBM BPM document store. After you configure the IBM BPM document store, you cannot dynamically enable or disable the IBM BPM document store.

The document store is only available when Federated Repositories is used as the user registry

The IBM BPM document store is only available when Business Process Manager is configured to use Federated Repositories as the user registry. If you are using a different user registry configuration, disable the autostart mechanism of the IBM_BPM_DocumentStore application.

To use the IBM BPM document store with your LDAP users and groups, configure LDAP as a repository in Federated Repositories instead of using stand-alone LDAP as the user registry. Additional information is found in the topic "Configuring external security providers."

An exception occurs when you are logging or tracing document store operations

When the server is started or the IBM BPM document store commands maintainDocumentStoreTrace or updateDocumentStoreApp are run, the following SystemErr exception might be logged:

[3/19/13 23:31:12:548 PDT] 00000084 SystemErr     R log4j:WARN No appenders could be found for logger (filenet_error.api.com.filenet.apiimpl.util.ConfigValueLookup).
[3/19/13 23:31:12:548 PDT] 00000084 SystemErr     R log4j:WARN Please initialize the log4j system properly.
[3/19/13 23:31:14:482 PDT] 00000084 SystemErr     R log4j:WARN Configuring default logging to the file E:\IBM\WebSphere\AppServer\profiles\Custom01\FileNet\
testDE1.AppCluster.WIN-E6GDL89KDJDNode01.0\p8_server_error.log
[3/19/13 23:31:49:536 PDT] 00000084 SystemErr     R log4j:WARN No appenders could be found for logger (filenet_error.api.com.filenet.apiimpl.util.ConfigValueLookup).
[3/19/13 23:31:49:536 PDT] 00000084 SystemErr     R log4j:WARN Please initialize the log4j system properly.
[3/19/13 23:33:25:867 PDT] 00000108 SystemErr     R SLF4J: Class path contains multiple SLF4J bindings.

The exception is caused by the tracing and logging mechanism that is used with the IBM BPM document store. The exception does not result in any operational problems and can be safely ignored.

Defining too many properties can exceed the table row size limit

Over time, the number of properties that are defined for an application can exceed the table row size limit. You can delete unused properties by completing the actions that are described in Cleaning up the IBM BPM document store.

BM Business Process Manager Event Manager - Common symptoms and Solutions

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 24 May 2016 12:56:00 +0530

Introduction

The event manager is the central component in IBM Business Process Manager that is responsible for scheduling a number of different tasks. If it's not working correctly, you might run into severe problems that need to be resolved quickly.

This blog entry describes some of the most common symptoms and shows how to resolve them.

In Part I, some common event manager problems will be shown. Part II explains how to analyze and fix these problems. Part III lists the available APARs that are related to the event manager.

Special thx to Mark Filley and Bill Wentworth for their technical input and in depth review!

Part I - Common event manager symptoms

Symptom A - Event manager is not processing any work

The event manger is responsible for the scheduling of various jobs like:

Executing undercover agents (UCAs)
Executing system lane tasks
Triggering business process definition (BPD) timers
Scheduling BPD notifications, which are essential to move the process flow forward through the business process diagram (BPMN)

If your process instances are stuck, timers not fired, and UCAs are no longer executed, then the event manager is not running or could be blocked.

The Process Admin Console gives you a comprehensive view that shows the status of the event manager. When the status light is red, the event manager is paused or did not start and its jobs are accumulating with a Scheduled Time much behind the current time. In the Process Admin Console, these jobs would show 'Job Status' as 'Scheduled' and jobs would not be in the 'Executing' state.

For example:

The following screen shot, which was taken from the Process Admin Console, shows the last event manager heart beat expiration time stamp of "12/10/2014 2:00:15 PM." This time stamp is normally ahead of the current time. The event manager job's (UCAs and BPD notifications) Scheduled Time shows an earlier time stamp and a job is not currently executing. In this example, the event manager is shown as inactive (red light), which explains the situation.

Note: Even if the event manager is not running, it is possible to start new process instances, but they will not move forward! As services are not scheduled by the event manager, those could also be executed.

Symptom B - Event manager shows jobs with a scheduled date of 2099

The Process Admin Console can show event manager jobs scheduled for 2099 as shown here:

Symptom C - Event manager is active, but long running system lane tasks block the event manager throughput

There can be situations where the event manager is actively working, but you experience throughput problems. For example, the flow in the process instances is not moving forward or the execution of timers is delayed.

The following screen shot shows five system lane activities being executed, but a couple of BPD notifications are waiting to be executed. These BPD notifications are overdue as the 'Scheduled Time' is greater than the current time. This situation can indicate that the event manager configuration needs to be tuned and/or the execution time for system lane tasks needs to be optimized, if possible.

See resolution section C,D,E,F - Event manager is active, but throughput problems exist to analyze and resolve this problem.

Symptom D - UCAs are not processing at the desired rate

According to the definition in the process application, UCAs are bound to a couple of synchronous queues or a single asynchronous queue managed by the event manager. The capacity for these queues is defined by the following parameters in the 80EventManager.xml configuration file:
nc-queue-capacity> or

c-queue-capacity>

These numbers limit the rate of UCAs that can be executed at a time.

See resolution section C,D,E,F - Event manager is active, but throughput problems exist to analyze and resolve that problem.

Symptom E - Many BPD timers wake up at the same time

When the event manager processes a timer, it loads the applicable task into the "BPD async queue," whose capacity is defined by the -queue-capacity> setting from the 80EventManager.xml configuration file. If the application design has hundreds or thousands of timers that start at the exact same time, then this setting might need to be increased beyond the default of forty (40).

Keep in mind that this queue is shared between timer executions, BPD notifications and the execution of system lane tasks.

See resolution section C,D,E,F - Event manager is active, but throughput problems exist to analyze and resolve that problem.

Symptom F - Event Manager warning messages CWLLG2156W, CWLLG2236W occur

If the BPM run time detects that the database connection pool is too small, it will dynamically reduce the queue sizes and you will see entries in SystemOut.log like the following messages:
"CWLLG2156W: The database connection pool size xxx of the Process Server data source might be too small." and/or
"CWLLG2236W: The configured <%%%%%%-queue-capacity> parameter of xxx has been changed to yyy."

These messages indicate that there is a mismatch between the event manager queue capacity and the JDBC data source pool size.

See resolution section C,D,E,F - Event manager is active, but throughput problems exist to analyze and resolve that problem.

Symptom G - Event manager tasks fail when LombardiEventEmitterInputQueue reached max threshold

When you have your IBM Business Process Manager environment configured to forward monitoring events to a Business Monitor server, the execution of event manager tasks involves sending a message to the local queue called "LombardiEventEmitterInputQueue." This queue maps to the JNDI name jms/com.ibm.lombardi/EventEmissionQueue.

If the queue depth of the LombardiEventEmitterInputQueue reaches the configured maximum threshold, no more message can be put to this queue and the execution of an event manager tasks will end up in an exception like the following text:

J2CA0027E: An exception occurred while invoking prepare on an XA Resource Adapter from DataSource jms/com.ibm.lombardi/EventEmissionQueueFactory, within transaction ID {XidImpl: formatId(57415344), gtrid_length(36), bqual_length(54),
data(0000014ac680b3dd000000010c3c5a4c30653f6b06f16c1e5782cea7f4fce4b60a8f48d30000014ac680b3dd000000010c3c5a4c30653f6b06f16c1e5782cea7f4fce4b60a8f48d3000000010000000000000000000000000002)} : javax.transaction.xa.XAException: CWSIC8007E: An exception was caught from the remote server with Probe Id 3-013-0010. Exception: CWSIC2029E: This transaction cannot commit as an operation that was performed within the transaction boundary failed. The first operation that failed generated the following exception: com.ibm.ws.sib.processor.exceptions.SIMPLimitExceededException: CWSIK0025E: The destination LombardiEventEmitterInputQueue on messaging engine ProcessServerProdDepEnv.SupCluster.000-MONITOR.Cell01.Bus is not available because the high limit for the number of messages for this destination has already been reached...
   at com.ibm.ws.sib.comms.common.CommsByteBuffer.parseSingleException(CommsByteBuffer.java:1753)
   at com.ibm.ws.sib.comms.common.CommsByteBuffer.getException(CommsByteBuffer.java)
   at com.ibm.ws.sib.comms.common.CommsByteBuffer.checkXACommandCompletionStatus(CommsByteBuffer.java:1218)
   at com.ibm.ws.sib.comms.client.OptimizedSIXAResourceProxy.prepare(OptimizedSIXAResourceProxy.java:749)
   at com.ibm.ws.sib.comms.client.SuspendableXAResource.prepare(SuspendableXAResource.java:386)
   at com.ibm.ws.sib.api.jmsra.impl.JmsJcaRecoverableSiXaResource.prepare(JmsJcaRecoverableSiXaResource.java:260)
   at com.ibm.ejs.j2c.XATransactionWrapper.prepare(XATransactionWrapper.java:1152)
   at com.ibm.tx.jta.impl.JTAXAResourceImpl.prepare(JTAXAResourceImpl.java:234)
   at com.ibm.tx.jta.impl.RegisteredResources.prepareResource(RegisteredResources.java:1211)
   at com.ibm.tx.jta.impl.RegisteredResources.distributePrepare(RegisteredResources.java:1472)
   at com.ibm.tx.jta.impl.TransactionImpl.prepareResources(TransactionImpl.java:1488)
   at com.ibm.ws.tx.jta.TransactionImpl.stage1CommitProcessing(TransactionImpl.java:602)
   at com.ibm.tx.jta.impl.TransactionImpl.processCommit(TransactionImpl.java:1028)
   at com.ibm.tx.jta.impl.TransactionImpl.commit(TransactionImpl.java:962)
   at com.ibm.ws.tx.jta.TranManagerImpl.commit(TranManagerImpl.java:439)
   at com.ibm.tx.jta.impl.TranManagerSet.commit(TranManagerSet.java:191)
   at com.ibm.ws.uow.UOWManagerImpl.uowCommit(UOWManagerImpl.java:807)
   at com.ibm.ws.uow.embeddable.EmbeddableUOWManagerImpl.uowEnd(EmbeddableUOWManagerImpl.java:881)
   at com.ibm.ws.uow.UOWManagerImpl.uowEnd(UOWManagerImpl.java:782)
   at com.ibm.ws.uow.embeddable.EmbeddableUOWManagerImpl.runUnderNewUOW(EmbeddableUOWManagerImpl.java:818)
   at com.ibm.ws.uow.embeddable.EmbeddableUOWManagerImpl.runUnderUOW(EmbeddableUOWManagerImpl.java:370)
   at org.springframework.transaction.jta.WebSphereUowTransactionManager.execute(WebSphereUowTransactionManager.java:252)
   at com.lombardisoftware.utility.spring.ProgrammaticTransactionSupport.executeInNewTransaction(ProgrammaticTransactionSupport.java:431)
   at com.lombardisoftware.utility.spring.ProgrammaticTransactionSupport.execute(ProgrammaticTransactionSupport.java:294)
   at com.lombardisoftware.server.core.TXCommand.executeInDeadlockRetryLoop(TXCommand.java:83)
   at com.lombardisoftware.server.core.TXCommand.execute(TXCommand.java:72)
   at com.lombardisoftware.bpd.runtime.engine.quartz.AbstractBpdTask.execute(AbstractBpdTask.java:119)
   at com.lombardisoftware.bpd.runtime.engine.quartz.AbstractBpdTask.execute(AbstractBpdTask.java:71)
   at com.lombardisoftware.server.scheduler.Engine.execute(Engine.java:847)
...
Caused by: com.ibm.wsspi.sib.core.exception.SILimitExceededException: CWSIK0025E: The destination LombardiEventEmitterInputQueue on messaging engine AdvProcessServerProdDepEnv.SupCluster.000-MONITOR.rsdcpprobpmdm01Cell01.Bus is not available because the high limit for the number of messages for this destination has already been reached.
   at com.ibm.ws.sib.comms.common.CommsByteBuffer.parseSingleException(CommsByteBuffer.java:1842)
   ... 49 more

Part II - Resolving common event manager symptoms

A - Event manager is not processing any work

If the event manager does not process any work as mentioned previously in the symptoms section, this situation might be caused by the event manager not being active or being active, but blocked for some reason.

The following sections, A.1 and A.2, describe how to analyze and resolve these situations.

To monitor and diagnose the status of the event manager, the following pieces of information are helpful:

DB table LSW_EM_INSTANCE
DB table LSW_EM_TASK
DB table LSW_BLACKOUT_CALENDAR
Process Admin Console section Event Manager -> Monitor as GUI to 1. and 2.
Process Admin Console section Event Manager -> Blackout Periods as GUI to 3.
BPM server log file SystemOut.log and FFDCs
Event manager configuration file '80EventManager.xml', respectively and the global BPM server configuration file TeamWorksConfiguration.running.xml, which contains all of the parameters at run time. The following technote will show where to find these files and how they relate: http://www.ibm.com/support/docview.wss?uid=swg21439614

A.1 - Event manager not active

The easiest way to check the status of the event manager is by using the Process Admin Console, which shows the event manager status and lists all event manager jobs. It also lists the expiration time stamp, which is regularly updated every 15s by an internal heartbeat thread and set to the current time + 60s. Keep in mind that this time stamp is created based on the current time used on the database system that is hosting the BPM tables.

The Process Admin Console panel named 'Event Manager -> Monitor' is a graphical user interface for the contents of the database tables:

BPM DB table LSW_EM_INSTANCE containing the event manager status and heartbeat timestamp
BPM DB table LSW_EM_TASK containing all event manager jobs

The following screen shot shows the event manager status in the Process Admin Console:

Status:

Green - running
Red - stopped, not running

Each cluster member will have an event manager. If you have a multi-cluster topology, it is only present in the AppTarget servers. In this example, it is a single node cluster and, therefore, only one event manager instance is listed. In a clustered environment, there is an entry for every cluster member as a new row in the table. To process work, the event manager needs to be in the running state (green) and the time stamp listed in the Connect expiration field needs to be ahead of the current time.

A successful event manager start up is reflected in the server's SystemOut.log file with messages that show the start of the heartbeat thread and acquisition of the synchronous queues. You can grep the log for messages of the wle_scheduler group as shown here:

wle_scheduler I   CWLLG0561I: Heartbeat thread starting...
wle_scheduler I   CWLLG0615I: Heartbeat resumed.
wle_scheduler I   CWLLG0597I: Trying to acquire synchronous queue SYNC_QUEUE_1.
wle_scheduler I   CWLLG0581I: Acquired synchronous queue SYNC_QUEUE_1.
wle_scheduler I   CWLLG0597I: Trying to acquire synchronous queue SYNC_QUEUE_2.
wle_scheduler I   CWLLG0581I: Acquired synchronous queue SYNC_QUEUE_2.
wle_scheduler I   CWLLG0597I: Trying to acquire synchronous queue SYNC_QUEUE_3.
wle_scheduler I   CWLLG0581I: Acquired synchronous queue SYNC_QUEUE_3.

In the LSW_EM_INSTANCE table, the STATUS column shows a value of '1' for an active event manager and '2' if it has been paused.

With the Process Admin Console, the event manager can be paused and resumed by clicking the applicable button. Make sure to click Refresh to update the panel so that the current status is read from the LSW_EM_INSTANCE table.

Reasons why the event manager might be inactive:

a) The event manager configuration is corrupted by an incorrect attribute in the custom property file (for example: 100Custom.xml)
If you tried to overwrite event manager parameters by using a 100Custom.xml file and accidentally used the 'replace' attribute for merge instead of 'mergeChildren' as show below, the required parameters from 80Eventmanager.xml are not honored:

Incorrect definition sample:

replace

e="replace">true

art-paused>

Correct definition sample:

e="mergeChildren">

e="replace">true

art-paused>

With the incorrect definition sample, the Process Admin Console shows a NullPointerException when you click Event Manager > Monitor as shown in the following screen shot:

To solve that problem, correct the 100Custom.xml file and restart the server. After the restart, make sure that the TeamWorksConfiguration.running.xml file contains the complete

section and the event manager is shown as active in the Process Admin Console.

Note: There is a list of sample configuration files to adapt the IBM Business Process Manager configuration, including some samples for the event manager. You can access these files here.

b) The event manager might have been paused manually by using the Process Admin Console. In this case, you can resume its activity as mentioned previously. Even when it is paused, the connect expiration time stamp is renewed every 15s (default).

c) The event manager is configured to be started as "paused"
The 80EventManager.xml BPM server configuration file contains a parameter called

, which is set to false, by default. If it is configured to true by overwriting the parameter with a 100Custom.xml file, then the heartbeat thread to set the event manager 'connect expiration' is active, but the event manager will not process any work.

To check for that situation, look at your TeamWorksConfiguration.running.xml BPM server configuration file. Search in that file for the

string in the

section. If that parameter is set to true, this setting explains why the event manager did not become active after server start up.

In case the event manager is configured to be started as "paused," the SystemOut.log file will only contain the following messages during start up. They show that the heartbeat thread started and continuously updates the connect expiration time stamp, but the event manager did not acquire the synchronous queues.

wle_scheduler I   CWLLG0570I: Heartbeat paused.
wle_scheduler I   CWLLG0561I: Heartbeat thread starting...
wle_scheduler I   CWLLG0615I: Heartbeat resumed.

To resume the event manager, use the Process Admin Console as shown previously. A successful resume action will result in the following messages in the SystemOut.log file:

wle_scheduler I   CWLLG0615I: Heartbeat resumed.
wle_scheduler I   CWLLG0597I: Trying to acquire synchronous queue SYNC_QUEUE_1.
wle_scheduler I   CWLLG0581I: Acquired synchronous queue SYNC_QUEUE_1.
wle_scheduler I   CWLLG0597I: Trying to acquire synchronous queue SYNC_QUEUE_2.
wle_scheduler I   CWLLG0581I: Acquired synchronous queue SYNC_QUEUE_2.
wle_scheduler I   CWLLG0597I: Trying to acquire synchronous queue SYNC_QUEUE_3.
wle_scheduler I   CWLLG0581I: Acquired synchronous queue SYNC_QUEUE_3.

Keep in mind that the

parameter in the event manager configuration needs to be set back to false. Otherwise, it will still be inactive after the next server restart.

d) Event manager is not enabled in the configuration.
The 80EventManager.xml BPM server configuration file contains a parameter called enabled, which is set to true, by default.

To check for that situation, look at your TeamWorksConfiguration.running.xml BPM server configuration file. Search in that file for the parameter in the

section . If that parameter is set to false, then the event manager will not be active after the server start up. In contrast to being started as "paused," it will show none of the previous messages in the SystemOut.log file and the connect expiration time stamp will not be updated!

You cannot resume the event manager through the Process Admin Console in such a case. However, you need to change your configuration to set the enabled parameter back to true and restart your server.

e) Blackout period is active
Administrators establish blackout periods to specify times when events cannot be scheduled. For example, you might schedule a blackout period due to a holiday or for regular system maintenance windows. The event manager takes blackout periods into account when scheduling and queuing events, event subscriptions, and undercover agents (UCAs). The following screenshot shows if and which blackout periods are configured. This data is persisted in the LSW_BLACKOUT_CALENDAR DB table.

If a blackout period is active, the event manager monitor in the Process Admin Console lists a scheduled job named End blackout period where the scheduled time column shows when the blackout period ends. Event manager jobs created during the blackout period show a job status of Blacked out.

The following screenshot shows that scenario:

The SystemOut.log file does not show any applicable messages when the blackout period is entered.

f) Exceptions during the event manager start up
If the event manager is not running after start up, but was not configured as paused or disabled, the SystemOut.log file might show a couple of exceptions.

There could be various reasons why the event manager failed during startup or resume. Gather the documents as mentioned in the event manager mustgather technote.

The following section shows a few examples:

Event manager configuration is broken

This problem is caused by an incomplete fix pack installation where required post-installation steps to upgrade the profile were not executed.

The SystemOut.log file will have exceptions that have the following signatures.

CWLLG0144E: Exception in init(): schedule cannot be started. com.lombardisoftware.core.TeamWorksException: Message: SCHEDULER_CONFIG_BROKEN Arguments: loader-acquire-sync-queue-query: com.lombardisoftware.core.config.eventmanager.SchedulerConfig checkAndReplace Message: SCHEDULER_CONFIG_REPLACEMENT_PARAMETER_NOT_FOUND Arguments: %executing% loader-acquire-tasks-query UPDATE LSW_EM_TASK SET TASK_STATUS = %acquired%, TASK_OWNER = ? WHERE TASK_ID IN (%task-ids%)

To fix this problem, review the documented post-installation (interim fix/fix pack) steps and rerun the missing steps.
Event manager start up problem due to a problem in the BPM embedded document store (applies to IBM Business Process Manager V8.5 and later))

Important note: If the embedded BPM document store cannot be started due to configuration or authorization problems, the event manager will also not start!

The SystemOut.log file will not show any of the event manager-related start up messages as shown previously, but you will see, for example, the following exception, which is related to the embedded document store:

CWTDS1100E: An error occurred while validating or creating the default configuration for the IBM BPM document store.
                                 com.ibm.bpm.embeddedecm.exception.UserMissesWritePermissionException: CWTDS0022E: The configuration was changed in a way that the technical user 'deadmin' of the IBM BPM document store fails to change the object 'Domain'.
Explanation: The technical user defined in the BPM role type 'EmbeddedECMTechnicalUser' is not permitted to perform changes on an object.
Action: Revert the recent configuration changes. Ensure that the user defined by the BPM role type 'EmbeddedECMTechnicalUser' has access to the object. Verify this using the admin task 'getDocumentStoreStatus'.
    at com.ibm.bpm.embeddedecm.internal.DomainConfiguration$2.run(DomainConfiguration.java:264)
    at com.ibm.bpm.embeddedecm.internal.DomainConfiguration$2.run(DomainConfiguration.java:207)
    at java.security.AccessController.doPrivileged(AccessController.java:362)

To fix that problem, the configuration error with the document store must be resolved as shown here: http://www.ibm.com/support/docview.wss?uid=swg21673250

A.2 - Event manager is active but it is not processing any jobs

When the event manager is active (Process Admin Console shows it as active and connect expiration is not outdated) but is not processing any tasks, this could be caused by:

Event manager configuration file '80EventManager.xml', respectively the global BPM server configuration file TeamWorksConfiguration.running.xml, which contains all of the parameters at run time. The following technote will show where to find these files and how they relate: http://www.ibm.com/support/docview.wss?uid=swg21439614
Event manager blocked due to orphaned transactions in Microsoft SQLServer holding locks on its tables:
In case you use Microsoft SQLServer as the process server database, the reason for that could be so called 'orphaned transactions' in the DB system. The following TechNote will show how to resolve such a problem: http://www.ibm.com/support/docview.wss?uid=swg21633692
System time or timezone of BPM and remote DB system which is hosting the BPM DB is out of sync:To fix that, please make sure, that the system time on the BPM and the DB node are in sync. It is a best practice to have both on the same network time protocol server (NTP).

B - Event manager shows jobs with a scheduled date of 2099

If the execution of an event manager job fails, it is retried a couple of times as defined by the re-execute-limit configuration parameter (default = 5) in the 80EventManager.xml file. The behavior in such a case has gone through a fundamental change with APAR JR47860:

Pre JR47860 behaviour: when the re-execute-limit is reached, the according event manager job is discarded! There is no way to re-execute this job.
Post JR47860 behaviour: when the re-execute-limit is reached, the event manager job is rescheduled for 2099.

The interim fix for the APAR also provides a new administrative command called BPMReplayOnHoldEMTasks, which was introduced to resubmit this failed job. Check the APAR description for more details or the see the product documentation information in the IBM Knowledge Center.

Important note: Before resubmitting an event manager job, it is important to eliminate the root cause! Otherwise, you might run into the same problem again. To find the root cause, check your SystemOut.log file for message CWLLG0197W. This message indicates, that the event manager has tried to execute a task for 5 times but it failed. Note the thread ID and walk back in the thread history within the SystemOut.log file, which will most probably tell you which exception the execution of this event manager task failed.

Example for an event manager task to execute an UCA:
1. Search the SystemOut.log file for CWLLG0197W shows the following line - note thread ID 00011779.
[2/4/14 5:54:18:395 GMT] 00011779 wle_ucaexcept E   CWLLG0197W: Task Notify BPD 202738 of notification failed 5 times. The task will not be re-executed.

The previous messages for thread 00011779 will show this error message:
[2/4/14 5:54:18:337 GMT] 00011779 wle_ucaexcept E   CWLLG0181E: An exception occurred during execution of task 4,425,203. Error: PreparedStatementCallback; SQL [update LSW_BPD_INSTANCE_DATA set DATA = ? where BPD_INSTANCE_ID = ?]; Error for batch element #1: DB2 SQL Error: SQLCODE=-1476, SQLSTATE=40506, SQLERRMC=-968, DRIVER=3.61.65; nested exception is com.ibm.db2.jcc.am.SqlTransactionRollbackException: Error for batch element #1: DB2 SQL Error: SQLCODE=-1476, SQLSTATE=40506, SQLERRMC=-968, DRIVER=3.61.65
com.lombardisoftware.core.TeamWorksException: PreparedStatementCallback; SQL [update LSW_BPD_INSTANCE_DATA set DATA = ? where BPD_INSTANCE_ID = ?]; Error for batch         element #1: DB2 SQL Error: SQLCODE=-1476, SQLSTATE=40506, SQLERRMC=-968, DRIVER=3.61.65; nested exception is com.ibm.db2.jcc.am.SqlTransactionRollbackException: Error for batch element #1: DB2 SQL Error: SQLCODE=-1476, SQLSTATE=40506, SQLERRMC=-968, DRIVER=3.61.65
   at com.lombardisoftware.core.TeamWorksException.asTeamWorksException(TeamWorksException.java:130 ...

In this special case, the execution of the event manager task failed due to an SQL exception with sqlcode -968, which means that the database filesystem is out of space.

2. Fix the problem that caused the exception. In the previous example, resolve the out-of-space condition in the database filesystem.

3. Resubmit the applicable event manager task by using the BPMReplayOnHoldEMTasks command.

C,D,E,F - Event manager is active, but throughput problems exist

Throughput problems might be caused by a wide range of reasons. In terms of the event manager, the potential throughput is limited by the capacity of its queues.

For a comprehensive summary of all event manager-related configuration parameters including the different queues, check this product documentation in the IBM Knowledge Center.

To analyze and fix this problem, you need to understand the involved configuration parameters and how to monitor and adapt them.

a) Find out the event manager queue capacities
The event manager maintains a number of internal queues. The capacity of each queue is limited by a configuration parameter that is specified in the 80EventManager.xml configuration file and limits the number of jobs that can be in the execution state simultaneously. The following table shows the different queues, the applicable configuration parameter, and the default capacity (as of IBM Business Process Manager 8.5.5):

Event Manager Queue	Configuration Parameter in 80EventManager.xml	Default capacity
Async Queue(UCA)	async-queue-capacity	10
Sync Queue (UCA)	sync-queue-capacity	10
BPD Async Queue - BPD Notification - system lane tasks - timer execution	bpd-queue-capacity	40
System Queue	system-queue-capacity	10

The default values could have been overwritten by using a 100Custom.xml file. Then, find out which values are currently being used and have a look into TeamWorksConfiguration.running.xml file.

b) Determine the event manager queue usage and adapt the event manager queue sizes
To monitor the number of executing jobs on each event manager queue, use the Process Admin Console event manager monitor and count the number of rows for each 'Job Queue' with job status 'Executing'. Alternatively you could use this SQL statement:

SELECT COUNT(*) as EXECUTION_COUNT,
case QUEUE_ID
when '-100' then 'UCA Async Queue'
when '-101' then 'BPD Async Queue'
when '-102' then 'EM System Queue'
else 'UCA Sync Queue' END as QUEUE
from LSW_EM_TASK where TASK_STATUS = 3 group by QUEUE_ID WITH UR;

If the number of executing event manager tasks for a queue has reached the capacity limit and there are more tasks on that queue waiting to be executed (time to be scheduled has already passed), then there might be a performance problem or the queue capacity is too low for the workload and needs to be increased.

The BPD async queue is of special interest because its capacity is shared between the execution of system lane tasks, timer executions, and BPD notifications. If the complete capacity is already occupied by currently executing, long-running system lane tasks, no other job can be executed on that queue. The screen shot shown previously for Symptom C is an example from a system with bpd-queue-capacity set to 5 and the complete capacity is occupied by five executing system tasks. To eliminate a problem related to long running system tasks:

Find out why the system lane tasks have such a long execution time and try to fix that. There might be various reasons like back-end response time, excessive JVM garbage collection, CPU and memory constraints, network delays, and so on.
If the system lane tasks are expected to be long-running, think about splitting them into smaller pieces or increase the capacity of the BPD async queue as shown in the next paragraph.

c) Increase the event manager queue capacities

To increase the event manager queue sizes, specify the applicable parameter as shown in the previous table in a 100Custom.xml file. For example:

e="mergeChildren">
e="mergeChildren">

e="replace">40</bpd-queue-capacity>
      nc-queue-capacity merge="replace">10</bpd-queue-capacity>
      c-queue-capacity merge="replace">10</bpd-queue-capacity>
      tem-queue-capacity merge="replace">10</bpd-queue-capacity>

Important: When increasing the capacity of event manager queues, keep in mind that, besides using additional threads in your JVM, also additional JDBC connections will be needed. Thus, the JDBC data source (jdbc/TeamworksDB) connection pool also needs to be increased.
As a general rule, increase the number of database connections by two times the value by which you increased the queue capacity. Apart from database connections, also more JVM heap size is needed.

If there is a mismatch between the queue capacities and the number of available connections for the data source, IBM Business Process Manager tries to scale down the queue size. That issue will be indicated in the log by the warning messages shown under Symptom F.

d) Understand the event manager queue capacity and the related thread pool size
The event manager configuration also shows a parameter named max-thread-pool-size. By default, the value for the max-thread-pool-size parameter is the sum of the individual queue capacities (70). It is important to understand that its size does not limit the overall number of event manager tasks that can be executed simultaneously. So even if you set max-thread-pool-size to 5 and bpd-queue-capacity to 10, you will be able to execute 10 system lane tasks simultaneously. It is possible because the threadpool is defined as 'growable', which means it temporarily allows the number of threads to exceed the defined limit, but such a thread would be discarded directly after it finished and not be returned to the pool. Therefore, these threads are a bit more expensive.

Starting in IBM Business Process Manager 8.5.5.0, the event manager no longer uses its own internal thread pool. Instead, it uses a WebSphere Application Server work manager thread pool. This function is configured by these two event manager parameters:

-was-work-manager>true</use-was-work-manager>
-work-manager>wm/BPMEventManagerWorkManager</was-work-manager>

When you use the WebSphere Application Server work manager thread pool, the maximum pool size is configured in the WebSphere Application Server Administrative Console as shown in the following screen shot:

In a default configuration, the work manager thread pool for the event manager is defined with a maximum of 70 threads, but also as 'growable'. When sizing the work manager thread pool for the event manager, also make sure that its size is at least equal to the sum of queue capacities.

In case you modified the thread pool properties and removed the checkbox for "Growable", then the maximum number of threads implicity also limits the number of event manager jobs that can be executed simultaneously! See this screen shot.

One of the advantages of using a WebSphere Application Server work manager thread pool for the event manager is that you can use the Tivoli Performance Viewer. It is available from the WebSphere Application Server Administrative Console to monitor the thread pool activity. See this screen shot:

G - Event manager tasks fail when the LombardiEventEmitterInputQueue reaches the maximum threshold

Check the current queue depth and the threshold. You can use the service integration bus browser, which is integrated into the WebSphere Application Server Administrative Console, to easily check the queue depth and the high message threshold.

Make sure that there is a message consumer active to read from that queue, which would typically be the Business Monitor infrastructure. If it is not started, start the message consumer and the queue depth should decrease.

If the Business Monitor environment is started and consuming messages, but the queue depth is still at the limit, then perform tuning actions for the Business Monitor server or increase the high message threshold for the involved queues.

In case the Business Monitor environment is no longer existent, but you did not revert the BPM server configuration, there are still messages generated and put to the queue, but not consumed!

To solve it, you need to:

Pause the event manager so that no new messages are created.
Manually delete the message on the queue destination as shown below.
Disable the event emission on the IBM Business Process Manager server according to instructions below.
Restart your IBM Business Process Manager server

To delete the message from the queue destination using the WebSphere Application Server Administrative Console, complete these steps:

In the SIBUS section, navigate to the queue point for the LombardiEventEmitterInputQueue.
Select the runtime tab.
Click messages, which will display DeleteAll option to delete all of the messages on that queue.

The event emission for Business Monitor has been explicitly enabled by the following entry. To disable it, set the value for parameter 'enabled' to false as shown here:

itor-event-emission>
bled>false

nabled>
-authentication-alias>MonitorBusAuthc-authentication-alias>
itor-event-emission>

Part III - Known APAR related to the event manager

Issue, error, or problem	Adressed in APAR	Fix included in
Duplicate execution of event manager task under high load when using Oracle DB	JR49359	8.0.1.3, 8.5.5
Change handling of failed event manager tasks and introduction of admin command to replay these failed tasks	JR47860	8.0.1.3, 8.5.5
Posting message to event manager only starts TIP snapshot	JR45615 and JR45616	7.5.1.2, 8.0.1.1
Blackout calendar not respected for timer events	JR45899	8.0.1.2
Task processing threadpool initialized with wrong user, error message CWLLG0326E or CWLLG0179E	JR46484	8.0.1.2, 7.5.1.2, 8.5.5
IllegalStateException when starting/stopping teamworks.ear	JR47360	8.0.1.2, 8.5.0.1, 8.5.5
Delayed communication between BPD and Service engine	JR47915	8.0.1.2, 8.5.0.1, 8.5.5
DB2 error "bad SQL grammar" with DB2 9.5 after upgrading to 8.0.1.2 or installation of JR46470	JR48878	8.0.1.3
com.lombardisoftware.core.TeamWorksException: Numeric Overflow on event manager task	JR49172	8.5.5, 8.0.1.3
Double execution of event manager tasks in heavily loaded environments with Oracle DB	JR46470	8.0.1.2
UCA message corrupted when larger than 1000 Bytes and using multibyte characters	JR47265	8.0.1.2, 8.5.0.1, 8.5.5
UCA input/output parameters corrupted when containing unicode characters	JR46993	8.0.1.2, 8.5.0.1, 8.5.5
Cleanup of duplicate UCAs entries created before JR41966 had been applied	JR47574	8.0.1.2, 8.5.0.1, 7.5.1.2, 8.5.5
Time based UCAs disappear due to incomplete event manager task	JR50384	8.0.1.3
Scheduling a time elapsed UCA task causes exception when Oracle DB is used	JR46249	8.0.1.2
Time elapsed UCA not executed when schedule contains 'FIRST', 'LAST' or multiple weekdays selected	JR46122	7.5.1.2, 8.0.1.2
Time elapsed UCAs executed at wrong time when DB and process server in different timezone	JR43099	7.5.1.1
Time elapsed UCAs fired multiple times	JR41966	7.5.1.1
CWLLG0181E: Error: [ssage:com.lombardisoftware.server.scheduler.TaskDeath: Task killed by stopping scheduler at server stop or DB failover	JR49523	8.0.1.3, 8.5.5
Exception when using BPMReplayOnHoldEMTasks command and DB2 on z/OS is used	JR50490	8.0.1.3
THE PROCESS ADMIN EVENT MANAGER MONITOR PAGE IS VERY SLOW	JR48052	7.5.1.2, 8.0.1.3, 8.5.5

IBM BPM Scheduled UCA's

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Thu, 24 Sep 2015 16:26:00 +0530

Scheduled UCAs do not automatically run in the Process Center. For testing, click Run Now in IBM Process Designer.

The next scheduled event displays on the Event Manager screen of the Process Admin console for a Process Server. For each scheduled UCA, it shows the last time it was executed and the next scheduled execution. If the time does not display, go to the Installed Apps tab, click the application name, then look under the exposing section for the UCA sub section. Check and re-check the box. Go back to the Event Manager page. Does the UCA show the correct next time to start? If not, turn on diagnostic tracing, repeat the steps, and send the log files to IBM Business Process Manager Support.

The following example is a screen shot of the Exposing section for UCAs.

Notes:

Scheduled UCAs only operate on their scheduled time in a Process Server environment. For a Process Center, click RUN NOW on the UCA implementation to test.
Scheduled UCAs only operate on the DEFAULT snapshot. If you have more than one active snapshot, only the code implementation in the default snapshot fires.

IBM BPM UCA - Consume & Durable Subscription

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Mon, 24 Aug 2015 16:17:00 +0530

Consume and Durable Subscription Options Usage on UCA (IBM BPM ):-

Durable Subscription:-
Think Our BPD is like this:-

Start Event----->Parallel Gateway--------------> MIE1(Message Intermediate event(configured

! MyUCA1))------------->Scrpit1---------->end

!-----------> MIE2(Message InterMediate event(Configured

MyUCA1))-- ----------------->Script2------------>end

Human Service:-(fireMyUCA1 human Service)

Start------------->Invoke UCA(Configured MyUCA1) -------->end

Testing:-

case1:-

1)If we start BPD instance .Then flow waits at MIE1,MIE 2 .

2)If we run fireMyUCA1 Human Service.Then both MIE1,MIE2 will trigger and instance will be completed success fully.

Case2:-

1) Check Durable Subscription option for MIE1 and Uncheck Durable Subscription option for MIE2.

2)Dont start BPD .But Run ” fireMyUCA1” human Service.

3)Now Start the BPD.Go to inspector view,Flow only waits at MIE2 only because MIE1 automatically fires because Durable Subscription option was checked .If you want fire MIE2 again you have to run fireMyUCA1 human service.

Observations:-We are checked Durable Subscription option for MIE1 means .If any of event fired(Which related MIE1) before flow reached MIE1 .That event persisted and Once our flow come into active it will be fired .

“What if the event that would trigger the listener occurs before the listener is reached? This is where the concept of the Durable Subscription comes into play. If this flag is checked, then the arrival of an event before the listener is reached is remembered and when the process
reaches the Intermediate Message Event, it is immediately notified that the solution can continue. If this flag is not checked, then the event that arrived previously is discarded and the process will wait for a further event.”

Consume explanation:-

"Consume" means when an intermediate listener in a given Business Process instance correlates to a message, should it mark that message so that it will not be used by any other event listeners in that instance that are listening for the same event. It is very important to note that this is a per instance flag. The value on this flag has no between 2 listeners in separate BPD instances. If a message is consumed, then the next time a listener begins listening it will only react to events that have not been consumed for this Business Process Instance.

Create two BPDs:

BPD1:-

MessageStartEvent(Configured with MYUCA1)---->MIE(Configured with MYUCA1)----->End (Consume Option was checked)

BPD2:- MessageStartEvent((Configured with MYUCA1)---->MIE((Configured with MYUCA1)----->End (Consume Option was Unchecked)

Testing:-

1)Create Human Service which will fire MYUCA1.Run service

2)Then Two instances were created (BPD1,BPD2).

3)Coming to BPD1 flow, instance will wait at MIE step because ,StartMessageEvent was consumed the message .So MIE is waiting for another Message.(If you observe the BPD1 Instance status is in Active state).

4)coming to BPD2 flow won’t wait it fires both events(MSE,MIE).(If you observe the BPD2 Instance status is complete )

IBM BPM 8.5 - Dynamic user assignment to task

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Sat, 11 Jul 2015 02:19:00 +0530

From IBM BPM v8.5, the Assignment options which were there before such as "Last User in the lane", "Routing Policy", "List Of Users" and "Custom" were deprecated an can no longer be used for the Task Assignments. In older version the option "Custom" was being used for dynamic assignment of Team or User to a Task. In the latest versions of IBM BPM i.e., from V 8.5.0 a new way of assignment has been introduced i.e., using the "Team Filter Service".

In this post, let us look at a code sample illustrating the Dynamic task assignment for user using Team Filter Service.

As a first step create a simple BPD with one Activity with a Human Service. Click on the activity and navigate to Properties --> Assignments and click on new in-front of "Team Filter Service" to create a new Integration service (team filter service) as shown in below figure or select an already created service.

Now in the "Team Filter Service", navigate to "Variables" section and create a new variable called "toUserId" as shown in the figure. This variable can be used to pass the userId to be assigned.

Let us look at the Assignment Tab of the activity in bpd after attaching the "Team Filter Service". Below figure shows the view of Assignment Tab for the activity along with the input mapping.

Now let us look at the script which is used to create a Team with the users passed dynamically to the Team Filter Service. In this Script we need to create the Team of User and assign it output Variable "filteredTeam". Below figure shows the diagram of the "Team Filter Service".

Below is the script using which the Team is created with the users passed dynamically.

tw.local.filteredTeam=new tw.object.Team();
tw.local.filteredTeam.members=new tw.object.listOf.String();
tw.local.filteredTeam.members.insertIntoList(tw.local.filteredTeam.members.listLength, tw.local.toUserId);

Once the BPD is Created and assignment is done as explained above. Create an instance for the BPD, you will notice that the task is assigned to the team created with list of Users.

This script can be extended to filter the users from the given team based on certain parameters or to create new temporary temporary team with of the list of intended users or any other scenario where the intended Users / Teams are determined dynamically during run time.

Hope this is use full !!!

IBM BPM EPV variable behaviour

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Fri, 10 Jul 2015 23:21:00 +0530

I have snapshot_A with an EPV with a default value: "123"
I installed that snapshot to my Process Server and the --> current EPV value is "123" as expected
Now I add a new EPV value "456" with effective date to near future and the --> current EPV value changed to "456" as expected
I created a new snapshot_B and I installed that one on my Process Server
I used Synchronize Settings or Inflight Migration (Instances needed) and discovered that --> the current EPV value switched back to "123". Here, I expected to have "456" because it was the last modified value.

The behavior of migrating EPV variables has changed due to requirements of utilizing the default EPV value specified in the snapshot, if one is defined.
There are two scenarios:

One scenario is the application may be developed in the perspective where the new application requires this new EPV value defined in the snapshot (default behavior in earlier releases).
The other scenario is to utilize only what is defined in runtime and do not use any values defined from the snapshot (new default behavior, described above).

With JR52960 a new configurable property "epv-deploy-default" has been introduced to toggle between the two behaviors. After applying the fix the default behavior will be reverted back to how it was in previous releases where the latest modified EPV value is migrated. This means the property by default is set to 'false'. Once the property is enabled (true) then the default EPV value from the snapshot will be once again be used during deployment or instance migration.
You can find the iFix and its pre-requisites on Fix Central: https://www-947.ibm.com/support/entry/portal/search_results?sn=spe&filter=keywords%3Aibmsupportfixcentralsearch&q=JR52960

IBM BPM - Task Management using server script ( ReAssign Task & Complete Task )

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Wed, 3 Jun 2015 00:02:00 +0530

Assign to me

tw.system.findTaskByID(tw.local.iTaskId).reassignTo(tw.system.user_loginName);

Complete Task

If we have output variable for task, we have to add those all output variable in map as below:

var outputVariable = new tw.object.Map();
outputVariable.put("out1","");
outputVariable.put("out2","");
outputVariable.put("out3","");
outputVariable.put("out4",0.0);
outputVariable.put("out5","");
outputVariable.put("conditioninBPD", "success");

tw.system.findTaskByID(tw.local.iTaskId).complete(tw.system.org.findUserByName(tw.system.user_loginName),outputVariable);

IBM BPM - Design Patterns

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 2 Jun 2015 23:35:00 +0530

Introduction

IBM BPM provides a number of generic artifacts for modeling purposes. These can be combined in a variety of ways in order to solve different technical problems.
A design pattern is used to document how a combination of model artifacts may be used together in order to solve a specific technical problem. Unlike a framework or utility, a design pattern cannot be deployed directly. A design pattern is rather like having a pattern template for making clothes, where a tailor may use the same template to create a number garments using different materials.
The design pattern provides a design template that allows the BPM developer to solve the same technical problem consistently throughout the model using different artifacts. Design patterns promote re-use and improve maintainability. Example design patterns include Layered Architecture, Task Services, Coach Services, Data Access Services and Manual Unit Tests.

General Patterns

This page outlines a number of general design patterns.
If reading for the first time it is recommended that the reader should read these key patterns in the following order:

1. Smart Folder and Tagging

Design Pattern

Objective

Tags can be used to create specific smart folders making it easy to manage and account for the development cycle of the assets being created. Using the “By Tag” library view, a user will be able to sort through a large asset library quickly.

You’re not limited to just one tag per component. For instance, if you have a service/BPD/integration that tests your database connections it would be tagged as both a test and a database service.

General (Pre-Exist in TW7)

Tag	Purpose
Data Access	General data access integrations (CRUD)
Data Transform	Transforms data from one form to another (e.g. when coming out of web services into a BPD)
Database	To distinguish Integration services that interact with databases
Exceptions	Used to handle exceptions
Deprecated	Items that are kept around for backward compatibility but are no longer the recommended implementation
Installation	Used for the installation of a process app or toolkit
Integration	A specific integration implementation
Report	Implementation that is used for reporting purposes
Reporting	To distinguish which services, variables, tracking groups, etc are linked to reporting
Security	Anything that is dealing with security, such as users and groups
Task	Specifically used to implement a task in a process. Can be used on all first-level task services
Test	To distinguish Test Harnesses
Top Level	The top-level BPD or a top-level service. Can be useful with an associated Smart folder to know where the top items are
UI	Helpers for human services, such as getting lists of text for a list
Utility	A utility service
Web Services	To distinguish Integration services that interact with web services

Naming Convention

Tag services as required in the Naming Conventions Pattern

Other Tagging Options

If your developers are the compulsively organizational type, try the following ideas for tags, and let us know the results. We’re always looking for feedback.

Development Status Based Tags - Tag each and every artifact with its development status (To Do, In Progress, Completed, etc.).
User Based Tags - Tag Task Services, Reports, and BPDs by the users/participant groups that will be using them.
Process Based Tags - If you have a process app with multiple processes, tag each process-specific artifact with a tag of the BPD it’s associated with.

Smart Folders

Objective

While the new library in IBM BPM versions 7 and up eliminates the cluttered, confusing nested library structure of previous Teamworks versions, it also eliminated the ability to quickly access top-level services and business process diagrams. We can eliminate this deficiency, and improve our development experience, by using tagging and smart folders.

Application

There are 4 types of IBM BPM artifacts that we want to be easily accessible. Create a shared smart folder for each tag listed in the table below.

Smart Folder	Tag	Description	Example
Top-Level BPDs	Top-Level BPD	These BPDs should be the highest level BPDs in your process app. You may only have a few, but the ability to get to them quickly is important.	An enterprise HR Onboarding process BPD. This may live in the HR Process App, alongside other processes, but it stands alone from others (i.e. offboarding, conflict resolution, etc.). We would tag the HR Onboarding process with “Top-Level BPD”, and it would add itself the top-level BPD smart folder. We would not tag any sub-processes this BPD has (i.e. background check, adding to payroll system, etc)
Top-Level Services	Top-Level Service	These stand-alone services (primarily Human Services) do not exist in any BPDs.	A CRUD (create, read, update, delete) service used to allow users to manually manage database content, event schedules, etc. A service that contains a report embedded in a coach, which will be deployed on the Left Side Navigation bar in the IBM BPM Portal. A service that allows users to drilldown through process instances and the data/statuses associated with each.
Integrations	(Use system specific tag)	These are services which contain integrations with other systems. Note: To create this folder, use system specific tags (i.e. Database, Document Management, Legacy System). This way, you’ll be able to sort your smart folder by integration (sort by tag).	A service that updates customer information using a webservice A service that writes a document to a content management system.
Test Services	Unit Test	Services/BPDs used to test User Interfaces, Integrations, Process flow, etc.	A service used to test an integration with a document management system. A service used to test a user interface’s validation on a customer service coach. A BPD used to test proper process flow.

Examples

Smart Folder	Example Screenshot
Top-Level BPDs
Top-Level Services
Integrations
Test Services

2. Naming Conventions

Purpose

To provide a standard method of naming TW artifacts to better organize and manage process apps. Additionally, updating the standard from Teamworks 6 in order to leverage new features in Teamworks 7 and make this pattern easier to learn and use.

Noticeable Changes from the TW6 pattern

Prefixes

Because of the separation of process apps in Teamworks 7, there is no longer a worry of cluttered libraries with artifacts from multiple different process apps. This removes the need for prefixes.

Body

The use of reserved verbs will help to clarify the action/use of a service.

Abbreviated Suffixes

Due to the new service types in Teamworks 7, and the addition of tagging capability, abbreviated suffixes, used heavily in Teamworks 6 naming convention pattern, are no longer part of the pattern. This should help make the naming pattern simpler and more user-friendly.

Artifacts

New service types allow artifacts to have simpler names, and the use of tags will allow clarification for users.

Tag	Artifact Type	Description	Notes	Examples
Tasks	Human Service or General System Service	A service that directly implements an activity. Such a service is responsible for coordinating a whole task for a user/system.		Register Sales Opportunity
Coaches	Human Service	A service that implements a single coach. It is generally recommended that a service not have more than a single coach in it.	If the coach service has the same name as the task service, add the suffix “Coach” to the coach service.	Register Sales Opportunity Coach
Events	General System Service	A service that is used specifically to invoke an Event Driven UCA.	The UCA has the same name as this service. If event based, append “Event” on both this service and the UCA	Start Sales Cycle Event
Event Implementation	General System Service	A service that directly implements an Event Driven UCA.	To name this service, precede the UCA name with the reserved verb “Implement”.	Implement Start Sales Cycle Event
Data Access	Integration Service or General System Service	A service whose specific purpose it is to get some data from inside (EPV, properties, variable) or outside (DB, LDAP) Teamworks and return it to the calling service/BPD.	Use the reserved verb “Retrieve”.	Retrieve Company Info
Unit Test	Human Service, General System Service, BPD	A service designed to test another service or BPD.	The unit test has the same name as the service/BPD being tested with the reserved verb “Test”. This can apply to any other type of service, such as task services, coach services, web service services, etc.	Test Register Sales Opportunity
Coach Validator	General System Service	A service used to encapsulate coach validation logic.	This is used in conjunction with the Coach Validation Framework. Service name starts with reserved verb “Validate”.	Validate Sales Opportunity
Batch	General System Service	A service that directly implements a Batch/Chron driven UCA.	To name this service, precede the UCA name with “Batch” and the reserved verb “Implement”.	Batch Implement Sales Cycle Event
Utilities	General System Service	A service that implements some piece of utility functionality (such as text parsing for valid email format, etc)		Parse Email Addresses
Inbound Web Service	Web Service	A service that directly implements a Teamworks hosted Web Service.		ReceiveProductDetails
Outbound Web Service	Integration Service	A service that wraps a Web Service connector.		Update Sales Opportunity in Salesforce.com
Constructor	General System Service	A service that initializes a variable.	Precede the variable name with the reserved verb “Construct”	Construct SalesforceOpportunity
Business Object	Variable Type	A variable type that resides within the Business Object Model layer within a layered Teamworks architecture. These are used to define a common view of business data within a Teamworks process.		SalesforceOpportunity
View Object	Variable Type	A variable type that resides within the View layer within a layered Teamworks architecture. These may be defined to present data in a specific way.
Integration Object	Variable Type	A variable type that resides within the Integration layer within a layered Teamworks architecture. These may be used directly with SQL and Web Service connectors that load data directly into Teamworks variables.	It may be useful to include the system being integrated with in the title of the variable.	SalesforceSalesOpportunity

Example Library

Reserved Verbs

These verbs can be used at the beginning of artifact names in order to more clearly specify the action of the service.

Verb	Use	Example
Retrieve	Pulling data from a system of record	Retrieve Product Details from Salesforce
Write	Creating a new record in a system of record	Write Customer Details to Salesforce
Update	Updating an existing record in a system of record	Update Customer Details in Salesforce
Delete	Removing a record from a system of record	Delete Customer from Salesforce
Send	Sending a message event/email to another system/participant	Send Email to Customer
Receive	Receiving a message event to and from a participant	Receive message from Salesforce
Validate	Validating a coach using the coach validation framework	Validate Product Details Coach
Test	Testing a service	Test Delete Product Details from Salesforce
Construct	Initializing a variable type	Construct ProductDetails
Implement	Implementing a UCA	Implement Batch Timer

Higher Level Artifacts

Snapshot Names

Snapshot names should do at least 1 of 2 things:

Provide a date stamp of the snapshot (e.g. v15March2010 or 14June2010Release)
Describe change/enhancement (e.g. RouteAroundExecutiveApprovals)

Here is an example of a more detailed naming convention around Snapshots
Special Note for BPM Advanced
Not all the recommendations apply to BPM Advanced. For example, refer to this infocenter reference in situations where you want to use more than 3 digit numeric snapshots.

(Prior Release/Production).(Playback/Maintenance Release).(Snapshot per Current Playback/Maintenance Release).(Workspace branch)
Examples:
- Snapshot for Release 1 development prior to installation to Production, during playback 3 development, the 6th snapshot during this time = 0.3.6
- Snapshot for Release 1 development post installation to Production, during development for the 2nd maintenance release, the 4th snapshot during this time = 1.2.4
- Snapshot for Release 1 development post installation to Production, in a workspace taken from a branch at 1.2.4, 1st snapshot in this branch= 1.2.4.1
Once there are multiple releases and multiple workspaces, this might need to be expanded to incorporate that. A possible approach would be going to other snapshots for subsequent releases (normally with a major scope change) or starting over from a snapshot of choice from a prior release.

Environment Variables

Environment Variables Naming Pattern: Coming Soon

Process App Names

Name your Process Application after the main process in the PA or the business term/purpose for the PA
Don’t use words “Process Application” in PA’s name

Toolkit Names

Name the toolkit after what utility/services it provides
Add “Toolkit” or “Framework” word to the name, so the export of it can be differentiated from process applications.

Process App & Toolkit Names

Don’t use very long names try to keep it less than 64 characters
Use white space between words to improve readability
Avoid using abbreviation (this is what acronym is meant for) except common words to make the name shorter
Put additional information in Description field
Don’t use version number in the name (this is what snapshot should be used for), unless want to bring attention to the major change in the solution (like Axis2 vs Axis)

Diagram

The names of model artifacts should be shortened to be readable on the diagram, but they must still provide an explanation of what the attached artifact does.

Specific Conventions

Logging. For most logging-related library items, the words “Log” or “Logging” should appear in the name.
Layouts. Layout names will generally include the name of the specific type of layout, e.g. a coach layout will have the word “Coach” in it. Again, this is not necessary, but it is useful.
Variable Types. Variable types must be all one word, no spaces and a limited selection of special characters (0..9 and _ are allowed). Also, variable types should always begin with a capital letter. Usually new types are defined to be complex objects (structures), and the standard for capitalization for such types is to be capitalized.
UCAs. UCAs that will be used as Events in a BPD should be named with the word “Event” in the name. For example, “New Order Event”. The services which implement these UCAs should be labeled as “Implement New Order Event” for example. UCAs which are not tied to a BPD implementation should not include the word “Event” in the name.
UCAs require attached Services – and it’s best to follow a convention where the name of the Service is “the same” as the name of the UCA. While it’s true that multiple UCAs can be attached to the same Service, it’s generally easier to think of them in terms of a paired Service and UCA.
Decision Points. Decision points, whether in BPDs or Services, should be in the form of a question. All of the lines coming out of the decision should be answers to the question.
Lines coming out of Decision points should have labels that indicate the condition under which the path is taken. Labels such as “yes” and “no” require the reader to trace back to the Decision Gateway, so they should be generally avoided in favor of something more descriptive like “loan exceeds $100″.

3. Reuse

Design Pattern

Reuse is recognized as a fundamental best practice within the IT industry and has been practiced from the earliest days of programming. This basic principle is the basis of many other best practices including modularity, loose coupling, high cohesion, information hiding and separation of concerns.
The idea is that a solution should be comprised of reusable modules instead of replicating complete sections of the solution no matter how large or small. Each module is written once and maintained in one place. If another aspect of the solution needs the same functionality then it can simply delegate to the module that provides that functionality. This avoids redundancy within the solution, improves maintenance time, and promotes consistency.
Within IBM BPM resue is achieved by wrapping reuseable aspects of the solution within a service. A library of reuseable services may be developed that can simply be dragged onto other service or BPD diagrams as many times as required. Many other design patterns are based upon this idea. For example, the task service design pattern illustartes a specific example of a reusable service.
Services may be used to wrap other model artifacts, such as coaches and server script, that cannot be reused directly without introducing redundancy. The coach service design pattern and data access service design pattern provide good examples of this.
Generally it is a good idea to avoid exposing java script to business users wherever possible. Wrapping server script within a reuseable service hides the complexity of the Java Script and provides a simple component which the business user is more familiar with.

4. Constructor Design Pattern

Use the constructor design pattern to create and initialise the data in your business objects in a consistent fashion and in one single place with a reusable component model within a Process Application or Toolkit. Adopt this design approach, instead of having multiple process code locations for initialising and setting default values for Business Objects. Typically, Business Object initialisation is done using local private JavaScript blocks which make the code difficult to manage, update and leads to errors/defects that difficult to trace and fix.
This pattern is a specialisation of the standard Singleton Design pattern.
The main parts of this pattern are:
Define a Business Object variable
Create a general system service to be used as the singleton constructor
Declare the target Business object as an input, output and private variable.
Model the General System Service
Create an initialisation wrapper service that calls the constructor
The example below creates a constructor for a list of Job Business Object.

Define a Business Object variable

In this case, I’m using a complex variable called Job
The Business object consists of three parameters – JobDescription, JobStatus, and JobCompleted

Create a general system service to be used as the singleton constructor

Create a service of type “General System Service” that will be used to instantiate the Business Object and set default values, if required.
I’ve used the prefix underscore (_) in the name to indicate this service is a helper or utility service that should only be used within other services and never directly in a human service or BPD activity. This makes it easy to spot misuse and ensure process developers are using agreed design guidelines. Also make it easier to unit test services based on different implementation and usage types.
Created _constructorListOfJobs

Declare the target Business object as an input, output and private variable.

If your variable is a list also declare as an input an integer for the size of the list to be created and populated with default values.
The input and output variable should be the same Business Object type and have a descriptive name.
The private variable should be the same Business Object type as the input and output variables, called something like “_constructor”, using a naming convention to indicate this is only ever to be a private variable.
Select the “Has Defaults” check box for the private variable to auto-generate the script to create and initialise the Business object.
See screenshots below for details.

Model the General System Service

Create a script block that contains the default values for this type of Business Object.
In addition, you should add error handling and logging to catch any errors. Typical errors would be initialisation script errors occurring after the modification of the Business Object, for example renaming a parameter.
Usually, the “Has Defaults” auto generated script should update in synch with any changes in the Business object. If it does not for whatever reason, just uncheck and recheck the check box to correct the “Has Defaults” auto generated script.
If required, make the necessary changes to the default values initialisation script block. Now any referencing BPD or Service that requires a variable of this Business Object type to be created, initialised and possibly have default values set will automatically have the benefit of these changes.
Always nullify private variables for efficient memory management.
I’ve used two exits as this is consistent with the developer guidelines agreed on the project for modelling utility and helper services. This simplifies the models in parent services and makes the flow logic clear when a system error, as opposed to business exception, has occurred.

Create an initialisation wrapper service that calls the constructor

Create a wrapper service that encapsulates and calls the constructor. This also has the benefit of being able to use the “Where Used” feature on the modular wrapper service to clearly see references to other services and BPDs using this particular Business Object initialisation logic, instead of trawling through individual private JavaScript blocks.

5. Loop Design Pattern

There are two ways to implement loops within services. One method is to write it entirely within Javascript, the other is to do it diagrammatically.

The preceding image illustrates a loop implemented diagrammatically. Some of these steps actually use small snippets of Javascript, but these are very simple constructs that business users can easily understand. The loop requires a counter to indicate the number of times the loop has been iterated. An Integer may be used for this purpose and is set to zero during the initialisation of the loop. Any other variable initialisation may also be performed during this step. For example:

tw.local.count = 0;

tw.local.policyDebt = 0;

Loops are typically used to iterate over a list variable. The list may be empty, so the loop exit criteria must be checked before looping commences. The decision gateway Yes path will require a condition to be specified. For example:
tw.local.count < tw.local.claims.listLength
Some action will be performed each time round the loop. Typically, this may be a Service, a Server Script or a combination. The list variable and counter may be used together to identify the next item within the list. This may be mapped to either an input or an output parameter of a service, or directly within a Server Script. For example:
tw.local.policyDebt += tw.local.claims[tw.local.count].debt;
Before re-entering the decision gateway the counter is incremented. This either locates the next item within the list or triggers the exit condition. For example:
tw.local.count++;
The following code segment illustrates a loop implemented entirely with Javascript:

tw.local.policyDebt = 0;

for(varcount = 0; count 
  tw.local.policyDebt += tw.local.claims[count.debt];

}

The advantages of using the Javascript approach are:

Performance improvement. There is a minimal run-time performance overhead when using the diagrammatic approach.
The speed of development. An experienced Javascript programmer may prefer this approach as it is quicker to implement.

The advantages of using the diagrammatic approach are:

Easy for business users to understand. i.e. They don't have to become a skilled Javascript programmer.
Easy to debug. The process inspector allows BPM developers to step through each step within the loop and examine variables. Conversely, Server Scripts are executed atomically, so it is not possible to step through each step within a loop written entirely within Javascript.
Avoids infinite loops. It is possible to define a loop either using Javascript or diagrammatically where the exit criteria is never satisfied. i.e. it loops forever. IBM BPM provides a facility to detect infinite loops. With diagrammatic loops it is possible for IBM BPM to stop services running infinite loops by using the admin console, whereas the only way to stop infinite loops written entirely in Javascript is to restart the process server.
Allows nested services to be used within the loop. This is also technically possible within Javascript but it has its drawbacks - the syntax it is not business user friendly and services invoked using Javascript cannot contain coaches.

Additional Notes

If you run a simple test you may see exponential performance impact as you increase the number of loops. However, this is likely due to the structure of your test.
When you add even a small operation, say a 20ms unit of work to be performed inside the illustrated test with a single loop of size 100, the results are no longer different between scripting and diagramming your loop. You'd have 210s (canvas) vs. 200.055s (script). For larger units of work, the difference approaches zero and becomes negligible.
Unless the unit of work inside the loop is insignificant (less than 10ms) and the size of the loop is significant (larger than 100) the performance difference between diagrammatic and script is negligible. On the other hand, there will always be the JS sync issue in anything prior to TW7.
The only time a script loop makes any sense is for very small loop size and/or very small unit of work contained inside the loop.

6. Constants Pattern

Overview
Teamworks does not provide a model artefact specifically designed to maintain constants used within the Solution. Constants are used to promote consistency, improve maintenance and reduce typographical errors. Exposed Process Values (EPVs) are intended to be used to allow business users modify the parameters affecting business rules within the solution. However, EPVs may also be used to maintain constants.
For each EPV variable the External Name, Variable Name, External Description and Default Value should all be identical, as illustrated in Figure 1. Constants should not be directly exposed within the user interfaces, use localization resources instead.

Source : IBM

IBM BPM - Functional Architecture

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 2 Jun 2015 23:05:00 +0530

Design Pattern

IBM BPM provides business process governance by leveraging existing legacy systems and data sources within organisations. IBM BPM is not intended to be the master of record nor replace existing systems and data sources, instead it integrates with these legacy assets, as illustrated in figure 1 (left-hand side). IBM BPM is a server-side application and provides its human interface by leveraging thin-client web browser technology supported by modern desktop computers and mobile devices. Figure 1 (right-hand-side) illustrates how a IBM BPM solution may be divided into a number of architectural layers. Figure 2 (left-hand-side) illustrates where various model artefacts reside within each layer of the architecture. Each layer is responsible for a specific aspect of the solution. These model artefacts are described within other design patterns.

The basic premise of these layers is based upon the de-facto Model-View-Controller design pattern that has been widely adopted throughout the IT industry. The Business Process layer is responsible for enforcing business process governance, the View layer is responsible for providing the user interface, and the Business Object Model (BOM) layer is responsible for providing a consistent means for accessing business data (regardless of where the data originated). The Business Object Model layer provides a common definition of business entities, their relationships and behaviour. The Integration layer is responsible for communicating with a variety of legacy systems and data sources in order to retrieve and store data. The Integration layer is responsible for interfacing with external systems and data sources using appropriate technologies (such as JDBC, Web Services, and Java connectors) and shields the other layers from having direct exposure to these interfaces.
Clients are encouraged to assemble BPM project teams with individuals from both the Business and IT. Clients often ask which aspects of the solution should the business be responsible for and and which aspects of the solution should IT be responsible for. A common assumption is that it should be possible to draw a horizontal line within the layered architecture to indicate which layers belong to the business and which belong to IT. In reality both parties are responsible for all layers within the architecture but the emphasis changes within each each layer, as illustrated in Figure 2 (right-hand-side). The diagram illustrates the division of responsibility with a diagonal line that passes through all the layers. The business has greater responsibility within the layers towards the the top of the architecture and IT has greater responsibility within the layers towards the bottom of the architecture.

Figure 3 illustrates how data is passed between the layers (left-hand-side) and how data is transformed between the layers (right-hand-side). Each legacy asset usually has its own definition for representing business data. The Integration layer shields the other layers from these different data models and is responsible for transforming business data into the common Business Object Model. Similarly, the View layer may need to provide different ways of presenting data based upon the common Business Object Model. The View layer is responsible for translating data between the Business Object Model and the data structures required to support the various user interfaces. IBM BPM combines business data with coach definitions and automatically transforms it into HTML pages that are displayed within the web browser and vice-versa.

Reference Architecture

Purpose

The reference architecture depicts typical cases of a functional architecture in traditional BPM projects.This can be taken as reference, guideline and best practice to create the application architecture on any BPM development project.There will never be a 100% pre-formed solution, therefore this may apply for 80% of cases and case dependent adjustment are recommended to be done.

Architecture Overview

The blue parts depict what’s usually part of the decision process of a BPM project.
The gray portion shows the pieces of the architecture that are usually out of scope to be designed by a BPM project are mostly part of a Enterprise Architecture initiative.
Most scenarios involve:

BPM itself with either coaches or a third party UI.
A shared service environment (ESB)
Shared data, which can either be enterprise master data management systems or simply other applications which have data that need to be accessed by one or more external systems

The reference architecture is divided into 4 layers:

User Interface (UI)

Visualization layer.
Mostly coaches are being used, therefore this can almost be neglected as coaches interaction with the process out of the box.
A commonly used alternative are custom UI, e.g. for mobile devices that interact with BPM using the REST API

Application (App)

The application layer holds the logic for each business application. Whether it is process oriented or not.
Business logic should always be solely held on the application layer and NOT distributed. Common mistakes are to have business logic either on the UI layer or even ESB.
If external systems interact with BPM, this can happen through different ways.
BPM can expose a service, e.g. web service, which would be called through ESB.
If the actual application is a combination of a external system together with BPM, it makes sense to interact using the WebServices API.

Integration – Enterprise Service Bus (ESB)

The ESB or Integration Layer is the portion of a architecture that integrates a application with other applications.
It is important to understand that a ESB is not a product. A ESB is a concept of a single instance (a bus) that exist within a company which enables you to access other enterprise services or data.
A ESB can be implemented different ways.
A very common and recommended way is to use existing products such as WebSphere Message Queue (MQ), WebSphere Message Broker (MB) or WebSphere ESB. However, it is not uncommon that clients have their own implementation of a ESB. Often even as custom java implementation.

Canonical Model

A ESB often implements the recommended pattern of a “canonical model”.This simply means that the enterprise data model “lives” on the ESB.Any application should basically implement this model. However, due to historical growth and many other reasons, application are often not able to do that or change their model into that fashion.For every service call that a application can do TO the ESB, the service data model gets the transformed into this standard model. From there it gets transformed into the target data model (if not the same).Through this, every transformation has only to be done once and is way more flexible for changes and enhancements as opposed to point-to-point transformations where every service call would have to maintained manually.

IBM BPM - Coach Views Separation of Concerns

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 2 Jun 2015 22:58:00 +0530

The following good practices are related to ensuring the right people are focused on the right things.

Good practice – Divide the labor when you author custom coach views

Coach views are reusable user interface controls in the coaches framework of IBM® Business Process Manager (BPM). IBM supplies a number of stock coach views, but you can create your own coach views for your own purposes. For these custom coach views, a good practice is to distinguish between atomic coach views and composite coach views:

Atomic coach views are coach views that are written with HTML and JavaScript. These coach views should be authored by someone on your team who is skilled in these languages. Everyone else on the development team can reuse atomic coach views that the skilled developer authored. Put these coach views into one toolkit for easy reuse.
Composite coach views are coach views that are built from other coach views, for example a date-range coach view or user-address coach view. These coach views can be authored by team members who do not have HTML or JavaScript skills because authoring these coach views involves laying out and configuring other coach views.

From a division-of-labor perspective, have one full- or part-time UI expert on the team to build the relatively rare atomic coach views; otherwise, the rest of the team can build many more reusable, composite coach views.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

Source: Leveraging the IBM BPM Coach Framework in Your Organization (SG24-8210-00)

IBM BPM - Security, Topology, Installation, Configuration, and Migration

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 2 Jun 2015 22:53:00 +0530

1. Good practice – Plan your release-to-release migration

Before you migrate from a version or release to another version or release, for example from V8.0.x to V8.5.x, in any production environment, make sure that you have migrated your staging or test environment and have tested your applications in the new environment.

Migrate to a new version for one or more of the following reasons:

You want to improve performance.
You need fixes that are in the new version.
You want to use new features that are provided in the new version.
Your existing product version is going out of service.

Test your migration procedures for one or more of the following reasons:

You must estimate in advance the amount of downtime that will be needed for migration. An estimate of downtime cannot be created without testing the migration procedures.
You want to make sure that the new version improves performance.
You want to make sure that the fixes you require are in the new version and work as expected.
You want to make sure that your existing applications work correctly in the new version.

For more information, read Planning a migration.

Applicable editions: Express, Standard, and Advanced
Applicable releases: All

2. Good practice – Specify configuration values in 100Custom.xml

There are a number of XML-based configuration files for IBM™ Business Process Manager that you should never directly edit:

99Local.xml.
00Static.xml
50AppServer.xml
60Database.xml
80EventManager.xml
98Database.xml

To ensure that you do not lose changes when you migrate to a new release, always edit the configuration values in 100Custom.xml instead of editing the configuration values in these files directly.

For detailed information, see The 99Local.xml and 100Custom.xml configuration files.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

3. Good practice – Use an offline process server for production

In IBM® Process Center, you can register online process servers and offline process servers. Online process servers are convenient for easily deploying snapshots to them by interactively using the Process Center user interface. However, for security reasons, it is a good practice to register the process server cell that runs your processes in production as an offline process server. By being offline, it prevents developers from being able to access and change the process using Process Designer’s inspector. Furthermore, being offline enables the Process Center and your mission-critical production server to be on different networks.

An acceptable alternative to using an offline Process Server for production is to have a separate Process Center just for online deployment to production. In this scenario, no Process Designer users should be given security permission to access the Process Center.

For information about how to deploy to an offline process server, see Installing snapshots on offline process servers.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

4. Good practice – Use the rolling upgrade option when you update IBM BPM

If you install IBM® Business Process Manager (BPM) fix packs V7.5.1.2, V8.0.1.2, V8.5.0.1, or upgrade to V8.5.5 or V8.5.6 from V8.5.0.1 or V8.5.5, you can use the rolling upgrade option. By using the rolling upgrade approach, you can incrementally upgrade one process server at a time, starting with test, then staging, and finishing with production. The final step is to upgrade your IBM Process Center and desktop tools. The rolling upgrade approach is safer because you can certify one cell at a time before upgrading the next cell, and it requires less down time for processes that are in production because you don’t have to wait for all the servers to be upgraded and certified to continue in-production processes.

Note, however, that in V7.5.1.2 your process servers must be offline, while in subsequent releases they can remain online. In all releases, you might not be able to debug your process applications by using IBM Process Designer until both IBM BPM Process Server and Process Designer are at the same level.

For more information, see Performing a rolling upgrade.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

5. Good-practice resource – Implement the appropriate IBM BPM production topology

Are you an IT architect or IT specialist who wants to understand, select, and implement the appropriate production topologies for an environment? If so, follow the step-by-step instructions to build those topologies in the appropriate information:

IBM Business Process Manager Version 8.0 Production Topologies – This IBM® Redbook® describes how to build production topologies for IBM Business Process Manager (BPM) V8.0 and is an update of the existing book IBM BPM V7.5 Production Topologies, SG24-7976.

Business Process Management Deployment Guide Using IBM Business Process Manager V8.5 – This IBM Redbook provides an introduction to designing and building IBM Business Process Manager V8.5 environments. It introduces the changes and new features in IBM BPM V8.5 and provides an overview of the basic topology and components. This book also provides an overview of a consolidated migration approach that was introduced in V8.5.

Planning your network deployment environment – This topic specifically refers to the IBM Business Process Manager V8.5 production topology.

Applicable editions: Express, Standard, Advanced

Applicable releases: All

6. Good-practice resource – Secure your IBM BPM environment

It is important to secure your IBM® Business Process Manager environment.

If you are on IBM BPM V7.5.1, consult the IBM Redbooks® publication IBM Business Process Manager Security: Concepts and Guidance, which provides information about security that concerns an organization’s business process management (BPM) program, common security holes that often occur in this field, and techniques for rectifying these holes. This book documents preferred practices and common security hardening exercises that will help you achieve a secured IBM BPM installation.

If you are on IBM BPM V8.0, see Securing IBM Business Process Manager and application.

If you are on IBM BPM V8.5, see Securing IBM Business Process Manager and applications.

If you are on IBM BPM V8.5.5, see Application security and Creating a secure environment.

If you are on IBM BPM V8.5.6, see Application security and Creating a secure environment.

Applicable editions: Express, Standard, Advanced

Applicable releases: All

7. Good-practice resource – Use the IBM Business Process Manager Interactive Installation and Configuration Guide or the Interactive Migration Guide

The IBM Business Process Manager Interactive Installation and Configuration Guide takes you through the steps for installing and configuring IBM Business Process Manager (IBM BPM) by using installation and configuration rules and considerations that are described in other topics in the documentation.
If you are migrating business data and applications from a previous version, use the IBM Business Process Manager Interactive Migration Guide instead. The Interactive Migration Guide generates instructions for a complete migration, including installing and configuring IBM BPM.
Applicable editions: Express, Standard, and Advanced
Applicable releases: All

IBM BPM - Performance

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 2 Jun 2015 22:43:00 +0530

1. Good practice – Avoid excessive use of server-side JavaScript

Avoid large server-side JavaScript blocks within BPDs and services, because JavaScript is interpreted and therefore is slower to process than other compiled mechanisms, such as Java™ code.

Furthermore, large JavaScript scripts often indicate that too much integration logic is being placed in the business process layer instead of having that logic encapsulated in Java code, or in an Advanced Integration service if you are using IBM™ Business Process Manager Advanced, or externally in an Enterprise Service Bus.

Beyond performance concerns, complex JavaScript runs the risk of infinite loops and other coding errors that are hard to triage and recover from.

Applicable editions: Express, Standard, Advanced.

Applicable releases: All

2. Good practice – Avoid large business objects in a process or service

Business processes in IBM® Business Process Manager should store only the data that is needed for the process or a service in the process as the process runs. Avoid large “cargo” object data being carried through the process because that data needs to be persisted as process instance state.

When large amounts of data are stored as variables, they use memory and disk space in the process database, require serializing and deserializing, and they will be copied on by-value invocations. According to the IBM Business Process Manager V8.5 Performance Tuning and Best Practices Redpaper, “In general, objects that are 5 MB or larger might be considered “large” and require special attention. Objects of 100 MB or larger are “very large” and generally require significant tuning to be processed successfully.”

One way to avoid carrying data is to use the Claim Check pattern; the large object is persisted in a separate system of record and only a reference to it is used in the process. Claim Check is an enterprise integration pattern (eaipatterns.com/StoreInLibrary.html). For information about using the claim check pattern with BPEL, see Improving application efficiency with the Claim Check pattern in WebSphere Integration Developer V6.2.0.1.

In addition, retrieve data only when it is needed, and carry data for only as long as it is needed. Consider the following examples:

A process refers to a customer and displays the customer’s address and order history at a point in the process. If the process does not need this information elsewhere, it should not be stored in the process; the information should be retrieved from the system of record as reference data before it is displayed.
A call to a web-service brings in 100 fields of data. The process needs only 2 fields of this data. Ensure that the rest of the data that is retrieved from the call is not stored and that the variables are nulled after use so the JVM can do garbage collection.
A process requires a file to be uploaded by a user and added to an Enterprise Content Management system. This scenario is best handled by using the Document List coach view which allows uploading of a document directly from a user’s machine without using an intermediate process or service variable to hold the contents of the file.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

3. Good practice – Avoid multiple sequential system lane activities

In IBM® Business Process Manager, minimize the extra resources that are needed for multiple system lane transitions.

Each system lane activity is considered a new Event Manager task, which adds a task transition in IBM Process Server. These task transitions are expensive. If your business process definition (BPD) contains multiple system lane service tasks in a row, use one system lane task that wraps the others to minimize the extra resources that these transitions need.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

Source: IBM Business Process Manager V8.5 Performance Tuning and Best Practices Redpaper

4. Good practice – Place Process Center near where your Process Designer users are physically located

If you have a geographically disperse business process management (BPM) development team, it is better to have regional IBM® Process Centers than to have a single shared Process Center that is accessed by remote Process Designer authoring clients.

The Process Designer interacts frequently with the Process Center for authoring tasks. For this reason, minimize network latency to provide optimal response times. Place the Process Center in or near the same physical location as the Process Designer users. Process Designer clients that connect to a very remote Process Center might experience slow performance and dropped connections.

To share content between Process Centers, exchange .twx files or, as of IBM Business Process Manager V8.0, see Registering Process Centers and sharing toolkits.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

Source: IBM Business Process Manager V8.5 Performance Tuning and Best Practices Redpaper

5. Good practice – Purge data regularly

If your IBM® Business Process Manager data grows without bounds, it can over time lead to disk space issues and to performance issues as database queries take longer and longer to process. Therefore, it is important to have a policy of continuously removing older data. There are a number of places within IBM BPM where data is collected.

Consult the article Purging data in IBM Business Process Manager on developerWorks to understand where with the product data is collected and how to purge it. Decide which data to purge and how often.

Applicable editions: Express, Standard, Advanced

Applicable releases: All

6. Good practice – Use efficient SQL statements

When you write SQL statements directly in IBM® Business Process Manager, such as from server-side JavaScript in a service, ensure that you use typical SQL good practices for performance and resiliency.

Avoid using ‘SELECT * from ‘

When you use ‘SELECT * ‘ all the fields from the table or view are returned. If the table changes, the list of fields also changes, which might not be what you want, especially when you are mapping directly to a business object where the new names might not exist.

In addition, the asterisk (*) might return many columns in the results that are not needed but take up memory.

Instead, explicitly name the columns that you want returned as a result name, for example “SELECT AS , AS ”. The use of AS means that your business object names do not need to match the database column names and can be more meaningful. For example, CST1NAM could map to CustomerName.

Use parameter markers

Do not construct an SQL statement by concatenating variable names, such as

“SELECT CUST_NAME FROM CUST_MAST WHERE CUST_NUM=”+tw.local.customer_number

If you concatenate variable names, the database cannot precompile and cache the select statement because it changes every time.

Instead, use parameter markers, such as in “SELECT CUST_NAME FROM CUST_MAST WHERE CUST_NUM=?”, and then set the parameter value.

Better yet, wrap database access in an SOA service that is invoked remotely or by using an Advanced Integration service.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

7. Good practice – Use query tables for BPEL processes

For BPEL process list and human task queries in IBM WebSphere® Process Server and IBM Business Process Manager (BPM) Advanced, use composite query tables to achieve excellent response times for high-volume task and process list queries.

Particularly in production scenarios, use composite query tables instead of the standard Business Process Choreographer query APIs because composite query tables provide an abstraction over the actual implementation of the query and, therefore, enable query optimization. Furthermore, you can change composite query tables at run time without redeploying the client that accesses the query table.

For information about query tables, see Query tables in Business Process Choreographer.

Source : IBM

IBM BPM - Operations

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 2 Jun 2015 22:33:00 +0530

1. Good practice – Have a plan for regularly upgrading IBM BPM

Like all software, IBM® Business Process Manager (BPM) is constantly improving. Every so often IBM “rolls up” (consolidates) all fixes into a new fourth digit fix pack or third digit modification release. These releases typically contain many critical fixes.

To avoid experiencing a serious issue that a fix was made available for in the last, say, 10 or 12 months, have a regular plan for updating your IBM BPM software within its current release. For example, you might have a plan that checks for the latest service level every six months and schedules an upgrade if one is available. If a new fix pack or modification release is not available at that time, you can apply the latest recommended fixes for your release instead. You can search for the list of fixes that IBM recommends for a given release on Fix Central.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

2. Good practice – Monitor the Process Federation Server embedded Elasticsearch service by using the Head utility

You can use the open source Head utility to browse your Elasticsearch cluster, view the status and topology of the Elasticsearch cluster, and perform index- and node-level operations. You can also use the Head utility to call the Elasticsearch RESTful API. The Head utility has been tested successfully on Firefox and Internet Explorer browsers in this configuration. Some issues have been seen in Chrome with requests other than HTTP GETs.

Viewing Elasticsearch health and topology

In the Overview tab, you see the status of the cluster, the nodes, and the indexes. Here, you see the primary shards and the replicas for each node, the size of each index on the node, and the number of documents that have been indexed.

Checking index status

To see more in-depth information about the index, click Info and select Index Status.

Viewing index data

Select the Browser tab to view index documents and their data. To see the details and field values for a specific document, select an index to restrict the tabular view to show only documents from one index and then select a document within the tabular view.

Making REST calls

You can make Elasticsearch REST calls in the Any Request tab, which you do to verify the queries that the Process Federation Server made.

The forwarder application

The Elasticsearch Head utility can work with the HTTP port of the Elasticsearch service. However, because some browsers do not support mixed content on the same page and that the HTTP port does not support authentication, authorization, or secure communications, keep the Elasticsearch HTTP port disabled (the default configuration). As a secure alternative to the Elasticsearch HTTP port, Process Federation Server provides an application, called the forwarder application, that securely forwards REST requests to the Elasticsearch service, acting like a proxy server. However, the forwarder application forwards the requests internally only to the Elasticsearch process that runs on the same server. Before the forwarder application accepts Elasticsearch HTTP requests, it checks the authorization of the user who sent the request.

Note: For single sign-on to work correctly, the host name and port in the URL must be the same for both the Head utility and the forwarder application.

Ensuring security credentials can be shared

To ensure that security credentials can be shared across the Elasticsearch Head utility and the forwarder application, run the Elasticsearch Head utility from the Process Federation Server that also hosts the forwarder application. To run the Head utility from your Process Federation Server Liberty server installation, download the Head utility and then repackage it into a deployable web application archive (WAR file) that can be run on the Process Federation Server Liberty server.

For more information about the Elasticsearch Head utility, see https://github.com/mobz/elasticsearch-head.

Packaging the Head utility

On https://github.com/mobz/elasticsearch-head, click Download ZIP to download the elasticsearch-head-master.zip file.

2. The files contained within the zip file have a directory structure that looks like this:

-elasticsearch-head-master

– index.html

– dist

– …

Copy the contents of the extracted zip file under elasticsearch-head-master directory into c:\temp\eshead\ directory. The structure will look like this:

– eshead

– index.html

– dist

– …

Notice that all the files under the elasticsearch-head-master directory are now under the new eshead directory.

3. Create a c:\temp\eshead\WEB-INF directory:

– eshead

– index.html

– WEB-INF

– dist

– …

4. Create a web.xml file in the c:\temp\eshead\WEB-INF directory:

– eshead

– index.html

– WEB-INF

-web.xml

– dist

– …

5. Edit the web.xml file and copy the following text into the file:


    ESHead
    ESHead
    
        ESHead
        
            UIContent
            /*
        
        
            esadmin
        
        
            CONFIDENTIAL
        
    
    
        BASIC
    
    
        esadmin
    
    
        index.html

6. Create a .zip file of the c:\temp\eshead\ directory and call it ESHead.war. The zip file will have the following structure:

– index.html

– WEB-INF

-web.xml

– dist

– …

Notice that the structure does not have the elasticsearch-head-master directory.

Setting up the Head utility

To configure Process Federation Server Liberty, complete the following steps:

Edit the server.xml file.
Ensure that the forwarder application feature is enabled in the section:
ibmPfs:federatedForwarder-1.0
Ensure that the Elasticsearch port is disabled by updating the attributes of the section:
http.enabled=”false”
Add authorized users, groups, or special subjects in the
element. For example, to allow all logged-in users to administer, monitor, and search the Elasticsearch data, use the following configuration:
```
        
            
        
        
            
        
        
            
        
```
Copy the ESHead.war file into the pfs_install_root/usr/shared/apps directory on your Process Federation Server Liberty server.
Add the following sections to the server.xml file. Note that the location is the name of the .zip file that you created previously; the default directory is \usr\shared\apps directory. The security role that you define must be the same as the role that is defined in the web.xml file (in this example it is “esadmin”). You can also authorize a group or special subject instead of a user.
```
     
        
                          
              
           
        
     
```
Ensure the user, group, or special subject is in the bpmadmin and bpmmonitor security roles of the com.ibm.bpm.federated.forwarder.authorization authorization role, as previously described. In this example, all authenticated users have access to the forwarder application, but only the admin user has access to the Head utility.
Restart Process Federation Server Liberty.

Accessing the Head utility

Go to https://:/ESHead.
In the Head utility, enter the location of the administrative forwarder application, for example https://localhost:9443/elasticsearch-admin/

Source : IBM

IBM BPM - Methodology

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 2 Jun 2015 22:29:00 +0530

1. Good practice – Ensure business processes have a business owner

Business process management can only succeed when there is a close partnership between IT and business. This collaboration is most critical when it comes to designing the processes themselves, both capturing today’s as-is information and tomorrow’s to-be information. Ensure that all business processes have a business owner who is the subject matter expert for that process. This process owner should attend all playbacks and have a final signoff on the process model.

Applicable editions: Express, Standard and Advanced

Applicable releases: All

2. Good practice – Plan for and perform non-functional testing

Before going into production, ensure that you planned for and tested non-functional aspects of your process, including response time of the user interface, throughput, and scalability. Allot adequate time for this phase before going to production. The test environment should match the target production system as closely as possible, and the use cases should represent both typical and stress scenarios that are anticipated in production. All systems should be tuned according to the IBM BPM Performance Tuning redpaper guidelines before you perform the non-functional tests.

Applicable editions: Express, Standard and Advanced

Applicable releases: All

3. Good practice – Plan for disaster recovery

Many factors, ranging from human error to natural disasters, could compromise the capability of the hardware infrastructure that runs your IBM® Business Process Manager (BPM) system. To preserve business continuity when an entire data center is lost, it is important to have a disaster recovery plan. This plan describes the operational procedures that must be followed to regularly replicate the configuration data and the runtime data that comprise your IBM BPM system as well as the operational procedures that must be followed when restoring the replicated data to an alternate data center.
There are several options available to IBM BPM administrators who want to design this type of replication strategy. One such option is described in detail in Storing transaction and compensation logs in a relational database for high availability and disaster recovery in IBM Business Process Manager. But consider other strategies as well.
For more information, see Disaster recovery and Disaster recovery guidance for IBM Business Process Manager: An updated approach for IBM BPM V8.x.
Applicable editions: Express, Standard, and Advanced
Applicable releases: All

4. Good-practice resource – Learn about IBM BPM from an expert

Neil Kolban is an IBM employee who focuses on the IBM Business Process Manager and related products. Over time, he has built and collected information related to the use of this product that he has found to be of value and has bundled this information into a book that is available as a PDF document that you can download. The book is released once a month (normally on the 1st day of the month), so it is a good practice to bookmark this page and reference it as required.

Kolban’s Book on IBM BPM

Although Neil is an IBM employee, please note that any words, concepts or content may not necessarily represent the views of IBM. This book does not replace the information center for official product documentation

Applicable editions: Express, Standard, Advanced

Applicable releases: All

5. Good-practice resource – Learn about troubleshooting IBM Business Process Manager

Troubleshooting IBM® BPM issues can be complex without the correct tools and techniques. Troubleshooting IBM Business Process Manager describes a set of tools and techniques that the IBM BPM team suggests to help you with problem determination.

Applicable editions: Express, Standard, Advanced

Applicable releases: All

6. Good-practice resource – New to IBM BPM? Start with the Hiring tutorial

If you are new to IBM Business Process Manager (BPM) and on V8.5 or later, check out the new Hiring tutorial.

After you complete the tutorial, you will be able to do the following tasks:

Model a process that is based on process requirements.
Implement a process, including data variables and services that are required by the process.
Create the user interface for the process.
Conduct playbacks to validate the work that you completed.
Run and review the process.

The Hiring Tutorial covers everything that you need to know to re-create the Hiring Sample process application that is packaged with IBM BPM. As you go though the tutorial, you create the My Hiring Sample process application that has a few enhancements from the packaged Hiring Sample process application. The “Comparison with the packaged Hiring Sample” topic covers the differences between this process application that you create in the tutorial and the packaged Hiring Sample process application.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

7. Good-practice resource – Read the coaches IBM Redbooks publication

If you use IBM® Business Process Manager (BPM) next-generation coaches, which were introduced in IBM BPM V8.0, read the Leveraging the IBM BPM Coach Framework in Your Organization IBM Redbooks (SG24-8210-00) publication that focuses on this subject to learn about how to develop coaches and find out about the various tips and good practices.

Applicable editions: Express, Standard, and Advanced

Applicable releases: V8.0 and later

8. Good-practice resource – Use the IBM BPM Center of Excellence and Program to Project Redbooks

To succeed with IBM® Business Process Manager (BPM) beyond your first project, ensure that you are prepared and organized for success. For example, do you have the proper buy-in and participation from the organization?

The following timeless resources will help you expand your first project into an ongoing program:

Scaling BPM Adoption: From Project to Program with IBM Business Process Manager (SG24-7973-01)
Creating a BPM Center of Excellence (CoE) (REDP-4898-00)

Applicable editions: Express, Standard, and Advanced

Applicable releases: all

9. Good-practice resource – Tune your IBM BPM performance

It is imperative to your success that you read and follow the advice in the appropriate IBM Redpaper™ for your release:

IBM Business Process Manager V8.5 Performance Tuning and Best Practices

IBM Business Process Manager V8.0 Performance Tuning and Best Practices

IBM Business Process Manager V7.5 Performance Tuning and Best Practices

Also see 5 Things to Know About IBM BPM Performance Tuning.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

Source : IBM

IBM BPM - Maintainability

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 2 Jun 2015 22:14:00 +0530

1. Good practice – Avoid mutually dependent toolkits

In IBM® Business Process Manager, design toolkit hierarchies to avoid mutual dependencies by factoring out common content into its own toolkit so that the other toolkits can refer to it independently.

If you update the dependency on a child toolkit, you need to take a new snapshot of that parent toolkit for the change to be effective for whoever uses that toolkit, which can lead to a race situation with mutually dependent toolkits. For example, when you snapshot toolkit A, you now need to update the dependency and snapshot toolkit B, which means that you need to update the dependency and snapshot toolkit A. And that means that you need to update the dependency and snapshot toolkit B. And so on.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

2. Good practice – Back up your IBM BPM data regularly

Back up your IBM® Business Process Manager (BPM) data regularly, particularly after you make discrete configuration changes, such as installing a new system, applying interim fixes, deploying applications, and changing the topology, which you would do for vertical or horizontal scaling. It is also especially important before purging any data. The more recent your data backup, the less work will be lost if restoring it becomes necessary.
To do the back up, shut down the cell, make sure no transaction is pending in the databases, and then back up the IBM BPM databases (and your relevant application databases).
Applicable editions: Express, Standard, and Advanced
Applicable releases: All
Source: IBM

IBM BPM - High-Quality Processes

teknoturfian@gmail.com (Marimuthu Udhayakumar) — Tue, 2 Jun 2015 21:58:00 +0530

1. Good practice – Diligently deal with faults when invoking external services

Well-designed external and Advanced Integration services have modeled faults for business exceptions such as “insufficient funds” and often have unmodeled faults for technical exceptions such as “network failure” issues. When you are invoking services from a process, design your process to deal with both types of faults. Typically, a business exception can be handled in the process flow, such as by returning to a previous step or engaging the user, whereas a system fault might result in retrying the service or engaging a process administrator.

To learn more about how to model fault handling in Business Process Modeling Notation (BPMN), search the IBM® Business Process Manager (BPM) documentation for your release for “Handling errors in services”.

Also, see the following resources:

To learn more about how to model fault handling in Business Process Execution Language (BPEL), search the IBM BPM documentation for your release for “Fault handling in BPEL“.

Also, see these developerWorks articles:

2. Good practice – Do not use IBM BPM as a system of record

Business processes naturally use business data in the form of variables to represent the process state and affect the process flow. However, do not consider this data a system of record (SOR). IBM® Business Process Manager should always work with external systems of record to access and update data. Use the business data in a process only for the purpose of that process; do not expose that data as an SOR for other purposes.

A proper SOR is architected and designed for transactional, efficient, and safe reading and writing and reporting by one or more users and producers. The business data in a process is merely a temporary stateful representation of that data to affect the process flow and user interactions. Process variables and their underlying IBM BPM persistent data store are not designed to be used outside of that process. Considering these process variables as the single source of truth for that data eventually causes issues and requests for typical transactional CRUD access to that data that is not possible or recommended on top of the IBM BPM internal database.

Applicable editions: Express, Standard and Advanced

Applicable releases: All

Source: System-of-Record Architecture for Process-Driven Solutions

3. Good practice – Ensure the health of your BPMN processes by using the JavaScript loop detector and process monitor

There are tools in IBM® Business Process Manager (BPM) that help you ensure the health of your Business process Modeling Notation (BPMN) processes:

JavaScript loop detector: This tool is in IBM BPM V8.5.5 and available as an interim fix (see APAR JR48395) for V8.0.1.1, V8.0.1.2, and V8.5.0.1. With this tool installed and enabled, the engine identifies what appear to be infinite loops in individual server-side JavaScript steps when you perform playbacks in Process Center. If potential infinite loops are detected, you are given an opportunity to terminate that JavaScript step without having to restart Process Center.

Process monitor: From this page on the Process Admin Console, you can proactively and reactively detect processes and services that are acting errantly. For more information, see Monitoring processes and services in the Process Admin Console for IBM Business Process Manager (BPM).

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

4. Good practice – Mark system tasks for deletion when you create them

For system tasks in your business process definitions (BPDs), select the Delete task on completion check box on the Implementation tab of the properties in IBM Process Designer. With this option selected, tasks are automatically deleted when they complete, which can save a significant amount of data from being persisted. Note that the default setting for this check box was changed to selected as of IBM Business Process Manager V8.5.5.0 for newly created system tasks.

For user tasks in your BPDs, make a conscious decision about the Clean State check box on the Implementation tab of the BPD’s properties. By default, this option is not selected, but selecting it automatically cleans up the context (such as variables) for the user task when it completes. If the state is not required to be persisted and this option is selected, you can save a significant about of database space and even speed the migration of snapshot instances.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

5.Good practice – Turn off auto-tracking in BPDs if it is not required

Auto-tracking in IBM® WebSphere Lombardi Edition and IBM Business Process Manager is important for many business process definitions (BPDs) because it helps you gather, track, and report key business metrics. However, an additional cost comes with auto-tracking because these events are processed by the Performance Data Warehouse and persisted in the database.

Because of that cost, disable the default auto-tracking capability for BPDs if you do not need to track and report on their business metrics so that you can lower your costs. Also, consider creating tracking groups to track only key business events, and then disable auto-tracking. This approach ensures that the events that are persisted are only those that are required for your business metrics.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

Source: IBM Business Process Manager V8.5 Performance Tuning and Best Practices Redpaper

6.Good practice – Use governance processes for snapshot installations

As of IBM Business Process Manager (BPM) V8.0, Process Center supports a special type of process called a governance process. This process is installed and runs in Process Center to detect and react when a snapshot changes status or a request is made to install a snapshot.

To ensure that there is visibility regarding the installation of new snapshots, it’s a good practice to have a governance process. For example, your governance process could ensure that the architect and test lead both approved installing the new snapshot before it is installed into a production environment.

For information about governance processes, see Applying governance to a process application.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

7. Good practice – Use IBM BPM Advanced, an enterprise service bus, or both to expose services to your business processes that use BPMN

Business processes orchestrate services and people. Most business processes require services, such as web services or REST services, to perform their business functions. However, because IBM® Business Process Manager (BPM) Standard is intended for the business developer more so than the integration developer, there is limited support in IBM BPM Standard for accessing services across different protocols. The type system is based on JavaScript rather than XML schema to reduce the complexity.

Therefore, to expose services to your business processes that use Business Process Modeling Notation (BPMN) and have business-friendly user interfaces and protocols, use IBM BPM Advanced, an enterprise service bus (ESB) such as IBM Integration Bus, or both. These products allow for the complexity of integrating with enterprise systems. They also keep dealing with various protocols and qualities of service out of the BPMN business processes that are developed by integration developers who use more powerful integration tools, such as IBM Integration Designer or IBM Integration Toolkit.

Applicable editions: Express, Standard, and Advanced

Applicable releases: All

8.Good practice – Use the facade pattern for Advanced Integration services

When you use Advanced Integration services in IBM® Business Process Manager (BPM) Advanced, a copy of the EAR file for the implementation of each Advanced Integration service is created for each process app that uses it.

For large implementations, these EAR file copies take a lot of space. To avoid wasting space, deploy that implementation EAR file once as part of one dedicated process app, and have a very small facade Advanced Integration service that invokes the process app. This facade pattern is documented in Implementing the facade pattern using IBM Business Process Manager Advanced V7.5. This IBM developerWorks article also applies to IBM BPM V8.0 through V8.5.5.

This pattern is built into IBM BPM v8.5.6.

Applicable editions: Advanced

Applicable releases: All

Source: Implementing the facade pattern using IBM Business Process Manager Advanced V7.5

9.Good practice – Use the right process for the job

It is important to use the right type of process for your requirements. You can determine the right type of process by following these guidelines:

For human and case centric processes, use BPMN or business process definitions (BPDs).
If you have IBM Business Process Manager (BPM) Advanced, for straight-through processes that contain no human tasks, use BPEL. These processes are more efficient and can use the advanced qualities of services and integration capability.
- For straight-through processes that do not need to wait on asynchronous services, use BPEL microflows, which are very efficient. The entire process runs in one transaction.
- For straight-through processes that might span a longer period of time, perhaps because they must wait on an asynchronous response, use BPEL long-running flows. If only a portion of the solution requires long-running processes, separate it into both microflows and long-running processes to maximize the use of microflows. For more information, see Transactional behavior of BPEL processes.
If you have only IBM BPM Express or Standard, for straight-through processes use the BPD option (new in V8.5.5) to optimize the process for latency. For more information, see Optimizing BPD execution for latency.

For more information about BPEL microflows versus long-running flows, see the topics BPEL process types and Choosing between a microflow and a long-running process.
Applicable editions: Express, Standard, and Advanced
Applicable releases: All

10. Good practice – Use the sync-over-async invocation pattern with caution

When you develop advanced IBM® Business Process Manager (BPM) applications using IBM Integration Designer, use caution when you invoke an asynchronous component or import using a synchronous invocation style.

Invoking an asynchronous component or import using a synchronous invocation style causes the infrastructure underneath to switch from synchronous to asynchronous, often with unintended consequences including a new transaction boundary, use of threads to wait on the asynchronous response, and specific retry behavior if the invocation fails. This now infamous “Sync Over Async” situation is considered an anti-pattern because of the issues it can cause.

Follow the instructions in Synchronous over asynchronous invocation.

Applicable editions: Advanced

Applicable releases: All