2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.yang.data.impl.leafref;
10 import com.google.common.base.Optional;
11 import com.google.common.collect.Iterables;
12 import java.util.ArrayList;
13 import java.util.Collection;
14 import java.util.HashMap;
15 import java.util.HashSet;
16 import java.util.Iterator;
17 import java.util.List;
19 import java.util.Map.Entry;
21 import org.opendaylight.yangtools.yang.common.QName;
22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
25 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
26 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
27 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
28 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
29 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
30 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
31 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
33 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
34 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
35 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
36 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
37 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
38 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
39 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
40 import org.slf4j.Logger;
41 import org.slf4j.LoggerFactory;
43 public class LeafRefValidatation {
45 private static final Logger LOG = LoggerFactory.getLogger(LeafRefValidatation.class);
46 private static final String FAILED = " -> FAILED";
47 private static final String SUCCESS = " -> OK";
49 private final Set<LeafRefContext> validatedLeafRefCtx = new HashSet<>();
50 private final List<String> errorsMessages = new ArrayList<>();
51 private final DataTreeCandidate tree;
53 private LeafRefValidatation(final DataTreeCandidate tree) {
57 public static void validate(final DataTreeCandidate tree, final LeafRefContext rootLeafRefCtx)
58 throws LeafRefDataValidationFailedException {
59 new LeafRefValidatation(tree).validate0(rootLeafRefCtx);
62 private void validate0(final LeafRefContext rootLeafRefCtx) throws LeafRefDataValidationFailedException {
63 for (final DataTreeCandidateNode dataTreeCandidateNode : tree.getRootNode().getChildNodes()) {
64 if (dataTreeCandidateNode.getModificationType() != ModificationType.UNMODIFIED) {
65 final PathArgument identifier = dataTreeCandidateNode.getIdentifier();
66 final QName childQName = identifier.getNodeType();
68 final LeafRefContext referencedByCtx = rootLeafRefCtx.getReferencedChildByName(childQName);
69 final LeafRefContext referencingCtx = rootLeafRefCtx.getReferencingChildByName(childQName);
70 if (referencedByCtx != null || referencingCtx != null) {
71 final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier
72 .create(dataTreeCandidateNode.getIdentifier());
73 validateNode(dataTreeCandidateNode, referencedByCtx, referencingCtx, yangInstanceIdentifier);
78 if (!errorsMessages.isEmpty()) {
79 final StringBuilder message = new StringBuilder();
81 for (final String errorMessage : errorsMessages) {
82 message.append(errorMessage);
85 throw new LeafRefDataValidationFailedException(message.toString(), errCount);
89 private void validateNode(final DataTreeCandidateNode node, final LeafRefContext referencedByCtx,
90 final LeafRefContext referencingCtx, final YangInstanceIdentifier current) {
92 if ((node.getModificationType() == ModificationType.WRITE) && node.getDataAfter().isPresent()) {
93 final Optional<NormalizedNode<?, ?>> dataAfter = node.getDataAfter();
94 final NormalizedNode<?, ?> normalizedNode = dataAfter.get();
95 validateNodeData(normalizedNode, referencedByCtx, referencingCtx,
96 node.getModificationType(), current);
100 if (node.getModificationType() == ModificationType.DELETE && referencedByCtx != null) {
101 final Optional<NormalizedNode<?, ?>> dataBefor = node.getDataBefore();
102 final NormalizedNode<?, ?> normalizedNode = dataBefor.get();
103 validateNodeData(normalizedNode, referencedByCtx, null,
104 node.getModificationType(), current);
108 final Collection<DataTreeCandidateNode> childNodes = node.getChildNodes();
109 for (final DataTreeCandidateNode childNode : childNodes) {
110 if (childNode.getModificationType() != ModificationType.UNMODIFIED) {
111 final LeafRefContext childReferencedByCtx = getReferencedByCtxChild(referencedByCtx, childNode);
112 final LeafRefContext childReferencingCtx = getReferencingCtxChild(referencingCtx, childNode);
114 if (childReferencedByCtx != null || childReferencingCtx != null) {
115 final YangInstanceIdentifier childYangInstanceIdentifier = current.node(childNode.getIdentifier());
116 validateNode(childNode, childReferencedByCtx,childReferencingCtx, childYangInstanceIdentifier);
122 private static LeafRefContext getReferencingCtxChild(final LeafRefContext referencingCtx,
123 final DataTreeCandidateNode childNode) {
124 if (referencingCtx == null) {
128 final QName childQName = childNode.getIdentifier().getNodeType();
129 LeafRefContext childReferencingCtx = referencingCtx.getReferencingChildByName(childQName);
130 if (childReferencingCtx == null) {
131 final NormalizedNode<?, ?> data = childNode.getDataAfter().get();
132 if (data instanceof MapEntryNode || data instanceof UnkeyedListEntryNode) {
133 childReferencingCtx = referencingCtx;
137 return childReferencingCtx;
140 private static LeafRefContext getReferencedByCtxChild(final LeafRefContext referencedByCtx,
141 final DataTreeCandidateNode childNode) {
142 if (referencedByCtx == null) {
146 final QName childQName = childNode.getIdentifier().getNodeType();
147 LeafRefContext childReferencedByCtx = referencedByCtx.getReferencedChildByName(childQName);
148 if (childReferencedByCtx == null) {
149 final NormalizedNode<?, ?> data = childNode.getDataAfter().get();
150 if (data instanceof MapEntryNode || data instanceof UnkeyedListEntryNode) {
151 childReferencedByCtx = referencedByCtx;
155 return childReferencedByCtx;
158 private void validateNodeData(final NormalizedNode<?, ?> node, final LeafRefContext referencedByCtx, final
159 LeafRefContext referencingCtx, final ModificationType modificationType, final YangInstanceIdentifier current) {
161 if (node instanceof LeafNode) {
162 final LeafNode<?> leaf = (LeafNode<?>) node;
164 if (referencedByCtx != null && referencedByCtx.isReferenced()) {
165 validateLeafRefTargetNodeData(leaf, referencedByCtx, modificationType);
167 if (referencingCtx != null && referencingCtx.isReferencing()) {
168 validateLeafRefNodeData(leaf, referencingCtx, modificationType, current);
174 if (node instanceof LeafSetNode) {
175 if (referencedByCtx == null && referencingCtx == null) {
179 final LeafSetNode<?> leafSet = (LeafSetNode<?>) node;
180 for (final NormalizedNode<?, ?> leafSetEntry : leafSet.getValue()) {
181 if (referencedByCtx != null && referencedByCtx.isReferenced()) {
182 validateLeafRefTargetNodeData(leafSetEntry, referencedByCtx, modificationType);
184 if (referencingCtx != null && referencingCtx.isReferencing()) {
185 validateLeafRefNodeData(leafSetEntry, referencingCtx, modificationType, current);
192 if (node instanceof ChoiceNode) {
193 final ChoiceNode choice = (ChoiceNode) node;
194 for (final DataContainerChild<? extends PathArgument, ?> dataContainerChild : choice.getValue()) {
195 final QName qname = dataContainerChild.getNodeType();
197 final LeafRefContext childReferencedByCtx;
198 if (referencedByCtx != null) {
199 childReferencedByCtx = findReferencedByCtxUnderChoice(referencedByCtx, qname);
201 childReferencedByCtx = null;
204 final LeafRefContext childReferencingCtx;
205 if (referencingCtx != null) {
206 childReferencingCtx = findReferencingCtxUnderChoice(referencingCtx, qname);
208 childReferencingCtx = null;
211 if (childReferencedByCtx != null || childReferencingCtx != null) {
212 final YangInstanceIdentifier childYangInstanceIdentifier = current
213 .node(dataContainerChild.getIdentifier());
214 validateNodeData(dataContainerChild, childReferencedByCtx,
215 childReferencingCtx, modificationType, childYangInstanceIdentifier);
218 } else if (node instanceof DataContainerNode) {
219 final DataContainerNode<?> dataContainerNode = (DataContainerNode<?>) node;
221 for (final DataContainerChild<? extends PathArgument, ?> dataContainerChild : dataContainerNode.getValue()) {
222 final QName qname = dataContainerChild.getNodeType();
224 final LeafRefContext childReferencedByCtx;
225 if (referencedByCtx != null) {
226 childReferencedByCtx = referencedByCtx.getReferencedChildByName(qname);
228 childReferencedByCtx = null;
231 final LeafRefContext childReferencingCtx;
232 if (referencingCtx != null) {
233 childReferencingCtx = referencingCtx.getReferencingChildByName(qname);
235 childReferencingCtx = null;
238 if (childReferencedByCtx != null || childReferencingCtx != null) {
239 final YangInstanceIdentifier childYangInstanceIdentifier = current
240 .node(dataContainerChild.getIdentifier());
241 validateNodeData(dataContainerChild, childReferencedByCtx,
242 childReferencingCtx, modificationType, childYangInstanceIdentifier);
245 } else if (node instanceof MapNode) {
246 final MapNode map = (MapNode) node;
248 for (final MapEntryNode mapEntry : map.getValue()) {
249 final YangInstanceIdentifier mapEntryYangInstanceIdentifier = current.node(mapEntry.getIdentifier());
250 for (final DataContainerChild<? extends PathArgument, ?> mapEntryNode : mapEntry.getValue()) {
251 final QName qname = mapEntryNode.getNodeType();
253 final LeafRefContext childReferencedByCtx;
254 if (referencedByCtx != null) {
255 childReferencedByCtx = referencedByCtx.getReferencedChildByName(qname);
257 childReferencedByCtx = null;
260 final LeafRefContext childReferencingCtx;
261 if (referencingCtx != null) {
262 childReferencingCtx = referencingCtx.getReferencingChildByName(qname);
264 childReferencingCtx = null;
267 if (childReferencedByCtx != null || childReferencingCtx != null) {
268 final YangInstanceIdentifier mapEntryNodeYangInstanceIdentifier = mapEntryYangInstanceIdentifier
269 .node(mapEntryNode.getIdentifier());
270 validateNodeData(mapEntryNode, childReferencedByCtx,
271 childReferencingCtx, modificationType,
272 mapEntryNodeYangInstanceIdentifier);
277 // FIXME if (node instance of UnkeyedListNode ...
280 private static LeafRefContext findReferencingCtxUnderChoice(
281 final LeafRefContext referencingCtx, final QName qname) {
283 for (final LeafRefContext child : referencingCtx.getReferencingChilds().values()) {
284 final LeafRefContext referencingChildByName = child.getReferencingChildByName(qname);
285 if (referencingChildByName != null) {
286 return referencingChildByName;
293 private static LeafRefContext findReferencedByCtxUnderChoice(
294 final LeafRefContext referencedByCtx, final QName qname) {
296 for (final LeafRefContext child : referencedByCtx.getReferencedByChilds().values()) {
297 final LeafRefContext referencedByChildByName = child.getReferencedChildByName(qname);
298 if (referencedByChildByName != null) {
299 return referencedByChildByName;
306 private void validateLeafRefTargetNodeData(final NormalizedNode<?, ?> leaf, final LeafRefContext
307 referencedByCtx, final ModificationType modificationType) {
308 final Map<LeafRefContext, Set<?>> leafRefsValues = new HashMap<>();
309 if (validatedLeafRefCtx.contains(referencedByCtx)) {
310 leafRefTargetNodeDataLog(leaf, referencedByCtx, modificationType, leafRefsValues, null);
314 final Map<QName, LeafRefContext> allReferencedByLeafRefCtxs = referencedByCtx.getAllReferencedByLeafRefCtxs();
315 for (final LeafRefContext leafRefContext : allReferencedByLeafRefCtxs.values()) {
316 if (leafRefContext.isReferencing()) {
317 final Set<Object> values = new HashSet<>();
319 final SchemaPath leafRefNodeSchemaPath = leafRefContext.getCurrentNodePath();
320 final LeafRefPath leafRefNodePath = LeafRefUtils.schemaPathToLeafRefPath(leafRefNodeSchemaPath,
321 leafRefContext.getLeafRefContextModule());
322 final Iterable<QNameWithPredicate> pathFromRoot = leafRefNodePath.getPathFromRoot();
323 addValues(values, tree.getRootNode().getDataAfter(), pathFromRoot, null, QNameWithPredicate.ROOT);
324 leafRefsValues.put(leafRefContext, values);
328 if (!leafRefsValues.isEmpty()) {
329 final Set<Object> leafRefTargetNodeValues = new HashSet<>();
330 final SchemaPath nodeSchemaPath = referencedByCtx.getCurrentNodePath();
331 final LeafRefPath nodePath = LeafRefUtils.schemaPathToLeafRefPath(nodeSchemaPath, referencedByCtx
332 .getLeafRefContextModule());
333 addValues(leafRefTargetNodeValues, tree.getRootNode().getDataAfter(), nodePath.getPathFromRoot(), null,
334 QNameWithPredicate.ROOT);
335 leafRefTargetNodeDataLog(leaf, referencedByCtx, modificationType, leafRefsValues,
336 leafRefTargetNodeValues);
338 leafRefTargetNodeDataLog(leaf, referencedByCtx, modificationType, null, null);
340 validatedLeafRefCtx.add(referencedByCtx);
343 private void leafRefTargetNodeDataLog(final NormalizedNode<?, ?> leaf, final LeafRefContext referencedByCtx,
344 final ModificationType modificationType, final Map<LeafRefContext, Set<?>> leafRefsValues,
345 final Set<Object> leafRefTargetNodeValues) {
347 if (leafRefsValues != null && !leafRefsValues.isEmpty()) {
348 final Set<Entry<LeafRefContext, Set<?>>> entrySet = leafRefsValues.entrySet();
349 LOG.debug("Operation [{}] validate data of leafref TARGET node: name[{}] = value[{}]",
350 modificationType, referencedByCtx.getNodeName(), leaf.getValue());
351 for (final Entry<LeafRefContext, Set<?>> entry : entrySet) {
352 final LeafRefContext leafRefContext = entry.getKey();
353 final Set<?> leafRefValuesSet = entry.getValue();
354 for (final Object leafRefsValue : leafRefValuesSet) {
355 if (leafRefTargetNodeValues != null && !leafRefTargetNodeValues.contains(leafRefsValue)) {
356 LOG.debug("Invalid leafref value [{}] allowed values {} by validation of leafref TARGET node:" +
357 " {} path of invalid LEAFREF node: {} leafRef target path: {} {}", leafRefsValue,
358 leafRefTargetNodeValues, leaf.getNodeType(), leafRefContext.getCurrentNodePath(),
359 leafRefContext.getAbsoluteLeafRefTargetPath(), FAILED);
360 errorsMessages.add(String.format("Invalid leafref value [%s] allowed values %s by validation " +
361 "of leafref TARGET node: %s path of invalid LEAFREF node: %s leafRef target " +
362 "path: %s %s", leafRefsValue, leafRefTargetNodeValues, leaf.getNodeType(),
363 leafRefContext.getCurrentNodePath(), leafRefContext.getAbsoluteLeafRefTargetPath(),
366 LOG.debug("Valid leafref value [{}] {}", leafRefsValue, SUCCESS);
370 } else if (leafRefsValues != null) {
371 LOG.debug("Operation [{}] validate data of leafref TARGET node: name[{}] = value[{}] -> SKIP: Already validated",
372 modificationType, referencedByCtx.getNodeName(), leaf.getValue());
376 private void validateLeafRefNodeData(final NormalizedNode<?, ?> leaf, final LeafRefContext referencingCtx,
377 final ModificationType modificationType, final YangInstanceIdentifier current) {
378 final HashSet<Object> values = new HashSet<>();
379 final LeafRefPath targetPath = referencingCtx.getAbsoluteLeafRefTargetPath();
380 final Iterable<QNameWithPredicate> pathFromRoot = targetPath.getPathFromRoot();
382 addValues(values, tree.getRootNode().getDataAfter(), pathFromRoot, current, QNameWithPredicate.ROOT);
384 if (!values.contains(leaf.getValue())) {
385 LOG.debug("Operation [{}] validate data of LEAFREF node: name[{}] = value[{}] {}",
386 modificationType, referencingCtx.getNodeName(), leaf.getValue(), FAILED);
387 LOG.debug("Invalid leafref value [{}] allowed values {} of LEAFREF node: {} leafRef target path: {}",
388 leaf.getValue(), values, leaf.getNodeType(), referencingCtx.getAbsoluteLeafRefTargetPath());
389 errorsMessages.add(String.format("Invalid leafref value [%s] allowed values %s of LEAFREF node: %s " +
390 "leafRef target path: %s", leaf.getValue(), values, leaf.getNodeType(), referencingCtx
391 .getAbsoluteLeafRefTargetPath()));
393 LOG.debug("Operation [{}] validate data of LEAFREF node: name[{}] = value[{}] {}", modificationType,
394 referencingCtx.getNodeName(), leaf.getValue(), SUCCESS);
398 private void addValues(final Set<Object> values, final Optional<? extends NormalizedNode<?, ?>> optDataNode,
399 final Iterable<QNameWithPredicate> path, final YangInstanceIdentifier current, final QNameWithPredicate previousQName) {
401 if (!optDataNode.isPresent()) {
404 final NormalizedNode<?, ?> node = optDataNode.get();
406 if (node instanceof LeafNode || node instanceof LeafSetEntryNode) {
407 values.add(node.getValue());
409 } else if (node instanceof LeafSetNode<?>) {
410 final LeafSetNode<?> leafSetNode = (LeafSetNode<?>) node;
411 final Iterable<? extends NormalizedNode<?, ?>> entries = leafSetNode
413 for (final NormalizedNode<?, ?> entry : entries) {
414 values.add(entry.getValue());
419 final Iterator<QNameWithPredicate> iterator = path.iterator();
420 if (!iterator.hasNext()) {
423 final QNameWithPredicate qnameWithPredicate = iterator.next();
424 final QName qName = qnameWithPredicate.getQName();
425 final PathArgument pathArgument = new NodeIdentifier(qName);
427 if (node instanceof DataContainerNode) {
428 final DataContainerNode<?> dataContainerNode = (DataContainerNode<?>) node;
429 final Optional<DataContainerChild<? extends PathArgument, ?>> child = dataContainerNode
430 .getChild(pathArgument);
432 if (child.isPresent()) {
433 addValues(values, child, nextLevel(path), current, qnameWithPredicate);
435 for (final ChoiceNode choiceNode : getChoiceNodes(dataContainerNode)) {
436 addValues(values, Optional.of(choiceNode), path, current,
441 } else if (node instanceof MapNode) {
442 final MapNode map = (MapNode) node;
443 final List<QNamePredicate> qNamePredicates = previousQName.getQNamePredicates();
444 if (qNamePredicates.isEmpty() || current == null) {
445 final Iterable<MapEntryNode> value = map.getValue();
446 for (final MapEntryNode mapEntryNode : value) {
447 final Optional<DataContainerChild<? extends PathArgument, ?>> child = mapEntryNode
448 .getChild(pathArgument);
450 if (child.isPresent()) {
451 addValues(values, child, nextLevel(path), current, qnameWithPredicate);
453 for (final ChoiceNode choiceNode : getChoiceNodes(mapEntryNode)) {
454 addValues(values, Optional.of(choiceNode), path, current, qnameWithPredicate);
459 final Map<QName, Set<?>> keyValues = new HashMap<>();
461 final Iterator<QNamePredicate> predicates = qNamePredicates.iterator();
462 while (predicates.hasNext()) {
463 final QNamePredicate predicate = predicates.next();
464 final QName identifier = predicate.getIdentifier();
465 final LeafRefPath predicatePathKeyExpression = predicate
466 .getPathKeyExpression();
468 final Set<?> pathKeyExprValues = getPathKeyExpressionValues(
469 predicatePathKeyExpression, current);
471 keyValues.put(identifier, pathKeyExprValues);
474 for (final MapEntryNode mapEntryNode : map.getValue()) {
475 if (isMatchingPredicate(mapEntryNode, keyValues)) {
476 final Optional<DataContainerChild<? extends PathArgument, ?>> child = mapEntryNode
477 .getChild(pathArgument);
479 if (child.isPresent()) {
480 addValues(values, child, nextLevel(path), current, qnameWithPredicate);
482 for (final ChoiceNode choiceNode : getChoiceNodes(mapEntryNode)) {
483 addValues(values, Optional.of(choiceNode), path, current, qnameWithPredicate);
492 private static Iterable<ChoiceNode> getChoiceNodes(final DataContainerNode<?> dataContainerNode) {
493 final List<ChoiceNode> choiceNodes = new ArrayList<>();
494 for (final DataContainerChild<? extends PathArgument, ?> child : dataContainerNode.getValue()) {
495 if (child instanceof ChoiceNode) {
496 choiceNodes.add((ChoiceNode) child);
502 private static boolean isMatchingPredicate(final MapEntryNode mapEntryNode, final Map<QName, Set<?>> allowedKeyValues) {
503 for (final Entry<QName, Object> entryKeyValue : mapEntryNode.getIdentifier().getKeyValues().entrySet()) {
504 final Set<?> allowedValues = allowedKeyValues.get(entryKeyValue.getKey());
505 if (allowedValues != null && !allowedValues.contains(entryKeyValue.getValue())) {
513 private Set<?> getPathKeyExpressionValues(final LeafRefPath predicatePathKeyExpression,
514 final YangInstanceIdentifier current) {
516 final Optional<NormalizedNode<?, ?>> parent = findParentNode(tree.getRootNode().getDataAfter(), current);
518 final Iterable<QNameWithPredicate> predicatePathExpr = predicatePathKeyExpression.getPathFromRoot();
519 final Iterable<QNameWithPredicate> predicatePath = nextLevel(predicatePathExpr);
521 final Set<Object> values = new HashSet<>();
522 if (parent != null) {
523 addValues(values, parent, predicatePath, null,QNameWithPredicate.ROOT);
529 private static Optional<NormalizedNode<?, ?>> findParentNode(
530 final Optional<NormalizedNode<?, ?>> root, final YangInstanceIdentifier path) {
531 Optional<NormalizedNode<?, ?>> currentNode = root;
532 final Iterator<PathArgument> pathIterator = path.getPathArguments().iterator();
533 while (pathIterator.hasNext()) {
534 final PathArgument childPathArgument = pathIterator.next();
535 if (pathIterator.hasNext() && currentNode.isPresent()) {
536 currentNode = NormalizedNodes.getDirectChild(currentNode.get(), childPathArgument);
541 return Optional.absent();
544 private static Iterable<QNameWithPredicate> nextLevel(final Iterable<QNameWithPredicate> path) {
545 return Iterables.skip(path, 1);