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);
}
};
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);
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);