//resultVehicle = updateTableFeatures(nodeIdent, configTree);
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
//final ListenableFuture<RpcResult<Void>> singleVoidUpdateResult = Futures.transform(
// Futures.asList Arrays.asList(input, output),
// ReconcileUtil.<UpdateFlowOutput>createRpcResultCondenser("TODO"));
- }
+ // }
return addMissingGroups(nodeId, nodeIdent, diffInput.getGroupsToAddOrUpdate(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "addMissingGroups"),
MoreExecutors.directExecutor());
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return addMissingMeters(nodeId, nodeIdent, diffInput.getMetersToAddOrUpdate(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "addMissingMeters"),
MoreExecutors.directExecutor());
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return addMissingFlows(nodeId, nodeIdent, diffInput.getFlowsToAddOrUpdate(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "addMissingFlows"),
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return removeRedundantFlows(nodeId, nodeIdent, diffInput.getFlowsToRemove(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "removeRedundantFlows"),
MoreExecutors.directExecutor());
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return removeRedundantMeters(nodeId, nodeIdent, diffInput.getMetersToRemove(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "removeRedundantMeters"),
MoreExecutors.directExecutor());
resultVehicle = Futures.transformAsync(resultVehicle, input -> {
- if (!input.isSuccessful()) {
+ // if (!input.isSuccessful()) {
//TODO chain errors but not skip processing on first error return Futures.immediateFuture(input);
- }
+ // }
return removeRedundantGroups(nodeId, nodeIdent, diffInput.getGroupsToRemove(), counters);
}, MoreExecutors.directExecutor());
Futures.addCallback(resultVehicle, FxChainUtil.logResultCallback(nodeId, "removeRedundantGroups"),
package org.opendaylight.openflowplugin.applications.lldpspeaker;
+import static org.opendaylight.infrautils.utils.concurrent.LoggingFutures.addErrorLogging;
+
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.security.NoSuchAlgorithmException;
if (deviceOwnershipService.isEntityOwned(nodeId.getValue())) {
LOG.debug("Node is owned by this controller, sending LLDP packet through port {}",
nodeConnectorId.getValue());
- packetProcessingService.transmitPacket(nodeConnectorMap.get(ncIID));
+ addErrorLogging(packetProcessingService.transmitPacket(nodeConnectorMap.get(ncIID)), LOG,
+ "transmitPacket() failed");
} else {
LOG.debug("Node {} is not owned by this controller, so skip sending LLDP packet on port {}",
nodeId.getValue(), nodeConnectorId.getValue());