NETVIRT-1630 migrate to md-sal APIs

[netvirt.git] / elanmanager / impl / src / main / java / org / opendaylight / netvirt / elan / internal / ElanGroupCache.java

diff --git a/elanmanager/impl/src/main/java/org/opendaylight/netvirt/elan/internal/ElanGroupCache.java b/elanmanager/impl/src/main/java/org/opendaylight/netvirt/elan/internal/ElanGroupCache.java
index 061d8029681cf7d3f7688bc660536187c79c1077..6aa03009da7344a9f42af750a6b8106f01348202 100644 (file)
--- a/elanmanager/impl/src/main/java/org/opendaylight/netvirt/elan/internal/ElanGroupCache.java
+++ b/elanmanager/impl/src/main/java/org/opendaylight/netvirt/elan/internal/ElanGroupCache.java
@@ -8,22 +8,22 @@
 
 package org.opendaylight.netvirt.elan.internal;
 
-import com.google.common.base.Optional;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
-
+import javax.annotation.PreDestroy;
 import javax.inject.Inject;
 import javax.inject.Singleton;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.genius.datastoreutils.AsyncClusteredDataTreeChangeListenerBase;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.netvirt.elan.utils.Scheduler;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
@@ -33,33 +33,24 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 @Singleton
-public class ElanGroupCache extends AsyncClusteredDataTreeChangeListenerBase<Group, ElanGroupCache> {
+public class ElanGroupCache extends AbstractClusteredAsyncDataTreeChangeListener<Group> {
     private static final Logger LOG = LoggerFactory.getLogger(ElanGroupCache.class);
     private final DataBroker dataBroker;
     private final Scheduler scheduler;
     private final Map<InstanceIdentifier<Group>, Group> groupsById = new ConcurrentHashMap<>();
     private final Map<InstanceIdentifier<Group>, Collection<Runnable>> waitingJobs = new ConcurrentHashMap<>();
-    private volatile boolean initialized = false;
 
     @Inject
     public ElanGroupCache(final DataBroker dataBroker, final Scheduler scheduler) {
-        super(Group.class, ElanGroupCache.class);
+        super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Nodes.class)
+                .child(Node.class).augmentation(FlowCapableNode.class).child(Group.class),
+                Executors.newListeningSingleThreadExecutor("ElanGroupCache", LOG));
         this.dataBroker = dataBroker;
         this.scheduler = scheduler;
     }
 
     public synchronized void init() {
-        if (!initialized) {
-            initialized = true;
-            this.registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
-        }
-    }
-
-    @Override
-    protected InstanceIdentifier<Group> getWildCardPath() {
-        return InstanceIdentifier.builder(Nodes.class)
-                .child(Node.class).augmentation(FlowCapableNode.class)
-                .child(Group.class).build();
+        LOG.info("{} registered", getClass().getSimpleName());
     }
 
     public synchronized void addJobToWaitList(InstanceIdentifier<Group> key,
@@ -73,22 +64,17 @@ public class ElanGroupCache extends AsyncClusteredDataTreeChangeListenerBase<Gro
     }
 
     @Override
-    protected ElanGroupCache getDataTreeChangeListener() {
-        return ElanGroupCache.this;
-    }
-
-    @Override
-    protected synchronized void remove(InstanceIdentifier<Group> key, Group deleted) {
+    public synchronized void remove(InstanceIdentifier<Group> key, Group deleted) {
         groupsById.remove(key);
     }
 
     @Override
-    protected void update(InstanceIdentifier<Group> key, Group old, Group updated) {
+    public void update(InstanceIdentifier<Group> key, Group old, Group updated) {
         add(key, updated);
     }
 
     @Override
-    protected synchronized void add(InstanceIdentifier<Group> key, Group added) {
+    public synchronized void add(InstanceIdentifier<Group> key, Group added) {
         if (groupsById.containsKey(key)) {
             groupsById.put(key, added);
             return;
@@ -105,13 +91,21 @@ public class ElanGroupCache extends AsyncClusteredDataTreeChangeListenerBase<Gro
         }, ElanInterfaceManager.WAIT_TIME_FOR_SYNC_INSTALL, TimeUnit.MILLISECONDS);
     }
 
-    public Optional<Group> getGroup(InstanceIdentifier<Group> key) throws ReadFailedException {
+    public Optional<Group> getGroup(InstanceIdentifier<Group> key) throws InterruptedException, ExecutionException {
         if (groupsById.containsKey(key)) {
             return Optional.of(groupsById.get(key));
         }
-        ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
-        Optional<Group> optional = transaction.read(LogicalDatastoreType.CONFIGURATION, key).checkedGet();
+        ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
+        Optional<Group> optional = transaction.read(LogicalDatastoreType.CONFIGURATION, key).get();
         transaction.close();
         return optional;
     }
+
+    @Override
+    @PreDestroy
+    public void close() {
+        super.close();
+        Executors.shutdownAndAwaitTermination(getExecutorService());
+    }
+
 }