import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.infrautils.utils.concurrent.JdkFutures;
bundleId.getValue(), nodeId.getValue());
final ListenableFuture<RpcResult<AddBundleMessagesOutput>> resultFuture = forwardingRulesManager
.getSalBundleService().addBundleMessages(addBundleMessagesInput);
- Futures.addCallback(resultFuture, new BundleRemoveGroupCallBack(group.getGroupId().getValue(), nodeId));
+ Futures.addCallback(resultFuture, new BundleRemoveGroupCallBack(group.getGroupId().getValue(), nodeId),
+ MoreExecutors.directExecutor());
JdkFutures.addErrorLogging(resultFuture, LOG, "removeBundleGroup");
return resultFuture;
});
final ListenableFuture<RpcResult<AddBundleMessagesOutput>> resultFuture = forwardingRulesManager
.getSalBundleService().addBundleMessages(addBundleMessagesInput);
Futures.addCallback(resultFuture, new BundleUpdateGroupCallBack(originalGroup.getGroupId().getValue(),
- nodeId));
+ nodeId), MoreExecutors.directExecutor());
JdkFutures.addErrorLogging(resultFuture, LOG, "updateBundleGroup");
return resultFuture;
});
bundleId.getValue(), nodeId.getValue());
ListenableFuture<RpcResult<AddBundleMessagesOutput>> resultFuture = forwardingRulesManager
.getSalBundleService().addBundleMessages(addBundleMessagesInput);
- Futures.addCallback(resultFuture, new BundleAddGroupCallBack(groupId, nodeId));
+ Futures.addCallback(resultFuture, new BundleAddGroupCallBack(groupId, nodeId),
+ MoreExecutors.directExecutor());
return resultFuture;
});
}
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import javax.inject.Inject;
import javax.inject.Singleton;
SettableFuture<RpcResult<ReconcileNodeOutput>> rpcResult = SettableFuture.create();
ListenableFuture<Boolean> futureResult = forwardingRulesManagerImpl
.getNodeListener().reconcileConfiguration(connectedNode);
- Futures.addCallback(futureResult, new ResultCallBack(futureResult, rpcResult));
+ Futures.addCallback(futureResult, new ResultCallBack(futureResult, rpcResult),
+ MoreExecutors.directExecutor());
LOG.debug("Completing reconciliation for node: {}", input.getNodeId().toString());
return rpcResult;
}
import com.google.common.util.concurrent.AsyncFunction;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
} else {
return Futures.immediateFailedFuture(null);
}
- });
+ }, MoreExecutors.directExecutor());
};
}
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
return Futures.catching(
super.handleServiceCall(input, isComplete),
Throwable.class,
- t -> RpcResultBuilder.<O>failed().build());
+ t -> RpcResultBuilder.<O>failed().build(), MoreExecutors.directExecutor());
}
}
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
final ListenableFuture<RpcResult<List<BatchFailedGroupsOutput>>> commonResult = Futures
.transform(Futures.allAsList(resultsLot),
- GroupUtil.createCumulatingFunction(groups, batchUpdateGroups.size()));
+ GroupUtil.createCumulatingFunction(groups, batchUpdateGroups.size()),
+ MoreExecutors.directExecutor());
ListenableFuture<RpcResult<UpdateGroupsBatchOutput>> updateGroupsBulkFuture = Futures
- .transform(commonResult, GroupUtil.GROUP_UPDATE_TRANSFORM);
+ .transform(commonResult, GroupUtil.GROUP_UPDATE_TRANSFORM, MoreExecutors.directExecutor());
if (input.isBarrierAfter()) {
updateGroupsBulkFuture = BarrierUtil
final ListenableFuture<RpcResult<List<BatchFailedGroupsOutput>>> commonResult = Futures
.transform(Futures.allAsList(resultsLot),
- GroupUtil.createCumulatingFunction(input.getBatchAddGroups()));
+ GroupUtil.createCumulatingFunction(input.getBatchAddGroups()),
+ MoreExecutors.directExecutor());
ListenableFuture<RpcResult<AddGroupsBatchOutput>> addGroupsBulkFuture = Futures
- .transform(commonResult, GroupUtil.GROUP_ADD_TRANSFORM);
+ .transform(commonResult, GroupUtil.GROUP_ADD_TRANSFORM, MoreExecutors.directExecutor());
if (input.isBarrierAfter()) {
addGroupsBulkFuture = BarrierUtil.chainBarrier(addGroupsBulkFuture, input.getNode(), transactionService,
final ListenableFuture<RpcResult<List<BatchFailedGroupsOutput>>> commonResult = Futures
.transform(Futures.allAsList(resultsLot),
- GroupUtil.createCumulatingFunction(input.getBatchRemoveGroups()));
+ GroupUtil.createCumulatingFunction(input.getBatchRemoveGroups()),
+ MoreExecutors.directExecutor());
ListenableFuture<RpcResult<RemoveGroupsBatchOutput>> removeGroupsBulkFuture = Futures
- .transform(commonResult, GroupUtil.GROUP_REMOVE_TRANSFORM);
+ .transform(commonResult, GroupUtil.GROUP_REMOVE_TRANSFORM, MoreExecutors.directExecutor());
if (input.isBarrierAfter()) {
removeGroupsBulkFuture = BarrierUtil