X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;ds=sidebyside;f=opendaylight%2Fmd-sal%2Fsal-inmemory-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fdom%2Fstore%2Fimpl%2FResolveDataChangeEventsTask.java;h=2e45150bb34576f77e8f1a58d9fef913a7d2fb1b;hb=401577076374485afea34caeb33bce474563f752;hp=a4e8c86aa83f1b10f084f86f81a10feb08178d58;hpb=4069cc0308f8fd76fffdbf6b010b2d4e25537a95;p=controller.git
diff --git a/opendaylight/md-sal/sal-inmemory-datastore/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeEventsTask.java b/opendaylight/md-sal/sal-inmemory-datastore/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeEventsTask.java
index a4e8c86aa8..2e45150bb3 100644
--- a/opendaylight/md-sal/sal-inmemory-datastore/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeEventsTask.java
+++ b/opendaylight/md-sal/sal-inmemory-datastore/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeEventsTask.java
@@ -7,23 +7,19 @@
*/
package org.opendaylight.controller.md.sal.dom.store.impl;
-import com.google.common.base.Optional;
+import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
-
-import java.util.ArrayList;
import java.util.Collection;
import java.util.Map.Entry;
-import java.util.concurrent.Callable;
-
+import java.util.Optional;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener;
import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.Builder;
import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.SimpleEventFactory;
-import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree;
-import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree.Walker;
+import org.opendaylight.controller.sal.core.compat.DataChangeListenerRegistration;
+import org.opendaylight.controller.sal.core.compat.ListenerTree;
+import org.opendaylight.mdsal.dom.spi.RegistrationTreeSnapshot;
import org.opendaylight.yangtools.util.concurrent.NotificationManager;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@@ -37,39 +33,29 @@ import org.slf4j.LoggerFactory;
/**
* Resolve Data Change Events based on modifications and listeners
*
- * Computes data change events for all affected registered listeners in data
- * tree.
+ *
+ * Computes data change events for all affected registered listeners in data tree.
*/
-final class ResolveDataChangeEventsTask implements Callable> {
+@Beta
+public final class ResolveDataChangeEventsTask {
private static final Logger LOG = LoggerFactory.getLogger(ResolveDataChangeEventsTask.class);
- @SuppressWarnings("rawtypes")
- private final NotificationManager notificationMgr;
private final DataTreeCandidate candidate;
private final ListenerTree listenerRoot;
private Multimap, DOMImmutableDataChangeEvent> collectedEvents;
- @SuppressWarnings("rawtypes")
- public ResolveDataChangeEventsTask(final DataTreeCandidate candidate, final ListenerTree listenerTree,
- final NotificationManager notificationMgr) {
+ private ResolveDataChangeEventsTask(final DataTreeCandidate candidate, final ListenerTree listenerTree) {
this.candidate = Preconditions.checkNotNull(candidate);
this.listenerRoot = Preconditions.checkNotNull(listenerTree);
- this.notificationMgr = Preconditions.checkNotNull(notificationMgr);
}
/**
- * Resolves and creates Notification Tasks
- *
- * Implementation of done as Map-Reduce with two steps: 1. resolving events
- * and their mapping to listeners 2. merging events affecting same listener
- *
- * @return An {@link Iterable} of Notification Tasks which needs to be executed in
- * order to delivery data change events.
+ * Resolves and submits notification tasks to the specified manager.
*/
- @Override
- public synchronized Iterable call() {
- try (final Walker w = listenerRoot.getWalker()) {
+ public synchronized void resolve(final NotificationManager,
+ DOMImmutableDataChangeEvent> manager) {
+ try (RegistrationTreeSnapshot> w = listenerRoot.takeSnapshot()) {
// Defensive: reset internal state
collectedEvents = ArrayListMultimap.create();
@@ -81,8 +67,8 @@ final class ResolveDataChangeEventsTask implements Callable ret = new ArrayList<>();
- for (Entry, Collection> e : collectedEvents.asMap().entrySet()) {
+ for (Entry, Collection> e :
+ collectedEvents.asMap().entrySet()) {
final Collection col = e.getValue();
final DOMImmutableDataChangeEvent event;
@@ -98,17 +84,13 @@ final class ResolveDataChangeEventsTask implements Callable> maybeBefore = node.getDataBefore();
+ final Optional> maybeAfter = node.getDataAfter();
+ final ModificationType type = node.getModificationType();
+
+ if (type != ModificationType.UNMODIFIED && !maybeAfter.isPresent() && !maybeBefore.isPresent()) {
LOG.debug("Modification at {} has type {}, but no before- and after-data. Assuming unchanged.",
- state.getPath(), node.getModificationType());
+ state.getPath(), type);
return false;
}
// no before and after state is present
- switch (node.getModificationType()) {
- case SUBTREE_MODIFIED:
- return resolveSubtreeChangeEvent(state, node);
- case MERGE:
- case WRITE:
- Preconditions.checkArgument(node.getDataAfter().isPresent(),
- "Modification at {} has type {} but no after-data", state.getPath(), node.getModificationType());
- if (!node.getDataBefore().isPresent()) {
- resolveCreateEvent(state, node.getDataAfter().get());
- return true;
- }
+ switch (type) {
+ case SUBTREE_MODIFIED:
+ return resolveSubtreeChangeEvent(state, node);
+ case APPEARED:
+ case WRITE:
+ Preconditions.checkArgument(maybeAfter.isPresent(),
+ "Modification at {} has type {} but no after-data", state.getPath(), type);
+ if (!maybeBefore.isPresent()) {
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ final NormalizedNode afterNode = (NormalizedNode)maybeAfter.get();
+ resolveSameEventRecursivelly(state, afterNode, DOMImmutableDataChangeEvent.getCreateEventFactory());
+ return true;
+ }
- return resolveReplacedEvent(state, node.getDataBefore().get(), node.getDataAfter().get());
- case DELETE:
- Preconditions.checkArgument(node.getDataBefore().isPresent(),
- "Modification at {} has type {} but no before-data", state.getPath(), node.getModificationType());
- resolveDeleteEvent(state, node.getDataBefore().get());
- return true;
- case UNMODIFIED:
- return false;
+ return resolveReplacedEvent(state, maybeBefore.get(), maybeAfter.get());
+ case DISAPPEARED:
+ case DELETE:
+ Preconditions.checkArgument(maybeBefore.isPresent(),
+ "Modification at {} has type {} but no before-data", state.getPath(), type);
+
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ final NormalizedNode beforeNode = (NormalizedNode)maybeBefore.get();
+ resolveSameEventRecursivelly(state, beforeNode, DOMImmutableDataChangeEvent.getRemoveEventFactory());
+ return true;
+ case UNMODIFIED:
+ return false;
+ default:
+ break;
}
- throw new IllegalStateException(String.format("Unhandled node state %s at %s", node.getModificationType(), state.getPath()));
+ throw new IllegalStateException(String.format("Unhandled node state %s at %s", type, state.getPath()));
}
private boolean resolveReplacedEvent(final ResolveDataChangeState state,
@@ -168,11 +161,14 @@ final class ResolveDataChangeEventsTask implements Callable> beforeCont = (NormalizedNodeContainer, PathArgument, NormalizedNode>) beforeData;
+ NormalizedNodeContainer, PathArgument, NormalizedNode> beforeCont =
+ (NormalizedNodeContainer, PathArgument, NormalizedNode>) beforeData;
@SuppressWarnings("unchecked")
- NormalizedNodeContainer, PathArgument, NormalizedNode> afterCont = (NormalizedNodeContainer, PathArgument, NormalizedNode>) afterData;
+ NormalizedNodeContainer, PathArgument, NormalizedNode> afterCont =
+ (NormalizedNodeContainer, PathArgument, NormalizedNode>) afterData;
return resolveNodeContainerReplaced(state, beforeCont, afterCont);
}
@@ -184,7 +180,8 @@ final class ResolveDataChangeEventsTask implements Callable afterState) {
- @SuppressWarnings({ "unchecked", "rawtypes" })
- final NormalizedNode node = (NormalizedNode) afterState;
- resolveSameEventRecursivelly(state, node, DOMImmutableDataChangeEvent.getCreateEventFactory());
- }
-
- private void resolveDeleteEvent(final ResolveDataChangeState state, final NormalizedNode, ?> beforeState) {
- @SuppressWarnings({ "unchecked", "rawtypes" })
- final NormalizedNode node = (NormalizedNode) beforeState;
- resolveSameEventRecursivelly(state, node, DOMImmutableDataChangeEvent.getRemoveEventFactory());
- }
-
private void resolveSameEventRecursivelly(final ResolveDataChangeState state,
final NormalizedNode node, final SimpleEventFactory eventFactory) {
if (!state.needsProcessing()) {
@@ -279,7 +257,8 @@ final class ResolveDataChangeEventsTask implements Callable> container = (NormalizedNodeContainer, PathArgument, NormalizedNode>) node;
+ NormalizedNodeContainer, PathArgument, NormalizedNode> container =
+ (NormalizedNodeContainer, PathArgument, NormalizedNode>) node;
for (NormalizedNode child : container.getValue()) {
final PathArgument childId = child.getIdentifier();
@@ -294,38 +273,53 @@ final class ResolveDataChangeEventsTask implements Callable> maybeBefore = modification.getDataBefore();
+ final Optional> maybeAfter = modification.getDataAfter();
+
+ Preconditions.checkArgument(maybeBefore.isPresent(), "Subtree change with before-data not present at path %s",
+ state.getPath());
+ Preconditions.checkArgument(maybeAfter.isPresent(), "Subtree change with after-data not present at path %s",
+ state.getPath());
+
+ if (!state.needsProcessing()) {
+ LOG.trace("Not processing modified subtree {}", state.getPath());
+ return true;
+ }
DataChangeScope scope = null;
for (DataTreeCandidateNode childMod : modification.getChildNodes()) {
final ResolveDataChangeState childState = state.child(childMod.getIdentifier());
switch (childMod.getModificationType()) {
- case WRITE:
- case MERGE:
- case DELETE:
- if (resolveAnyChangeEvent(childState, childMod)) {
- scope = DataChangeScope.ONE;
- }
- break;
- case SUBTREE_MODIFIED:
- if (resolveSubtreeChangeEvent(childState, childMod) && scope == null) {
- scope = DataChangeScope.SUBTREE;
- }
- break;
- case UNMODIFIED:
- // no-op
- break;
+ case APPEARED:
+ case DELETE:
+ case DISAPPEARED:
+ case WRITE:
+ if (resolveAnyChangeEvent(childState, childMod)) {
+ scope = DataChangeScope.ONE;
+ }
+ break;
+ case SUBTREE_MODIFIED:
+ if (resolveSubtreeChangeEvent(childState, childMod) && scope == null) {
+ scope = DataChangeScope.SUBTREE;
+ }
+ break;
+ case UNMODIFIED:
+ // no-op
+ break;
+ default:
+ break;
}
}
- final NormalizedNode, ?> before = modification.getDataBefore().get();
- final NormalizedNode, ?> after = modification.getDataAfter().get();
+ final NormalizedNode, ?> before = maybeBefore.get();
+ final NormalizedNode, ?> after = maybeAfter.get();
if (scope != null) {
- DOMImmutableDataChangeEvent one = DOMImmutableDataChangeEvent.builder(scope).addUpdated(state.getPath(), before, after).build();
+ DOMImmutableDataChangeEvent one = DOMImmutableDataChangeEvent.builder(scope)
+ .addUpdated(state.getPath(), before, after).build();
state.addEvent(one);
}
@@ -333,10 +327,8 @@ final class ResolveDataChangeEventsTask implements Callable notificationMgr) {
- return new ResolveDataChangeEventsTask(candidate, listenerTree, notificationMgr);
+ final ListenerTree listenerTree) {
+ return new ResolveDataChangeEventsTask(candidate, listenerTree);
}
}