opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/utils/PruningDataTreeModification.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.controller.cluster.datastore.utils;
  10
  11 import com.google.common.annotations.VisibleForTesting;
  12 import com.google.common.base.Optional;
  13 import com.google.common.base.Preconditions;
  14 import java.io.IOException;
  15 import java.util.ArrayDeque;
  16 import java.util.Deque;
  17 import javax.annotation.Nonnull;
  18 import org.opendaylight.controller.cluster.datastore.node.utils.transformer.NormalizedNodePruner;
  19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  21 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  22 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
  23 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
  24 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
  25 import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModificationCursor;
  26 import org.opendaylight.yangtools.yang.data.impl.schema.tree.SchemaValidationFailedException;
  27 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30
  31 /**
  32  * The PruningDataTreeModification first removes all entries from the data which do not belong in the schemaContext
  33  * before delegating it to the actual DataTreeModification
  34  */
  35 public class PruningDataTreeModification implements DataTreeModification {
  36
  37     private static final Logger LOG = LoggerFactory.getLogger(PruningDataTreeModification.class);
  38     private DataTreeModification delegate;
  39     private final SchemaContext schemaContext;
  40     private final DataTree dataTree;
  41
  42     public PruningDataTreeModification(DataTreeModification delegate, DataTree dataTree, SchemaContext schemaContext) {
  43         this.delegate = delegate;
  44         this.dataTree = dataTree;
  45         this.schemaContext = schemaContext;
  46     }
  47
  48     @Override
  49     public void delete(YangInstanceIdentifier yangInstanceIdentifier) {
  50         try {
  51             delegate.delete(yangInstanceIdentifier);
  52         } catch(SchemaValidationFailedException e){
  53             LOG.warn("Node at path : {} does not exist ignoring delete", yangInstanceIdentifier);
  54         }
  55     }
  56
  57     @Override
  58     public void merge(YangInstanceIdentifier yangInstanceIdentifier, NormalizedNode<?, ?> normalizedNode) {
  59         try {
  60             if(YangInstanceIdentifier.EMPTY.equals(yangInstanceIdentifier)){
  61                 pruneAndMergeNode(yangInstanceIdentifier, normalizedNode);
  62             } else {
  63                 delegate.merge(yangInstanceIdentifier, normalizedNode);
  64             }
  65         } catch (SchemaValidationFailedException e){
  66             LOG.warn("Node at path {} was pruned during merge due to validation error: {}",
  67                     yangInstanceIdentifier, e.getMessage());
  68
  69             pruneAndMergeNode(yangInstanceIdentifier, normalizedNode);
  70         }
  71
  72     }
  73
  74     private void pruneAndMergeNode(YangInstanceIdentifier yangInstanceIdentifier, NormalizedNode<?, ?> normalizedNode) {
  75         NormalizedNode<?,?> pruned = pruneNormalizedNode(yangInstanceIdentifier, normalizedNode);
  76
  77         if(pruned != null) {
  78             delegate.merge(yangInstanceIdentifier, pruned);
  79         }
  80     }
  81
  82     @Override
  83     public void write(YangInstanceIdentifier yangInstanceIdentifier, NormalizedNode<?, ?> normalizedNode) {
  84         try {
  85             if(YangInstanceIdentifier.EMPTY.equals(yangInstanceIdentifier)){
  86                 pruneAndWriteNode(yangInstanceIdentifier, normalizedNode);
  87             } else {
  88                 delegate.write(yangInstanceIdentifier, normalizedNode);
  89             }
  90         } catch (SchemaValidationFailedException e){
  91             LOG.warn("Node at path : {} was pruned during write due to validation error: {}",
  92                     yangInstanceIdentifier, e.getMessage());
  93
  94             pruneAndWriteNode(yangInstanceIdentifier, normalizedNode);
  95         }
  96     }
  97
  98     private void pruneAndWriteNode(YangInstanceIdentifier yangInstanceIdentifier, NormalizedNode<?, ?> normalizedNode) {
  99         NormalizedNode<?,?> pruned = pruneNormalizedNode(yangInstanceIdentifier, normalizedNode);
 100
 101         if(pruned != null) {
 102             delegate.write(yangInstanceIdentifier, pruned);
 103         }
 104     }
 105
 106     @Override
 107     public void ready() {
 108         try {
 109             delegate.ready();
 110         } catch (SchemaValidationFailedException e) {
 111             DataTreeModification newModification = dataTree.takeSnapshot().newModification();
 112             delegate.applyToCursor(new PruningDataTreeModificationCursor(newModification, this));
 113
 114             delegate = newModification;
 115             delegate.ready();
 116         }
 117     }
 118
 119     @Override
 120     public void applyToCursor(DataTreeModificationCursor dataTreeModificationCursor) {
 121         delegate.applyToCursor(dataTreeModificationCursor);
 122     }
 123
 124     @Override
 125     public Optional<NormalizedNode<?, ?>> readNode(YangInstanceIdentifier yangInstanceIdentifier) {
 126         return delegate.readNode(yangInstanceIdentifier);
 127     }
 128
 129     @Override
 130     public DataTreeModification newModification() {
 131         return new PruningDataTreeModification(delegate.newModification(), dataTree, schemaContext);
 132     }
 133
 134     @VisibleForTesting
 135     NormalizedNode<?, ?> pruneNormalizedNode(YangInstanceIdentifier path, NormalizedNode<?,?> input) {
 136         NormalizedNodePruner pruner = new NormalizedNodePruner(path, schemaContext);
 137         try {
 138             NormalizedNodeWriter.forStreamWriter(pruner).write(input);
 139         } catch (IOException ioe) {
 140             LOG.error("Unexpected IOException when pruning normalizedNode", ioe);
 141         }
 142
 143         return pruner.normalizedNode();
 144     }
 145
 146     public DataTreeModification getResultingModification(){
 147         return delegate;
 148     }
 149
 150     private static class PruningDataTreeModificationCursor implements DataTreeModificationCursor {
 151         private final Deque<YangInstanceIdentifier> stack = new ArrayDeque<>();
 152         private final DataTreeModification toModification;
 153         private final PruningDataTreeModification pruningModification;
 154
 155         PruningDataTreeModificationCursor(DataTreeModification toModification,
 156                 PruningDataTreeModification pruningModification) {
 157             this.toModification = toModification;
 158             this.pruningModification = pruningModification;
 159             stack.push(YangInstanceIdentifier.EMPTY);
 160         }
 161
 162         @Override
 163         public void write(PathArgument child, NormalizedNode<?, ?> data) {
 164             YangInstanceIdentifier path = stack.peek().node(child);
 165             NormalizedNode<?, ?> prunedNode = pruningModification.pruneNormalizedNode(path, data);
 166             if(prunedNode != null) {
 167                 toModification.write(path, prunedNode);
 168             }
 169         }
 170
 171         @Override
 172         public void merge(PathArgument child, NormalizedNode<?, ?> data) {
 173             YangInstanceIdentifier path = stack.peek().node(child);
 174             NormalizedNode<?, ?> prunedNode = pruningModification.pruneNormalizedNode(path, data);
 175             if(prunedNode != null) {
 176                 toModification.merge(path, prunedNode);
 177             }
 178         }
 179
 180         @Override
 181         public void delete(PathArgument child) {
 182             try {
 183                 toModification.delete(stack.peek().node(child));
 184             } catch(SchemaValidationFailedException e) {
 185                 // Ignoring since we would've already logged this in the call to the original modification.
 186             }
 187         }
 188
 189         @Override
 190         public void enter(@Nonnull final PathArgument child) {
 191             stack.push(stack.peek().node(child));
 192         }
 193
 194         @Override
 195         public void enter(@Nonnull final PathArgument... path) {
 196             for (PathArgument arg : path) {
 197                 enter(arg);
 198             }
 199         }
 200
 201         @Override
 202         public void enter(@Nonnull final Iterable<PathArgument> path) {
 203             for (PathArgument arg : path) {
 204                 enter(arg);
 205             }
 206         }
 207
 208         @Override
 209         public void exit() {
 210             stack.pop();
 211         }
 212
 213         @Override
 214         public void exit(final int depth) {
 215             Preconditions.checkArgument(depth < stack.size(), "Stack holds only %s elements, cannot exit %s levels", stack.size(), depth);
 216             for (int i = 0; i < depth; ++i) {
 217                 stack.pop();
 218             }
 219         }
 220
 221         @Override
 222         public Optional<NormalizedNode<?, ?>> readNode(@Nonnull final PathArgument child) {
 223             throw new UnsupportedOperationException("Not implemented");
 224         }
 225
 226         @Override
 227         public void close() {
 228         }
 229     }
 230 }