private ConnectionManager connectionManager;
private ListeningExecutorService executorService;
private ContextChainHolderImpl contextChainHolder;
- private OpenflowPluginDiagStatusProvider openflowPluginStatusMonitor;
+ private final OpenflowPluginDiagStatusProvider openflowPluginStatusMonitor;
public static MessageIntelligenceAgency getMessageIntelligenceAgency() {
return MESSAGE_INTELLIGENCE_AGENCY;
return switchConnectionProvider.startup();
}).collect(Collectors.toSet())), new FutureCallback<List<Boolean>>() {
@Override
- public void onSuccess(final List<Boolean> result) {
+ public void onSuccess(@Nonnull final List<Boolean> result) {
LOG.info("All switchConnectionProviders are up and running ({}).", result.size());
openflowPluginStatusMonitor.reportStatus(ServiceState.OPERATIONAL, "switch connections started");
}
Futures.addCallback(listListenableFuture, new FutureCallback<List<Boolean>>() {
@Override
- public void onSuccess(final List<Boolean> result) {
+ public void onSuccess(@Nonnull final List<Boolean> result) {
LOG.info("All switchConnectionProviders were successfully shut down ({}).", result.size());
}
import java.util.List;
import java.util.Objects;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.core.ErrorHandler;
ListenableFuture<RpcResult<Void>> rpcResultListenableFuture = JdkFutureAdapters.listenInPoolThread(helloResult);
Futures.addCallback(rpcResultListenableFuture, new FutureCallback<RpcResult<Void>>() {
@Override
- public void onSuccess(RpcResult<Void> result) {
+ public void onSuccess(@Nonnull RpcResult<Void> result) {
if (result.isSuccessful()) {
LOG.debug("hello successfully sent, xid={}, addr={}", helloXid,
connectionAdapter.getRemoteAddress());
Futures.addCallback(JdkFutureAdapters.listenInPoolThread(featuresFuture),
new FutureCallback<RpcResult<GetFeaturesOutput>>() {
@Override
- public void onSuccess(RpcResult<GetFeaturesOutput> rpcFeatures) {
+ public void onSuccess(@Nonnull RpcResult<GetFeaturesOutput> rpcFeatures) {
LOG.trace("features are back");
if (rpcFeatures.isSuccessful()) {
GetFeaturesOutput featureOutput = rpcFeatures.getResult();
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import io.netty.util.HashedWheelTimer;
import java.util.Collection;
import java.util.Collections;
}
@Override
+ // The cast to PacketInMessage is safe as the implemented interface is verified before the cas tbut FB doesn't
+ // recognize it.
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
public boolean processAlienMessage(final OfHeader message) {
final Class<? extends DataContainer> implementedInterface = message.getImplementedInterface();
private final NotificationPublishService notificationPublishService;
private final MessageSpy messageSpy;
private final HashedWheelTimer hashedWheelTimer;
+ private final Object updatePacketInRateLimitersLock = new Object();
private TranslatorLibrary translatorLibrary;
private ExtensionConverterProvider extensionConverterProvider;
private ScheduledThreadPoolExecutor spyPool;
}
+ @Override
public DeviceContext createContext(@Nonnull final ConnectionContext connectionContext) {
LOG.info("ConnectionEvent: Device connected to controller, Device:{}, NodeId:{}",
}
private void updatePacketInRateLimiters() {
- synchronized (deviceContexts) {
+ synchronized (updatePacketInRateLimitersLock) {
final int deviceContextsSize = deviceContexts.size();
if (deviceContextsSize > 0) {
long freshNotificationLimit = config.getGlobalNotificationQuota() / deviceContextsSize;
if (LOG.isDebugEnabled()) {
LOG.debug("Device context removed for node {}", deviceInfo);
}
- if (deviceContexts.size() > 0) {
- this.updatePacketInRateLimiters();
- }
+
+ this.updatePacketInRateLimiters();
}
@Override
abstract class SimpleRatelimiter {
private final AtomicInteger counter = new AtomicInteger();
+ private final Object counterLock = new Object();
+ @GuardedBy("counterLock")
private int lowWatermark;
- private int lowWatermarkEffective;
- private int highWatermark;
- @GuardedBy("counter")
+ private volatile int lowWatermarkEffective;
+ private volatile int highWatermark;
+ @GuardedBy("counterLock")
private volatile boolean limited;
SimpleRatelimiter(final int lowWatermark, final int highWatermark) {
boolean acquirePermit() {
final int cnt = counter.incrementAndGet();
if (cnt > highWatermark) {
- synchronized (counter) {
+ synchronized (counterLock) {
final int recheck = counter.decrementAndGet();
if (recheck >= highWatermark && !limited) {
disableFlow();
void releasePermit() {
final int cnt = counter.decrementAndGet();
if (cnt <= lowWatermarkEffective) {
- synchronized (counter) {
+ synchronized (counterLock) {
final int recheck = counter.get();
if (recheck <= lowWatermarkEffective && limited) {
enableFlow();
}
}
- void resetLowWaterMark() {
- synchronized (counter) {
- lowWatermarkEffective = lowWatermark;
- }
+ @GuardedBy("counterLock")
+ private void resetLowWaterMark() {
+ lowWatermarkEffective = lowWatermark;
}
void adaptLowWaterMarkAndDisableFlow(int temporaryLowWaterMark) {
if (temporaryLowWaterMark < highWatermark) {
- synchronized (counter) {
+ synchronized (counterLock) {
lowWatermarkEffective = temporaryLowWaterMark;
if (!limited) {
disableFlow();
}
void changeWaterMarks(final int newLowWatermark, final int newHighWatermark) {
- synchronized (counter) {
+ synchronized (counterLock) {
lowWatermark = newLowWatermark;
highWatermark = newHighWatermark;
resetLowWaterMark();
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
-import java.util.List;
import java.util.concurrent.Future;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.CapabilitiesV10;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsDataBuilder;
-import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
new SingleLayerMultipartCollectorService(deviceContext, deviceContext);
return Futures.transform(service.handleServiceCall(multipartType),
- new Function<RpcResult<List<MultipartReply>>, Boolean>() {
- @Nonnull
- @Override
- public Boolean apply(final RpcResult<List<MultipartReply>> input) {
- return input.isSuccessful();
- }
- }, MoreExecutors.directExecutor());
+ input -> input.isSuccessful(), MoreExecutors.directExecutor());
}
final MultiLayerMultipartCollectorService service =
new MultiLayerMultipartCollectorService(deviceContext, deviceContext);
return Futures.transform(service.handleServiceCall(multipartType),
- new Function<RpcResult<List<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol
- .rev130731.MultipartReply>>, Boolean>() {
- @Nonnull
- @Override
- public Boolean apply(final RpcResult<List<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow
- .protocol
- .rev130731.MultipartReply>> input) {
- return input.isSuccessful();
- }
- }, MoreExecutors.directExecutor());
+ input -> input.isSuccessful(), MoreExecutors.directExecutor());
}
}
import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterFeatures;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Capabilities;
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;
multipartWriterProvider, convertorExecutor));
return Futures.transform(
- (switchFeaturesMandatory ? Futures.allAsList(futures) : Futures.successfulAsList(futures)),
+ switchFeaturesMandatory ? Futures.allAsList(futures) : Futures.successfulAsList(futures),
new Function<List<RpcResult<List<OfHeader>>>, Void>() {
@Nullable
@Override
@Nullable final ConvertorExecutor convertorExecutor) {
Futures.addCallback(future, new FutureCallback<RpcResult<List<OfHeader>>>() {
@Override
- public void onSuccess(final RpcResult<List<OfHeader>> result) {
+ public void onSuccess(@Nonnull final RpcResult<List<OfHeader>> result) {
if (Objects.nonNull(result.getResult())) {
LOG.info("Static node {} info: {} collected", deviceContext.getDeviceInfo(), type);
translateAndWriteResult(
new SingleLayerMultipartCollectorService(deviceContext, deviceContext);
return Futures.transform(service.handleServiceCall(multipartType),
- new Function<RpcResult<List<MultipartReply>>, RpcResult<List<OfHeader>>>() {
- @Nonnull
- @Override
- public RpcResult<List<OfHeader>> apply(final RpcResult<List<MultipartReply>> input) {
- if (Objects.isNull(input.getResult()) && input.isSuccessful()) {
- final List<OfHeader> temp = null;
- return RpcResultBuilder.success(temp).build();
- }
+ input -> {
+ if (Objects.isNull(input.getResult()) && input.isSuccessful()) {
+ return RpcResultBuilder.<List<OfHeader>>success(null).build();
+ }
- return input.isSuccessful()
- ? RpcResultBuilder.success(input
+ return input.isSuccessful()
+ ? RpcResultBuilder.success(input
.getResult()
.stream()
.map(OfHeader.class::cast)
.collect(Collectors.toList()))
.build()
- : RpcResultBuilder.<List<OfHeader>>failed()
+ : RpcResultBuilder.<List<OfHeader>>failed()
.withRpcErrors(input.getErrors())
.build();
- }
- }, MoreExecutors.directExecutor());
+ }, MoreExecutors.directExecutor());
}
final MultiLayerMultipartCollectorService service =
new MultiLayerMultipartCollectorService(deviceContext, deviceContext);
- return Futures.transform(service.handleServiceCall(multipartType), new Function<RpcResult<List<org
- .opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReply>>,
- RpcResult<List<OfHeader>>>() {
- @Nonnull
- @Override
- public RpcResult<List<OfHeader>> apply(final RpcResult<List<org.opendaylight.yang.gen.v1.urn.opendaylight
- .openflow.protocol.rev130731.MultipartReply>> input) {
- if (Objects.isNull(input.getResult()) && input.isSuccessful()) {
- final List<OfHeader> temp = null;
- return RpcResultBuilder.success(temp).build();
- }
-
- return input.isSuccessful()
- ? RpcResultBuilder.success(input
- .getResult()
- .stream()
- .map(OfHeader.class::cast)
- .collect(Collectors.toList()))
- .build()
- : RpcResultBuilder.<List<OfHeader>>failed()
- .withRpcErrors(input.getErrors())
- .build();
+ return Futures.transform(service.handleServiceCall(multipartType), input -> {
+ if (Objects.isNull(input.getResult()) && input.isSuccessful()) {
+ return RpcResultBuilder.<List<OfHeader>>success(null).build();
}
+
+ return input.isSuccessful() ? RpcResultBuilder
+ .success(input.getResult().stream().map(OfHeader.class::cast).collect(Collectors.toList())).build()
+ : RpcResultBuilder.<List<OfHeader>>failed().withRpcErrors(input.getErrors()).build();
}, MoreExecutors.directExecutor());
}
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
}
@Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
public void ownershipChanged(EntityOwnershipChange entityOwnershipChange) {
if (entityOwnershipChange.getState().hasOwner()) {
return;
}
+ // Findbugs flags a false violation for "Unchecked/unconfirmed cast" from GenericEntity to Entity hence the
+ // suppression above. The suppression is temporary until EntityOwnershipChange is modified to eliminate the
+ // violation.
final String entityName = entityOwnershipChange
.getEntity()
.getIdentifier()
LOG.info("Started clustering services for node {}", deviceInfo);
} catch (final Exception ex) {
LOG.warn("Not able to start clustering services for node {}", deviceInfo);
- executorService.submit(() -> contextChainMastershipWatcher
+ executorService.execute(() -> contextChainMastershipWatcher
.onNotAbleToStartMastershipMandatory(deviceInfo, ex.toString()));
}
}
@Override
public boolean addAuxiliaryConnection(@Nonnull ConnectionContext connectionContext) {
- return (connectionContext.getFeatures().getAuxiliaryId() != 0)
- && (!ConnectionContext.CONNECTION_STATE.RIP.equals(primaryConnection.getConnectionState()))
+ return connectionContext.getFeatures().getAuxiliaryId() != 0
+ && !ConnectionContext.CONNECTION_STATE.RIP.equals(primaryConnection.getConnectionState())
&& auxiliaryConnections.add(connectionContext);
}
masterStateOnDevice.set(false);
rpcRegistration.set(false);
}
-}
\ No newline at end of file
+}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.ListenableFuture;
-import java.util.ArrayList;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
import org.opendaylight.openflowplugin.api.openflow.lifecycle.MasterChecker;
public final class MastershipChangeServiceManagerImpl implements MastershipChangeServiceManager {
- private final List<MastershipChangeService> serviceGroup = new ArrayList<>();
+ private final List<MastershipChangeService> serviceGroup = new CopyOnWriteArrayList<>();
private ReconciliationFrameworkEvent rfService = null;
private MasterChecker masterChecker;
new MastershipServiceDelegate(service, () -> serviceGroup.remove(service));
serviceGroup.add(service);
if (masterChecker != null && masterChecker.isAnyDeviceMastered()) {
- fireBecomeOwnerAfterRegistration(service);
+ masterChecker.listOfMasteredDevices().forEach(service::onBecomeOwner);
}
return registration;
}
}
@Override
+ // FB flags this for onDeviceDisconnected but unclear why - seems a false positive.
+ @SuppressFBWarnings("RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT")
public void becomeSlaveOrDisconnect(@Nonnull final DeviceInfo deviceInfo) {
if (rfService != null) {
rfService.onDeviceDisconnected(deviceInfo);
@Override
public boolean isReconciliationFrameworkRegistered() {
- return (rfService != null);
+ return rfService != null;
}
@VisibleForTesting
int serviceGroupListSize() {
return serviceGroup.size();
}
-
- private void fireBecomeOwnerAfterRegistration(@Nonnull final MastershipChangeService service) {
- masterChecker.listOfMasteredDevices().forEach(service::onBecomeOwner);
- }
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistryInjector;
@Override
public Action deserialize(ByteBuf message) {
- final MatchEntryDeserializer deserializer = registry.getDeserializer(MATCH_KEY);
+ final MatchEntryDeserializer deserializer = Preconditions.checkNotNull(registry).getDeserializer(MATCH_KEY);
final MatchBuilder builder = new MatchBuilder();
final int startIndex = message.readerIndex();
package org.opendaylight.openflowplugin.impl.protocol.deserialization.match;
import io.netty.buffer.ByteBuf;
-
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
-
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistryInjector;
import org.opendaylight.openflowjava.protocol.api.extensibility.HeaderDeserializer;
final MatchBuilder builder = new MatchBuilder();
// OFP do not have any method to differentiate between OXM and standard match, so we do not care about type
- final int type = inBuffer.readUnsignedShort();
+ inBuffer.readUnsignedShort();
final int length = inBuffer.readUnsignedShort();
final int startIndex = inBuffer.readerIndex();
final int entriesLength = length - 2 * EncodeConstants.SIZE_OF_SHORT_IN_BYTES;
- while ((inBuffer.readerIndex() - startIndex) < entriesLength) {
+ while (inBuffer.readerIndex() - startIndex < entriesLength) {
deserializeEntry(inBuffer, builder);
}
package org.opendaylight.openflowplugin.impl.protocol.deserialization.messages;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.math.BigInteger;
import java.util.ArrayList;
message.skipBytes(PADDING);
- final OFDeserializer<Match> matchDeserializer = registry.getDeserializer(MATCH_KEY);
+ final OFDeserializer<Match> matchDeserializer = Preconditions.checkNotNull(registry).getDeserializer(MATCH_KEY);
builder.setMatch(new MatchBuilder(matchDeserializer.deserialize(message)).build());
final int length = message.readableBytes();
OFDeserializer<Instruction> deserializer = null;
if (InstructionConstants.APPLY_ACTIONS_TYPE == type) {
- deserializer = registry.getDeserializer(
+ deserializer = Preconditions.checkNotNull(registry).getDeserializer(
new MessageCodeActionExperimenterKey(
EncodeConstants.OF13_VERSION_ID, type, Instruction.class,
ActionPath.INVENTORY_FLOWNODE_TABLE_APPLY_ACTIONS,
null));
} else if (InstructionConstants.WRITE_ACTIONS_TYPE == type) {
- deserializer = registry.getDeserializer(
+ deserializer = Preconditions.checkNotNull(registry).getDeserializer(
new MessageCodeActionExperimenterKey(
EncodeConstants.OF13_VERSION_ID, type, Instruction.class,
ActionPath.INVENTORY_FLOWNODE_TABLE_WRITE_ACTIONS,
+ 2 * EncodeConstants.SIZE_OF_SHORT_IN_BYTES);
}
- deserializer = registry.getDeserializer(
+ deserializer = Preconditions.checkNotNull(registry).getDeserializer(
new MessageCodeExperimenterKey(
EncodeConstants.OF13_VERSION_ID, type, Instruction.class, expId));
}
}
private static FlowModFlags createFlowModFlagsFromBitmap(int input) {
- final Boolean ofp_FF_SendFlowRem = (input & 1 << 0) > 0;
- final Boolean ofp_FF_CheckOverlap = (input & 1 << 1) > 0;
- final Boolean ofp_FF_ResetCounts = (input & 1 << 2) > 0;
- final Boolean ofp_FF_NoPktCounts = (input & 1 << 3) > 0;
- final Boolean ofp_FF_NoBytCounts = (input & 1 << 4) > 0;
+ final Boolean ofp_FF_SendFlowRem = (input & 1 << 0) != 0;
+ final Boolean ofp_FF_CheckOverlap = (input & 1 << 1) != 0;
+ final Boolean ofp_FF_ResetCounts = (input & 1 << 2) != 0;
+ final Boolean ofp_FF_NoPktCounts = (input & 1 << 3) != 0;
+ final Boolean ofp_FF_NoBytCounts = (input & 1 << 4) != 0;
return new FlowModFlags(ofp_FF_CheckOverlap, ofp_FF_NoBytCounts, ofp_FF_NoPktCounts, ofp_FF_ResetCounts,
ofp_FF_SendFlowRem);
}
package org.opendaylight.openflowplugin.impl.protocol.deserialization.messages;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.math.BigInteger;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
.setXid(message.readUnsignedInt());
// We are ignoring buffer id and total len as it is not specified in OpenFlowPlugin models
- final long bufferId = message.readUnsignedInt();
- final int totalLen = message.readUnsignedShort();
+ message.readUnsignedInt();
+ message.readUnsignedShort();
packetInMessageBuilder
.setPacketInReason(PacketInUtil
packetInMessageBuilder
.setFlowCookie(new FlowCookie(new BigInteger(1, cookie)));
- final OFDeserializer<Match> matchDeserializer = registry.getDeserializer(MATCH_KEY);
+ final OFDeserializer<Match> matchDeserializer = Preconditions.checkNotNull(registry).getDeserializer(MATCH_KEY);
packetInMessageBuilder.setMatch(MatchUtil.transformMatch(matchDeserializer.deserialize(message),
org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.packet.in.message
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
import io.netty.buffer.ByteBuf;
+import java.nio.charset.StandardCharsets;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.multipart.reply.multipart.reply.body.MultipartReplyDescBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.reply.MultipartReplyBody;
message.readBytes(dpDescBytes);
return new MultipartReplyDescBuilder()
- .setManufacturer(new String(mfrDescBytes).trim())
- .setHardware(new String(hwDescBytes).trim())
- .setSoftware(new String(swDescBytes).trim())
- .setSerialNumber(new String(serialNumBytes).trim())
- .setDescription(new String(dpDescBytes).trim())
+ .setManufacturer(new String(mfrDescBytes, StandardCharsets.UTF_8).trim())
+ .setHardware(new String(hwDescBytes, StandardCharsets.UTF_8).trim())
+ .setSoftware(new String(swDescBytes, StandardCharsets.UTF_8).trim())
+ .setSerialNumber(new String(serialNumBytes, StandardCharsets.UTF_8).trim())
+ .setDescription(new String(dpDescBytes, StandardCharsets.UTF_8).trim())
.build();
}
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.math.BigInteger;
import java.util.ArrayList;
.setPacketCount(new Counter64(new BigInteger(1, packetCount)))
.setByteCount(new Counter64(new BigInteger(1, byteCount)));
- final OFDeserializer<Match> matchDeserializer = registry.getDeserializer(MATCH_KEY);
+ final OFDeserializer<Match> matchDeserializer =
+ Preconditions.checkNotNull(registry).getDeserializer(MATCH_KEY);
itemBuilder.setMatch(MatchUtil.transformMatch(matchDeserializer.deserialize(itemMessage),
org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match.class));
}
private static FlowModFlags createFlowModFlagsFromBitmap(int input) {
- final Boolean ofp_FF_SendFlowRem = (input & 1) > 0;
- final Boolean ofp_FF_CheckOverlap = (input & 1 << 1) > 0;
- final Boolean ofp_FF_ResetCounts = (input & 1 << 2) > 0;
- final Boolean ofp_FF_NoPktCounts = (input & 1 << 3) > 0;
- final Boolean ofp_FF_NoBytCounts = (input & 1 << 4) > 0;
+ final Boolean ofp_FF_SendFlowRem = (input & 1) != 0;
+ final Boolean ofp_FF_CheckOverlap = (input & 1 << 1) != 0;
+ final Boolean ofp_FF_ResetCounts = (input & 1 << 2) != 0;
+ final Boolean ofp_FF_NoPktCounts = (input & 1 << 3) != 0;
+ final Boolean ofp_FF_NoBytCounts = (input & 1 << 4) != 0;
return new FlowModFlags(ofp_FF_CheckOverlap, ofp_FF_NoBytCounts, ofp_FF_NoPktCounts, ofp_FF_ResetCounts,
ofp_FF_SendFlowRem);
}
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistryInjector;
final boolean reqMore = (message.readUnsignedShort() & 0x01) != 0;
message.skipBytes(PADDING_IN_MULTIPART_REPLY_HEADER);
- final OFDeserializer<MultipartReplyBody> deserializer = registry
+ final OFDeserializer<MultipartReplyBody> deserializer = Preconditions.checkNotNull(registry)
.getDeserializer(new MessageCodeKey(EncodeConstants.OF13_VERSION_ID,
type, MultipartReplyBody.class));
*/
static void injectSerializers(final SerializerExtensionProvider provider) {
// Inject new message serializers here using injector created by createInjector method
- final Function<Class<? extends MultipartRequestBody>, Consumer<OFSerializer<MultipartRequestBody>>> injector =
+ final Function<Class<? extends MultipartRequestBody>,
+ Consumer<OFSerializer<? extends MultipartRequestBody>>> injector =
createInjector(provider, EncodeConstants.OF13_VERSION_ID);
MultipartMatchFieldSerializerInjector.injectSerializers(provider);
* @return injector
*/
@VisibleForTesting
- static Function<Class<? extends MultipartRequestBody>, Consumer<OFSerializer<MultipartRequestBody>>> createInjector(
- final SerializerExtensionProvider provider,
- final byte version) {
+ static Function<Class<? extends MultipartRequestBody>,
+ Consumer<OFSerializer<? extends MultipartRequestBody>>> createInjector(
+ final SerializerExtensionProvider provider, final byte version) {
return type -> serializer ->
provider.registerSerializer(
new MessageTypeKey<>(version, type),
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
-public abstract class AbstractActionSerializer implements OFSerializer<Action>, HeaderSerializer<Action> {
+public abstract class AbstractActionSerializer<T extends Action> implements OFSerializer<T>, HeaderSerializer<T> {
@Override
- public void serialize(Action input, ByteBuf outBuffer) {
+ public void serialize(T input, ByteBuf outBuffer) {
outBuffer.writeShort(getType());
outBuffer.writeShort(getLength());
}
@Override
- public void serializeHeader(Action input, ByteBuf outBuffer) {
+ public void serializeHeader(T input, ByteBuf outBuffer) {
outBuffer.writeShort(getType());
outBuffer.writeShort(ActionConstants.ACTION_IDS_LENGTH);
}
package org.opendaylight.openflowplugin.impl.protocol.serialization.actions;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetFieldCase;
-public abstract class AbstractSetFieldActionSerializer extends AbstractActionSerializer implements
+public abstract class AbstractSetFieldActionSerializer extends AbstractActionSerializer<Action> implements
SerializerRegistryInjector {
private SerializerRegistry registry;
@Override
public void serialize(Action input, ByteBuf outBuffer) {
- final OFSerializer<Action> serializer = registry
+ final OFSerializer<Action> serializer = Preconditions.checkNotNull(registry)
.getSerializer(new MessageTypeKey<>(EncodeConstants.OF13_VERSION_ID, SetFieldCase.class));
serializer.serialize(buildAction(input), outBuffer);
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
-public class CopyTtlInActionSerializer extends AbstractActionSerializer {
+public class CopyTtlInActionSerializer extends AbstractActionSerializer<Action> {
@Override
public void serialize(Action action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
-public class CopyTtlOutActionSerializer extends AbstractActionSerializer {
+public class CopyTtlOutActionSerializer extends AbstractActionSerializer<Action> {
@Override
public void serialize(Action action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
-public class DecMplsTtlActionSerializer extends AbstractActionSerializer {
+public class DecMplsTtlActionSerializer extends AbstractActionSerializer<Action> {
@Override
public void serialize(Action action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
-public class DecNwTtlActionSerializer extends AbstractActionSerializer {
+public class DecNwTtlActionSerializer extends AbstractActionSerializer<Action> {
@Override
public void serialize(Action action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
-public class DropActionSerializer extends AbstractActionSerializer {
+public class DropActionSerializer extends AbstractActionSerializer<Action> {
@Override
public void serialize(Action action, ByteBuf outBuffer) {
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.group.action._case.GroupAction;
-public class GroupActionSerializer extends AbstractActionSerializer {
+public class GroupActionSerializer extends AbstractActionSerializer<GroupActionCase> {
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(GroupActionCase action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
- final GroupAction groupAction = GroupActionCase.class.cast(action).getGroupAction();
+ final GroupAction groupAction = action.getGroupAction();
outBuffer.writeInt(groupAction.getGroupId().intValue());
}
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.OutputActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputAction;
-public class OutputActionSerializer extends AbstractActionSerializer {
+public class OutputActionSerializer extends AbstractActionSerializer<OutputActionCase> {
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(OutputActionCase action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
- final OutputAction outputAction = OutputActionCase.class.cast(action).getOutputAction();
+ final OutputAction outputAction = action.getOutputAction();
Long value = InventoryDataServiceUtil.portNumberfromNodeConnectorId(
OpenflowVersion.OF13,
outputAction.getOutputNodeConnector().getValue());
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PopMplsActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.mpls.action._case.PopMplsAction;
-public class PopMplsActionSerializer extends AbstractActionSerializer {
+public class PopMplsActionSerializer extends AbstractActionSerializer<PopMplsActionCase> {
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(PopMplsActionCase action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
- final PopMplsAction popMplsAction = PopMplsActionCase.class.cast(action).getPopMplsAction();
+ final PopMplsAction popMplsAction = action.getPopMplsAction();
outBuffer.writeShort(popMplsAction.getEthernetType());
outBuffer.writeZero(ActionConstants.ETHERTYPE_ACTION_PADDING);
}
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
-public class PopPbbActionSerializer extends AbstractActionSerializer {
+public class PopPbbActionSerializer extends AbstractActionSerializer<Action> {
@Override
public void serialize(Action action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
-public class PopVlanActionSerializer extends AbstractActionSerializer {
+public class PopVlanActionSerializer extends AbstractActionSerializer<Action> {
@Override
public void serialize(Action action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushMplsActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.mpls.action._case.PushMplsAction;
-public class PushMplsActionSerializer extends AbstractActionSerializer {
+public class PushMplsActionSerializer extends AbstractActionSerializer<PushMplsActionCase> {
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(PushMplsActionCase action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
- final PushMplsAction pushMplsAction = PushMplsActionCase.class.cast(action).getPushMplsAction();
+ final PushMplsAction pushMplsAction = action.getPushMplsAction();
outBuffer.writeShort(pushMplsAction.getEthernetType());
outBuffer.writeZero(ActionConstants.ETHERTYPE_ACTION_PADDING);
}
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushPbbActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.pbb.action._case.PushPbbAction;
-public class PushPbbActionSerializer extends AbstractActionSerializer {
+public class PushPbbActionSerializer extends AbstractActionSerializer<PushPbbActionCase> {
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(PushPbbActionCase action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
- final PushPbbAction pushPbbAction = PushPbbActionCase.class.cast(action).getPushPbbAction();
+ final PushPbbAction pushPbbAction = action.getPushPbbAction();
outBuffer.writeShort(pushPbbAction.getEthernetType());
outBuffer.writeZero(ActionConstants.ETHERTYPE_ACTION_PADDING);
}
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.PushVlanActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.vlan.action._case.PushVlanAction;
-public class PushVlanActionSerializer extends AbstractActionSerializer {
+public class PushVlanActionSerializer extends AbstractActionSerializer<PushVlanActionCase> {
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(PushVlanActionCase action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
- final PushVlanAction pushVlanAction = PushVlanActionCase.class.cast(action).getPushVlanAction();
+ final PushVlanAction pushVlanAction = action.getPushVlanAction();
outBuffer.writeShort(pushVlanAction.getEthernetType());
outBuffer.writeZero(ActionConstants.ETHERTYPE_ACTION_PADDING);
}
package org.opendaylight.openflowplugin.impl.protocol.serialization.actions;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.HeaderSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetFieldCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.field._case.SetField;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
-public class SetFieldActionSerializer extends AbstractActionSerializer implements SerializerRegistryInjector {
+public class SetFieldActionSerializer extends AbstractActionSerializer<SetFieldCase>
+ implements SerializerRegistryInjector {
private SerializerRegistry registry;
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(SetFieldCase action, ByteBuf outBuffer) {
// Serialize field type and save position
final int startIndex = outBuffer.writerIndex();
outBuffer.writeShort(getType());
outBuffer.writeShort(EncodeConstants.EMPTY_LENGTH);
// Serialize match (using small workaround with serializeHeader method to serialize only match entries)
- final SetField setField = SetFieldCase.class.cast(action).getSetField();
- final HeaderSerializer<Match> serializer = registry
+ final SetField setField = action.getSetField();
+ final HeaderSerializer<Match> serializer = Preconditions.checkNotNull(registry)
.getSerializer(new MessageTypeKey<>(EncodeConstants.OF13_VERSION_ID, Match.class));
serializer.serializeHeader(setField, outBuffer);
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetMplsTtlActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.mpls.ttl.action._case.SetMplsTtlAction;
-public class SetMplsTtlActionSerializer extends AbstractActionSerializer {
+public class SetMplsTtlActionSerializer extends AbstractActionSerializer<SetMplsTtlActionCase> {
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(SetMplsTtlActionCase action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
- final SetMplsTtlAction setMplsTtlAction = SetMplsTtlActionCase.class.cast(action).getSetMplsTtlAction();
+ final SetMplsTtlAction setMplsTtlAction = action.getSetMplsTtlAction();
outBuffer.writeByte(setMplsTtlAction.getMplsTtl());
outBuffer.writeZero(ActionConstants.SET_MPLS_TTL_PADDING);
}
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetNwTtlActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.nw.ttl.action._case.SetNwTtlAction;
-public class SetNwTtlActionSerializer extends AbstractActionSerializer {
+public class SetNwTtlActionSerializer extends AbstractActionSerializer<SetNwTtlActionCase> {
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(SetNwTtlActionCase action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
- final SetNwTtlAction setNwTtlAction = SetNwTtlActionCase.class.cast(action).getSetNwTtlAction();
+ final SetNwTtlAction setNwTtlAction = action.getSetNwTtlAction();
outBuffer.writeByte(setNwTtlAction.getNwTtl());
outBuffer.writeZero(ActionConstants.SET_NW_TTL_PADDING);
}
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SetQueueActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.queue.action._case.SetQueueAction;
-public class SetQueueActionSerializer extends AbstractActionSerializer {
+public class SetQueueActionSerializer extends AbstractActionSerializer<SetQueueActionCase> {
@Override
- public void serialize(Action action, ByteBuf outBuffer) {
+ public void serialize(SetQueueActionCase action, ByteBuf outBuffer) {
super.serialize(action, outBuffer);
- final SetQueueAction setQueueAction = SetQueueActionCase.class.cast(action).getSetQueueAction();
+ final SetQueueAction setQueueAction = action.getSetQueueAction();
outBuffer.writeInt(setQueueAction.getQueueId().intValue());
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.ActionList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
-public abstract class AbstractActionInstructionSerializer extends AbstractInstructionSerializer implements
- SerializerRegistryInjector {
+public abstract class AbstractActionInstructionSerializer<T extends Instruction>
+ extends AbstractInstructionSerializer<T> implements SerializerRegistryInjector {
private SerializerRegistry registry;
@Override
- public void serialize(Instruction input, ByteBuf outBuffer) {
+ public void serialize(T input, ByteBuf outBuffer) {
outBuffer.writeShort(getType());
}
import org.opendaylight.openflowjava.protocol.impl.util.InstructionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
-public abstract class AbstractInstructionSerializer implements OFSerializer<Instruction>,
- HeaderSerializer<Instruction> {
+public abstract class AbstractInstructionSerializer<T extends Instruction> implements OFSerializer<T>,
+ HeaderSerializer<T> {
@Override
- public void serialize(Instruction input, ByteBuf outBuffer) {
+ public void serialize(T input, ByteBuf outBuffer) {
outBuffer.writeShort(getType());
outBuffer.writeShort(getLength());
}
@Override
- public void serializeHeader(Instruction input, ByteBuf outBuffer) {
+ public void serializeHeader(T input, ByteBuf outBuffer) {
outBuffer.writeShort(getType());
outBuffer.writeShort(InstructionConstants.INSTRUCTION_IDS_LENGTH);
}
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.impl.util.InstructionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCase;
-public class ApplyActionsInstructionSerializer extends AbstractActionInstructionSerializer {
+public class ApplyActionsInstructionSerializer extends AbstractActionInstructionSerializer<ApplyActionsCase> {
@Override
- public void serialize(Instruction input, ByteBuf outBuffer) {
+ public void serialize(ApplyActionsCase input, ByteBuf outBuffer) {
int index = outBuffer.writerIndex();
super.serialize(input, outBuffer);
- writeActions(ApplyActionsCase.class.cast(input).getApplyActions(),
- EncodeConstants.OF13_VERSION_ID, outBuffer,index);
+ writeActions(input.getApplyActions(), EncodeConstants.OF13_VERSION_ID, outBuffer,index);
}
@Override
import org.opendaylight.openflowjava.protocol.impl.util.InstructionConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
-public class ClearActionsInstructionSerializer extends AbstractInstructionSerializer {
+public class ClearActionsInstructionSerializer extends AbstractInstructionSerializer<Instruction> {
@Override
public void serialize(Instruction input, ByteBuf outBuffer) {
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.InstructionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.GoToTableCase;
-public class GoToTableInstructionSerializer extends AbstractInstructionSerializer {
+public class GoToTableInstructionSerializer extends AbstractInstructionSerializer<GoToTableCase> {
@Override
- public void serialize(Instruction input, ByteBuf outBuffer) {
+ public void serialize(GoToTableCase input, ByteBuf outBuffer) {
super.serialize(input, outBuffer);
- outBuffer.writeByte(GoToTableCase.class.cast(input).getGoToTable().getTableId());
+ outBuffer.writeByte(input.getGoToTable().getTableId());
outBuffer.writeZero(InstructionConstants.PADDING_IN_GOTO_TABLE);
}
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.InstructionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.MeterCase;
-public class MeterInstructionSerializer extends AbstractInstructionSerializer {
+public class MeterInstructionSerializer extends AbstractInstructionSerializer<MeterCase> {
@Override
- public void serialize(Instruction input, ByteBuf outBuffer) {
+ public void serialize(MeterCase input, ByteBuf outBuffer) {
super.serialize(input, outBuffer);
- outBuffer.writeInt(MeterCase.class.cast(input).getMeter().getMeterId().getValue().intValue());
+ outBuffer.writeInt(input.getMeter().getMeterId().getValue().intValue());
}
@Override
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.impl.util.InstructionConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteActionsCase;
-public class WriteActionsInstructionSerializer extends AbstractActionInstructionSerializer {
+public class WriteActionsInstructionSerializer extends AbstractActionInstructionSerializer<WriteActionsCase> {
@Override
- public void serialize(Instruction input, ByteBuf outBuffer) {
+ public void serialize(WriteActionsCase input, ByteBuf outBuffer) {
int index = outBuffer.writerIndex();
super.serialize(input, outBuffer);
- writeActions(WriteActionsCase.class.cast(input).getWriteActions(),
- EncodeConstants.OF13_VERSION_ID, outBuffer,index);
+ writeActions(input.getWriteActions(), EncodeConstants.OF13_VERSION_ID, outBuffer,index);
}
@Override
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.protocol.impl.util.InstructionConstants;
import org.opendaylight.openflowplugin.openflow.md.util.ByteUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.WriteMetadataCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.write.metadata._case.WriteMetadata;
-public class WriteMetadataInstructionSerializer extends AbstractInstructionSerializer {
+public class WriteMetadataInstructionSerializer extends AbstractInstructionSerializer<WriteMetadataCase> {
@Override
- public void serialize(Instruction input, ByteBuf outBuffer) {
+ public void serialize(WriteMetadataCase input, ByteBuf outBuffer) {
super.serialize(input, outBuffer);
- final WriteMetadata writeMetadata = WriteMetadataCase.class.cast(input).getWriteMetadata();
+ final WriteMetadata writeMetadata = input.getWriteMetadata();
outBuffer.writeZero(InstructionConstants.PADDING_IN_WRITE_METADATA);
outBuffer.writeBytes(ByteUtil
.convertBigIntegerToNBytes(writeMetadata.getMetadata(), EncodeConstants.SIZE_OF_LONG_IN_BYTES));
package org.opendaylight.openflowplugin.impl.protocol.serialization.messages;
import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.math.BigInteger;
import java.util.ArrayList;
* @param outBuffer output buffer
*/
private void writeMatch(final FlowMessage message, final ByteBuf outBuffer) {
- registry.<Match, OFSerializer<Match>>getSerializer(new MessageTypeKey<>(message.getVersion(), Match.class))
- .serialize(message.getMatch(), outBuffer);
+ Preconditions.checkNotNull(registry).<Match, OFSerializer<Match>>getSerializer(
+ new MessageTypeKey<>(message.getVersion(), Match.class)).serialize(message.getMatch(), outBuffer);
}
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.Optional;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowplugin.extension.api.TypeVersionKey;
import org.opendaylight.openflowplugin.extension.api.exception.ConversionException;
import org.opendaylight.openflowplugin.openflow.md.core.session.OFSessionUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.request.MultipartRequestBody;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.experimenter.core.ExperimenterDataOfChoice;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.experimenter.types.rev151020.experimenter.core.message.ExperimenterMessageOfChoice;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.experimenter.types.rev151020.multipart.request.multipart.request.body.MultipartRequestExperimenter;
-public class MultipartRequestExperimenterSerializer implements OFSerializer<MultipartRequestBody>,
+public class MultipartRequestExperimenterSerializer implements OFSerializer<MultipartRequestExperimenter>,
SerializerRegistryInjector {
private SerializerRegistry registry;
@Override
@SuppressWarnings("unchecked")
- public void serialize(final MultipartRequestBody multipartRequestBody, final ByteBuf byteBuf) {
- final MultipartRequestExperimenter multipartRequestExperimenter = MultipartRequestExperimenter
- .class
- .cast(multipartRequestBody);
-
+ public void serialize(final MultipartRequestExperimenter multipartRequestExperimenter, final ByteBuf byteBuf) {
try {
- final OFSerializer<ExperimenterMessageOfChoice> serializer = registry
+ final OFSerializer<ExperimenterMessageOfChoice> serializer = Preconditions.checkNotNull(registry)
.getSerializer(new MessageTypeKey<>(
EncodeConstants.OF13_VERSION_ID,
multipartRequestExperimenter.getExperimenterMessageOfChoice().getImplementedInterface()));
.getExperimenterMessageOfChoice().getImplementedInterface(),
OFConstants.OFP_VERSION_1_3)))
.ifPresent(converter -> {
- final OFSerializer<ExperimenterDataOfChoice> serializer = registry
+ final OFSerializer<ExperimenterDataOfChoice> serializer = Preconditions.checkNotNull(registry)
.getSerializer(ExperimenterSerializerKeyFactory
.createMultipartRequestSerializerKey(
EncodeConstants.OF13_VERSION_ID,
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.multipart.request.multipart.request.body.MultipartRequestFlowAggregateStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.request.MultipartRequestBody;
-public class MultipartRequestFlowAggregateStatsSerializer implements OFSerializer<MultipartRequestBody>,
+public class MultipartRequestFlowAggregateStatsSerializer implements OFSerializer<MultipartRequestFlowAggregateStats>,
SerializerRegistryInjector {
private static final byte PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01 = 3;
private SerializerRegistry registry;
@Override
- public void serialize(final MultipartRequestBody multipartRequestBody, final ByteBuf byteBuf) {
- final MultipartRequestFlowAggregateStats multipartRequestFlowAggregateStats = MultipartRequestFlowAggregateStats
- .class
- .cast(multipartRequestBody);
-
+ public void serialize(final MultipartRequestFlowAggregateStats multipartRequestFlowAggregateStats,
+ final ByteBuf byteBuf) {
byteBuf.writeByte(MoreObjects.firstNonNull(multipartRequestFlowAggregateStats.getTableId(),
OFConstants.OFPTT_ALL).byteValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01);
byteBuf.writeLong(MoreObjects.firstNonNull(multipartRequestFlowAggregateStats.getCookieMask(),
new FlowCookie(OFConstants.DEFAULT_COOKIE_MASK)).getValue().longValue());
- registry.<Match, OFSerializer<Match>>getSerializer(
+ Preconditions.checkNotNull(registry).<Match, OFSerializer<Match>>getSerializer(
new MessageTypeKey<>(EncodeConstants.OF13_VERSION_ID, Match.class))
.serialize(multipartRequestFlowAggregateStats.getMatch(), byteBuf);
}
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.multipart.request.multipart.request.body.MultipartRequestFlowStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.Match;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.request.MultipartRequestBody;
-public class MultipartRequestFlowStatsSerializer implements OFSerializer<MultipartRequestBody>,
+public class MultipartRequestFlowStatsSerializer implements OFSerializer<MultipartRequestFlowStats>,
SerializerRegistryInjector {
private static final byte PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01 = 3;
private SerializerRegistry registry;
@Override
- public void serialize(final MultipartRequestBody multipartRequestBody, final ByteBuf byteBuf) {
- final MultipartRequestFlowStats multipartRequestFlowStats = MultipartRequestFlowStats
- .class
- .cast(multipartRequestBody);
-
+ public void serialize(final MultipartRequestFlowStats multipartRequestFlowStats, final ByteBuf byteBuf) {
byteBuf.writeByte(MoreObjects.firstNonNull(multipartRequestFlowStats.getTableId(),
OFConstants.OFPTT_ALL).byteValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01);
byteBuf.writeLong(MoreObjects.firstNonNull(multipartRequestFlowStats.getCookieMask(),
new FlowCookie(OFConstants.DEFAULT_COOKIE_MASK)).getValue().longValue());
- registry.<Match, OFSerializer<Match>>getSerializer(
+ Preconditions.checkNotNull(registry).<Match, OFSerializer<Match>>getSerializer(
new MessageTypeKey<>(EncodeConstants.OF13_VERSION_ID, Match.class))
.serialize(multipartRequestFlowStats.getMatch(), byteBuf);
}
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.multipart.request.multipart.request.body.MultipartRequestGroupStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.request.MultipartRequestBody;
-public class MultipartRequestGroupStatsSerializer implements OFSerializer<MultipartRequestBody> {
+public class MultipartRequestGroupStatsSerializer implements OFSerializer<MultipartRequestGroupStats> {
private static final byte PADDING_IN_MULTIPART_REQUEST_GROUP_BODY = 4;
@Override
- public void serialize(final MultipartRequestBody multipartRequestBody, final ByteBuf byteBuf) {
- final MultipartRequestGroupStats multipartRequestGroupStats = MultipartRequestGroupStats
- .class
- .cast(multipartRequestBody);
-
+ public void serialize(final MultipartRequestGroupStats multipartRequestGroupStats, final ByteBuf byteBuf) {
byteBuf.writeInt(MoreObjects
.firstNonNull(multipartRequestGroupStats.getGroupId(), new GroupId(OFConstants.OFPG_ALL))
.getValue().intValue());
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.Objects;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
outBuffer.writeShort(ByteBufUtils.fillBitMask(0, message.isRequestMore()));
outBuffer.writeZero(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
- final OFSerializer<MultipartRequestBody> serializer = registry
+ final OFSerializer<MultipartRequestBody> serializer = Preconditions.checkNotNull(registry)
.getSerializer(new MessageTypeKey<>(
EncodeConstants.OF13_VERSION_ID,
multipartRequestBody.getImplementedInterface()));
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.multipart.request.multipart.request.body.MultipartRequestMeterConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.request.MultipartRequestBody;
-public class MultipartRequestMeterConfigSerializer implements OFSerializer<MultipartRequestBody> {
+public class MultipartRequestMeterConfigSerializer implements OFSerializer<MultipartRequestMeterConfig> {
private static final byte PADDING_IN_MULTIPART_REQUEST_METER_CONFIG_BODY = 4;
@Override
- public void serialize(final MultipartRequestBody multipartRequestBody, final ByteBuf byteBuf) {
- final MultipartRequestMeterConfig multipartRequestMeterConfig = MultipartRequestMeterConfig
- .class
- .cast(multipartRequestBody);
-
+ public void serialize(final MultipartRequestMeterConfig multipartRequestMeterConfig, final ByteBuf byteBuf) {
byteBuf.writeInt(MoreObjects.firstNonNull(multipartRequestMeterConfig.getMeterId(),
new MeterId(OFConstants.OFPM_ALL)).getValue().intValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_METER_CONFIG_BODY);
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.multipart.request.multipart.request.body.MultipartRequestMeterStats;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.request.MultipartRequestBody;
-public class MultipartRequestMeterStatsSerializer implements OFSerializer<MultipartRequestBody> {
+public class MultipartRequestMeterStatsSerializer implements OFSerializer<MultipartRequestMeterStats> {
private static final byte PADDING_IN_MULTIPART_REQUEST_METER_BODY = 4;
@Override
- public void serialize(final MultipartRequestBody multipartRequestBody, final ByteBuf byteBuf) {
- final MultipartRequestMeterStats multipartRequestMeterStats = MultipartRequestMeterStats
- .class
- .cast(multipartRequestBody);
-
+ public void serialize(final MultipartRequestMeterStats multipartRequestMeterStats, final ByteBuf byteBuf) {
byteBuf.writeInt(MoreObjects
.firstNonNull(multipartRequestMeterStats.getMeterId(), new MeterId(OFConstants.OFPM_ALL))
.getValue().intValue());
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.request.MultipartRequestBody;
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.multipart.request.multipart.request.body.MultipartRequestPortStats;
-public class MultipartRequestPortStatsSerializer implements OFSerializer<MultipartRequestBody> {
+public class MultipartRequestPortStatsSerializer implements OFSerializer<MultipartRequestPortStats> {
private static final byte PADDING_IN_MULTIPART_REQUEST_PORTSTATS_BODY = 4;
@Override
- public void serialize(final MultipartRequestBody multipartRequestBody, final ByteBuf byteBuf) {
- final MultipartRequestPortStats multipartRequestPortStats = MultipartRequestPortStats
- .class
- .cast(multipartRequestBody);
-
+ public void serialize(final MultipartRequestPortStats multipartRequestPortStats, final ByteBuf byteBuf) {
if (Objects.isNull(multipartRequestPortStats.getNodeConnectorId())) {
byteBuf.writeInt(OFConstants.OFPP_ANY.intValue());
} else {
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.queue.rev130925.QueueId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.request.MultipartRequestBody;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.multipart.request.multipart.request.body.MultipartRequestQueueStats;
-public class MultipartRequestQueueStatsSerializer implements OFSerializer<MultipartRequestBody> {
+public class MultipartRequestQueueStatsSerializer implements OFSerializer<MultipartRequestQueueStats> {
@Override
- public void serialize(final MultipartRequestBody multipartRequestBody, final ByteBuf byteBuf) {
- final MultipartRequestQueueStats multipartRequestQueueStats = MultipartRequestQueueStats
- .class
- .cast(multipartRequestBody);
-
+ public void serialize(final MultipartRequestQueueStats multipartRequestQueueStats, final ByteBuf byteBuf) {
if (Objects.isNull(multipartRequestQueueStats.getNodeConnectorId())) {
byteBuf.writeInt(OFConstants.OFPP_ANY.intValue());
} else {
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
+import java.nio.charset.StandardCharsets;
import java.util.Objects;
import java.util.Optional;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
import org.opendaylight.openflowjava.util.ByteBufUtils;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.multipart.request.MultipartRequestBody;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.multipart.request.multipart.request.body.MultipartRequestTableFeatures;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.feature.prop.type.TableFeaturePropType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.table.features.TableProperties;
-public class MultipartRequestTableFeaturesSerializer implements OFSerializer<MultipartRequestBody>,
+public class MultipartRequestTableFeaturesSerializer implements OFSerializer<MultipartRequestTableFeatures>,
SerializerRegistryInjector {
private static final byte PADDING_IN_MULTIPART_REQUEST_TABLE_FEATURES_BODY = 5;
private SerializerRegistry registry;
@Override
- public void serialize(final MultipartRequestBody multipartRequestBody, final ByteBuf byteBuf) {
- final MultipartRequestTableFeatures multipartRequestTableFeatures = MultipartRequestTableFeatures
- .class
- .cast(multipartRequestBody);
-
+ public void serialize(final MultipartRequestTableFeatures multipartRequestTableFeatures, final ByteBuf byteBuf) {
Optional
.ofNullable(multipartRequestTableFeatures.getTableFeatures())
.ifPresent(tableFeatures -> tableFeatures
byteBuf.writeShort(EncodeConstants.EMPTY_LENGTH);
byteBuf.writeByte(tableFeature.getTableId().byteValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_TABLE_FEATURES_BODY);
- byteBuf.writeBytes(tableFeature.getName().getBytes());
- byteBuf.writeZero(32 - tableFeature.getName().getBytes().length);
+ byteBuf.writeBytes(tableFeature.getName().getBytes(StandardCharsets.UTF_8));
+ byteBuf.writeZero(32 - tableFeature.getName().getBytes(StandardCharsets.UTF_8).length);
byteBuf.writeLong(tableFeature.getMetadataMatch().longValue());
byteBuf.writeLong(tableFeature.getMetadataWrite().longValue());
byteBuf.writeInt(ByteBufUtils.fillBitMask(0, tableFeature.getConfig().isDEPRECATEDMASK()));
.getTableFeaturePropType()
.getImplementedInterface();
- registry.<TableFeaturePropType, OFSerializer<TableFeaturePropType>>getSerializer(
+ Preconditions.checkNotNull(registry)
+ .<TableFeaturePropType, OFSerializer<TableFeaturePropType>>getSerializer(
new MessageTypeKey<>(EncodeConstants.OF13_VERSION_ID, clazz))
- .serialize(property.getTableFeaturePropType(), byteBuf);
+ .serialize(property.getTableFeaturePropType(), byteBuf);
}));
}
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getApplySetfieldMiss()
.getSetFieldMatch()
- .forEach(setFieldMatch -> registry
+ .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(
new MessageTypeKey<>(
EncodeConstants.OF13_VERSION_ID,
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getApplySetfield()
.getSetFieldMatch()
- .forEach(setFieldMatch -> registry
+ .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(
new MessageTypeKey<>(
EncodeConstants.OF13_VERSION_ID,
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getMatchSetfield()
.getSetFieldMatch()
- .forEach(setFieldMatch -> registry
+ .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(
new MessageTypeKey<>(
EncodeConstants.OF13_VERSION_ID,
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getWildcardSetfield()
.getSetFieldMatch()
- .forEach(setFieldMatch -> registry
+ .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(
new MessageTypeKey<>(
EncodeConstants.OF13_VERSION_ID,
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getWriteSetfieldMiss()
.getSetFieldMatch()
- .forEach(setFieldMatch -> registry
+ .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(
new MessageTypeKey<>(
EncodeConstants.OF13_VERSION_ID,
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
+import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getWriteSetfield()
.getSetFieldMatch()
- .forEach(setFieldMatch -> registry
+ .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(
new MessageTypeKey<>(
EncodeConstants.OF13_VERSION_ID,
Optional.ofNullable(OFSessionUtil.getExtensionConvertorProvider())
.flatMap(provider ->
(GeneralExtensionGrouping.class.isInstance(action)
- ? convertExtensionGrouping(provider, action, version)
+ ? convertExtensionGrouping(provider, (GeneralExtensionGrouping)action, version)
: convertGenericAction(provider, action, version))
.map(ofjAction -> {
final OFSerializer<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common
Optional.ofNullable(OFSessionUtil.getExtensionConvertorProvider())
.flatMap(provider ->
(GeneralExtensionGrouping.class.isInstance(action)
- ? convertExtensionGrouping(provider, action, version)
+ ? convertExtensionGrouping(provider, (GeneralExtensionGrouping)action, version)
: convertGenericAction(provider, action, version))
.map(ofjAction -> {
final HeaderSerializer<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow
* to OpenFlowJava action
*
* @param provider extension converter provider
- * @param action OpenFlowPlugin action
+ * @param action GeneralExtensionGrouping action
* @param version OpenFlow version
* @return optional OpenFlowJava action
*/
private static Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions
.grouping.Action> convertExtensionGrouping(final ExtensionConverterProvider provider,
- final Action action,
+ final GeneralExtensionGrouping action,
final short version) {
final ConverterExtensionKey<? extends ExtensionKey> key =
- new ConverterExtensionKey<>(GeneralExtensionGrouping.class.cast(action).getExtensionKey(), version);
+ new ConverterExtensionKey<>(action.getExtensionKey(), version);
final ConvertorToOFJava<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev150203.actions
.grouping.Action> converter = provider.getConverter(key);
- return Optional.ofNullable(converter).map(c -> c.convert(((GeneralExtensionGrouping) action).getExtension()));
+ return Optional.ofNullable(converter).map(c -> c.convert(action.getExtension()));
}
/**
Futures.addCallback(future, new FutureCallback<Optional<FlowCapableNode>>() {
@Override
- public void onSuccess(Optional<FlowCapableNode> result) {
+ public void onSuccess(@Nonnull Optional<FlowCapableNode> result) {
result.asSet().stream()
.filter(Objects::nonNull)
.filter(flowCapableNode -> Objects.nonNull(flowCapableNode.getTable()))
import java.util.Collection;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
handleServiceCall(roleRequestInputBuilder);
Futures.addCallback(genIdListenableFuture, new FutureCallback<RpcResult<RoleRequestOutput>>() {
@Override
- public void onSuccess(final RpcResult<RoleRequestOutput> roleRequestOutputRpcResult) {
+ public void onSuccess(@Nonnull final RpcResult<RoleRequestOutput> roleRequestOutputRpcResult) {
if (roleRequestOutputRpcResult.isSuccessful()) {
final RoleRequestOutput roleRequestOutput = roleRequestOutputRpcResult.getResult();
if (roleRequestOutput != null) {
final SettableFuture<RpcResult<SetRoleOutput>> finalFuture = SettableFuture.create();
Futures.addCallback(roleListenableFuture, new FutureCallback<RpcResult<RoleRequestOutput>>() {
@Override
- public void onSuccess(final RpcResult<RoleRequestOutput> roleRequestOutputRpcResult) {
+ public void onSuccess(@Nonnull final RpcResult<RoleRequestOutput> roleRequestOutputRpcResult) {
LOG.info("submitRoleChange onSuccess for device:{}, role:{}",
getDeviceInfo().getNodeId(), ofpRole);
final RoleRequestOutput roleRequestOutput = roleRequestOutputRpcResult.getResult();
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
return new Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>() {
@Nullable
@Override
- public RpcResult<ProcessFlatBatchOutput> apply(@Nullable final RpcResult<T> input) {
+ public RpcResult<ProcessFlatBatchOutput> apply(@Nonnull final RpcResult<T> input) {
List<BatchFailure> batchFailures = wrapBatchFlowFailuresForFlat(input, stepOffset);
ProcessFlatBatchOutputBuilder outputBuilder =
new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
return new Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>() {
@Nullable
@Override
- public RpcResult<ProcessFlatBatchOutput> apply(@Nullable final RpcResult<T> input) {
+ public RpcResult<ProcessFlatBatchOutput> apply(@Nonnull final RpcResult<T> input) {
List<BatchFailure> batchFailures = wrapBatchGroupFailuresForFlat(input, stepOffset);
ProcessFlatBatchOutputBuilder outputBuilder =
new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
return new Function<RpcResult<T>, RpcResult<ProcessFlatBatchOutput>>() {
@Nullable
@Override
- public RpcResult<ProcessFlatBatchOutput> apply(@Nullable final RpcResult<T> input) {
+ public RpcResult<ProcessFlatBatchOutput> apply(@Nonnull final RpcResult<T> input) {
List<BatchFailure> batchFailures = wrapBatchMeterFailuresForFlat(input, stepOffset);
ProcessFlatBatchOutputBuilder outputBuilder =
new ProcessFlatBatchOutputBuilder().setBatchFailure(batchFailures);
import java.util.List;
import java.util.Objects;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
class CallBackImpl implements FutureCallback<RpcResult<List<MultipartReply>>> {
@Override
- public void onSuccess(final RpcResult<List<MultipartReply>> result) {
+ public void onSuccess(@Nonnull final RpcResult<List<MultipartReply>> result) {
if (result.isSuccessful()) {
final List<MultipartReply> multipartReplies = result.getResult();
if (multipartReplies.isEmpty()) {
import java.util.Collections;
import java.util.List;
import java.util.Optional;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
final SettableFuture<RpcResult<O>> finalFuture = SettableFuture.create();
Futures.addCallback(allFutures, new FutureCallback<List<RpcResult<O>>>() {
@Override
- public void onSuccess(final List<RpcResult<O>> results) {
+ public void onSuccess(@Nonnull final List<RpcResult<O>> results) {
final ArrayList<RpcError> errors = new ArrayList();
for (RpcResult<O> flowModResult : results) {
if (flowModResult == null) {
import java.util.List;
import java.util.Optional;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
class CallBackImpl implements FutureCallback<RpcResult<List<MultipartReply>>> {
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- public void onSuccess(final RpcResult<List<MultipartReply>> result) {
+ public void onSuccess(@Nonnull final RpcResult<List<MultipartReply>> result) {
if (result.isSuccessful()) {
final List<MultipartReply> multipartReplies = result.getResult();
final MultipartReplyBody multipartReplyBody = multipartReply.getMultipartReplyBody();
if (multipartReplyBody instanceof MultipartReplyTableFeaturesCase) {
final MultipartReplyTableFeaturesCase tableFeaturesCase =
- ((MultipartReplyTableFeaturesCase) multipartReplyBody);
+ (MultipartReplyTableFeaturesCase) multipartReplyBody;
final MultipartReplyTableFeatures salTableFeatures = tableFeaturesCase
.getMultipartReplyTableFeatures();
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.opendaylight.experimenter.message.service.rev151020.SalExperimenterMessageService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.experimenter.message.service.rev151020.SendExperimenterInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.AddBundleMessagesInput;
final SettableFuture<RpcResult<Void>> result = SettableFuture.create();
Futures.addCallback(Futures.successfulAsList(partialResults), new FutureCallback<List<RpcResult<Void>>>() {
@Override
- public void onSuccess(List<RpcResult<Void>> results) {
+ public void onSuccess(@Nonnull List<RpcResult<Void>> results) {
final ArrayList<RpcError> errors = new ArrayList<>();
final RpcResultBuilder<Void> rpcResultBuilder;
for (RpcResult<Void> res : results) {
}, MoreExecutors.directExecutor());
return result;
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.openflowplugin.impl.services.sal;
-import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.Future;
-import javax.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.impl.services.EchoService;
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;
- }
- }, MoreExecutors.directExecutor());
+ return Futures.transform(rpcResultListenableFuture, 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;
+ }, MoreExecutors.directExecutor());
}
}
import java.util.List;
import java.util.Objects;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
Futures.addCallback(listListenableFuture, new FutureCallback<List<RpcResult<UpdateFlowOutput>>>() {
@Override
- public void onSuccess(final List<RpcResult<UpdateFlowOutput>> results) {
+ public void onSuccess(@Nonnull final List<RpcResult<UpdateFlowOutput>> results) {
final ArrayList<RpcError> errors = new ArrayList();
for (RpcResult<UpdateFlowOutput> flowModResult : results) {
if (flowModResult == null) {
}
@Override
- public void onSuccess(final RpcResult<AddFlowOutput> rpcResult) {
+ public void onSuccess(
@Nonnull final RpcResult<AddFlowOutput> rpcResult) {
if (rpcResult.isSuccessful()) {
final FlowDescriptor flowDescriptor;
}
@Override
- public void onSuccess(final RpcResult<RemoveFlowOutput> result) {
+ public void onSuccess(@Nonnull final RpcResult<RemoveFlowOutput> result) {
if (result.isSuccessful()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Flow remove finished without error for flow={}", input);
}
@Override
- public void onSuccess(final RpcResult<UpdateFlowOutput> updateFlowOutputRpcResult) {
+ public void onSuccess(@Nonnull final RpcResult<UpdateFlowOutput> updateFlowOutputRpcResult) {
final DeviceFlowRegistry deviceFlowRegistry = deviceContext.getDeviceFlowRegistry();
final UpdatedFlow updated = input.getUpdatedFlow();
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.impl.services.multilayer.MultiLayerGroupService;
Futures.addCallback(resultFuture, new FutureCallback<RpcResult<AddGroupOutput>>() {
@Override
- public void onSuccess(RpcResult<AddGroupOutput> result) {
+ public void onSuccess(
@Nonnull RpcResult<AddGroupOutput> result) {
if (result.isSuccessful()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Group add with id={} finished without error", input.getGroupId().getValue());
Futures.addCallback(resultFuture, new FutureCallback<RpcResult<UpdateGroupOutput>>() {
@Override
- public void onSuccess(RpcResult<UpdateGroupOutput> result) {
+ public void onSuccess(@Nonnull RpcResult<UpdateGroupOutput> result) {
if (result.isSuccessful()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Group update with original id={} finished without error",
Futures.addCallback(resultFuture, new FutureCallback<RpcResult<RemoveGroupOutput>>() {
@Override
- public void onSuccess(RpcResult<RemoveGroupOutput> result) {
+ public void onSuccess(@Nonnull RpcResult<RemoveGroupOutput> result) {
if (result.isSuccessful()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Group remove with id={} finished without error", input.getGroupId().getValue());
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.Future;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.impl.services.multilayer.MultiLayerMeterService;
Futures.addCallback(resultFuture, new FutureCallback<RpcResult<AddMeterOutput>>() {
@Override
- public void onSuccess(RpcResult<AddMeterOutput> result) {
+ public void onSuccess(
@Nonnull RpcResult<AddMeterOutput> result) {
if (result.isSuccessful()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Meter add with id={} finished without error", input.getMeterId());
Futures.addCallback(resultFuture, new FutureCallback<RpcResult<UpdateMeterOutput>>() {
@Override
- public void onSuccess(RpcResult<UpdateMeterOutput> result) {
+ public void onSuccess(@Nonnull RpcResult<UpdateMeterOutput> result) {
if (result.isSuccessful()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Meter update with id={} finished without error",
Futures.addCallback(resultFuture, new FutureCallback<RpcResult<RemoveMeterOutput>>() {
@Override
- public void onSuccess(RpcResult<RemoveMeterOutput> result) {
+ public void onSuccess(@Nonnull RpcResult<RemoveMeterOutput> result) {
if (result.isSuccessful()) {
if (LOG.isDebugEnabled()) {
LOG.debug("Meter remove with id={} finished without error", input.getMeterId());
import java.util.List;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
Futures.addCallback(handleServiceCall(input), new FutureCallback<RpcResult<List<MultipartReply>>>() {
@Override
- public void onSuccess(final RpcResult<List<MultipartReply>> result) {
+ public void onSuccess(@Nonnull final RpcResult<List<MultipartReply>> result) {
if (result.isSuccessful()) {
future.set(RpcResultBuilder
.success(new SendExperimenterMpRequestOutputBuilder()
import java.util.List;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContextStack;
import org.opendaylight.openflowplugin.api.openflow.device.Xid;
Futures.addCallback(handleServiceCall(input), new FutureCallback<RpcResult<List<MultipartReply>>>() {
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- public void onSuccess(final RpcResult<List<MultipartReply>> result) {
+ public void onSuccess(@Nonnull final RpcResult<List<MultipartReply>> result) {
if (result.isSuccessful()) {
final List<MultipartReply> multipartReplies = result.getResult();
if (multipartReplies.isEmpty()) {
return finalFuture;
}
-}
\ No newline at end of file
+}
// write end timestamp to state snapshot container
Futures.addCallback(newDataGathering, new FutureCallback<Boolean>() {
@Override
- public void onSuccess(final Boolean result) {
+ public void onSuccess(@Nonnull final Boolean result) {
StatisticsGatheringUtils.markDeviceStateSnapshotEnd(deviceInfo, deviceContext, result);
}
import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProvider;
import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProviderFactory;
import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.OpenflowProviderConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.sm.control.rev150812.ChangeStatisticsWorkModeInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.sm.control.rev150812.GetStatisticsWorkModeOutput;
private final Semaphore workModeGuard = new Semaphore(1, true);
private final BindingAwareBroker.RpcRegistration<StatisticsManagerControlService> controlServiceRegistration;
private final ListeningExecutorService executorService;
- private StatisticsWorkMode workMode = StatisticsWorkMode.COLLECTALL;
+ private final StatisticsWorkMode workMode = StatisticsWorkMode.COLLECTALL;
private boolean isStatisticsFullyDisabled;
public StatisticsManagerImpl(@Nonnull final OpenflowProviderConfig config,
final MultipartWriterProvider statisticsWriterProvider = MultipartWriterProviderFactory
.createDefaultProvider(deviceContext);
- final StatisticsContext statisticsContext =
- deviceContext.canUseSingleLayerSerialization()
- ? new StatisticsContextImpl<MultipartReply>(
- deviceContext,
- converterExecutor,
- statisticsWriterProvider,
- executorService,
- !isStatisticsFullyDisabled && config.isIsStatisticsPollingOn(),
- useReconciliationFramework,
- config.getBasicTimerDelay().getValue(),
- config.getMaximumTimerDelay().getValue()) :
- new StatisticsContextImpl<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow
- .protocol.rev130731.MultipartReply>(
- deviceContext,
- converterExecutor,
- statisticsWriterProvider,
- executorService,
- !isStatisticsFullyDisabled && config.isIsStatisticsPollingOn(),
- useReconciliationFramework,
- config.getBasicTimerDelay().getValue(),
- config.getMaximumTimerDelay().getValue());
+ final StatisticsContext statisticsContext = new StatisticsContextImpl<>(
+ deviceContext,
+ converterExecutor,
+ statisticsWriterProvider,
+ executorService,
+ !isStatisticsFullyDisabled && config.isIsStatisticsPollingOn(),
+ useReconciliationFramework,
+ config.getBasicTimerDelay().getValue(),
+ config.getMaximumTimerDelay().getValue());
contexts.put(deviceContext.getDeviceInfo(), statisticsContext);
return statisticsContext;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.opendaylight.openflowplugin.api.ConnectionException;
public class StatisticsPollingService extends AbstractScheduledService {
Futures.addCallback(gatheringSupplier.get(), new FutureCallback<Boolean>() {
@Override
- public void onSuccess(@Nullable final Boolean result) {
+ public void onSuccess(@Nonnull final Boolean result) {
waitFuture.complete(result);
}
}
}
}
-}
\ No newline at end of file
+}
import java.net.InetAddress;
import java.net.UnknownHostException;
+import java.util.Locale;
import java.util.Objects;
import javax.annotation.Nullable;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
return null;
}
- return new MacAddress(macAddress.getValue().toLowerCase());
+ return new MacAddress(macAddress.getValue().toLowerCase(Locale.ROOT));
}
/**
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
-import javax.annotation.Nullable;
+import javax.annotation.Nonnull;
import org.apache.commons.lang3.tuple.Pair;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
* Gather errors into collection and wrap it into {@link RpcResult} and propagate all {@link RpcError}.
*/
public static final Function<RpcResult<List<BatchFailedFlowsOutput>>,
- RpcResult<RemoveFlowsBatchOutput>> FLOW_REMOVE_TRANSFORM =
- new Function<RpcResult<List<BatchFailedFlowsOutput>>, RpcResult<RemoveFlowsBatchOutput>>() {
- @Nullable
- @Override
- public RpcResult<RemoveFlowsBatchOutput> apply(
- @Nullable final RpcResult<List<BatchFailedFlowsOutput>> batchFlowsCumulativeResult) {
+ RpcResult<RemoveFlowsBatchOutput>> FLOW_REMOVE_TRANSFORM =
+ batchFlowsCumulativeResult -> {
final RemoveFlowsBatchOutput batchOutput = new RemoveFlowsBatchOutputBuilder()
.setBatchFailedFlowsOutput(batchFlowsCumulativeResult.getResult()).build();
final RpcResultBuilder<RemoveFlowsBatchOutput> resultBld =
createCumulativeRpcResult(batchFlowsCumulativeResult, batchOutput);
return resultBld.build();
- }
- };
+ };
/**
* Gather errors into collection and wrap it into {@link RpcResult} and propagate all {@link RpcError}.
*/
public static final Function<RpcResult<List<BatchFailedFlowsOutput>>,
- RpcResult<AddFlowsBatchOutput>> FLOW_ADD_TRANSFORM =
- new Function<RpcResult<List<BatchFailedFlowsOutput>>, RpcResult<AddFlowsBatchOutput>>() {
- @Nullable
- @Override
- public RpcResult<AddFlowsBatchOutput> apply(
- @Nullable final RpcResult<List<BatchFailedFlowsOutput>> batchFlowsCumulativeResult) {
+ RpcResult<AddFlowsBatchOutput>> FLOW_ADD_TRANSFORM =
+ batchFlowsCumulativeResult -> {
final AddFlowsBatchOutput batchOutput = new AddFlowsBatchOutputBuilder()
.setBatchFailedFlowsOutput(batchFlowsCumulativeResult.getResult()).build();
final RpcResultBuilder<AddFlowsBatchOutput> resultBld =
createCumulativeRpcResult(batchFlowsCumulativeResult, batchOutput);
return resultBld.build();
- }
- };
+ };
/**
* Gather errors into collection and wrap it into {@link RpcResult} and propagate all {@link RpcError}.
*/
public static final Function<RpcResult<List<BatchFailedFlowsOutput>>,
- RpcResult<UpdateFlowsBatchOutput>> FLOW_UPDATE_TRANSFORM =
- new Function<RpcResult<List<BatchFailedFlowsOutput>>, RpcResult<UpdateFlowsBatchOutput>>() {
- @Nullable
- @Override
- public RpcResult<UpdateFlowsBatchOutput> apply(
- @Nullable final RpcResult<List<BatchFailedFlowsOutput>> batchFlowsCumulativeResult) {
+ RpcResult<UpdateFlowsBatchOutput>> FLOW_UPDATE_TRANSFORM =
+ batchFlowsCumulativeResult -> {
final UpdateFlowsBatchOutput batchOutput = new UpdateFlowsBatchOutputBuilder()
.setBatchFailedFlowsOutput(batchFlowsCumulativeResult.getResult()).build();
final RpcResultBuilder<UpdateFlowsBatchOutput> resultBld =
createCumulativeRpcResult(batchFlowsCumulativeResult, batchOutput);
return resultBld.build();
- }
- };
+ };
private FlowUtil() {
throw new IllegalStateException("This class should not be instantiated.");
@VisibleForTesting
static <T extends BatchFlowOutputListGrouping>
Function<Pair<RpcResult<T>, RpcResult<Void>>, RpcResult<T>> createComposingFunction() {
- return new Function<Pair<RpcResult<T>, RpcResult<Void>>, RpcResult<T>>() {
- @Nullable
- @Override
- public RpcResult<T> apply(@Nullable final Pair<RpcResult<T>, RpcResult<Void>> input) {
- final RpcResultBuilder<T> resultBld;
- if (input.getLeft().isSuccessful() && input.getRight().isSuccessful()) {
- resultBld = RpcResultBuilder.success();
- } else {
- resultBld = RpcResultBuilder.failed();
- }
+ return input -> {
+ final RpcResultBuilder<T> resultBld;
+ if (input.getLeft().isSuccessful() && input.getRight().isSuccessful()) {
+ resultBld = RpcResultBuilder.success();
+ } else {
+ resultBld = RpcResultBuilder.failed();
+ }
- final ArrayList<RpcError> rpcErrors = new ArrayList<>(input.getLeft().getErrors());
- rpcErrors.addAll(input.getRight().getErrors());
- resultBld.withRpcErrors(rpcErrors);
+ final ArrayList<RpcError> rpcErrors = new ArrayList<>(input.getLeft().getErrors());
+ rpcErrors.addAll(input.getRight().getErrors());
+ resultBld.withRpcErrors(rpcErrors);
- resultBld.withResult(input.getLeft().getResult());
+ resultBld.withResult(input.getLeft().getResult());
- return resultBld.build();
- }
+ return resultBld.build();
};
}
}
public Function<List<RpcResult<O>>, RpcResult<List<BatchFailedFlowsOutput>>> invoke() {
- return new Function<List<RpcResult<O>>, RpcResult<List<BatchFailedFlowsOutput>>>() {
- @Nullable
- @Override
- public RpcResult<List<BatchFailedFlowsOutput>> apply(@Nullable final List<RpcResult<O>> innerInput) {
- final int sizeOfFutures = innerInput.size();
- final int sizeOfInputBatch = inputBatchFlows.size();
- Preconditions.checkArgument(sizeOfFutures == sizeOfInputBatch,
- "wrong amount of returned futures: {} <> {}", sizeOfFutures, sizeOfInputBatch);
-
- final ArrayList<BatchFailedFlowsOutput> batchFlows = new ArrayList<>(sizeOfFutures);
- final Iterator<? extends BatchFlowIdGrouping> batchFlowIterator = inputBatchFlows.iterator();
-
- Collection<RpcError> flowErrors = new ArrayList<>(sizeOfFutures);
-
- int batchOrder = 0;
- for (RpcResult<O> flowModOutput : innerInput) {
- final FlowId flowId = batchFlowIterator.next().getFlowId();
-
- if (!flowModOutput.isSuccessful()) {
- batchFlows.add(new BatchFailedFlowsOutputBuilder()
- .setFlowId(flowId)
- .setBatchOrder(batchOrder)
- .build());
- flowErrors.addAll(flowModOutput.getErrors());
- }
- batchOrder++;
+ return (@Nonnull final List<RpcResult<O>> innerInput) -> {
+ final int sizeOfFutures = innerInput.size();
+ final int sizeOfInputBatch = inputBatchFlows.size();
+ Preconditions.checkArgument(sizeOfFutures == sizeOfInputBatch,
+ "wrong amount of returned futures: {} <> {}", sizeOfFutures, sizeOfInputBatch);
+
+ final ArrayList<BatchFailedFlowsOutput> batchFlows = new ArrayList<>(sizeOfFutures);
+ final Iterator<? extends BatchFlowIdGrouping> batchFlowIterator = inputBatchFlows.iterator();
+
+ Collection<RpcError> flowErrors = new ArrayList<>(sizeOfFutures);
+
+ int batchOrder = 0;
+ for (RpcResult<O> flowModOutput : innerInput) {
+ final FlowId flowId = batchFlowIterator.next().getFlowId();
+
+ if (!flowModOutput.isSuccessful()) {
+ batchFlows.add(new BatchFailedFlowsOutputBuilder()
+ .setFlowId(flowId)
+ .setBatchOrder(batchOrder)
+ .build());
+ flowErrors.addAll(flowModOutput.getErrors());
}
+ batchOrder++;
+ }
- final RpcResultBuilder<List<BatchFailedFlowsOutput>> resultBuilder;
- if (!flowErrors.isEmpty()) {
- resultBuilder = RpcResultBuilder.<List<BatchFailedFlowsOutput>>failed()
- .withRpcErrors(flowErrors).withResult(batchFlows);
- } else {
- resultBuilder = SUCCESSFUL_FLOW_OUTPUT_RPC_RESULT;
- }
- return resultBuilder.build();
+ final RpcResultBuilder<List<BatchFailedFlowsOutput>> resultBuilder;
+ if (!flowErrors.isEmpty()) {
+ resultBuilder = RpcResultBuilder.<List<BatchFailedFlowsOutput>>failed()
+ .withRpcErrors(flowErrors).withResult(batchFlows);
+ } else {
+ resultBuilder = SUCCESSFUL_FLOW_OUTPUT_RPC_RESULT;
}
+ return resultBuilder.build();
};
}
}
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
-import javax.annotation.Nullable;
import org.apache.commons.lang3.tuple.Pair;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
RpcResultBuilder.success(Collections.<BatchFailedGroupsOutput>emptyList());
public static final Function<RpcResult<List<BatchFailedGroupsOutput>>, RpcResult<AddGroupsBatchOutput>>
- GROUP_ADD_TRANSFORM =
- new Function<RpcResult<List<BatchFailedGroupsOutput>>, RpcResult<AddGroupsBatchOutput>>() {
- @Nullable
- @Override
- public RpcResult<AddGroupsBatchOutput> apply(
- @Nullable final RpcResult<List<BatchFailedGroupsOutput>> batchGroupsCumulatedResult) {
- final AddGroupsBatchOutput batchOutput = new AddGroupsBatchOutputBuilder()
- .setBatchFailedGroupsOutput(batchGroupsCumulatedResult.getResult()).build();
+ GROUP_ADD_TRANSFORM = batchGroupsCumulatedResult -> {
+ final AddGroupsBatchOutput batchOutput = new AddGroupsBatchOutputBuilder()
+ .setBatchFailedGroupsOutput(batchGroupsCumulatedResult.getResult()).build();
- final RpcResultBuilder<AddGroupsBatchOutput> resultBld =
- createCumulativeRpcResult(batchGroupsCumulatedResult, batchOutput);
- return resultBld.build();
- }
+ final RpcResultBuilder<AddGroupsBatchOutput> resultBld =
+ createCumulativeRpcResult(batchGroupsCumulatedResult, batchOutput);
+ return resultBld.build();
};
public static final Function<Pair<RpcResult<AddGroupsBatchOutput>,
RpcResult<Void>>,
public static final Function<RpcResult<List<BatchFailedGroupsOutput>>, RpcResult<RemoveGroupsBatchOutput>>
GROUP_REMOVE_TRANSFORM =
- new Function<RpcResult<List<BatchFailedGroupsOutput>>, RpcResult<RemoveGroupsBatchOutput>>() {
- @Nullable
- @Override
- public RpcResult<RemoveGroupsBatchOutput> apply(
- @Nullable final RpcResult<List<BatchFailedGroupsOutput>> batchGroupsCumulatedResult) {
+ batchGroupsCumulatedResult -> {
final RemoveGroupsBatchOutput batchOutput = new RemoveGroupsBatchOutputBuilder()
.setBatchFailedGroupsOutput(batchGroupsCumulatedResult.getResult()).build();
final RpcResultBuilder<RemoveGroupsBatchOutput> resultBld =
createCumulativeRpcResult(batchGroupsCumulatedResult, batchOutput);
return resultBld.build();
- }
- };
+ };
public static final Function<Pair<RpcResult<RemoveGroupsBatchOutput>,
RpcResult<Void>>,
RpcResult<RemoveGroupsBatchOutput>>
public static final Function<RpcResult<List<BatchFailedGroupsOutput>>, RpcResult<UpdateGroupsBatchOutput>>
GROUP_UPDATE_TRANSFORM =
- new Function<RpcResult<List<BatchFailedGroupsOutput>>, RpcResult<UpdateGroupsBatchOutput>>() {
- @Nullable
- @Override
- public RpcResult<UpdateGroupsBatchOutput> apply(
- @Nullable final RpcResult<List<BatchFailedGroupsOutput>> batchGroupsCumulatedResult) {
+ batchGroupsCumulatedResult -> {
final UpdateGroupsBatchOutput batchOutput = new UpdateGroupsBatchOutputBuilder()
.setBatchFailedGroupsOutput(batchGroupsCumulatedResult.getResult()).build();
final RpcResultBuilder<UpdateGroupsBatchOutput> resultBld =
createCumulativeRpcResult(batchGroupsCumulatedResult, batchOutput);
return resultBld.build();
- }
- };
+ };
public static final Function<Pair<RpcResult<UpdateGroupsBatchOutput>,
RpcResult<Void>>,
RpcResult<UpdateGroupsBatchOutput>>
@VisibleForTesting
static <T extends BatchGroupOutputListGrouping> Function<Pair<RpcResult<T>, RpcResult<Void>>, RpcResult<T>>
createComposingFunction() {
- return new Function<Pair<RpcResult<T>, RpcResult<Void>>, RpcResult<T>>() {
- @Nullable
- @Override
- public RpcResult<T> apply(@Nullable final Pair<RpcResult<T>, RpcResult<Void>> input) {
- final RpcResultBuilder<T> resultBld;
- if (input.getLeft().isSuccessful() && input.getRight().isSuccessful()) {
- resultBld = RpcResultBuilder.success();
- } else {
- resultBld = RpcResultBuilder.failed();
- }
+ return input -> {
+ final RpcResultBuilder<T> resultBld;
+ if (input.getLeft().isSuccessful() && input.getRight().isSuccessful()) {
+ resultBld = RpcResultBuilder.success();
+ } else {
+ resultBld = RpcResultBuilder.failed();
+ }
- final ArrayList<RpcError> rpcErrors = new ArrayList<>(input.getLeft().getErrors());
- rpcErrors.addAll(input.getRight().getErrors());
- resultBld.withRpcErrors(rpcErrors);
+ final ArrayList<RpcError> rpcErrors = new ArrayList<>(input.getLeft().getErrors());
+ rpcErrors.addAll(input.getRight().getErrors());
+ resultBld.withRpcErrors(rpcErrors);
- resultBld.withResult(input.getLeft().getResult());
+ resultBld.withResult(input.getLeft().getResult());
- return resultBld.build();
- }
+ return resultBld.build();
};
}
}
public Function<List<RpcResult<O>>, RpcResult<List<BatchFailedGroupsOutput>>> invoke() {
- return new Function<List<RpcResult<O>>, RpcResult<List<BatchFailedGroupsOutput>>>() {
- @Nullable
- @Override
- public RpcResult<List<BatchFailedGroupsOutput>> apply(@Nullable final List<RpcResult<O>> innerInput) {
- final int sizeOfFutures = innerInput.size();
- Preconditions.checkArgument(sizeOfFutures == sizeOfInputBatch,
- "wrong amount of returned futures: {} <> {}", sizeOfFutures, sizeOfInputBatch);
+ return innerInput -> {
+ final int sizeOfFutures = innerInput.size();
+ Preconditions.checkArgument(sizeOfFutures == sizeOfInputBatch,
+ "wrong amount of returned futures: {} <> {}", sizeOfFutures, sizeOfInputBatch);
- final List<BatchFailedGroupsOutput> batchGroups = new ArrayList<>();
- final Iterator<? extends org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.Group>
- batchGroupIterator = inputBatchGroups.iterator();
+ final List<BatchFailedGroupsOutput> batchGroups = new ArrayList<>();
+ final Iterator<? extends org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.Group>
+ batchGroupIterator = inputBatchGroups.iterator();
- Collection<RpcError> groupErrors = new ArrayList<>(sizeOfFutures);
+ Collection<RpcError> groupErrors = new ArrayList<>(sizeOfFutures);
- int batchOrder = 0;
- for (RpcResult<O> groupModOutput : innerInput) {
- final GroupId groupId = batchGroupIterator.next().getGroupId();
+ int batchOrder = 0;
+ for (RpcResult<O> groupModOutput : innerInput) {
+ final GroupId groupId = batchGroupIterator.next().getGroupId();
- if (!groupModOutput.isSuccessful()) {
- batchGroups.add(new BatchFailedGroupsOutputBuilder()
- .setGroupId(groupId)
- .setBatchOrder(batchOrder)
- .build());
- groupErrors.addAll(groupModOutput.getErrors());
- }
- batchOrder++;
+ if (!groupModOutput.isSuccessful()) {
+ batchGroups.add(new BatchFailedGroupsOutputBuilder()
+ .setGroupId(groupId)
+ .setBatchOrder(batchOrder)
+ .build());
+ groupErrors.addAll(groupModOutput.getErrors());
}
+ batchOrder++;
+ }
- final RpcResultBuilder<List<BatchFailedGroupsOutput>> resultBuilder;
- if (!groupErrors.isEmpty()) {
- resultBuilder = RpcResultBuilder.<List<BatchFailedGroupsOutput>>failed()
- .withRpcErrors(groupErrors).withResult(batchGroups);
- } else {
- resultBuilder = SUCCESSFUL_GROUP_OUTPUT_RPC_RESULT;
- }
- return resultBuilder.build();
+ final RpcResultBuilder<List<BatchFailedGroupsOutput>> resultBuilder;
+ if (!groupErrors.isEmpty()) {
+ resultBuilder = RpcResultBuilder.<List<BatchFailedGroupsOutput>>failed()
+ .withRpcErrors(groupErrors).withResult(batchGroups);
+ } else {
+ resultBuilder = SUCCESSFUL_GROUP_OUTPUT_RPC_RESULT;
}
+ return resultBuilder.build();
};
}
}
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
-import javax.annotation.Nullable;
import org.apache.commons.lang3.tuple.Pair;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
RpcResultBuilder.success(Collections.<BatchFailedMetersOutput>emptyList());
public static final Function<RpcResult<List<BatchFailedMetersOutput>>, RpcResult<AddMetersBatchOutput>>
- METER_ADD_TRANSFORM =
- new Function<RpcResult<List<BatchFailedMetersOutput>>, RpcResult<AddMetersBatchOutput>>() {
- @Nullable
- @Override
- public RpcResult<AddMetersBatchOutput> apply(
- @Nullable final RpcResult<List<BatchFailedMetersOutput>> batchMetersCumulatedResult) {
- final AddMetersBatchOutput batchOutput = new AddMetersBatchOutputBuilder()
- .setBatchFailedMetersOutput(batchMetersCumulatedResult.getResult()).build();
+ METER_ADD_TRANSFORM = batchMetersCumulatedResult -> {
+ final AddMetersBatchOutput batchOutput = new AddMetersBatchOutputBuilder()
+ .setBatchFailedMetersOutput(batchMetersCumulatedResult.getResult()).build();
- final RpcResultBuilder<AddMetersBatchOutput> resultBld =
- createCumulativeRpcResult(batchMetersCumulatedResult, batchOutput);
- return resultBld.build();
- }
+ final RpcResultBuilder<AddMetersBatchOutput> resultBld =
+ createCumulativeRpcResult(batchMetersCumulatedResult, batchOutput);
+ return resultBld.build();
};
public static final Function<Pair<RpcResult<AddMetersBatchOutput>,
RpcResult<Void>>,
public static final Function<RpcResult<List<BatchFailedMetersOutput>>, RpcResult<RemoveMetersBatchOutput>>
METER_REMOVE_TRANSFORM =
- new Function<RpcResult<List<BatchFailedMetersOutput>>, RpcResult<RemoveMetersBatchOutput>>() {
- @Nullable
- @Override
- public RpcResult<RemoveMetersBatchOutput> apply(
- @Nullable final RpcResult<List<BatchFailedMetersOutput>> batchMetersCumulatedResult) {
+ batchMetersCumulatedResult -> {
final RemoveMetersBatchOutput batchOutput = new RemoveMetersBatchOutputBuilder()
.setBatchFailedMetersOutput(batchMetersCumulatedResult.getResult()).build();
final RpcResultBuilder<RemoveMetersBatchOutput> resultBld =
createCumulativeRpcResult(batchMetersCumulatedResult, batchOutput);
return resultBld.build();
- }
- };
+ };
public static final Function<Pair<RpcResult<RemoveMetersBatchOutput>,
RpcResult<Void>>,
RpcResult<RemoveMetersBatchOutput>>
public static final Function<RpcResult<List<BatchFailedMetersOutput>>, RpcResult<UpdateMetersBatchOutput>>
METER_UPDATE_TRANSFORM =
- new Function<RpcResult<List<BatchFailedMetersOutput>>, RpcResult<UpdateMetersBatchOutput>>() {
- @Nullable
- @Override
- public RpcResult<UpdateMetersBatchOutput> apply(
- @Nullable final RpcResult<List<BatchFailedMetersOutput>> batchMetersCumulatedResult) {
+ batchMetersCumulatedResult -> {
final UpdateMetersBatchOutput batchOutput = new UpdateMetersBatchOutputBuilder()
.setBatchFailedMetersOutput(batchMetersCumulatedResult.getResult()).build();
final RpcResultBuilder<UpdateMetersBatchOutput> resultBld =
createCumulativeRpcResult(batchMetersCumulatedResult, batchOutput);
return resultBld.build();
- }
- };
+ };
public static final Function<Pair<RpcResult<UpdateMetersBatchOutput>,
RpcResult<Void>>,
RpcResult<UpdateMetersBatchOutput>>
@VisibleForTesting
static <T extends BatchMeterOutputListGrouping>
Function<Pair<RpcResult<T>, RpcResult<Void>>, RpcResult<T>> createComposingFunction() {
- return new Function<Pair<RpcResult<T>, RpcResult<Void>>, RpcResult<T>>() {
- @Nullable
- @Override
- public RpcResult<T> apply(@Nullable final Pair<RpcResult<T>, RpcResult<Void>> input) {
- final RpcResultBuilder<T> resultBld;
- if (input.getLeft().isSuccessful() && input.getRight().isSuccessful()) {
- resultBld = RpcResultBuilder.success();
- } else {
- resultBld = RpcResultBuilder.failed();
- }
+ return input -> {
+ final RpcResultBuilder<T> resultBld;
+ if (input.getLeft().isSuccessful() && input.getRight().isSuccessful()) {
+ resultBld = RpcResultBuilder.success();
+ } else {
+ resultBld = RpcResultBuilder.failed();
+ }
- final ArrayList<RpcError> rpcErrors = new ArrayList<>(input.getLeft().getErrors());
- rpcErrors.addAll(input.getRight().getErrors());
- resultBld.withRpcErrors(rpcErrors);
+ final ArrayList<RpcError> rpcErrors = new ArrayList<>(input.getLeft().getErrors());
+ rpcErrors.addAll(input.getRight().getErrors());
+ resultBld.withRpcErrors(rpcErrors);
- resultBld.withResult(input.getLeft().getResult());
+ resultBld.withResult(input.getLeft().getResult());
- return resultBld.build();
- }
+ return resultBld.build();
};
}
}
public Function<List<RpcResult<O>>, RpcResult<List<BatchFailedMetersOutput>>> invoke() {
- return new Function<List<RpcResult<O>>, RpcResult<List<BatchFailedMetersOutput>>>() {
- @Nullable
- @Override
- public RpcResult<List<BatchFailedMetersOutput>> apply(@Nullable final List<RpcResult<O>> innerInput) {
- final int sizeOfFutures = innerInput.size();
- Preconditions.checkArgument(sizeOfFutures == sizeOfInputBatch,
- "wrong amount of returned futures: {} <> {}", sizeOfFutures, sizeOfInputBatch);
-
- final List<BatchFailedMetersOutput> batchMeters = new ArrayList<>();
- final Iterator<? extends org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.Meter>
- batchMeterIterator = inputBatchMeters.iterator();
-
- Collection<RpcError> meterErrors = new ArrayList<>(sizeOfFutures);
-
- int batchOrder = 0;
- for (RpcResult<O> meterModOutput : innerInput) {
- final MeterId meterId = batchMeterIterator.next().getMeterId();
-
- if (!meterModOutput.isSuccessful()) {
- batchMeters.add(new BatchFailedMetersOutputBuilder()
- .setBatchOrder(batchOrder)
- .setMeterId(meterId)
- .build());
- meterErrors.addAll(meterModOutput.getErrors());
- }
- batchOrder++;
+ return innerInput -> {
+ final int sizeOfFutures = innerInput.size();
+ Preconditions.checkArgument(sizeOfFutures == sizeOfInputBatch,
+ "wrong amount of returned futures: {} <> {}", sizeOfFutures, sizeOfInputBatch);
+
+ final List<BatchFailedMetersOutput> batchMeters = new ArrayList<>();
+ final Iterator<? extends org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.Meter>
+ batchMeterIterator = inputBatchMeters.iterator();
+
+ Collection<RpcError> meterErrors = new ArrayList<>(sizeOfFutures);
+
+ int batchOrder = 0;
+ for (RpcResult<O> meterModOutput : innerInput) {
+ final MeterId meterId = batchMeterIterator.next().getMeterId();
+
+ if (!meterModOutput.isSuccessful()) {
+ batchMeters.add(new BatchFailedMetersOutputBuilder()
+ .setBatchOrder(batchOrder)
+ .setMeterId(meterId)
+ .build());
+ meterErrors.addAll(meterModOutput.getErrors());
}
+ batchOrder++;
+ }
- final RpcResultBuilder<List<BatchFailedMetersOutput>> resultBuilder;
- if (!meterErrors.isEmpty()) {
- resultBuilder = RpcResultBuilder.<List<BatchFailedMetersOutput>>failed()
- .withRpcErrors(meterErrors).withResult(batchMeters);
- } else {
- resultBuilder = SUCCESSFUL_METER_OUTPUT_RPC_RESULT;
- }
- return resultBuilder.build();
+ final RpcResultBuilder<List<BatchFailedMetersOutput>> resultBuilder;
+ if (!meterErrors.isEmpty()) {
+ resultBuilder = RpcResultBuilder.<List<BatchFailedMetersOutput>>failed()
+ .withRpcErrors(meterErrors).withResult(batchMeters);
+ } else {
+ resultBuilder = SUCCESSFUL_METER_OUTPUT_RPC_RESULT;
}
+ return resultBuilder.build();
};
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.InPortCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev150225.match.entry.value.grouping.match.entry.value.in.port._case.InPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PacketIn;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
/**
Long port = null;
- if (nodeConnectorRef.getValue() instanceof KeyedInstanceIdentifier) {
+ final InstanceIdentifier<?> value = nodeConnectorRef.getValue();
+ if (value instanceof KeyedInstanceIdentifier) {
KeyedInstanceIdentifier<NodeConnector, NodeConnectorKey> identifier =
- (KeyedInstanceIdentifier<NodeConnector, NodeConnectorKey>) nodeConnectorRef.getValue();
+ (KeyedInstanceIdentifier<NodeConnector, NodeConnectorKey>) value;
OpenflowVersion ofVersion = OpenflowVersion.get(version);
String nodeConnectorId = identifier.getKey().getId().getValue();
Code Review / openflowplugin.git / commitdiff