X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=openflowplugin-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fimpl%2Futil%2FFlowUtil.java;h=3c10e637adcd28f75c54200ab52b427fd7641efa;hb=dc2befb3188ea11dfd0d74d375a8d3acf3619d38;hp=a16e27a7db2b69042232e5e8e2ec2fca117800c3;hpb=5f548420a66867d4c5a671d395930d74bfe5289c;p=openflowplugin.git diff --git a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/util/FlowUtil.java b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/util/FlowUtil.java index a16e27a7db..3c10e637ad 100644 --- a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/util/FlowUtil.java +++ b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/util/FlowUtil.java @@ -5,7 +5,6 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.openflowplugin.impl.util; import com.google.common.annotations.VisibleForTesting; @@ -13,11 +12,9 @@ import com.google.common.base.Function; import com.google.common.base.Preconditions; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.Iterator; import java.util.List; -import java.util.concurrent.atomic.AtomicInteger; -import javax.annotation.Nullable; +import java.util.Map; import org.apache.commons.lang3.tuple.Pair; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId; @@ -25,6 +22,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.ta import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchOutputBuilder; @@ -38,102 +36,104 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.bat import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.batch.flow.output.list.grouping.BatchFailedFlowsOutputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.Key; +import org.opendaylight.yangtools.yang.binding.KeyAware; import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.util.BindingMap; import org.opendaylight.yangtools.yang.common.RpcError; import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.common.RpcResultBuilder; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import org.opendaylight.yangtools.yang.common.Uint16; +import org.opendaylight.yangtools.yang.common.Uint8; -/** - * Created by Martin Bobak <mbobak@cisco.com> on 8.4.2015. - */ public final class FlowUtil { - private static final String ALIEN_SYSTEM_FLOW_ID = "#UF$TABLE*"; - private static final AtomicInteger unaccountedFlowsCounter = new AtomicInteger(0); - private static final Logger LOG = LoggerFactory.getLogger(FlowUtil.class); private static final RpcResultBuilder> SUCCESSFUL_FLOW_OUTPUT_RPC_RESULT = - RpcResultBuilder.success(Collections.emptyList()); + RpcResultBuilder.success(List.of()); - /** Attach barrier response to given {@link RpcResult}<RemoveFlowsBatchOutput> */ - public static final Function, RpcResult>, RpcResult> + /** + * Attach barrier response to given {@link RpcResult}<RemoveFlowsBatchOutput>. + */ + public static final Function, + RpcResult>, + RpcResult> FLOW_REMOVE_COMPOSING_TRANSFORM = createComposingFunction(); - /** Attach barrier response to given {@link RpcResult}<AddFlowsBatchOutput> */ - public static final Function, RpcResult>, RpcResult> + /** + * Attach barrier response to given {@link RpcResult}<AddFlowsBatchOutput>. + */ + public static final Function, RpcResult>, + RpcResult> FLOW_ADD_COMPOSING_TRANSFORM = createComposingFunction(); - /** Attach barrier response to given {@link RpcResult}<UpdateFlowsBatchOutput> */ - public static final Function, RpcResult>, RpcResult> + /** + * Attach barrier response to given {@link RpcResult}<UpdateFlowsBatchOutput>. + */ + public static final Function, + RpcResult>, + RpcResult> FLOW_UPDATE_COMPOSING_TRANSFORM = createComposingFunction(); /** - * Gather errors into collection and wrap it into {@link RpcResult} and propagate all {@link RpcError} + * Gather errors into collection and wrap it into {@link RpcResult} and propagate all {@link RpcError}. */ - public static final Function>, RpcResult> FLOW_REMOVE_TRANSFORM = - new Function>, RpcResult>() { - @Nullable - @Override - public RpcResult apply(@Nullable final RpcResult> batchFlowsCumulativeResult) { - final RemoveFlowsBatchOutput batchOutput = new RemoveFlowsBatchOutputBuilder() - .setBatchFailedFlowsOutput(batchFlowsCumulativeResult.getResult()).build(); - - final RpcResultBuilder resultBld = - createCumulativeRpcResult(batchFlowsCumulativeResult, batchOutput); - return resultBld.build(); - } + public static final Function>, + RpcResult> FLOW_REMOVE_TRANSFORM = + batchFlowsCumulativeResult -> { + final RemoveFlowsBatchOutput batchOutput = new RemoveFlowsBatchOutputBuilder() + .setBatchFailedFlowsOutput(index(batchFlowsCumulativeResult.getResult())).build(); + + final RpcResultBuilder resultBld = + createCumulativeRpcResult(batchFlowsCumulativeResult, batchOutput); + return resultBld.build(); }; /** - * Gather errors into collection and wrap it into {@link RpcResult} and propagate all {@link RpcError} + * Gather errors into collection and wrap it into {@link RpcResult} and propagate all {@link RpcError}. */ - public static final Function>, RpcResult> FLOW_ADD_TRANSFORM = - new Function>, RpcResult>() { - @Nullable - @Override - public RpcResult apply(@Nullable final RpcResult> batchFlowsCumulativeResult) { - final AddFlowsBatchOutput batchOutput = new AddFlowsBatchOutputBuilder() - .setBatchFailedFlowsOutput(batchFlowsCumulativeResult.getResult()).build(); - - final RpcResultBuilder resultBld = - createCumulativeRpcResult(batchFlowsCumulativeResult, batchOutput); - return resultBld.build(); - } + public static final Function>, + RpcResult> FLOW_ADD_TRANSFORM = + batchFlowsCumulativeResult -> { + final AddFlowsBatchOutput batchOutput = new AddFlowsBatchOutputBuilder() + .setBatchFailedFlowsOutput(index(batchFlowsCumulativeResult.getResult())).build(); + + final RpcResultBuilder resultBld = + createCumulativeRpcResult(batchFlowsCumulativeResult, batchOutput); + return resultBld.build(); }; /** - * Gather errors into collection and wrap it into {@link RpcResult} and propagate all {@link RpcError} + * Gather errors into collection and wrap it into {@link RpcResult} and propagate all {@link RpcError}. */ - public static final Function>, RpcResult> FLOW_UPDATE_TRANSFORM = - new Function>, RpcResult>() { - @Nullable - @Override - public RpcResult apply(@Nullable final RpcResult> batchFlowsCumulativeResult) { - final UpdateFlowsBatchOutput batchOutput = new UpdateFlowsBatchOutputBuilder() - .setBatchFailedFlowsOutput(batchFlowsCumulativeResult.getResult()).build(); - - final RpcResultBuilder resultBld = - createCumulativeRpcResult(batchFlowsCumulativeResult, batchOutput); - return resultBld.build(); - } + public static final Function>, + RpcResult> FLOW_UPDATE_TRANSFORM = + batchFlowsCumulativeResult -> { + final UpdateFlowsBatchOutput batchOutput = new UpdateFlowsBatchOutputBuilder() + .setBatchFailedFlowsOutput(index(batchFlowsCumulativeResult.getResult())).build(); + + final RpcResultBuilder resultBld = + createCumulativeRpcResult(batchFlowsCumulativeResult, batchOutput); + return resultBld.build(); }; private FlowUtil() { - throw new IllegalStateException("This class should not be instantiated."); + // Hidden on purpose + } + + static , V extends KeyAware> Map index(final List list) { + return list == null ? null : BindingMap.ordered(list); } /** * Wrap given list of problematic flow-ids into {@link RpcResult} of given type. * * @param batchFlowsCumulativeResult list of ids failed flows - * @param batchOutput - * @param flow operation type + * @param batchOutput flow operation type * @return batch flow operation output of given type containing list of flow-ids and corresponding success flag */ - private static - RpcResultBuilder createCumulativeRpcResult(final @Nullable RpcResult> batchFlowsCumulativeResult, - final T batchOutput) { + private static RpcResultBuilder createCumulativeRpcResult( + final RpcResult> batchFlowsCumulativeResult, + final T batchOutput) { final RpcResultBuilder resultBld; if (batchFlowsCumulativeResult.isSuccessful()) { resultBld = RpcResultBuilder.success(batchOutput); @@ -145,14 +145,6 @@ public final class FlowUtil { return resultBld; } - public static FlowId createAlienFlowId(final short tableId) { - final StringBuilder sBuilder = new StringBuilder(ALIEN_SYSTEM_FLOW_ID) - .append(tableId).append('-').append(unaccountedFlowsCounter.incrementAndGet()); - String alienId = sBuilder.toString(); - return new FlowId(alienId); - - } - /** * Factory method: create {@link Function} which attaches barrier response to given {@link RpcResult}<T> * and changes success flag if needed. @@ -164,37 +156,35 @@ public final class FlowUtil { */ @VisibleForTesting static - Function, RpcResult>, RpcResult> createComposingFunction() { - return new Function, RpcResult>, RpcResult>() { - @Nullable - @Override - public RpcResult apply(@Nullable final Pair, RpcResult> input) { - final RpcResultBuilder resultBld; - if (input.getLeft().isSuccessful() && input.getRight().isSuccessful()) { - resultBld = RpcResultBuilder.success(); - } else { - resultBld = RpcResultBuilder.failed(); - } + Function, RpcResult>, RpcResult> createComposingFunction() { + return input -> { + final RpcResultBuilder resultBld; + if (input.getLeft().isSuccessful() && input.getRight().isSuccessful()) { + resultBld = RpcResultBuilder.success(); + } else { + resultBld = RpcResultBuilder.failed(); + } - final ArrayList rpcErrors = new ArrayList<>(input.getLeft().getErrors()); - rpcErrors.addAll(input.getRight().getErrors()); - resultBld.withRpcErrors(rpcErrors); + final ArrayList rpcErrors = new ArrayList<>(input.getLeft().getErrors()); + rpcErrors.addAll(input.getRight().getErrors()); + resultBld.withRpcErrors(rpcErrors); - resultBld.withResult(input.getLeft().getResult()); + resultBld.withResult(input.getLeft().getResult()); - return resultBld.build(); - } + return resultBld.build(); }; } /** + * Build flow path flow ref. + * * @param nodePath path to {@link Node} * @param tableId path to {@link Table} under {@link Node} * @param flowId path to {@link Flow} under {@link Table} * @return instance identifier assembled for given node, table and flow */ public static FlowRef buildFlowPath(final InstanceIdentifier nodePath, - final short tableId, final FlowId flowId) { + final Uint8 tableId, final FlowId flowId) { final KeyedInstanceIdentifier flowPath = nodePath .augmentation(FlowCapableNode.class) .child(Table.class, new TableKey(tableId)) @@ -207,16 +197,24 @@ public final class FlowUtil { * Factory method: creates {@link Function} which keeps info of original inputs (passed to flow-rpc) and processes * list of all flow-rpc results. * - * @param inputBatchFlows collection of problematic flow-ids wrapped in container of given type <O> * @param result container type + * @param inputBatchFlows collection of problematic flow-ids wrapped in container of given type <O> * @return static reusable function */ public static Function>, RpcResult>> createCumulatingFunction( - final List inputBatchFlows) { - return new Function>, RpcResult>>() { - @Nullable - @Override - public RpcResult> apply(@Nullable final List> innerInput) { + final Collection inputBatchFlows) { + return new CumulatingFunction(inputBatchFlows).invoke(); + } + + private static class CumulatingFunction { + private final Collection inputBatchFlows; + + CumulatingFunction(final Collection inputBatchFlows) { + this.inputBatchFlows = inputBatchFlows; + } + + public Function>, RpcResult>> invoke() { + return (final List> innerInput) -> { final int sizeOfFutures = innerInput.size(); final int sizeOfInputBatch = inputBatchFlows.size(); Preconditions.checkArgument(sizeOfFutures == sizeOfInputBatch, @@ -234,7 +232,7 @@ public final class FlowUtil { if (!flowModOutput.isSuccessful()) { batchFlows.add(new BatchFailedFlowsOutputBuilder() .setFlowId(flowId) - .setBatchOrder(batchOrder) + .setBatchOrder(Uint16.valueOf(batchOrder)) .build()); flowErrors.addAll(flowModOutput.getErrors()); } @@ -249,7 +247,7 @@ public final class FlowUtil { resultBuilder = SUCCESSFUL_FLOW_OUTPUT_RPC_RESULT; } return resultBuilder.build(); - } - }; + }; + } } }