Merge "CHange log level from warn to debug in ProtocolSessionPromise when connection...

[controller.git] / opendaylight / md-sal / statistics-manager / src / main / java / org / opendaylight / controller / md / statistics / manager / AbstractStatsTracker.java

diff --git a/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/AbstractStatsTracker.java b/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/AbstractStatsTracker.java
index 03ed6cb1f1420edcd3c502d26fccf37a56fd3fab..c29b6a7730ced4f24374d2e4e67a650f3ed69293 100644 (file)
--- a/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/AbstractStatsTracker.java
+++ b/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/AbstractStatsTracker.java
@@ -22,19 +22,41 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.N
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import com.google.common.base.Function;
 import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.JdkFutureAdapters;
-import com.google.common.util.concurrent.ListenableFuture;
 
 abstract class AbstractStatsTracker<I, K> {
-    private static final Function<RpcResult<? extends TransactionAware>, TransactionId> FUNCTION =
-            new Function<RpcResult<? extends TransactionAware>, TransactionId>() {
+    private static final Logger logger = LoggerFactory.getLogger(AbstractStatsTracker.class);
+    private final FutureCallback<RpcResult<? extends TransactionAware>> callback =
+            new FutureCallback<RpcResult<? extends TransactionAware>>() {
         @Override
-        public TransactionId apply(RpcResult<? extends TransactionAware> input) {
-            return input.getResult().getTransactionId();
+        public void onSuccess(RpcResult<? extends TransactionAware> result) {
+            if (result.isSuccessful()) {
+                final TransactionId id = result.getResult().getTransactionId();
+                if (id == null) {
+                    final Throwable t = new UnsupportedOperationException("No protocol support");
+                    t.fillInStackTrace();
+                    onFailure(t);
+                } else {
+                    context.registerTransaction(id);
+                }
+            } else {
+                logger.debug("Statistics request failed: {}", result.getErrors());
+
+                final Throwable t = new RPCFailedException("Failed to send statistics request", result.getErrors());
+                t.fillInStackTrace();
+                onFailure(t);
+            }
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            logger.debug("Failed to send statistics request", t);
         }
     };
 
@@ -59,8 +81,12 @@ abstract class AbstractStatsTracker<I, K> {
         return context.getNodeIdentifier();
     }
 
-    protected static final <T extends TransactionAware> ListenableFuture<TransactionId> requestHelper(Future<RpcResult<T>> future) {
-        return Futures.transform(JdkFutureAdapters.listenInPoolThread(future), FUNCTION);
+    protected final <T extends TransactionAware> void requestHelper(Future<RpcResult<T>> future) {
+        Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future), callback);
+    }
+
+    protected final DataModificationTransaction startTransaction() {
+        return context.startDataModification();
     }
 
     protected abstract void cleanupSingleStat(DataModificationTransaction trans, K item);
@@ -68,7 +94,7 @@ abstract class AbstractStatsTracker<I, K> {
 
     public final synchronized void updateStats(List<I> list) {
         final Long expiryTime = System.nanoTime() + lifetimeNanos;
-        final DataModificationTransaction trans = context.startDataModification();
+        final DataModificationTransaction trans = startTransaction();
 
         for (final I item : list) {
             trackedItems.put(updateSingleStat(trans, item), expiryTime);