Examples with PvmException org.activiti.engine.impl.pvm.PvmException used on opensource projects

Example 1 with PvmException

use of org.activiti.engine.impl.pvm.PvmException in project Activiti by Activiti.

the class ExecutionEntity method signal.

// methods that translate to operations /////////////////////////////////////
public void signal(String signalName, Object signalData) {
    ensureActivityInitialized();
    SignallableActivityBehavior activityBehavior = (SignallableActivityBehavior) activity.getActivityBehavior();
    try {
        String signalledActivityId = activity.getId();
        activityBehavior.signal(this, signalName, signalData);
        // If needed, dispatch an event indicating an activity was signalled
        boolean isUserTask = (activityBehavior instanceof UserTaskActivityBehavior) || ((activityBehavior instanceof MultiInstanceActivityBehavior) && ((MultiInstanceActivityBehavior) activityBehavior).getInnerActivityBehavior() instanceof UserTaskActivityBehavior);
        if (!isUserTask && Context.getProcessEngineConfiguration() != null && Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
            Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createSignalEvent(ActivitiEventType.ACTIVITY_SIGNALED, signalledActivityId, signalName, signalData, this.id, this.processInstanceId, this.processDefinitionId));
        }
    } catch (RuntimeException e) {
        throw e;
    } catch (Exception e) {
        throw new PvmException("couldn't process signal '" + signalName + "' on activity '" + activity.getId() + "': " + e.getMessage(), e);
    }
}

Example 2 with PvmException

use of org.activiti.engine.impl.pvm.PvmException in project Activiti by Activiti.

the class AbstractEventAtomicOperation method execute.

public void execute(InterpretableExecution execution) {
    ScopeImpl scope = getScope(execution);
    List<ExecutionListener> exectionListeners = scope.getExecutionListeners(getEventName());
    int executionListenerIndex = execution.getExecutionListenerIndex();
    if (exectionListeners.size() > executionListenerIndex) {
        execution.setEventName(getEventName());
        execution.setEventSource(scope);
        ExecutionListener listener = exectionListeners.get(executionListenerIndex);
        try {
            listener.notify(execution);
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new PvmException("couldn't execute event listener : " + e.getMessage(), e);
        }
        execution.setExecutionListenerIndex(executionListenerIndex + 1);
        execution.performOperation(this);
    } else {
        execution.setExecutionListenerIndex(0);
        execution.setEventName(null);
        execution.setEventSource(null);
        eventNotificationsCompleted(execution);
    }
}

Example 3 with PvmException

use of org.activiti.engine.impl.pvm.PvmException in project Activiti by Activiti.

the class ExecutionEntity method takeAll.

