public String getNodeName() { if (node==null) { return null; } return node.getName(); }
public String toString() { String destinationName = (destination!=null ? destination.getName() : null); String sourceName = (source!=null ? source.getName() : null); return (sourceName!=null ? "("+sourceName+")--" : "--") + (name!=null ? name+"-->" : ">") + (destinationName!=null ? "("+destinationName+")" : ""); }
static Map<String, NodeImpl> getNodesMap(List<NodeImpl> nodes) { Map<String, NodeImpl> map = null; if (nodes!=null) { map = new HashMap<String, NodeImpl>(); for (NodeImpl node: nodes) { if (node.getName()!=null) { if (! map.containsKey(node.getName())) { map.put(node.getName(), node); } } } } return map; }
public boolean equals(Object arg0, Object arg1) throws HibernateException { if ( (arg0==null) || (arg1==null)) return false; ExecutionImpl execution0 = (ExecutionImpl) arg0; ExecutionImpl execution1 = (ExecutionImpl) arg1; String nodeName0 = execution0.getNode().getName(); String nodeName1 = execution1.getNode().getName(); return nodeName0.equals(nodeName1); }
public void nullSafeSet(PreparedStatement st, Object owner, int index) throws HibernateException, SQLException { if (owner!=null) { ExecutionImpl execution = (ExecutionImpl) owner; String nodeName = execution.getNode().getName(); log.trace("binding 'execution-state{"+nodeName+"}' to parameter: "+index); st.setString(index, nodeName); } }
/** * Fill the path and transitions fields of the CycleObject c. * @param c cycle object to fill * @param sourceNode source node of the path * @param destNode destination of the path * @return */ private static boolean fillCycleObject(CycleObject c, NodeImpl sourceNode, NodeImpl destNode) { if (sourceNode.equals(destNode)) { c.path.add(sourceNode.getName()); return true; } if (sourceNode.hasOutgoingTransitions()) { boolean res = false; for (Transition t : sourceNode.getOutgoingTransitions()) { if (fillCycleObject(c, (NodeImpl) t.getDestination(), destNode)) { c.path.add(sourceNode.getName()); MyTransition myT = new MyTransition(); myT.fromNode = t.getSource().getName(); myT.toNode = t.getDestination().getName(); c.transitions.add(myT); res = true; } } return res; } return false; }
private static JoinRunTime getJoinRunTime(XpdlInstance instance, NodeImpl node) { JoinType joinType = ((AbstractActivity) node.getBehaviour()).getJoinType(); JoinRunTime joinRunTime = instance.getJoinRunTime(node.getName()); if (joinRunTime == null) { int joinIncomingTransitionNbRequired = 1; if (joinType.equals(JoinType.AND)) { joinIncomingTransitionNbRequired = node.getIncomingTransitions().size(); } Map<String, JoinRunTime.WaitingTransition> ins = new HashMap<String, JoinRunTime.WaitingTransition>(); for (Transition t : node.getIncomingTransitions()) { String name = t.getSource().getName(); ins.put(name, new JoinRunTime.WaitingTransition(name, null)); } joinRunTime = new JoinRunTime(node.getName(), ins, joinIncomingTransitionNbRequired); instance.pushJoinRuntime(joinRunTime); } return joinRunTime; }
private XpdlExecution getExecOnNode(XpdlExecution exec, String nodeName, String iterationId, String activityInstanceId) { Misc.checkArgsNotNull(exec, nodeName, iterationId, activityInstanceId); if (exec.getExecutions() == null || exec.getExecutions().isEmpty()) { if (exec.getNode() != null && exec.getNode().getName().equals(nodeName) && exec.getIterationId().equals(iterationId) && exec.getActivityInstanceId().equals(activityInstanceId)) { return exec; } } for (Execution child : exec.getExecutions()) { XpdlExecution found = getExecOnNode((XpdlExecution) child, nodeName, iterationId, activityInstanceId); if (found != null) { return found; } } return null; }
public Object deepCopy(Object object) throws HibernateException { if (object==null) { return null; } ExecutionImpl original = (ExecutionImpl) object; NodeImpl node = new NodeImpl(); node.setName(original.getNode().getName()); ExecutionImpl copy = new ExecutionImpl(); copy.setNode(node); return copy; }
NodeImpl currentNode = xpdlExecution.getNode(); if (LOG.isLoggable(Level.FINE)) { LOG.fine("node = " + currentNode.getName() + " - splitType = " + splitType + " - execution = " + execution.getName()); if (transitions == null) { if (LOG.isLoggable(Level.FINE)) { LOG.fine("node = " + currentNode.getName() + " - splitType = " + splitType + " - execution = " + execution.getName() + " no transition available. Ending execution");
NodeImpl initialActivityNode = createdNodes.get(initialActivity.getActivityId()); initialNode.createOutgoingTransition(initialActivityNode, "initialSplit_" + initialNode.getName() + "_to_" + initialActivityNode.getName()); NodeImpl endingActivityNode = createdNodes.get(endingActivity.getActivityId()); endingActivityNode.createOutgoingTransition(endingNode, "endingJoin_" + endingActivityNode.getName() + "_to_" + endingNode.getName()); initialNode.createOutgoingTransition(endingNode, "initialSplit_" + initialNode.getName() + "_to_" + endingNode.getName());
/** * Deep first search algorithm that creates spanning tree * (see {@link IterationDetection#createSpanningTree(ProcessDefinitionImpl, ProcessDefinitionImpl)} * @param inNode node of the input process currently processed * @param outNode corresponding node in the spanning tree * @param outProcess spanning tree * @return list of unprocessed transitions during the DFS */ private static List<Transition> processNode(Node inNode, NodeImpl outNode, ProcessDefinitionImpl outProcess) { List<Transition> nonProcessedTransitions = new ArrayList<Transition>(); if (inNode.hasOutgoingTransitions()) { for (Transition t : inNode.getOutgoingTransitions()) { NodeImpl destNode = (NodeImpl) t.getDestination(); String destName = destNode.getName(); if (!outProcess.hasNode(destName)) { // create node NodeImpl newNode = outProcess.createNode(destName); outNode.createOutgoingTransition(newNode, t.getName()); nonProcessedTransitions.addAll(processNode(t.getDestination(), newNode, outProcess)); } else { // node already in the spanning tree, the transition is not in the spanning tree. nonProcessedTransitions.add(t); } } } return nonProcessedTransitions; }
c.exitNodes.add(sourceNode.getName());
public void signal(ActivityExecution execution, String signal, Map<String, Object> parameters) { XpdlExecution xpdlExecution = (XpdlExecution) execution; if (BODY_FINISHED.equals(signal)) { end(xpdlExecution); } else if (ACT_INSTANCE_FINISHED.equals(signal)) { xpdlExecution.setWaitingForActivityInstanceNb(xpdlExecution.getWaitingForActivityInstanceNb() - 1); if (xpdlExecution.getWaitingForActivityInstanceNb() == 0) { // TODO: cancel remaining activity instances executeSplit(xpdlExecution, false); } } else if (signal != null && deadlines != null) { for (String deadline : deadlines) { if (deadline.equals(signal)) { Authentication.setUserId("SYSTEM"); // By default, a deadline does not propagate execution xpdlExecution.waitForSignal(); String activityId = xpdlExecution.getNode().getName(); JavaHook javaHook = new JavaHook(signal, JavaHook.Type.onDeadline, true); HookExecutor.executeHook(xpdlExecution, activityId, javaHook); return; } } } }
protected TaskInstance getTask(XpdlExecution xpdlExecution, ActivityInstance<ActivityBody> activityInstance) { this.taskRuntime = new TaskRunTime(new TaskUUID(activityInstance.getUUID()), xpdlExecution.getNode().getName(), this, xpdlExecution); final TaskUUID taskUUID = taskRuntime.getUUID(); final TaskState state = taskRuntime.getState(); final Date createdDate = new Date(); final Date dueDate = taskRuntime.getDueDate(); return new TaskFullInstanceImpl(taskUUID, state, createdDate, dueDate, EnvTool.getUserId()); }
@Override public void signal(ActivityExecution execution, String signal, Map<String, Object> signalParameters) { XpdlExecution xpdlExecution = (XpdlExecution) execution; if (SUBFLOW_SIGNAL.equals(signal)) { if (outParameters != null) { final Recorder recorder = EnvTool.getRecorder(); ProcessInstanceUUID instanceUUID = xpdlExecution.getXpdlInstance().getUUID(); String activityId = xpdlExecution.getNode().getName(); for (Map.Entry<String, String> parameter : outParameters.entrySet()) { String variableId = parameter.getValue(); Object variableValue = signalParameters.get(parameter.getKey()); execution.setVariable(variableId, variableValue); if (xpdlExecution.getXpdlInstance().getRootExecution().hasVariable(variableId)) { recorder.recordInstanceVariableUpdated(variableId, variableValue, instanceUUID, EnvTool.getUserId()); } else { recorder.recordActivityVariableUpdated(variableId, variableValue, instanceUUID, activityId, xpdlExecution.getIterationId(), xpdlExecution.getActivityInstanceId(), EnvTool.getUserId()); } } } super.signal(xpdlExecution, BODY_FINISHED, null); } else { super.signal(xpdlExecution, signal, signalParameters); } }
c.entryNodes.add(sourceNode.getName()); joinType = ((AbstractActivity)sourceNode.getBehaviour()).getJoinType(); if (JoinType.XOR.equals(joinType)) {
execution.getNode().getName(), execution.getIterationId(), execution.getActivityInstanceId(), EnvTool.getUserId());
public void recordEnterActivity(final AbstractActivity activity, final XpdlExecution xpdlExecution) { Misc.checkArgsNotNull(activity, xpdlExecution); final NodeImpl node = xpdlExecution.getNode(); XpdlInstance instance = xpdlExecution.getXpdlInstance(); final String id = node.getName(); final PackageDefinitionUUID packageUUID = instance.getPackageDefinitionUUID(); final ProcessDefinitionUUID processUUID = instance.getProcessDefinitionUUID(); final ProcessInstanceUUID instanceUUID = instance.getUUID(); final String iterationId = xpdlExecution.getIterationId(); final String activityInstanceId = xpdlExecution.getActivityInstanceId(); final ActivityFullInstanceImpl<ActivityBody> activityRecord = new ActivityFullInstanceImpl<ActivityBody>( new ActivityInstanceUUID(instanceUUID, activity.getActivityId(), EnvTool.getRepository().getNextActivityInstanceNb(instanceUUID, activity.getActivityId())), id, packageUUID, processUUID, instanceUUID, iterationId, activityInstanceId); ActivityBody body = activity.getBody(xpdlExecution, activityRecord); activityRecord.setBody(body); ProcessFullInstance processInstance = getProcessInstance(instanceUUID); processInstance.addActivity(activityRecord); activityRecord.setVariablesBeforeReady(xpdlExecution.getScopeVariables()); }