Bug 5578 Improve frsync (barriers)

 - edit batch futures chaining to wait for barrier
   only when it is necessary/planned

Change-Id: I29f18939682c0344e2a23925f6643c9b43463ffe
Signed-off-by: Andrej Leitner <anleitne@cisco.com>

diff --git a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/SalFlatBatchServiceImpl.java b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/SalFlatBatchServiceImpl.java
index 56989de6993d4dff6dea6421e5cb90c114fe50da..d700c9a8f7180fea26c3c6fc13c2f98523717bb3 100644 (file)
--- a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/SalFlatBatchServiceImpl.java
+++ b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/SalFlatBatchServiceImpl.java
@@ -17,6 +17,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Future;
 import org.opendaylight.openflowplugin.impl.services.batch.BatchPlanStep;
+import org.opendaylight.openflowplugin.impl.services.batch.BatchStepJob;
 import org.opendaylight.openflowplugin.impl.services.batch.FlatBatchFlowAdapters;
 import org.opendaylight.openflowplugin.impl.services.batch.FlatBatchGroupAdapters;
 import org.opendaylight.openflowplugin.impl.services.batch.FlatBatchMeterAdapters;
@@ -26,6 +27,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev16032
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.SalFlatBatchService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.BatchFailure;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchOutput;
@@ -49,6 +51,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.Re
 import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.SalMetersBatchService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.UpdateMetersBatchInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.UpdateMetersBatchOutput;
