Bug-5691: Replace usage of deprecated DCL with DTCL

Change-Id: Id92514c2d07cc694be58578ad0e53ac73383d27b
Signed-off-by: Ajay L <ajayl.bro@gmail.com>

diff --git a/data-change-counter/src/main/java/org/opendaylight/controller/config/yang/bgpcep/data/change/counter/DataChangeCounterImplModule.java b/data-change-counter/src/main/java/org/opendaylight/controller/config/yang/bgpcep/data/change/counter/DataChangeCounterImplModule.java
index f057d65f65e1f64e14e76c1dc1c69294151cf4b2..a936f019c5e65f4d638aeacf38d261fa15119c6c 100755 (executable)
--- a/data-change-counter/src/main/java/org/opendaylight/controller/config/yang/bgpcep/data/change/counter/DataChangeCounterImplModule.java
+++ b/data-change-counter/src/main/java/org/opendaylight/controller/config/yang/bgpcep/data/change/counter/DataChangeCounterImplModule.java
@@ -9,8 +9,7 @@
 package org.opendaylight.controller.config.yang.bgpcep.data.change.counter;
 
 import org.opendaylight.controller.config.api.JmxAttributeValidationException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.protocol.data.change.counter.TopologyDataChangeCounter;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
@@ -45,18 +44,18 @@ public class DataChangeCounterImplModule extends org.opendaylight.controller.con
         final TopologyDataChangeCounter counter = new TopologyDataChangeCounter(getDataProviderDependency(), getCounterId());
         final InstanceIdentifier<Topology> topoIId = InstanceIdentifier.builder(NetworkTopology.class)
                 .child(Topology.class, new TopologyKey(new TopologyId(getTopologyName()))).build();
