*/
package org.opendaylight.openflowplugin.impl.device;
-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 io.netty.util.HashedWheelTimer;
import io.netty.util.internal.ConcurrentSet;
import java.util.Optional;
public abstract class AbstractAggregateFlowMultipartService<T extends OfHeader>
extends AbstractMultipartService<GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput, T> {
- public AbstractAggregateFlowMultipartService(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
+ public AbstractAggregateFlowMultipartService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext) {
super(requestContextStack, deviceContext);
}
/**
- * Process input and return reply
+ * Process input and return reply.
* @param input input
* @return reply
*/
public abstract Future<RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>> handleAndReply(
- final GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input);
+ GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input);
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
import org.opendaylight.yangtools.yang.common.RpcResult;
-public abstract class AbstractExperimenterMultipartService<T extends OfHeader> extends AbstractMultipartService<SendExperimenterMpRequestInput, T> {
+public abstract class AbstractExperimenterMultipartService<T extends OfHeader>
+ extends AbstractMultipartService<SendExperimenterMpRequestInput, T> {
private final ExtensionConverterProvider extensionConverterProvider;
}
/**
- * Get extension converter provider
+ * Get extension converter provider.
* @return extension converter provider
*/
protected ExtensionConverterProvider getExtensionConverterProvider() {
}
/**
- * Process experimenter input and result experimenter output
+ * Process experimenter input and result experimenter output.
* @param input experimenter input
* @return experimenter output
*/
- public abstract Future<RpcResult<SendExperimenterMpRequestOutput>> handleAndReply(SendExperimenterMpRequestInput input);
-
+ public abstract Future<RpcResult<SendExperimenterMpRequestOutput>>
+ handleAndReply(SendExperimenterMpRequestInput input);
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
-public abstract class AbstractMultipartCollectorService<T extends OfHeader> extends AbstractMultipartService<MultipartType, T> {
+public abstract class AbstractMultipartCollectorService<T extends OfHeader>
+ extends AbstractMultipartService<MultipartType, T> {
- protected AbstractMultipartCollectorService(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
+ protected AbstractMultipartCollectorService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext) {
super(requestContextStack, deviceContext);
}
}
@Override
- public void onFailure(@Nonnull final Throwable t) {
+ public void onFailure(@Nonnull final Throwable throwable) {
// If we failed getting table features, at least create empty tables
if (MultipartType.OFPMPTABLEFEATURES.getClass().equals(requestType)) {
DeviceInitializationUtil.makeEmptyTables(
getDeviceContext().getPrimaryConnectionContext().getFeatures().getTables());
}
- callback.onFailure(t);
+ callback.onFailure(throwable);
}
};
}
@Override
protected OfHeader buildRequest(final Xid xid, final MultipartType input) {
- return MultipartRequestInputFactory.makeMultipartRequest(xid.getValue(), getVersion(), input, canUseSingleLayerSerialization());
+ return MultipartRequestInputFactory.makeMultipartRequest(xid.getValue(),
+ getVersion(),
+ input,
+ canUseSingleLayerSerialization());
}
}
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
+import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProvider;
import org.opendaylight.openflowplugin.impl.services.multilayer.MultiLayerFlowMultipartRequestOnTheFlyCallback;
import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerFlowMultipartRequestOnTheFlyCallback;
-import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProvider;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
}
@Override
- protected final FutureCallback<OfHeader> createCallback(final RequestContext<List<T>> context, final Class<?> requestType) {
+ protected final FutureCallback<OfHeader> createCallback(final RequestContext<List<T>> context,
+ final Class<?> requestType) {
return canUseSingleLayerSerialization()
- ? new SingleLayerFlowMultipartRequestOnTheFlyCallback<>(context, requestType, getDeviceContext(), getEventIdentifier(), statisticsWriterProvider)
- : new MultiLayerFlowMultipartRequestOnTheFlyCallback<>(context, requestType, getDeviceContext(), getEventIdentifier(), statisticsWriterProvider, convertorExecutor);
+ ? new SingleLayerFlowMultipartRequestOnTheFlyCallback<>(context,
+ requestType,
+ getDeviceContext(),
+ getEventIdentifier(),
+ statisticsWriterProvider)
+ : new MultiLayerFlowMultipartRequestOnTheFlyCallback<>(context,
+ requestType,
+ getDeviceContext(),
+ getEventIdentifier(),
+ statisticsWriterProvider,
+ convertorExecutor);
}
-
}
}
/**
- * Check if result is multipart
+ * Check if result is multipart.
* @param result result
* @return true if result is multipart
*/
- protected abstract boolean isMultipart(final OfHeader result);
+ protected abstract boolean isMultipart(OfHeader result);
/**
- * Check if result requests more multiparts
+ * Check if result requests more multiparts.
* @param result result
* @return true if result requests more multiparts
*/
- protected abstract boolean isReqMore(final T result);
+ protected abstract boolean isReqMore(T result);
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public abstract class AbstractMultipartRequestOnTheFlyCallback<T extends OfHeader> extends AbstractMultipartRequestCallback<T> {
+public abstract class AbstractMultipartRequestOnTheFlyCallback<T extends OfHeader>
+ extends AbstractMultipartRequestCallback<T> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractMultipartRequestOnTheFlyCallback.class);
private final DeviceInfo deviceInfo;
private final EventIdentifier doneEventIdentifier;
final ConvertorExecutor convertorExecutor) {
super(context, requestType, deviceContext, eventIdentifier);
deviceInfo = deviceContext.getDeviceInfo();
- doneEventIdentifier = new EventIdentifier(getMultipartType().name(), deviceContext.getDeviceInfo().getNodeId().toString());
+ doneEventIdentifier =
+ new EventIdentifier(getMultipartType().name(), deviceContext.getDeviceInfo().getNodeId().toString());
txFacade = deviceContext;
deviceRegistry = deviceContext;
this.statisticsWriterProvider = statisticsWriterProvider;
}
@Override
- @SuppressWarnings("unchecked")
+ @SuppressWarnings({"unchecked", "checkstyle:IllegalCatch"})
public void onSuccess(final OfHeader result) {
if (Objects.isNull(result)) {
LOG.warn("Response received was null.");
} catch (final Exception ex) {
LOG.warn("Unexpected exception occurred while translating response: {}.", result.getClass(), ex);
setResult(RpcResultBuilder.<List<T>>failed().withError(RpcError.ErrorType.APPLICATION,
- String.format("Unexpected exception occurred while translating response: %s. %s", result.getClass(), ex)).build());
+ String.format("Unexpected exception occurred while translating response: %s. %s",
+ result.getClass(),
+ ex)).build());
endCollecting(false);
return;
}
}
/**
- * Get tx facade
+ * Get tx facade.
* @return tx facade
*/
protected TxFacade getTxFacade() {
}
/**
- * Starts collecting of multipart data
+ * Starts collecting of multipart data.
*/
private synchronized void startCollecting() {
EventsTimeCounter.markStart(doneEventIdentifier);
instanceIdentifier,
deviceRegistry.getDeviceGroupRegistry());
break;
+ default:
+ LOG.warn("Unsupported type {}", getMultipartType());
}
}
/**
- * Ends collecting of multipart data
+ * Ends collecting of multipart data.
* @param setResult set empty success result
*/
private void endCollecting(final boolean setResult) {
case OFPMPGROUPDESC:
deviceRegistry.getDeviceGroupRegistry().processMarks();
break;
+ default:
+ LOG.warn("Unsupported type {}", getMultipartType());
}
}
/**
- * Get multipart type
+ * Get multipart type.
* @return multipart type
*/
protected abstract MultipartType getMultipartType();
-
}
private static final Function<OfHeader, Boolean> ALTERNATE_IS_COMPLETE = message ->
!(message instanceof MultipartReply) || !((MultipartReply) message).isRequestMore();
- protected AbstractMultipartService(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
+ protected AbstractMultipartService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext) {
super(requestContextStack, deviceContext);
}
}
@Override
- public final void onFailure(@Nonnull final Throwable t) {
+ public final void onFailure(@Nonnull final Throwable throwable) {
final RpcResultBuilder<T> builder;
if (null != eventIdentifier) {
EventsTimeCounter.markEnd(eventIdentifier);
}
- if (t instanceof DeviceRequestFailedException) {
- final Error err = ((DeviceRequestFailedException) t).getError();
- final String errorString = String.format("Device reported error type %s code %s", err.getTypeString(), err.getCodeString());
+ if (throwable instanceof DeviceRequestFailedException) {
+ final Error err = ((DeviceRequestFailedException) throwable).getError();
+ final String errorString = String.format("Device reported error type %s code %s",
+ err.getTypeString(),
+ err.getCodeString());
- builder = RpcResultBuilder.<T>failed().withError(RpcError.ErrorType.APPLICATION, errorString, t);
+ builder = RpcResultBuilder.<T>failed().withError(RpcError.ErrorType.APPLICATION, errorString, throwable);
spyMessage(StatisticsGroup.TO_SWITCH_SUBMIT_FAILURE);
} else {
- builder = RpcResultBuilder.<T>failed().withError(RpcError.ErrorType.APPLICATION, t.getMessage(), t);
+ builder = RpcResultBuilder.<T>failed()
+ .withError(RpcError.ErrorType.APPLICATION, throwable.getMessage(), throwable);
spyMessage(StatisticsGroup.TO_SWITCH_SUBMIT_ERROR);
}
}
if (Objects.isNull(requestContext.getXid())) {
- getMessageSpy().spyMessage(requestContext.getClass(), MessageSpy.StatisticsGroup.TO_SWITCH_RESERVATION_REJECTED);
- return RequestContextUtil.closeRequestContextWithRpcError(requestContext, "Outbound queue wasn't able to reserve XID.");
+ getMessageSpy().spyMessage(requestContext.getClass(),
+ MessageSpy.StatisticsGroup.TO_SWITCH_RESERVATION_REJECTED);
+ return RequestContextUtil
+ .closeRequestContextWithRpcError(requestContext, "Outbound queue wasn't able to reserve XID.");
}
getMessageSpy().spyMessage(requestContext.getClass(), MessageSpy.StatisticsGroup.TO_SWITCH_READY_FOR_SUBMIT);
OfHeader request = null;
try {
request = buildRequest(xid, input);
- Verify.verify(xid.getValue().equals(request.getXid()), "Expected XID %s got %s", xid.getValue(), request.getXid());
- } catch (Exception ex) {
+ Verify.verify(xid.getValue().equals(request.getXid()),
+ "Expected XID %s got %s",
+ xid.getValue(),
+ request.getXid());
+ } catch (ServiceException ex) {
LOG.error("Failed to build request for {}, forfeiting request {}", input, xid.getValue(), ex);
- RequestContextUtil.closeRequestContextWithRpcError(requestContext, "failed to build request input: " + ex.getMessage());
+ RequestContextUtil.closeRequestContextWithRpcError(requestContext,
+ "failed to build request input: " + ex.getMessage());
} finally {
- final OutboundQueue outboundQueue = getDeviceContext().getPrimaryConnectionContext().getOutboundQueueProvider();
+ final OutboundQueue outboundQueue =
+ getDeviceContext().getPrimaryConnectionContext().getOutboundQueueProvider();
if (Objects.nonNull(isComplete)) {
- outboundQueue.commitEntry(xid.getValue(), request, createCallback(requestContext, requestType), isComplete);
+ outboundQueue.commitEntry(xid.getValue(),
+ request,
+ createCallback(requestContext, requestType), isComplete);
} else {
outboundQueue.commitEntry(xid.getValue(), request, createCallback(requestContext, requestType));
}
public abstract class AbstractSilentErrorService<I, O extends DataObject>
extends AbstractSimpleService<I, O> {
- protected AbstractSilentErrorService(RequestContextStack requestContextStack, DeviceContext deviceContext, Class<O> clazz) {
+ protected AbstractSilentErrorService(RequestContextStack requestContextStack,
+ DeviceContext deviceContext,
+ Class<O> clazz) {
super(requestContextStack, deviceContext, clazz);
}
public ListenableFuture<RpcResult<O>> handleServiceCall(@Nonnull I input,
@Nullable final Function<OfHeader, Boolean> isComplete) {
return Futures.catching(
- super.handleServiceCall(input, isComplete),
- Throwable.class,
- t -> RpcResultBuilder.<O>failed().build());
+ super.handleServiceCall(input, isComplete),
+ Throwable.class,
+ t -> RpcResultBuilder.<O>failed().build());
}
-
}
public abstract class AbstractSimpleService<I, O extends DataObject> extends AbstractService<I, O> {
private final Class<O> clazz;
- protected AbstractSimpleService(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final Class<O> clazz) {
+ protected AbstractSimpleService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final Class<O> clazz) {
super(requestContextStack, deviceContext);
this.clazz = Preconditions.checkNotNull(clazz);
}
@Override
- protected final FutureCallback<OfHeader> createCallback(final RequestContext<O> context, final Class<?> requestType) {
+ protected final FutureCallback<OfHeader> createCallback(final RequestContext<O> context,
+ final Class<?> requestType) {
return SimpleRequestCallback.create(context, requestType, getMessageSpy(), clazz);
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.UpdateTableOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
-public abstract class AbstractTableMultipartService<T extends OfHeader> extends AbstractMultipartService<UpdateTableInput, T> {
+public abstract class AbstractTableMultipartService<T extends OfHeader>
+ extends AbstractMultipartService<UpdateTableInput, T> {
private final MultipartWriterProvider multipartWriterProvider;
}
/**
- * Stores table features to operational datastore
+ * Stores table features to operational datastore.
*/
- protected void storeStatistics(List<org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures> result) {
+ protected void storeStatistics(List<org.opendaylight.yang.gen.v1.urn
+ .opendaylight.table.types.rev131026.table.features.TableFeatures> result) {
multipartWriterProvider
.lookup(MultipartType.OFPMPTABLEFEATURES)
.ifPresent(writer -> {
}
/**
- * Process experimenter input and result experimenter output
+ * Process experimenter input and result experimenter output.
* @param input experimenter input
* @return experimenter output
*/
}
@Override
- protected final FutureCallback<OfHeader> createCallback(final RequestContext<Void> context, final Class<?> requestType) {
+ protected final FutureCallback<OfHeader> createCallback(final RequestContext<Void> context,
+ final Class<?> requestType) {
return new VoidRequestCallback(context, requestType, getMessageSpy());
}
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-/**
- * Created by kramesha on 8/24/15.
- */
public class RoleService extends AbstractSimpleService<RoleRequestInputBuilder, RoleRequestOutput> {
private static final Logger LOG = LoggerFactory.getLogger(RoleService.class);
private final DeviceContext deviceContext;
- public RoleService(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final Class<RoleRequestOutput> clazz) {
+ public RoleService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final Class<RoleRequestOutput> clazz) {
super(requestContextStack, deviceContext, clazz);
this.deviceContext = deviceContext;
}
roleRequestInputBuilder.setGenerationId(BigInteger.ZERO);
final SettableFuture<BigInteger> finalFuture = SettableFuture.create();
- final ListenableFuture<RpcResult<RoleRequestOutput>> genIdListenableFuture = handleServiceCall(roleRequestInputBuilder);
+ final ListenableFuture<RpcResult<RoleRequestOutput>> genIdListenableFuture =
+ handleServiceCall(roleRequestInputBuilder);
Futures.addCallback(genIdListenableFuture, new FutureCallback<RpcResult<RoleRequestOutput>>() {
@Override
public void onSuccess(final RpcResult<RoleRequestOutput> roleRequestOutputRpcResult) {
finalFuture.set(roleRequestOutput.getGenerationId());
} else {
LOG.info("roleRequestOutput is null in getGenerationIdFromDevice");
- finalFuture.setException(new RoleChangeException("Exception in getting generationId for device:" + getDeviceInfo().getNodeId().getValue()));
+ finalFuture.setException(new RoleChangeException("Exception in getting generationId for device:"
+ + getDeviceInfo().getNodeId().getValue()));
}
} else {
- LOG.error("getGenerationIdFromDevice RPC error " +
- roleRequestOutputRpcResult.getErrors().iterator().next().getInfo());
- finalFuture.setException(new RoleChangeException(ErrorUtil.errorsToString(roleRequestOutputRpcResult.getErrors())));
+ LOG.error("getGenerationIdFromDevice RPC error "
+ + roleRequestOutputRpcResult.getErrors().iterator().next().getInfo());
+ finalFuture.setException(new RoleChangeException(ErrorUtil
+ .errorsToString(roleRequestOutputRpcResult.getErrors())));
}
}
}
- public Future<RpcResult<SetRoleOutput>> submitRoleChange(final OfpRole ofpRole, final Short version, final BigInteger generationId) {
+ public Future<RpcResult<SetRoleOutput>> submitRoleChange(final OfpRole ofpRole,
+ final Short version,
+ final BigInteger generationId) {
LOG.info("submitRoleChange called for device:{}, role:{}",
getDeviceInfo().getNodeId(), ofpRole);
final RoleRequestInputBuilder roleRequestInputBuilder = new RoleRequestInputBuilder();
roleRequestInputBuilder.setVersion(version);
roleRequestInputBuilder.setGenerationId(generationId);
- final ListenableFuture<RpcResult<RoleRequestOutput>> roleListenableFuture = handleServiceCall(roleRequestInputBuilder);
+ final ListenableFuture<RpcResult<RoleRequestOutput>> roleListenableFuture =
+ handleServiceCall(roleRequestInputBuilder);
final SettableFuture<RpcResult<SetRoleOutput>> finalFuture = SettableFuture.create();
Futures.addCallback(roleListenableFuture, new FutureCallback<RpcResult<RoleRequestOutput>>() {
final Collection<RpcError> rpcErrors = roleRequestOutputRpcResult.getErrors();
if (roleRequestOutput != null) {
final SetRoleOutputBuilder setRoleOutputBuilder = new SetRoleOutputBuilder();
- setRoleOutputBuilder.setTransactionId(new TransactionId(BigInteger.valueOf(roleRequestOutput.getXid())));
- finalFuture.set(RpcResultBuilder.<SetRoleOutput>success().withResult(setRoleOutputBuilder.build()).build());
+ setRoleOutputBuilder
+ .setTransactionId(new TransactionId(BigInteger.valueOf(roleRequestOutput.getXid())));
+ finalFuture.set(RpcResultBuilder.<SetRoleOutput>success()
+ .withResult(setRoleOutputBuilder.build()).build());
} else if (rpcErrors != null) {
LOG.trace("roleRequestOutput is null , rpcErrors={}", rpcErrors);
}
return ofJavaRole;
}
-
-
}
private static final Logger LOG = LoggerFactory.getLogger(SimpleRequestCallback.class);
private final Class<T> clazz;
- private SimpleRequestCallback(final RequestContext<T> context, final Class<?> requestType, final MessageSpy spy, final Class<T> clazz) {
+ private SimpleRequestCallback(final RequestContext<T> context,
+ final Class<?> requestType,
+ final MessageSpy spy,
+ final Class<T> clazz) {
super(context, requestType, spy, null);
this.clazz = Preconditions.checkNotNull(clazz);
}
- public static <T extends DataObject> FutureCallback<OfHeader> create(final RequestContext<T> context, final Class<?> requestType, final MessageSpy spy, final Class<T> clazz) {
+ public static <T extends DataObject> FutureCallback<OfHeader> create(final RequestContext<T> context,
+ final Class<?> requestType,
+ final MessageSpy spy,
+ final Class<T> clazz) {
return new SimpleRequestCallback<>(context, requestType, spy, clazz);
}
@Override
- public final void onSuccess(final OfHeader result) {
+ public void onSuccess(OfHeader result) {
spyMessage(MessageSpy.StatisticsGroup.TO_SWITCH_SUBMIT_SUCCESS);
if (result == null) {
private final AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> stepFunction;
public BatchStepJob(final BatchPlanStep planStep,
- final AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> stepFunction) {
+ final AsyncFunction<RpcResult<ProcessFlatBatchOutput>,
+ RpcResult<ProcessFlatBatchOutput>> stepFunction) {
this.planStep = planStep;
this.stepFunction = stepFunction;
}
public AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> getStepFunction() {
return stepFunction;
}
-
}
*/
public enum BatchStepType {
- /** flow add operation */FLOW_ADD,
- /** flow remove operation */FLOW_REMOVE,
- /** flow update operation */FLOW_UPDATE,
+ /** Flow add operation. */FLOW_ADD,
+ /** Flow remove operation. */FLOW_REMOVE,
+ /** Flow update operation. */FLOW_UPDATE,
- /** group add operation */GROUP_ADD,
- /** group remove operation */GROUP_REMOVE,
- /** group update operation */GROUP_UPDATE,
+ /** Group add operation. */GROUP_ADD,
+ /** Group remove operation. */GROUP_REMOVE,
+ /** Group update operation. */GROUP_UPDATE,
- /** meter add operation */METER_ADD,
- /** meter remove operation */METER_REMOVE,
- /** meter update operation */METER_UPDATE
+ /** Meter add operation. */METER_ADD,
+ /** Meter remove operation. */METER_REMOVE,
+ /** Meter update operation. */METER_UPDATE
}
}
/**
+ * Adapt flat batch add flow.
* @param planStep batch step containing changes of the same type
* @param node pointer for RPC routing
- * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.SalFlowsBatchService#addFlowsBatch(AddFlowsBatchInput)}
+ * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn
+ * .opendaylight.flows.service.rev160314.SalFlowsBatchService#addFlowsBatch(AddFlowsBatchInput)}
*/
public static AddFlowsBatchInput adaptFlatBatchAddFlow(final BatchPlanStep planStep, final NodeRef node) {
final List<BatchAddFlows> batchFlows = new ArrayList<>();
}
/**
+ * Adapt flat batch remove flow.
* @param planStep batch step containing changes of the same type
* @param node pointer for RPC routing
- * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.SalFlowsBatchService#removeFlowsBatch(RemoveFlowsBatchInput)}
+ * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn
+ * .opendaylight.flows.service.rev160314.SalFlowsBatchService#removeFlowsBatch(RemoveFlowsBatchInput)}
*/
public static RemoveFlowsBatchInput adaptFlatBatchRemoveFlow(final BatchPlanStep planStep, final NodeRef node) {
final List<BatchRemoveFlows> batchFlows = new ArrayList<>();
}
/**
+ * Adapt flat batch update flow.
* @param planStep batch step containing changes of the same type
* @param node pointer for RPC routing
- * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.SalFlowsBatchService#updateFlowsBatch(UpdateFlowsBatchInput)}
+ * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn
+ * .opendaylight.flows.service.rev160314.SalFlowsBatchService#updateFlowsBatch(UpdateFlowsBatchInput)}
*/
public static UpdateFlowsBatchInput adaptFlatBatchUpdateFlow(final BatchPlanStep planStep, final NodeRef node) {
final List<BatchUpdateFlows> batchFlows = new ArrayList<>();
}
/**
+ * Convert batch result.
* @param stepOffset offset of current batch plan step
* @return converted {@link ProcessFlatBatchOutput} RPC result
*/
@VisibleForTesting
static <T extends BatchFlowOutputListGrouping> Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>
- convertBatchFlowResult(final int stepOffset) {
+ convertBatchFlowResult(final int stepOffset) {
return new Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>() {
@Nullable
@Override
public RpcResult<ProcessFlatBatchOutput> apply(@Nullable final RpcResult<T> input) {
List<BatchFailure> batchFailures = wrapBatchFlowFailuresForFlat(input, stepOffset);
- ProcessFlatBatchOutputBuilder outputBuilder = new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
+ ProcessFlatBatchOutputBuilder outputBuilder =
+ new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
return RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
.withRpcErrors(input.getErrors())
.withResult(outputBuilder.build())
}
/**
- * shortcut for {@link #convertBatchFlowResult(int)} with conversion {@link ListenableFuture}
+ * Shortcut for {@link #convertBatchFlowResult(int)} with conversion {@link ListenableFuture}.
*
* @param <T> exact type of batch flow output
* @param resultUpdateFlowFuture batch flow rpc-result (add/remove/update)
* @return ListenableFuture with converted result {@link ProcessFlatBatchOutput}
*/
public static <T extends BatchFlowOutputListGrouping> ListenableFuture<RpcResult<ProcessFlatBatchOutput>>
- convertFlowBatchFutureForChain(final Future<RpcResult<T>> resultUpdateFlowFuture,
+ convertFlowBatchFutureForChain(final Future<RpcResult<T>> resultUpdateFlowFuture,
final int currentOffset) {
return Futures.transform(JdkFutureAdapters.listenInPoolThread(resultUpdateFlowFuture),
FlatBatchFlowAdapters.<T>convertBatchFlowResult(currentOffset));
}
/**
+ * Adapt flat batch add group.
* @param planStep batch step containing changes of the same type
* @param node pointer for RPC routing
- * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.SalGroupsBatchService#addGroupsBatch(AddGroupsBatchInput)}
+ * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn
+ * .opendaylight.groups.service.rev160315.SalGroupsBatchService#addGroupsBatch(AddGroupsBatchInput)}
*/
public static AddGroupsBatchInput adaptFlatBatchAddGroup(final BatchPlanStep planStep, final NodeRef node) {
final List<BatchAddGroups> batchGroups = new ArrayList<>();
}
/**
+ * Adapt flat batch remove group.
* @param planStep batch step containing changes of the same type
* @param node pointer for RPC routing
- * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.SalGroupsBatchService#removeGroupsBatch(RemoveGroupsBatchInput)}
+ * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn
+ * .opendaylight.groups.service.rev160315.SalGroupsBatchService#removeGroupsBatch(RemoveGroupsBatchInput)}
*/
public static RemoveGroupsBatchInput adaptFlatBatchRemoveGroup(final BatchPlanStep planStep, final NodeRef node) {
final List<BatchRemoveGroups> batchGroups = new ArrayList<>();
}
/**
+ * Adapt flat batch update group.
* @param planStep batch step containing changes of the same type
* @param node pointer for RPC routing
- * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.SalGroupsBatchService#updateGroupsBatch(UpdateGroupsBatchInput)}
+ * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn
+ * .opendaylight.groups.service.rev160315.SalGroupsBatchService#updateGroupsBatch(UpdateGroupsBatchInput)}
*/
public static UpdateGroupsBatchInput adaptFlatBatchUpdateGroup(final BatchPlanStep planStep, final NodeRef node) {
final List<BatchUpdateGroups> batchGroups = new ArrayList<>();
}
/**
+ * Convert batch group result.
* @param stepOffset offset of current batch plan step
* @return converted {@link ProcessFlatBatchOutput} RPC result
*/
@VisibleForTesting
static <T extends BatchGroupOutputListGrouping> Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>
- convertBatchGroupResult(final int stepOffset) {
+ convertBatchGroupResult(final int stepOffset) {
return new Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>() {
@Nullable
@Override
public RpcResult<ProcessFlatBatchOutput> apply(@Nullable final RpcResult<T> input) {
List<BatchFailure> batchFailures = wrapBatchGroupFailuresForFlat(input, stepOffset);
- ProcessFlatBatchOutputBuilder outputBuilder = new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
+ ProcessFlatBatchOutputBuilder outputBuilder =
+ new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
return RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
.withRpcErrors(input.getErrors())
.withResult(outputBuilder.build())
}
/**
- * shortcut for {@link #convertBatchGroupResult(int)} with conversion {@link ListenableFuture}
+ * Shortcut for {@link #convertBatchGroupResult(int)} with conversion {@link ListenableFuture}.
*
* @param <T> exact type of batch flow output
* @param resultUpdateGroupFuture batch group rpc-result (add/remove/update)
* @return ListenableFuture with converted result {@link ProcessFlatBatchOutput}
*/
public static <T extends BatchGroupOutputListGrouping> ListenableFuture<RpcResult<ProcessFlatBatchOutput>>
- convertGroupBatchFutureForChain(final Future<RpcResult<T>> resultUpdateGroupFuture,
+ convertGroupBatchFutureForChain(final Future<RpcResult<T>> resultUpdateGroupFuture,
final int currentOffset) {
return Futures.transform(JdkFutureAdapters.listenInPoolThread(resultUpdateGroupFuture),
FlatBatchGroupAdapters.<T>convertBatchGroupResult(currentOffset));
}
/**
+ * Adapt flat batch add meter.
* @param planStep batch step containing changes of the same type
* @param node pointer for RPC routing
- * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.SalMetersBatchService#addMetersBatch(AddMetersBatchInput)}
+ * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn
+ * .opendaylight.meters.service.rev160316.SalMetersBatchService#addMetersBatch(AddMetersBatchInput)}
*/
public static AddMetersBatchInput adaptFlatBatchAddMeter(final BatchPlanStep planStep, final NodeRef node) {
final List<BatchAddMeters> batchMeters = new ArrayList<>();
}
/**
+ * Adapt flat batch remove meter.
* @param planStep batch step containing changes of the same type
* @param node pointer for RPC routing
- * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.SalMetersBatchService#removeMetersBatch(RemoveMetersBatchInput)}
+ * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn
+ * .opendaylight.meters.service.rev160316.SalMetersBatchService#removeMetersBatch(RemoveMetersBatchInput)}
*/
public static RemoveMetersBatchInput adaptFlatBatchRemoveMeter(final BatchPlanStep planStep, final NodeRef node) {
final List<BatchRemoveMeters> batchMeters = new ArrayList<>();
}
/**
+ * Adapt flat batch update meter.
* @param planStep batch step containing changes of the same type
* @param node pointer for RPC routing
- * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.SalMetersBatchService#updateMetersBatch(UpdateMetersBatchInput)}
+ * @return input suitable for {@link org.opendaylight.yang.gen.v1.urn
+ * .opendaylight.meters.service.rev160316.SalMetersBatchService#updateMetersBatch(UpdateMetersBatchInput)}
*/
public static UpdateMetersBatchInput adaptFlatBatchUpdateMeter(final BatchPlanStep planStep, final NodeRef node) {
final List<BatchUpdateMeters> batchMeters = new ArrayList<>();
}
/**
+ * Convert meter batch result.
* @param stepOffset offset of current batch plan step
* @return converted {@link ProcessFlatBatchOutput} RPC result
*/
@VisibleForTesting
static <T extends BatchMeterOutputListGrouping> Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>
- convertBatchMeterResult(final int stepOffset) {
+ convertBatchMeterResult(final int stepOffset) {
return new Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>() {
@Nullable
@Override
public RpcResult<ProcessFlatBatchOutput> apply(@Nullable final RpcResult<T> input) {
List<BatchFailure> batchFailures = wrapBatchMeterFailuresForFlat(input, stepOffset);
- ProcessFlatBatchOutputBuilder outputBuilder = new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
+ ProcessFlatBatchOutputBuilder outputBuilder =
+ new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
return RpcResultBuilder.<ProcessFlatBatchOutput>status(input.isSuccessful())
.withRpcErrors(input.getErrors())
.withResult(outputBuilder.build())
}
/**
- * shortcut for {@link #convertBatchMeterResult(int)} with conversion {@link ListenableFuture}
+ * Shortcut for {@link #convertBatchMeterResult(int)} with conversion {@link ListenableFuture}.
*
* @param <T> exact type of batch flow output
* @param resultUpdateMeterFuture batch group rpc-result (add/remove/update)
* @return ListenableFuture with converted result {@link ProcessFlatBatchOutput}
*/
public static <T extends BatchMeterOutputListGrouping> ListenableFuture<RpcResult<ProcessFlatBatchOutput>>
- convertMeterBatchFutureForChain(final Future<RpcResult<T>> resultUpdateMeterFuture,
+ convertMeterBatchFutureForChain(final Future<RpcResult<T>> resultUpdateMeterFuture,
final int currentOffset) {
return Futures.transform(JdkFutureAdapters.listenInPoolThread(resultUpdateMeterFuture),
FlatBatchMeterAdapters.<T>convertBatchMeterResult(currentOffset));
@Override
- protected OfHeader buildRequest(final Xid xid, final GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input) throws ServiceException {
- final MultipartRequestAggregateCaseBuilder multipartRequestAggregateCaseBuilder = new MultipartRequestAggregateCaseBuilder();
+ protected OfHeader buildRequest(final Xid xid,
+ final GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input)
+ throws ServiceException {
+ final MultipartRequestAggregateCaseBuilder multipartRequestAggregateCaseBuilder =
+ new MultipartRequestAggregateCaseBuilder();
final MultipartRequestAggregateBuilder mprAggregateRequestBuilder = new MultipartRequestAggregateBuilder();
final short tableId = MoreObjects.firstNonNull(input.getTableId(), OFConstants.OFPTT_ALL);
mprAggregateRequestBuilder.setTableId(tableId);
if (input.getCookie() == null) {
mprAggregateRequestBuilder.setCookie(OFConstants.DEFAULT_COOKIE);
} else {
- mprAggregateRequestBuilder.setCookie(MoreObjects.firstNonNull(input.getCookie().getValue(), OFConstants.DEFAULT_COOKIE));
+ mprAggregateRequestBuilder
+ .setCookie(MoreObjects.firstNonNull(input.getCookie().getValue(), OFConstants.DEFAULT_COOKIE));
}
if (input.getCookieMask() == null) {
mprAggregateRequestBuilder.setCookieMask(OFConstants.DEFAULT_COOKIE_MASK);
} else {
- mprAggregateRequestBuilder.setCookieMask(MoreObjects.firstNonNull(input.getCookieMask().getValue(), OFConstants.DEFAULT_COOKIE_MASK));
+ mprAggregateRequestBuilder.setCookieMask(MoreObjects.firstNonNull(input.getCookieMask().getValue(),
+ OFConstants.DEFAULT_COOKIE_MASK));
}
long outGroup = MoreObjects.firstNonNull(input.getOutGroup(), OFConstants.OFPG_ANY);
mprAggregateRequestBuilder.setOutGroup(outGroup);
}
@Override
- public Future<RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>> handleAndReply(final GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input) {
+ public Future<RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>>
+ handleAndReply(final GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input) {
return Futures.transform(handleServiceCall(input),
- (Function<RpcResult<List<MultipartReply>>, RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>>) result -> {
+ (Function<RpcResult<List<MultipartReply>>,
+ RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>>) result -> {
if (Preconditions.checkNotNull(result).isSuccessful()) {
- final MessageTranslator<MultipartReply, AggregatedFlowStatistics> messageTranslator = translatorLibrary
+ final MessageTranslator<MultipartReply, AggregatedFlowStatistics> messageTranslator =
+ translatorLibrary
.lookupTranslator(new TranslatorKey(getVersion(), MultipartReplyAggregateCase.class.getName()));
return RpcResultBuilder
.build();
});
}
-
}
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
-import org.opendaylight.openflowplugin.extension.api.ConvertorMessageFromOFJava;
import org.opendaylight.openflowplugin.extension.api.ConverterMessageToOFJava;
+import org.opendaylight.openflowplugin.extension.api.ConvertorMessageFromOFJava;
import org.opendaylight.openflowplugin.extension.api.TypeVersionKey;
import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
import org.opendaylight.openflowplugin.extension.api.exception.ConversionException;
final List<MultipartReply> multipartReplies = result.getResult();
if (multipartReplies.isEmpty()) {
LOG.warn("Multipart reply to Experimenter-Mp request shouldn't be empty list.");
- finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed().withError(ErrorType.RPC, "Multipart reply list is empty.").build());
+ finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
+ .withError(ErrorType.RPC, "Multipart reply list is empty.").build());
} else {
LOG.debug(
- "OnSuccess, rpc result successful, multipart response for rpc sendExperimenterMpRequest with xid {} obtained.",
+ "OnSuccess, rpc result successful,"
+ + " multipart response for rpc sendExperimenterMpRequest with xid {} obtained.",
multipartReplies.get(0).getXid());
- final SendExperimenterMpRequestOutputBuilder sendExpMpReqOutputBuilder = new SendExperimenterMpRequestOutputBuilder();
+ final SendExperimenterMpRequestOutputBuilder sendExpMpReqOutputBuilder =
+ new SendExperimenterMpRequestOutputBuilder();
final List<ExperimenterCoreMessageItem> expCoreMessageItem = new ArrayList<>();
- for(MultipartReply multipartReply : multipartReplies){
- final MultipartReplyExperimenterCase caseBody = (MultipartReplyExperimenterCase)multipartReply.getMultipartReplyBody();
+ for (MultipartReply multipartReply : multipartReplies) {
+ final MultipartReplyExperimenterCase caseBody =
+ (MultipartReplyExperimenterCase)multipartReply.getMultipartReplyBody();
final MultipartReplyExperimenter replyBody = caseBody.getMultipartReplyExperimenter();
final ExperimenterDataOfChoice vendorData = replyBody.getExperimenterDataOfChoice();
final MessageTypeKey<? extends ExperimenterDataOfChoice> key = new MessageTypeKey<>(
LOG.warn("Custom converter for {}[OF:{}] not found",
vendorData.getImplementedInterface(),
getVersion());
- finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed().withError(ErrorType.RPC, "Custom converter not found.").build());
+ finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
+ .withError(ErrorType.RPC, "Custom converter not found.").build());
return;
}
try {
- final ExperimenterMessageOfChoice messageOfChoice = messageConverter.convert(vendorData, MessagePath.MPMESSAGE_RPC_OUTPUT);
- final ExperimenterCoreMessageItemBuilder expCoreMessageItemBuilder = new ExperimenterCoreMessageItemBuilder();
+ final ExperimenterMessageOfChoice messageOfChoice =
+ messageConverter.convert(vendorData, MessagePath.MPMESSAGE_RPC_OUTPUT);
+ final ExperimenterCoreMessageItemBuilder expCoreMessageItemBuilder =
+ new ExperimenterCoreMessageItemBuilder();
expCoreMessageItemBuilder.setExperimenterMessageOfChoice(messageOfChoice);
expCoreMessageItem.add(expCoreMessageItemBuilder.build());
} catch (final ConversionException e) {
LOG.error("Conversion of experimenter message reply failed. Exception: {}", e);
- finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed().withError(ErrorType.RPC, "Conversion of experimenter rpc output failed.").build());
+ finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
+ .withError(ErrorType.RPC,
+ "Conversion of experimenter rpc output failed.").build());
return;
}
}
finalFuture.set(RpcResultBuilder.success(sendExpMpReqOutputBuilder.build()).build());
}
} else {
- LOG.warn("OnSuccess, rpc result unsuccessful, multipart response for rpc sendExperimenterMpRequest was unsuccessful.");
- finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed().withRpcErrors(result.getErrors()).build());
+ LOG.warn("OnSuccess, rpc result unsuccessful,"
+ + " multipart response for rpc sendExperimenterMpRequest was unsuccessful.");
+ finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
+ .withRpcErrors(result.getErrors()).build());
}
}
@Override
- public void onFailure(final Throwable t) {
- LOG.warn("Failure multipart response for Experimenter-Mp request. Exception: {}", t);
- finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed().withError(ErrorType.RPC, "Future error", t).build());
+ public void onFailure(final Throwable throwable) {
+ LOG.warn("Failure multipart response for Experimenter-Mp request. Exception: {}", throwable);
+ finalFuture.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
+ .withError(ErrorType.RPC, "Future error", throwable).build());
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
-public class MultiLayerFlowMultipartRequestOnTheFlyCallback<T extends OfHeader> extends AbstractMultipartRequestOnTheFlyCallback<T> {
+public class MultiLayerFlowMultipartRequestOnTheFlyCallback<T extends OfHeader>
+ extends AbstractMultipartRequestOnTheFlyCallback<T> {
public MultiLayerFlowMultipartRequestOnTheFlyCallback(final RequestContext<List<T>> context,
final Class<?> requestType,
protected MultipartType getMultipartType() {
return MultipartType.OFPMPFLOW;
}
-
}
private final ConvertorExecutor convertorExecutor;
private final VersionDatapathIdConvertorData data;
- public MultiLayerFlowService(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final Class<O> clazz, final ConvertorExecutor convertorExecutor) {
+ public MultiLayerFlowService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final Class<O> clazz,
+ final ConvertorExecutor convertorExecutor) {
super(requestContextStack, deviceContext, clazz);
this.convertorExecutor = convertorExecutor;
data = new VersionDatapathIdConvertorData(getVersion());
}
@Override
- public void onFailure(final Throwable t) {
+ public void onFailure(final Throwable throwable) {
RpcResultBuilder<O> rpcResultBuilder = RpcResultBuilder.failed();
finalFuture.set(rpcResultBuilder.build());
}
return finalFuture;
}
-
}
private final ConvertorExecutor convertorExecutor;
private final VersionDatapathIdConvertorData data;
- public MultiLayerGroupService(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final Class<O> clazz, final ConvertorExecutor convertorExecutor) {
+ public MultiLayerGroupService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final Class<O> clazz,
+ final ConvertorExecutor convertorExecutor) {
super(requestContextStack, deviceContext, clazz);
this.convertorExecutor = convertorExecutor;
data = new VersionDatapathIdConvertorData(getVersion());
private final ConvertorExecutor convertorExecutor;
private final VersionConvertorData data;
- public MultiLayerMeterService(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final Class<O> clazz, final ConvertorExecutor convertorExecutor) {
+ public MultiLayerMeterService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final Class<O> clazz,
+ final ConvertorExecutor convertorExecutor) {
super(requestContextStack, deviceContext, clazz);
this.convertorExecutor = convertorExecutor;
data = new VersionConvertorData(getVersion());
public class MultiLayerMultipartCollectorService extends AbstractMultipartCollectorService<MultipartReply> {
- public MultiLayerMultipartCollectorService(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
+ public MultiLayerMultipartCollectorService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext) {
super(requestContextStack, deviceContext);
}
-
}
public class MultiLayerMultipartRequestCallback<T extends OfHeader> extends AbstractMultipartRequestCallback<T> {
- public MultiLayerMultipartRequestCallback(RequestContext<List<T>> context, Class<?> requestType, DeviceContext deviceContext, EventIdentifier eventIdentifier) {
+ public MultiLayerMultipartRequestCallback(RequestContext<List<T>> context, Class<?> requestType,
+ DeviceContext deviceContext,
+ EventIdentifier eventIdentifier) {
super(context, requestType, deviceContext, eventIdentifier);
}
final MultipartRequestFlags flags = MultipartReply.class.cast(result).getFlags();
return Objects.nonNull(flags) && flags.isOFPMPFREQMORE();
}
-
}
protected OfHeader buildRequest(final Xid xid, final UpdateTableInput input) throws ServiceException {
final Optional<List<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart
.request.multipart.request.body.multipart.request.table.features._case.multipart.request
- .table.features.TableFeatures>> tableFeatures = convertorExecutor.convert(input.getUpdatedTable(), data);
+ .table.features.TableFeatures>> tableFeatures =
+ convertorExecutor.convert(input.getUpdatedTable(), data);
return RequestInputUtils.createMultipartHeader(MultipartType.OFPMPTABLEFEATURES, xid.getValue(), getVersion())
.setMultipartRequestBody(new MultipartRequestTableFeaturesCaseBuilder()
}
@Override
+
public Future<RpcResult<UpdateTableOutput>> handleAndReply(UpdateTableInput input) {
final ListenableFuture<RpcResult<List<MultipartReply>>> multipartFuture = handleServiceCall(input);
final SettableFuture<RpcResult<UpdateTableOutput>> finalFuture = SettableFuture.create();
class CallBackImpl implements FutureCallback<RpcResult<List<MultipartReply>>> {
@Override
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void onSuccess(final RpcResult<List<MultipartReply>> result) {
if (result.isSuccessful()) {
} else {
final Long xid = multipartReplies.get(0).getXid();
LOG.debug(
- "OnSuccess, rpc result successful, multipart response for rpc update-table with xid {} obtained.",
+ "OnSuccess, rpc result successful,"
+ + " multipart response for rpc update-table with xid {} obtained.",
xid);
final UpdateTableOutputBuilder updateTableOutputBuilder = new UpdateTableOutputBuilder();
updateTableOutputBuilder.setTransactionId(new TransactionId(BigInteger.valueOf(xid)));
}
}
} else {
- LOG.debug("OnSuccess, rpc result unsuccessful, multipart response for rpc update-table was unsuccessful.");
+ LOG.debug("OnSuccess, rpc result unsuccessful,"
+ + " multipart response for rpc update-table was unsuccessful.");
finalFuture.set(RpcResultBuilder.<UpdateTableOutput>failed().withRpcErrors(result.getErrors())
.build());
}
}
@Override
- public void onFailure(final Throwable t) {
- LOG.error("Failure multipart response for table features request. Exception: {}", t);
+ public void onFailure(final Throwable throwable) {
+ LOG.error("Failure multipart response for table features request. Exception: {}", throwable);
finalFuture.set(RpcResultBuilder.<UpdateTableOutput>failed()
- .withError(ErrorType.RPC, "Future error", t).build());
+ .withError(ErrorType.RPC, "Future error", throwable).build());
}
}
return finalFuture;
}
- protected List<org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures> convertToSalTableFeatures(
+ protected List<org.opendaylight.yang.gen.v1.urn
+ .opendaylight.table.types.rev131026.table.features.TableFeatures> convertToSalTableFeatures(
final List<MultipartReply> multipartReplies) {
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures> salTableFeaturesAll = new ArrayList<>();
+ final List<org.opendaylight.yang.gen.v1.urn
+ .opendaylight.table.types.rev131026.table.features.TableFeatures> salTableFeaturesAll =
+ new ArrayList<>();
for (final MultipartReply multipartReply : multipartReplies) {
if (multipartReply.getType().equals(MultipartType.OFPMPTABLEFEATURES)) {
final MultipartReplyBody multipartReplyBody = multipartReply.getMultipartReplyBody();
if (multipartReplyBody instanceof MultipartReplyTableFeaturesCase) {
- final MultipartReplyTableFeaturesCase tableFeaturesCase = ((MultipartReplyTableFeaturesCase) multipartReplyBody);
+ final MultipartReplyTableFeaturesCase tableFeaturesCase =
+ ((MultipartReplyTableFeaturesCase) multipartReplyBody);
final MultipartReplyTableFeatures salTableFeatures = tableFeaturesCase
.getMultipartReplyTableFeatures();
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
import org.opendaylight.yangtools.yang.common.RpcResult;
-public class FlowCapableTransactionServiceImpl extends AbstractVoidService<SendBarrierInput> implements FlowCapableTransactionService {
- public FlowCapableTransactionServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
+public class FlowCapableTransactionServiceImpl extends AbstractVoidService<SendBarrierInput>
+ implements FlowCapableTransactionService {
+ public FlowCapableTransactionServiceImpl(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext) {
super(requestContextStack, deviceContext);
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.SetConfigInputBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
-public final class NodeConfigServiceImpl extends AbstractSimpleService<SetConfigInput, SetConfigOutput> implements NodeConfigService {
+public final class NodeConfigServiceImpl extends AbstractSimpleService<SetConfigInput, SetConfigOutput>
+ implements NodeConfigService {
public NodeConfigServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
super(requestContextStack, deviceContext, SetConfigOutput.class);
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.TransmitPacketInput;
import org.opendaylight.yangtools.yang.common.RpcResult;
-public final class PacketProcessingServiceImpl extends AbstractVoidService<TransmitPacketInput> implements PacketProcessingService {
+public final class PacketProcessingServiceImpl extends AbstractVoidService<TransmitPacketInput>
+ implements PacketProcessingService {
private final ConvertorExecutor convertorExecutor;
- public PacketProcessingServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final ConvertorExecutor convertorExecutor) {
+ public PacketProcessingServiceImpl(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final ConvertorExecutor convertorExecutor) {
super(requestContextStack, deviceContext);
this.convertorExecutor = convertorExecutor;
}
return transform(echoService.handleServiceCall(echoInputBld));
}
- private Future<RpcResult<SendEchoOutput>> transform(final ListenableFuture<RpcResult<EchoOutput>> rpcResultListenableFuture) {
- return Futures.transform(rpcResultListenableFuture, new Function<RpcResult<EchoOutput>, RpcResult<SendEchoOutput>>() {
- @Nullable
- @Override
- public RpcResult<SendEchoOutput> apply(@Nullable final RpcResult<EchoOutput> input) {
- Preconditions.checkNotNull(input, "echoOutput value is never expected to be NULL");
- final RpcResult<SendEchoOutput> rpcOutput;
- if (input.isSuccessful()) {
- final SendEchoOutput sendEchoOutput = new SendEchoOutputBuilder()
- .setData(input.getResult().getData())
- .build();
- rpcOutput = RpcResultBuilder.success(sendEchoOutput).build();
- } else {
- rpcOutput = RpcResultBuilder.<SendEchoOutput>failed()
- .withRpcErrors(input.getErrors())
- .build();
+ private Future<RpcResult<SendEchoOutput>>
+ transform(final ListenableFuture<RpcResult<EchoOutput>> rpcResultListenableFuture) {
+ return Futures.transform(rpcResultListenableFuture,
+ new Function<RpcResult<EchoOutput>,
+ RpcResult<SendEchoOutput>>() {
+ @Nullable
+ @Override
+ public RpcResult<SendEchoOutput> apply(@Nullable final RpcResult<EchoOutput> input) {
+ Preconditions.checkNotNull(input, "echoOutput value is never expected to be NULL");
+ final RpcResult<SendEchoOutput> rpcOutput;
+ if (input.isSuccessful()) {
+ final SendEchoOutput sendEchoOutput = new SendEchoOutputBuilder()
+ .setData(input.getResult().getData())
+ .build();
+ rpcOutput = RpcResultBuilder.success(sendEchoOutput).build();
+ } else {
+ rpcOutput = RpcResultBuilder.<SendEchoOutput>failed()
+ .withRpcErrors(input.getErrors())
+ .build();
+ }
+ return rpcOutput;
}
- return rpcOutput;
- }
- });
+ });
}
-
}
import org.opendaylight.yangtools.yang.common.RpcResult;
-public class SalExperimenterMessageServiceImpl extends AbstractVoidService<SendExperimenterInput> implements SalExperimenterMessageService {
+public class SalExperimenterMessageServiceImpl extends AbstractVoidService<SendExperimenterInput>
+ implements SalExperimenterMessageService {
private final ExtensionConverterProvider extensionConverterProvider;
@Override
protected OfHeader buildRequest(Xid xid, SendExperimenterInput input) throws ServiceException {
- final TypeVersionKey key = new TypeVersionKey(input.getExperimenterMessageOfChoice().getImplementedInterface(), getVersion());
+ final TypeVersionKey key =
+ new TypeVersionKey(input.getExperimenterMessageOfChoice().getImplementedInterface(), getVersion());
final ConverterMessageToOFJava<ExperimenterMessageOfChoice, ExperimenterDataOfChoice> messageConverter =
extensionConverterProvider.getMessageConverter(key);
}
@Override
- public Future<RpcResult<SendExperimenterMpRequestOutput>> sendExperimenterMpRequest(SendExperimenterMpRequestInput input) {
+ public Future<RpcResult<SendExperimenterMpRequestOutput>>
+ sendExperimenterMpRequest(SendExperimenterMpRequestInput input) {
return singleLayerService.canUseSingleLayerSerialization()
? singleLayerService.handleAndReply(input)
: multiLayerService.handleAndReply(input);
}
-
}
import org.slf4j.LoggerFactory;
/**
- * default implementation of {@link SalFlowsBatchService} - delegates work to {@link SalFlowService}
+ * Default implementation of {@link SalFlowsBatchService} - delegates work to {@link SalFlowService}.
*/
public class SalFlatBatchServiceImpl implements SalFlatBatchService {
private static final Logger LOG = LoggerFactory.getLogger(SalFlatBatchServiceImpl.class);
final SalGroupsBatchService salGroupsBatchService,
final SalMetersBatchService salMetersBatchService) {
this.salFlowService = Preconditions.checkNotNull(salFlowBatchService, "delegate flow service must not be null");
- this.salGroupService = Preconditions.checkNotNull(salGroupsBatchService, "delegate group service must not be null");
- this.salMeterService = Preconditions.checkNotNull(salMetersBatchService, "delegate meter service must not be null");
+ this.salGroupService =
+ Preconditions.checkNotNull(salGroupsBatchService, "delegate group service must not be null");
+ this.salMeterService =
+ Preconditions.checkNotNull(salMetersBatchService, "delegate meter service must not be null");
}
@Override
public Future<RpcResult<ProcessFlatBatchOutput>> processFlatBatch(final ProcessFlatBatchInput input) {
- LOG.trace("processing flat batch @ {} : {}", PathUtil.extractNodeId(input.getNode()).getValue(), 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<BatchStepJob> 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);
}
// wire actual job with chain
firedJobs.add(Futures.transformAsync(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)) {
+ if ((batchJob.getPlanStep().isBarrierAfter()) || (i == batchJobsChain.size() - 1)) {
firedJobs.add(0, chainSummaryResult);
chainSummaryResult = FlatBatchUtil.mergeJobsResultsFutures(firedJobs);
firedJobs.clear();
}
@VisibleForTesting
- List<BatchStepJob> prepareBatchChain(final List<BatchPlanStep> batchPlan, final NodeRef node, final boolean exitOnFirstError) {
+ List<BatchStepJob> prepareBatchChain(final List<BatchPlanStep> batchPlan,
+ final NodeRef node,
+ final boolean exitOnFirstError) {
// create batch API calls based on plan steps
final List<BatchStepJob> chainJobs = new ArrayList<>();
int stepOffset = 0;
switch (planStep.getStepType()) {
case FLOW_ADD:
- final AddFlowsBatchInput addFlowsBatchInput = FlatBatchFlowAdapters.adaptFlatBatchAddFlow(planStep, node);
- final Future<RpcResult<AddFlowsBatchOutput>> resultAddFlowFuture = salFlowService.addFlowsBatch(addFlowsBatchInput);
+ final AddFlowsBatchInput addFlowsBatchInput =
+ FlatBatchFlowAdapters.adaptFlatBatchAddFlow(planStep, node);
+ final Future<RpcResult<AddFlowsBatchOutput>> resultAddFlowFuture =
+ salFlowService.addFlowsBatch(addFlowsBatchInput);
chainOutput = FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultAddFlowFuture, currentOffset);
break;
case FLOW_REMOVE:
- final RemoveFlowsBatchInput removeFlowsBatchInput = FlatBatchFlowAdapters.adaptFlatBatchRemoveFlow(planStep, node);
- final Future<RpcResult<RemoveFlowsBatchOutput>> resultRemoveFlowFuture = salFlowService.removeFlowsBatch(removeFlowsBatchInput);
- chainOutput = FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultRemoveFlowFuture, currentOffset);
+ final RemoveFlowsBatchInput removeFlowsBatchInput =
+ FlatBatchFlowAdapters.adaptFlatBatchRemoveFlow(planStep, node);
+ final Future<RpcResult<RemoveFlowsBatchOutput>> resultRemoveFlowFuture =
+ salFlowService.removeFlowsBatch(removeFlowsBatchInput);
+ chainOutput =
+ FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultRemoveFlowFuture, currentOffset);
break;
case FLOW_UPDATE:
- final UpdateFlowsBatchInput updateFlowsBatchInput = FlatBatchFlowAdapters.adaptFlatBatchUpdateFlow(planStep, node);
- final Future<RpcResult<UpdateFlowsBatchOutput>> resultUpdateFlowFuture = salFlowService.updateFlowsBatch(updateFlowsBatchInput);
- chainOutput = FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultUpdateFlowFuture, currentOffset);
+ final UpdateFlowsBatchInput updateFlowsBatchInput =
+ FlatBatchFlowAdapters.adaptFlatBatchUpdateFlow(planStep, node);
+ final Future<RpcResult<UpdateFlowsBatchOutput>> resultUpdateFlowFuture =
+ salFlowService.updateFlowsBatch(updateFlowsBatchInput);
+ chainOutput =
+ FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultUpdateFlowFuture, currentOffset);
break;
case GROUP_ADD:
- final AddGroupsBatchInput addGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchAddGroup(planStep, node);
- final Future<RpcResult<AddGroupsBatchOutput>> resultAddGroupFuture = salGroupService.addGroupsBatch(addGroupsBatchInput);
- chainOutput = FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultAddGroupFuture, currentOffset);
+ final AddGroupsBatchInput addGroupsBatchInput =
+ FlatBatchGroupAdapters.adaptFlatBatchAddGroup(planStep, node);
+ final Future<RpcResult<AddGroupsBatchOutput>> resultAddGroupFuture =
+ salGroupService.addGroupsBatch(addGroupsBatchInput);
+ chainOutput =
+ FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultAddGroupFuture, currentOffset);
break;
case GROUP_REMOVE:
- final RemoveGroupsBatchInput removeGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchRemoveGroup(planStep, node);
- final Future<RpcResult<RemoveGroupsBatchOutput>> resultRemoveGroupFuture = salGroupService.removeGroupsBatch(removeGroupsBatchInput);
- chainOutput = FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultRemoveGroupFuture, currentOffset);
+ final RemoveGroupsBatchInput removeGroupsBatchInput =
+ FlatBatchGroupAdapters.adaptFlatBatchRemoveGroup(planStep, node);
+ final Future<RpcResult<RemoveGroupsBatchOutput>> resultRemoveGroupFuture =
+ salGroupService.removeGroupsBatch(removeGroupsBatchInput);
+ chainOutput =
+ FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultRemoveGroupFuture, currentOffset);
break;
case GROUP_UPDATE:
- final UpdateGroupsBatchInput updateGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchUpdateGroup(planStep, node);
- final Future<RpcResult<UpdateGroupsBatchOutput>> resultUpdateGroupFuture = salGroupService.updateGroupsBatch(updateGroupsBatchInput);
- chainOutput = FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultUpdateGroupFuture, currentOffset);
+ final UpdateGroupsBatchInput updateGroupsBatchInput =
+ FlatBatchGroupAdapters.adaptFlatBatchUpdateGroup(planStep, node);
+ final Future<RpcResult<UpdateGroupsBatchOutput>> resultUpdateGroupFuture =
+ salGroupService.updateGroupsBatch(updateGroupsBatchInput);
+ chainOutput =
+ FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultUpdateGroupFuture, currentOffset);
break;
case METER_ADD:
- final AddMetersBatchInput addMetersBatchInput = FlatBatchMeterAdapters.adaptFlatBatchAddMeter(planStep, node);
- final Future<RpcResult<AddMetersBatchOutput>> resultAddMeterFuture = salMeterService.addMetersBatch(addMetersBatchInput);
- chainOutput = FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultAddMeterFuture, currentOffset);
+ final AddMetersBatchInput addMetersBatchInput =
+ FlatBatchMeterAdapters.adaptFlatBatchAddMeter(planStep, node);
+ final Future<RpcResult<AddMetersBatchOutput>> resultAddMeterFuture =
+ salMeterService.addMetersBatch(addMetersBatchInput);
+ chainOutput =
+ FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultAddMeterFuture, currentOffset);
break;
case METER_REMOVE:
- final RemoveMetersBatchInput removeMetersBatchInput = FlatBatchMeterAdapters.adaptFlatBatchRemoveMeter(planStep, node);
- final Future<RpcResult<RemoveMetersBatchOutput>> resultRemoveMeterFuture = salMeterService.removeMetersBatch(removeMetersBatchInput);
- chainOutput = FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultRemoveMeterFuture, currentOffset);
+ final RemoveMetersBatchInput removeMetersBatchInput =
+ FlatBatchMeterAdapters.adaptFlatBatchRemoveMeter(planStep, node);
+ final Future<RpcResult<RemoveMetersBatchOutput>> resultRemoveMeterFuture =
+ salMeterService.removeMetersBatch(removeMetersBatchInput);
+ chainOutput =
+ FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultRemoveMeterFuture, currentOffset);
break;
case METER_UPDATE:
- final UpdateMetersBatchInput updateMetersBatchInput = FlatBatchMeterAdapters.adaptFlatBatchUpdateMeter(planStep, node);
- final Future<RpcResult<UpdateMetersBatchOutput>> resultUpdateMeterFuture = salMeterService.updateMetersBatch(updateMetersBatchInput);
- chainOutput = FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultUpdateMeterFuture, currentOffset);
+ final UpdateMetersBatchInput updateMetersBatchInput =
+ FlatBatchMeterAdapters.adaptFlatBatchUpdateMeter(planStep, node);
+ final Future<RpcResult<UpdateMetersBatchOutput>> resultUpdateMeterFuture =
+ salMeterService.updateMetersBatch(updateMetersBatchInput);
+ chainOutput =
+ FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultUpdateMeterFuture, currentOffset);
break;
default:
LOG.warn("Unsupported plan-step type occurred: {} -> OMITTING", planStep.getStepType());
import org.opendaylight.openflowplugin.api.openflow.rpc.listener.ItemLifecycleListener;
import org.opendaylight.openflowplugin.impl.registry.flow.FlowDescriptorFactory;
import org.opendaylight.openflowplugin.impl.registry.flow.FlowRegistryKeyFactory;
-import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerFlowService;
import org.opendaylight.openflowplugin.impl.services.multilayer.MultiLayerFlowService;
+import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerFlowService;
import org.opendaylight.openflowplugin.impl.util.ErrorUtil;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.openflowplugin.openflow.md.util.FlowCreatorUtil;
private final DeviceContext deviceContext;
private ItemLifecycleListener itemLifecycleListener;
- public SalFlowServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final ConvertorExecutor convertorExecutor) {
+ public SalFlowServiceImpl(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final ConvertorExecutor convertorExecutor) {
this.deviceContext = deviceContext;
- flowRemove = new MultiLayerFlowService<>(requestContextStack, deviceContext, RemoveFlowOutput.class, convertorExecutor);
- flowAdd = new MultiLayerFlowService<>(requestContextStack, deviceContext, AddFlowOutput.class, convertorExecutor);
- flowUpdate = new MultiLayerFlowService<>(requestContextStack, deviceContext, UpdateFlowOutput.class, convertorExecutor);
+ flowRemove = new MultiLayerFlowService<>(requestContextStack,
+ deviceContext,
+ RemoveFlowOutput.class,
+ convertorExecutor);
+ flowAdd = new MultiLayerFlowService<>(requestContextStack,
+ deviceContext,
+ AddFlowOutput.class,
+ convertorExecutor);
+ flowUpdate = new MultiLayerFlowService<>(requestContextStack,
+ deviceContext,
+ UpdateFlowOutput.class,
+ convertorExecutor);
flowAddMessage = new SingleLayerFlowService<>(requestContextStack, deviceContext, AddFlowOutput.class);
flowUpdateMessage = new SingleLayerFlowService<>(requestContextStack, deviceContext, UpdateFlowOutput.class);
- flowRemoveMessage= new SingleLayerFlowService<>(requestContextStack, deviceContext, RemoveFlowOutput.class);
+ flowRemoveMessage = new SingleLayerFlowService<>(requestContextStack, deviceContext, RemoveFlowOutput.class);
}
@Override
@Override
public Future<RpcResult<AddFlowOutput>> addFlow(final AddFlowInput input) {
- final FlowRegistryKey flowRegistryKey = FlowRegistryKeyFactory.create(deviceContext.getDeviceInfo().getVersion(), input);
+ final FlowRegistryKey flowRegistryKey =
+ FlowRegistryKeyFactory.create(deviceContext.getDeviceInfo().getVersion(), input);
final ListenableFuture<RpcResult<AddFlowOutput>> future;
if (flowAddMessage.canUseSingleLayerSerialization()) {
if (!FlowCreatorUtil.canModifyFlow(original, updated, flowUpdateMessage.getVersion())) {
final SettableFuture<RpcResult<UpdateFlowOutput>> objectSettableFuture = SettableFuture.create();
- final ListenableFuture<List<RpcResult<UpdateFlowOutput>>> listListenableFuture = Futures.successfulAsList(
- flowUpdateMessage.handleServiceCall(input.getOriginalFlow()),
- flowUpdateMessage.handleServiceCall(input.getUpdatedFlow()));
+ final ListenableFuture<List<RpcResult<UpdateFlowOutput>>> listListenableFuture =
+ Futures.successfulAsList(flowUpdateMessage.handleServiceCall(input.getOriginalFlow()),
+ flowUpdateMessage.handleServiceCall(input.getUpdatedFlow()));
Futures.addCallback(listListenableFuture, new FutureCallback<List<RpcResult<UpdateFlowOutput>>>() {
@Override
}
@Override
- public void onFailure(final Throwable t) {
+ public void onFailure(final Throwable throwable) {
RpcResultBuilder<UpdateFlowOutput> rpcResultBuilder = RpcResultBuilder.failed();
objectSettableFuture.set(rpcResultBuilder.build());
}
}
@VisibleForTesting
- private static KeyedInstanceIdentifier<Flow, FlowKey> createFlowPath(FlowDescriptor flowDescriptor,
- KeyedInstanceIdentifier<Node, NodeKey> nodePath) {
+ private static KeyedInstanceIdentifier<Flow, FlowKey> createFlowPath(
+ FlowDescriptor flowDescriptor,
+ KeyedInstanceIdentifier<Node, NodeKey> nodePath) {
return nodePath.augmentation(FlowCapableNode.class)
.child(Table.class, flowDescriptor.getTableKey())
.child(Flow.class, new FlowKey(flowDescriptor.getFlowId()));
if (LOG.isDebugEnabled()) {
LOG.debug("Flow remove finished without error for flow={}", input);
}
- FlowRegistryKey flowRegistryKey = FlowRegistryKeyFactory.create(deviceContext.getDeviceInfo().getVersion(), input);
+ FlowRegistryKey flowRegistryKey =
+ FlowRegistryKeyFactory.create(deviceContext.getDeviceInfo().getVersion(), input);
deviceContext.getDeviceFlowRegistry().addMark(flowRegistryKey);
if (itemLifecycleListener != null) {
- final FlowDescriptor flowDescriptor = deviceContext.getDeviceFlowRegistry().retrieveDescriptor(flowRegistryKey);
+ final FlowDescriptor flowDescriptor =
+ deviceContext.getDeviceFlowRegistry().retrieveDescriptor(flowRegistryKey);
if (flowDescriptor != null) {
KeyedInstanceIdentifier<Flow, FlowKey> flowPath = createFlowPath(flowDescriptor,
}
@Override
- public void onSuccess(final RpcResult<UpdateFlowOutput> o) {
+ public void onSuccess(final RpcResult<UpdateFlowOutput> updateFlowOutputRpcResult) {
final DeviceFlowRegistry deviceFlowRegistry = deviceContext.getDeviceFlowRegistry();
final UpdatedFlow updated = input.getUpdatedFlow();
final OriginalFlow original = input.getOriginalFlow();
- final FlowRegistryKey origFlowRegistryKey = FlowRegistryKeyFactory.create(deviceContext.getDeviceInfo().getVersion(), original);
- final FlowRegistryKey updatedFlowRegistryKey = FlowRegistryKeyFactory.create(deviceContext.getDeviceInfo().getVersion(), updated);
+ final FlowRegistryKey origFlowRegistryKey =
+ FlowRegistryKeyFactory.create(deviceContext.getDeviceInfo().getVersion(), original);
+ final FlowRegistryKey updatedFlowRegistryKey =
+ FlowRegistryKeyFactory.create(deviceContext.getDeviceInfo().getVersion(), updated);
final FlowDescriptor origFlowDescriptor = deviceFlowRegistry.retrieveDescriptor(origFlowRegistryKey);
final boolean isUpdate = Objects.nonNull(origFlowDescriptor);
final FlowDescriptor updatedFlowDescriptor;
if (Objects.nonNull(input.getFlowRef())) {
- updatedFlowDescriptor = FlowDescriptorFactory.create(updated.getTableId(), input.getFlowRef().getValue().firstKeyOf(Flow.class).getId());
+ updatedFlowDescriptor =
+ FlowDescriptorFactory.create(updated.getTableId(),
+ input.getFlowRef().getValue().firstKeyOf(Flow.class).getId());
} else {
if (isUpdate) {
updatedFlowDescriptor = origFlowDescriptor;
public SalFlowsBatchServiceImpl(final SalFlowService salFlowService,
final FlowCapableTransactionService transactionService) {
this.salFlowService = Preconditions.checkNotNull(salFlowService, "delegate flow service must not be null");
- this.transactionService = Preconditions.checkNotNull(transactionService, "delegate transaction service must not be null");
+ this.transactionService =
+ Preconditions.checkNotNull(transactionService, "delegate transaction service must not be null");
}
@Override
public Future<RpcResult<RemoveFlowsBatchOutput>> removeFlowsBatch(final RemoveFlowsBatchInput input) {
- LOG.trace("Removing flows @ {} : {}", PathUtil.extractNodeId(input.getNode()), input.getBatchRemoveFlows().size());
+ LOG.trace("Removing flows @ {} : {}",
+ PathUtil.extractNodeId(input.getNode()),
+ input.getBatchRemoveFlows().size());
final ArrayList<ListenableFuture<RpcResult<RemoveFlowOutput>>> resultsLot = new ArrayList<>();
for (BatchFlowInputGrouping batchFlow : input.getBatchRemoveFlows()) {
final RemoveFlowInput removeFlowInput = new RemoveFlowInputBuilder(batchFlow)
Futures.transform(Futures.successfulAsList(resultsLot),
FlowUtil.<RemoveFlowOutput>createCumulatingFunction(input.getBatchRemoveFlows()));
- ListenableFuture<RpcResult<RemoveFlowsBatchOutput>> removeFlowsBulkFuture = Futures.transform(commonResult, FlowUtil.FLOW_REMOVE_TRANSFORM);
+ ListenableFuture<RpcResult<RemoveFlowsBatchOutput>> removeFlowsBulkFuture =
+ Futures.transform(commonResult, FlowUtil.FLOW_REMOVE_TRANSFORM);
if (input.isBarrierAfter()) {
removeFlowsBulkFuture = BarrierUtil.chainBarrier(removeFlowsBulkFuture, input.getNode(),
@Override
public Future<RpcResult<UpdateFlowsBatchOutput>> updateFlowsBatch(final UpdateFlowsBatchInput input) {
- LOG.trace("Updating flows @ {} : {}", PathUtil.extractNodeId(input.getNode()), input.getBatchUpdateFlows().size());
+ LOG.trace("Updating flows @ {} : {}",
+ PathUtil.extractNodeId(input.getNode()),
+ input.getBatchUpdateFlows().size());
final ArrayList<ListenableFuture<RpcResult<UpdateFlowOutput>>> resultsLot = new ArrayList<>();
for (BatchUpdateFlows batchFlow : input.getBatchUpdateFlows()) {
final UpdateFlowInput updateFlowInput = new UpdateFlowInputBuilder(input)
}
final ListenableFuture<RpcResult<List<BatchFailedFlowsOutput>>> commonResult =
- Futures.transform(Futures.successfulAsList(resultsLot), FlowUtil.<UpdateFlowOutput>createCumulatingFunction(input.getBatchUpdateFlows()));
+ Futures.transform(Futures.successfulAsList(resultsLot),
+ FlowUtil.<UpdateFlowOutput>createCumulatingFunction(input.getBatchUpdateFlows()));
- ListenableFuture<RpcResult<UpdateFlowsBatchOutput>> updateFlowsBulkFuture = Futures.transform(commonResult, FlowUtil.FLOW_UPDATE_TRANSFORM);
+ ListenableFuture<RpcResult<UpdateFlowsBatchOutput>> updateFlowsBulkFuture =
+ Futures.transform(commonResult, FlowUtil.FLOW_UPDATE_TRANSFORM);
if (input.isBarrierAfter()) {
updateFlowsBulkFuture = BarrierUtil.chainBarrier(updateFlowsBulkFuture, input.getNode(),
return updateFlowsBulkFuture;
}
-
}
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.api.openflow.rpc.ItemLifeCycleSource;
import org.opendaylight.openflowplugin.api.openflow.rpc.listener.ItemLifecycleListener;
-import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerGroupService;
import org.opendaylight.openflowplugin.impl.services.multilayer.MultiLayerGroupService;
+import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerGroupService;
import org.opendaylight.openflowplugin.impl.util.ErrorUtil;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
private final DeviceContext deviceContext;
private ItemLifecycleListener itemLifecycleListener;
- public SalGroupServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final ConvertorExecutor convertorExecutor) {
+ public SalGroupServiceImpl(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final ConvertorExecutor convertorExecutor) {
this.deviceContext = deviceContext;
- addGroup = new MultiLayerGroupService<>(requestContextStack, deviceContext, AddGroupOutput.class, convertorExecutor);
- updateGroup = new MultiLayerGroupService<>(requestContextStack, deviceContext, UpdateGroupOutput.class, convertorExecutor);
- removeGroup = new MultiLayerGroupService<>(requestContextStack, deviceContext, RemoveGroupOutput.class, convertorExecutor);
+ addGroup = new MultiLayerGroupService<>(requestContextStack,
+ deviceContext,
+ AddGroupOutput.class,
+ convertorExecutor);
+
+ updateGroup = new MultiLayerGroupService<>(requestContextStack,
+ deviceContext,
+ UpdateGroupOutput.class,
+ convertorExecutor);
+
+ removeGroup = new MultiLayerGroupService<>(requestContextStack,
+ deviceContext,
+ RemoveGroupOutput.class,
+ convertorExecutor);
addGroupMessage = new SingleLayerGroupService<>(requestContextStack, deviceContext, AddGroupOutput.class);
updateGroupMessage = new SingleLayerGroupService<>(requestContextStack, deviceContext, UpdateGroupOutput.class);
@Override
public Future<RpcResult<AddGroupOutput>> addGroup(final AddGroupInput input) {
- final ListenableFuture<RpcResult<AddGroupOutput>> resultFuture = addGroupMessage.canUseSingleLayerSerialization()
+ final ListenableFuture<RpcResult<AddGroupOutput>> resultFuture =
+ addGroupMessage.canUseSingleLayerSerialization()
? addGroupMessage.handleServiceCall(input)
: addGroup.handleServiceCall(input);
}
@Override
- public void onFailure(Throwable t) {
- LOG.warn("Service call for adding group={} failed, reason: {}", input.getGroupId().getValue(), t);
+ public void onFailure(Throwable throwable) {
+ LOG.warn("Service call for adding group={} failed, reason: {}",
+ input.getGroupId().getValue(),
+ throwable);
}
});
return resultFuture;
@Override
public Future<RpcResult<UpdateGroupOutput>> updateGroup(final UpdateGroupInput input) {
- final ListenableFuture<RpcResult<UpdateGroupOutput>> resultFuture = updateGroupMessage.canUseSingleLayerSerialization()
+ final ListenableFuture<RpcResult<UpdateGroupOutput>> resultFuture =
+ updateGroupMessage.canUseSingleLayerSerialization()
? updateGroupMessage.handleServiceCall(input.getUpdatedGroup())
: updateGroup.handleServiceCall(input.getUpdatedGroup());
}
@Override
- public void onFailure(Throwable t) {
+ public void onFailure(Throwable throwable) {
LOG.warn("Service call for updating group={} failed, reason: {}",
- input.getOriginalGroup().getGroupId(), t);
+ input.getOriginalGroup().getGroupId(), throwable);
}
});
return resultFuture;
@Override
public Future<RpcResult<RemoveGroupOutput>> removeGroup(final RemoveGroupInput input) {
- final ListenableFuture<RpcResult<RemoveGroupOutput>> resultFuture = removeGroupMessage.canUseSingleLayerSerialization()
+ final ListenableFuture<RpcResult<RemoveGroupOutput>> resultFuture =
+ removeGroupMessage.canUseSingleLayerSerialization()
? removeGroupMessage.handleServiceCall(input)
: removeGroup.handleServiceCall(input);
}
@Override
- public void onFailure(Throwable t) {
+ public void onFailure(Throwable throwable) {
LOG.warn("Service call for removing group={} failed, reason: {}",
- input.getGroupId().getValue(), t);
+ input.getGroupId().getValue(), throwable);
}
});
return resultFuture;
private void removeIfNecessaryFromDS(final GroupId groupId) {
if (itemLifecycleListener != null) {
- KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group, GroupKey> groupPath
+ KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn
+ .opendaylight.group.types.rev131018.groups.Group, GroupKey> groupPath
= createGroupPath(groupId,
- deviceContext.getDeviceInfo().getNodeInstanceIdentifier());
+ deviceContext.getDeviceInfo().getNodeInstanceIdentifier());
itemLifecycleListener.onRemoved(groupPath);
}
}
private void addIfNecessaryToDS(final GroupId groupId, final Group data) {
if (itemLifecycleListener != null) {
- KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group, GroupKey> groupPath
+ KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn
+ .opendaylight.group.types.rev131018.groups.Group, GroupKey> groupPath
= createGroupPath(groupId,
- deviceContext.getDeviceInfo().getNodeInstanceIdentifier());
+ deviceContext.getDeviceInfo().getNodeInstanceIdentifier());
itemLifecycleListener.onAdded(groupPath, new GroupBuilder(data).build());
}
}
- private static KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group, GroupKey>
- createGroupPath(final GroupId groupId, final KeyedInstanceIdentifier<Node, NodeKey> nodePath) {
- return nodePath.augmentation(FlowCapableNode.class).
- child(org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group.class, new GroupKey(groupId));
+ private static KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn
+ .opendaylight.group.types.rev131018.groups.Group, GroupKey>
+ createGroupPath(final GroupId groupId, final KeyedInstanceIdentifier<Node, NodeKey> nodePath) {
+ return nodePath.augmentation(FlowCapableNode.class).child(org.opendaylight.yang.gen.v1.urn
+ .opendaylight.group.types.rev131018.groups.Group.class, new GroupKey(groupId));
}
}
private final SalGroupService salGroupService;
private final FlowCapableTransactionService transactionService;
- public SalGroupsBatchServiceImpl(final SalGroupService salGroupService, final FlowCapableTransactionService transactionService) {
+ public SalGroupsBatchServiceImpl(final SalGroupService salGroupService,
+ final FlowCapableTransactionService transactionService) {
this.salGroupService = Preconditions.checkNotNull(salGroupService);
this.transactionService = Preconditions.checkNotNull(transactionService);
}
}
final Iterable<Group> groups = Iterables.transform(batchUpdateGroups, new Function<BatchUpdateGroups, Group>() {
- @Nullable
- @Override
- public Group apply(@Nullable final BatchUpdateGroups input) {
- return input.getUpdatedBatchedGroup();
- }
+ @Nullable
+ @Override
+ public Group apply(@Nullable final BatchUpdateGroups input) {
+ return input.getUpdatedBatchedGroup();
}
+ }
);
final ListenableFuture<RpcResult<List<BatchFailedGroupsOutput>>> commonResult =
@Override
public Future<RpcResult<RemoveGroupsBatchOutput>> removeGroupsBatch(final RemoveGroupsBatchInput input) {
- LOG.trace("Removing groups @ {} : {}", PathUtil.extractNodeId(input.getNode()), input.getBatchRemoveGroups().size());
+ LOG.trace("Removing groups @ {} : {}",
+ PathUtil.extractNodeId(input.getNode()),
+ input.getBatchRemoveGroups().size());
final ArrayList<ListenableFuture<RpcResult<RemoveGroupOutput>>> resultsLot = new ArrayList<>();
for (BatchRemoveGroups addGroup : input.getBatchRemoveGroups()) {
final RemoveGroupInput removeGroupInput = new RemoveGroupInputBuilder(addGroup)
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.api.openflow.rpc.ItemLifeCycleSource;
import org.opendaylight.openflowplugin.api.openflow.rpc.listener.ItemLifecycleListener;
-import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerMeterService;
import org.opendaylight.openflowplugin.impl.services.multilayer.MultiLayerMeterService;
+import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerMeterService;
import org.opendaylight.openflowplugin.impl.util.ErrorUtil;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
private ItemLifecycleListener itemLifecycleListener;
private final DeviceContext deviceContext;
- public SalMeterServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final ConvertorExecutor convertorExecutor) {
+ public SalMeterServiceImpl(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final ConvertorExecutor convertorExecutor) {
this.deviceContext = deviceContext;
- addMeter = new MultiLayerMeterService<>(requestContextStack, deviceContext, AddMeterOutput.class, convertorExecutor);
- updateMeter = new MultiLayerMeterService<>(requestContextStack, deviceContext, UpdateMeterOutput.class, convertorExecutor);
- removeMeter = new MultiLayerMeterService<>(requestContextStack, deviceContext, RemoveMeterOutput.class, convertorExecutor);
+ addMeter = new MultiLayerMeterService<>(requestContextStack,
+ deviceContext,
+ AddMeterOutput.class,
+ convertorExecutor);
+
+ updateMeter = new MultiLayerMeterService<>(requestContextStack,
+ deviceContext,
+ UpdateMeterOutput.class,
+ convertorExecutor);
+
+ removeMeter = new MultiLayerMeterService<>(requestContextStack,
+ deviceContext,
+ RemoveMeterOutput.class,
+ convertorExecutor);
addMeterMessage = new SingleLayerMeterService<>(requestContextStack, deviceContext, AddMeterOutput.class);
updateMeterMessage = new SingleLayerMeterService<>(requestContextStack, deviceContext, UpdateMeterOutput.class);
@Override
public Future<RpcResult<AddMeterOutput>> addMeter(final AddMeterInput input) {
- final ListenableFuture<RpcResult<AddMeterOutput>> resultFuture = addMeterMessage.canUseSingleLayerSerialization()
+ final ListenableFuture<RpcResult<AddMeterOutput>> resultFuture =
+ addMeterMessage.canUseSingleLayerSerialization()
? addMeterMessage.handleServiceCall(input)
: addMeter.handleServiceCall(input);
}
@Override
- public void onFailure(Throwable t) {
- LOG.warn("Service call for adding meter={} failed, reason: {}", input.getMeterId(), t);
+ public void onFailure(Throwable throwable) {
+ LOG.warn("Service call for adding meter={} failed, reason: {}", input.getMeterId(), throwable);
}
});
return resultFuture;
@Override
public Future<RpcResult<UpdateMeterOutput>> updateMeter(final UpdateMeterInput input) {
- final ListenableFuture<RpcResult<UpdateMeterOutput>> resultFuture = updateMeterMessage.canUseSingleLayerSerialization()
+ final ListenableFuture<RpcResult<UpdateMeterOutput>> resultFuture =
+ updateMeterMessage.canUseSingleLayerSerialization()
? updateMeterMessage.handleServiceCall(input.getUpdatedMeter())
: updateMeter.handleServiceCall(input.getUpdatedMeter());
public void onSuccess(RpcResult<UpdateMeterOutput> result) {
if (result.isSuccessful()) {
if (LOG.isDebugEnabled()) {
- LOG.debug("Meter update with id={} finished without error", input.getOriginalMeter().getMeterId());
+ LOG.debug("Meter update with id={} finished without error",
+ input.getOriginalMeter().getMeterId());
}
if (itemLifecycleListener != null) {
removeIfNecessaryFromDS(input.getOriginalMeter().getMeterId());
}
@Override
- public void onFailure(Throwable t) {
+ public void onFailure(Throwable throwable) {
LOG.warn("Service call for updating meter={} failed, reason: {}",
- input.getOriginalMeter().getMeterId(),t);
+ input.getOriginalMeter().getMeterId(),throwable);
}
});
return resultFuture;
@Override
public Future<RpcResult<RemoveMeterOutput>> removeMeter(final RemoveMeterInput input) {
- final ListenableFuture<RpcResult<RemoveMeterOutput>> resultFuture = removeMeterMessage.canUseSingleLayerSerialization()
+ final ListenableFuture<RpcResult<RemoveMeterOutput>> resultFuture =
+ removeMeterMessage.canUseSingleLayerSerialization()
? removeMeterMessage.handleServiceCall(input)
: removeMeter.handleServiceCall(input);
}
@Override
- public void onFailure(Throwable t) {
- LOG.warn("Service call for removing meter={} failed, reason: {}",input.getMeterId(),t);
+ public void onFailure(Throwable throwable) {
+ LOG.warn("Service call for removing meter={} failed, reason: {}",input.getMeterId(),throwable);
}
});
return resultFuture;
private void removeIfNecessaryFromDS(final MeterId meterId) {
if (itemLifecycleListener != null) {
- KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter, MeterKey> meterPath
+ KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn
+ .opendaylight.flow.inventory.rev130819.meters.Meter, MeterKey> meterPath
= createMeterPath(meterId, deviceContext.getDeviceInfo().getNodeInstanceIdentifier());
itemLifecycleListener.onRemoved(meterPath);
}
private void addIfNecessaryToDS(final MeterId meterId, final Meter data) {
if (itemLifecycleListener != null) {
- KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter, MeterKey> groupPath
+ KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn
+ .opendaylight.flow.inventory.rev130819.meters.Meter, MeterKey> groupPath
= createMeterPath(meterId, deviceContext.getDeviceInfo().getNodeInstanceIdentifier());
itemLifecycleListener.onAdded(groupPath, new MeterBuilder(data).build());
}
}
- private static KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter, MeterKey> createMeterPath(final MeterId meterId, final KeyedInstanceIdentifier<Node, NodeKey> nodePath) {
- return nodePath.augmentation(FlowCapableNode.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter.class, new MeterKey(meterId));
+ private static KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn
+ .opendaylight.flow.inventory.rev130819.meters.Meter, MeterKey> createMeterPath(
+ final MeterId meterId,
+ final KeyedInstanceIdentifier<Node, NodeKey> nodePath) {
+ return nodePath.augmentation(FlowCapableNode.class)
+ .child(org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter.class,
+ new MeterKey(meterId));
}
}
private final SalMeterService salMeterService;
private final FlowCapableTransactionService transactionService;
- public SalMetersBatchServiceImpl(final SalMeterService salMeterService, final FlowCapableTransactionService transactionService) {
+ public SalMetersBatchServiceImpl(final SalMeterService salMeterService,
+ final FlowCapableTransactionService transactionService) {
this.salMeterService = Preconditions.checkNotNull(salMeterService);
this.transactionService = Preconditions.checkNotNull(transactionService);
}
}
final Iterable<Meter> meters = Iterables.transform(batchUpdateMeters, new Function<BatchUpdateMeters, Meter>() {
- @Nullable
- @Override
- public Meter apply(@Nullable final BatchUpdateMeters input) {
- return input.getUpdatedBatchedMeter();
- }
+ @Nullable
+ @Override
+ public Meter apply(@Nullable final BatchUpdateMeters input) {
+ return input.getUpdatedBatchedMeter();
}
+ }
);
final ListenableFuture<RpcResult<List<BatchFailedMetersOutput>>> commonResult =
@Override
public Future<RpcResult<RemoveMetersBatchOutput>> removeMetersBatch(final RemoveMetersBatchInput input) {
- LOG.trace("Removing meters @ {} : {}", PathUtil.extractNodeId(input.getNode()), input.getBatchRemoveMeters().size());
+ LOG.trace("Removing meters @ {} : {}",
+ PathUtil.extractNodeId(input.getNode()),
+ input.getBatchRemoveMeters().size());
final ArrayList<ListenableFuture<RpcResult<RemoveMeterOutput>>> resultsLot = new ArrayList<>();
for (BatchRemoveMeters addMeter : input.getBatchRemoveMeters()) {
final RemoveMeterInput removeMeterInput = new RemoveMeterInputBuilder(addMeter)
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.service.rev131107.UpdatePortOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
-public final class SalPortServiceImpl extends AbstractSimpleService<UpdatePortInput, UpdatePortOutput> implements SalPortService {
+public final class SalPortServiceImpl
+ extends AbstractSimpleService<UpdatePortInput, UpdatePortOutput> implements SalPortService {
private final ConvertorExecutor convertorExecutor;
private final VersionConvertorData data;
private final SingleLayerPortService<UpdatePortOutput> portMessage;
- public SalPortServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final ConvertorExecutor convertorExecutor) {
+ public SalPortServiceImpl(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final ConvertorExecutor convertorExecutor) {
super(requestContextStack, deviceContext, UpdatePortOutput.class);
this.convertorExecutor = convertorExecutor;
data = new VersionConvertorData(getVersion());
import org.slf4j.LoggerFactory;
-public final class SalRoleServiceImpl extends AbstractSimpleService<SetRoleInput, SetRoleOutput> implements SalRoleService {
+public final class SalRoleServiceImpl extends AbstractSimpleService<SetRoleInput, SetRoleOutput>
+ implements SalRoleService {
+
private static final Logger LOG = LoggerFactory.getLogger(SalRoleServiceImpl.class);
private static final BigInteger MAX_GENERATION_ID = new BigInteger("ffffffffffffffff", 16);
final Future<BigInteger> generationFuture = roleService.getGenerationIdFromDevice(getVersion());
return Futures.transformAsync(JdkFutureAdapters.listenInPoolThread(generationFuture), generationId -> {
- LOG.debug("RoleChangeTask, GenerationIdFromDevice from device {} is {}", getDeviceInfo().getNodeId().getValue(), generationId);
+ LOG.debug("RoleChangeTask, GenerationIdFromDevice from device {} is {}",
+ getDeviceInfo().getNodeId().getValue(), generationId);
final BigInteger nextGenerationId = getNextGenerationId(generationId);
- LOG.debug("nextGenerationId received from device:{} is {}", getDeviceInfo().getNodeId().getValue(), nextGenerationId);
- final Future<RpcResult<SetRoleOutput>> submitRoleFuture = roleService.submitRoleChange(role, getVersion(), nextGenerationId);
+ LOG.debug("nextGenerationId received from device:{} is {}",
+ getDeviceInfo().getNodeId().getValue(), nextGenerationId);
+ final Future<RpcResult<SetRoleOutput>> submitRoleFuture =
+ roleService.submitRoleChange(role, getVersion(), nextGenerationId);
return JdkFutureAdapters.listenInPoolThread(submitRoleFuture);
});
}
final DeviceContext deviceContext,
final ConvertorExecutor convertorExecutor,
final MultipartWriterProvider multipartWriterProvider) {
- singleLayerService = new SingleLayerTableMultipartService(requestContextStack, deviceContext, multipartWriterProvider);
- multiLayerService = new MultiLayerTableMultipartService(requestContextStack, deviceContext, convertorExecutor, multipartWriterProvider);
+ singleLayerService = new SingleLayerTableMultipartService(requestContextStack,
+ deviceContext,
+ multipartWriterProvider);
+ multiLayerService = new MultiLayerTableMultipartService(requestContextStack,
+ deviceContext,
+ convertorExecutor,
+ multipartWriterProvider);
}
@Override
? singleLayerService.handleAndReply(input)
: multiLayerService.handleAndReply(input);
}
-
}
}
@Override
- protected OfHeader buildRequest(final Xid xid, final GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input) throws ServiceException {
+ protected OfHeader buildRequest(final Xid xid,
+ final GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input)
+ throws ServiceException {
return new MultipartRequestBuilder()
.setXid(xid.getValue())
.setVersion(getVersion())
.map(MultipartReply::getMultipartReplyBody)
.filter(MultipartReplyFlowAggregateStats.class::isInstance)
.map(multipartReplyBody ->
- new AggregatedFlowStatisticsBuilder(MultipartReplyFlowAggregateStats.class
+ new AggregatedFlowStatisticsBuilder(
+ MultipartReplyFlowAggregateStats.class
.cast(multipartReplyBody))
.build())
.collect(Collectors.toList())))
.build();
});
}
-
}
.build())
.build());
} else {
- LOG.warn("OnSuccess, rpc result unsuccessful, multipart response for rpc sendExperimenterMpRequest was unsuccessful.");
- future.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed().withRpcErrors(result.getErrors()).build());
+ LOG.warn("OnSuccess, rpc result unsuccessful,"
+ + " multipart response for rpc sendExperimenterMpRequest was unsuccessful.");
+ future.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
+ .withRpcErrors(result.getErrors()).build());
}
}
@Override
- public void onFailure(final Throwable t) {
- LOG.warn("Failure multipart response for Experimenter-Mp request. Exception: {}", t);
- future.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed().withError(ErrorType.RPC, "Future error", t).build());
+ public void onFailure(final Throwable throwable) {
+ LOG.warn("Failure multipart response for Experimenter-Mp request. Exception: {}", throwable);
+ future.set(RpcResultBuilder.<SendExperimenterMpRequestOutput>failed()
+ .withError(ErrorType.RPC, "Future error", throwable).build());
}
});
return future;
}
-
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
-public class SingleLayerFlowMultipartRequestOnTheFlyCallback<T extends OfHeader> extends AbstractMultipartRequestOnTheFlyCallback<T> {
+public class SingleLayerFlowMultipartRequestOnTheFlyCallback<T extends OfHeader>
+ extends AbstractMultipartRequestOnTheFlyCallback<T> {
public SingleLayerFlowMultipartRequestOnTheFlyCallback(final RequestContext<List<T>> context,
final Class<?> requestType,
protected MultipartType getMultipartType() {
return MultipartType.OFPMPFLOW;
}
-
}
import org.opendaylight.yangtools.yang.binding.DataObject;
public final class SingleLayerFlowService<O extends DataObject> extends AbstractSilentErrorService<Flow, O> {
- public SingleLayerFlowService(final RequestContextStack requestContextStack, final DeviceContext deviceContext, final Class<O> clazz) {
+ public SingleLayerFlowService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext,
+ final Class<O> clazz) {
super(requestContextStack, deviceContext, clazz);
}
.setXid(xid.getValue())
.build();
}
-
}
public class SingleLayerMultipartCollectorService extends AbstractMultipartCollectorService<MultipartReply> {
- public SingleLayerMultipartCollectorService(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
+ public SingleLayerMultipartCollectorService(final RequestContextStack requestContextStack,
+ final DeviceContext deviceContext) {
super(requestContextStack, deviceContext);
}
-
}
public class SingleLayerMultipartRequestCallback<T extends OfHeader> extends AbstractMultipartRequestCallback<T> {
- public SingleLayerMultipartRequestCallback(RequestContext<List<T>> context, Class<?> requestType, DeviceContext deviceContext, EventIdentifier eventIdentifier) {
+ public SingleLayerMultipartRequestCallback(RequestContext<List<T>> context,
+ Class<?> requestType,
+ DeviceContext deviceContext,
+ EventIdentifier eventIdentifier) {
super(context, requestType, deviceContext, eventIdentifier);
}
protected boolean isReqMore(T result) {
return MultipartReply.class.cast(result).isRequestMore();
}
-
}
Futures.addCallback(handleServiceCall(input), new FutureCallback<RpcResult<List<MultipartReply>>>() {
@Override
+ @SuppressWarnings("checkstyle:IllegalCatch")
public void onSuccess(final RpcResult<List<MultipartReply>> result) {
if (result.isSuccessful()) {
final List<MultipartReply> multipartReplies = result.getResult();
} else {
finalFuture.set(RpcResultBuilder
.success(new UpdateTableOutputBuilder()
- .setTransactionId(new TransactionId(BigInteger.valueOf(multipartReplies.get(0).getXid())))
+ .setTransactionId(
+ new TransactionId(BigInteger.valueOf(multipartReplies.get(0).getXid())))
.build())
.build());
}
}
} else {
- LOG.debug("OnSuccess, rpc result unsuccessful, multipart response for rpc update-table was unsuccessful.");
+ LOG.debug("OnSuccess, rpc result unsuccessful,"
+ + " multipart response for rpc update-table was unsuccessful.");
finalFuture.set(RpcResultBuilder.<UpdateTableOutput>failed().withRpcErrors(result.getErrors())
.build());
}
}
@Override
- public void onFailure(Throwable t) {
- LOG.error("Failure multipart response for table features request. Exception: {}", t);
+ public void onFailure(Throwable throwable) {
+ LOG.error("Failure multipart response for table features request. Exception: {}", throwable);
finalFuture.set(RpcResultBuilder.<UpdateTableOutput>failed()
- .withError(ErrorType.RPC, "Future error", t).build());
+ .withError(ErrorType.RPC, "Future error", throwable).build());
}
});
return finalFuture;
}
-
}
\ No newline at end of file
}
- public static <T> ListenableFuture<RpcResult<T>> closeRequestContextWithRpcError(final RequestContext<T> requestContext,
- final String errorMessage) {
+ public static <T> ListenableFuture<RpcResult<T>> closeRequestContextWithRpcError(
+ final RequestContext<T> requestContext,
+ final String errorMessage) {
RpcResultBuilder<T> rpcResultBuilder = RpcResultBuilder.<T>failed().withRpcError(RpcResultBuilder
.newError(RpcError.ErrorType.APPLICATION, "", errorMessage));
requestContext.setResult(rpcResultBuilder.build());
return requestContext.getFuture();
}
+ @SuppressWarnings("checkstyle:IllegalCatch")
public static void closeRequestContext(final RequestContext<?> requestContext) {
try {
requestContext.close();
package org.opendaylight.openflowplugin.impl.services.util;
/**
- * Exception thrown by {@link org.opendaylight.openflowplugin.impl.services.AbstractService#buildRequest(org.opendaylight.openflowplugin.api.openflow.device.Xid, Object)}
+ * Exception thrown by {@link org.opendaylight.openflowplugin.impl.services.AbstractService#buildRequest(
+ * org.opendaylight.openflowplugin.api.openflow.device.Xid, Object)}.
*/
public class ServiceException extends Exception {
public ServiceException(Throwable cause) {
* @param deviceInfo device info
* @param nrOfTables number of tables
*/
- @SuppressWarnings("checkstyle:IllegalCatch")
public static void makeEmptyTables(final TxFacade txFacade, final DeviceInfo deviceInfo, final short nrOfTables) {
if (LOG.isDebugEnabled()) {
LOG.debug("About to create {} empty tables for node {}.", nrOfTables, deviceInfo.getLOGValue());
}
for (int i = 0; i < nrOfTables; i++) {
- try {
- txFacade.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
- deviceInfo
- .getNodeInstanceIdentifier()
- .augmentation(FlowCapableNode.class)
- .child(Table.class, new TableKey((short) i)),
- new TableBuilder()
- .setId((short) i)
- .addAugmentation(
- FlowTableStatisticsData.class,
- new FlowTableStatisticsDataBuilder().build())
- .build());
- } catch (final Exception e) {
- LOG.debug("makeEmptyTables: Failed to write node {} to DS ", deviceInfo.getLOGValue(), e);
- }
+ txFacade.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
+ deviceInfo
+ .getNodeInstanceIdentifier()
+ .augmentation(FlowCapableNode.class)
+ .child(Table.class, new TableKey((short) i)),
+ new TableBuilder()
+ .setId((short) i)
+ .addAugmentation(
+ FlowTableStatisticsData.class,
+ new FlowTableStatisticsDataBuilder().build())
+ .build());
}
}
private static final Class<?> DUMMY_REQUEST_TYPE = String.class;
private static final String DUMMY_DEVICE_ID = "DEVICE ID";
private static final String DUMMY_EVENT_NAME = "EVENT NAME";
- private static final EventIdentifier DUMMY_EVENT_IDENTIFIER = new EventIdentifier(DUMMY_EVENT_NAME, DUMMY_DEVICE_ID);
+ private static final EventIdentifier DUMMY_EVENT_IDENTIFIER =
+ new EventIdentifier(DUMMY_EVENT_NAME, DUMMY_DEVICE_ID);
private static final String DUMMY_EXCEPTION_DESCRIPTION = "dummy exception description";
private static final Long DUMMY_XID = 100L;
private static final String DUMMY_MESSAGE_ILLEGAL_STATE_EXCEPTION = "dummy illegal state exception";
DUMMY_REQUEST_TYPE, new MessageIntelligenceAgencyImpl(),
DUMMY_EVENT_IDENTIFIER) {
@Override
- public void onSuccess(Object o) {
+ public void onSuccess(Object object) {
}
@Test
public void testOnFailureWithDeviceRequestFailedException() throws Exception {
ErrorMessage dummyErrorMessage = new ErrorMessageBuilder().build();
- abstractRequestCallback.onFailure(new DeviceRequestFailedException(DUMMY_EXCEPTION_DESCRIPTION, dummyErrorMessage));
+ abstractRequestCallback
+ .onFailure(new DeviceRequestFailedException(DUMMY_EXCEPTION_DESCRIPTION, dummyErrorMessage));
final ListenableFuture futureResult = dummyRequestContext.getFuture();
RpcError rpcError = provideRpcError(futureResult);
@Test
public void testOnFailure() throws Exception {
- ErrorMessage dummyErrorMessage = new ErrorMessageBuilder().build();
abstractRequestCallback.onFailure(new IllegalStateException(DUMMY_MESSAGE_ILLEGAL_STATE_EXCEPTION));
final ListenableFuture futureResult = dummyRequestContext.getFuture();
RpcError rpcError = provideRpcError(futureResult);
assertEquals(DUMMY_MESSAGE_ILLEGAL_STATE_EXCEPTION, rpcError.getMessage());
-
}
- private RpcError provideRpcError(ListenableFuture futureResult) throws InterruptedException, java.util.concurrent.ExecutionException {
+ private RpcError provideRpcError(ListenableFuture futureResult) throws InterruptedException,
+ java.util.concurrent.ExecutionException {
final Object result = futureResult.get();
assertTrue(result instanceof RpcResult);
RpcResult rpcResult = (RpcResult) result;
assertTrue(error instanceof RpcError);
return (RpcError) error;
}
-
-
}
final OngoingStubbing<MultiMsgCollector<MultipartReply>> when =
Mockito.when(deviceContext.getMultiMsgCollector(Matchers.any()));
when.thenReturn(multiMsgCollector);
- multipartRequestCallback = new MultiLayerMultipartRequestCallback<>(requestContext, MultipartRequestInput.class, deviceContext, null);
+ multipartRequestCallback = new MultiLayerMultipartRequestCallback<>(requestContext,
+ MultipartRequestInput.class,
+ deviceContext,
+ null);
}
/**
- * end collecting
- *
- * @throws Exception
+ * End collecting.
*/
@Test
public void testOnSuccess1() throws Exception {
}
/**
- * fail adding to collection
- *
- * @throws Exception
+ * Fail adding to collection.
*/
@Test
public void testOnSuccess2() throws Exception {
}
/**
- * successfully added to collection
- *
- * @throws Exception
+ * Successfully added to collection.
*/
@Test
public void testOnSuccess3() throws Exception {
final MultipartReplyMessage replyMessage = new MultipartReplyMessageBuilder().build();
multipartRequestCallback.onSuccess(replyMessage);
- Mockito.verify(multiMsgCollector).addMultipartMsg(Matchers.eq(replyMessage), Matchers.eq(false), Matchers.any());
+ Mockito.verify(multiMsgCollector)
+ .addMultipartMsg(Matchers.eq(replyMessage), Matchers.eq(false), Matchers.any());
}
}
import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
-import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
-import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.DeviceFlowRegistry;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowRegistryKey;
@Mock
private DeviceContext mockedDeviceContext;
@Mock
- private RequestContext<List<MultipartReply>> mockedRequestContext;
- @Mock
private ConnectionContext mockedPrimaryConnection;
@Mock
private NodeId mockedNodeId;
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
when(mockedDeviceContext.getDeviceInfo()).thenReturn(mockedDeviceInfo);
when(mockedDeviceContext.getDeviceFlowRegistry()).thenReturn(mockedFlowRegistry);
- when(mockedFlowRegistry.retrieveDescriptor(Matchers.any(FlowRegistryKey.class))).thenReturn(mockedFlowDescriptor);
+ when(mockedFlowRegistry.retrieveDescriptor(Matchers.any(FlowRegistryKey.class)))
+ .thenReturn(mockedFlowDescriptor);
- final InstanceIdentifier<FlowCapableNode> nodePath = mockedDeviceInfo.getNodeInstanceIdentifier().augmentation(FlowCapableNode.class);
+ final InstanceIdentifier<FlowCapableNode> nodePath =
+ mockedDeviceInfo.getNodeInstanceIdentifier().augmentation(FlowCapableNode.class);
final FlowCapableNodeBuilder flowNodeBuilder = new FlowCapableNodeBuilder();
- flowNodeBuilder.setTable(Collections.<Table> emptyList());
+ flowNodeBuilder.setTable(Collections.<Table>emptyList());
final Optional<FlowCapableNode> flowNodeOpt = Optional.of(flowNodeBuilder.build());
- final CheckedFuture<Optional<FlowCapableNode>, ReadFailedException> flowNodeFuture = Futures.immediateCheckedFuture(flowNodeOpt);
+ final CheckedFuture<Optional<FlowCapableNode>, ReadFailedException> flowNodeFuture =
+ Futures.immediateCheckedFuture(flowNodeOpt);
when(mockedReadOnlyTx.read(LogicalDatastoreType.OPERATIONAL, nodePath)).thenReturn(flowNodeFuture);
when(mockedDeviceContext.getReadTransaction()).thenReturn(mockedReadOnlyTx);
@Test
public void testOnSuccessWithNull() throws Exception {
multipartRequestOnTheFlyCallback.onSuccess(null);
- final RpcResult<List<MultipartReply>> expectedRpcResult = RpcResultBuilder.success(Collections.<MultipartReply>emptyList()).build();
+ final RpcResult<List<MultipartReply>> expectedRpcResult =
+ RpcResultBuilder.success(Collections.<MultipartReply>emptyList()).build();
final RpcResult<List<MultipartReply>> actualResult = dummyRequestContext.getFuture().get();
assertEquals(expectedRpcResult.getErrors(), actualResult.getErrors());
assertEquals(expectedRpcResult.getResult(), actualResult.getResult());
assertEquals(1, actualResult.getErrors().size());
final RpcError actualError = actualResult.getErrors().iterator().next();
- assertEquals(actualError.getMessage(), String.format("Unexpected response type received: %s.", mockedHelloMessage.getClass()));
+ assertEquals(actualError.getMessage(),
+ String.format("Unexpected response type received: %s.",
+ mockedHelloMessage.getClass()));
assertEquals(actualError.getErrorType(),RpcError.ErrorType.APPLICATION);
assertEquals(expectedRpcResult.getResult(), actualResult.getResult());
assertEquals(expectedRpcResult.isSuccessful(), actualResult.isSuccessful());
- Mockito.verify(mockedDeviceContext, Mockito.never()).writeToTransaction(Matchers.eq(LogicalDatastoreType.OPERATIONAL),
+ Mockito.verify(mockedDeviceContext, Mockito.never())
+ .writeToTransaction(Matchers.eq(LogicalDatastoreType.OPERATIONAL),
Matchers.<InstanceIdentifier>any(), Matchers.<DataObject>any());
Mockito.verify(mockedDeviceContext).submitTransaction();
}
/**
- * not the last reply
- *
- * @throws ExecutionException
- * @throws InterruptedException
+ * Not the last reply.
*/
@Test
public void testOnSuccessWithValidMultipart1() throws Exception {
}
/**
- * the last reply
- *
- * @throws ExecutionException
- * @throws InterruptedException
+ * The last reply.
*/
@Test
public void testOnSuccessWithValidMultipart2() throws Exception {
assertNotNull(actualResult.getErrors());
assertFalse(actualResult.getErrors().isEmpty());
Mockito.verify(mockedFlowRegistry, Mockito.never()).store(Matchers.any());
- Mockito.verify(mockedDeviceContext, Mockito.never()).writeToTransaction(Matchers.eq(LogicalDatastoreType.OPERATIONAL),
+ Mockito.verify(mockedDeviceContext, Mockito.never())
+ .writeToTransaction(Matchers.eq(LogicalDatastoreType.OPERATIONAL),
Matchers.<InstanceIdentifier>any(), Matchers.<DataObject>any());
}
}
when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockedPrimConnectionContext);
when(mockedDeviceContext.getMessageSpy()).thenReturn(mockedMessagSpy);
- when(mockedDeviceContext.getDeviceFlowRegistry()).thenReturn(new DeviceFlowRegistryImpl(DUMMY_VERSION, dataBroker, DUMMY_NODE_II));
+ when(mockedDeviceContext.getDeviceFlowRegistry())
+ .thenReturn(new DeviceFlowRegistryImpl(DUMMY_VERSION, dataBroker, DUMMY_NODE_II));
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
when(mockedDeviceContext.getDeviceInfo()).thenReturn(mockedDeviceInfo);
when(mockedDeviceContext.getMultiMsgCollector(Matchers.any())).thenReturn(multiMessageCollector);
}
protected <T> void mockSuccessfulFuture() {
- ListenableFuture<RpcResult<T>> dummySuccessfulFuture = Futures.immediateFuture(RpcResultBuilder.success((T) null).build());
+ ListenableFuture<RpcResult<T>> dummySuccessfulFuture =
+ Futures.immediateFuture(RpcResultBuilder.success((T) null).build());
when(mockedRequestContext.getFuture()).thenReturn(dummySuccessfulFuture);
}
createRemoveFlowBatch("1"),
createRemoveFlowBatch("2")));
- final RemoveFlowsBatchInput removeFlowsBatchInput = FlatBatchFlowAdapters.adaptFlatBatchRemoveFlow(planStep, NODE_REF);
+ final RemoveFlowsBatchInput removeFlowsBatchInput =
+ FlatBatchFlowAdapters.adaptFlatBatchRemoveFlow(planStep, NODE_REF);
Assert.assertTrue(removeFlowsBatchInput.isBarrierAfter());
Assert.assertEquals(2, removeFlowsBatchInput.getBatchRemoveFlows().size());
createUpdateFlowBatch("1"),
createUpdateFlowBatch("2")));
- final UpdateFlowsBatchInput updateFlowsBatchInput = FlatBatchFlowAdapters.adaptFlatBatchUpdateFlow(planStep, NODE_REF);
+ final UpdateFlowsBatchInput updateFlowsBatchInput =
+ FlatBatchFlowAdapters.adaptFlatBatchUpdateFlow(planStep, NODE_REF);
Assert.assertTrue(updateFlowsBatchInput.isBarrierAfter());
Assert.assertEquals(2, updateFlowsBatchInput.getBatchUpdateFlows().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());
+ Assert.assertEquals("f2",
+ ((FlatBatchFailureFlowIdCase) rpcResult.getResult().getBatchFailure().get(1).getBatchItemIdChoice())
+ .getFlowId().getValue());
}
@Test
createAddGroupBatch(1L),
createAddGroupBatch(2L)));
- final AddGroupsBatchInput addGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchAddGroup(planStep, NODE_REF);
+ final AddGroupsBatchInput addGroupsBatchInput =
+ FlatBatchGroupAdapters.adaptFlatBatchAddGroup(planStep, NODE_REF);
Assert.assertTrue(addGroupsBatchInput.isBarrierAfter());
Assert.assertEquals(2, addGroupsBatchInput.getBatchAddGroups().size());
createRemoveGroupBatch(1L),
createRemoveGroupBatch(2L)));
- final RemoveGroupsBatchInput removeGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchRemoveGroup(planStep, NODE_REF);
+ final RemoveGroupsBatchInput removeGroupsBatchInput =
+ FlatBatchGroupAdapters.adaptFlatBatchRemoveGroup(planStep, NODE_REF);
Assert.assertTrue(removeGroupsBatchInput.isBarrierAfter());
Assert.assertEquals(2, removeGroupsBatchInput.getBatchRemoveGroups().size());
- Assert.assertEquals(1L, removeGroupsBatchInput.getBatchRemoveGroups().get(0).getGroupId().getValue().longValue());
- Assert.assertEquals(2L, removeGroupsBatchInput.getBatchRemoveGroups().get(1).getGroupId().getValue().longValue());
+ Assert.assertEquals(1L,
+ removeGroupsBatchInput.getBatchRemoveGroups().get(0).getGroupId().getValue().longValue());
+ Assert.assertEquals(2L,
+ removeGroupsBatchInput.getBatchRemoveGroups().get(1).getGroupId().getValue().longValue());
}
@Test
createUpdateGroupBatch(1L),
createUpdateGroupBatch(2L)));
- final UpdateGroupsBatchInput updateGroupsBatchInput = FlatBatchGroupAdapters.adaptFlatBatchUpdateGroup(planStep, NODE_REF);
+ final UpdateGroupsBatchInput updateGroupsBatchInput =
+ FlatBatchGroupAdapters.adaptFlatBatchUpdateGroup(planStep, NODE_REF);
Assert.assertTrue(updateGroupsBatchInput.isBarrierAfter());
Assert.assertEquals(2, updateGroupsBatchInput.getBatchUpdateGroups().size());
- Assert.assertEquals(1L, updateGroupsBatchInput.getBatchUpdateGroups().get(0).getUpdatedBatchedGroup().getGroupId().getValue().longValue());
- Assert.assertEquals(2L, updateGroupsBatchInput.getBatchUpdateGroups().get(1).getUpdatedBatchedGroup().getGroupId().getValue().longValue());
+ Assert.assertEquals(1L, updateGroupsBatchInput.getBatchUpdateGroups().get(0)
+ .getUpdatedBatchedGroup().getGroupId().getValue().longValue());
+ Assert.assertEquals(2L, updateGroupsBatchInput.getBatchUpdateGroups().get(1)
+ .getUpdatedBatchedGroup().getGroupId().getValue().longValue());
}
@Test
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());
+ Assert.assertEquals(2L, ((FlatBatchFailureGroupIdCase) rpcResult.getResult().getBatchFailure().get(1)
+ .getBatchItemIdChoice()).getGroupId().getValue().longValue());
}
@Test
createAddMeterBatch(1L),
createAddMeterBatch(2L)));
- final AddMetersBatchInput addMetersBatchInput = FlatBatchMeterAdapters.adaptFlatBatchAddMeter(planStep, NODE_REF);
+ final AddMetersBatchInput addMetersBatchInput =
+ FlatBatchMeterAdapters.adaptFlatBatchAddMeter(planStep, NODE_REF);
Assert.assertTrue(addMetersBatchInput.isBarrierAfter());
Assert.assertEquals(2, addMetersBatchInput.getBatchAddMeters().size());
createRemoveMeterBatch(1L),
createRemoveMeterBatch(2L)));
- final RemoveMetersBatchInput removeMetersBatchInput = FlatBatchMeterAdapters.adaptFlatBatchRemoveMeter(planStep, NODE_REF);
+ final RemoveMetersBatchInput removeMetersBatchInput =
+ FlatBatchMeterAdapters.adaptFlatBatchRemoveMeter(planStep, NODE_REF);
Assert.assertTrue(removeMetersBatchInput.isBarrierAfter());
Assert.assertEquals(2, removeMetersBatchInput.getBatchRemoveMeters().size());
- Assert.assertEquals(1L, removeMetersBatchInput.getBatchRemoveMeters().get(0).getMeterId().getValue().longValue());
- Assert.assertEquals(2L, removeMetersBatchInput.getBatchRemoveMeters().get(1).getMeterId().getValue().longValue());
+ Assert.assertEquals(1L,
+ removeMetersBatchInput.getBatchRemoveMeters().get(0).getMeterId().getValue().longValue());
+ Assert.assertEquals(2L,
+ removeMetersBatchInput.getBatchRemoveMeters().get(1).getMeterId().getValue().longValue());
}
@Test
createUpdateMeterBatch(1L),
createUpdateMeterBatch(2L)));
- final UpdateMetersBatchInput updateMetersBatchInput = FlatBatchMeterAdapters.adaptFlatBatchUpdateMeter(planStep, NODE_REF);
+ final UpdateMetersBatchInput updateMetersBatchInput =
+ FlatBatchMeterAdapters.adaptFlatBatchUpdateMeter(planStep, NODE_REF);
Assert.assertTrue(updateMetersBatchInput.isBarrierAfter());
Assert.assertEquals(2, updateMetersBatchInput.getBatchUpdateMeters().size());
- Assert.assertEquals(1L, updateMetersBatchInput.getBatchUpdateMeters().get(0).getUpdatedBatchedMeter().getMeterId().getValue().longValue());
- Assert.assertEquals(2L, updateMetersBatchInput.getBatchUpdateMeters().get(1).getUpdatedBatchedMeter().getMeterId().getValue().longValue());
+ Assert.assertEquals(1L, updateMetersBatchInput.getBatchUpdateMeters().get(0)
+ .getUpdatedBatchedMeter().getMeterId().getValue().longValue());
+ Assert.assertEquals(2L, updateMetersBatchInput.getBatchUpdateMeters().get(1)
+ .getUpdatedBatchedMeter().getMeterId().getValue().longValue());
}
@Test
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());
+ Assert.assertEquals(2L, ((FlatBatchFailureMeterIdCase) rpcResult.getResult().getBatchFailure().get(1)
+ .getBatchItemIdChoice()).getMeterId().getValue().longValue());
}
@Test
import org.junit.Test;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.services.ServiceMocking;
-import org.opendaylight.openflowplugin.impl.services.sal.FlowCapableTransactionServiceImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
@Override
protected void setup() {
- flowCapableTransactionService = new FlowCapableTransactionServiceImpl(mockedRequestContextStack, mockedDeviceContext);
+ flowCapableTransactionService =
+ new FlowCapableTransactionServiceImpl(mockedRequestContextStack, mockedDeviceContext);
}
@Test
import org.junit.Test;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.openflowplugin.impl.services.ServiceMocking;
-import org.opendaylight.openflowplugin.impl.services.sal.NodeConfigServiceImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.module.config.rev141015.SetConfigInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.module.config.rev141015.SetConfigInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.SwitchConfigFlag;
nodeConfigService = new NodeConfigServiceImpl(mockedRequestContextStack, mockedDeviceContext);
final OfHeader request = nodeConfigService.buildRequest(new Xid(DUMMY_XID_VALUE), dummyConfigInput());
- assertTrue(request instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.SetConfigInput);
+ assertTrue(request instanceof org.opendaylight.yang.gen.v1.urn
+ .opendaylight.openflow.protocol.rev130731.SetConfigInput);
org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.SetConfigInput setConfigInput
= (org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.SetConfigInput) request;
assertEquals(DUMMY_FLAG,setConfigInput.getFlags());
assertEquals(DUMMY_XID_VALUE, setConfigInput.getXid());
}
- private SetConfigInput dummyConfigInput(){
+ private SetConfigInput dummyConfigInput() {
SetConfigInputBuilder setConfigInputBuilder = new SetConfigInputBuilder();
setConfigInputBuilder.setFlag(DUMMY_FLAG_STR);
setConfigInputBuilder.setMissSearchLength(DUMMY_MISS_SEARCH_LENGTH);
@Override
protected void setup() {
final ConvertorManager convertorManager = ConvertorManagerFactory.createDefaultManager();
- packetProcessingService = new PacketProcessingServiceImpl(mockedRequestContextStack, mockedDeviceContext, convertorManager);
+ packetProcessingService =
+ new PacketProcessingServiceImpl(mockedRequestContextStack, mockedDeviceContext, convertorManager);
pathToNodeconnector = KeyedInstanceIdentifier.create(Nodes.class)
.child(Node.class, new NodeKey(new NodeId("ofp-ut:123")))
.child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId("ofp-ut:123:1")));
import org.mockito.Matchers;
import org.mockito.Mockito;
import org.opendaylight.openflowplugin.impl.services.ServiceMocking;
-import org.opendaylight.openflowplugin.impl.services.sal.SalEchoServiceImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.echo.service.rev150305.SendEchoInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.echo.service.rev150305.SendEchoInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.echo.service.rev150305.SendEchoOutput;
Assert.assertTrue(echoOutput.isDone());
Assert.assertTrue(echoOutput.get().isSuccessful());
verify(mockedRequestContextStack).createRequestContext();
- verify(mockedOutboundQueue).commitEntry(Matchers.eq(2121L), Matchers.<OfHeader>any(), Matchers.<FutureCallback<OfHeader>>any());
+ verify(mockedOutboundQueue)
+ .commitEntry(Matchers.eq(2121L), Matchers.<OfHeader>any(), Matchers.<FutureCallback<OfHeader>>any());
}
}
@Override
protected void setup() {
- salExperimenterMessageService = new SalExperimenterMessageServiceImpl(mockedRequestContextStack, mockedDeviceContext, extensionConverterProvider);
+ salExperimenterMessageService = new SalExperimenterMessageServiceImpl(mockedRequestContextStack,
+ mockedDeviceContext,
+ extensionConverterProvider);
Mockito.when(extensionConverterProvider.getMessageConverter(Matchers.<TypeVersionKey>any()))
.thenReturn(extensionConverter);
Mockito.when(extensionConverter.getExperimenterId()).thenReturn(new ExperimenterId(43L));
public void testBuildRequest() throws Exception {
SendExperimenterInput sendExperimenterInput = buildSendExperimenterInput();
- final OfHeader request = salExperimenterMessageService.buildRequest(new Xid(DUMMY_XID_VALUE), sendExperimenterInput);
+ final OfHeader request =
+ salExperimenterMessageService.buildRequest(new Xid(DUMMY_XID_VALUE), sendExperimenterInput);
assertEquals(DUMMY_XID_VALUE, request.getXid());
assertTrue(request instanceof ExperimenterInput);
final ExperimenterInput input = (ExperimenterInput) request;
return DummyExperimenter.class;
}
}
-
}
@Before
public void setUp() throws Exception {
- salFlatBatchService = new SalFlatBatchServiceImpl(salFlowsBatchService, salGroupsBatchService, salMetersBatchService);
+ salFlatBatchService =
+ new SalFlatBatchServiceImpl(salFlowsBatchService, salGroupsBatchService, salMetersBatchService);
}
.setExitOnFirstError(true)
.build();
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture = salFlatBatchService.processFlatBatch(batchInput);
+ final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
+ salFlatBatchService.processFlatBatch(batchInput);
Assert.assertTrue(rpcResultFuture.isDone());
final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
Assert.assertTrue(rpcResult.isSuccessful());
.setExitOnFirstError(true)
.build();
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture = salFlatBatchService.processFlatBatch(batchInput);
+ final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
+ salFlatBatchService.processFlatBatch(batchInput);
Assert.assertTrue(rpcResultFuture.isDone());
final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
Assert.assertFalse(rpcResult.isSuccessful());
.setExitOnFirstError(false)
.build();
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture = salFlatBatchService.processFlatBatch(batchInput);
+ final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
+ salFlatBatchService.processFlatBatch(batchInput);
Assert.assertTrue(rpcResultFuture.isDone());
final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
Assert.assertFalse(rpcResult.isSuccessful());
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);
+ 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);
Mockito.when(batchStepJob1.getPlanStep()).thenReturn(batchPlanStep1);
Mockito.when(batchStepJob2.getPlanStep()).thenReturn(batchPlanStep2);
- final ListenableFuture<RpcResult<ProcessFlatBatchOutput>> succeededChainOutput = FlatBatchUtil.createEmptyRpcBatchResultFuture(true);
+ final ListenableFuture<RpcResult<ProcessFlatBatchOutput>> succeededChainOutput =
+ FlatBatchUtil.createEmptyRpcBatchResultFuture(true);
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(batchStepJob1.getStepFunction().apply(Matchers.<RpcResult<ProcessFlatBatchOutput>>any()))
.thenReturn(failedChainOutput);
final List<BatchStepJob> batchChainElements = Lists.newArrayList(batchStepJob1, batchStepJob2);
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture = salFlatBatchService.executeBatchPlan(batchChainElements);
+ final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
+ salFlatBatchService.executeBatchPlan(batchChainElements);
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("f2", ((FlatBatchFailureFlowIdCase) rpcResult.getResult().getBatchFailure().get(1).getBatchItemIdChoice()).getFlowId().getValue());
+ Assert.assertEquals("f2",
+ ((FlatBatchFailureFlowIdCase) rpcResult.getResult().getBatchFailure().get(1).getBatchItemIdChoice())
+ .getFlowId().getValue());
}
private BatchFailure createFlowBatchFailure(final int batchOrder, final String flowIdValue) {
.success(new AddFlowsBatchOutputBuilder().build())
.buildFuture());
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture = salFlatBatchService.executeBatchPlan(batchChain);
+ final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
+ salFlatBatchService.executeBatchPlan(batchChain);
Assert.assertTrue(rpcResultFuture.isDone());
final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
Assert.assertTrue(rpcResult.isSuccessful());
.withError(RpcError.ErrorType.APPLICATION, "ut-addFlowBatchError")
.buildFuture());
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture = salFlatBatchService.executeBatchPlan(batchChain);
+ final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
+ salFlatBatchService.executeBatchPlan(batchChain);
Assert.assertTrue(rpcResultFuture.isDone());
final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
Assert.assertFalse(rpcResult.isSuccessful());
*/
package org.opendaylight.openflowplugin.impl.services.sal;
-
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.when;
.when(requestContext).getFuture();
mockingFlowRegistryLookup();
- final Future<RpcResult<AddFlowOutput>> rpcResultFuture = mockSalFlowService(version).addFlow(mockedAddFlowInput);
+ final Future<RpcResult<AddFlowOutput>> rpcResultFuture =
+ mockSalFlowService(version).addFlow(mockedAddFlowInput);
assertNotNull(rpcResultFuture);
final RpcResult<?> addFlowOutputRpcResult = rpcResultFuture.get();
Mockito.doReturn(Futures.<RequestContext<Object>>immediateFailedFuture(new Exception("ut-failed-response")))
.when(requestContext).getFuture();
- final Future<RpcResult<RemoveFlowOutput>> rpcResultFuture = mockSalFlowService(version).removeFlow(mockedRemoveFlowInput);
+ final Future<RpcResult<RemoveFlowOutput>> rpcResultFuture =
+ mockSalFlowService(version).removeFlow(mockedRemoveFlowInput);
assertNotNull(rpcResultFuture);
final RpcResult<?> removeFlowOutputRpcResult = rpcResultFuture.get();
addFlow(mock(ItemLifecycleListener.class), OFConstants.OFP_VERSION_1_3);
}
- private void addFlow(final ItemLifecycleListener itemLifecycleListener, short version) throws ExecutionException, InterruptedException {
+ private void addFlow(final ItemLifecycleListener itemLifecycleListener, short version) throws ExecutionException,
+ InterruptedException {
AddFlowInput mockedAddFlowInput = new AddFlowInputBuilder()
.setMatch(match)
.setTableId((short)1)
mockingFlowRegistryLookup();
verifyOutput(salFlowService.addFlow(mockedAddFlowInput));
if (itemLifecycleListener != null) {
- Mockito.verify(itemLifecycleListener).onAdded(Matchers.<KeyedInstanceIdentifier<Flow, FlowKey>>any(), Matchers.<Flow>any());
+ Mockito.verify(itemLifecycleListener)
+ .onAdded(Matchers.<KeyedInstanceIdentifier<Flow, FlowKey>>any(), Matchers.<Flow>any());
}
}
when(mockedUpdateFlowInput1.getUpdatedFlow()).thenReturn(mockedUpdateFlow1);
FlowRef mockedFlowRef = mock(FlowRef.class);
- Mockito.doReturn(TABLE_II.child(Flow.class, new FlowKey(new FlowId(DUMMY_FLOW_ID)))).when(mockedFlowRef).getValue();
+ Mockito.doReturn(TABLE_II.child(Flow.class,
+ new FlowKey(new FlowId(DUMMY_FLOW_ID)))).when(mockedFlowRef).getValue();
when(mockedUpdateFlowInput.getFlowRef()).thenReturn(mockedFlowRef);
when(mockedUpdateFlowInput1.getFlowRef()).thenReturn(mockedFlowRef);
verifyOutput(salFlowService.updateFlow(mockedUpdateFlowInput1));
if (itemLifecycleListener != null) {
- Mockito.verify(itemLifecycleListener, times(2)).onUpdated(Matchers.<KeyedInstanceIdentifier<Flow, FlowKey>>any(), Matchers.<Flow>any());
+ Mockito.verify(itemLifecycleListener, times(2))
+ .onUpdated(Matchers.<KeyedInstanceIdentifier<Flow, FlowKey>>any(), Matchers.<Flow>any());
}
}
when(mockedFlowDescriptor.getFlowId()).thenReturn(flowId);
when(mockedFlowDescriptor.getTableKey()).thenReturn(new TableKey(DUMMY_TABLE_ID));
- when(deviceFlowRegistry.retrieveDescriptor(Matchers.any(FlowRegistryKey.class))).thenReturn(mockedFlowDescriptor);
+ when(deviceFlowRegistry
+ .retrieveDescriptor(Matchers.any(FlowRegistryKey.class))).thenReturn(mockedFlowDescriptor);
}
- private <T extends DataObject> void verifyOutput(Future<RpcResult<T>> rpcResultFuture) throws ExecutionException, InterruptedException {
+ private <T extends DataObject> void verifyOutput(Future<RpcResult<T>> rpcResultFuture) throws ExecutionException,
+ InterruptedException {
assertNotNull(rpcResultFuture);
final RpcResult<?> addFlowOutputRpcResult = rpcResultFuture.get();
assertNotNull(addFlowOutputRpcResult);
public static final NodeId NODE_ID = new NodeId("ut-dummy-node");
public static final NodeKey NODE_KEY = new NodeKey(NODE_ID);
- public static final NodeRef NODE_REF = new NodeRef(InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY));
+ public static final NodeRef NODE_REF =
+ new NodeRef(InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY));
@Mock
private SalFlowService salFlowService;
@Test
public void testAddFlowsBatch_failed() throws Exception {
Mockito.when(salFlowService.addFlow(Matchers.<AddFlowInput>any()))
- .thenReturn(RpcResultBuilder.<AddFlowOutput>failed().withError(RpcError.ErrorType.APPLICATION, "ut-groupAddError")
+ .thenReturn(RpcResultBuilder
+ .<AddFlowOutput>failed().withError(RpcError.ErrorType.APPLICATION, "ut-groupAddError")
.buildFuture());
final AddFlowsBatchInput input = new AddFlowsBatchInputBuilder()
Assert.assertTrue(resultFuture.isDone());
Assert.assertFalse(resultFuture.get().isSuccessful());
Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedFlowsOutput().size());
- Assert.assertEquals(FLOW_ID_VALUE_1, resultFuture.get().getResult().getBatchFailedFlowsOutput().get(0).getFlowId().getValue());
- Assert.assertEquals(FLOW_ID_VALUE_2, resultFuture.get().getResult().getBatchFailedFlowsOutput().get(1).getFlowId().getValue());
+ Assert.assertEquals(FLOW_ID_VALUE_1,
+ resultFuture.get().getResult().getBatchFailedFlowsOutput().get(0).getFlowId().getValue());
+ Assert.assertEquals(FLOW_ID_VALUE_2,
+ resultFuture.get().getResult().getBatchFailedFlowsOutput().get(1).getFlowId().getValue());
Assert.assertEquals(2, resultFuture.get().getErrors().size());
final InOrder inOrder = Mockito.inOrder(salFlowService, transactionService);
@Test
public void testUpdateFlowsBatch_failure() throws Exception {
Mockito.when(salFlowService.updateFlow(Matchers.<UpdateFlowInput>any()))
- .thenReturn(RpcResultBuilder.<UpdateFlowOutput>failed().withError(RpcError.ErrorType.APPLICATION, "ut-flowUpdateError")
+ .thenReturn(RpcResultBuilder.<UpdateFlowOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, "ut-flowUpdateError")
.buildFuture());
final UpdateFlowsBatchInput input = new UpdateFlowsBatchInputBuilder()
Assert.assertFalse(resultFuture.get().isSuccessful());
Assert.assertFalse(resultFuture.get().isSuccessful());
Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedFlowsOutput().size());
- Assert.assertEquals(FLOW_ID_VALUE_1, resultFuture.get().getResult().getBatchFailedFlowsOutput().get(0).getFlowId().getValue());
- Assert.assertEquals(FLOW_ID_VALUE_2, resultFuture.get().getResult().getBatchFailedFlowsOutput().get(1).getFlowId().getValue());
+ Assert.assertEquals(FLOW_ID_VALUE_1,
+ resultFuture.get().getResult().getBatchFailedFlowsOutput().get(0).getFlowId().getValue());
+ Assert.assertEquals(FLOW_ID_VALUE_2,
+ resultFuture.get().getResult().getBatchFailedFlowsOutput().get(1).getFlowId().getValue());
Assert.assertEquals(2, resultFuture.get().getErrors().size());
final InOrder inOrder = Mockito.inOrder(salFlowService, transactionService);
verify(mockedDeviceGroupRegistry).store(eq(dummyGroupId));
if (itemLifecycleListener != null) {
- verify(itemLifecycleListener).onAdded(Matchers.<KeyedInstanceIdentifier<Group, GroupKey>>any(),Matchers.<Group>any());
+ verify(itemLifecycleListener)
+ .onAdded(Matchers.<KeyedInstanceIdentifier<Group, GroupKey>>any(),Matchers.<Group>any());
}
}
private void updateGroup(final ItemLifecycleListener itemLifecycleListener) {
final UpdatedGroup updatedGroup = new UpdatedGroupBuilder().setGroupId(new GroupId(DUMMY_GROUP_ID)).build();
final OriginalGroup originalGroup = new OriginalGroupBuilder().setGroupId(new GroupId(DUMMY_GROUP_ID)).build();
- final UpdateGroupInput updateGroupInput = new UpdateGroupInputBuilder().setUpdatedGroup(updatedGroup).setOriginalGroup(originalGroup).build();
+ final UpdateGroupInput updateGroupInput =
+ new UpdateGroupInputBuilder().setUpdatedGroup(updatedGroup).setOriginalGroup(originalGroup).build();
this.<UpdateGroupOutput>mockSuccessfulFuture();
verify(mockedRequestContextStack).createRequestContext();
if (itemLifecycleListener != null) {
- verify(itemLifecycleListener).onAdded(Matchers.<KeyedInstanceIdentifier<Group, GroupKey>>any(),Matchers.<Group>any());
+ verify(itemLifecycleListener)
+ .onAdded(Matchers.<KeyedInstanceIdentifier<Group, GroupKey>>any(),Matchers.<Group>any());
verify(itemLifecycleListener).onRemoved(Matchers.<KeyedInstanceIdentifier<Group, GroupKey>>any());
}
}
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.openflowplugin.impl.services.sal.SalGroupsBatchServiceImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.FlowCapableTransactionService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupInput;
public static final NodeId NODE_ID = new NodeId("ut-dummy-node");
public static final NodeKey NODE_KEY = new NodeKey(NODE_ID);
- public static final NodeRef NODE_REF = new NodeRef(InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY));
+ public static final NodeRef NODE_REF =
+ new NodeRef(InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY));
@Mock
private SalGroupService salGroupService;
Assert.assertTrue(resultFuture.isDone());
Assert.assertFalse(resultFuture.get().isSuccessful());
Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedGroupsOutput().size());
- Assert.assertEquals(43L, resultFuture.get().getResult().getBatchFailedGroupsOutput().get(0).getGroupId().getValue().longValue());
- Assert.assertEquals(45L, resultFuture.get().getResult().getBatchFailedGroupsOutput().get(1).getGroupId().getValue().longValue());
+ Assert.assertEquals(43L,
+ resultFuture.get().getResult().getBatchFailedGroupsOutput().get(0).getGroupId().getValue().longValue());
+ Assert.assertEquals(45L,
+ resultFuture.get().getResult().getBatchFailedGroupsOutput().get(1).getGroupId().getValue().longValue());
Assert.assertEquals(2, resultFuture.get().getErrors().size());
@Test
public void testAddGroupsBatch_failure() throws Exception {
Mockito.when(salGroupService.addGroup(Mockito.<AddGroupInput>any()))
- .thenReturn(RpcResultBuilder.<AddGroupOutput>failed().withError(RpcError.ErrorType.APPLICATION, "ut-groupAddError")
+ .thenReturn(RpcResultBuilder.<AddGroupOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, "ut-groupAddError")
.buildFuture());
final AddGroupsBatchInput input = new AddGroupsBatchInputBuilder()
Assert.assertTrue(resultFuture.isDone());
Assert.assertFalse(resultFuture.get().isSuccessful());
Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedGroupsOutput().size());
- Assert.assertEquals(42L, resultFuture.get().getResult().getBatchFailedGroupsOutput().get(0).getGroupId().getValue().longValue());
- Assert.assertEquals(43L, resultFuture.get().getResult().getBatchFailedGroupsOutput().get(1).getGroupId().getValue().longValue());
+ Assert.assertEquals(42L,
+ resultFuture.get().getResult().getBatchFailedGroupsOutput().get(0).getGroupId().getValue().longValue());
+ Assert.assertEquals(43L,
+ resultFuture.get().getResult().getBatchFailedGroupsOutput().get(1).getGroupId().getValue().longValue());
Assert.assertEquals(2, resultFuture.get().getErrors().size());
@Test
public void testRemoveGroupsBatch_failure() throws Exception {
Mockito.when(salGroupService.removeGroup(Mockito.<RemoveGroupInput>any()))
- .thenReturn(RpcResultBuilder.<RemoveGroupOutput>failed().withError(RpcError.ErrorType.APPLICATION, "ut-groupRemoveError")
+ .thenReturn(RpcResultBuilder.<RemoveGroupOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, "ut-groupRemoveError")
.buildFuture());
final RemoveGroupsBatchInput input = new RemoveGroupsBatchInputBuilder()
Assert.assertTrue(resultFuture.isDone());
Assert.assertFalse(resultFuture.get().isSuccessful());
Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedGroupsOutput().size());
- Assert.assertEquals(42L, resultFuture.get().getResult().getBatchFailedGroupsOutput().get(0).getGroupId().getValue().longValue());
- Assert.assertEquals(43L, resultFuture.get().getResult().getBatchFailedGroupsOutput().get(1).getGroupId().getValue().longValue());
+ Assert.assertEquals(42L,
+ resultFuture.get().getResult().getBatchFailedGroupsOutput().get(0).getGroupId().getValue().longValue());
+ Assert.assertEquals(43L,
+ resultFuture.get().getResult().getBatchFailedGroupsOutput().get(1).getGroupId().getValue().longValue());
Assert.assertEquals(2, resultFuture.get().getErrors().size());
final InOrder inOrder = Mockito.inOrder(salGroupService, transactionService);
private static BatchUpdateGroups createEmptyBatchUpdateGroup(final long groupIdValue) {
return new BatchUpdateGroupsBuilder()
- .setOriginalBatchedGroup(new OriginalBatchedGroupBuilder(createEmptyBatchAddGroup(groupIdValue)).build())
- .setUpdatedBatchedGroup(new UpdatedBatchedGroupBuilder(createEmptyBatchAddGroup(groupIdValue+1)).build())
+ .setOriginalBatchedGroup(
+ new OriginalBatchedGroupBuilder(createEmptyBatchAddGroup(groupIdValue)).build())
+ .setUpdatedBatchedGroup(
+ new UpdatedBatchedGroupBuilder(createEmptyBatchAddGroup(groupIdValue + 1)).build())
.build();
}
}
verify(mockedDeviceMeterRegistry).store(eq(dummyMeterId));
if (itemLifecycleListener != null) {
- verify(itemLifecycleListener).onAdded(Matchers.<KeyedInstanceIdentifier<Meter, MeterKey>>any(),Matchers.<Meter>any());
+ verify(itemLifecycleListener)
+ .onAdded(Matchers.<KeyedInstanceIdentifier<Meter, MeterKey>>any(),Matchers.<Meter>any());
}
}
}
private void updateMeter(final ItemLifecycleListener itemLifecycleListener) throws Exception {
- final UpdatedMeter dummyUpdatedMeter = new UpdatedMeterBuilder().setMeterId(new MeterId(DUMMY_METTER_ID)).build();
- final OriginalMeter dummyOriginalMeter = new OriginalMeterBuilder().setMeterId(new MeterId(DUMMY_METTER_ID)).build();
+ final UpdatedMeter dummyUpdatedMeter =
+ new UpdatedMeterBuilder().setMeterId(new MeterId(DUMMY_METTER_ID)).build();
+ final OriginalMeter dummyOriginalMeter =
+ new OriginalMeterBuilder().setMeterId(new MeterId(DUMMY_METTER_ID)).build();
- final UpdateMeterInput updateMeterInput = new UpdateMeterInputBuilder().setUpdatedMeter(dummyUpdatedMeter).setOriginalMeter(dummyOriginalMeter).build();
+ final UpdateMeterInput updateMeterInput = new UpdateMeterInputBuilder()
+ .setUpdatedMeter(dummyUpdatedMeter).setOriginalMeter(dummyOriginalMeter).build();
this.<AddMeterOutput>mockSuccessfulFuture();
verify(mockedRequestContextStack).createRequestContext();
if (itemLifecycleListener != null) {
- verify(itemLifecycleListener).onAdded(Matchers.<KeyedInstanceIdentifier<Meter, MeterKey>>any(),Matchers.<Meter>any());
+ verify(itemLifecycleListener)
+ .onAdded(Matchers.<KeyedInstanceIdentifier<Meter, MeterKey>>any(),Matchers.<Meter>any());
verify(itemLifecycleListener).onRemoved(Matchers.<KeyedInstanceIdentifier<Meter, MeterKey>>any());
}
}
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.openflowplugin.impl.services.sal.SalMetersBatchServiceImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.FlowCapableTransactionService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
public static final NodeId NODE_ID = new NodeId("ut-dummy-node");
public static final NodeKey NODE_KEY = new NodeKey(NODE_ID);
- public static final NodeRef NODE_REF = new NodeRef(InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY));
+ public static final NodeRef NODE_REF =
+ new NodeRef(InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY));
@Mock
private SalMeterService salMeterService;
Assert.assertTrue(resultFuture.isDone());
Assert.assertFalse(resultFuture.get().isSuccessful());
Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedMetersOutput().size());
- Assert.assertEquals(43L, resultFuture.get().getResult().getBatchFailedMetersOutput().get(0).getMeterId().getValue().longValue());
- Assert.assertEquals(45L, resultFuture.get().getResult().getBatchFailedMetersOutput().get(1).getMeterId().getValue().longValue());
+ Assert.assertEquals(43L,
+ resultFuture.get().getResult().getBatchFailedMetersOutput().get(0).getMeterId().getValue().longValue());
+ Assert.assertEquals(45L,
+ resultFuture.get().getResult().getBatchFailedMetersOutput().get(1).getMeterId().getValue().longValue());
Assert.assertEquals(2, resultFuture.get().getErrors().size());
@Test
public void testAddMetersBatch_failure() throws Exception {
Mockito.when(salMeterService.addMeter(Mockito.<AddMeterInput>any()))
- .thenReturn(RpcResultBuilder.<AddMeterOutput>failed().withError(RpcError.ErrorType.APPLICATION, "ut-groupAddError")
+ .thenReturn(RpcResultBuilder.<AddMeterOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, "ut-groupAddError")
.buildFuture());
final AddMetersBatchInput input = new AddMetersBatchInputBuilder()
Assert.assertTrue(resultFuture.isDone());
Assert.assertFalse(resultFuture.get().isSuccessful());
Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedMetersOutput().size());
- Assert.assertEquals(42L, resultFuture.get().getResult().getBatchFailedMetersOutput().get(0).getMeterId().getValue().longValue());
- Assert.assertEquals(43L, resultFuture.get().getResult().getBatchFailedMetersOutput().get(1).getMeterId().getValue().longValue());
+ Assert.assertEquals(42L,
+ resultFuture.get().getResult().getBatchFailedMetersOutput().get(0).getMeterId().getValue().longValue());
+ Assert.assertEquals(43L,
+ resultFuture.get().getResult().getBatchFailedMetersOutput().get(1).getMeterId().getValue().longValue());
Assert.assertEquals(2, resultFuture.get().getErrors().size());
@Test
public void testRemoveMetersBatch_failure() throws Exception {
Mockito.when(salMeterService.removeMeter(Mockito.<RemoveMeterInput>any()))
- .thenReturn(RpcResultBuilder.<RemoveMeterOutput>failed().withError(RpcError.ErrorType.APPLICATION, "ut-groupRemoveError")
+ .thenReturn(RpcResultBuilder.<RemoveMeterOutput>failed()
+ .withError(RpcError.ErrorType.APPLICATION, "ut-groupRemoveError")
.buildFuture());
final RemoveMetersBatchInput input = new RemoveMetersBatchInputBuilder()
Assert.assertTrue(resultFuture.isDone());
Assert.assertFalse(resultFuture.get().isSuccessful());
Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedMetersOutput().size());
- Assert.assertEquals(42L, resultFuture.get().getResult().getBatchFailedMetersOutput().get(0).getMeterId().getValue().longValue());
- Assert.assertEquals(43L, resultFuture.get().getResult().getBatchFailedMetersOutput().get(1).getMeterId().getValue().longValue());
+ Assert.assertEquals(42L,
+ resultFuture.get().getResult().getBatchFailedMetersOutput().get(0).getMeterId().getValue().longValue());
+ Assert.assertEquals(43L,
+ resultFuture.get().getResult().getBatchFailedMetersOutput().get(1).getMeterId().getValue().longValue());
Assert.assertEquals(2, resultFuture.get().getErrors().size());
final InOrder inOrder = Mockito.inOrder(salMeterService, transactionService);
private static BatchUpdateMeters createEmptyBatchUpdateMeter(final long groupIdValue) {
return new BatchUpdateMetersBuilder()
- .setOriginalBatchedMeter(new OriginalBatchedMeterBuilder(createEmptyBatchAddMeter(groupIdValue)).build())
- .setUpdatedBatchedMeter(new UpdatedBatchedMeterBuilder(createEmptyBatchAddMeter(groupIdValue + 1)).build())
+ .setOriginalBatchedMeter(
+ new OriginalBatchedMeterBuilder(createEmptyBatchAddMeter(groupIdValue)).build())
+ .setUpdatedBatchedMeter(
+ new UpdatedBatchedMeterBuilder(createEmptyBatchAddMeter(groupIdValue + 1)).build())
.build();
}
}
final OfHeader ofHeader = salPortService.buildRequest(new Xid(DUMMY_XID), dummyUpdatePortInput());
}
- private UpdatePortInput dummyUpdatePortInput(){
- org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.port.mod.port.PortBuilder concretePortBuilder
- = new org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.port.mod.port.PortBuilder();
+ private UpdatePortInput dummyUpdatePortInput() {
+ org.opendaylight.yang.gen.v1.urn
+ .opendaylight.flow.types.port.rev130925.port.mod.port.PortBuilder concretePortBuilder
+ = new org.opendaylight.yang.gen.v1.urn
+ .opendaylight.flow.types.port.rev130925.port.mod.port.PortBuilder();
concretePortBuilder.setConfiguration(new PortConfig(true, true, true, true));
- concretePortBuilder.setAdvertisedFeatures(new PortFeatures(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true));
+ concretePortBuilder.setAdvertisedFeatures(new PortFeatures(true, true, true, true, true, true, true, true,
+ true, true, true, true, true, true, true, true));
concretePortBuilder.setPortNumber(new PortNumberUni(DUMMY_PORT_NUMBER));
concretePortBuilder.setHardwareAddress(new MacAddress(DUMMY_MAC_ADDRESS));
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueue;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-/**
- * Created by kramesha on 8/27/15.
- */
public class SalRoleServiceImplTest {
@Mock
@Mock
private DeviceContext mockDeviceContext;
- @Mock
- private ConnectionAdapter mockConnectionAdapter;
-
@Mock
private FeaturesReply mockFeaturesReply;
private static long testXid = 100L;
- private static final String ROLEREQUESTFAILED =
- org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.ErrorType.ROLEREQUESTFAILED.name();
+ private static final String ROLEREQUESTFAILED = org.opendaylight.yang.gen.v1.urn
+ .opendaylight.openflow.common.types.rev130731.ErrorType.ROLEREQUESTFAILED.name();
- private static final String ROLES_UNSUPPORTED = "Device reported error type "+ ROLEREQUESTFAILED +" code UNSUP";
+ private static final String ROLES_UNSUPPORTED = "Device reported error type " + ROLEREQUESTFAILED + " code UNSUP";
private NodeRef nodeRef;
Mockito.when(mockRequestContextStack.<RoleRequestOutput>createRequestContext()).thenReturn(mockRequestContext);
Mockito.when(mockRequestContext.getXid()).thenReturn(new Xid(testXid));
Mockito.when(mockConnectionContext.getOutboundQueueProvider()).thenReturn(mockOutboundQueue);
- Mockito.when(mockDeviceContext.getPrimaryConnectionContext().getConnectionState()).thenReturn(ConnectionContext.CONNECTION_STATE.WORKING);
+ Mockito.when(mockDeviceContext.getPrimaryConnectionContext().getConnectionState())
+ .thenReturn(ConnectionContext.CONNECTION_STATE.WORKING);
NodeKey key = new NodeKey(testNodeId);
InstanceIdentifier<Node> path = InstanceIdentifier.<Nodes>builder(Nodes.class)
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.SettableFuture;
-import java.math.BigInteger;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.EventIdentifier;
import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProviderFactory;
import org.opendaylight.openflowplugin.impl.services.ServiceMocking;
public class SalTableServiceImplTest extends ServiceMocking {
- private static final BigInteger DUMMY_DATAPATH_ID = new BigInteger("444");
- private static final Short DUMMY_VERSION = OFConstants.OFP_VERSION_1_3;
- private static final int DUMMY_MAX_REQUEST = 88;
-
@Mock
RpcProviderRegistry mockedRpcProviderRegistry;
Mockito.doAnswer(new Answer<Void>() {
@Override
public Void answer(InvocationOnMock invocation) throws Throwable {
- final RpcResult<List<MultipartReply>> rpcResult = RpcResultBuilder.<List<MultipartReply>>failed().build();
+ final RpcResult<List<MultipartReply>> rpcResult =
+ RpcResultBuilder.<List<MultipartReply>>failed().build();
handleResultFuture.set(rpcResult);
return null;
}
Mockito.doAnswer(new Answer<Void>() {
@Override
public Void answer(InvocationOnMock invocation) throws Throwable {
- final RpcResult<List<MultipartReply>> rpcResult = RpcResultBuilder.success(Collections.<MultipartReply>emptyList())
+ final RpcResult<List<MultipartReply>> rpcResult =
+ RpcResultBuilder.success(Collections.<MultipartReply>emptyList())
.build();
handleResultFuture.set(rpcResult);
return null;
final Future<RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>> rpcResultFuture = service
.handleAndReply(input);
- final RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput> sendAggregateFlowMpRequestOutputRpcResult =
- rpcResultFuture.get();
+ final RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>
+ sendAggregateFlowMpRequestOutputRpcResult = rpcResultFuture.get();
assertEquals(BYTE_COUNT, sendAggregateFlowMpRequestOutputRpcResult
.getResult()
Code Review / openflowplugin.git / commitdiff