+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;
@@ -74,108 +77,147 @@ public class SalFlatBatchServiceImpl implements SalFlatBatchService {
 
     @Override
     public Future<RpcResult<ProcessFlatBatchOutput>> processFlatBatch(final ProcessFlatBatchInput input) {
-        LOG.trace("processing flat batch @ {} : {}", PathUtil.extractNodeId(input.getNode()), input.getBatch().size());
-
+        LOG.trace("processing flat batch @ {} : {}", PathUtil.extractNodeId(input.getNode()).getValue(), input.getBatch().size());
         // create plan
         final List<BatchPlanStep> batchPlan = FlatBatchUtil.assembleBatchPlan(input.getBatch());
         // add barriers where needed
         FlatBatchUtil.markBarriersWhereNeeded(batchPlan);
         // prepare chain elements
-        final List<AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>>> batchChainElements =
-                prepareBatchChain(batchPlan, input.getNode(), input.isExitOnFirstError());
+        final List<BatchStepJob> batchChainElements = prepareBatchChain(batchPlan, input.getNode(), input.isExitOnFirstError());
         // execute plan with barriers and collect outputs chain correspondingly, collect results
         return executeBatchPlan(batchChainElements);
     }
 
     @VisibleForTesting
-    Future<RpcResult<ProcessFlatBatchOutput>> executeBatchPlan(final List<AsyncFunction<RpcResult<ProcessFlatBatchOutput>,
-            RpcResult<ProcessFlatBatchOutput>>> batchChainElements) {
+    Future<RpcResult<ProcessFlatBatchOutput>> executeBatchPlan(final List<BatchStepJob> batchJobsChain) {
+        BatchStepJob batchJob;
+        final List<ListenableFuture<RpcResult<ProcessFlatBatchOutput>>> firedJobs = new ArrayList<>();
         ListenableFuture<RpcResult<ProcessFlatBatchOutput>> chainSummaryResult =
-                RpcResultBuilder.success(new ProcessFlatBatchOutputBuilder().build()).buildFuture();
-
-        for (AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> chainElement : batchChainElements) {
-            chainSummaryResult = Futures.transform(chainSummaryResult, chainElement);
+            RpcResultBuilder.<ProcessFlatBatchOutput>success()
+                            .withRpcErrors(new ArrayList<>())
+                            .withResult(new ProcessFlatBatchOutputBuilder().setBatchFailure(new ArrayList<>()).build())
+                            .buildFuture();
+
+        for (int i = 0; i < batchJobsChain.size(); i++)  {
+            batchJob = batchJobsChain.get(i);
+            // wire actual job with chain
+            firedJobs.add(Futures.transform(chainSummaryResult, batchJob.getStepFunction()));
+            // if barrier after actual job is needed or it is the last job -> merge fired job results with chain result
+            if ((batchJob.getPlanStep().isBarrierAfter()) || (i == batchJobsChain.size()-1)) {
+                firedJobs.add(0, chainSummaryResult);
+                chainSummaryResult = mergeJobsResultsFutures(firedJobs);
+                firedJobs.clear();
+            }
         }
-
         return chainSummaryResult;
     }
 
-    @VisibleForTesting
-    List<AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>>> prepareBatchChain(
-            final List<BatchPlanStep> batchPlan,
-            final NodeRef node,
-            final boolean exitOnFirstError) {
+    private static ListenableFuture<RpcResult<ProcessFlatBatchOutput>> mergeJobsResultsFutures(
+            final List<ListenableFuture<RpcResult<ProcessFlatBatchOutput>>> firedJobs) {
+
+        ListenableFuture<List<RpcResult<ProcessFlatBatchOutput>>> jobs = Futures.successfulAsList(firedJobs);
+
+        return Futures.transform(jobs, new AsyncFunction<List<RpcResult<ProcessFlatBatchOutput>>, RpcResult<ProcessFlatBatchOutput>>() {
+            @Override
+            public ListenableFuture<RpcResult<ProcessFlatBatchOutput>> apply(List<RpcResult<ProcessFlatBatchOutput>> jobsResults) {
+                boolean isSuccessful = true;
+                List<RpcError> rpcErrors = new ArrayList<>();
+                List<BatchFailure> batchFailures = new ArrayList<>();
 
+                for (RpcResult<ProcessFlatBatchOutput> jobResult : jobsResults) {
+                    if (jobResult != null) {
+                        isSuccessful = (isSuccessful && jobResult.isSuccessful());
+                        rpcErrors.addAll(jobResult.getErrors());
+                        batchFailures.addAll(jobResult.getResult().getBatchFailure());
+                    }
+                }
+
+                return RpcResultBuilder.<ProcessFlatBatchOutput>status(isSuccessful)
+                        .withRpcErrors(rpcErrors)
+                        .withResult(new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures).build())
+                        .buildFuture();
+            }
+        });
+    }
+
+    @VisibleForTesting
+    List<BatchStepJob> prepareBatchChain(final List<BatchPlanStep> batchPlan, final NodeRef node, final boolean exitOnFirstError) {
         // create batch API calls based on plan steps
-        final List<AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>>> chainJobs = new ArrayList<>();
+        final List<BatchStepJob> chainJobs = new ArrayList<>();
         int stepOffset = 0;
         for (final BatchPlanStep planStep : batchPlan) {
             final int currentOffset = stepOffset;
-            chainJobs.add(new AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>>() {
+            chainJobs.add(new BatchStepJob(planStep, new AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>>() {
                 @Override
                 public ListenableFuture<RpcResult<ProcessFlatBatchOutput>> apply(final RpcResult<ProcessFlatBatchOutput> chainInput) {
                     if (exitOnFirstError && !chainInput.isSuccessful()) {
                         LOG.debug("error on flat batch chain occurred -> skipping step {}", planStep.getStepType());
-                        return Futures.immediateFuture(chainInput);
+                        return RpcResultBuilder.<ProcessFlatBatchOutput>status(false)
+                                               .withRpcErrors(new ArrayList<>())
+                                               .withResult(new ProcessFlatBatchOutputBuilder().setBatchFailure(new ArrayList<>()).build())
+                                               .buildFuture();
                     }
 
                     LOG.trace("batch progressing on step type {}", planStep.getStepType());
-                    LOG.trace("batch progressing previous step result: {}", chainInput.isSuccessful());
+                    LOG.trace("batch progressing previous steps result: {}", chainInput.isSuccessful());
 
                     final ListenableFuture<RpcResult<ProcessFlatBatchOutput>> chainOutput;
                     switch (planStep.getStepType()) {
                         case FLOW_ADD:
                             final AddFlowsBatchInput addFlowsBatchInput = FlatBatchFlowAdapters.adaptFlatBatchAddFlow(planStep, node);
                             final Future<RpcResult<AddFlowsBatchOutput>> resultAddFlowFuture = salFlowService.addFlowsBatch(addFlowsBatchInput);
-                            chainOutput = FlatBatchFlowAdapters.adaptFlowBatchFutureForChain(chainInput, resultAddFlowFuture, currentOffset);
+                            chainOutput = FlatBatchFlowAdapters.adaptFlowBatchFutureForChain(resultAddFlowFuture, currentOffset);
                             break;
                         case FLOW_REMOVE:
                             final RemoveFlowsBatchInput removeFlowsBatchInput = FlatBatchFlowAdapters.adaptFlatBatchRemoveFlow(planStep, node);
                             final Future<RpcResult<RemoveFlowsBatchOutput>> resultRemoveFlowFuture = salFlowService.removeFlowsBatch(removeFlowsBatchInput);
-                            chainOutput = FlatBatchFlowAdapters.adaptFlowBatchFutureForChain(chainInput, resultRemoveFlowFuture, currentOffset);
+                            chainOutput = FlatBatchFlowAdapters.adaptFlowBatchFutureForChain(resultRemoveFlowFuture, currentOffset);
                             break;
                         case FLOW_UPDATE:
                             final UpdateFlowsBatchInput updateFlowsBatchInput = FlatBatchFlowAdapters.adaptFlatBatchUpdateFlow(planStep, node);
                             final Future<RpcResult<UpdateFlowsBatchOutput>> resultUpdateFlowFuture = salFlowService.updateFlowsBatch(updateFlowsBatchInput);
-                            chainOutput = FlatBatchFlowAdapters.adaptFlowBatchFutureForChain(chainInput, resultUpdateFlowFuture, currentOffset);
+                            chainOutput = FlatBatchFlowAdapters.adaptFlowBatchFutureForChain(resultUpdateFlowFuture, currentOffset);
                             break;
                         case GROUP_ADD:
                             final AddGroupsBatchInput addGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchAddGroup(planStep, node);
                             final Future<RpcResult<AddGroupsBatchOutput>> resultAddGroupFuture = salGroupService.addGroupsBatch(addGroupsBatchInput);
-                            chainOutput = FlatBatchGroupAdapters.adaptGroupBatchFutureForChain(chainInput, resultAddGroupFuture, currentOffset);
+                            chainOutput = FlatBatchGroupAdapters.adaptGroupBatchFutureForChain(resultAddGroupFuture, currentOffset);
                             break;
                         case GROUP_REMOVE:
                             final RemoveGroupsBatchInput removeGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchRemoveGroup(planStep, node);
                             final Future<RpcResult<RemoveGroupsBatchOutput>> resultRemoveGroupFuture = salGroupService.removeGroupsBatch(removeGroupsBatchInput);
-                            chainOutput = FlatBatchGroupAdapters.adaptGroupBatchFutureForChain(chainInput, resultRemoveGroupFuture, currentOffset);
+                            chainOutput = FlatBatchGroupAdapters.adaptGroupBatchFutureForChain(resultRemoveGroupFuture, currentOffset);
                             break;
                         case GROUP_UPDATE:
                             final UpdateGroupsBatchInput updateGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchUpdateGroup(planStep, node);
                             final Future<RpcResult<UpdateGroupsBatchOutput>> resultUpdateGroupFuture = salGroupService.updateGroupsBatch(updateGroupsBatchInput);
-                            chainOutput = FlatBatchGroupAdapters.adaptGroupBatchFutureForChain(chainInput, resultUpdateGroupFuture, currentOffset);
+                            chainOutput = FlatBatchGroupAdapters.adaptGroupBatchFutureForChain(resultUpdateGroupFuture, currentOffset);
                             break;
                         case METER_ADD:
                             final AddMetersBatchInput addMetersBatchInput = FlatBatchMeterAdapters.adaptFlatBatchAddMeter(planStep, node);
                             final Future<RpcResult<AddMetersBatchOutput>> resultAddMeterFuture = salMeterService.addMetersBatch(addMetersBatchInput);
-                            chainOutput = FlatBatchMeterAdapters.adaptMeterBatchFutureForChain(chainInput, resultAddMeterFuture, currentOffset);
+                            chainOutput = FlatBatchMeterAdapters.adaptMeterBatchFutureForChain(resultAddMeterFuture, currentOffset);
                             break;
                         case METER_REMOVE:
                             final RemoveMetersBatchInput removeMetersBatchInput = FlatBatchMeterAdapters.adaptFlatBatchRemoveMeter(planStep, node);
                             final Future<RpcResult<RemoveMetersBatchOutput>> resultRemoveMeterFuture = salMeterService.removeMetersBatch(removeMetersBatchInput);
-                            chainOutput = FlatBatchMeterAdapters.adaptMeterBatchFutureForChain(chainInput, resultRemoveMeterFuture, currentOffset);
+                            chainOutput = FlatBatchMeterAdapters.adaptMeterBatchFutureForChain(resultRemoveMeterFuture, currentOffset);
                             break;
                         case METER_UPDATE:
                             final UpdateMetersBatchInput updateMetersBatchInput = FlatBatchMeterAdapters.adaptFlatBatchUpdateMeter(planStep, node);
                             final Future<RpcResult<UpdateMetersBatchOutput>> resultUpdateMeterFuture = salMeterService.updateMetersBatch(updateMetersBatchInput);
-                            chainOutput = FlatBatchMeterAdapters.adaptMeterBatchFutureForChain(chainInput, resultUpdateMeterFuture, currentOffset);
+                            chainOutput = FlatBatchMeterAdapters.adaptMeterBatchFutureForChain(resultUpdateMeterFuture, currentOffset);
                             break;
                         default:
                             LOG.warn("Unsupported plan-step type occurred: {} -> OMITTING", planStep.getStepType());
-                            chainOutput = Futures.immediateFuture(chainInput);
+                            chainOutput = RpcResultBuilder.<ProcessFlatBatchOutput>status(true)
+                                                          .withRpcErrors(new ArrayList<>())
+                                                          .withResult(new ProcessFlatBatchOutputBuilder().setBatchFailure(new ArrayList<>()).build())
+                                                          .buildFuture();
                     }
                     return chainOutput;
                 }
-            });
+            }));
             stepOffset += planStep.getTaskBag().size();
         }
 

diff --git a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/BatchStepJob.java b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/BatchStepJob.java
new file mode 100644 (file)
index 0000000..0449c17
--- /dev/null
+++ b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/BatchStepJob.java
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * 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.services.batch;
+
+import com.google.common.util.concurrent.AsyncFunction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+
+/**
+ * Wrapper for batch step jobs.
+ */
+public class BatchStepJob {
+
+    private final BatchPlanStep planStep;
+    private final AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> stepFunction;
+
+    public BatchStepJob(final BatchPlanStep planStep, final AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> stepFunction) {
+        this.planStep = planStep;
+        this.stepFunction = stepFunction;
+    }
+
+    public BatchPlanStep getPlanStep() {
+        return planStep;
+    }
+
+    public AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> getStepFunction() {
+        return stepFunction;
+    }
+
+
+}

diff --git a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchFlowAdapters.java b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchFlowAdapters.java
index e110703a33a5e66ee475552925182b70752619de..a2d93b9ef324617eab81a1845b2e4dacc3471457 100644 (file)
--- a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchFlowAdapters.java
+++ b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchFlowAdapters.java
@@ -17,7 +17,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Future;
 import javax.annotation.Nullable;
-import org.opendaylight.openflowplugin.impl.util.FlatBatchUtil;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.flow._case.FlatBatchAddFlow;
@@ -117,30 +116,22 @@ public class FlatBatchFlowAdapters {
     }
 
     /**
-     * @param chainInput here all partial results are collected (values + errors)
      * @param stepOffset offset of current batch plan step
      * @return next chained result incorporating results of this step's batch
      */
     @VisibleForTesting
     static <T extends BatchFlowOutputListGrouping> Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>
-    createBatchFlowChainingFunction(final RpcResult<ProcessFlatBatchOutput> chainInput,
-                                    final int stepOffset) {
+    createBatchFlowChainingFunction(final int stepOffset) {
         return new Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>() {
             @Nullable
             @Override
             public RpcResult<ProcessFlatBatchOutput> apply(@Nullable final RpcResult<T> input) {
-                // create rpcResult builder honoring both success/failure of current input and chained input + join errors
-                final RpcResultBuilder<ProcessFlatBatchOutput> output = FlatBatchUtil.mergeRpcResults(chainInput, input);
-                // convert values and add to chain values
-                final ProcessFlatBatchOutputBuilder outputBuilder = new ProcessFlatBatchOutputBuilder(chainInput.getResult());
-                final List<BatchFailure> batchFailures = wrapBatchFlowFailuresForFlat(input, stepOffset);
-                // join values
-                if (outputBuilder.getBatchFailure() == null) {
-                    outputBuilder.setBatchFailure(new ArrayList<BatchFailure>(batchFailures.size()));
-                }
-                outputBuilder.getBatchFailure().addAll(batchFailures);
-
-                return output.withResult(outputBuilder.build()).build();
+                List<BatchFailure> batchFailures = wrapBatchFlowFailuresForFlat(input, stepOffset);
+                ProcessFlatBatchOutputBuilder outputBuilder = new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
+                return RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
+                                       .withRpcErrors(input.getErrors())
+                                       .withResult(outputBuilder.build())
+                                       .build();
             }
         };
     }
@@ -163,19 +154,17 @@ public class FlatBatchFlowAdapters {
     }
 
     /**
-     * shortcut for {@link #createBatchFlowChainingFunction(RpcResult, int)} with conversion {@link ListenableFuture}
+     * shortcut for {@link #createBatchFlowChainingFunction(int)} with conversion {@link ListenableFuture}
      *
      * @param <T>                    exact type of batch flow output
-     * @param chainInput             here all partial results are collected (values + errors)
      * @param resultUpdateFlowFuture batch flow rpc-result (add/remove/update)
      * @param currentOffset          offset of current batch plan step with respect to entire chain of steps
      * @return next chained result incorporating results of this step's batch
      */
     public static <T extends BatchFlowOutputListGrouping> ListenableFuture<RpcResult<ProcessFlatBatchOutput>>
-    adaptFlowBatchFutureForChain(final RpcResult<ProcessFlatBatchOutput> chainInput,
-                                 final Future<RpcResult<T>> resultUpdateFlowFuture,
+    adaptFlowBatchFutureForChain(final Future<RpcResult<T>> resultUpdateFlowFuture,
                                  final int currentOffset) {
         return Futures.transform(JdkFutureAdapters.listenInPoolThread(resultUpdateFlowFuture),
-                FlatBatchFlowAdapters.<T>createBatchFlowChainingFunction(chainInput, currentOffset));
+                FlatBatchFlowAdapters.<T>createBatchFlowChainingFunction(currentOffset));
     }
 }

diff --git a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdapters.java b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdapters.java
index 0ea8a07f91cc084d5fe8102f6113823ebac42e43..bad00a2c80f738485d096d7de787e18b08c20450 100644 (file)
--- a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdapters.java
+++ b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdapters.java
@@ -17,7 +17,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Future;
 import javax.annotation.Nullable;
-import org.opendaylight.openflowplugin.impl.util.FlatBatchUtil;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.group._case.FlatBatchAddGroup;
@@ -116,30 +115,22 @@ public class FlatBatchGroupAdapters {
     }
 
     /**
-     * @param chainInput here all partial results are collected (values + errors)
      * @param stepOffset offset of current batch plan step
      * @return next chained result incorporating results of this step's batch
      */
     @VisibleForTesting
     static <T extends BatchGroupOutputListGrouping> Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>
-    createBatchGroupChainingFunction(final RpcResult<ProcessFlatBatchOutput> chainInput,
-                                     final int stepOffset) {
+    createBatchGroupChainingFunction(final int stepOffset) {
         return new Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>() {
             @Nullable
             @Override
             public RpcResult<ProcessFlatBatchOutput> apply(@Nullable final RpcResult<T> input) {
-                // create rpcResult builder honoring both success/failure of current input and chained input + join errors
-                final RpcResultBuilder<ProcessFlatBatchOutput> output = FlatBatchUtil.mergeRpcResults(chainInput, input);
-                // convert values and add to chain values
-                final ProcessFlatBatchOutputBuilder outputBuilder = new ProcessFlatBatchOutputBuilder(chainInput.getResult());
-                final List<BatchFailure> batchFailures = wrapBatchGroupFailuresForFlat(input, stepOffset);
-                // join values
-                if (outputBuilder.getBatchFailure() == null) {
-                    outputBuilder.setBatchFailure(new ArrayList<BatchFailure>(batchFailures.size()));
-                }
-                outputBuilder.getBatchFailure().addAll(batchFailures);
-
-                return output.withResult(outputBuilder.build()).build();
+                List<BatchFailure> batchFailures = wrapBatchGroupFailuresForFlat(input, stepOffset);
+                ProcessFlatBatchOutputBuilder outputBuilder = new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
+                return RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
+                                       .withRpcErrors(input.getErrors())
+                                       .withResult(outputBuilder.build())
+                                       .build();
             }
         };
     }
@@ -162,19 +153,17 @@ public class FlatBatchGroupAdapters {
     }
 
     /**
-     * shortcut for {@link #createBatchGroupChainingFunction(RpcResult, int)} with conversion {@link ListenableFuture}
+     * shortcut for {@link #createBatchGroupChainingFunction(int)} with conversion {@link ListenableFuture}
      *
      * @param <T>                     exact type of batch flow output
-     * @param chainInput              here all partial results are collected (values + errors)
      * @param resultUpdateGroupFuture batch group rpc-result (add/remove/update)
      * @param currentOffset           offset of current batch plan step with respect to entire chain of steps
      * @return next chained result incorporating results of this step's batch
      */
     public static <T extends BatchGroupOutputListGrouping> ListenableFuture<RpcResult<ProcessFlatBatchOutput>>
-    adaptGroupBatchFutureForChain(final RpcResult<ProcessFlatBatchOutput> chainInput,
-                                  final Future<RpcResult<T>> resultUpdateGroupFuture,
+    adaptGroupBatchFutureForChain(final Future<RpcResult<T>> resultUpdateGroupFuture,
                                   final int currentOffset) {
         return Futures.transform(JdkFutureAdapters.listenInPoolThread(resultUpdateGroupFuture),
-                FlatBatchGroupAdapters.<T>createBatchGroupChainingFunction(chainInput, currentOffset));
+                FlatBatchGroupAdapters.<T>createBatchGroupChainingFunction(currentOffset));
     }
 }

diff --git a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchMeterAdapters.java b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchMeterAdapters.java
index e670bb1e98e7d6c12278eea0a52f9b08f26b15b4..33d6a4bad0eac5de8e3b227baea45a0c721cd29c 100644 (file)
--- a/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchMeterAdapters.java
+++ b/openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchMeterAdapters.java
@@ -17,7 +17,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Future;
 import javax.annotation.Nullable;
-import org.opendaylight.openflowplugin.impl.util.FlatBatchUtil;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.meter._case.FlatBatchAddMeter;
@@ -116,30 +115,22 @@ public class FlatBatchMeterAdapters {
     }
 
     /**
-     * @param chainInput here all partial results are collected (values + errors)
      * @param stepOffset offset of current batch plan step
      * @return next chained result incorporating results of this step's batch
      */
     @VisibleForTesting
     static <T extends BatchMeterOutputListGrouping> Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>
-    createBatchMeterChainingFunction(final RpcResult<ProcessFlatBatchOutput> chainInput,
-                                     final int stepOffset) {
+    createBatchMeterChainingFunction(final int stepOffset) {
         return new Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>() {
             @Nullable
             @Override
             public RpcResult<ProcessFlatBatchOutput> apply(@Nullable final RpcResult<T> input) {
-                // create rpcResult builder honoring both success/failure of current input and chained input + join errors
-                final RpcResultBuilder<ProcessFlatBatchOutput> output = FlatBatchUtil.mergeRpcResults(chainInput, input);
-                // convert values and add to chain values
-                final ProcessFlatBatchOutputBuilder outputBuilder = new ProcessFlatBatchOutputBuilder(chainInput.getResult());
-                final List<BatchFailure> batchFailures = wrapBatchMeterFailuresForFlat(input, stepOffset);
-                // join values
-                if (outputBuilder.getBatchFailure() == null) {
-                    outputBuilder.setBatchFailure(new ArrayList<BatchFailure>(batchFailures.size()));
-                }
-                outputBuilder.getBatchFailure().addAll(batchFailures);
-
-                return output.withResult(outputBuilder.build()).build();
+                List<BatchFailure> batchFailures = wrapBatchMeterFailuresForFlat(input, stepOffset);
+                ProcessFlatBatchOutputBuilder outputBuilder = new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
+                return RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
+                        .withRpcErrors(input.getErrors())
+                        .withResult(outputBuilder.build())
+                        .build();
             }
         };
     }
@@ -162,19 +153,17 @@ public class FlatBatchMeterAdapters {
     }
 
     /**
-     * shortcut for {@link #createBatchMeterChainingFunction(RpcResult, int)} with conversion {@link ListenableFuture}
+     * shortcut for {@link #createBatchMeterChainingFunction(int)} with conversion {@link ListenableFuture}
      *
      * @param <T>                     exact type of batch flow output
-     * @param chainInput              here all partial results are collected (values + errors)
      * @param resultUpdateMeterFuture batch group rpc-result (add/remove/update)
      * @param currentOffset           offset of current batch plan step with respect to entire chain of steps
      * @return next chained result incorporating results of this step's batch
      */
     public static <T extends BatchMeterOutputListGrouping> ListenableFuture<RpcResult<ProcessFlatBatchOutput>>
-    adaptMeterBatchFutureForChain(final RpcResult<ProcessFlatBatchOutput> chainInput,
-                                  final Future<RpcResult<T>> resultUpdateMeterFuture,
+    adaptMeterBatchFutureForChain(final Future<RpcResult<T>> resultUpdateMeterFuture,
                                   final int currentOffset) {
         return Futures.transform(JdkFutureAdapters.listenInPoolThread(resultUpdateMeterFuture),
-                FlatBatchMeterAdapters.<T>createBatchMeterChainingFunction(chainInput, currentOffset));
+                FlatBatchMeterAdapters.<T>createBatchMeterChainingFunction(currentOffset));
     }
 }

diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/SalFlatBatchServiceImplTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/SalFlatBatchServiceImplTest.java
index 51fa0691d084fd3dc40514b4dbffe64b4ff51d0f..0a5084f90b3dd7e0b160083ea5143f4fca904610 100644 (file)
--- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/SalFlatBatchServiceImplTest.java
+++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/SalFlatBatchServiceImplTest.java
@@ -28,6 +28,7 @@ import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.runners.MockitoJUnitRunner;
 import org.opendaylight.openflowplugin.impl.services.batch.BatchPlanStep;
+import org.opendaylight.openflowplugin.impl.services.batch.BatchStepJob;
 import org.opendaylight.openflowplugin.impl.services.batch.BatchStepType;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchInputBuilder;
@@ -35,7 +36,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev16032
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.Batch;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.BatchBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.FlatBatchAddFlowCase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.FlatBatchAddFlowCaseBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.FlatBatchAddGroupCaseBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.FlatBatchAddMeterCaseBuilder;
@@ -117,10 +117,6 @@ public class SalFlatBatchServiceImplTest {
     private SalGroupsBatchService salGroupsBatchService;
     @Mock
     private SalMetersBatchService salMetersBatchService;
-    @Mock
-    private AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> chainElement1;
-    @Mock
-    private AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> chainElement2;
     @Captor
     private ArgumentCaptor<AddFlowsBatchInput> addFlowsBatchInputCpt;
 
@@ -234,6 +230,8 @@ public class SalFlatBatchServiceImplTest {
         final InOrder inOrder = Mockito.inOrder(salFlowsBatchService, salGroupsBatchService, salMetersBatchService);
         inOrder.verify(salFlowsBatchService).addFlowsBatch(Matchers.<AddFlowsBatchInput>any());
         inOrder.verify(salFlowsBatchService).removeFlowsBatch(Matchers.<RemoveFlowsBatchInput>any());
+        inOrder.verify(salFlowsBatchService).updateFlowsBatch(Matchers.<UpdateFlowsBatchInput>any());
+        inOrder.verify(salGroupsBatchService).addGroupsBatch(Matchers.<AddGroupsBatchInput>any());
     }
 
     @Test
@@ -436,22 +434,33 @@ public class SalFlatBatchServiceImplTest {
 
     @Test
     public void testExecuteBatchPlan() throws Exception {
+        BatchStepJob batchStepJob1 = Mockito.mock(BatchStepJob.class);
+        BatchStepJob batchStepJob2 = Mockito.mock(BatchStepJob.class);
+        AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> function1 = Mockito.mock(AsyncFunction.class);
+        AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> function2 = Mockito.mock(AsyncFunction.class);
+        Mockito.when(batchStepJob1.getStepFunction()).thenReturn(function1);
+        Mockito.when(batchStepJob2.getStepFunction()).thenReturn(function2);
+        BatchPlanStep batchPlanStep1 = new BatchPlanStep(BatchStepType.GROUP_ADD);
+        batchPlanStep1.setBarrierAfter(true);
+        BatchPlanStep batchPlanStep2 = new BatchPlanStep(BatchStepType.FLOW_ADD);
+        batchPlanStep1.setBarrierAfter(false);
+        Mockito.when(batchStepJob1.getPlanStep()).thenReturn(batchPlanStep1);
+        Mockito.when(batchStepJob2.getPlanStep()).thenReturn(batchPlanStep2);
+
         final ListenableFuture<RpcResult<ProcessFlatBatchOutput>> succeededChainOutput =
-                RpcResultBuilder.<ProcessFlatBatchOutput>success().buildFuture();
+                RpcResultBuilder.<ProcessFlatBatchOutput>success().withResult(new ProcessFlatBatchOutputBuilder().setBatchFailure(new ArrayList<>()).build()).buildFuture();
         final ListenableFuture<RpcResult<ProcessFlatBatchOutput>> failedChainOutput =
                 RpcResultBuilder.<ProcessFlatBatchOutput>failed()
                         .withError(RpcError.ErrorType.APPLICATION, "ut-chainError")
-                        .withResult(createFlatBatchOutput(
-                                createFlowBatchFailure(0, "f1"), createFlowBatchFailure(1, "f2")))
+                        .withResult(createFlatBatchOutput(createFlowBatchFailure(0, "f1"), createFlowBatchFailure(1, "f2")))
                         .buildFuture();
 
-        Mockito.when(chainElement1.apply(Matchers.<RpcResult<ProcessFlatBatchOutput>>any()))
+        Mockito.when(batchStepJob1.getStepFunction().apply(Matchers.<RpcResult<ProcessFlatBatchOutput>>any()))
                 .thenReturn(succeededChainOutput);
-        Mockito.when(chainElement2.apply(Matchers.<RpcResult<ProcessFlatBatchOutput>>any()))
+        Mockito.when(batchStepJob2.getStepFunction().apply(Matchers.<RpcResult<ProcessFlatBatchOutput>>any()))
                 .thenReturn(failedChainOutput);
 
-        final List<AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>>> batchChainElements =
-                Lists.newArrayList(chainElement1, chainElement2);
+        final List<BatchStepJob> batchChainElements = Lists.newArrayList(batchStepJob1, batchStepJob2);
         final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture = salFlatBatchService.executeBatchPlan(batchChainElements);
 
         Assert.assertTrue(rpcResultFuture.isDone());
@@ -479,17 +488,14 @@ public class SalFlatBatchServiceImplTest {
 
     @Test
     public void testPrepareBatchPlan_success() throws Exception {
-        final FlatBatchAddFlowCase flatBatchAddFlowCase = new FlatBatchAddFlowCaseBuilder()
-                .setFlatBatchAddFlow(Collections.singletonList(new FlatBatchAddFlowBuilder()
-                        .setFlowId(new FlowId("f1"))
-                        .build()))
+        final FlatBatchAddFlow flatBatchAddFlow = new FlatBatchAddFlowBuilder()
+                .setFlowId(new FlowId("f1"))
                 .build();
-        final BatchPlanStep batchPlanStep =
-                new BatchPlanStep(BatchStepType.FLOW_ADD);
+        final BatchPlanStep batchPlanStep = new BatchPlanStep(BatchStepType.FLOW_ADD);
+        batchPlanStep.getTaskBag().addAll(Lists.newArrayList(flatBatchAddFlow, flatBatchAddFlow));
         final List<BatchPlanStep> batchPlan = Lists.newArrayList(batchPlanStep);
 
-        final List<AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>>> batchChain =
-                salFlatBatchService.prepareBatchChain(batchPlan, NODE_REF, true);
+        final List<BatchStepJob> batchChain = salFlatBatchService.prepareBatchChain(batchPlan, NODE_REF, true);
 
         Assert.assertEquals(1, batchChain.size());
 
@@ -513,16 +519,12 @@ public class SalFlatBatchServiceImplTest {
         final FlatBatchAddFlow flatBatchAddFlow = new FlatBatchAddFlowBuilder()
                 .setFlowId(new FlowId("f1"))
                 .build();
-        final BatchPlanStep batchPlanStep =
-                new BatchPlanStep(BatchStepType.FLOW_ADD);
-        batchPlanStep.getTaskBag().addAll(Lists.newArrayList(
-                flatBatchAddFlow,
-                flatBatchAddFlow));
+        final BatchPlanStep batchPlanStep = new BatchPlanStep(BatchStepType.FLOW_ADD);
+        batchPlanStep.getTaskBag().addAll(Lists.newArrayList(flatBatchAddFlow, flatBatchAddFlow));
 
         final List<BatchPlanStep> batchPlan = Lists.newArrayList(batchPlanStep, batchPlanStep);
 
-        final List<AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>>> batchChain =
-                salFlatBatchService.prepareBatchChain(batchPlan, NODE_REF, true);
+        final List<BatchStepJob> batchChain = salFlatBatchService.prepareBatchChain(batchPlan, NODE_REF, true);
 
         Assert.assertEquals(2, batchChain.size());
 
@@ -547,10 +549,10 @@ public class SalFlatBatchServiceImplTest {
         Assert.assertTrue(rpcResultFuture.isDone());
         final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
         Assert.assertFalse(rpcResult.isSuccessful());
-        Assert.assertEquals(1, rpcResult.getErrors().size());
-        Assert.assertEquals(2, rpcResult.getResult().getBatchFailure().size());
+        Assert.assertEquals(2, rpcResult.getErrors().size());
+        Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().size());
 
-        Mockito.verify(salFlowsBatchService).addFlowsBatch(addFlowsBatchInputCpt.capture());
+        Mockito.verify(salFlowsBatchService, Mockito.times(2)).addFlowsBatch(addFlowsBatchInputCpt.capture());
         Assert.assertEquals(2, addFlowsBatchInputCpt.getValue().getBatchAddFlows().size());
     }
 }
\ No newline at end of file

diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchFlowAdaptersTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchFlowAdaptersTest.java
index cb12adfb885aed2cf332dbcb0c39e1d7f6ee39a0..26e257697cc01ecb285c4d13b10ec2055fe1446e 100644 (file)
--- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchFlowAdaptersTest.java
+++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchFlowAdaptersTest.java
@@ -12,7 +12,6 @@ import com.google.common.collect.Lists;
 import org.junit.Assert;
 import org.junit.Test;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.flow._case.FlatBatchAddFlow;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.flow._case.FlatBatchAddFlowBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.remove.flow._case.FlatBatchRemoveFlow;
@@ -119,49 +118,35 @@ public class FlatBatchFlowAdaptersTest {
 
     @Test
     public void testCreateBatchFlowChainingFunction_failures() throws Exception {
-        final RpcResult<ProcessFlatBatchOutput> chainInput = RpcResultBuilder.<ProcessFlatBatchOutput>failed()
-                .withError(RpcError.ErrorType.APPLICATION, "ut-chainError")
-                .withResult(new ProcessFlatBatchOutputBuilder()
-                        .setBatchFailure(Lists.newArrayList(
-                                createChainFailure(0, "f1"),
-                                createChainFailure(1, "f2")))
-                        .build())
-                .build();
-
         final RpcResult<BatchFlowOutputListGrouping> input = RpcResultBuilder.<BatchFlowOutputListGrouping>failed()
                 .withError(RpcError.ErrorType.APPLICATION, "ut-flowError")
                 .withResult(new AddFlowsBatchOutputBuilder()
                         .setBatchFailedFlowsOutput(Lists.newArrayList(
-                                createBatchFailedFlowsOutput(0, "f3"),
-                                createBatchFailedFlowsOutput(1, "f4")
+                                createBatchFailedFlowsOutput(0, "f1"),
+                                createBatchFailedFlowsOutput(1, "f2")
                         ))
                         .build())
                 .build();
 
         final RpcResult<ProcessFlatBatchOutput> rpcResult = FlatBatchFlowAdapters
-                .createBatchFlowChainingFunction(chainInput, 2).apply(input);
+                .createBatchFlowChainingFunction(3).apply(input);
 
         Assert.assertFalse(rpcResult.isSuccessful());
-        Assert.assertEquals(2, rpcResult.getErrors().size());
-        Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().size());
-        Assert.assertEquals(0, rpcResult.getResult().getBatchFailure().get(0).getBatchOrder().intValue());
-        Assert.assertEquals(1, rpcResult.getResult().getBatchFailure().get(1).getBatchOrder().intValue());
-        Assert.assertEquals(2, rpcResult.getResult().getBatchFailure().get(2).getBatchOrder().intValue());
-        Assert.assertEquals(3, rpcResult.getResult().getBatchFailure().get(3).getBatchOrder().intValue());
-        Assert.assertEquals("f4", ((FlatBatchFailureFlowIdCase) rpcResult.getResult().getBatchFailure().get(3).getBatchItemIdChoice()).getFlowId().getValue());
+        Assert.assertEquals(1, rpcResult.getErrors().size());
+        Assert.assertEquals(2, rpcResult.getResult().getBatchFailure().size());
+        Assert.assertEquals(3, rpcResult.getResult().getBatchFailure().get(0).getBatchOrder().intValue());
+        Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().get(1).getBatchOrder().intValue());
+        Assert.assertEquals("f2", ((FlatBatchFailureFlowIdCase) rpcResult.getResult().getBatchFailure().get(1).getBatchItemIdChoice()).getFlowId().getValue());
     }
 
     @Test
     public void testCreateBatchFlowChainingFunction_successes() throws Exception {
-        final RpcResult<ProcessFlatBatchOutput> chainInput = RpcResultBuilder
-                .success(new ProcessFlatBatchOutputBuilder().build())
-                .build();
         final RpcResult<BatchFlowOutputListGrouping> input = RpcResultBuilder
                 .<BatchFlowOutputListGrouping>success(new AddFlowsBatchOutputBuilder().build())
                 .build();
 
         final RpcResult<ProcessFlatBatchOutput> rpcResult = FlatBatchFlowAdapters
-                .createBatchFlowChainingFunction(chainInput, 0).apply(input);
+                .createBatchFlowChainingFunction(0).apply(input);
 
         Assert.assertTrue(rpcResult.isSuccessful());
         Assert.assertEquals(0, rpcResult.getErrors().size());

diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdaptersTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdaptersTest.java
index 086a5304a095f372735b00dbc38843d97d885497..8e289685ee1f7cb9105f690e6fef45bac0db9233 100644 (file)
--- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdaptersTest.java
+++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchGroupAdaptersTest.java
@@ -12,7 +12,6 @@ import com.google.common.collect.Lists;
 import org.junit.Assert;
 import org.junit.Test;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.group._case.FlatBatchAddGroup;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.group._case.FlatBatchAddGroupBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.remove.group._case.FlatBatchRemoveGroup;
@@ -126,49 +125,35 @@ public class FlatBatchGroupAdaptersTest {
 
     @Test
     public void testCreateBatchGroupChainingFunction_failures() throws Exception {
-        final RpcResult<ProcessFlatBatchOutput> chainInput = RpcResultBuilder.<ProcessFlatBatchOutput>failed()
-                .withError(RpcError.ErrorType.APPLICATION, "ut-chainError")
-                .withResult(new ProcessFlatBatchOutputBuilder()
-                        .setBatchFailure(Lists.newArrayList(
-                                createChainFailure(0, 1L),
-                                createChainFailure(1, 2L)))
-                        .build())
-                .build();
-
         final RpcResult<BatchGroupOutputListGrouping> input = RpcResultBuilder.<BatchGroupOutputListGrouping>failed()
                 .withError(RpcError.ErrorType.APPLICATION, "ut-groupError")
                 .withResult(new AddGroupsBatchOutputBuilder()
                         .setBatchFailedGroupsOutput(Lists.newArrayList(
-                                createBatchFailedGroupsOutput(0, 3L),
-                                createBatchFailedGroupsOutput(1, 4L)
+                                createBatchFailedGroupsOutput(0, 1L),
+                                createBatchFailedGroupsOutput(1, 2L)
                         ))
                         .build())
                 .build();
 
         final RpcResult<ProcessFlatBatchOutput> rpcResult = FlatBatchGroupAdapters
-                .createBatchGroupChainingFunction(chainInput, 2).apply(input);
+                .createBatchGroupChainingFunction(3).apply(input);
 
         Assert.assertFalse(rpcResult.isSuccessful());
-        Assert.assertEquals(2, rpcResult.getErrors().size());
-        Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().size());
-        Assert.assertEquals(0, rpcResult.getResult().getBatchFailure().get(0).getBatchOrder().intValue());
-        Assert.assertEquals(1, rpcResult.getResult().getBatchFailure().get(1).getBatchOrder().intValue());
-        Assert.assertEquals(2, rpcResult.getResult().getBatchFailure().get(2).getBatchOrder().intValue());
-        Assert.assertEquals(3, rpcResult.getResult().getBatchFailure().get(3).getBatchOrder().intValue());
-        Assert.assertEquals(4L, ((FlatBatchFailureGroupIdCase) rpcResult.getResult().getBatchFailure().get(3).getBatchItemIdChoice()).getGroupId().getValue().longValue());
+        Assert.assertEquals(1, rpcResult.getErrors().size());
+        Assert.assertEquals(2, rpcResult.getResult().getBatchFailure().size());
+        Assert.assertEquals(3, rpcResult.getResult().getBatchFailure().get(0).getBatchOrder().intValue());
+        Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().get(1).getBatchOrder().intValue());
+        Assert.assertEquals(2L, ((FlatBatchFailureGroupIdCase) rpcResult.getResult().getBatchFailure().get(1).getBatchItemIdChoice()).getGroupId().getValue().longValue());
     }
 
     @Test
     public void testCreateBatchGroupChainingFunction_successes() throws Exception {
-        final RpcResult<ProcessFlatBatchOutput> chainInput = RpcResultBuilder
-                .success(new ProcessFlatBatchOutputBuilder().build())
-                .build();
         final RpcResult<BatchGroupOutputListGrouping> input = RpcResultBuilder
                 .<BatchGroupOutputListGrouping>success(new AddGroupsBatchOutputBuilder().build())
                 .build();
 
         final RpcResult<ProcessFlatBatchOutput> rpcResult = FlatBatchGroupAdapters
-                .createBatchGroupChainingFunction(chainInput, 0).apply(input);
+                .createBatchGroupChainingFunction(0).apply(input);
 
         Assert.assertTrue(rpcResult.isSuccessful());
         Assert.assertEquals(0, rpcResult.getErrors().size());

diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchMeterAdaptersTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchMeterAdaptersTest.java
index 1e1117235b620b7e672dfeaf404da914d7df272f..970ba6a001e4b530aa7e6de2235d9d2715354405 100644 (file)
--- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchMeterAdaptersTest.java
+++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/services/batch/FlatBatchMeterAdaptersTest.java
@@ -12,7 +12,6 @@ import com.google.common.collect.Lists;
 import org.junit.Assert;
 import org.junit.Test;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.meter._case.FlatBatchAddMeter;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.add.meter._case.FlatBatchAddMeterBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.batch.batch.choice.flat.batch.remove.meter._case.FlatBatchRemoveMeter;
@@ -126,49 +125,35 @@ public class FlatBatchMeterAdaptersTest {
 
     @Test
     public void testCreateBatchMeterChainingFunction_failures() throws Exception {
-        final RpcResult<ProcessFlatBatchOutput> chainInput = RpcResultBuilder.<ProcessFlatBatchOutput>failed()
-                .withError(RpcError.ErrorType.APPLICATION, "ut-chainError")
-                .withResult(new ProcessFlatBatchOutputBuilder()
-                        .setBatchFailure(Lists.newArrayList(
-                                createChainFailure(0, 1L),
-                                createChainFailure(1, 2L)))
-                        .build())
-                .build();
-
         final RpcResult<BatchMeterOutputListGrouping> input = RpcResultBuilder.<BatchMeterOutputListGrouping>failed()
-                .withError(RpcError.ErrorType.APPLICATION, "ut-groupError")
+                .withError(RpcError.ErrorType.APPLICATION, "ut-meterError")
                 .withResult(new AddMetersBatchOutputBuilder()
                         .setBatchFailedMetersOutput(Lists.newArrayList(
-                                createBatchFailedMetersOutput(0, 3L),
-                                createBatchFailedMetersOutput(1, 4L)
+                                createBatchFailedMetersOutput(0, 1L),
+                                createBatchFailedMetersOutput(1, 2L)
                         ))
                         .build())
                 .build();
 
         final RpcResult<ProcessFlatBatchOutput> rpcResult = FlatBatchMeterAdapters
-                .createBatchMeterChainingFunction(chainInput, 2).apply(input);
+                .createBatchMeterChainingFunction(3).apply(input);
 
         Assert.assertFalse(rpcResult.isSuccessful());
-        Assert.assertEquals(2, rpcResult.getErrors().size());
-        Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().size());
-        Assert.assertEquals(0, rpcResult.getResult().getBatchFailure().get(0).getBatchOrder().intValue());
-        Assert.assertEquals(1, rpcResult.getResult().getBatchFailure().get(1).getBatchOrder().intValue());
-        Assert.assertEquals(2, rpcResult.getResult().getBatchFailure().get(2).getBatchOrder().intValue());
-        Assert.assertEquals(3, rpcResult.getResult().getBatchFailure().get(3).getBatchOrder().intValue());
-        Assert.assertEquals(4L, ((FlatBatchFailureMeterIdCase) rpcResult.getResult().getBatchFailure().get(3).getBatchItemIdChoice()).getMeterId().getValue().longValue());
+        Assert.assertEquals(1, rpcResult.getErrors().size());
+        Assert.assertEquals(2, rpcResult.getResult().getBatchFailure().size());
+        Assert.assertEquals(3, rpcResult.getResult().getBatchFailure().get(0).getBatchOrder().intValue());
+        Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().get(1).getBatchOrder().intValue());
+        Assert.assertEquals(2L, ((FlatBatchFailureMeterIdCase) rpcResult.getResult().getBatchFailure().get(1).getBatchItemIdChoice()).getMeterId().getValue().longValue());
     }
 
     @Test
     public void testCreateBatchMeterChainingFunction_successes() throws Exception {
-        final RpcResult<ProcessFlatBatchOutput> chainInput = RpcResultBuilder
-                .success(new ProcessFlatBatchOutputBuilder().build())
-                .build();
         final RpcResult<BatchMeterOutputListGrouping> input = RpcResultBuilder
                 .<BatchMeterOutputListGrouping>success(new AddMetersBatchOutputBuilder().build())
                 .build();
 
         final RpcResult<ProcessFlatBatchOutput> rpcResult = FlatBatchMeterAdapters
-                .createBatchMeterChainingFunction(chainInput, 0).apply(input);
+                .createBatchMeterChainingFunction(0).apply(input);
 
         Assert.assertTrue(rpcResult.isSuccessful());
         Assert.assertEquals(0, rpcResult.getErrors().size());