-        final ListenerRegistration<DataChangeListener> registration = getDataProviderDependency().registerDataChangeListener(
-                LogicalDatastoreType.OPERATIONAL, topoIId, counter, DataBroker.DataChangeScope.SUBTREE);
+        final ListenerRegistration<TopologyDataChangeCounter> registration = getDataProviderDependency().registerDataTreeChangeListener(
+                new DataTreeIdentifier<Topology>(LogicalDatastoreType.OPERATIONAL, topoIId), counter);
         return new DataChangeCounterCloseable(counter, registration);
     }
 
     private static final class DataChangeCounterCloseable implements AutoCloseable {
 
         private final TopologyDataChangeCounter inner;
-        private final ListenerRegistration<DataChangeListener> registration;
+        private final ListenerRegistration<TopologyDataChangeCounter> registration;
 
         public DataChangeCounterCloseable(final TopologyDataChangeCounter inner,
-                final ListenerRegistration<DataChangeListener> registration) {
+                final ListenerRegistration<TopologyDataChangeCounter> registration) {
             this.inner = inner;
             this.registration = registration;
         }

diff --git a/data-change-counter/src/main/java/org/opendaylight/protocol/data/change/counter/TopologyDataChangeCounter.java b/data-change-counter/src/main/java/org/opendaylight/protocol/data/change/counter/TopologyDataChangeCounter.java
index 572fdcf375371d7a0e76d4cc1255f92da48feca9..d1eae3c5f677cc5adf230ae8a9e3b8f16feabbe9 100755 (executable)
--- a/data-change-counter/src/main/java/org/opendaylight/protocol/data/change/counter/TopologyDataChangeCounter.java
+++ b/data-change-counter/src/main/java/org/opendaylight/protocol/data/change/counter/TopologyDataChangeCounter.java
@@ -8,12 +8,13 @@
 
 package org.opendaylight.protocol.data.change.counter;
 
+import java.util.Collection;
 import java.util.concurrent.atomic.AtomicLong;
 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
 import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
@@ -23,12 +24,12 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.data
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.data.change.counter.rev160315.data.change.counter.Counter;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.data.change.counter.rev160315.data.change.counter.CounterBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.data.change.counter.rev160315.data.change.counter.CounterKey;
-import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class TopologyDataChangeCounter implements DataChangeListener, TransactionChainListener {
+public class TopologyDataChangeCounter implements DataTreeChangeListener<Topology>, TransactionChainListener {
 
     private static final Logger LOG = LoggerFactory.getLogger(TopologyDataChangeCounter.class);
 
@@ -50,7 +51,7 @@ public class TopologyDataChangeCounter implements DataChangeListener, Transactio
     }
 
     @Override
-    public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+    public void onDataTreeChanged(final Collection<DataTreeModification<Topology>> changes) {
         putCount(this.count.incrementAndGet());
         LOG.debug("Data change #{} for counter {}", this.count.get(), this.counterId);
     }

diff --git a/data-change-counter/src/test/java/org/opendaylight/controller/config/yang/bgpcep/data/change/counter/DataChangeCounterImplModuleTest.java b/data-change-counter/src/test/java/org/opendaylight/controller/config/yang/bgpcep/data/change/counter/DataChangeCounterImplModuleTest.java
index 7b7b320236e3f9b1fd8379dd8a7df2755bfaff70..20acfc3c4a528198711e525c0d8e8d947a0b59fa 100755 (executable)
--- a/data-change-counter/src/test/java/org/opendaylight/controller/config/yang/bgpcep/data/change/counter/DataChangeCounterImplModuleTest.java
+++ b/data-change-counter/src/test/java/org/opendaylight/controller/config/yang/bgpcep/data/change/counter/DataChangeCounterImplModuleTest.java
@@ -28,7 +28,8 @@ import org.opendaylight.controller.config.spi.Module;
 import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
 import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
@@ -49,26 +50,26 @@ public class DataChangeCounterImplModuleTest extends AbstractConfigTest {
     private static final String NEW_TOPOLOGY_NAME = "new-test";
 
     @Mock
-    private CloseableDataBroker dataBorker;
+    private CloseableDataBroker dataBroker;
     @Mock
     private BindingTransactionChain chain;
     @Mock
     private WriteTransaction wTx;
     @Mock
-    private ListenerRegistration<DataChangeListener> registration;
+    private ListenerRegistration<DataTreeChangeListener<?>> registration;
 
     @Before
     public void setUp() throws Exception {
         Mockito.doNothing().when(this.registration).close();
         Mockito.doReturn(null).when(this.wTx).submit();
         Mockito.doNothing().when(this.wTx).put(Mockito.any(LogicalDatastoreType.class), Mockito.<InstanceIdentifier<DataChangeCounter>>any(), Mockito.any(DataChangeCounter.class));
-        Mockito.doReturn(this.registration).when(this.dataBorker).registerDataChangeListener(Mockito.any(LogicalDatastoreType.class), Mockito.<InstanceIdentifier<?>>any(), Mockito.any(DataChangeListener.class), Mockito.any(DataBroker.DataChangeScope.class));
+        Mockito.doReturn(this.registration).when(this.dataBroker).registerDataTreeChangeListener(Mockito.any(DataTreeIdentifier.class), Mockito.any(DataTreeChangeListener.class));
         Mockito.doNothing().when(this.wTx).delete(Mockito.any(LogicalDatastoreType.class), Mockito.<InstanceIdentifier<?>>any());
-        Mockito.doReturn(this.chain).when(this.dataBorker).createTransactionChain(Mockito.any(TransactionChainListener.class));
+        Mockito.doReturn(this.chain).when(this.dataBroker).createTransactionChain(Mockito.any(TransactionChainListener.class));
         Mockito.doReturn(this.wTx).when(this.chain).newWriteOnlyTransaction();
-        Mockito.doReturn(this.wTx).when(this.dataBorker).newWriteOnlyTransaction();
+        Mockito.doReturn(this.wTx).when(this.dataBroker).newWriteOnlyTransaction();
         Mockito.doNothing().when(this.chain).close();
-        Mockito.doNothing().when(this.dataBorker).close();
+        Mockito.doNothing().when(this.dataBroker).close();
         super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(this.mockedContext, new DataChangeCounterImplModuleFactory(), new MockDataBrokerModuleFct()));
     }
 
@@ -193,7 +194,7 @@ public class DataChangeCounterImplModuleTest extends AbstractConfigTest {
 
         @Override
         public AutoCloseable getInstance() {
-            return DataChangeCounterImplModuleTest.this.dataBorker;
+            return DataChangeCounterImplModuleTest.this.dataBroker;
         }
 
         @Override

diff --git a/data-change-counter/src/test/java/org/opendaylight/protocol/data/change/counter/TopologyDataChangeCounterTest.java b/data-change-counter/src/test/java/org/opendaylight/protocol/data/change/counter/TopologyDataChangeCounterTest.java
index 4f3219d4935c2751cf4167593ea4a10be082df9d..828b953a63ec13fda9bdb1310244d9cd43293305 100755 (executable)
--- a/data-change-counter/src/test/java/org/opendaylight/protocol/data/change/counter/TopologyDataChangeCounterTest.java
+++ b/data-change-counter/src/test/java/org/opendaylight/protocol/data/change/counter/TopologyDataChangeCounterTest.java
@@ -35,7 +35,7 @@ public class TopologyDataChangeCounterTest extends AbstractDataBrokerTest {
         assertTrue(count.isPresent());
         assertEquals(0, count.get().longValue());
 
-        counter.onDataChanged(null);
+        counter.onDataTreeChanged(null);
         final Optional<Long> countAfterDataChange = getCount(COUNTER_ID1);
         assertTrue(countAfterDataChange.isPresent());
         assertEquals(1, countAfterDataChange.get().longValue());
@@ -57,7 +57,7 @@ public class TopologyDataChangeCounterTest extends AbstractDataBrokerTest {
         assertTrue(count2.isPresent());
         assertEquals(0, count2.get().longValue());
 
-        counter1.onDataChanged(null);
+        counter1.onDataTreeChanged(null);
         final Optional<Long> countAfterDataChange1 = getCount(COUNTER_ID1);
         assertTrue(countAfterDataChange1.isPresent());
         assertEquals(1, countAfterDataChange1.get().longValue());

diff --git a/pcep/tunnel-provider/src/main/java/org/opendaylight/bgpcep/pcep/tunnel/provider/NodeChangedListener.java b/pcep/tunnel-provider/src/main/java/org/opendaylight/bgpcep/pcep/tunnel/provider/NodeChangedListener.java
index e9c8957e98103468ee6221f81474fcd86001ceb4..83e004b88af0d5cba2a58cb427ae90f8d5151f2d 100644 (file)
--- a/pcep/tunnel-provider/src/main/java/org/opendaylight/bgpcep/pcep/tunnel/provider/NodeChangedListener.java
+++ b/pcep/tunnel-provider/src/main/java/org/opendaylight/bgpcep/pcep/tunnel/provider/NodeChangedListener.java
@@ -13,13 +13,18 @@ import com.google.common.collect.Lists;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.JdkFutureAdapters;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
@@ -66,10 +71,11 @@ import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.nt.l3.unicast.igp.topology.rev131021.igp.termination.point.attributes.igp.termination.point.attributes.termination.point.type.IpBuilder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public final class NodeChangedListener implements DataChangeListener {
+public final class NodeChangedListener implements DataTreeChangeListener<Node> {
     private static final Logger LOG = LoggerFactory.getLogger(NodeChangedListener.class);
     private final InstanceIdentifier<Topology> target;
     private final DataBroker dataProvider;
@@ -372,37 +378,31 @@ public final class NodeChangedListener implements DataChangeListener {
     }
 
     @Override
-    public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+    public void onDataTreeChanged(final Collection<DataTreeModification<Node>> changes) {
         final ReadWriteTransaction trans = this.dataProvider.newReadWriteTransaction();
 
         final Set<InstanceIdentifier<ReportedLsp>> lsps = new HashSet<>();
         final Set<InstanceIdentifier<Node>> nodes = new HashSet<>();
 
-        // Categorize reported identifiers
-        for (final InstanceIdentifier<?> i : change.getRemovedPaths()) {
-            categorizeIdentifier(i, lsps, nodes);
-        }
-        for (final InstanceIdentifier<?> i : change.getUpdatedData().keySet()) {
-            categorizeIdentifier(i, lsps, nodes);
-        }
-        for (final InstanceIdentifier<?> i : change.getCreatedData().keySet()) {
-            categorizeIdentifier(i, lsps, nodes);
-        }
+        final Map<InstanceIdentifier<?>, DataObject> original = new HashMap<>();
+        final Map<InstanceIdentifier<?>, DataObject> updated = new HashMap<>();
+        final Map<InstanceIdentifier<?>, DataObject> created = new HashMap<>();
 
-        // Get the subtrees
-        final Map<InstanceIdentifier<?>, ? extends DataObject> o = change.getOriginalData();
-        final Map<InstanceIdentifier<?>, DataObject> u = change.getUpdatedData();
-        final Map<InstanceIdentifier<?>, DataObject> c = change.getCreatedData();
+        for (final DataTreeModification<?> change : changes) {
+            final InstanceIdentifier<?> iid = change.getRootPath().getRootIdentifier();
+            final DataObjectModification<?> rootNode = change.getRootNode();
+            handleChangedNode(rootNode, iid, lsps, nodes, original, updated, created);
+        }
 
         // Now walk all nodes, check for removals/additions and cascade them to LSPs
-        for (final InstanceIdentifier<Node> i : nodes) {
-            enumerateLsps(i, (Node) o.get(i), lsps);
-            enumerateLsps(i, (Node) u.get(i), lsps);
-            enumerateLsps(i, (Node) c.get(i), lsps);
+        for (final InstanceIdentifier<Node> iid : nodes) {
+            enumerateLsps(iid, (Node) original.get(iid), lsps);
+            enumerateLsps(iid, (Node) updated.get(iid), lsps);
+            enumerateLsps(iid, (Node) created.get(iid), lsps);
         }
 
         // We now have list of all affected LSPs. Walk them create/remove them
-        updateTransaction(trans, lsps, o, u, c);
+        updateTransaction(trans, lsps, original, updated, created);
 
         Futures.addCallback(JdkFutureAdapters.listenInPoolThread(trans.submit()), new FutureCallback<Void>() {
             @Override
@@ -417,6 +417,41 @@ public final class NodeChangedListener implements DataChangeListener {
         });
     }
 
+    private void handleChangedNode(final DataObjectModification<?> changedNode, final InstanceIdentifier<?> iid,
+            final Set<InstanceIdentifier<ReportedLsp>> lsps, final Set<InstanceIdentifier<Node>> nodes,
+            final Map<InstanceIdentifier<?>, DataObject> original, final Map<InstanceIdentifier<?>, DataObject> updated,
+            final Map<InstanceIdentifier<?>, DataObject> created) {
+
+        // Categorize reported identifiers
+        categorizeIdentifier(iid, lsps, nodes);
+
+        // Get the subtrees
+        switch (changedNode.getModificationType()) {
+        case DELETE:
+            original.put(iid, changedNode.getDataBefore());
+            break;
+        case SUBTREE_MODIFIED:
+            original.put(iid, changedNode.getDataBefore());
+            updated.put(iid, changedNode.getDataAfter());
+            break;
+        case WRITE:
+            created.put(iid, changedNode.getDataAfter());
+            break;
+        default:
+            throw new IllegalArgumentException("Unhandled modification type " + changedNode.getModificationType());
+        }
+
+        for (DataObjectModification<? extends DataObject> child : changedNode.getModifiedChildren()) {
+            final List<PathArgument> pathArguments = new ArrayList<>();
+            for (PathArgument pathArgument : iid.getPathArguments()) {
+                pathArguments.add(pathArgument);
+            }
+            pathArguments.add(child.getIdentifier());
+            final InstanceIdentifier<?> childIID = InstanceIdentifier.create(pathArguments);
+            handleChangedNode(child, childIID, lsps, nodes, original, updated, created);
+        }
+    }
+
     private void updateTransaction(final ReadWriteTransaction trans, final Set<InstanceIdentifier<ReportedLsp>> lsps,
         final Map<InstanceIdentifier<?>, ? extends DataObject> old, final Map<InstanceIdentifier<?>, DataObject> updated,
         final Map<InstanceIdentifier<?>, DataObject> created) {

diff --git a/pcep/tunnel-provider/src/main/java/org/opendaylight/bgpcep/pcep/tunnel/provider/PCEPTunnelTopologyProvider.java b/pcep/tunnel-provider/src/main/java/org/opendaylight/bgpcep/pcep/tunnel/provider/PCEPTunnelTopologyProvider.java
index 5d7987bd0d8016fcdac97db87db0407bfff7b15e..11b434c97b2233e39127877f1daa0333f29f6001 100644 (file)
--- a/pcep/tunnel-provider/src/main/java/org/opendaylight/bgpcep/pcep/tunnel/provider/PCEPTunnelTopologyProvider.java
+++ b/pcep/tunnel-provider/src/main/java/org/opendaylight/bgpcep/pcep/tunnel/provider/PCEPTunnelTopologyProvider.java
@@ -11,8 +11,7 @@ import com.google.common.base.Preconditions;
 import org.opendaylight.bgpcep.topology.DefaultTopologyReference;
 import org.opendaylight.bgpcep.topology.TopologyReference;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
@@ -23,10 +22,10 @@ import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 public final class PCEPTunnelTopologyProvider implements AutoCloseable {
-    private final ListenerRegistration<DataChangeListener> reg;
+    private final ListenerRegistration<NodeChangedListener> reg;
     private final TopologyReference ref;
 
-    private PCEPTunnelTopologyProvider(final InstanceIdentifier<Topology> dst, final ListenerRegistration<DataChangeListener> reg) {
+    private PCEPTunnelTopologyProvider(final InstanceIdentifier<Topology> dst, final ListenerRegistration<NodeChangedListener> reg) {
         this.ref = new DefaultTopologyReference(dst);
         this.reg = Preconditions.checkNotNull(reg);
     }
@@ -35,10 +34,10 @@ public final class PCEPTunnelTopologyProvider implements AutoCloseable {
             final InstanceIdentifier<Topology> sourceTopology, final TopologyId targetTopology) {
         final InstanceIdentifier<Topology> dst = InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class,
                 new TopologyKey(targetTopology)).build();
-        final NodeChangedListener ncl = new NodeChangedListener(dataProvider, sourceTopology.firstKeyOf(Topology.class, TopologyKey.class).getTopologyId(), dst);
+        final NodeChangedListener ncl = new NodeChangedListener(dataProvider, sourceTopology.firstKeyOf(Topology.class).getTopologyId(), dst);
 
         final InstanceIdentifier<Node> src = sourceTopology.child(Node.class);
-        final ListenerRegistration<DataChangeListener> reg = dataProvider.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, src, ncl, DataChangeScope.SUBTREE);
+        final ListenerRegistration<NodeChangedListener> reg = dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, src), ncl);
 
         return new PCEPTunnelTopologyProvider(dst, reg);
     }

diff --git a/pcep/tunnel-provider/src/test/java/org/opendaylight/bgpcep/pcep/tunnel/provider/NodeChangedListenerTest.java b/pcep/tunnel-provider/src/test/java/org/opendaylight/bgpcep/pcep/tunnel/provider/NodeChangedListenerTest.java
index d8a02f35b858ba495f1704185f1795ab808a9b5a..9aa15a120fd05870d025370640eea6312803e9f6 100644 (file)
--- a/pcep/tunnel-provider/src/test/java/org/opendaylight/bgpcep/pcep/tunnel/provider/NodeChangedListenerTest.java
+++ b/pcep/tunnel-provider/src/test/java/org/opendaylight/bgpcep/pcep/tunnel/provider/NodeChangedListenerTest.java
@@ -14,11 +14,10 @@ import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
 import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
@@ -78,7 +77,7 @@ public class NodeChangedListenerTest extends AbstractDataBrokerTest {
     private static final InstanceIdentifier<Topology> PCEP_TOPO_IID = InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(PCEP_TOPOLOGY_ID)).build();
     private static final InstanceIdentifier<Topology> TUNNEL_TOPO_IID = InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(TUNNEL_TOPOLOGY_ID)).build();
 
-    private ListenerRegistration<DataChangeListener> listenerRegistration;
+    private ListenerRegistration<NodeChangedListener> listenerRegistration;
 
     @Before
     public void setUp() throws TransactionCommitFailedException {
@@ -87,7 +86,7 @@ public class NodeChangedListenerTest extends AbstractDataBrokerTest {
         wTx.put(LogicalDatastoreType.OPERATIONAL, TUNNEL_TOPO_IID, new TopologyBuilder().setKey(new TopologyKey(TUNNEL_TOPOLOGY_ID)).setTopologyId(TUNNEL_TOPOLOGY_ID).build(), true);
         wTx.submit().checkedGet();
         final NodeChangedListener nodeListener = new NodeChangedListener(getDataBroker(), PCEP_TOPOLOGY_ID, TUNNEL_TOPO_IID);
-        this.listenerRegistration = getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, PCEP_TOPO_IID.child(Node.class), nodeListener, DataChangeScope.SUBTREE);
+        this.listenerRegistration = getDataBroker().registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, PCEP_TOPO_IID.child(Node.class)), nodeListener);
     }
 
     @Test