in jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/validation/RuleFlowProcessValidator.java [161:764]
protected void validateNodes(org.kie.api.definition.process.Node[] nodes,
List<ProcessValidationError> errors,
RuleFlowProcess process) {
String isForCompensation = "isForCompensation";
for (int i = 0; i < nodes.length; i++) {
final org.kie.api.definition.process.Node node = nodes[i];
if (node instanceof StartNode) {
final StartNode startNode = (StartNode) node;
if (startNode.getTo() == null) {
addErrorMessage(process,
node,
errors,
"Start has no outgoing connection.");
}
if (startNode.getTimer() != null) {
validateTimer(startNode.getTimer(),
node,
process,
errors);
}
} else if (node instanceof EndNode) {
final EndNode endNode = (EndNode) node;
if (endNode.getFrom() == null) {
addErrorMessage(process,
node,
errors,
"End has no incoming connection.");
}
validateCompensationIntermediateOrEndEvent(endNode,
process,
errors);
} else if (node instanceof RuleSetNode) {
final RuleSetNode ruleSetNode = (RuleSetNode) node;
if (ruleSetNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"RuleSet has no incoming connection.");
}
if (ruleSetNode.getTo() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process,
node,
errors,
"RuleSet has no outgoing connection.");
}
final String language = ruleSetNode.getLanguage();
RuleType ruleType = ruleSetNode.getRuleType();
if (ruleType.isRuleFlowGroup()) {
final String ruleFlowGroup = ruleType.getName();
if (ruleFlowGroup == null || "".equals(ruleFlowGroup)) {
addErrorMessage(process,
node,
errors,
"RuleSet (DRL) has no ruleflow-group.");
}
} else if (ruleType.isRuleUnit()) {
final String unit = ruleType.getName();
if (unit == null || "".equals(unit)) {
addErrorMessage(process,
node,
errors,
"RuleSet (Rule Unit) has no ruleflow-group.");
}
} else if (ruleType.isDecision()) {
DecisionRuleType decision = (DecisionRuleType) ruleType;
final String namespace = decision.getNamespace();
if (namespace == null || "".equals(namespace)) {
addErrorMessage(process,
node,
errors,
"RuleSet (DMN) has no namespace.");
}
final String model = decision.getModel();
if (model == null || "".equals(model)) {
addErrorMessage(process,
node,
errors,
"RuleSet (DMN) has no model.");
}
} else {
addErrorMessage(process,
node,
errors,
"Unsupported rule language '" + language + "'");
}
if (ruleSetNode.getTimers() != null) {
for (Timer timer : ruleSetNode.getTimers().keySet()) {
validateTimer(timer,
node,
process,
errors);
}
}
} else if (node instanceof Split) {
final Split split = (Split) node;
if (split.getType() == Split.TYPE_UNDEFINED) {
addErrorMessage(process,
node,
errors,
"Split has no type.");
}
if (split.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Split has no incoming connection.");
}
if (split.getDefaultOutgoingConnections().size() < 2) {
addErrorMessage(process,
node,
errors,
"Split does not have more than one outgoing connection: " + split.getOutgoingConnections().size() + ".");
}
if (split.getType() == Split.TYPE_XOR || split.getType() == Split.TYPE_OR) {
for (final Iterator<Connection> it = split.getDefaultOutgoingConnections().iterator(); it.hasNext();) {
final Connection connection = it.next();
Collection<Constraint> constraints = split.getConstraints(connection);
if ((constraints == null || constraints.stream().allMatch(c -> c == null || c.getConstraint() == null || c.getConstraint().isBlank())) && !split.isDefault(connection)) {
addErrorMessage(process,
node,
errors,
"Split does not have a constraint for " + connection.toString() + ".");
}
}
}
} else if (node instanceof Join) {
final Join join = (Join) node;
if (join.getType() == Join.TYPE_UNDEFINED) {
addErrorMessage(process,
node,
errors,
"Join has no type.");
}
if (join.getDefaultIncomingConnections().size() < 2) {
addErrorMessage(process,
node,
errors,
"Join does not have more than one incoming connection: " + join.getIncomingConnections().size() + ".");
}
if (join.getTo() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Join has no outgoing connection.");
}
if (join.getType() == Join.TYPE_N_OF_M) {
String n = join.getN();
if (!join.getMetaData().containsKey(Metadata.ACTION) && (!n.startsWith("#{") || !n.endsWith("}"))) {
try {
Integer.parseInt(n);
} catch (NumberFormatException e) {
addErrorMessage(process,
node,
errors,
"Join has illegal n value: " + n);
}
}
}
} else if (node instanceof MilestoneNode) {
final MilestoneNode milestone = (MilestoneNode) node;
if (milestone.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Milestone has no incoming connection.");
}
if (milestone.getTo() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Milestone has no outgoing connection.");
}
if (milestone.getTimers() != null) {
for (Timer timer : milestone.getTimers().keySet()) {
validateTimer(timer,
node,
process,
errors);
}
}
} else if (node instanceof StateNode) {
final StateNode stateNode = (StateNode) node;
if (stateNode.getDefaultIncomingConnections().isEmpty() && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"State has no incoming connection");
}
} else if (node instanceof SubProcessNode) {
final SubProcessNode subProcess = (SubProcessNode) node;
if (subProcess.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"SubProcess has no incoming connection.");
}
if (subProcess.getTo() == null && !acceptsNoOutgoingConnections(node)) {
Object compensationObj = subProcess.getMetaData(isForCompensation);
if (compensationObj == null || !((Boolean) compensationObj)) {
addErrorMessage(process,
node,
errors,
"SubProcess has no outgoing connection.");
}
}
if (subProcess.getProcessId() == null && subProcess.getProcessName() == null) {
addErrorMessage(process,
node,
errors,
"SubProcess has no process id.");
}
if (subProcess.getTimers() != null) {
for (Timer timer : subProcess.getTimers().keySet()) {
validateTimer(timer,
node,
process,
errors);
}
}
if (!subProcess.isIndependent() && !subProcess.isWaitForCompletion()) {
addErrorMessage(process,
node,
errors,
"SubProcess you can only set " +
"independent to 'false' only when 'Wait for completion' is set to true.");
}
} else if (node instanceof ActionNode) {
final ActionNode actionNode = (ActionNode) node;
if (actionNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Action has no incoming connection.");
}
if (actionNode.getTo() == null && !acceptsNoOutgoingConnections(node)) {
Object compensationObj = actionNode.getMetaData(isForCompensation);
if (compensationObj == null || !((Boolean) compensationObj)) {
addErrorMessage(process,
node,
errors,
"Action has no outgoing connection.");
}
}
// don't add message if action node action is null
// with codegen the ActionNodeVisitor will add the action
// so when testing outside codegen having no action
// does not mean the action node has an error (this was true before with jBPM but not in Kogito)
if (actionNode.getAction() instanceof DroolsConsequenceAction) {
DroolsConsequenceAction droolsAction = (DroolsConsequenceAction) actionNode.getAction();
String actionString = droolsAction.getConsequence();
if (actionString == null) {
addErrorMessage(process,
node,
errors,
"Action has empty action.");
}
if (!"java".equals(droolsAction.getDialect())) {
addErrorMessage(process,
node,
errors,
droolsAction.getDialect() + " script language is not supported in Kogito.");
}
validateCompensationIntermediateOrEndEvent(actionNode,
process,
errors);
}
} else if (node instanceof WorkItemNode) {
final WorkItemNode workItemNode = (WorkItemNode) node;
if (workItemNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Task has no incoming connection.");
}
if (workItemNode.getTo() == null && !acceptsNoOutgoingConnections(node)) {
Object compensationObj = workItemNode.getMetaData(isForCompensation);
if (compensationObj == null || !((Boolean) compensationObj)) {
addErrorMessage(process,
node,
errors,
"Task has no outgoing connection.");
}
}
if (workItemNode.getWork() == null) {
addErrorMessage(process,
node,
errors,
"Task has no work specified.");
} else {
Work work = workItemNode.getWork();
if (work.getName() == null || work.getName().trim().length() == 0) {
addErrorMessage(process,
node,
errors,
"Task has no task type.");
}
}
if (workItemNode.getTimers() != null) {
for (Timer timer : workItemNode.getTimers().keySet()) {
validateTimer(timer,
node,
process,
errors);
}
}
} else if (node instanceof ForEachNode) {
final ForEachNode forEachNode = (ForEachNode) node;
String variableName = forEachNode.getVariableName();
if (variableName == null || "".equals(variableName)) {
addErrorMessage(process,
node,
errors,
"ForEach has no variable name");
}
String collectionExpression = forEachNode.getCollectionExpression();
if (collectionExpression == null || "".equals(collectionExpression)) {
addErrorMessage(process,
node,
errors,
"ForEach has no collection expression");
}
if (forEachNode.getDefaultIncomingConnections().isEmpty() && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"ForEach has no incoming connection");
}
if (forEachNode.getDefaultOutgoingConnections().isEmpty() && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process,
node,
errors,
"ForEach has no outgoing connection");
}
final List<org.kie.api.definition.process.Node> start = RuleFlowProcess.getStartNodes(forEachNode.getNodes());
if (start != null) {
for (org.kie.api.definition.process.Node s : start) {
if (((StartNode) s).getTriggers() != null && !((StartNode) s).getTriggers().isEmpty() || ((StartNode) s).getTimer() != null) {
addErrorMessage(process,
node,
errors,
"MultiInstance subprocess can only have none start event.");
}
}
}
validateNodes(forEachNode.getNodes(),
errors,
process);
} else if (node instanceof DynamicNode) {
final DynamicNode dynamicNode = (DynamicNode) node;
if (dynamicNode.getDefaultIncomingConnections().isEmpty() && !acceptsNoIncomingConnections(dynamicNode)) {
addErrorMessage(process,
node,
errors,
"Dynamic has no incoming connection");
}
if (dynamicNode.getDefaultOutgoingConnections().isEmpty() && !acceptsNoOutgoingConnections(dynamicNode)) {
addErrorMessage(process,
node,
errors,
"Dynamic has no outgoing connection");
}
if (!dynamicNode.hasCompletionCondition() && !dynamicNode.isAutoComplete()) {
addErrorMessage(process,
node,
errors,
"Dynamic has no completion condition set");
}
validateNodes(dynamicNode.getNodes(),
errors,
process);
} else if (node instanceof CompositeNode) {
final CompositeNode compositeNode = (CompositeNode) node;
for (Map.Entry<String, NodeAndType> inType : compositeNode.getLinkedIncomingNodes().entrySet()) {
if (compositeNode.getIncomingConnections(inType.getKey()).isEmpty() && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Composite has no incoming connection for type " + inType.getKey());
}
if (inType.getValue().getNode() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Composite has invalid linked incoming node for type " + inType.getKey());
}
}
for (Map.Entry<String, NodeAndType> outType : compositeNode.getLinkedOutgoingNodes().entrySet()) {
if (compositeNode.getOutgoingConnections(outType.getKey()).isEmpty()) {
addErrorMessage(process,
node,
errors,
"Composite has no outgoing connection for type " + outType.getKey());
}
if (outType.getValue().getNode() == null) {
addErrorMessage(process,
node,
errors,
"Composite has invalid linked outgoing node for type " + outType.getKey());
}
}
if (compositeNode.getLinkedIncomingNodes().values().isEmpty()) {
boolean foundStartNode = false;
for (org.kie.api.definition.process.Node internalNode : compositeNode.getNodes()) {
if (internalNode instanceof StartNode) {
foundStartNode = true;
}
}
if (!foundStartNode) {
addErrorMessage(process,
node,
errors,
"Composite has no start node defined.");
}
}
if (compositeNode instanceof EventSubProcessNode) {
if (compositeNode.getIncomingConnections().size() > 0) {
addErrorMessage(process,
node,
errors,
"Event subprocess is not allowed to have any incoming connections.");
}
if (compositeNode.getOutgoingConnections().size() > 0) {
addErrorMessage(process,
node,
errors,
"Event subprocess is not allowed to have any outgoing connections.");
}
org.kie.api.definition.process.Node[] eventSubProcessNodes = compositeNode.getNodes();
int startEventCount = 0;
for (int j = 0; j < eventSubProcessNodes.length; ++j) {
if (eventSubProcessNodes[j] instanceof StartNode) {
StartNode startNode = (StartNode) eventSubProcessNodes[j];
if (++startEventCount == 2) {
addErrorMessage(process,
compositeNode,
errors,
"Event subprocess is not allowed to have more than one start node.");
}
if (startNode.getTriggers() == null || startNode.getTriggers().isEmpty()) {
addErrorMessage(process,
startNode,
errors,
"Start in Event SubProcess '" + compositeNode.getName() + "' [" + compositeNode.getId().toExternalFormat() + "] must contain a trigger (event definition).");
}
}
}
} else {
Boolean isForCompensationObject = (Boolean) compositeNode.getMetaData("isForCompensation");
if (compositeNode.getIncomingConnections().size() == 0 && !Boolean.TRUE.equals(isForCompensationObject)) {
addErrorMessage(process,
node,
errors,
"Embedded subprocess does not have incoming connection.");
}
if (compositeNode.getOutgoingConnections().size() == 0 && !Boolean.TRUE.equals(isForCompensationObject)) {
addErrorMessage(process,
node,
errors,
"Embedded subprocess does not have outgoing connection.");
}
final List<org.kie.api.definition.process.Node> start = RuleFlowProcess.getStartNodes(compositeNode.getNodes());
if (start != null) {
for (org.kie.api.definition.process.Node s : start) {
if (((StartNode) s).getTriggers() != null && !((StartNode) s).getTriggers().isEmpty() || ((StartNode) s).getTimer() != null) {
addErrorMessage(process,
node,
errors,
"Embedded subprocess can only have none start event.");
}
}
}
}
if (compositeNode.getTimers() != null) {
for (Timer timer : compositeNode.getTimers().keySet()) {
validateTimer(timer,
node,
process,
errors);
}
}
validateNodes(compositeNode.getNodes(),
errors,
process);
} else if (node instanceof EventNode) {
final EventNode eventNode = (EventNode) node;
if (eventNode.getEventFilters().isEmpty()) {
addErrorMessage(process,
node,
errors,
"Event should specify an event type");
}
if (eventNode instanceof BoundaryEventNode && EVENT_TYPE_MESSAGE.equals(eventNode.getMetaData(EVENT_TYPE))) {
if (eventNode.getMetaData(TRIGGER_REF) == null) {
addErrorMessage(process,
node,
errors,
"Boundary event missing message name");
}
if (eventNode.getVariableName() == null) {
addErrorMessage(process,
node,
errors,
"Boundary event missing variable in data assignment");
}
if (eventNode.getMetaData(MESSAGE_TYPE) == null) {
addErrorMessage(process,
node,
errors,
"Boundary event missing message type");
}
}
if (eventNode.getDefaultOutgoingConnections().isEmpty()) {
addErrorMessage(process,
node,
errors,
"Event has no outgoing connection");
} else {
List<EventFilter> eventFilters = eventNode.getEventFilters();
boolean compensationHandler = false;
for (EventFilter eventFilter : eventFilters) {
if (((EventTypeFilter) eventFilter).getType().startsWith("Compensation")) {
compensationHandler = true;
break;
}
}
if (compensationHandler && eventNode instanceof BoundaryEventNode) {
Connection connection = eventNode.getDefaultOutgoingConnections().get(0);
Boolean isAssociation = (Boolean) connection.getMetaData().get("association");
if (isAssociation == null) {
isAssociation = false;
}
if (!(eventNode.getDefaultOutgoingConnections().size() == 1 && connection != null && isAssociation)) {
addErrorMessage(process,
node,
errors,
"Compensation Boundary Event is only allowed to have 1 association to 1 compensation activity.");
}
}
}
} else if (node instanceof FaultNode) {
final FaultNode faultNode = (FaultNode) node;
if (faultNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Fault has no incoming connection.");
}
if (faultNode.getFaultName() == null) {
addErrorMessage(process,
node,
errors,
"Fault has no fault name.");
}
} else if (node instanceof TimerNode) {
TimerNode timerNode = (TimerNode) node;
if (timerNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Timer has no incoming connection.");
}
if (timerNode.getTo() == null && !acceptsNoOutgoingConnections(node)) {
addErrorMessage(process,
node,
errors,
"Timer has no outgoing connection.");
}
if (timerNode.getTimer() == null) {
addErrorMessage(process,
node,
errors,
"Timer has no timer specified.");
} else {
validateTimer(timerNode.getTimer(),
node,
process,
errors);
}
} else if (node instanceof CatchLinkNode) {
// catchlink validation here, there also are validations in
// ProcessHandler regarding connection issues
} else if (node instanceof ThrowLinkNode) {
// throw validation here, there also are validations in
// ProcessHandler regarding connection issues
} else {
errors.add(new ProcessValidationErrorImpl(process,
"Unknown node type '" + node.getClass().getName() + "'"));
}
}
}