package org.opendaylight.openflowplugin.impl.connection;
import static java.util.Objects.requireNonNull;
+import static java.util.Objects.requireNonNullElse;
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.slf4j.LoggerFactory;
public class ConnectionContextImpl implements ConnectionContext {
+ private static final Logger LOG = LoggerFactory.getLogger(ConnectionContextImpl.class);
private final ConnectionAdapter connectionAdapter;
private volatile CONNECTION_STATE connectionState;
private FeaturesReply featuresReply;
private NodeId nodeId;
private DeviceDisconnectedHandler deviceDisconnectedHandler;
- private static final Logger LOG = LoggerFactory.getLogger(ConnectionContextImpl.class);
private OutboundQueueProvider outboundQueueProvider;
private OutboundQueueHandlerRegistration<OutboundQueueProvider> outboundQueueHandlerRegistration;
private HandshakeContext handshakeContext;
@Override
public OutboundQueue getOutboundQueueProvider() {
- return this.outboundQueueProvider;
+ return outboundQueueProvider;
}
@Override
public void setOutboundQueueProvider(final OutboundQueueProvider outboundQueueProvider) {
this.outboundQueueProvider = outboundQueueProvider;
- ((DeviceInfoImpl)this.deviceInfo).setOutboundQueueProvider(this.outboundQueueProvider);
+ ((DeviceInfoImpl)deviceInfo).setOutboundQueueProvider(this.outboundQueueProvider);
}
@Override
@Override
public void setFeatures(final FeaturesReply newFeaturesReply) {
- this.featuresReply = newFeaturesReply;
+ featuresReply = newFeaturesReply;
}
@Override
@Override
public void setOutboundQueueHandleRegistration(
final OutboundQueueHandlerRegistration<OutboundQueueProvider> newRegistration) {
- this.outboundQueueHandlerRegistration = newRegistration;
+ outboundQueueHandlerRegistration = newRegistration;
}
private void unregisterOutboundQueue() {
LOG.info("Received early port status message for node {} with reason {} and state {}",
getSafeNodeIdForLOG(),
portStatusMessage.getReason(),
- MoreObjects.firstNonNull(portStatusMessage.getState(), portStatusMessage.getStateV10()));
+ requireNonNullElse(portStatusMessage.getState(), portStatusMessage.getStateV10()));
LOG.debug("Early port status message body is {}", portStatusMessage);
portStatusMessages.add(portStatusMessage);
@Override
public DeviceInfo getDeviceInfo() {
- return this.deviceInfo;
+ return deviceInfo;
}
@Override
public void handshakeSuccessful() {
- Preconditions.checkNotNull(nodeId, "Cannot create DeviceInfo if 'NodeId' is not set!");
- Preconditions.checkNotNull(featuresReply, "Cannot create DeviceInfo if 'features' is not set!");
- this.deviceInfo = new DeviceInfoImpl(
+ requireNonNull(nodeId, "Cannot create DeviceInfo if 'NodeId' is not set!");
+ requireNonNull(featuresReply, "Cannot create DeviceInfo if 'features' is not set!");
+ deviceInfo = new DeviceInfoImpl(
nodeId,
DeviceStateUtil.createNodeInstanceIdentifier(nodeId),
featuresReply.getVersion(),
this.version = requireNonNull(version);
this.datapathId = datapathId;
this.outboundQueueProvider = outboundQueueProvider;
- this.serviceGroupIdentifier = ServiceGroupIdentifier.create(this.nodeId.getValue());
+ serviceGroupIdentifier = ServiceGroupIdentifier.create(this.nodeId.getValue());
}
@Override
@Override
public ServiceGroupIdentifier getServiceIdentifier() {
- return this.serviceGroupIdentifier;
+ return serviceGroupIdentifier;
}
@Override
*/
package org.opendaylight.openflowplugin.impl.connection;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.math.BigInteger;
import java.net.InetAddress;
@Override
public void onDataTreeChanged(@NonNull final Collection<DataTreeModification<Node>> changes) {
- Preconditions.checkNotNull(changes, "Changes must not be null!");
+ requireNonNull(changes, "Changes must not be null!");
for (DataTreeModification<Node> change : changes) {
final DataObjectModification<Node> mod = change.getRootNode();
switch (mod.getModificationType()) {
*/
package org.opendaylight.openflowplugin.impl.connection.listener;
-import com.google.common.base.Objects;
+import java.util.Objects;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.connection.HandshakeContext;
import org.opendaylight.openflowplugin.impl.connection.HandshakeStepWrapper;
*/
protected boolean checkState(final ConnectionContext.CONNECTION_STATE expectedState) {
boolean verdict = true;
- if (! Objects.equal(connectionContext.getConnectionState(), expectedState)) {
+ if (!Objects.equals(connectionContext.getConnectionState(), expectedState)) {
verdict = false;
LOG.info("Expected state: {}, actual state: {}", expectedState,
connectionContext.getConnectionState());
*/
package org.opendaylight.openflowplugin.impl.device;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy;
final class PacketInRateLimiter extends SimpleRatelimiter {
private static final Logger LOG = LoggerFactory.getLogger(PacketInRateLimiter.class);
+
private final float rejectedDrainFactor;
private final ConnectionAdapter connectionAdapter;
private final MessageSpy messageSpy;
final MessageSpy messageSpy,
float rejectedDrainFactor) {
super(lowWatermark, highWatermark);
- Preconditions.checkArgument(rejectedDrainFactor > 0 && rejectedDrainFactor < 1);
+ checkArgument(rejectedDrainFactor > 0 && rejectedDrainFactor < 1);
this.rejectedDrainFactor = rejectedDrainFactor;
- this.connectionAdapter = Preconditions.checkNotNull(connectionAdapter);
- this.messageSpy = Preconditions.checkNotNull(messageSpy);
+ this.connectionAdapter = requireNonNull(connectionAdapter);
+ this.messageSpy = requireNonNull(messageSpy);
}
@Override
*/
package org.opendaylight.openflowplugin.impl.device.initialization;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import java.util.Collections;
import java.util.concurrent.Future;
import org.slf4j.LoggerFactory;
public abstract class AbstractDeviceInitializer {
-
private static final Logger LOG = LoggerFactory.getLogger(AbstractDeviceInitializer.class);
/**
final boolean skipTableFeatures,
@Nullable final MultipartWriterProvider multipartWriterProvider,
@Nullable final ConvertorExecutor convertorExecutor) {
- Preconditions.checkNotNull(deviceContext);
+ requireNonNull(deviceContext);
// Write node to datastore
LOG.debug("Initializing node information for node {}", deviceContext.getDeviceInfo());
*/
package org.opendaylight.openflowplugin.impl.device.initialization;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
final boolean skipTableFeatures,
@Nullable final MultipartWriterProvider multipartWriterProvider,
@Nullable final ConvertorExecutor convertorExecutor) {
- final ConnectionContext connectionContext =
- Preconditions.checkNotNull(deviceContext.getPrimaryConnectionContext());
- final DeviceState deviceState = Preconditions.checkNotNull(deviceContext.getDeviceState());
- final DeviceInfo deviceInfo = Preconditions.checkNotNull(deviceContext.getDeviceInfo());
+ final ConnectionContext connectionContext = requireNonNull(deviceContext.getPrimaryConnectionContext());
+ final DeviceState deviceState = requireNonNull(deviceContext.getDeviceState());
+ final DeviceInfo deviceInfo = requireNonNull(deviceContext.getDeviceInfo());
final CapabilitiesV10 capabilitiesV10 = connectionContext.getFeatures().getCapabilitiesV10();
// Set capabilities for this device based on capabilities of connection context
*/
package org.opendaylight.openflowplugin.impl.device.initialization;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import org.slf4j.LoggerFactory;
public class OF13DeviceInitializer extends AbstractDeviceInitializer {
-
private static final Logger LOG = LoggerFactory.getLogger(OF13DeviceInitializer.class);
@Override
final boolean skipTableFeatures,
@Nullable final MultipartWriterProvider multipartWriterProvider,
@Nullable final ConvertorExecutor convertorExecutor) {
- final ConnectionContext connectionContext =
- Preconditions.checkNotNull(deviceContext.getPrimaryConnectionContext());
- final DeviceState deviceState = Preconditions.checkNotNull(deviceContext.getDeviceState());
- final DeviceInfo deviceInfo = Preconditions.checkNotNull(deviceContext.getDeviceInfo());
+ final ConnectionContext connectionContext = requireNonNull(deviceContext.getPrimaryConnectionContext());
+ final DeviceState deviceState = requireNonNull(deviceContext.getDeviceState());
+ final DeviceInfo deviceInfo = requireNonNull(deviceContext.getDeviceInfo());
final Capabilities capabilities = connectionContext.getFeatures().getCapabilities();
LOG.debug("Setting capabilities for device {}", deviceInfo);
DeviceStateUtil.setDeviceStateBasedOnV13Capabilities(deviceState, capabilities);
// If we collected meter features, check if we have support for meters
// and pass this information to device context
if (MultipartType.OFPMPMETERFEATURES.equals(type)
- && translatedReply instanceof MeterFeatures) {
- final MeterFeatures meterFeatures = (MeterFeatures) translatedReply;
-
+ && translatedReply instanceof MeterFeatures meterFeatures) {
if (meterFeatures.getMaxMeter().getValue().toJava() > 0) {
deviceContext.getDeviceState().setMeterAvailable(true);
}
*/
package org.opendaylight.openflowplugin.impl.device.listener;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
*/
public class MultiMsgCollectorImpl<T extends OfHeader> implements MultiMsgCollector<T> {
private static final Logger LOG = LoggerFactory.getLogger(MultiMsgCollectorImpl.class);
+
private final List<T> replyCollection = new ArrayList<>();
private final RequestContext<List<T>> requestContext;
private final DeviceReplyProcessor deviceReplyProcessor;
public MultiMsgCollectorImpl(final DeviceReplyProcessor deviceReplyProcessor,
final RequestContext<List<T>> requestContext) {
- this.deviceReplyProcessor = Preconditions.checkNotNull(deviceReplyProcessor);
- this.requestContext = Preconditions.checkNotNull(requestContext);
+ this.deviceReplyProcessor = requireNonNull(deviceReplyProcessor);
+ this.requestContext = requireNonNull(requestContext);
}
@Override
public void addMultipartMsg(@NonNull final T reply, final boolean reqMore,
@Nullable final EventIdentifier eventIdentifier) {
- Preconditions.checkNotNull(reply);
- Preconditions.checkNotNull(requestContext.getXid());
- Preconditions.checkArgument(requestContext.getXid().getValue().equals(reply.getXid()));
+ requireNonNull(reply);
+ requireNonNull(requestContext.getXid());
+ checkArgument(requestContext.getXid().getValue().equals(reply.getXid()));
LOG.trace("Try to add Multipart reply msg with XID {}", reply.getXid());
replyCollection.add(reply);
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.action;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
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(final ByteBuf message) {
- final MatchEntryDeserializer deserializer = Preconditions.checkNotNull(registry).getDeserializer(MATCH_KEY);
+ final MatchEntryDeserializer deserializer = requireNonNull(registry).getDeserializer(MATCH_KEY);
final MatchBuilder builder = new MatchBuilder();
final int startIndex = message.readerIndex();
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.messages;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
-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;
message.skipBytes(PADDING);
- final OFDeserializer<Match> matchDeserializer = Preconditions.checkNotNull(registry).getDeserializer(MATCH_KEY);
+ final OFDeserializer<Match> matchDeserializer = requireNonNull(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 = Preconditions.checkNotNull(registry).getDeserializer(
+ deserializer = requireNonNull(registry).getDeserializer(
new MessageCodeActionExperimenterKey(
EncodeConstants.OF_VERSION_1_3, type, Instruction.class,
ActionPath.INVENTORY_FLOWNODE_TABLE_APPLY_ACTIONS,
null));
} else if (InstructionConstants.WRITE_ACTIONS_TYPE == type) {
- deserializer = Preconditions.checkNotNull(registry).getDeserializer(
+ deserializer = requireNonNull(registry).getDeserializer(
new MessageCodeActionExperimenterKey(
EncodeConstants.OF_VERSION_1_3, type, Instruction.class,
ActionPath.INVENTORY_FLOWNODE_TABLE_WRITE_ACTIONS,
expId = message.getUnsignedInt(message.readerIndex() + 2 * Short.BYTES);
}
- deserializer = Preconditions.checkNotNull(registry).getDeserializer(
+ deserializer = requireNonNull(registry).getDeserializer(
new MessageCodeExperimenterKey(
EncodeConstants.OF_VERSION_1_3, type, Instruction.class, expId));
}
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint16;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint64;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint8;
-import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.List;
.setPacketCount(new Counter64(readUint64(itemMessage)))
.setByteCount(new Counter64(readUint64(itemMessage)));
- final OFDeserializer<Match> matchDeserializer =
- Preconditions.checkNotNull(registry).getDeserializer(MATCH_KEY);
+ final OFDeserializer<Match> matchDeserializer = requireNonNull(registry).getDeserializer(MATCH_KEY);
itemBuilder.setMatch(MatchUtil.transformMatch(matchDeserializer.deserialize(itemMessage),
org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.Match.class));
*/
package org.opendaylight.openflowplugin.impl.protocol.deserialization.multipart;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
-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;
import org.opendaylight.yangtools.yang.common.Uint32;
public class MultipartReplyMessageDeserializer implements OFDeserializer<MultipartReply>, DeserializerRegistryInjector {
-
private static final byte PADDING_IN_MULTIPART_REPLY_HEADER = 4;
private DeserializerRegistry registry;
final boolean reqMore = (message.readUnsignedShort() & 0x01) != 0;
message.skipBytes(PADDING_IN_MULTIPART_REPLY_HEADER);
- final OFDeserializer<MultipartReplyBody> deserializer = Preconditions.checkNotNull(registry)
+ final OFDeserializer<MultipartReplyBody> deserializer = requireNonNull(registry)
.getDeserializer(new MessageCodeKey(EncodeConstants.OF_VERSION_1_3, type, MultipartReplyBody.class));
return new MultipartReplyBuilder()
public void injectDeserializerRegistry(final DeserializerRegistry deserializerRegistry) {
registry = deserializerRegistry;
}
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.actions;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
@Override
public void serialize(final Action input, final ByteBuf outBuffer) {
- final OFSerializer<Action> serializer = Preconditions.checkNotNull(registry)
+ final OFSerializer<Action> serializer = requireNonNull(registry)
.getSerializer(new MessageTypeKey<>(EncodeConstants.OF_VERSION_1_3, SetFieldCase.class));
serializer.serialize(buildAction(input), outBuffer);
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.actions;
-import com.google.common.base.MoreObjects;
+import static java.util.Objects.requireNonNullElse;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.impl.util.ActionConstants;
import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
+ outputAction.getOutputNodeConnector().getValue());
}
outBuffer.writeInt(value.intValue());
- outBuffer.writeShort(MoreObjects.firstNonNull(outputAction.getMaxLength(), Uint16.ZERO).toJava());
+ outBuffer.writeShort(requireNonNullElse(outputAction.getMaxLength(), Uint16.ZERO).toJava());
outBuffer.writeZero(ActionConstants.OUTPUT_PADDING);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.actions;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.HeaderSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
// Serialize match (using small workaround with serializeHeader method to serialize only match entries)
final SetField setField = action.getSetField();
- final HeaderSerializer<Match> serializer = Preconditions.checkNotNull(registry)
+ final HeaderSerializer<Match> serializer = requireNonNull(registry)
.getSerializer(new MessageTypeKey<>(EncodeConstants.OF_VERSION_1_3, Match.class));
serializer.serializeHeader(setField, outBuffer);
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.messages;
-import com.google.common.base.MoreObjects;
+import static java.util.Objects.requireNonNullElse;
+
import com.google.common.collect.ImmutableMap;
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.util.ByteBufUtils;
* OF protocol versions: 1.3.
*/
public class PortMessageSerializer extends AbstractMessageSerializer<PortMessage> {
-
private static final byte PADDING_IN_PORT_MOD_MESSAGE_01 = 4;
private static final byte PADDING_IN_PORT_MOD_MESSAGE_02 = 2;
private static final byte PADDING_IN_PORT_MOD_MESSAGE_03 = 4;
outBuffer.writeBytes(IetfYangUtil.INSTANCE.macAddressBytes(message.getHardwareAddress()));
outBuffer.writeZero(PADDING_IN_PORT_MOD_MESSAGE_02);
outBuffer.writeInt(createPortConfigBitMask(message.getConfiguration()));
- outBuffer.writeInt(MoreObjects
- .firstNonNull(createPortConfigBitMask(message.getMask()), DEFAULT_PORT_CONFIG_MASK));
+ outBuffer.writeInt(requireNonNullElse(createPortConfigBitMask(message.getMask()), DEFAULT_PORT_CONFIG_MASK));
outBuffer.writeInt(createPortFeaturesBitMask(message.getAdvertisedFeatures()));
outBuffer.writeZero(PADDING_IN_PORT_MOD_MESSAGE_03);
outBuffer.setShort(index + 2, outBuffer.writerIndex() - index);
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+import static java.util.Objects.requireNonNullElse;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
public class MultipartRequestFlowAggregateStatsSerializer implements OFSerializer<MultipartRequestFlowAggregateStats>,
SerializerRegistryInjector {
-
private static final byte PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01 = 3;
private static final byte PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_02 = 4;
+
private SerializerRegistry registry;
@Override
public void serialize(final MultipartRequestFlowAggregateStats multipartRequestFlowAggregateStats,
final ByteBuf byteBuf) {
final FlowAggregateStats stats = multipartRequestFlowAggregateStats.getFlowAggregateStats();
- byteBuf.writeByte(MoreObjects.firstNonNull(stats.getTableId(), OFConstants.OFPTT_ALL).byteValue());
+ byteBuf.writeByte(requireNonNullElse(stats.getTableId(), OFConstants.OFPTT_ALL).byteValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01);
- byteBuf.writeInt(MoreObjects.firstNonNull(stats.getOutPort(), OFConstants.OFPP_ANY).intValue());
- byteBuf.writeInt(MoreObjects.firstNonNull(stats.getOutGroup(), OFConstants.OFPG_ANY).intValue());
+ byteBuf.writeInt(requireNonNullElse(stats.getOutPort(), OFConstants.OFPP_ANY).intValue());
+ byteBuf.writeInt(requireNonNullElse(stats.getOutGroup(), OFConstants.OFPG_ANY).intValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_02);
- byteBuf.writeLong(MoreObjects.firstNonNull(stats.getCookie(),
+ byteBuf.writeLong(requireNonNullElse(stats.getCookie(),
new FlowCookie(OFConstants.DEFAULT_COOKIE)).getValue().longValue());
- byteBuf.writeLong(MoreObjects.firstNonNull(stats.getCookieMask(),
+ byteBuf.writeLong(requireNonNullElse(stats.getCookieMask(),
new FlowCookie(OFConstants.DEFAULT_COOKIE_MASK)).getValue().longValue());
- Preconditions.checkNotNull(registry).<Match, OFSerializer<Match>>getSerializer(
+ requireNonNull(registry).<Match, OFSerializer<Match>>getSerializer(
new MessageTypeKey<>(EncodeConstants.OF_VERSION_1_3, Match.class))
.serialize(stats.getMatch(), byteBuf);
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+import static java.util.Objects.requireNonNullElse;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
public class MultipartRequestFlowStatsSerializer implements OFSerializer<MultipartRequestFlowStats>,
SerializerRegistryInjector {
-
private static final byte PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01 = 3;
private static final byte PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_02 = 4;
+
private SerializerRegistry registry;
@Override
public void serialize(final MultipartRequestFlowStats multipartRequestFlowStats, final ByteBuf byteBuf) {
final FlowStats stats = multipartRequestFlowStats.getFlowStats();
- byteBuf.writeByte(MoreObjects.firstNonNull(stats.getTableId(), OFConstants.OFPTT_ALL).byteValue());
+ byteBuf.writeByte(requireNonNullElse(stats.getTableId(), OFConstants.OFPTT_ALL).byteValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01);
- byteBuf.writeInt(MoreObjects.firstNonNull(stats.getOutPort(), OFConstants.OFPP_ANY).intValue());
- byteBuf.writeInt(MoreObjects.firstNonNull(stats.getOutGroup(), OFConstants.OFPG_ANY).intValue());
+ byteBuf.writeInt(requireNonNullElse(stats.getOutPort(), OFConstants.OFPP_ANY).intValue());
+ byteBuf.writeInt(requireNonNullElse(stats.getOutGroup(), OFConstants.OFPG_ANY).intValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_02);
- byteBuf.writeLong(MoreObjects.firstNonNull(stats.getCookie(),
+ byteBuf.writeLong(requireNonNullElse(stats.getCookie(),
new FlowCookie(OFConstants.DEFAULT_COOKIE)).getValue().longValue());
- byteBuf.writeLong(MoreObjects.firstNonNull(stats.getCookieMask(),
+ byteBuf.writeLong(requireNonNullElse(stats.getCookieMask(),
new FlowCookie(OFConstants.DEFAULT_COOKIE_MASK)).getValue().longValue());
- Preconditions.checkNotNull(registry).<Match, OFSerializer<Match>>getSerializer(
+ requireNonNull(registry).<Match, OFSerializer<Match>>getSerializer(
new MessageTypeKey<>(EncodeConstants.OF_VERSION_1_3, Match.class))
.serialize(stats.getMatch(), byteBuf);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
-import com.google.common.base.MoreObjects;
+import static java.util.Objects.requireNonNullElse;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
public class MultipartRequestGroupStatsSerializer implements OFSerializer<MultipartRequestGroupStats> {
-
private static final byte PADDING_IN_MULTIPART_REQUEST_GROUP_BODY = 4;
@Override
public void serialize(final MultipartRequestGroupStats multipartRequestGroupStats, final ByteBuf byteBuf) {
- byteBuf.writeInt(MoreObjects
- .firstNonNull(multipartRequestGroupStats.getGroupId(), new GroupId(OFConstants.OFPG_ALL))
- .getValue().intValue());
-
+ byteBuf.writeInt(requireNonNullElse(multipartRequestGroupStats.getGroupId(),
+ new GroupId(OFConstants.OFPG_ALL)).getValue().intValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_GROUP_BODY);
}
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
outBuffer.writeShort(ByteBufUtils.fillBitMask(0, message.getRequestMore()));
outBuffer.writeZero(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
- final OFSerializer<MultipartRequestBody> serializer = Preconditions.checkNotNull(registry)
+ final OFSerializer<MultipartRequestBody> serializer = requireNonNull(registry)
.getSerializer(new MessageTypeKey<>(
EncodeConstants.OF_VERSION_1_3,
multipartRequestBody.implementedInterface()));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
-import com.google.common.base.MoreObjects;
+import static java.util.Objects.requireNonNullElse;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
public class MultipartRequestMeterConfigSerializer implements OFSerializer<MultipartRequestMeterConfig> {
-
private static final byte PADDING_IN_MULTIPART_REQUEST_METER_CONFIG_BODY = 4;
@Override
public void serialize(final MultipartRequestMeterConfig multipartRequestMeterConfig, final ByteBuf byteBuf) {
- byteBuf.writeInt(MoreObjects.firstNonNull(multipartRequestMeterConfig.getMeterId(),
- new MeterId(OFConstants.OFPM_ALL)).getValue().intValue());
+ byteBuf.writeInt(requireNonNullElse(multipartRequestMeterConfig.getMeterId(),
+ new MeterId(OFConstants.OFPM_ALL)).getValue().intValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_METER_CONFIG_BODY);
}
-
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
-import com.google.common.base.MoreObjects;
+import static java.util.Objects.requireNonNullElse;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
public class MultipartRequestMeterStatsSerializer implements OFSerializer<MultipartRequestMeterStats> {
-
private static final byte PADDING_IN_MULTIPART_REQUEST_METER_BODY = 4;
@Override
public void serialize(final MultipartRequestMeterStats multipartRequestMeterStats, final ByteBuf byteBuf) {
- byteBuf.writeInt(MoreObjects
- .firstNonNull(multipartRequestMeterStats.getStatMeterId(), new MeterId(OFConstants.OFPM_ALL))
- .getValue().intValue());
+ byteBuf.writeInt(requireNonNullElse(multipartRequestMeterStats.getStatMeterId(),
+ new MeterId(OFConstants.OFPM_ALL)).getValue().intValue());
byteBuf.writeZero(PADDING_IN_MULTIPART_REQUEST_METER_BODY);
}
-
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart;
-import com.google.common.base.MoreObjects;
+import static java.util.Objects.requireNonNullElse;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowplugin.api.OFConstants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.multipart.request.multipart.request.body.MultipartRequestQueueStats;
public class MultipartRequestQueueStatsSerializer implements OFSerializer<MultipartRequestQueueStats> {
-
@Override
public void serialize(final MultipartRequestQueueStats multipartRequestQueueStats, final ByteBuf byteBuf) {
if (multipartRequestQueueStats.getNodeConnectorId() == null) {
multipartRequestQueueStats.getNodeConnectorId()).intValue());
}
- byteBuf.writeInt(MoreObjects
- .firstNonNull(multipartRequestQueueStats.getQueueId(), new QueueId(OFConstants.OFPQ_ALL))
+ byteBuf.writeInt(requireNonNullElse(multipartRequestQueueStats.getQueueId(), new QueueId(OFConstants.OFPQ_ALL))
.getValue().intValue());
}
}
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getApplySetfieldMiss()
.nonnullSetFieldMatch().values()
- .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
+ .forEach(setFieldMatch -> requireNonNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(new MessageTypeKey<>(
EncodeConstants.OF_VERSION_1_3, setFieldMatch.getMatchType().implementedInterface()))
.serialize(setFieldMatch, byteBuf));
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getApplySetfield()
.nonnullSetFieldMatch().values()
- .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
+ .forEach(setFieldMatch -> requireNonNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(new MessageTypeKey<>(
EncodeConstants.OF_VERSION_1_3,setFieldMatch.getMatchType().implementedInterface()))
.serialize(setFieldMatch, byteBuf));
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getMatchSetfield()
.nonnullSetFieldMatch().values()
- .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
+ .forEach(setFieldMatch -> requireNonNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(new MessageTypeKey<>(
EncodeConstants.OF_VERSION_1_3, setFieldMatch.getMatchType().implementedInterface()))
.serialize(setFieldMatch, byteBuf));
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getWildcardSetfield()
.nonnullSetFieldMatch().values()
- .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
+ .forEach(setFieldMatch -> requireNonNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(new MessageTypeKey<>(
EncodeConstants.OF_VERSION_1_3, setFieldMatch.getMatchType().implementedInterface()))
.serialize(setFieldMatch, byteBuf));
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getWriteSetfieldMiss()
.nonnullSetFieldMatch().values()
- .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
+ .forEach(setFieldMatch -> requireNonNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(new MessageTypeKey<>(
EncodeConstants.OF_VERSION_1_3, setFieldMatch.getMatchType().implementedInterface()))
.serialize(setFieldMatch, byteBuf));
*/
package org.opendaylight.openflowplugin.impl.protocol.serialization.multipart.tablefeatures;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
property
.getWriteSetfield()
.nonnullSetFieldMatch().values()
- .forEach(setFieldMatch -> Preconditions.checkNotNull(registry)
+ .forEach(setFieldMatch -> requireNonNull(registry)
.<MatchField, OFSerializer<SetFieldMatch>>getSerializer(new MessageTypeKey<>(
EncodeConstants.OF_VERSION_1_3, setFieldMatch.getMatchType().implementedInterface()))
.serialize(setFieldMatch, byteBuf));
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Objects;
+import java.util.Objects;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.openflow.registry.flow.FlowDescriptor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
// Hide implicit constructor
}
- @NonNull
- public static FlowDescriptor create(final Uint8 tableId, @NonNull final FlowId flowId) {
+ public static @NonNull FlowDescriptor create(final Uint8 tableId, @NonNull final FlowId flowId) {
return new FlowDescriptorDto(new TableKey(tableId), requireNonNull(flowId));
}
private static final class FlowDescriptorDto implements FlowDescriptor {
-
private final FlowId flowId;
private final TableKey tableKey;
}
@Override
- public boolean equals(final Object object) {
- if (this == object) {
- return true;
- }
- if (object == null || getClass() != object.getClass()) {
- return false;
- }
- FlowDescriptorDto that = (FlowDescriptorDto) object;
- return Objects.equal(flowId, that.flowId) && Objects.equal(tableKey, that.tableKey);
+ public boolean equals(final Object obj) {
+ return this == obj || obj instanceof FlowDescriptorDto other && Objects.equals(flowId, other.flowId)
+ && Objects.equals(tableKey, other.tableKey);
}
@Override
public int hashCode() {
- return Objects.hashCode(flowId, tableKey);
+ return Objects.hash(flowId, tableKey);
}
@Override
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.registry.flow;
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+import static java.util.Objects.requireNonNullElse;
+
import java.util.Objects;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.openflowplugin.api.OFConstants;
@NonNull
public static FlowRegistryKey create(final Uint8 version, @NonNull final Flow flow) {
//TODO: mandatory flow input values (or default values) should be specified via yang model
- final Uint8 tableId = Preconditions.checkNotNull(flow.getTableId(), "flow tableId must not be null");
- final Uint16 priority = MoreObjects.firstNonNull(flow.getPriority(), OFConstants.DEFAULT_FLOW_PRIORITY);
- final Uint64 cookie =
- MoreObjects.firstNonNull(flow.getCookie(), OFConstants.DEFAULT_FLOW_COOKIE).getValue();
- Match match = MatchNormalizationUtil
- .normalizeMatch(MoreObjects.firstNonNull(flow.getMatch(), OFConstants.EMPTY_MATCH), version);
+ final Uint8 tableId = requireNonNull(flow.getTableId(), "flow tableId must not be null");
+ final Uint16 priority = requireNonNullElse(flow.getPriority(), OFConstants.DEFAULT_FLOW_PRIORITY);
+ final Uint64 cookie = requireNonNullElse(flow.getCookie(), OFConstants.DEFAULT_FLOW_COOKIE).getValue();
+ Match match = MatchNormalizationUtil.normalizeMatch(
+ requireNonNullElse(flow.getMatch(), OFConstants.EMPTY_MATCH), version);
return new FlowRegistryKeyDto(tableId.toJava(), priority.toJava(), cookie, match);
}
return true;
}
- if (object == null || !(object instanceof FlowRegistryKey)) {
+ if (object == null || !(object instanceof FlowRegistryKey that)) {
return false;
}
- final FlowRegistryKey that = (FlowRegistryKey) object;
-
return getPriority() == that.getPriority()
&& getTableId() == that.getTableId()
&& getCookie().equals(that.getCookie())
*/
package org.opendaylight.openflowplugin.impl.services;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FutureCallback;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
final Class<?> requestType,
final MessageSpy spy,
final EventIdentifier eventIdentifier) {
- this.context = Preconditions.checkNotNull(context);
- this.requestType = Preconditions.checkNotNull(requestType);
- this.spy = Preconditions.checkNotNull(spy);
+ this.context = requireNonNull(context);
+ this.requestType = requireNonNull(requestType);
+ this.spy = requireNonNull(spy);
this.eventIdentifier = eventIdentifier;
}
}
protected final void spyMessage(@NonNull final StatisticsGroup group) {
- spy.spyMessage(requestType, Preconditions.checkNotNull(group));
+ spy.spyMessage(requestType, requireNonNull(group));
}
public EventIdentifier getEventIdentifier() {
*/
package org.opendaylight.openflowplugin.impl.services;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Verify;
+import static com.google.common.base.Verify.verify;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
public ListenableFuture<RpcResult<O>> handleServiceCall(@NonNull final I input,
@Nullable final Function<OfHeader, Boolean> isComplete) {
- Preconditions.checkNotNull(input);
+ requireNonNull(input);
final Class<?> requestType = input instanceof DataContainer
? ((DataContainer) input).implementedInterface()
OfHeader request = null;
try {
request = buildRequest(xid, input);
- Verify.verify(xid.getValue().equals(request.getXid()),
+ verify(xid.getValue().equals(request.getXid()),
"Expected XID %s got %s",
xid.getValue(),
request.getXid());
*/
package org.opendaylight.openflowplugin.impl.services;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FutureCallback;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
final DeviceContext deviceContext,
final Class<O> clazz) {
super(requestContextStack, deviceContext);
- this.clazz = Preconditions.checkNotNull(clazz);
+ this.clazz = requireNonNull(clazz);
}
@Override
*/
package org.opendaylight.openflowplugin.impl.services;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FutureCallback;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy;
public final class SimpleRequestCallback<T extends DataObject> extends AbstractRequestCallback<T> {
private static final Logger LOG = LoggerFactory.getLogger(SimpleRequestCallback.class);
+
private final Class<T> clazz;
private SimpleRequestCallback(final RequestContext<T> context,
final MessageSpy spy,
final Class<T> clazz) {
super(context, requestType, spy, null);
- this.clazz = Preconditions.checkNotNull(clazz);
+ this.clazz = requireNonNull(clazz);
}
public static <T extends DataObject> FutureCallback<OfHeader> create(final RequestContext<T> context,
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.services.multilayer;
import static java.util.Objects.requireNonNull;
+import static java.util.Objects.requireNonNullElse;
-import com.google.common.base.MoreObjects;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import org.opendaylight.yangtools.yang.common.Uint8;
public class MultiLayerAggregateFlowMultipartService extends AbstractAggregateFlowMultipartService<MultipartReply> {
-
private final TranslatorLibrary translatorLibrary;
private final ConvertorExecutor convertorExecutor;
private final VersionConvertorData data;
final MultipartRequestAggregateCaseBuilder multipartRequestAggregateCaseBuilder
= new MultipartRequestAggregateCaseBuilder();
final MultipartRequestAggregateBuilder mprAggregateRequestBuilder = new MultipartRequestAggregateBuilder();
- final Uint8 tableId = MoreObjects.firstNonNull(input.getTableId(), OFConstants.OFPTT_ALL);
+ final Uint8 tableId = requireNonNullElse(input.getTableId(), OFConstants.OFPTT_ALL);
mprAggregateRequestBuilder.setTableId(tableId);
- long outputPortValue = MoreObjects.firstNonNull(input.getOutPort(), OFConstants.OFPP_ANY).longValue();
+ long outputPortValue = requireNonNullElse(input.getOutPort(), OFConstants.OFPP_ANY).longValue();
mprAggregateRequestBuilder.setOutPort(Uint32.valueOf(outputPortValue));
final Uint8 version = getVersion();
mprAggregateRequestBuilder.setCookie(OFConstants.DEFAULT_COOKIE);
} else {
mprAggregateRequestBuilder
- .setCookie(MoreObjects.firstNonNull(input.getCookie().getValue(), OFConstants.DEFAULT_COOKIE));
+ .setCookie(requireNonNullElse(input.getCookie().getValue(), OFConstants.DEFAULT_COOKIE));
}
if (input.getCookieMask() == null) {
mprAggregateRequestBuilder.setCookieMask(OFConstants.DEFAULT_COOKIE_MASK);
} else {
mprAggregateRequestBuilder.setCookieMask(
- MoreObjects.firstNonNull(input.getCookieMask().getValue(), OFConstants.DEFAULT_COOKIE_MASK));
+ requireNonNullElse(input.getCookieMask().getValue(), OFConstants.DEFAULT_COOKIE_MASK));
}
- Uint32 outGroup = MoreObjects.firstNonNull(input.getOutGroup(), OFConstants.OFPG_ANY);
+ Uint32 outGroup = requireNonNullElse(input.getOutGroup(), OFConstants.OFPG_ANY);
mprAggregateRequestBuilder.setOutGroup(outGroup);
} else {
mprAggregateRequestBuilder.setOutGroup(OFConstants.OFPG_ANY);
*/
package org.opendaylight.openflowplugin.impl.services.sal;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
*/
public class SalBundleServiceImpl implements SalBundleService {
private static final Logger LOG = LoggerFactory.getLogger(SalBundleServiceImpl.class);
+
private final SalExperimenterMessageService experimenterMessageService;
public SalBundleServiceImpl(final SalExperimenterMessageService experimenterMessageService) {
- this.experimenterMessageService = Preconditions
- .checkNotNull(experimenterMessageService, "SalExperimenterMessageService can not be null!");
+ this.experimenterMessageService = requireNonNull(experimenterMessageService,
+ "SalExperimenterMessageService can not be null!");
}
@Override
*/
package org.opendaylight.openflowplugin.impl.services.sal;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
public final class SalEchoServiceImpl implements SalEchoService {
-
private final EchoService echoService;
public SalEchoServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
private static ListenableFuture<RpcResult<SendEchoOutput>>
transform(final ListenableFuture<RpcResult<EchoOutput>> rpcResultListenableFuture) {
return Futures.transform(rpcResultListenableFuture, input -> {
- Preconditions.checkNotNull(input, "echoOutput value is never expected to be NULL");
+ requireNonNull(input, "echoOutput value is never expected to be NULL");
final RpcResult<SendEchoOutput> rpcOutput;
if (input.isSuccessful()) {
final SendEchoOutput sendEchoOutput = new SendEchoOutputBuilder()
*/
package org.opendaylight.openflowplugin.impl.services.sal;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-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;
public SalFlatBatchServiceImpl(final SalFlowsBatchService salFlowBatchService,
final SalGroupsBatchService salGroupsBatchService,
final SalMetersBatchService salMetersBatchService) {
- this.salFlowService = Preconditions.checkNotNull(salFlowBatchService, "delegate flow service must not be null");
- this.salGroupService =
- Preconditions.checkNotNull(salGroupsBatchService, "delegate group service must not be null");
- this.salMeterService =
- Preconditions.checkNotNull(salMetersBatchService, "delegate meter service must not be null");
+ salFlowService = requireNonNull(salFlowBatchService, "delegate flow service must not be null");
+ salGroupService = requireNonNull(salGroupsBatchService, "delegate group service must not be null");
+ salMeterService = requireNonNull(salMetersBatchService, "delegate meter service must not be null");
}
@Override
private ListenableFuture<RpcResult<ProcessFlatBatchOutput>> getChainOutput(final NodeRef node,
final BatchPlanStep planStep,
final int currentOffset) {
- final ListenableFuture<RpcResult<ProcessFlatBatchOutput>> chainOutput;
-
- switch (planStep.getStepType()) {
- case FLOW_ADD:
+ return switch (planStep.getStepType()) {
+ case FLOW_ADD -> {
final AddFlowsBatchInput addFlowsBatchInput =
- FlatBatchFlowAdapters.adaptFlatBatchAddFlow(planStep, node);
+ FlatBatchFlowAdapters.adaptFlatBatchAddFlow(planStep, node);
final ListenableFuture<RpcResult<AddFlowsBatchOutput>> resultAddFlowFuture =
- salFlowService.addFlowsBatch(addFlowsBatchInput);
- chainOutput = FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultAddFlowFuture, currentOffset);
- break;
- case FLOW_REMOVE:
+ salFlowService.addFlowsBatch(addFlowsBatchInput);
+ yield FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultAddFlowFuture, currentOffset);
+ }
+ case FLOW_REMOVE -> {
final RemoveFlowsBatchInput removeFlowsBatchInput =
- FlatBatchFlowAdapters.adaptFlatBatchRemoveFlow(planStep, node);
+ FlatBatchFlowAdapters.adaptFlatBatchRemoveFlow(planStep, node);
final ListenableFuture<RpcResult<RemoveFlowsBatchOutput>> resultRemoveFlowFuture =
- salFlowService.removeFlowsBatch(removeFlowsBatchInput);
- chainOutput =
- FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultRemoveFlowFuture, currentOffset);
- break;
- case FLOW_UPDATE:
+ salFlowService.removeFlowsBatch(removeFlowsBatchInput);
+ yield FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultRemoveFlowFuture, currentOffset);
+ }
+ case FLOW_UPDATE -> {
final UpdateFlowsBatchInput updateFlowsBatchInput =
- FlatBatchFlowAdapters.adaptFlatBatchUpdateFlow(planStep, node);
+ FlatBatchFlowAdapters.adaptFlatBatchUpdateFlow(planStep, node);
final ListenableFuture<RpcResult<UpdateFlowsBatchOutput>> resultUpdateFlowFuture =
- salFlowService.updateFlowsBatch(updateFlowsBatchInput);
- chainOutput =
- FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultUpdateFlowFuture, currentOffset);
- break;
- case GROUP_ADD:
+ salFlowService.updateFlowsBatch(updateFlowsBatchInput);
+ yield FlatBatchFlowAdapters.convertFlowBatchFutureForChain(resultUpdateFlowFuture, currentOffset);
+ }
+ case GROUP_ADD -> {
final AddGroupsBatchInput addGroupsBatchInput =
- FlatBatchGroupAdapters.adaptFlatBatchAddGroup(planStep, node);
+ FlatBatchGroupAdapters.adaptFlatBatchAddGroup(planStep, node);
final ListenableFuture<RpcResult<AddGroupsBatchOutput>> resultAddGroupFuture =
- salGroupService.addGroupsBatch(addGroupsBatchInput);
- chainOutput =
- FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultAddGroupFuture, currentOffset);
- break;
- case GROUP_REMOVE:
+ salGroupService.addGroupsBatch(addGroupsBatchInput);
+ yield FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultAddGroupFuture, currentOffset);
+ }
+ case GROUP_REMOVE -> {
final RemoveGroupsBatchInput removeGroupsBatchInput =
- FlatBatchGroupAdapters.adaptFlatBatchRemoveGroup(planStep, node);
+ FlatBatchGroupAdapters.adaptFlatBatchRemoveGroup(planStep, node);
final ListenableFuture<RpcResult<RemoveGroupsBatchOutput>> resultRemoveGroupFuture =
- salGroupService.removeGroupsBatch(removeGroupsBatchInput);
- chainOutput =
- FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultRemoveGroupFuture, currentOffset);
- break;
- case GROUP_UPDATE:
+ salGroupService.removeGroupsBatch(removeGroupsBatchInput);
+ yield FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultRemoveGroupFuture, currentOffset);
+ }
+ case GROUP_UPDATE -> {
final UpdateGroupsBatchInput updateGroupsBatchInput =
- FlatBatchGroupAdapters.adaptFlatBatchUpdateGroup(planStep, node);
+ FlatBatchGroupAdapters.adaptFlatBatchUpdateGroup(planStep, node);
final ListenableFuture<RpcResult<UpdateGroupsBatchOutput>> resultUpdateGroupFuture =
- salGroupService.updateGroupsBatch(updateGroupsBatchInput);
- chainOutput =
- FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultUpdateGroupFuture, currentOffset);
- break;
- case METER_ADD:
+ salGroupService.updateGroupsBatch(updateGroupsBatchInput);
+ yield FlatBatchGroupAdapters.convertGroupBatchFutureForChain(resultUpdateGroupFuture, currentOffset);
+ }
+ case METER_ADD -> {
final AddMetersBatchInput addMetersBatchInput =
- FlatBatchMeterAdapters.adaptFlatBatchAddMeter(planStep, node);
+ FlatBatchMeterAdapters.adaptFlatBatchAddMeter(planStep, node);
final ListenableFuture<RpcResult<AddMetersBatchOutput>> resultAddMeterFuture =
- salMeterService.addMetersBatch(addMetersBatchInput);
- chainOutput =
- FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultAddMeterFuture, currentOffset);
- break;
- case METER_REMOVE:
+ salMeterService.addMetersBatch(addMetersBatchInput);
+ yield FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultAddMeterFuture, currentOffset);
+ }
+ case METER_REMOVE -> {
final RemoveMetersBatchInput removeMetersBatchInput =
- FlatBatchMeterAdapters.adaptFlatBatchRemoveMeter(planStep, node);
+ FlatBatchMeterAdapters.adaptFlatBatchRemoveMeter(planStep, node);
final ListenableFuture<RpcResult<RemoveMetersBatchOutput>> resultRemoveMeterFuture =
- salMeterService.removeMetersBatch(removeMetersBatchInput);
- chainOutput =
- FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultRemoveMeterFuture, currentOffset);
- break;
- case METER_UPDATE:
+ salMeterService.removeMetersBatch(removeMetersBatchInput);
+ yield FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultRemoveMeterFuture, currentOffset);
+ }
+ case METER_UPDATE -> {
final UpdateMetersBatchInput updateMetersBatchInput =
- FlatBatchMeterAdapters.adaptFlatBatchUpdateMeter(planStep, node);
+ FlatBatchMeterAdapters.adaptFlatBatchUpdateMeter(planStep, node);
final ListenableFuture<RpcResult<UpdateMetersBatchOutput>> resultUpdateMeterFuture =
- salMeterService.updateMetersBatch(updateMetersBatchInput);
- chainOutput =
- FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultUpdateMeterFuture, currentOffset);
- break;
- default:
+ salMeterService.updateMetersBatch(updateMetersBatchInput);
+ yield FlatBatchMeterAdapters.convertMeterBatchFutureForChain(resultUpdateMeterFuture, currentOffset);
+ }
+ default -> {
LOG.warn("Unsupported plan-step type occurred: {} -> OMITTING", planStep.getStepType());
- chainOutput = FlatBatchUtil.createEmptyRpcBatchResultFuture(true);
- }
-
- return chainOutput;
+ yield FlatBatchUtil.createEmptyRpcBatchResultFuture(true);
+ }
+ };
}
}
*/
package org.opendaylight.openflowplugin.impl.services.sal;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
public SalFlowsBatchServiceImpl(final SalFlowService salFlowService,
final FlowCapableTransactionService transactionService) {
- this.salFlowService = Preconditions.checkNotNull(salFlowService, "delegate flow service must not be null");
- this.transactionService =
- Preconditions.checkNotNull(transactionService, "delegate transaction service must not be null");
+ this.salFlowService = requireNonNull(salFlowService, "delegate flow service must not be null");
+ this.transactionService = requireNonNull(transactionService, "delegate transaction service must not be null");
}
@Override
*/
package org.opendaylight.openflowplugin.impl.services.sal;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
* Default implementation of {@link SalGroupsBatchService} - delegates work to {@link SalGroupService}.
*/
public class SalGroupsBatchServiceImpl implements SalGroupsBatchService {
-
private static final Logger LOG = LoggerFactory.getLogger(SalGroupsBatchServiceImpl.class);
private final SalGroupService salGroupService;
public SalGroupsBatchServiceImpl(final SalGroupService salGroupService,
final FlowCapableTransactionService transactionService) {
- this.salGroupService = Preconditions.checkNotNull(salGroupService);
- this.transactionService = Preconditions.checkNotNull(transactionService);
+ this.salGroupService = requireNonNull(salGroupService);
+ this.transactionService = requireNonNull(transactionService);
}
@Override
*/
package org.opendaylight.openflowplugin.impl.services.sal;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
* Default implementation of {@link SalMetersBatchService} - delegates work to {@link SalMeterService}.
*/
public class SalMetersBatchServiceImpl implements SalMetersBatchService {
-
private static final Logger LOG = LoggerFactory.getLogger(SalMetersBatchServiceImpl.class);
private final SalMeterService salMeterService;
public SalMetersBatchServiceImpl(final SalMeterService salMeterService,
final FlowCapableTransactionService transactionService) {
- this.salMeterService = Preconditions.checkNotNull(salMeterService);
- this.transactionService = Preconditions.checkNotNull(transactionService);
+ this.salMeterService = requireNonNull(salMeterService);
+ this.transactionService = requireNonNull(transactionService);
}
@Override
*/
package org.opendaylight.openflowplugin.impl.services.sal;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
public final class SalRoleServiceImpl extends AbstractSimpleService<SetRoleInput, SetRoleOutput>
implements SalRoleService {
-
private static final Logger LOG = LoggerFactory.getLogger(SalRoleServiceImpl.class);
private static final Uint64 MAX_GENERATION_ID = Uint64.valueOf("ffffffffffffffff", 16);
public SalRoleServiceImpl(final RequestContextStack requestContextStack, final DeviceContext deviceContext) {
super(requestContextStack, deviceContext, SetRoleOutput.class);
- this.deviceContext = Preconditions.checkNotNull(deviceContext);
- this.roleService = new RoleService(requestContextStack, deviceContext, RoleRequestOutput.class);
+ this.deviceContext = requireNonNull(deviceContext);
+ roleService = new RoleService(requestContextStack, deviceContext, RoleRequestOutput.class);
}
@Override
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.services.singlelayer;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
public class SingleLayerAggregateFlowMultipartService
extends AbstractAggregateFlowMultipartService<MultipartReply> {
-
public SingleLayerAggregateFlowMultipartService(final RequestContextStack requestContextStack,
final DeviceContext deviceContext) {
super(requestContextStack, deviceContext);
public ListenableFuture<RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>> handleAndReply(
final GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input) {
return Futures.transform(handleServiceCall(input), result -> {
- if (Preconditions.checkNotNull(result).isSuccessful()) {
+ if (requireNonNull(result).isSuccessful()) {
return RpcResultBuilder
.success(new GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutputBuilder()
.setAggregatedFlowStatistics(result
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.openflowplugin.impl.statistics.ofpspecific;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
* Class counts message of {@link StatisticsGroup} type and provides info as debug log.
*/
public class MessageIntelligenceAgencyImpl implements MessageIntelligenceAgency, MessageIntelligenceAgencyMXBean {
-
private static final Logger LOG = LoggerFactory.getLogger(MessageIntelligenceAgencyImpl.class);
private static final class MessageCounters {
@Override
public void spyMessage(final Class<?> message, final StatisticsGroup statGroup) {
- Preconditions.checkNotNull(message, "Message can't be null.");
+ requireNonNull(message, "Message can't be null.");
getCounters(message, statGroup).increment();
}
*/
package org.opendaylight.openflowplugin.impl.statistics.services.direct;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
}
private RpcResult<O> transformResult(final RpcResult<List<T>> input) {
- return Preconditions.checkNotNull(input).isSuccessful()
+ return requireNonNull(input).isSuccessful()
? RpcResultBuilder.success(buildReply(input.getResult(), input.isSuccessful())).build()
: RpcResultBuilder.<O>failed().withRpcErrors(input.getErrors()).build();
}
private RpcResult<O> storeResult(final RpcResult<O> input) {
- Preconditions.checkNotNull(input);
+ requireNonNull(input);
if (input.isSuccessful()) {
multipartWriterProvider.lookup(multipartType).ifPresent(writer -> {
*/
package org.opendaylight.openflowplugin.impl.util;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.concurrent.atomic.AtomicLong;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
AtomicLong compatibilityXidSeed = new AtomicLong();
// pickup low statistics service
- final OpendaylightFlowStatisticsService flowStatisticsService = Preconditions.checkNotNull(
+ final OpendaylightFlowStatisticsService flowStatisticsService = requireNonNull(
rpcContext.lookupRpcService(OpendaylightFlowStatisticsService.class));
// attach delegate to flow statistics service (to cover all but aggregated stats with match filter input)
*/
package org.opendaylight.openflowplugin.impl.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
*/
@Nullable
public static NodeConnectorRef toNodeConnectorRef(@NonNull final PacketIn packetIn, final Uint64 dataPathId) {
- Preconditions.checkNotNull(packetIn);
+ requireNonNull(packetIn);
NodeConnectorRef ref = null;
Uint32 port = getPortNoFromPacketIn(packetIn);
@SuppressWarnings("unchecked")
@Nullable
public static Uint32 fromNodeConnectorRef(@NonNull final NodeConnectorRef nodeConnectorRef, final Uint8 version) {
- Preconditions.checkNotNull(nodeConnectorRef);
+ requireNonNull(nodeConnectorRef);
Uint32 port = null;
@VisibleForTesting
@Nullable
static Uint32 getPortNoFromPacketIn(@NonNull final PacketIn packetIn) {
- Preconditions.checkNotNull(packetIn);
+ requireNonNull(packetIn);
Uint32 port = null;
import static org.mockito.Mockito.when;
import com.google.common.collect.ImmutableMap;
-import java.util.Hashtable;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
when(config.getDeviceConnectionHoldTimeInSeconds()).thenReturn(DEVICE_CONNECTION_HOLD_TIME_IN_SECONDS);
when(config.getDeviceDatastoreRemovalDelay()).thenReturn(new NonZeroUint32Type(DEVICE_DATASTORE_REMOVAL_DELAY));
- final Map<String, String> properties = new Hashtable<>();
- properties.put(ConfigurationProperty.IS_STATISTICS_POLLING_ON.toString(),
- Boolean.toString(IS_STATISTICS_POLLING_ON));
-
configurationService = new ConfigurationServiceFactoryImpl().newInstance(config);
- configurationService.update(properties);
+ configurationService.update(Map.of(
+ ConfigurationProperty.IS_STATISTICS_POLLING_ON.toString(),
+ Boolean.toString(IS_STATISTICS_POLLING_ON)));
}
@Test
Code Review / openflowplugin.git / commitdiff