opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/DataChangeEventResolver.java

   1 package org.opendaylight.controller.md.sal.dom.store.impl;
   2
   3 import static org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.builder;
   4 import static org.opendaylight.controller.md.sal.dom.store.impl.StoreUtils.append;
   5 import static org.opendaylight.controller.md.sal.dom.store.impl.tree.TreeNodeUtils.getChild;
   6
   7 import java.util.ArrayList;
   8 import java.util.Collection;
   9
  10 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  11 import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.Builder;
  12 import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerRegistrationNode;
  13 import org.opendaylight.controller.md.sal.dom.store.impl.tree.NodeModification;
  14 import org.opendaylight.controller.md.sal.dom.store.impl.tree.StoreMetadataNode;
  15 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
  16 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
  17 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  18 import org.slf4j.Logger;
  19 import org.slf4j.LoggerFactory;
  20
  21 import com.google.common.base.Optional;
  22 import com.google.common.collect.ImmutableList;
  23 import com.google.common.collect.ImmutableSet;
  24
  25 public class DataChangeEventResolver {
  26
  27
  28     private  static final Logger LOG = LoggerFactory.getLogger(DataChangeEventResolver.class);
  29
  30     private static final DOMImmutableDataChangeEvent NO_CHANGE = builder().build();
  31     private InstanceIdentifier rootPath;
  32     private ListenerRegistrationNode listenerRoot;
  33     private NodeModification modificationRoot;
  34     private Optional<StoreMetadataNode> beforeRoot;
  35     private Optional<StoreMetadataNode> afterRoot;
  36     private final ImmutableList.Builder<ChangeListenerNotifyTask> tasks = ImmutableList.builder();
  37
  38     protected InstanceIdentifier getRootPath() {
  39         return rootPath;
  40     }
  41
  42     protected DataChangeEventResolver setRootPath(final InstanceIdentifier rootPath) {
  43         this.rootPath = rootPath;
  44         return this;
  45     }
  46
  47     protected ListenerRegistrationNode getListenerRoot() {
  48         return listenerRoot;
  49     }
  50
  51     protected DataChangeEventResolver setListenerRoot(final ListenerRegistrationNode listenerRoot) {
  52         this.listenerRoot = listenerRoot;
  53         return this;
  54     }
  55
  56     protected NodeModification getModificationRoot() {
  57         return modificationRoot;
  58     }
  59
  60     protected DataChangeEventResolver setModificationRoot(final NodeModification modificationRoot) {
  61         this.modificationRoot = modificationRoot;
  62         return this;
  63     }
  64
  65     protected Optional<StoreMetadataNode> getBeforeRoot() {
  66         return beforeRoot;
  67     }
  68
  69     protected DataChangeEventResolver setBeforeRoot(final Optional<StoreMetadataNode> beforeRoot) {
  70         this.beforeRoot = beforeRoot;
  71         return this;
  72     }
  73
  74     protected Optional<StoreMetadataNode> getAfterRoot() {
  75         return afterRoot;
  76     }
  77
  78     protected DataChangeEventResolver setAfterRoot(final Optional<StoreMetadataNode> afterRoot) {
  79         this.afterRoot = afterRoot;
  80         return this;
  81     }
  82
  83     public Iterable<ChangeListenerNotifyTask> resolve() {
  84         LOG.trace("Resolving events for {}" ,modificationRoot);
  85         resolveAnyChangeEvent(rootPath, Optional.of(listenerRoot), modificationRoot, beforeRoot, afterRoot);
  86         return tasks.build();
  87     }
  88
  89     private DOMImmutableDataChangeEvent resolveAnyChangeEvent(final InstanceIdentifier path,
  90             final Optional<ListenerRegistrationNode> listeners, final NodeModification modification,
  91             final Optional<StoreMetadataNode> before, final Optional<StoreMetadataNode> after) {
  92         // No listeners are present in listener registration subtree
  93         // no before and after state is present
  94         if (!before.isPresent() && !after.isPresent()) {
  95             return NO_CHANGE;
  96         }
  97         switch (modification.getModificationType()) {
  98         case SUBTREE_MODIFIED:
  99             return resolveSubtreeChangeEvent(path, listeners, modification, before.get(), after.get());
 100         case WRITE:
 101             if (before.isPresent()) {
 102                 return resolveReplacedEvent(path, listeners, modification, before.get(), after.get());
 103             } else {
 104                 return resolveCreateEvent(path, listeners, after.get());
 105             }
 106         case DELETE:
 107             return resolveDeleteEvent(path, listeners, before.get());
 108         default:
 109             return NO_CHANGE;
 110         }
 111
 112     }
 113
 114     /**
 115      * Resolves create events deep down the interest listener tree.
 116      *
 117      *
 118      * @param path
 119      * @param listeners
 120      * @param afterState
 121      * @return
 122      */
 123     private DOMImmutableDataChangeEvent resolveCreateEvent(final InstanceIdentifier path,
 124             final Optional<ListenerRegistrationNode> listeners, final StoreMetadataNode afterState) {
 125         final NormalizedNode<?, ?> node = afterState.getData();
 126         Builder builder = builder().setAfter(node).addCreated(path, node);
 127
 128         for (StoreMetadataNode child : afterState.getChildren()) {
 129             PathArgument childId = child.getIdentifier();
 130             Optional<ListenerRegistrationNode> childListeners = getChild(listeners, childId);
 131
 132             InstanceIdentifier childPath = StoreUtils.append(path, childId);
 133             builder.merge(resolveCreateEvent(childPath, childListeners, child));
 134         }
 135
 136         DOMImmutableDataChangeEvent event = builder.build();
 137         if (listeners.isPresent()) {
 138             addNotifyTask(listeners.get().getListeners(), event);
 139         }
 140         return event;
 141     }
 142
 143     private DOMImmutableDataChangeEvent resolveDeleteEvent(final InstanceIdentifier path,
 144             final Optional<ListenerRegistrationNode> listeners, final StoreMetadataNode beforeState) {
 145         final NormalizedNode<?, ?> node = beforeState.getData();
 146         Builder builder = builder().setBefore(node).addRemoved(path, node);
 147
 148         for (StoreMetadataNode child : beforeState.getChildren()) {
 149             PathArgument childId = child.getIdentifier();
 150             Optional<ListenerRegistrationNode> childListeners = getChild(listeners, childId);
 151             InstanceIdentifier childPath = StoreUtils.append(path, childId);
 152             builder.merge(resolveDeleteEvent(childPath, childListeners, child));
 153         }
 154         DOMImmutableDataChangeEvent event = builder.build();
 155         if (listeners.isPresent()) {
 156             addNotifyTask(listeners.get().getListeners(), event);
 157         }
 158         return event;
 159
 160     }
 161
 162     private DOMImmutableDataChangeEvent resolveSubtreeChangeEvent(final InstanceIdentifier path,
 163             final Optional<ListenerRegistrationNode> listeners, final NodeModification modification,
 164             final StoreMetadataNode before, final StoreMetadataNode after) {
 165
 166         Builder one = builder().setBefore(before.getData()).setAfter(after.getData());
 167
 168         Builder subtree = builder();
 169
 170         for (NodeModification childMod : modification.getModifications()) {
 171             PathArgument childId = childMod.getIdentifier();
 172             InstanceIdentifier childPath = append(path, childId);
 173             Optional<ListenerRegistrationNode> childListen = getChild(listeners, childId);
 174
 175             Optional<StoreMetadataNode> childBefore = before.getChild(childId);
 176             Optional<StoreMetadataNode> childAfter = after.getChild(childId);
 177
 178             switch (childMod.getModificationType()) {
 179             case WRITE:
 180             case DELETE:
 181                 one.merge(resolveAnyChangeEvent(childPath, childListen, childMod, childBefore, childAfter));
 182                 break;
 183             case SUBTREE_MODIFIED:
 184                 subtree.merge(resolveSubtreeChangeEvent(childPath, childListen, childMod, childBefore.get(),
 185                         childAfter.get()));
 186                 break;
 187             case UNMODIFIED:
 188                 // no-op
 189                 break;
 190             }
 191         }
 192         DOMImmutableDataChangeEvent oneChangeEvent = one.build();
 193         subtree.merge(oneChangeEvent);
 194         DOMImmutableDataChangeEvent subtreeEvent = subtree.build();
 195         if (listeners.isPresent()) {
 196             addNotifyTask(listeners.get(), DataChangeScope.ONE, oneChangeEvent);
 197             addNotifyTask(listeners.get(), DataChangeScope.SUBTREE, subtreeEvent);
 198         }
 199         return subtreeEvent;
 200     }
 201
 202     private DOMImmutableDataChangeEvent resolveReplacedEvent(final InstanceIdentifier path,
 203             final Optional<ListenerRegistrationNode> listeners, final NodeModification modification,
 204             final StoreMetadataNode before, final StoreMetadataNode after) {
 205         // FIXME Add task
 206         return builder().build();
 207     }
 208
 209     private void addNotifyTask(final ListenerRegistrationNode listenerRegistrationNode, final DataChangeScope scope,
 210             final DOMImmutableDataChangeEvent event) {
 211         Collection<DataChangeListenerRegistration<?>> potential = listenerRegistrationNode.getListeners();
 212         if(potential.isEmpty()) {
 213             return;
 214         }
 215         ArrayList<DataChangeListenerRegistration<?>> toNotify = new ArrayList<>(potential.size());
 216         for(DataChangeListenerRegistration<?> listener : potential) {
 217             if(scope.equals(listener.getScope())) {
 218                 toNotify.add(listener);
 219             }
 220         }
 221         addNotifyTask(toNotify, event);
 222
 223     }
 224
 225     private void addNotifyTask(final Collection<DataChangeListenerRegistration<?>> listeners,
 226             final DOMImmutableDataChangeEvent event) {
 227         if(!listeners.isEmpty()) {
 228             tasks.add(new ChangeListenerNotifyTask(ImmutableSet.copyOf(listeners),event));
 229         }
 230     }
 231
 232     public static DataChangeEventResolver create() {
 233         return new DataChangeEventResolver();
 234     }
 235
 236
 237
 238 }