@SuppressWarnings({ "unchecked", "rawtypes" })
public void takeAll(List<PvmTransition> transitions, List<ActivityExecution> recyclableExecutions) {
    fireActivityCompletedEvent();
    transitions = new ArrayList<PvmTransition>(transitions);
    recyclableExecutions = (recyclableExecutions != null ? new ArrayList<ActivityExecution>(recyclableExecutions) : new ArrayList<ActivityExecution>());
    if (recyclableExecutions.size() > 1) {
        for (ActivityExecution recyclableExecution : recyclableExecutions) {
            if (((ExecutionEntity) recyclableExecution).isScope()) {
                throw new PvmException("joining scope executions is not allowed");
            }
        }
    }
    ExecutionEntity concurrentRoot = ((isConcurrent && !isScope) ? getParent() : this);
    List<ExecutionEntity> concurrentActiveExecutions = new ArrayList<ExecutionEntity>();
    List<ExecutionEntity> concurrentInActiveExecutions = new ArrayList<ExecutionEntity>();
    for (ExecutionEntity execution : concurrentRoot.getExecutions()) {
        if (execution.isActive()) {
            concurrentActiveExecutions.add(execution);
        } else {
            concurrentInActiveExecutions.add(execution);
        }
    }
    if (log.isDebugEnabled()) {
        log.debug("transitions to take concurrent: {}", transitions);
        log.debug("active concurrent executions: {}", concurrentActiveExecutions);
    }
    if ((transitions.size() == 1) && (concurrentActiveExecutions.isEmpty()) && allExecutionsInSameActivity(concurrentInActiveExecutions)) {
        List<ExecutionEntity> recyclableExecutionImpls = (List) recyclableExecutions;
        recyclableExecutions.remove(concurrentRoot);
        for (ExecutionEntity prunedExecution : recyclableExecutionImpls) {
            // End the pruned executions if necessary.
            // Some recyclable executions are inactivated (joined executions)
            // Others are already ended (end activities)
            // Need to call the activity end here. If we would do it later,
            // the executions are removed and the historic activity instances are
            // never ended as the combination of {activityId,executionId} is not valid anymor
            Context.getCommandContext().getHistoryManager().recordActivityEnd(prunedExecution);
            log.debug("pruning execution {}", prunedExecution);
            prunedExecution.remove();
        }
        log.debug("activating the concurrent root {} as the single path of execution going forward", concurrentRoot);
        concurrentRoot.setActive(true);
        concurrentRoot.setActivity(activity);
        concurrentRoot.setConcurrent(false);
        concurrentRoot.take(transitions.get(0), false);
    } else {
        List<OutgoingExecution> outgoingExecutions = new ArrayList<OutgoingExecution>();
        recyclableExecutions.remove(concurrentRoot);
        log.debug("recyclable executions for reuse: {}", recyclableExecutions);
        // first create the concurrent executions
        while (!transitions.isEmpty()) {
            PvmTransition outgoingTransition = transitions.remove(0);
            ExecutionEntity outgoingExecution = null;
            if (recyclableExecutions.isEmpty()) {
                outgoingExecution = concurrentRoot.createExecution();
                log.debug("new {} with parent {} created to take transition {}", outgoingExecution, outgoingExecution.getParent(), outgoingTransition);
            } else {
                outgoingExecution = (ExecutionEntity) recyclableExecutions.remove(0);
                log.debug("recycled {} to take transition {}", outgoingExecution, outgoingTransition);
            }
            outgoingExecution.setActive(true);
            outgoingExecution.setScope(false);
            outgoingExecution.setConcurrent(true);
            outgoingExecution.setTransitionBeingTaken((TransitionImpl) outgoingTransition);
            outgoingExecutions.add(new OutgoingExecution(outgoingExecution, outgoingTransition, true));
        }
        // prune the executions that are not recycled 
        for (ActivityExecution prunedExecution : recyclableExecutions) {
            log.debug("pruning execution {}", prunedExecution);
            prunedExecution.end();
        }
        // then launch all the concurrent executions
        for (OutgoingExecution outgoingExecution : outgoingExecutions) {
            outgoingExecution.take(false);
        }
    }
}

Example 4 with PvmException

use of org.activiti.engine.impl.pvm.PvmException in project Activiti by Activiti.

the class ErrorPropagation method mapException.

public static boolean mapException(Exception e, ActivityExecution execution, List<MapExceptionEntry> exceptionMap, boolean wrapped) throws Exception {
    if (exceptionMap == null) {
        return false;
    }
    if (wrapped && e instanceof PvmException) {
        e = (Exception) ((PvmException) e).getCause();
    }
    String defaultMap = null;
    for (MapExceptionEntry me : exceptionMap) {
        String exceptionClass = me.getClassName();
        String errorCode = me.getErrorCode();
        // save the first mapping with no exception class as default map
        if (StringUtils.isNotEmpty(errorCode) && StringUtils.isEmpty(exceptionClass) && defaultMap == null) {
            defaultMap = errorCode;
            continue;
        }
        // ignore if error code or class are not defined
        if (StringUtils.isEmpty(errorCode) || StringUtils.isEmpty(exceptionClass))
            continue;
        if (e.getClass().getName().equals(exceptionClass)) {
            propagateError(errorCode, execution);
            return true;
        }
        if (me.isAndChildren()) {
            Class<?> exceptionClassClass = ReflectUtil.loadClass(exceptionClass);
            if (exceptionClassClass.isAssignableFrom(e.getClass())) {
                propagateError(errorCode, execution);
                return true;
            }
        }
    }
    if (defaultMap != null) {
        propagateError(defaultMap, execution);
        return true;
    }
    return false;
}

