Java Code Examples for org.camunda.bpm.engine.impl.context.Context#executeWithinProcessApplication()

protected void performNotification(final DelegateExecution execution, Callable<Void> notification) throws Exception {
  final ProcessApplicationReference processApp = ProcessApplicationContextUtil.getTargetProcessApplication((ExecutionEntity) execution);
  if (processApp == null) {
    // ignore silently
    LOG.noTargetProcessApplicationForExecution(execution);

  } else {
    if (ProcessApplicationContextUtil.requiresContextSwitch(processApp)) {
      // this should not be necessary since context switch is already performed by OperationContext and / or DelegateInterceptor
      Context.executeWithinProcessApplication(notification, processApp, new InvocationContext(execution));

    } else {
      // context switch already performed
      notification.call();

    }
  }
}
 

@Override
public boolean validate(final Object submittedValue, final FormFieldValidatorContext validatorContext) {

  final DelegateExecution execution = validatorContext.getExecution();

  if(shouldPerformPaContextSwitch(validatorContext.getExecution())) {
    ProcessApplicationReference processApplicationReference = ProcessApplicationContextUtil.getTargetProcessApplication((ExecutionEntity) execution);

    return Context.executeWithinProcessApplication(new Callable<Boolean>() {
      public Boolean call() throws Exception {
        return doValidate(submittedValue, validatorContext);
      }
    }, processApplicationReference, new InvocationContext(execution));

  } else {
    return doValidate(submittedValue, validatorContext);

  }

}
 

protected <T> T performContextSwitch(final Callable<T> callable) {

    ProcessApplicationReference targetProcessApplication = ProcessApplicationContextUtil.getTargetProcessApplication(deploymentId);

    if(targetProcessApplication != null) {

      return Context.executeWithinProcessApplication(new Callable<T>() {
        public T call() throws Exception {
          return doCall(callable);
        }

      }, targetProcessApplication);

    } else {
      return doCall(callable);
    }
  }
 

public void performOperation(final CmmnAtomicOperation executionOperation, final CaseExecutionEntity execution) {
  ProcessApplicationReference targetProcessApplication = getTargetProcessApplication(execution);

  if(requiresContextSwitch(targetProcessApplication)) {
    Context.executeWithinProcessApplication(new Callable<Void>() {
      public Void call() throws Exception {
        performOperation(executionOperation, execution);
        return null;
      }

    }, targetProcessApplication, new InvocationContext(execution));

  } else {
    try {
      Context.setExecutionContext(execution);
      LOG.debugExecutingAtomicOperation(executionOperation, execution);

      executionOperation.execute(execution);
    } finally {
      Context.removeExecutionContext();
    }
  }
}
 

@Override
public void onImplicitValueUpdate(final TypedValue updatedValue) {
  // note: this implementation relies on the
  //   behavior that the variable scope
  //   of variable value can never become null

  ProcessApplicationReference targetProcessApplication = getContextProcessApplication();
  if (targetProcessApplication != null) {
    Context.executeWithinProcessApplication(new Callable<Void>() {

      @Override
      public Void call() throws Exception {
        getVariableScope().setVariableLocal(name, updatedValue);
        return null;
      }

    }, targetProcessApplication, new InvocationContext(getExecution()));

  }
  else {
    if (!isTransient) {
      getVariableScope().setVariableLocal(name, updatedValue);
    }
  }
}
 

public void handleInvocation(final DelegateInvocation invocation) throws Exception {

    final ProcessApplicationReference processApplication = getProcessApplicationForInvocation(invocation);

    if (processApplication != null && ProcessApplicationContextUtil.requiresContextSwitch(processApplication)) {
      Context.executeWithinProcessApplication(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
          handleInvocation(invocation);
          return null;
        }
      }, processApplication, new InvocationContext(invocation.getContextExecution()));
    }
    else {
      handleInvocationInContext(invocation);
    }

  }
 

