public abstract class CommonService {
private static final Logger LOG = org.slf4j.LoggerFactory.getLogger(CommonService.class);
private static final long WAIT_TIME = 2000;
- protected final static Future<RpcResult<Void>> ERROR_RPC_RESULT = Futures.immediateFuture(RpcResultBuilder
+ private final static Future<RpcResult<Void>> ERROR_RPC_RESULT = Futures.immediateFuture(RpcResultBuilder
.<Void>failed().withError(ErrorType.APPLICATION, "", "Request quota exceeded.").build());
- protected static final BigInteger PRIMARY_CONNECTION = new BigInteger("0");
- // protected OFRpcTaskContext rpcTaskContext;
- public short version;
- public BigInteger datapathId;
- protected RequestContextStack requestContextStack;
- protected DeviceContext deviceContext;
- public ConnectionAdapter primaryConnectionAdapter;
- public MessageSpy messageSpy;
+ private static final BigInteger PRIMARY_CONNECTION = new BigInteger("0");
+
+ private final short version;
+ private final BigInteger datapathId;
+ private final RequestContextStack requestContextStack;
+ private final DeviceContext deviceContext;
+ private final ConnectionAdapter primaryConnectionAdapter;
+ private final MessageSpy messageSpy;
- /**
- * @deprecated use {@link #CommonService(RequestContextStack, DeviceContext)}
- */
- @Deprecated
- public CommonService() {
- }
public CommonService(final RequestContextStack requestContextStack, DeviceContext deviceContext) {
this.requestContextStack = requestContextStack;
-
this.deviceContext = deviceContext;
final FeaturesReply features = this.deviceContext.getPrimaryConnectionContext().getFeatures();
this.datapathId = features.getDatapathId();
this.primaryConnectionAdapter = deviceContext.getPrimaryConnectionContext().getConnectionAdapter();
this.messageSpy = deviceContext.getMessageSpy();
}
+ public static BigInteger getPrimaryConnection() {
+ return PRIMARY_CONNECTION;
+ }
+
+ public short getVersion(){
+ return version;
+ }
+
+ public BigInteger getDatapathId() {
+ return datapathId;
+ }
+
+ public RequestContextStack getRequestContextStack() {
+ return requestContextStack;
+ }
+
+ public DeviceContext getDeviceContext() {
+ return deviceContext;
+ }
+
+ public ConnectionAdapter getPrimaryConnectionAdapter() {
+ return primaryConnectionAdapter;
+ }
+
+ public MessageSpy getMessageSpy() {
+ return messageSpy;
+ }
protected long provideWaitTime() {
return WAIT_TIME;
}
+
protected ConnectionAdapter provideConnectionAdapter(final BigInteger connectionID) {
if (connectionID == null) {
return primaryConnectionAdapter;
DataCrateBuilder<T> dataCrateBuilder = DataCrateBuilder.<T>builder();
return handleServiceCall(connectionID, function, dataCrateBuilder);
}
+ public <T, F> ListenableFuture<RpcResult<T>> handleServiceCall(final Function<DataCrate<T>, ListenableFuture<RpcResult<F>>> function) {
+ DataCrateBuilder<T> dataCrateBuilder = DataCrateBuilder.<T>builder();
+ return handleServiceCall(PRIMARY_CONNECTION, function, dataCrateBuilder);
+ }
/**
* @param <T>
@Override
public Future<RpcResult<Void>> sendBarrier(SendBarrierInput input) {
- final RequestContext<Void> requestContext = requestContextStack.createRequestContext();
- final SettableFuture<RpcResult<Void>> sendBarrierOutput = requestContextStack
+ final RequestContext<Void> requestContext = getRequestContextStack().createRequestContext();
+ final SettableFuture<RpcResult<Void>> sendBarrierOutput = getRequestContextStack()
.storeOrFail(requestContext);
if (!sendBarrierOutput.isDone()) {
-
+ final DeviceContext deviceContext =getDeviceContext();
final Xid xid = deviceContext.getNextXid();
requestContext.setXid(xid);
final BarrierInputBuilder barrierInputOFJavaBuilder = new BarrierInputBuilder();
- barrierInputOFJavaBuilder.setVersion(version);
+ barrierInputOFJavaBuilder.setVersion(getVersion());
barrierInputOFJavaBuilder.setXid(xid.getValue());
LOG.trace("Hooking xid {} to device context - precaution.", requestContext.getXid().getValue());
final BarrierInput barrierInputOFJava = barrierInputOFJavaBuilder.build();
- final Future<RpcResult<BarrierOutput>> barrierOutputOFJava = provideConnectionAdapter(PRIMARY_CONNECTION)
+ final Future<RpcResult<BarrierOutput>> barrierOutputOFJava = getPrimaryConnectionAdapter()
.barrier(barrierInputOFJava);
LOG.debug("Barrier with xid {} was sent from controller.", xid);
};
Futures.addCallback(listenableBarrierOutputOFJava, successCallback);
} else {
- messageSpy.spyMessage(requestContext, MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
+ getMessageSpy().spyMessage(requestContext, MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
}
//callback on request context future
builder.setXid(xid.getValue());
builder.setFlags(flag);
builder.setMissSendLen(input.getMissSearchLength());
- builder.setVersion(version);
+ builder.setVersion(getVersion());
ListenableFuture<RpcResult<Void>> futureResultFromOfLib;
synchronized (deviceContext) {
futureResultFromOfLib = JdkFutureAdapters.listenInPoolThread(deviceContext.getPrimaryConnectionContext().getConnectionAdapter().setConfig(builder.build()));
@Override
public Future<RpcResult<Void>> transmitPacket(final TransmitPacketInput input) {
- return handleServiceCall(PRIMARY_CONNECTION, new Function<DataCrate<Void>, ListenableFuture<RpcResult<Void>>>() {
+ return handleServiceCall(new Function<DataCrate<Void>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(DataCrate<Void> data) {
final Xid xid = data.getRequestContext().getXid();
- final PacketOutInput message = PacketOutConvertor.toPacketOutInput(input, version, xid.getValue(),
- datapathId);
+ final PacketOutInput message = PacketOutConvertor.toPacketOutInput(input, getVersion(), xid.getValue(),
+ getDatapathId());
- BigInteger connectionID = PRIMARY_CONNECTION;
+ BigInteger connectionID = getPrimaryConnection();
final ConnectionCookie connectionCookie = input.getConnectionCookie();
if (connectionCookie != null && connectionCookie.getValue() != null) {
connectionID = BigInteger.valueOf(connectionCookie.getValue());
@Override
public Future<RpcResult<SendEchoOutput>> sendEcho(final SendEchoInput sendEchoInput) {
- final RequestContext<SendEchoOutput> requestContext = requestContextStack.createRequestContext();
- final SettableFuture<RpcResult<SendEchoOutput>> sendEchoOutput = requestContextStack
+ final RequestContext<SendEchoOutput> requestContext = getRequestContextStack().createRequestContext();
+ final SettableFuture<RpcResult<SendEchoOutput>> sendEchoOutput = getRequestContextStack()
.storeOrFail(requestContext);
if (!sendEchoOutput.isDone()) {
+ final DeviceContext deviceContext = getDeviceContext();
final Xid xid = deviceContext.getNextXid();
requestContext.setXid(xid);
deviceContext.hookRequestCtx(requestContext.getXid(), requestContext);
final EchoInputBuilder echoInputOFJavaBuilder = new EchoInputBuilder();
- echoInputOFJavaBuilder.setVersion(version);
+ echoInputOFJavaBuilder.setVersion(getVersion());
echoInputOFJavaBuilder.setXid(xid.getValue());
echoInputOFJavaBuilder.setData(sendEchoInput.getData());
final EchoInput echoInputOFJava = echoInputOFJavaBuilder.build();
- final Future<RpcResult<EchoOutput>> rpcEchoOutputOFJava = provideConnectionAdapter(PRIMARY_CONNECTION)
+ final Future<RpcResult<EchoOutput>> rpcEchoOutputOFJava = getPrimaryConnectionAdapter()
.echo(echoInputOFJava);
LOG.debug("Echo with xid {} was sent from controller", xid);
};
Futures.addCallback(listenableRpcEchoOutputOFJava, successCallback);
} else {
- messageSpy.spyMessage(requestContext, MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
+ getMessageSpy().spyMessage(requestContext, MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
}
// callback on request context future
}
+ final DeviceContext deviceContext = getDeviceContext();
final FlowHash flowHash = FlowHashFactory.create(input, deviceContext.getPrimaryConnectionContext().getFeatures().getVersion());
final FlowDescriptor flowDescriptor = FlowDescriptorFactory.create(input.getTableId(), flowId);
- final List<FlowModInputBuilder> ofFlowModInputs = FlowConvertor.toFlowModInputs(input, version, datapathId);
+ final List<FlowModInputBuilder> ofFlowModInputs = FlowConvertor.toFlowModInputs(input, getVersion(), getDatapathId());
final ListenableFuture<RpcResult<AddFlowOutput>> future = processFlowModInputBuilders(ofFlowModInputs);
Futures.addCallback(future, new FutureCallback<RpcResult<AddFlowOutput>>() {
@Override
public void onSuccess(final RpcResult<AddFlowOutput> rpcResult) {
- messageSpy.spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
+ getMessageSpy().spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
synchronized (deviceContext) {
deviceContext.getDeviceFlowRegistry().store(flowHash, flowDescriptor);
}
@Override
public void onFailure(final Throwable throwable) {
- messageSpy.spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
+ getMessageSpy().spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
synchronized (deviceContext) {
deviceContext.getDeviceFlowRegistry().markToBeremoved(flowHash);
}
@Override
public Future<RpcResult<RemoveFlowOutput>> removeFlow(final RemoveFlowInput input) {
LOG.trace("Calling remove flow for flow with ID ={}.", input.getFlowRef());
- return this.<RemoveFlowOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
- new Function<DataCrate<RemoveFlowOutput>, ListenableFuture<RpcResult<Void>>>() {
+ return this.<RemoveFlowOutput, Void>handleServiceCall(new Function<DataCrate<RemoveFlowOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<RemoveFlowOutput> data) {
- final FlowModInputBuilder ofFlowModInput = FlowConvertor.toFlowModInput(input, version,
- datapathId);
+ final FlowModInputBuilder ofFlowModInput = FlowConvertor.toFlowModInput(input, getVersion(),
+ getDatapathId());
final ListenableFuture<RpcResult<Void>> future = createResultForFlowMod(data, ofFlowModInput);
Futures.addCallback(future, new FutureCallback() {
@Override
public void onSuccess(final Object o) {
- messageSpy.spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
+ final DeviceContext deviceContext = getDeviceContext();
+ getMessageSpy().spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
FlowHash flowHash = FlowHashFactory.create(input, deviceContext.getPrimaryConnectionContext().getFeatures().getVersion());
synchronized (deviceContext) {
deviceContext.getDeviceFlowRegistry().markToBeremoved(flowHash);
@Override
public void onFailure(final Throwable throwable) {
- messageSpy.spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
+ getMessageSpy().spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
StringBuffer errors = new StringBuffer();
try {
RpcResult<Void> result = future.get();
final List<FlowModInputBuilder> allFlowMods = new ArrayList<>();
List<FlowModInputBuilder> ofFlowModInputs;
- if (!FlowCreatorUtil.canModifyFlow(original, updated, version)) {
+ if (!FlowCreatorUtil.canModifyFlow(original, updated, getVersion())) {
// We would need to remove original and add updated.
// remove flow
final RemoveFlowInputBuilder removeflow = new RemoveFlowInputBuilder(original);
final List<FlowModInputBuilder> ofFlowRemoveInput = FlowConvertor.toFlowModInputs(removeflow.build(),
- version, datapathId);
+ getVersion(), getDatapathId());
// remove flow should be the first
allFlowMods.addAll(ofFlowRemoveInput);
final AddFlowInputBuilder addFlowInputBuilder = new AddFlowInputBuilder(updated);
- ofFlowModInputs = FlowConvertor.toFlowModInputs(addFlowInputBuilder.build(), version, datapathId);
+ ofFlowModInputs = FlowConvertor.toFlowModInputs(addFlowInputBuilder.build(), getVersion(), getDatapathId());
} else {
- ofFlowModInputs = FlowConvertor.toFlowModInputs(updated, version, datapathId);
+ ofFlowModInputs = FlowConvertor.toFlowModInputs(updated, getVersion(), getDatapathId());
}
allFlowMods.addAll(ofFlowModInputs);
Futures.addCallback(future, new FutureCallback() {
@Override
public void onSuccess(final Object o) {
- messageSpy.spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
- short version = deviceContext.getPrimaryConnectionContext().getFeatures().getVersion();
+ final DeviceContext deviceContext = getDeviceContext();
+ getMessageSpy().spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
+ final short version = deviceContext.getPrimaryConnectionContext().getFeatures().getVersion();
FlowHash flowHash = FlowHashFactory.create(original, version);
FlowHash updatedflowHash = FlowHashFactory.create(updated, version);
@Override
public void onFailure(final Throwable throwable) {
- messageSpy.spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
+ getMessageSpy().spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_FAILURE);
}
});
return future;
for (FlowModInputBuilder flowModInputBuilder : ofFlowModInputs) {
DataCrateBuilder<T> dataCrateBuilder = DataCrateBuilder.<T>builder().setFlowModInputBuilder(flowModInputBuilder);
ListenableFuture<RpcResult<T>> partialFuture = handleServiceCall(
- PRIMARY_CONNECTION,
+ getPrimaryConnection(),
new Function<DataCrate<T>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<T> data) {
// xid might be not available in case requestContext not even stored
if (xid != null) {
+ final DeviceContext deviceContext = getDeviceContext();
synchronized (deviceContext) {
deviceContext.unhookRequestCtx(new Xid(xid));
}
@Override
public Future<RpcResult<AddGroupOutput>> addGroup(final AddGroupInput input) {
- deviceContext.getDeviceGroupRegistry().store(input.getGroupId());
- return this.<AddGroupOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
+ getDeviceContext().getDeviceGroupRegistry().store(input.getGroupId());
+ return this.<AddGroupOutput, Void>handleServiceCall(getPrimaryConnection(),
new Function<DataCrate<AddGroupOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
@Override
public Future<RpcResult<UpdateGroupOutput>> updateGroup(final UpdateGroupInput input) {
- return this.<UpdateGroupOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
+ return this.<UpdateGroupOutput, Void>handleServiceCall(getPrimaryConnection(),
new Function<DataCrate<UpdateGroupOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
@Override
public Future<RpcResult<RemoveGroupOutput>> removeGroup(final RemoveGroupInput input) {
- deviceContext.getDeviceGroupRegistry().markToBeremoved(input.getGroupId());
- return this.<RemoveGroupOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
+ getDeviceContext().getDeviceGroupRegistry().markToBeremoved(input.getGroupId());
+ return this.<RemoveGroupOutput, Void>handleServiceCall(getPrimaryConnection(),
new Function<DataCrate<RemoveGroupOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
}
<T> ListenableFuture<RpcResult<Void>> convertAndSend(final Group iputGroup, final DataCrate<T> data) {
- messageSpy.spyMessage(iputGroup.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
- final GroupModInputBuilder ofGroupModInput = GroupConvertor.toGroupModInput(iputGroup, version, datapathId);
+ getMessageSpy().spyMessage(iputGroup.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
+ final GroupModInputBuilder ofGroupModInput = GroupConvertor.toGroupModInput(iputGroup, getVersion(), getDatapathId());
final Xid xid = data.getRequestContext().getXid();
ofGroupModInput.setXid(xid.getValue());
return JdkFutureAdapters.listenInPoolThread(provideConnectionAdapter(data.getiDConnection()).groupMod(ofGroupModInput.build()));
@Override
public Future<RpcResult<AddMeterOutput>> addMeter(final AddMeterInput input) {
- deviceContext.getDeviceMeterRegistry().store(input.getMeterId());
- return this.<AddMeterOutput, Void>handleServiceCall( PRIMARY_CONNECTION,
+ getDeviceContext().getDeviceMeterRegistry().store(input.getMeterId());
+ return this.<AddMeterOutput, Void>handleServiceCall( getPrimaryConnection(),
new Function<DataCrate<AddMeterOutput>,ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<AddMeterOutput> data) {
@Override
public Future<RpcResult<UpdateMeterOutput>> updateMeter(final UpdateMeterInput input) {
- return this.<UpdateMeterOutput, Void>handleServiceCall( PRIMARY_CONNECTION,
+ return this.<UpdateMeterOutput, Void>handleServiceCall( getPrimaryConnection(),
new Function<DataCrate<UpdateMeterOutput>,ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<UpdateMeterOutput> data) {
@Override
public Future<RpcResult<RemoveMeterOutput>> removeMeter(final RemoveMeterInput input) {
- deviceContext.getDeviceMeterRegistry().markToBeremoved(input.getMeterId());
- return this.<RemoveMeterOutput, Void>handleServiceCall( PRIMARY_CONNECTION,
+ getDeviceContext().getDeviceMeterRegistry().markToBeremoved(input.getMeterId());
+ return this.<RemoveMeterOutput, Void>handleServiceCall( getPrimaryConnection(),
new Function<DataCrate<RemoveMeterOutput>,ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<RemoveMeterOutput> data) {
}
<T> ListenableFuture<RpcResult<Void>> convertAndSend(final Meter iputMeter, final DataCrate<T> data) {
- messageSpy.spyMessage(iputMeter.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
+ getMessageSpy().spyMessage(iputMeter.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
- final MeterModInputBuilder ofMeterModInput = MeterConvertor.toMeterModInput(iputMeter, version);
+ final MeterModInputBuilder ofMeterModInput = MeterConvertor.toMeterModInput(iputMeter, getVersion());
final Xid xid = data.getRequestContext().getXid();
ofMeterModInput.setXid(xid.getValue());
return JdkFutureAdapters.listenInPoolThread(provideConnectionAdapter(data.getiDConnection()).meterMod(ofMeterModInput.build()));
import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.concurrent.Future;
+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.api.openflow.statistics.ofpspecific.MessageSpy;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.PortConvertor;
public class SalPortServiceImpl extends CommonService implements SalPortService {
private static final Logger LOG = org.slf4j.LoggerFactory.getLogger(SalPortServiceImpl.class);
+ public SalPortServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
+ super(requestContextStack, deviceContext);
+ }
+
@Override
public Future<RpcResult<UpdatePortOutput>> updatePort(final UpdatePortInput input) {
- return this.<UpdatePortOutput, Void> handleServiceCall(PRIMARY_CONNECTION,
- new Function<DataCrate<UpdatePortOutput>, ListenableFuture<RpcResult<Void>>>() {
+ return this.<UpdatePortOutput, Void> handleServiceCall(new Function<DataCrate<UpdatePortOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<UpdatePortOutput> data) {
- messageSpy.spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
+ getMessageSpy().spyMessage(input.getImplementedInterface(), MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
final Port inputPort = input.getUpdatedPort().getPort().getPort().get(0);
- final PortModInput ofPortModInput = PortConvertor.toPortModInput(inputPort, version);
+ final PortModInput ofPortModInput = PortConvertor.toPortModInput(inputPort, getVersion());
final PortModInputBuilder mdInput = new PortModInputBuilder(ofPortModInput);
final Xid xid = data.getRequestContext().getXid();
mdInput.setXid(xid.getValue());
@Override
public ListenableFuture<RpcResult<List<MultipartReply>>> apply(final DataCrate<List<MultipartReply>> data) {
- messageSpy.spyMessage(input.getImplementedInterface(),
+ getMessageSpy().spyMessage(input.getImplementedInterface(),
MessageSpy.STATISTIC_GROUP.TO_SWITCH_SUBMITTED_SUCCESS);
final SettableFuture<RpcResult<List<MultipartReply>>> result = SettableFuture.create();
// Set request body to main multipart request
final Xid xid = data.getRequestContext().getXid();
- deviceContext.getOpenflowMessageListenerFacade().registerMultipartXid(xid.getValue());
+ getDeviceContext().getOpenflowMessageListenerFacade().registerMultipartXid(xid.getValue());
final MultipartRequestInputBuilder mprInput = createMultipartHeader(MultipartType.OFPMPTABLEFEATURES,
xid.getValue());
mprInput.setMultipartRequestBody(caseBuilder.build());
- final Future<RpcResult<Void>> resultFromOFLib = provideConnectionAdapter(PRIMARY_CONNECTION)
+ final Future<RpcResult<Void>> resultFromOFLib = getPrimaryConnectionAdapter()
.multipartRequest(mprInput.build());
final ListenableFuture<RpcResult<Void>> resultLib = JdkFutureAdapters
.listenInPoolThread(resultFromOFLib);
}
}
- final ListenableFuture<RpcResult<List<MultipartReply>>> multipartFuture = handleServiceCall(PRIMARY_CONNECTION,
- new FunctionImpl());
+ final ListenableFuture<RpcResult<List<MultipartReply>>> multipartFuture = handleServiceCall(new FunctionImpl());
final SettableFuture<RpcResult<UpdateTableOutput>> finalFuture = SettableFuture.create();
class CallBackImpl implements FutureCallback<RpcResult<List<MultipartReply>>> {
final List<org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures> salTableFeatures = convertToSalTableFeatures(multipartReplies);
+ final DeviceContext deviceContext = getDeviceContext();
final NodeId nodeId = deviceContext.getPrimaryConnectionContext().getNodeId();
final InstanceIdentifier<FlowCapableNode> flowCapableNodeII = InstanceIdentifier.create(Nodes.class)
.child(Node.class, new NodeKey(nodeId)).augmentation(FlowCapableNode.class);
private MultipartRequestInputBuilder createMultipartHeader(final MultipartType multipart, final Long xid) {
final MultipartRequestInputBuilder mprInput = new MultipartRequestInputBuilder();
mprInput.setType(multipart);
- mprInput.setVersion(version);
+ mprInput.setVersion(getVersion());
mprInput.setXid(xid);
mprInput.setFlags(new MultipartRequestFlags(false));
return mprInput;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.JdkFutureAdapters;
import com.google.common.util.concurrent.ListenableFuture;
-
-import java.io.Serializable;
-import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-import java.util.Objects;
import java.util.concurrent.Future;
+import javax.annotation.Nullable;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator;
import org.opendaylight.openflowplugin.impl.services.RequestInputUtils;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.match.MatchReactor;
import org.opendaylight.openflowplugin.openflow.md.util.FlowCreatorUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsUpdate;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAggregateFlowStatisticsFromFlowTableForAllFlowsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAggregateFlowStatisticsFromFlowTableForAllFlowsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsFromFlowTableOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.aggregate.flow.statistics.from.flow.table._for.given.match.output.AggregatedFlowStatistics;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartRequestInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketIn;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketInMessage;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyAggregateCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestAggregateCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestFlowCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.aggregate._case.MultipartRequestAggregateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.flow._case.MultipartRequestFlowBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
-import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.annotation.Nullable;
-
/**
* @author joe
*/
return this.<GetAggregateFlowStatisticsFromFlowTableForAllFlowsOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION,
new Function<DataCrate<GetAggregateFlowStatisticsFromFlowTableForAllFlowsOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
mprAggregateRequestBuilder.setOutGroup(OFConstants.OFPG_ANY);
mprAggregateRequestBuilder.setCookie(OFConstants.DEFAULT_COOKIE);
mprAggregateRequestBuilder.setCookieMask(OFConstants.DEFAULT_COOKIE_MASK);
-
+ final short version = getVersion();
FlowCreatorUtil.setWildcardedFlowMatch(version, mprAggregateRequestBuilder);
// Set request body to main multipart request
mprInput.setMultipartRequestBody(multipartRequestAggregateCaseBuilder.build());
- final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ final Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
ListenableFuture<RpcResult<List<MultipartReply>>> rpcResultListenableFuture = handleServiceCall(
- PRIMARY_CONNECTION,
- new Function<DataCrate<List<MultipartReply>>, ListenableFuture<RpcResult<Void>>>() {
-
- @Override
- public ListenableFuture<RpcResult<Void>> apply(final DataCrate<List<MultipartReply>> data) {
- final Xid xid = data.getRequestContext().getXid();
- deviceContext.getOpenflowMessageListenerFacade().registerMultipartXid(xid.getValue());
- final MultipartRequestAggregateCaseBuilder multipartRequestAggregateCaseBuilder = new MultipartRequestAggregateCaseBuilder();
- final MultipartRequestAggregateBuilder mprAggregateRequestBuilder = new MultipartRequestAggregateBuilder();
- final short tableId = MoreObjects.firstNonNull(input.getTableId(), OFConstants.OFPTT_ALL).shortValue();
- mprAggregateRequestBuilder.setTableId(tableId);
- long outputPortValue = MoreObjects.firstNonNull(input.getOutPort(), OFConstants.OFPP_ANY).longValue();
- mprAggregateRequestBuilder.setOutPort(outputPortValue);
- // TODO: repeating code
- if (version == OFConstants.OFP_VERSION_1_3) {
-
- if (input.getCookie() == null) {
- mprAggregateRequestBuilder.setCookie(OFConstants.DEFAULT_COOKIE);
- } else {
- mprAggregateRequestBuilder.setCookie(MoreObjects.firstNonNull(input.getCookie().getValue(), OFConstants.DEFAULT_COOKIE));
- }
+ new Function<DataCrate<List<MultipartReply>>, ListenableFuture<RpcResult<Void>>>() {
- if (input.getCookieMask() == null) {
- mprAggregateRequestBuilder.setCookieMask(OFConstants.DEFAULT_COOKIE_MASK);
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(final DataCrate<List<MultipartReply>> data) {
+ final Xid xid = data.getRequestContext().getXid();
+ final DeviceContext deviceContext = getDeviceContext();
+ deviceContext.getOpenflowMessageListenerFacade().registerMultipartXid(xid.getValue());
+ final MultipartRequestAggregateCaseBuilder multipartRequestAggregateCaseBuilder = new MultipartRequestAggregateCaseBuilder();
+ final MultipartRequestAggregateBuilder mprAggregateRequestBuilder = new MultipartRequestAggregateBuilder();
+ final short tableId = MoreObjects.firstNonNull(input.getTableId(), OFConstants.OFPTT_ALL).shortValue();
+ mprAggregateRequestBuilder.setTableId(tableId);
+ long outputPortValue = MoreObjects.firstNonNull(input.getOutPort(), OFConstants.OFPP_ANY).longValue();
+ mprAggregateRequestBuilder.setOutPort(outputPortValue);
+ // TODO: repeating code
+
+ final short version = getVersion();
+ if (version == OFConstants.OFP_VERSION_1_3) {
+
+ if (input.getCookie() == null) {
+ mprAggregateRequestBuilder.setCookie(OFConstants.DEFAULT_COOKIE);
+ } else {
+ 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));
+ }
+ long outGroup = MoreObjects.firstNonNull(input.getOutGroup(), OFConstants.OFPG_ANY).longValue();
+ mprAggregateRequestBuilder.setOutGroup(outGroup);
} else {
- mprAggregateRequestBuilder.setCookieMask(MoreObjects.firstNonNull(input.getCookieMask().getValue(), OFConstants.DEFAULT_COOKIE_MASK));
+ mprAggregateRequestBuilder.setOutGroup(OFConstants.OFPG_ANY);
+ mprAggregateRequestBuilder.setCookie(OFConstants.DEFAULT_COOKIE);
+ mprAggregateRequestBuilder.setCookieMask(OFConstants.DEFAULT_COOKIE_MASK);
}
- long outGroup = MoreObjects.firstNonNull(input.getOutGroup(), OFConstants.OFPG_ANY).longValue();
- mprAggregateRequestBuilder.setOutGroup(outGroup);
- } else {
- mprAggregateRequestBuilder.setOutGroup(OFConstants.OFPG_ANY);
- mprAggregateRequestBuilder.setCookie(OFConstants.DEFAULT_COOKIE);
- mprAggregateRequestBuilder.setCookieMask(OFConstants.DEFAULT_COOKIE_MASK);
- }
- MatchReactor.getInstance().convert(input.getMatch(), version, mprAggregateRequestBuilder,
- deviceContext.getPrimaryConnectionContext().getFeatures().getDatapathId());
+ MatchReactor.getInstance().convert(input.getMatch(), version, mprAggregateRequestBuilder,
+ deviceContext.getPrimaryConnectionContext().getFeatures().getDatapathId());
- FlowCreatorUtil.setWildcardedFlowMatch(version, mprAggregateRequestBuilder);
+ FlowCreatorUtil.setWildcardedFlowMatch(version, mprAggregateRequestBuilder);
- // Set request body to main multipart request
- multipartRequestAggregateCaseBuilder.setMultipartRequestAggregate(mprAggregateRequestBuilder
- .build());
+ // Set request body to main multipart request
+ multipartRequestAggregateCaseBuilder.setMultipartRequestAggregate(mprAggregateRequestBuilder
+ .build());
- final MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
- MultipartType.OFPMPAGGREGATE, xid.getValue(), version);
+ final MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
+ MultipartType.OFPMPAGGREGATE, xid.getValue(), version);
- mprInput.setMultipartRequestBody(multipartRequestAggregateCaseBuilder.build());
- final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
- .getConnectionAdapter().multipartRequest(mprInput.build());
- return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
- }
- });
+ mprInput.setMultipartRequestBody(multipartRequestAggregateCaseBuilder.build());
+ final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ .getConnectionAdapter().multipartRequest(mprInput.build());
+ return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
+ }
+ });
return Futures.transform(rpcResultListenableFuture, new Function<RpcResult<List<MultipartReply>>, RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>>() {
@Nullable
@Override
public RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput> apply(RpcResult<List<MultipartReply>> input) {
+ final DeviceContext deviceContext = getDeviceContext();
TranslatorLibrary translatorLibrary = deviceContext.oook();
RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput> rpcResult;
- if(input.isSuccessful()) {
+ if (input.isSuccessful()) {
MultipartReply reply = input.getResult().get(0);
final TranslatorKey translatorKey = new TranslatorKey(reply.getVersion(), MultipartReplyAggregateCase.class.getName());
final MessageTranslator<MultipartReply, AggregatedFlowStatistics> messageTranslator = translatorLibrary.lookupTranslator(translatorKey);
public Future<RpcResult<GetAllFlowStatisticsFromFlowTableOutput>> getAllFlowStatisticsFromFlowTable(
final GetAllFlowStatisticsFromFlowTableInput input) {
- return this.<GetAllFlowStatisticsFromFlowTableOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
- new Function<DataCrate<GetAllFlowStatisticsFromFlowTableOutput>, ListenableFuture<RpcResult<Void>>>() {
+ return this.<GetAllFlowStatisticsFromFlowTableOutput, Void>handleServiceCall(new Function<DataCrate<GetAllFlowStatisticsFromFlowTableOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllFlowStatisticsFromFlowTableOutput> data) {
mprFlowRequestBuilder.setOutGroup(OFConstants.OFPG_ANY);
mprFlowRequestBuilder.setCookie(OFConstants.DEFAULT_COOKIE);
mprFlowRequestBuilder.setCookieMask(OFConstants.DEFAULT_COOKIE_MASK);
+
+ final short version = getVersion();
FlowCreatorUtil.setWildcardedFlowMatch(version, mprFlowRequestBuilder);
final MultipartRequestFlowCaseBuilder multipartRequestFlowCaseBuilder = new MultipartRequestFlowCaseBuilder();
MultipartType.OFPMPFLOW, xid.getValue(), version);
mprInput.setMultipartRequestBody(multipartRequestFlowCaseBuilder.build());
- final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ final Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
final GetAllFlowsStatisticsFromAllFlowTablesInput input) {
- return this.<GetAllFlowsStatisticsFromAllFlowTablesOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
- new Function<DataCrate<GetAllFlowsStatisticsFromAllFlowTablesOutput>, ListenableFuture<RpcResult<Void>>>() {
+ return this.<GetAllFlowsStatisticsFromAllFlowTablesOutput, Void>handleServiceCall(new Function<DataCrate<GetAllFlowsStatisticsFromAllFlowTablesOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllFlowsStatisticsFromAllFlowTablesOutput> data) {
mprFlowRequestBuilder.setOutGroup(OFConstants.OFPG_ANY);
mprFlowRequestBuilder.setCookie(OFConstants.DEFAULT_COOKIE);
mprFlowRequestBuilder.setCookieMask(OFConstants.DEFAULT_COOKIE_MASK);
+ final short version = getVersion();
FlowCreatorUtil.setWildcardedFlowMatch(version, mprFlowRequestBuilder);
final Xid xid = data.getRequestContext().getXid();
multipartRequestFlowCaseBuilder.setMultipartRequestFlow(mprFlowRequestBuilder.build());
mprInput.setMultipartRequestBody(multipartRequestFlowCaseBuilder.build());
- final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ final Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
final GetFlowStatisticsFromFlowTableInput input) {
- return this.<GetFlowStatisticsFromFlowTableOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
- new Function<DataCrate<GetFlowStatisticsFromFlowTableOutput>, ListenableFuture<RpcResult<Void>>>() {
+ return this.<GetFlowStatisticsFromFlowTableOutput, Void>handleServiceCall(new Function<DataCrate<GetFlowStatisticsFromFlowTableOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetFlowStatisticsFromFlowTableOutput> data) {
}
// convert and inject match
+ final short version = getVersion();
+ final DeviceContext deviceContext = getDeviceContext();
MatchReactor.getInstance().convert(input.getMatch(), version, mprFlowRequestBuilder,
deviceContext.getPrimaryConnectionContext().getFeatures().getDatapathId());
}
private <T> void convertRpcResultToRequestFuture(final RequestContext<T> requestContext,
- final ListenableFuture<RpcResult<Void>> futureResultFromOfLib) {
- final OFJResult2RequestCtxFuture<T> OFJResult2RequestCtxFuture = new OFJResult2RequestCtxFuture<>(requestContext, deviceContext);
+ final ListenableFuture<RpcResult<Void>> futureResultFromOfLib) {
+ final OFJResult2RequestCtxFuture<T> OFJResult2RequestCtxFuture = new OFJResult2RequestCtxFuture<>(requestContext, getDeviceContext());
OFJResult2RequestCtxFuture.processResultFromOfJava(futureResultFromOfLib);
}
final GetFlowTablesStatisticsInput input) {
- return this.<GetFlowTablesStatisticsOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
- new Function<DataCrate<GetFlowTablesStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
+ return this.<GetFlowTablesStatisticsOutput, Void>handleServiceCall(new Function<DataCrate<GetFlowTablesStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetFlowTablesStatisticsOutput> data) {
// Set request body to main multipart request
final Xid xid = data.getRequestContext().getXid();
final MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
- MultipartType.OFPMPFLOW, xid.getValue(), version);
+ MultipartType.OFPMPFLOW, xid.getValue(), getVersion());
mprInput.setMultipartRequestBody(multipartRequestTableCaseBuilder.build());
- final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ final Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
public Future<RpcResult<GetAllGroupStatisticsOutput>> getAllGroupStatistics(final GetAllGroupStatisticsInput input) {
- return this.<GetAllGroupStatisticsOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
- new Function<DataCrate<GetAllGroupStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
+ return this.<GetAllGroupStatisticsOutput, Void>handleServiceCall(new Function<DataCrate<GetAllGroupStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
- @Override
- public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllGroupStatisticsOutput> data) {
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllGroupStatisticsOutput> data) {
- final MultipartRequestGroupCaseBuilder caseBuilder = new MultipartRequestGroupCaseBuilder();
- final MultipartRequestGroupBuilder mprGroupBuild = new MultipartRequestGroupBuilder();
- mprGroupBuild.setGroupId(new GroupId(
- BinContent
- .intToUnsignedLong(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Group.OFPGALL
- .getIntValue())));
- caseBuilder.setMultipartRequestGroup(mprGroupBuild.build());
+ final MultipartRequestGroupCaseBuilder caseBuilder = new MultipartRequestGroupCaseBuilder();
+ final MultipartRequestGroupBuilder mprGroupBuild = new MultipartRequestGroupBuilder();
+ mprGroupBuild.setGroupId(new GroupId(
+ BinContent
+ .intToUnsignedLong(org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Group.OFPGALL
+ .getIntValue())));
+ caseBuilder.setMultipartRequestGroup(mprGroupBuild.build());
- // Create multipart request header
- final Xid xid = data.getRequestContext().getXid();
- final MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
- MultipartType.OFPMPGROUP, xid.getValue(), version);
+ // Create multipart request header
+ final Xid xid = data.getRequestContext().getXid();
+ final MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
+ MultipartType.OFPMPGROUP, xid.getValue(), getVersion());
- // Set request body to main multipart request
- mprInput.setMultipartRequestBody(caseBuilder.build());
+ // Set request body to main multipart request
+ mprInput.setMultipartRequestBody(caseBuilder.build());
- // Send the request, no cookies associated, use any connection
+ // Send the request, no cookies associated, use any connection
- final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
- .getConnectionAdapter().multipartRequest(mprInput.build());
- return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
- }
- });
+ final Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
+ .getConnectionAdapter().multipartRequest(mprInput.build());
+ return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
+ }
+ });
}
@Override
public Future<RpcResult<GetGroupDescriptionOutput>> getGroupDescription(final GetGroupDescriptionInput input) {
- return this.<GetGroupDescriptionOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
+ return this.<GetGroupDescriptionOutput, Void>handleServiceCall(
new Function<DataCrate<GetGroupDescriptionOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
final Xid xid = data.getRequestContext().getXid();
final MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
- MultipartType.OFPMPGROUPDESC, xid.getValue(), version);
+ MultipartType.OFPMPGROUPDESC, xid.getValue(), getVersion());
mprInput.setMultipartRequestBody(mprGroupDescCaseBuild.build());
- final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ final Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
@Override
public Future<RpcResult<GetGroupFeaturesOutput>> getGroupFeatures(final GetGroupFeaturesInput input) {
- return this.<GetGroupFeaturesOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
+ return this.<GetGroupFeaturesOutput, Void>handleServiceCall(
new Function<DataCrate<GetGroupFeaturesOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
final Xid xid = data.getRequestContext().getXid();
final MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
- MultipartType.OFPMPGROUPFEATURES, xid.getValue(), version);
+ MultipartType.OFPMPGROUPFEATURES, xid.getValue(), getVersion());
mprInput.setMultipartRequestBody(mprGroupFeaturesBuild.build());
- final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ final Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
@Override
public Future<RpcResult<GetGroupStatisticsOutput>> getGroupStatistics(final GetGroupStatisticsInput input) {
- return this.<GetGroupStatisticsOutput, Void>handleServiceCall(PRIMARY_CONNECTION,
+ return this.<GetGroupStatisticsOutput, Void>handleServiceCall(
new Function<DataCrate<GetGroupStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
final Xid xid = data.getRequestContext().getXid();
final MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
- MultipartType.OFPMPGROUP, xid.getValue(), version);
+ MultipartType.OFPMPGROUP, xid.getValue(), getVersion());
mprInput.setMultipartRequestBody(caseBuilder.build());
- final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ final Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
public Future<RpcResult<GetAllMeterConfigStatisticsOutput>> getAllMeterConfigStatistics(
final GetAllMeterConfigStatisticsInput input) {
return this
- .<GetAllMeterConfigStatisticsOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION, new Function<DataCrate<GetAllMeterConfigStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
-
- @Override
- public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllMeterConfigStatisticsOutput> data) {
-
- MultipartRequestMeterConfigCaseBuilder caseBuilder =
- new MultipartRequestMeterConfigCaseBuilder();
- MultipartRequestMeterConfigBuilder mprMeterConfigBuild =
- new MultipartRequestMeterConfigBuilder();
- mprMeterConfigBuild.setMeterId(new MeterId(BinContent.intToUnsignedLong(
- org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common
- .types.rev130731.Meter.OFPMALL.getIntValue())));
- caseBuilder.setMultipartRequestMeterConfig(mprMeterConfigBuild.build());
-
- final Xid xid = data.getRequestContext().getXid();
- MultipartRequestInputBuilder mprInput = RequestInputUtils
- .createMultipartHeader(MultipartType.OFPMPMETERCONFIG, xid.getValue(), version);
- mprInput.setMultipartRequestBody(caseBuilder.build());
- Future<RpcResult<Void>> resultFromOFLib = deviceContext
- .getPrimaryConnectionContext().getConnectionAdapter().multipartRequest(mprInput.build());
- return JdkFutureAdapters
- .listenInPoolThread(resultFromOFLib);
- }
- });
+ .<GetAllMeterConfigStatisticsOutput, Void>handleServiceCall(new Function<DataCrate<GetAllMeterConfigStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
+
+ @Override
+ public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllMeterConfigStatisticsOutput> data) {
+
+ MultipartRequestMeterConfigCaseBuilder caseBuilder =
+ new MultipartRequestMeterConfigCaseBuilder();
+ MultipartRequestMeterConfigBuilder mprMeterConfigBuild =
+ new MultipartRequestMeterConfigBuilder();
+ mprMeterConfigBuild.setMeterId(new MeterId(BinContent.intToUnsignedLong(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common
+ .types.rev130731.Meter.OFPMALL.getIntValue())));
+ caseBuilder.setMultipartRequestMeterConfig(mprMeterConfigBuild.build());
+
+ final Xid xid = data.getRequestContext().getXid();
+ MultipartRequestInputBuilder mprInput = RequestInputUtils
+ .createMultipartHeader(MultipartType.OFPMPMETERCONFIG, xid.getValue(), getVersion());
+ mprInput.setMultipartRequestBody(caseBuilder.build());
+ Future<RpcResult<Void>> resultFromOFLib = getDeviceContext()
+ .getPrimaryConnectionContext().getConnectionAdapter().multipartRequest(mprInput.build());
+ return JdkFutureAdapters
+ .listenInPoolThread(resultFromOFLib);
+ }
+ });
}
public Future<RpcResult<GetAllMeterStatisticsOutput>> getAllMeterStatistics(final GetAllMeterStatisticsInput input) {
return this.<GetAllMeterStatisticsOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION,
new Function<DataCrate<GetAllMeterStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllMeterStatisticsOutput> data) {
final Xid xid = data.getRequestContext().getXid();
MultipartRequestInputBuilder mprInput = RequestInputUtils
- .createMultipartHeader(MultipartType.OFPMPMETER, xid.getValue(), version);
+ .createMultipartHeader(MultipartType.OFPMPMETER, xid.getValue(), getVersion());
mprInput.setMultipartRequestBody(caseBuilder.build());
- Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
@Override
public Future<RpcResult<GetMeterFeaturesOutput>> getMeterFeatures(final GetMeterFeaturesInput input) {
return this.<GetMeterFeaturesOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION,
new Function<DataCrate<GetMeterFeaturesOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetMeterFeaturesOutput> data) {
final Xid xid = data.getRequestContext().getXid();
MultipartRequestInputBuilder mprInput =
- RequestInputUtils.createMultipartHeader(MultipartType.OFPMPMETERFEATURES, xid.getValue(), version);
+ RequestInputUtils.createMultipartHeader(MultipartType.OFPMPMETERFEATURES, xid.getValue(), getVersion());
mprInput.setMultipartRequestBody(mprMeterFeaturesBuild.build());
- Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext().getConnectionAdapter().multipartRequest(mprInput.build());
+ Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext().getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
});
@Override
public Future<RpcResult<GetMeterStatisticsOutput>> getMeterStatistics(final GetMeterStatisticsInput input) {
return this.<GetMeterStatisticsOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION,
new Function<DataCrate<GetMeterStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetMeterStatisticsOutput> data) {
final Xid xid = data.getRequestContext().getXid();
MultipartRequestInputBuilder mprInput =
- RequestInputUtils.createMultipartHeader(MultipartType.OFPMPMETER, xid.getValue(), version);
+ RequestInputUtils.createMultipartHeader(MultipartType.OFPMPMETER, xid.getValue(), getVersion());
mprInput.setMultipartRequestBody(caseBuilder.build());
- Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext().getConnectionAdapter().multipartRequest(mprInput.build());
+ Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext().getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
});
final GetAllNodeConnectorsStatisticsInput input) {
return this
.<GetAllNodeConnectorsStatisticsOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION, new Function<DataCrate<GetAllNodeConnectorsStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
+ new Function<DataCrate<GetAllNodeConnectorsStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllNodeConnectorsStatisticsOutput> data) {
final Xid xid = data.getRequestContext().getXid();
MultipartRequestInputBuilder mprInput = RequestInputUtils
- .createMultipartHeader(MultipartType.OFPMPPORTSTATS, xid.getValue(), version);
+ .createMultipartHeader(MultipartType.OFPMPPORTSTATS, xid.getValue(), getVersion());
mprInput.setMultipartRequestBody(caseBuilder.build());
- Future<RpcResult<Void>> resultFromOFLib = deviceContext
+ Future<RpcResult<Void>> resultFromOFLib = getDeviceContext()
.getPrimaryConnectionContext().getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
final GetNodeConnectorStatisticsInput input) {
return this
.<GetNodeConnectorStatisticsOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION, new Function<DataCrate<GetNodeConnectorStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
+ new Function<DataCrate<GetNodeConnectorStatisticsOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetNodeConnectorStatisticsOutput> data) {
MultipartRequestPortStatsBuilder mprPortStatsBuilder =
new MultipartRequestPortStatsBuilder();
// Set specific port
+ final short version = getVersion();
mprPortStatsBuilder
.setPortNo(InventoryDataServiceUtil.portNumberfromNodeConnectorId(
OpenflowVersion.get(version),
MultipartRequestInputBuilder mprInput = RequestInputUtils
.createMultipartHeader(MultipartType.OFPMPPORTSTATS, xid.getValue(), version);
mprInput.setMultipartRequestBody(caseBuilder.build());
- Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
public Future<RpcResult<GetAllQueuesStatisticsFromAllPortsOutput>> getAllQueuesStatisticsFromAllPorts(
final GetAllQueuesStatisticsFromAllPortsInput input) {
return this.<GetAllQueuesStatisticsFromAllPortsOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION, new Function<DataCrate<GetAllQueuesStatisticsFromAllPortsOutput>, ListenableFuture<RpcResult<Void>>>() {
+ new Function<DataCrate<GetAllQueuesStatisticsFromAllPortsOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllQueuesStatisticsFromAllPortsOutput> data) {
// Set request body to main multipart request
final Xid xid = data.getRequestContext().getXid();
MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
- MultipartType.OFPMPQUEUE, xid.getValue(), version);
+ MultipartType.OFPMPQUEUE, xid.getValue(), getVersion());
mprInput.setMultipartRequestBody(caseBuilder.build());
- Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
public Future<RpcResult<GetAllQueuesStatisticsFromGivenPortOutput>> getAllQueuesStatisticsFromGivenPort(
final GetAllQueuesStatisticsFromGivenPortInput input) {
return this.<GetAllQueuesStatisticsFromGivenPortOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION, new Function<DataCrate<GetAllQueuesStatisticsFromGivenPortOutput>, ListenableFuture<RpcResult<Void>>>() {
+ new Function<DataCrate<GetAllQueuesStatisticsFromGivenPortOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetAllQueuesStatisticsFromGivenPortOutput> data) {
// Select all queues
mprQueueBuilder.setQueueId(OFConstants.OFPQ_ALL);
// Select specific port
+ final short version = getVersion();
mprQueueBuilder.setPortNo(InventoryDataServiceUtil.portNumberfromNodeConnectorId(
OpenflowVersion.get(version), input.getNodeConnectorId()));
caseBuilder.setMultipartRequestQueue(mprQueueBuilder.build());
MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
MultipartType.OFPMPQUEUE, xid.getValue(), version);
mprInput.setMultipartRequestBody(caseBuilder.build());
- Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
public Future<RpcResult<GetQueueStatisticsFromGivenPortOutput>> getQueueStatisticsFromGivenPort(
final GetQueueStatisticsFromGivenPortInput input) {
return this.<GetQueueStatisticsFromGivenPortOutput, Void>handleServiceCall(
- PRIMARY_CONNECTION, new Function<DataCrate<GetQueueStatisticsFromGivenPortOutput>, ListenableFuture<RpcResult<Void>>>() {
+ new Function<DataCrate<GetQueueStatisticsFromGivenPortOutput>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<GetQueueStatisticsFromGivenPortOutput> data) {
// Select specific queue
mprQueueBuilder.setQueueId(input.getQueueId().getValue());
// Select specific port
+ final short version = getVersion();
mprQueueBuilder.setPortNo(InventoryDataServiceUtil.portNumberfromNodeConnectorId(
OpenflowVersion.get(version), input.getNodeConnectorId()));
caseBuilder.setMultipartRequestQueue(mprQueueBuilder.build());
MultipartRequestInputBuilder mprInput = RequestInputUtils.createMultipartHeader(
MultipartType.OFPMPQUEUE, xid.getValue(), version);
mprInput.setMultipartRequestBody(caseBuilder.build());
- Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
+ Future<RpcResult<Void>> resultFromOFLib = getDeviceContext().getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(mprInput.build());
return JdkFutureAdapters.listenInPoolThread(resultFromOFLib);
}
public Future<RpcResult<List<MultipartReply>>> getStatisticsOfType(final MultipartType type) {
- return handleServiceCall(
- PRIMARY_CONNECTION, new Function<DataCrate<List<MultipartReply>>, ListenableFuture<RpcResult<Void>>>() {
+ return handleServiceCall( new Function<DataCrate<List<MultipartReply>>, ListenableFuture<RpcResult<Void>>>() {
@Override
public ListenableFuture<RpcResult<Void>> apply(final DataCrate<List<MultipartReply>> data) {
final Xid xid = data.getRequestContext().getXid();
+ final DeviceContext deviceContext = getDeviceContext();
deviceContext.getOpenflowMessageListenerFacade().registerMultipartXid(xid.getValue());
MultipartRequestInput multipartRequestInput = MultipartRequestInputFactory.
makeMultipartRequestInput(xid.getValue(),
- version,
+ getVersion(),
type);
final Future<RpcResult<Void>> resultFromOFLib = deviceContext.getPrimaryConnectionContext()
.getConnectionAdapter().multipartRequest(multipartRequestInput);
Code Review / openflowplugin.git / commitdiff