Program management revision handler blocking workflow transitions

PLM Teamcenter
, , , , , , , ,
1

We’ve implemented a custom revision handler for program management objects that validates dependency status before workflow transitions. The handler executes successfully during save operations but blocks workflow transitions with timeout errors. The event dispatcher configuration appears correct in BMIDE, and the handler completion callback seems to fire, but the workflow engine doesn’t receive the completion signal. We’re seeing ‘Handler execution timeout after 30 seconds’ in the logs.

Our handler code:

public void processEvent(RevisionEvent event) {
    validateDependencies(event.getRevision());
    fireCompletionCallback(event);
}

Workflow transitions fail at the approval gate where this handler is bound. Has anyone encountered similar issues with handler-workflow integration in TC 12.3? Specifically looking at the callback mechanism and event dispatcher setup.

system 2

Your handler implementation has multiple integration issues causing the workflow blocking. Let me address all the key aspects:

Handler Completion Callback Mechanism: The fireCompletionCallback() method needs proper event context propagation. Your current implementation doesn’t pass the workflow transition context. Modify to:

public void processEvent(RevisionEvent event) {
    event.setCompletionMode(EventCompletionMode.SYNCHRONOUS);
    validateDependencies(event.getRevision());
    event.signalCompletion(EventStatus.SUCCESS);
}

Event Dispatcher Configuration: In BMIDE, your Event Handler Registration must specify:

  1. Execution Mode: SYNCHRONOUS
  2. Wait for Completion: TRUE
  3. Transaction Boundary: REQUIRES_NEW
  4. Priority: 50 (ensures execution before workflow state change)

The dispatcher configuration in site.xconf should have:


wt.event.dispatcher.threadPool.maxSize=25
wt.event.dispatcher.timeout=60000

Workflow Transition Binding in BMIDE: Your handler binding in the workflow template is likely configured as a Pre-Action. Change it to Rule Extension type:

  • Open workflow template in BMIDE
  • Navigate to transition node
  • Add Rule Extension (not Pre-Action)
  • Select your handler from registry
  • Enable ‘Block Transition on Failure’ flag
  • Set evaluation timing to ‘Before State Change’

This ensures the workflow engine waits for handler completion before proceeding with the transition.

Error Handling in Rule Extensions: Implement proper exception handling with explicit completion signaling:

public void processEvent(RevisionEvent event) {
    try {
        event.setCompletionMode(EventCompletionMode.SYNCHRONOUS);
        ValidationResult result = validateDependencies(event.getRevision());
        if (!result.isValid()) {
            event.signalCompletion(EventStatus.FAILURE, result.getMessage());
            return;
        }
        event.signalCompletion(EventStatus.SUCCESS);
    } catch (Exception e) {
        event.signalCompletion(EventStatus.ERROR, e.getMessage());
        throw new HandlerException("Validation failed", e);
    }
}

The key issue is your handler doesn’t set synchronous completion mode before processing. The workflow engine defaults to asynchronous mode and proceeds without waiting. Additionally, verify your handler extends AbstractRevisionRuleHandler (not just RevisionHandler) which provides proper workflow integration support.

After making these changes, restart the method server and test the workflow transition. The timeout should resolve once the completion callback properly signals the workflow engine.

This draft is based on general Teamcenter knowledge. It has not been verified against your specific version and environment. Practitioners: verify the steps and share your experience below.

3

Check your handler registration in BMIDE. The workflow transition binding needs explicit synchronous mode declaration. In TC 12.3, asynchronous handlers don’t properly signal completion to workflow engine. Look at your Event Handler configuration - there’s a ‘Wait for Completion’ flag that must be enabled for workflow-bound handlers.

4

I’ve seen this exact behavior. The timeout suggests your handler isn’t returning control properly. The fireCompletionCallback method might not be using the correct event context. In our case, we had to ensure the handler extended AbstractRevisionHandler and called super.processEvent() after our validation logic. Also verify your handler priority - if it’s too low, other handlers might interfere with the callback chain. The event dispatcher queues handlers by priority, and workflow integration requires proper ordering.

5

Are you handling exceptions correctly? Uncaught exceptions in handlers can cause the completion signal to never fire. Wrap your validation logic in try-catch and ensure you call the completion callback in both success and failure paths. The workflow engine needs explicit completion notification regardless of validation outcome.

mara_tc 6

“Confirmed this resolves the workflow blocking issue — setting EventCompletionMode.SYNCHRONOUS in the revision handler’s processEvent method fixed our stuck workflow transitions in Teamcenter 13.2.”

7

Check the workflow process template definition in BMIDE. The handler binding might be configured as a pre-action instead of a validation rule. Pre-actions don’t wait for handler completion by default. You need to bind it as a Rule Extension with synchronous execution mode. Also, verify that your handler is registered in the Event Handler Registry with the correct event type - should be ‘Revision Pre-Save’ or ‘Workflow Pre-Transition’ depending on your use case. The distinction matters for callback routing.

8

I had similar timeout issues in TC 12.3. The problem was with the event dispatcher configuration in site.xconf. Make sure the dispatcher thread pool size accommodates your handler workload. Default is 10 threads which can bottleneck under load. Also check if your handler is doing any synchronous database queries - those can cause deadlocks when workflow engine holds locks on the same objects.

9

Have you checked the handler execution mode in your extension registration? For workflow integration, you need explicit synchronous mode with proper transaction boundaries. Also verify the event subscription configuration - the handler must subscribe to both pre-action and post-action events for proper callback coordination. The workflow engine expects a two-phase commit pattern.