@SuppressWarnings("unchecked")
public void testExecuteWithInvocationContext() throws Exception {
  // given a process application which extends the default one
  // - using a spy for verify the invocations
  TestApplicationWithoutEngine processApplication = spy(pa);
  ProcessApplicationReference processApplicationReference = mock(ProcessApplicationReference.class);
  when(processApplicationReference.getProcessApplication()).thenReturn(processApplication);

  // when execute with context
  InvocationContext invocationContext = new InvocationContext(mock(BaseDelegateExecution.class));
  Context.executeWithinProcessApplication(mock(Callable.class), processApplicationReference, invocationContext);

  // then the execute method should be invoked with context
  verify(processApplication).execute(any(Callable.class), eq(invocationContext));
  // and forward to call to the default execute method
  verify(processApplication).execute(any(Callable.class));
}
 

protected void performNext() {
  AtomicOperationInvocation nextInvocation = queuedInvocations.get(0);

  if(nextInvocation.operation.isAsyncCapable() && isExecuting) {
    // will be picked up by while loop below
    return;
  }

  ProcessApplicationReference targetProcessApplication = getTargetProcessApplication(nextInvocation.execution);
  if(requiresContextSwitch(targetProcessApplication)) {

    Context.executeWithinProcessApplication(new Callable<Void>() {
      public Void call() throws Exception {
        performNext();
        return null;
      }

    }, targetProcessApplication, new InvocationContext(nextInvocation.execution));
  }
  else {
    if(!nextInvocation.operation.isAsyncCapable()) {
      // if operation is not async capable, perform right away.
      invokeNext();
    }
    else {
      try  {
        isExecuting = true;
        while (! queuedInvocations.isEmpty()) {
          // assumption: all operations are executed within the same process application...
          invokeNext();
        }
      }
      finally {
        isExecuting = false;
      }
    }
  }
}
 

@Override
public <T> T execute(final Command<T> command) {
  ProcessApplicationIdentifier processApplicationIdentifier = ProcessApplicationContextImpl.get();

  if (processApplicationIdentifier != null) {
    // clear the identifier so this interceptor does not apply to nested commands
    ProcessApplicationContextImpl.clear();

    try {
      ProcessApplicationReference reference = getPaReference(processApplicationIdentifier);
      return Context.executeWithinProcessApplication(new Callable<T>() {

        @Override
        public T call() throws Exception {
          return next.execute(command);
        }
      },
      reference);

    }
    finally {
      // restore the identifier for subsequent commands
      ProcessApplicationContextImpl.set(processApplicationIdentifier);
    }
  }
  else {
    return next.execute(command);
  }
}
 

@Override
public void signal(final ActivityExecution execution, final String signalName, final Object signalData) throws Exception {
  ProcessApplicationReference targetProcessApplication = ProcessApplicationContextUtil.getTargetProcessApplication((ExecutionEntity) execution);
  if(ProcessApplicationContextUtil.requiresContextSwitch(targetProcessApplication)) {
    Context.executeWithinProcessApplication(new Callable<Void>() {
      public Void call() throws Exception {
        signal(execution, signalName, signalData);
        return null;
      }
    }, targetProcessApplication, new InvocationContext(execution));
  }
  else {
    doSignal(execution, signalName, signalData);
  }
}
 

public Object resolveDelegateClass(final ActivityExecution execution) {
  ProcessApplicationReference targetProcessApplication
          = ProcessApplicationContextUtil.getTargetProcessApplication((ExecutionEntity) execution);
  if (ProcessApplicationContextUtil.requiresContextSwitch(targetProcessApplication)) {
    return Context.executeWithinProcessApplication(new Callable<Object>() {

      @Override
      public Object call() throws Exception {
        return resolveDelegateClass(execution);
      }
    }, targetProcessApplication, new InvocationContext(execution));
  } else {
    return instantiateDelegateClass(execution);
  }
}
 

@Override
public void signal(final ActivityExecution execution, final String signalName, final Object signalData) throws Exception {
  ProcessApplicationReference targetProcessApplication = ProcessApplicationContextUtil.getTargetProcessApplication((ExecutionEntity) execution);
  if(ProcessApplicationContextUtil.requiresContextSwitch(targetProcessApplication)) {
    Context.executeWithinProcessApplication(new Callable<Void>() {
      public Void call() throws Exception {
        signal(execution, signalName, signalData);
        return null;
      }
    }, targetProcessApplication, new InvocationContext(execution));
  }
  else {
    doSignal(execution, signalName, signalData);
  }
}