Example 5 with PvmException

use of org.activiti.engine.impl.pvm.PvmException in project Activiti by Activiti.

the class ExecutionImpl method takeAll.

@SuppressWarnings("unchecked")
public void takeAll(List<PvmTransition> transitions, List<ActivityExecution> recyclableExecutions) {
    transitions = new ArrayList<PvmTransition>(transitions);
    recyclableExecutions = (recyclableExecutions != null ? new ArrayList<ActivityExecution>(recyclableExecutions) : new ArrayList<ActivityExecution>());
    if (recyclableExecutions.size() > 1) {
        for (ActivityExecution recyclableExecution : recyclableExecutions) {
            if (((ExecutionImpl) recyclableExecution).isScope()) {
                throw new PvmException("joining scope executions is not allowed");
            }
        }
    }
    ExecutionImpl concurrentRoot = ((isConcurrent && !isScope) ? getParent() : this);
    List<ExecutionImpl> concurrentActiveExecutions = new ArrayList<ExecutionImpl>();
    for (ExecutionImpl execution : concurrentRoot.getExecutions()) {
        if (execution.isActive()) {
            concurrentActiveExecutions.add(execution);
        }
    }
    if (log.isDebugEnabled()) {
        log.debug("transitions to take concurrent: {}", transitions);
        log.debug("active concurrent executions: {}", concurrentActiveExecutions);
    }
    if ((transitions.size() == 1) && (concurrentActiveExecutions.isEmpty())) {
        @SuppressWarnings("rawtypes") List<ExecutionImpl> recyclableExecutionImpls = (List) recyclableExecutions;
        for (ExecutionImpl prunedExecution : recyclableExecutionImpls) {
            // Others are already ended (end activities)
            if (!prunedExecution.isEnded()) {
                log.debug("pruning execution {}", prunedExecution);
                prunedExecution.remove();
            }
        }
        log.debug("activating the concurrent root {} as the single path of execution going forward", concurrentRoot);
        concurrentRoot.setActive(true);
        concurrentRoot.setActivity(activity);
        concurrentRoot.setConcurrent(false);
        concurrentRoot.take(transitions.get(0));
    } else {
        List<OutgoingExecution> outgoingExecutions = new ArrayList<OutgoingExecution>();
        recyclableExecutions.remove(concurrentRoot);
        log.debug("recyclable executions for reused: {}", recyclableExecutions);
        // first create the concurrent executions
        while (!transitions.isEmpty()) {
            PvmTransition outgoingTransition = transitions.remove(0);
            ExecutionImpl outgoingExecution = null;
            if (recyclableExecutions.isEmpty()) {
                outgoingExecution = concurrentRoot.createExecution();
                log.debug("new {} created to take transition {}", outgoingExecution, outgoingTransition);
            } else {
                outgoingExecution = (ExecutionImpl) recyclableExecutions.remove(0);
                log.debug("recycled {} to take transition {}", outgoingExecution, outgoingTransition);
            }
            outgoingExecution.setActive(true);
            outgoingExecution.setScope(false);
            outgoingExecution.setConcurrent(true);
            outgoingExecutions.add(new OutgoingExecution(outgoingExecution, outgoingTransition, true));
        }
        // prune the executions that are not recycled 
        for (ActivityExecution prunedExecution : recyclableExecutions) {
            log.debug("pruning execution {}", prunedExecution);
            prunedExecution.end();
        }
        // then launch all the concurrent executions
        for (OutgoingExecution outgoingExecution : outgoingExecutions) {
            outgoingExecution.take();
        }
    }
}