package org.opendaylight.protocol.bgp.benchmark.app;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
import com.google.common.net.InetAddresses;
import com.google.common.util.concurrent.FutureCallback;
public AppPeerBenchmark(final DataBroker bindingDataBroker, final RpcProviderRegistry rpcProviderRegistry,
final String appRibId) {
- this.appRibId = Preconditions.checkNotNull(appRibId);
+ this.appRibId = requireNonNull(appRibId);
this.txChain = bindingDataBroker.createTransactionChain(this);
this.appIID = InstanceIdentifier.builder(ApplicationRib.class,
return processRoutes(ipv4Prefix, count, batch, null);
}
- private long processRoutes(final Ipv4Prefix ipv4Prefix, final long count, final long batch, final Attributes attributes) {
+ private long processRoutes(final Ipv4Prefix ipv4Prefix, final long count, final long batch,
+ final Attributes attributes) {
WriteTransaction wTx = this.txChain.newWriteOnlyTransaction();
String address = getAdddressFromPrefix(ipv4Prefix);
final Stopwatch stopwatch = Stopwatch.createStarted();
for (int i = 1; i <= count; i++) {
final Ipv4RouteKey routeKey = new Ipv4RouteKey(PATH_ID, createPrefix(address));
- final KeyedInstanceIdentifier<Ipv4Route, Ipv4RouteKey> routeIId = this.routesIId.child(Ipv4Route.class, routeKey);
+ final KeyedInstanceIdentifier<Ipv4Route, Ipv4RouteKey> routeIId =
+ this.routesIId.child(Ipv4Route.class, routeKey);
if (attributes != null) {
final Ipv4RouteBuilder ipv4RouteBuilder = new Ipv4RouteBuilder();
ipv4RouteBuilder.setPrefix(routeKey.getPrefix());
package org.opendaylight.protocol.bmp.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelHandlerContext;
private final BmpMessageRegistry registry;
public BmpByteToMessageDecoder(final BmpMessageRegistry registry) {
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
}
@Override
- protected void decode(final ChannelHandlerContext ctx, final ByteBuf in, final List<Object> out) throws BmpDeserializationException {
+ protected void decode(final ChannelHandlerContext ctx, final ByteBuf in, final List<Object> out)
+ throws BmpDeserializationException {
if (in.isReadable()) {
LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
out.add(this.registry.parseMessage(in));
package org.opendaylight.protocol.bmp.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.PooledByteBufAllocator;
this.bossGroup = new EpollEventLoopGroup();
this.workerGroup = new EpollEventLoopGroup();
} else {
- this.bossGroup = Preconditions.checkNotNull(bossGroup);
- this.workerGroup = Preconditions.checkNotNull(workerGroup);
+ this.bossGroup = requireNonNull(bossGroup);
+ this.workerGroup = requireNonNull(workerGroup);
}
- this.hf = new BmpHandlerFactory(Preconditions.checkNotNull(registry));
- this.sessionFactory = Preconditions.checkNotNull(sessionFactory);
+ this.hf = new BmpHandlerFactory(requireNonNull(registry));
+ this.sessionFactory = requireNonNull(sessionFactory);
}
@Override
- public ChannelFuture createClient(final InetSocketAddress address, final BmpSessionListenerFactory slf, final KeyMapping keys) {
+ public ChannelFuture createClient(final InetSocketAddress address, final BmpSessionListenerFactory slf,
+ final KeyMapping keys) {
final Bootstrap b = new Bootstrap();
- Preconditions.checkNotNull(address);
+ requireNonNull(address);
if (Epoll.isAvailable()) {
b.channel(EpollSocketChannel.class);
}
@Override
- public ChannelFuture createServer(final InetSocketAddress address, final BmpSessionListenerFactory slf, final KeyMapping keys) {
- Preconditions.checkNotNull(address);
- Preconditions.checkNotNull(slf);
+ public ChannelFuture createServer(final InetSocketAddress address, final BmpSessionListenerFactory slf,
+ final KeyMapping keys) {
+ requireNonNull(address);
+ requireNonNull(slf);
final ServerBootstrap b = new ServerBootstrap();
b.childHandler(new ChannelInitializer<Channel>() {
LOG.debug("Connection {} succeeded!", cf);
} else {
if (this.delay > MAXIMUM_BACKOFF) {
- LOG.warn("The time of maximum backoff has been exceeded. No further connection attempts with BMP router {}.", this.address);
+ LOG.warn("The time of maximum backoff has been exceeded. No further connection attempts with BMP " +
+ "router {}.", this.address);
cf.cancel(false);
return;
}
final EventLoop loop = cf.channel().eventLoop();
loop.schedule(() -> this.bootstrap.connect().addListener(this), this.delay, TimeUnit.MILLISECONDS);
- LOG.info("The connection try to BMP router {} failed. Next reconnection attempt in {} milliseconds.", this.address, this.delay);
+ LOG.info("The connection try to BMP router {} failed. Next reconnection attempt in {} milliseconds.",
+ this.address, this.delay);
this.delay *= 2;
}
}
*/
package org.opendaylight.protocol.bmp.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelOutboundHandler;
private final BmpMessageRegistry registry;
public BmpHandlerFactory(final BmpMessageRegistry registry) {
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
this.encoder = new BmpMessageToByteEncoder(registry);
}
package org.opendaylight.protocol.bmp.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
private final BmpMessageRegistry registry;
public BmpMessageToByteEncoder(final BmpMessageRegistry registry) {
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
}
@Override
- protected void encode(final ChannelHandlerContext ctx, final Notification message, final ByteBuf out) throws Exception {
+ protected void encode(final ChannelHandlerContext ctx, final Notification message, final ByteBuf out)
+ throws Exception {
LOG.trace("Encoding message: {}", message);
this.registry.serializeMessage(message, out);
LOG.debug("Message sent to output: {}", message);
package org.opendaylight.protocol.bmp.impl.app;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bmp.impl.app.KeyConstructorUtil.constructKeys;
import com.google.common.base.Optional;
public BmpMonitoringStationImpl(final BmpDeployerDependencies bmpDeployerDependencies,
final BmpDispatcher dispatcher, final MonitorId monitorId, final InetSocketAddress address,
final List<MonitoredRouter> mrs) {
- this.domDataBroker = Preconditions.checkNotNull(bmpDeployerDependencies.getDomDataBroker());
- this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ this.domDataBroker = requireNonNull(bmpDeployerDependencies.getDomDataBroker());
+ this.dispatcher = requireNonNull(dispatcher);
this.monitorId = monitorId;
this.monitoredRouters = mrs;
- this.address = Preconditions.checkNotNull(address);
+ this.address = requireNonNull(address);
this.yangMonitorId = YangInstanceIdentifier.builder()
.node(BmpMonitor.QNAME).node(Monitor.QNAME)
if (this.monitoredRouters != null) {
for (final MonitoredRouter mr : this.monitoredRouters) {
if (mr.isActive()) {
- Preconditions.checkNotNull(mr.getAddress());
- Preconditions.checkNotNull(mr.getPort());
+ requireNonNull(mr.getAddress());
+ requireNonNull(mr.getPort());
final String s = mr.getAddress().getIpv4Address().getValue();
final InetAddress addr = InetAddresses.forString(s);
final KeyMapping ret;
package org.opendaylight.protocol.bmp.impl.app;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
import java.util.HashMap;
private YangInstanceIdentifier peersYangIId;
public BmpRouterImpl(final RouterSessionManager sessionManager) {
- this.sessionManager = Preconditions.checkNotNull(sessionManager);
+ this.sessionManager = requireNonNull(sessionManager);
this.domDataBroker = sessionManager.getDomDataBroker();
this.domTxChain = this.domDataBroker.createTransactionChain(this);
this.extensions = sessionManager.getExtensions();
this.routerId = new RouterId(Ipv4Util.getIpAddress(this.session.getRemoteAddress()));
// check if this session is redundant
if (!this.sessionManager.addSessionListener(this)) {
- LOG.warn("Redundant BMP session with remote router {} ({}) detected. This BMP session will be abandoned.", this.routerIp, this.session);
+ LOG.warn("Redundant BMP session with remote router {} ({}) detected. This BMP session will be abandoned.",
+ this.routerIp, this.session);
this.close();
} else {
- this.routerYangIId = YangInstanceIdentifier.builder(this.sessionManager.getRoutersYangIId()).nodeWithKey(Router.QNAME,
- ROUTER_ID_QNAME, this.routerIp).build();
+ this.routerYangIId = YangInstanceIdentifier.builder(this.sessionManager.getRoutersYangIId())
+ .nodeWithKey(Router.QNAME, ROUTER_ID_QNAME, this.routerIp).build();
this.peersYangIId = YangInstanceIdentifier.builder(this.routerYangIId).node(Peer.QNAME).build();
createRouterEntry();
LOG.info("BMP session with remote router {} ({}) is up now.", this.routerIp, this.session);
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain, final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ public void onTransactionChainFailed(final TransactionChain<?, ?> chain, final AsyncTransaction<?, ?> transaction,
+ final Throwable cause) {
LOG.error("Transaction chain failed.", cause);
}
private void onPeerUp(final PeerUpNotification peerUp) {
final PeerId peerId = getPeerIdFromOpen(peerUp.getReceivedOpen());
if (!getPeer(peerId).isPresent()) {
- final BmpRouterPeer peer = BmpRouterPeerImpl.createRouterPeer(this.domTxChain, this.peersYangIId, peerUp, this.extensions, this.tree, peerId);
+ final BmpRouterPeer peer = BmpRouterPeerImpl.createRouterPeer(this.domTxChain, this.peersYangIId, peerUp,
+ this.extensions, this.tree, peerId);
this.peers.put(peerId, peer);
LOG.debug("Router {}: Peer {} goes up.", this.routerIp, peerId.getValue());
} else {
package org.opendaylight.protocol.bmp.impl.app;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bmp.impl.app.TablesUtil.BMP_TABLES_QNAME;
import com.google.common.base.Preconditions;
private final BindingCodecTreeNode<ReceivedOpen> receivedOpenCodec;
private boolean up = true;
- private BmpRouterPeerImpl(final DOMTransactionChain domTxChain, final YangInstanceIdentifier peersYangIId, final PeerId peerId,
- final RIBExtensionConsumerContext extensions, final PeerUpNotification peerUp,
- final BindingCodecTree tree) {
- this.domTxChain = Preconditions.checkNotNull(domTxChain);
+ private BmpRouterPeerImpl(final DOMTransactionChain domTxChain, final YangInstanceIdentifier peersYangIId,
+ final PeerId peerId, final RIBExtensionConsumerContext extensions, final PeerUpNotification peerUp,
+ final BindingCodecTree tree) {
+ this.domTxChain = requireNonNull(domTxChain);
this.peerId = peerId;
this.peerYangIId = YangInstanceIdentifier.builder(peersYangIId).nodeWithKey(Peer.QNAME, PEER_ID_QNAME, this.peerId.getValue()).build();
this.sentOpenCodec = tree.getSubtreeCodec(SENT_OPEN_IID);
package org.opendaylight.protocol.bmp.impl.app;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
}
private synchronized boolean isSessionExist(final BmpRouter sessionListener) {
- Preconditions.checkNotNull(sessionListener);
- return this.sessionListeners.containsKey(Preconditions.checkNotNull(sessionListener.getRouterId()));
+ requireNonNull(sessionListener);
+ return this.sessionListeners.containsKey(requireNonNull(sessionListener.getRouterId()));
}
synchronized boolean addSessionListener(final BmpRouter sessionListener) {
package org.opendaylight.protocol.bmp.impl.app;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bmp.impl.app.TablesUtil.BMP_ATTRIBUTES_QNAME;
import static org.opendaylight.protocol.bmp.impl.app.TablesUtil.BMP_ROUTES_QNAME;
@SuppressWarnings({ "unchecked", "rawtypes" })
TableContext(final RIBSupport tableSupport, final YangInstanceIdentifier tableId, final BindingCodecTree tree) {
- this.tableSupport = Preconditions.checkNotNull(tableSupport);
- this.tableId = Preconditions.checkNotNull(tableId);
+ this.tableSupport = requireNonNull(tableSupport);
+ this.tableId = requireNonNull(tableId);
final BindingCodecTreeNode tableCodecContext = tree.getSubtreeCodec(tableId);
final BindingCodecTreeNode<? extends Route> routeListCodec = tableCodecContext
.streamChild(Routes.class)
*/
package org.opendaylight.protocol.bmp.impl.config;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
public BmpDeployerDependencies(final DataBroker dataBroker, final DOMDataBroker domDataBroker,
final RIBExtensionConsumerContext extensions, final BindingCodecTreeFactory codecTreeFactory,
final SchemaContext schemaContext, final ClusterSingletonServiceProvider singletonProvider) {
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.domDataBroker = Preconditions.checkNotNull(domDataBroker);
- this.extensions = Preconditions.checkNotNull(extensions);
- this.tree = Preconditions.checkNotNull(codecTreeFactory).create(schemaContext);
- this.singletonProvider = Preconditions.checkNotNull(singletonProvider);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.domDataBroker = requireNonNull(domDataBroker);
+ this.extensions = requireNonNull(extensions);
+ this.tree = requireNonNull(codecTreeFactory).create(schemaContext);
+ this.singletonProvider = requireNonNull(singletonProvider);
}
public DataBroker getDataBroker() {
*/
package org.opendaylight.protocol.bmp.impl.config;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Iterables;
import java.net.InetSocketAddress;
import java.util.Collection;
private ListenerRegistration<BmpDeployerImpl> registration;
public BmpDeployerImpl(final BmpDispatcher dispatcher, final BmpDeployerDependencies bmpDeployerDependencies) {
- this.dispatcher = Preconditions.checkNotNull(dispatcher);
- this.bmpDeployerDependencies = Preconditions.checkNotNull(bmpDeployerDependencies);
+ this.dispatcher = requireNonNull(dispatcher);
+ this.bmpDeployerDependencies = requireNonNull(bmpDeployerDependencies);
}
public synchronized void register() {
package org.opendaylight.protocol.bmp.impl.session;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Preconditions;
private State state;
public BmpSessionImpl(@Nonnull final BmpSessionListener listener) {
- this.listener = Preconditions.checkNotNull(listener);
+ this.listener = requireNonNull(listener);
this.state = State.IDLE;
}
@Override
public InetAddress getRemoteAddress() {
- Preconditions.checkNotNull(this.channel.remoteAddress(), "BMP Channel doesn't have a valid remote address.");
+ requireNonNull(this.channel.remoteAddress(), "BMP Channel doesn't have a valid remote address.");
return ((InetSocketAddress) this.channel.remoteAddress()).getAddress();
}
package org.opendaylight.protocol.bmp.mock;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.PooledByteBufAllocator;
private final EventLoopGroup workerGroup = new NioEventLoopGroup();
BmpMockDispatcher(final BmpMessageRegistry registry, final BmpSessionFactory sessionFactory) {
- this.sessionFactory = Preconditions.checkNotNull(sessionFactory);
- Preconditions.checkNotNull(registry);
+ this.sessionFactory = requireNonNull(sessionFactory);
+ requireNonNull(registry);
this.hf = new BmpHandlerFactory(registry);
}
}
ChannelFuture createClient(final SocketAddress localAddress, final SocketAddress remoteAddress) {
- Preconditions.checkNotNull(localAddress);
- Preconditions.checkNotNull(remoteAddress);
+ requireNonNull(localAddress);
+ requireNonNull(remoteAddress);
// ideally we should use Bootstrap clones here
final Bootstrap bootstrap = createClientInstance(localAddress);
}
ChannelFuture createServer(final InetSocketAddress localAddress) {
- Preconditions.checkNotNull(localAddress);
+ requireNonNull(localAddress);
final ServerBootstrap serverBootstrap = createServerInstance();
final ChannelFuture channelFuture = serverBootstrap.bind(localAddress);
LOG.info("Initiated BMP server at {}.", localAddress);
package org.opendaylight.protocol.bmp.parser.message;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bmp.parser.message.PeerDownHandler.Reason.REASON_FOUR;
import static org.opendaylight.protocol.bmp.parser.message.PeerDownHandler.Reason.REASON_ONE;
import static org.opendaylight.protocol.bmp.parser.message.PeerDownHandler.Reason.REASON_THREE;
= new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.message.rev150512.peer.down.data.notification.NotificationBuilder();
try {
final Notification not = this.msgRegistry.parseMessage(bytes, null);
- Preconditions.checkNotNull(not, "Notify message may not be null.");
+ requireNonNull(not, "Notify message may not be null.");
Preconditions.checkArgument(not instanceof NotifyMessage, "An instance of NotifyMessage is required");
notificationBuilder.fieldsFrom((NotifyMessage) not);
notificationCBuilder.setNotification(notificationBuilder.build());
package org.opendaylight.protocol.bmp.parser.message;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import io.netty.buffer.ByteBuf;
try {
final Notification opSent = this.msgRegistry
.parseMessage(bytes.readSlice(getBgpMessageLength(bytes)), null);
- Preconditions.checkNotNull(opSent,
+ requireNonNull(opSent,
"Error on parse Sent OPEN Message, Sent OPEN Message is null");
Preconditions.checkArgument(opSent instanceof OpenMessage,
"An instance of OpenMessage notification is required");
final Notification opRec = this.msgRegistry
.parseMessage(bytes.readSlice(getBgpMessageLength(bytes)), null);
- Preconditions.checkNotNull(opRec,
+ requireNonNull(opRec,
"Error on parse Received OPEN Message, Received OPEN Message is null");
Preconditions.checkArgument(opRec instanceof OpenMessage,
"An instance of OpenMessage notification is required");
package org.opendaylight.protocol.bmp.parser.message;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
final RouteMonitoringMessageBuilder routeMonitor = new RouteMonitoringMessageBuilder().setPeerHeader(parsePerPeerHeader(bytes));
try {
final Notification message = this.msgRegistry.parseMessage(bytes, null);
- Preconditions.checkNotNull(message, "UpdateMessage may not be null");
+ requireNonNull(message, "UpdateMessage may not be null");
Preconditions.checkArgument(message instanceof UpdateMessage, "An instance of UpdateMessage is required");
final UpdateMessage updateMessage = (UpdateMessage) message;
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.message.rev150512.route.monitoring
package org.opendaylight.protocol.bmp.parser.tlv;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final SubsequentAddressFamilyRegistry safiRegistry;
public StatType009TlvHandler(final AddressFamilyRegistry afiReg, SubsequentAddressFamilyRegistry safiReg) {
- this.afiRegistry = Preconditions.checkNotNull(afiReg, "AddressFamily cannot be null");
- this.safiRegistry = Preconditions.checkNotNull(safiReg, "SubsequentAddressFamily cannot be null");
+ this.afiRegistry = requireNonNull(afiReg, "AddressFamily cannot be null");
+ this.safiRegistry = requireNonNull(safiReg, "SubsequentAddressFamily cannot be null");
}
@Override
package org.opendaylight.protocol.bmp.parser.tlv;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final SubsequentAddressFamilyRegistry safiRegistry;
public StatType010TlvHandler(final AddressFamilyRegistry afiReg, SubsequentAddressFamilyRegistry safiReg) {
- this.afiRegistry = Preconditions.checkNotNull(afiReg, "AddressFamily cannot be null");
- this.safiRegistry = Preconditions.checkNotNull(safiReg, "SubsequentAddressFamily cannot be null");
+ this.afiRegistry = requireNonNull(afiReg, "AddressFamily cannot be null");
+ this.safiRegistry = requireNonNull(safiReg, "SubsequentAddressFamily cannot be null");
}
@Override
package org.opendaylight.protocol.bmp.spi.parser;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
}
protected final void serializeTlv(final Tlv tlv, final ByteBuf buffer) {
- Preconditions.checkNotNull(tlv, "BMP TLV is mandatory.");
+ requireNonNull(tlv, "BMP TLV is mandatory.");
LOG.trace("Serializing BMP TLV {}", tlv);
this.tlvRegistry.serializeTlv(tlv, buffer);
LOG.trace("Serialized BMP TLV : {}.", ByteBufUtil.hexDump(buffer));
package org.opendaylight.protocol.bmp.spi.parser;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.bgp.concepts.RouteDistinguisherUtil;
public AbstractBmpPerPeerMessageParser(final MessageRegistry bgpMssageRegistry, final BmpTlvRegistry tlvRegistry) {
super(tlvRegistry);
- this.bgpMssageRegistry = Preconditions.checkNotNull(bgpMssageRegistry);
+ this.bgpMssageRegistry = requireNonNull(bgpMssageRegistry);
}
@Override
package org.opendaylight.protocol.bmp.spi.registry;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.List;
import javax.annotation.Nonnull;
@Override
public final synchronized void start(@Nonnull final BmpExtensionProviderContext context) {
Preconditions.checkState(this.registrations == null);
- this.registrations = Preconditions.checkNotNull(startImpl(context));
+ this.registrations = requireNonNull(startImpl(context));
}
@Override
*/
package org.opendaylight.protocol.bmp.spi.registry;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public SimpleBmpExtensionProviderContextActivator(final BmpExtensionProviderContext providerContext,
final List<BmpExtensionProviderActivator> extensionActivators) {
- this.providerContext = Preconditions.checkNotNull(providerContext);
- this.extensionActivators = Preconditions.checkNotNull(extensionActivators);
+ this.providerContext = requireNonNull(providerContext);
+ this.extensionActivators = requireNonNull(extensionActivators);
}
public void start() {
*/
package org.opendaylight.bgp.concepts;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
* @param byteAggregator
*/
public static void serializeRouteDistinquisher(final RouteDistinguisher distinguisher, final ByteBuf byteAggregator) {
- Preconditions.checkNotNull(distinguisher);
+ requireNonNull(distinguisher);
Preconditions.checkState(byteAggregator != null && byteAggregator.isWritable(RD_LENGTH), "Cannot write Route Distinguisher to provided buffer.");
if (distinguisher.getRdTwoOctetAs() != null) {
final String[] values = distinguisher.getRdTwoOctetAs().getValue().split(SEPARATOR);
package org.opendaylight.protocol.bgp.config.loader.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public ConfigLoaderImpl(final SchemaContext schemaContext, final BindingNormalizedNodeSerializer bindingSerializer,
final String path, final WatchService watchService) {
- this.schemaContext = Preconditions.checkNotNull(schemaContext);
- this.bindingSerializer = Preconditions.checkNotNull(bindingSerializer);
- this.path = Preconditions.checkNotNull(path);
- Preconditions.checkNotNull(watchService);
+ this.schemaContext = requireNonNull(schemaContext);
+ this.bindingSerializer = requireNonNull(bindingSerializer);
+ this.path = requireNonNull(path);
+ requireNonNull(watchService);
this.watcherThread = new Thread(new ConfigLoaderImplRunnable(watchService));
this.watcherThread.start();
LOG.info("Config Loader service initiated");
package org.opendaylight.protocol.bgp.evpn.impl.nlri;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bgp.evpn.impl.nlri.NlriModelUtil.extractOrigRouteIp;
import com.google.common.base.Preconditions;
"Wrong length of array of bytes. Passed: %s ;", buffer);
final Esi esi = SimpleEsiTypeRegistry.getInstance().parseEsi(buffer.readSlice(ESI_SIZE));
- final IpAddress ip = Preconditions.checkNotNull(parseOrigRouteIp(buffer));
+ final IpAddress ip = requireNonNull(parseOrigRouteIp(buffer));
final EsRouteBuilder builder = new EsRouteBuilder().setEsi(esi).setOrigRouteIp(ip);
return new EsRouteCaseBuilder().setEsRoute(builder.build()).build();
package org.opendaylight.protocol.bgp.evpn.impl.nlri;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bgp.evpn.impl.nlri.NlriModelUtil.extractETI;
import static org.opendaylight.protocol.bgp.evpn.impl.nlri.NlriModelUtil.extractOrigRouteIp;
"Wrong length of array of bytes. Passed: %s ;", buffer);
final EthernetTagId eti = new EthernetTagIdBuilder().setVlanId(buffer.readUnsignedInt()).build();
- IpAddress ip = Preconditions.checkNotNull(EthSegRParser.parseOrigRouteIp(buffer));
+ IpAddress ip = requireNonNull(EthSegRParser.parseOrigRouteIp(buffer));
final IncMultiEthernetTagResBuilder builder = new IncMultiEthernetTagResBuilder().setEthernetTagId(eti).setOrigRouteIp(ip);
return new IncMultiEthernetTagResCaseBuilder().setIncMultiEthernetTagRes(builder.build()).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Joiner;
import com.google.common.base.Optional;
private static final String FLOW_SEPARATOR = " AND ";
protected AbstractFlowspecNlriParser(final SimpleFlowspecTypeRegistry flowspecTypeRegistry) {
- this.flowspecTypeRegistry = Preconditions.checkNotNull(flowspecTypeRegistry);
+ this.flowspecTypeRegistry = requireNonNull(flowspecTypeRegistry);
}
protected abstract void serializeMpReachNlri(final DestinationType dstType, final ByteBuf byteAggregator);
}
public final List<Flowspec> extractFlowspec(final DataContainerNode<?> route) {
- Preconditions.checkNotNull(route, "Cannot extract flowspec from null route.");
+ requireNonNull(route, "Cannot extract flowspec from null route.");
final List<Flowspec> fsList = new ArrayList<>();
final Optional<DataContainerChild<? extends PathArgument, ?>> flowspecs = route.getChild(FLOWSPEC_NID);
if (flowspecs.isPresent()) {
}
public static final int readNlriLength(@Nonnull final ByteBuf nlri) {
- Preconditions.checkNotNull(nlri, "NLRI information cannot be null");
+ requireNonNull(nlri, "NLRI information cannot be null");
Preconditions.checkState(nlri.isReadable(), "NLRI Byte buffer is not readable.");
int length = nlri.readUnsignedByte();
if (length >= MAX_NLRI_LENGTH_ONE_BYTE) {
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
) {
super(cazeClass, containerClass, listClass, afiClass, safiClass, "route-key", dstContainerClassQName);
- this.nlriParser = Preconditions.checkNotNull(nlriParser);
+ this.nlriParser = requireNonNull(nlriParser);
}
@Override
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.List;
private final FlowspecActivator activator;
public BGPActivator(@Nonnull final FlowspecActivator activator) {
- this.activator = Preconditions.checkNotNull(activator);
+ this.activator = requireNonNull(activator);
}
@Override
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
@Override
public FlowspecType parseType(ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new DestinationPortCaseBuilder().setDestinationPorts(parseDestinationPort(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
@Override
public FlowspecType parseType(ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new DscpCaseBuilder().setDscps(parseDscps(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
@Override
public FlowspecType parseType(ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new IcmpCodeCaseBuilder().setCodes(parseIcmpCode(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
@Override
public FlowspecType parseType(ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new IcmpTypeCaseBuilder().setTypes(parseIcmpType(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
@Override
public FlowspecType parseType(ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new ProtocolIpCaseBuilder().setProtocolIps(parseProtocolIp(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
@Override
public FlowspecType parseType(ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new PacketLengthCaseBuilder().setPacketLengths(parsePacketLength(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
@Override
public FlowspecType parseType(ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new PortCaseBuilder().setPorts(parsePort(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
@Override
public FlowspecType parseType(ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new SourcePortCaseBuilder().setSourcePorts(parseSourcePort(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
@Override
public FlowspecType parseType(ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new TcpFlagsCaseBuilder().setTcpFlags(parseTcpFlags(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Nonnull;
}
public FlowspecActivator(@Nonnull final SimpleFlowspecExtensionProviderContext context) {
- this.context = Preconditions.checkNotNull(context);
+ this.context = requireNonNull(context);
for (SimpleFlowspecExtensionProviderContext.SAFI safi : SimpleFlowspecExtensionProviderContext.SAFI.values()) {
registerCommonFlowspecTypeHandlers(
*/
package org.opendaylight.protocol.bgp.flowspec;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import org.opendaylight.protocol.bgp.flowspec.handlers.FlowspecTypeParser;
import org.opendaylight.protocol.bgp.flowspec.handlers.FlowspecTypeSerializer;
public void serializeFlowspecType(final FlowspecType fsType, final ByteBuf output) {
final FlowspecTypeSerializer serializer = getFlowspecTypeSerializer(fsType);
- Preconditions.checkNotNull(serializer, "serializer for flowspec type %s is not registered.", fsType);
+ requireNonNull(serializer, "serializer for flowspec type " + fsType + " is not registered.");
serializer.serializeType(fsType, output);
}
public FlowspecType parseFlowspecType(final ByteBuf buffer) {
final short type = buffer.readUnsignedByte();
final FlowspecTypeParser parser = getFlowspecTypeParser(type);
- Preconditions.checkNotNull(parser, "parser for flowspec type %s is not registered", type);
+ requireNonNull(parser, "parser for flowspec type "+ type +" is not registered");
return parser.parseType(buffer);
}
*/
package org.opendaylight.protocol.bgp.flowspec.handlers;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
@Override
public FlowspecType parseType(final ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new DestinationPrefixCaseBuilder().setDestinationPrefix(Ipv4Util.prefixForByteBuf(buffer)).build();
}
}
*/
package org.opendaylight.protocol.bgp.flowspec.handlers;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
@Override
public FlowspecType parseType(final ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new SourcePrefixCaseBuilder().setSourcePrefix(Ipv4Util.prefixForByteBuf(buffer)).build();
}
}
*/
package org.opendaylight.protocol.bgp.flowspec.handlers;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.flowspec.rev150807.flowspec.destination.flowspec.FlowspecType;
@Override
public FlowspecType parseType(final ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new DestinationIpv6PrefixCaseBuilder().setDestinationPrefix(
FSIpv6SourcePrefixHandler.parseIpv6Prefix(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec.handlers;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import org.opendaylight.protocol.util.ByteArray;
@Override
public FlowspecType parseType(final ByteBuf buffer) {
- Preconditions.checkNotNull(buffer, "input buffer is null, missing data to parse.");
+ requireNonNull(buffer, "input buffer is null, missing data to parse.");
return new SourceIpv6PrefixCaseBuilder().setSourcePrefix(parseIpv6Prefix(buffer)).build();
}
*/
package org.opendaylight.protocol.bgp.flowspec.l3vpn;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.bgp.concepts.RouteDistinguisherUtil.extractRouteDistinguisher;
-import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.List;
@Override
protected void serializeNlri(final Object[] nlriFields, final ByteBuf buffer) {
- final RouteDistinguisher rd = Preconditions.checkNotNull((RouteDistinguisher) nlriFields[0]);
+ final RouteDistinguisher rd = requireNonNull((RouteDistinguisher) nlriFields[0]);
RouteDistinguisherUtil.serializeRouteDistinquisher(rd, buffer);
final List<Flowspec> flowspecList = (List<Flowspec>) nlriFields[1];
serializeNlri(flowspecList, buffer);
protected Object[] parseNlri(final ByteBuf nlri) throws BGPParsingException {
readNlriLength(nlri);
return new Object[] {
- Preconditions.checkNotNull(readRouteDistinguisher(nlri)),
+ requireNonNull(readRouteDistinguisher(nlri)),
parseL3vpnNlriFlowspecList(nlri)
};
}
package org.opendaylight.protocol.bgp.linkstate.spi.pojo;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
if (nlri == null) {
return;
}
- Preconditions.checkNotNull(byteAggregator);
+ requireNonNull(byteAggregator);
final ObjectType objectType = nlri.getObjectType();
final NlriTypeCaseSerializer serializer = this.nlriRegistry.getSerializer((Class<? extends ObjectType>) objectType.getImplementedInterface());
if (serializer == null) {
if (tlv == null) {
return;
}
- Preconditions.checkNotNull(tlvQName);
- Preconditions.checkNotNull(buffer);
+ requireNonNull(tlvQName);
+ requireNonNull(buffer);
final LinkstateTlvParser.LinkstateTlvSerializer<T> tlvSerializer = (LinkstateTlvParser.LinkstateTlvSerializer<T>) this.tlvSerializers.get(tlvQName);
if (tlvSerializer == null) {
LOG.warn("Linkstate TLV serializer for QName: {} was not found.", tlvQName);
package org.opendaylight.protocol.bgp.openconfig.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.List;
import javax.annotation.concurrent.GuardedBy;
@Override
public final synchronized void startBGPTableTypeRegistryProvider(final BGPTableTypeRegistryProvider provider) {
Preconditions.checkState(this.registrations == null);
- this.registrations = Preconditions.checkNotNull(startBGPTableTypeRegistryProviderImpl(provider));
+ this.registrations = requireNonNull(startBGPTableTypeRegistryProviderImpl(provider));
}
@Override
package org.opendaylight.protocol.bgp.openconfig.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.List;
import org.slf4j.Logger;
public SimpleBGPTableTypeRegistryProviderActivator(final BGPTableTypeRegistryProvider providerContext,
final List<BGPTableTypeRegistryProviderActivator> extensionActivators) {
- this.providerContext = Preconditions.checkNotNull(providerContext);
- this.extensionActivators = Preconditions.checkNotNull(extensionActivators);
+ this.providerContext = requireNonNull(providerContext);
+ this.extensionActivators = requireNonNull(extensionActivators);
}
public void start() {
package org.opendaylight.protocol.bgp.state;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
import io.netty.util.concurrent.GlobalEventExecutor;
public StateProviderImpl(@Nonnull final DataBroker dataBroker, final int timeout,
@Nonnull BGPTableTypeRegistryConsumer bgpTableTypeRegistry, @Nonnull final BGPStateConsumer stateCollector,
@Nonnull final String networkInstanceName, @Nonnull final ClusterSingletonServiceProvider provider) {
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.bgpTableTypeRegistry = Preconditions.checkNotNull(bgpTableTypeRegistry);
- this.stateCollector = Preconditions.checkNotNull(stateCollector);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.bgpTableTypeRegistry = requireNonNull(bgpTableTypeRegistry);
+ this.stateCollector = requireNonNull(stateCollector);
this.networkInstanceIId = InstanceIdentifier.create(NetworkInstances.class)
.child(NetworkInstance.class, new NetworkInstanceKey(networkInstanceName));
this.timeout = timeout;
- this.singletonServiceRegistration = Preconditions.checkNotNull(provider)
+ this.singletonServiceRegistration = requireNonNull(provider)
.registerClusterSingletonService(this);
}
*/
package org.opendaylight.protocol.bgp.parser;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.BgpTableType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.AddressFamily;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.SubsequentAddressFamily;
* @param safi Subsequent Address Family Identifier
*/
public BgpTableTypeImpl(final Class<? extends AddressFamily> afi, final Class<? extends SubsequentAddressFamily> safi) {
- this.afi = Preconditions.checkNotNull(afi, "Address family may not be null");
- this.safi = Preconditions.checkNotNull(safi, "Subsequent address family may not be null");
+ this.afi = requireNonNull(afi, "Address family may not be null");
+ this.safi = requireNonNull(safi, "Subsequent address family may not be null");
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.impl.message;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
private final ParameterRegistry reg;
public BGPOpenMessageParser(final ParameterRegistry reg) {
- this.reg = Preconditions.checkNotNull(reg);
+ this.reg = requireNonNull(reg);
}
/**
*/
package org.opendaylight.protocol.bgp.parser.impl.message;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
private final SubsequentAddressFamilyRegistry safiReg;
public BGPRouteRefreshMessageParser(final AddressFamilyRegistry afiReg, final SubsequentAddressFamilyRegistry safiReg) {
- this.afiReg = Preconditions.checkNotNull(afiReg);
- this.safiReg = Preconditions.checkNotNull(safiReg);
+ this.afiReg = requireNonNull(afiReg);
+ this.safiReg = requireNonNull(safiReg);
}
/**
package org.opendaylight.protocol.bgp.parser.impl.message;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final AttributeRegistry reg;
public BGPUpdateMessageParser(final AttributeRegistry reg) {
- this.reg = Preconditions.checkNotNull(reg);
+ this.reg = requireNonNull(reg);
}
@Override
* @throws BGPDocumentedException
*/
private static void checkMandatoryAttributesPresence(final Update message) throws BGPDocumentedException {
- Preconditions.checkNotNull(message, "Update message cannot be null");
+ requireNonNull(message, "Update message cannot be null");
final Attributes attrs = message.getAttributes();
*/
package org.opendaylight.protocol.bgp.parser.impl.message.open;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final SubsequentAddressFamilyRegistry safiReg;
public AddPathCapabilityHandler(final AddressFamilyRegistry afiReg, final SubsequentAddressFamilyRegistry safiReg) {
- this.afiReg = Preconditions.checkNotNull(afiReg);
- this.safiReg = Preconditions.checkNotNull(safiReg);
+ this.afiReg = requireNonNull(afiReg);
+ this.safiReg = requireNonNull(safiReg);
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.impl.message.open;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
private final CapabilityRegistry reg;
public CapabilityParameterParser(final CapabilityRegistry reg) {
- this.reg = Preconditions.checkNotNull(reg);
+ this.reg = requireNonNull(reg);
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.impl.message.open;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedShort;
import com.google.common.base.Preconditions;
private final SubsequentAddressFamilyRegistry safiReg;
public GracefulCapabilityHandler(final AddressFamilyRegistry afiReg, final SubsequentAddressFamilyRegistry safiReg) {
- this.afiReg = Preconditions.checkNotNull(afiReg);
- this.safiReg = Preconditions.checkNotNull(safiReg);
+ this.afiReg = requireNonNull(afiReg);
+ this.safiReg = requireNonNull(safiReg);
}
private void serializeTables(final List<Tables> tables, final ByteBuf bytes) {
*/
package org.opendaylight.protocol.bgp.parser.impl.message.open;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.util.Optional;
private final SubsequentAddressFamilyRegistry safiReg;
public MultiProtocolCapabilityHandler(final AddressFamilyRegistry afiReg, final SubsequentAddressFamilyRegistry safiReg) {
- this.afiReg = Preconditions.checkNotNull(afiReg);
- this.safiReg = Preconditions.checkNotNull(safiReg);
+ this.afiReg = requireNonNull(afiReg);
+ this.safiReg = requireNonNull(safiReg);
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.impl.message.update;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final ReferenceCache refCache;
public AggregatorAttributeParser(final ReferenceCache refCache) {
- this.refCache = Preconditions.checkNotNull(refCache);
+ this.refCache = requireNonNull(refCache);
}
/**
*/
package org.opendaylight.protocol.bgp.parser.impl.message.update;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private static final AsPath EMPTY = new AsPathBuilder().setSegments(Collections.emptyList()).build();
public AsPathAttributeParser(final ReferenceCache refCache) {
- this.refCache = Preconditions.checkNotNull(refCache);
+ this.refCache = requireNonNull(refCache);
}
/**
*/
package org.opendaylight.protocol.bgp.parser.impl.message.update;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
private final BgpPrefixSidTlvRegistry reg;
public BgpPrefixSidAttributeParser(final BgpPrefixSidTlvRegistry registry) {
- this.reg = Preconditions.checkNotNull(registry);
+ this.reg = requireNonNull(registry);
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.impl.message.update;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
private final ReferenceCache refCache;
public CommunitiesAttributeParser(final ReferenceCache refCache) {
- this.refCache = Preconditions.checkNotNull(refCache);
+ this.refCache = requireNonNull(refCache);
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.impl.message.update;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.protocol.util.NoopReferenceCache;
import org.opendaylight.protocol.util.ReferenceCache;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
private final ReferenceCache refCache;
public CommunityUtil(final ReferenceCache refCache) {
- this.refCache = Preconditions.checkNotNull(refCache);
+ this.refCache = requireNonNull(refCache);
}
/**
package org.opendaylight.protocol.bgp.parser.impl.message.update;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final ExtendedCommunityRegistry ecReg;
public ExtendedCommunitiesAttributeParser(final ExtendedCommunityRegistry ecReg) {
- this.ecReg = Preconditions.checkNotNull(ecReg);
+ this.ecReg = requireNonNull(ecReg);
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.impl.message.update;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final NlriRegistry reg;
public MPReachAttributeParser(final NlriRegistry reg) {
- this.reg = Preconditions.checkNotNull(reg);
+ this.reg = requireNonNull(reg);
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.impl.message.update;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final NlriRegistry reg;
public MPUnreachAttributeParser(final NlriRegistry reg) {
- this.reg = Preconditions.checkNotNull(reg);
+ this.reg = requireNonNull(reg);
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.List;
import javax.annotation.concurrent.GuardedBy;
public final synchronized void start(final BGPExtensionProviderContext context) {
Preconditions.checkState(this.registrations == null);
- this.registrations = Preconditions.checkNotNull(startImpl(context));
+ this.registrations = requireNonNull(startImpl(context));
}
@Override
*/
package org.opendaylight.protocol.bgp.parser.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
@Override
public final void serializeMessage(final Notification message, final ByteBuf buffer) {
- Preconditions.checkNotNull(message, "BGPMessage is mandatory.");
+ requireNonNull(message, "BGPMessage is mandatory.");
serializeMessageImpl(message, buffer);
}
}
package org.opendaylight.protocol.bgp.parser.spi;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
* @return True if AFI/SAFI is supported.
*/
public static boolean isTableTypeSupported(@Nullable final PeerSpecificParserConstraint constraints, @Nonnull final BgpTableType afiSafi) {
- Preconditions.checkNotNull(afiSafi);
+ requireNonNull(afiSafi);
if (constraints != null) {
final Optional<MultiPathSupport> peerConstraint = constraints.getPeerConstraint(MultiPathSupport.class);
return peerConstraint.isPresent() && peerConstraint.get().isTableTypeSupported(afiSafi);
*/
package org.opendaylight.protocol.bgp.parser.spi.pojo;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.Map;
private final Map<N, Class<? extends C>> numberToClass = new ConcurrentHashMap<>();
protected synchronized AutoCloseable registerFamily(final Class<? extends C> clazz, final N number) {
- Preconditions.checkNotNull(clazz);
+ requireNonNull(clazz);
final Class<?> c = this.numberToClass.get(number);
Preconditions.checkState(c == null, "Number " + number + " already registered to " + c);
package org.opendaylight.protocol.bgp.parser.spi.pojo;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableSet;
import java.util.List;
import java.util.Set;
* @return MultiPathSupport instance.
*/
public static MultiPathSupport createParserMultiPathSupport(@Nonnull final List<AddressFamilies> addPathCapabilities) {
- Preconditions.checkNotNull(addPathCapabilities);
+ requireNonNull(addPathCapabilities);
final Set<BgpTableType> support = addPathCapabilities
.stream()
.filter(e -> e.getSendReceive() == SendReceive.Both || e.getSendReceive() == SendReceive.Send)
package org.opendaylight.protocol.bgp.parser.spi.pojo;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.HashMap;
import java.util.Map;
@Override
public synchronized <T extends PeerConstraint> boolean addPeerConstraint(final Class<T> classType, final T peerConstraint) {
- Preconditions.checkNotNull(classType);
- Preconditions.checkNotNull(peerConstraint);
+ requireNonNull(classType);
+ requireNonNull(peerConstraint);
final PeerConstraint previous = this.constraints.putIfAbsent(classType, peerConstraint);
return previous == null;
}
*/
package org.opendaylight.protocol.bgp.parser.spi.pojo;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
private final ByteBuf buffer;
public RawAttribute(final AttributeParser parser, final ByteBuf buffer) {
- this.parser = Preconditions.checkNotNull(parser);
- this.buffer = Preconditions.checkNotNull(buffer);
+ this.parser = requireNonNull(parser);
+ this.buffer = requireNonNull(buffer);
}
}
*/
package org.opendaylight.protocol.bgp.parser.spi.pojo;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.List;
import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderActivator;
import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderContext;
public SimpleBGPExtensionProviderContextActivator(final BGPExtensionProviderContext providerContext,
final List<BGPExtensionProviderActivator> extensionActivators) {
- this.providerContext = Preconditions.checkNotNull(providerContext);
- this.extensionActivators = Preconditions.checkNotNull(extensionActivators);
+ this.providerContext = requireNonNull(providerContext);
+ this.extensionActivators = requireNonNull(extensionActivators);
}
public void start() {
*/
package org.opendaylight.protocol.bgp.parser.spi.pojo;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import io.netty.buffer.ByteBuf;
private final AddressFamilyRegistry afiReg;
public SimpleNlriRegistry(final AddressFamilyRegistry afiReg, final SubsequentAddressFamilyRegistry safiReg) {
- this.afiReg = Preconditions.checkNotNull(afiReg);
- this.safiReg = Preconditions.checkNotNull(safiReg);
+ this.afiReg = requireNonNull(afiReg);
+ this.safiReg = requireNonNull(safiReg);
}
private static BgpTableType createKey(final Class<? extends AddressFamily> afi,
final Class<? extends SubsequentAddressFamily> safi) {
- Preconditions.checkNotNull(afi);
- Preconditions.checkNotNull(safi);
+ requireNonNull(afi);
+ requireNonNull(safi);
return new BgpTableTypeImpl(afi, safi);
}
*/
package org.opendaylight.protocol.bgp.mode.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.collect.ImmutableList;
throw new IllegalStateException("Error creating namespace-specific attributes collection.", e);
}
- this.attributes = Preconditions.checkNotNull(attributes);
+ this.attributes = requireNonNull(attributes);
this.ids = col;
resolveValues();
}
*/
package org.opendaylight.protocol.bgp.mode.impl.add;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedInteger;
import javax.annotation.Nonnull;
import org.opendaylight.protocol.bgp.mode.api.BestPathState;
public AddPathBestPath(@Nonnull final BestPathState state, @Nonnull final RouteKey key, final int offsetPosition, final Long pathId) {
super(state);
- this.routeKey = Preconditions.checkNotNull(key);
+ this.routeKey = requireNonNull(key);
this.offsetPosition = offsetPosition;
this.pathId = pathId;
}
*/
package org.opendaylight.protocol.bgp.mode.impl.add;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.primitives.UnsignedInteger;
import org.opendaylight.protocol.bgp.mode.api.BestPathState;
import org.opendaylight.protocol.bgp.mode.impl.BestPathStateImpl;
}
void processPath(final ContainerNode attrs, final RouteKey key, final int offsetPosition, final Long pathId) {
- Preconditions.checkNotNull(key.getRouteId(), "Router ID may not be null");
+ requireNonNull(key.getRouteId(), "Router ID may not be null");
// Consider only non-null attributes
if (attrs != null) {
package org.opendaylight.protocol.bgp.mode.impl.add.all.paths;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.List;
for (final RouteKey key : keyList) {
final int offset = this.offsets.offsetOf(key);
final ContainerNode attributes = this.offsets.getValue(this.values, offset);
- Preconditions.checkNotNull(key.getRouteId(), "Router ID may not be null");
+ requireNonNull(key.getRouteId(), "Router ID may not be null");
if (attributes != null) {
final BestPathState state = new BestPathStateImpl(attributes);
final AddPathBestPath bestPath = new AddPathBestPath(state, key, offset, this.offsets.getValue(this.pathsId, offset));
*/
package org.opendaylight.protocol.bgp.mode.impl.base;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedInteger;
import javax.annotation.Nonnull;
import org.opendaylight.protocol.bgp.mode.api.BestPathState;
BaseBestPath(@Nonnull final UnsignedInteger routerId, @Nonnull final BestPathState state) {
super(state);
- this.routerId = Preconditions.checkNotNull(routerId);
+ this.routerId = requireNonNull(routerId);
}
@Override
*/
package org.opendaylight.protocol.bgp.mode.impl.base;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.primitives.UnsignedInteger;
import org.opendaylight.protocol.bgp.mode.api.BestPathState;
import org.opendaylight.protocol.bgp.mode.impl.BestPathStateImpl;
}
void processPath(final UnsignedInteger routerId, final ContainerNode attrs) {
- Preconditions.checkNotNull(routerId, "Router ID may not be null");
+ requireNonNull(routerId, "Router ID may not be null");
// Consider only non-null attributes
if (attrs != null) {
package org.opendaylight.protocol.bgp.mode.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
import org.opendaylight.protocol.bgp.mode.api.BestPath;
import org.opendaylight.protocol.bgp.mode.api.BestPathState;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
protected final BestPathState state;
protected AbstractBestPath(final BestPathState state) {
- this.state = Preconditions.checkNotNull(state);
+ this.state = requireNonNull(state);
}
protected abstract MoreObjects.ToStringHelper addToStringAttributes(final MoreObjects.ToStringHelper toStringHelper);
package org.opendaylight.protocol.bgp.peer.acceptor;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.channel.Channel;
import io.netty.channel.ChannelConfig;
public BGPPeerAcceptorImpl(final IpAddress bindingAddress, final PortNumber portNumber,
final BGPDispatcher bgpDispatcher) {
- this.bgpDispatcher = Preconditions.checkNotNull(bgpDispatcher);
- this.address = getAddress(Preconditions.checkNotNull(bindingAddress), Preconditions.checkNotNull(portNumber));
+ this.bgpDispatcher = requireNonNull(bgpDispatcher);
+ this.address = getAddress(requireNonNull(bindingAddress), requireNonNull(portNumber));
if (!PlatformDependent.isWindows() && !PlatformDependent.isRoot()
&& portNumber.getValue() < PRIVILEGED_PORTS) {
throw new AccessControlException("Unable to bind port " + portNumber.getValue() +
*/
package org.opendaylight.protocol.bgp.rib;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.Rib;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.RibKey;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
private final KeyedInstanceIdentifier<Rib, RibKey> instanceIdentifier;
public DefaultRibReference(final KeyedInstanceIdentifier<Rib, RibKey> instanceIdentifier) {
- this.instanceIdentifier = Preconditions.checkNotNull(instanceIdentifier);
+ this.instanceIdentifier = requireNonNull(instanceIdentifier);
}
@Override
*/
package org.opendaylight.controller.config.yang.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.controller.config.api.JmxAttributeValidationException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.BgpTableType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.SendReceive;
private final SendReceive sendReceiveMode;
public AutoCloseableAddPath(final BgpTableType addressFamilyDependency, final SendReceive sendReceive) {
- this.family = Preconditions.checkNotNull(addressFamilyDependency);
- this.sendReceiveMode = Preconditions.checkNotNull(sendReceive);
+ this.family = requireNonNull(addressFamilyDependency);
+ this.sendReceiveMode = requireNonNull(sendReceive);
}
@Override
*/
package org.opendaylight.controller.config.yang.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.controller.config.api.DependencyResolver;
import org.opendaylight.controller.config.api.ModuleIdentifier;
import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
private final PathSelectionMode strategyFactory;
AutoCloseableBestPathSelectionStrategy(final BgpTableType pathFamilyDependency, final PathSelectionMode strategyFactory) {
- this.pathFamilyDependency = Preconditions.checkNotNull(pathFamilyDependency);
- this.strategyFactory = Preconditions.checkNotNull(strategyFactory);
+ this.pathFamilyDependency = requireNonNull(pathFamilyDependency);
+ this.strategyFactory = requireNonNull(strategyFactory);
}
@Override
*/
package org.opendaylight.controller.config.yang.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.controller.config.api.JmxAttributeValidationException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.BgpTableType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.AddressFamily;
private final Class<? extends SubsequentAddressFamily> safi;
public AutoCloseableBgpTableType(final Class<? extends AddressFamily> afi, final Class<? extends SubsequentAddressFamily> safi) {
- this.afi = Preconditions.checkNotNull(afi);
- this.safi = Preconditions.checkNotNull(safi);
+ this.afi = requireNonNull(afi);
+ this.safi = requireNonNull(safi);
}
@Override
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
AbstractBGPSessionNegotiator(final Promise<BGPSessionImpl> promise, final Channel channel,
final BGPPeerRegistry registry) {
- this.promise = Preconditions.checkNotNull(promise);
- this.channel = Preconditions.checkNotNull(channel);
+ this.promise = requireNonNull(promise);
+ this.channel = requireNonNull(channel);
this.registry = registry;
}
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
private final Ipv4Address originatorId;
protected AbstractReflectingExportPolicy(final Ipv4Address originatorId, final ClusterIdentifier clusterId) {
- this.originatorId = Preconditions.checkNotNull(originatorId);
- this.clusterId = Preconditions.checkNotNull(clusterId);
+ this.originatorId = requireNonNull(originatorId);
+ this.clusterId = requireNonNull(clusterId);
}
/**
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import com.google.common.util.concurrent.FutureCallback;
private AdjRibInWriter(final YangInstanceIdentifier ribPath, final DOMTransactionChain chain, final PeerRole role,
final Optional<SimpleRoutingPolicy> simpleRoutingPolicy, final YangInstanceIdentifier peerPath, final Map<TablesKey, TableContext> tables) {
- this.ribPath = Preconditions.checkNotNull(ribPath);
- this.chain = Preconditions.checkNotNull(chain);
- this.tables = Preconditions.checkNotNull(tables);
- this.role = Preconditions.checkNotNull(role);
+ this.ribPath = requireNonNull(ribPath);
+ this.chain = requireNonNull(chain);
+ this.tables = requireNonNull(tables);
+ this.role = requireNonNull(role);
this.simpleRoutingPolicy = simpleRoutingPolicy;
this.peerPath = peerPath;
}
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
private AdjRibOutListener(final PeerId peerId, final TablesKey tablesKey, final YangInstanceIdentifier ribId,
final CodecsRegistry registry, final RIBSupport support, final DOMDataTreeChangeService service,
final ChannelOutputLimiter session, final boolean mpSupport, final LongAdder routeCounter) {
- this.session = Preconditions.checkNotNull(session);
- this.support = Preconditions.checkNotNull(support);
+ this.session = requireNonNull(session);
+ this.support = requireNonNull(support);
this.codecs = registry.getCodecs(this.support);
this.mpSupport = mpSupport;
final YangInstanceIdentifier adjRibOutId = ribId.node(Peer.QNAME).node(IdentifierUtils.domPeerId(peerId)).node(AdjRibOut.QNAME).node(Tables.QNAME).node(RibSupportUtils.toYangTablesKey(tablesKey));
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Verify;
import com.google.common.net.InetAddresses;
import com.google.common.util.concurrent.Futures;
super(rib.getInstanceIdentifier(), "application-peers", new IpAddress(ipAddress), rib.getLocalTablesKeys(),
Collections.emptySet());
this.name = applicationRibId.getValue();
- final RIB targetRib = Preconditions.checkNotNull(rib);
+ final RIB targetRib = requireNonNull(rib);
this.rawIdentifier = InetAddresses.forString(ipAddress.getValue()).getAddress();
final NodeIdentifierWithPredicates peerId = IdentifierUtils.domPeerId(RouterIds.createPeerId(ipAddress));
this.peerIId = targetRib.getYangRibId().node(Peer.QNAME).node(peerId);
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelHandlerContext;
public BGPByteToMessageDecoder(final MessageRegistry registry) {
this.constraints = new PeerSpecificParserConstraintImpl();
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
}
public <T extends PeerConstraint> boolean addDecoderConstraint(final Class<T> classType, final T peerConstraint) {
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.PooledByteBufAllocator;
this.bossGroup = new EpollEventLoopGroup();
this.workerGroup = new EpollEventLoopGroup();
} else {
- this.bossGroup = Preconditions.checkNotNull(bossGroup);
- this.workerGroup = Preconditions.checkNotNull(workerGroup);
+ this.bossGroup = requireNonNull(bossGroup);
+ this.workerGroup = requireNonNull(workerGroup);
}
- this.bgpPeerRegistry = Preconditions.checkNotNull(bgpPeerRegistry);
+ this.bgpPeerRegistry = requireNonNull(bgpPeerRegistry);
this.handlerFactory = new BGPHandlerFactory(messageRegistry);
}
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+
+import static java.util.Objects.requireNonNull;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelOutboundHandler;
private final MessageRegistry registry;
public BGPHandlerFactory(final MessageRegistry registry) {
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
this.encoder = new BGPMessageToByteEncoder(registry);
}
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelHandler.Sharable;
private final MessageRegistry registry;
BGPMessageToByteEncoder(final MessageRegistry registry) {
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
}
@Override
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bgp.rib.impl.AdjRibInWriter.isAnnounceNone;
import static org.opendaylight.protocol.bgp.rib.impl.AdjRibInWriter.isLearnNone;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.net.InetAddresses;
import com.google.common.util.concurrent.Futures;
afiSafisGracefulAdvertized);
this.peerRole = role;
this.simpleRoutingPolicy = Optional.ofNullable(peerStatus);
- this.rib = Preconditions.checkNotNull(rib);
+ this.rib = requireNonNull(rib);
this.name = name;
this.rpcRegistry = rpcRegistry;
this.peerStats = new BGPPeerStatsImpl(this.name, this.tables, this);
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
public BGPSessionImpl(final BGPSessionListener listener, final Channel channel, final Open remoteOpen,
final int localHoldTimer, final BGPPeerRegistry peerRegistry) {
- this.listener = Preconditions.checkNotNull(listener);
- this.channel = Preconditions.checkNotNull(channel);
+ this.listener = requireNonNull(listener);
+ this.channel = requireNonNull(channel);
this.limiter = new ChannelOutputLimiter(this);
this.channel.pipeline().addLast(this.limiter);
this.holdTimerValue = (remoteOpen.getHoldTimer() < localHoldTimer) ? remoteOpen.getHoldTimer() : localHoldTimer;
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import java.util.Map;
import java.util.Map.Entry;
private final BGPSessionListener listener;
public BGPSynchronization(final BGPSessionListener listener, final Set<TablesKey> types) {
- this.listener = Preconditions.checkNotNull(listener);
+ this.listener = requireNonNull(listener);
for (final TablesKey type : types) {
this.syncStorage.put(type, new SyncVariables());
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
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.JdkFutureAdapters;
import com.google.common.util.concurrent.MoreExecutors;
private final Set<TablesKey> supportedFamilies;
BgpPeerRpc(final BGPSession session, final Set<TablesKey> supportedFamilies) {
- this.session = Preconditions.checkNotNull(session);
- this.supportedFamilies = Preconditions.checkNotNull(supportedFamilies);
+ this.session = requireNonNull(session);
+ this.supportedFamilies = requireNonNull(supportedFamilies);
}
@Override
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.Interner;
import com.google.common.collect.Interners;
import com.google.common.collect.MapMaker;
private final AbstractImportPolicy delegate;
CachingImportPolicy(final AbstractImportPolicy delegate) {
- this.delegate = Preconditions.checkNotNull(delegate);
+ this.delegate = requireNonNull(delegate);
}
@Nonnull private static ContainerNode maskNull(@Nullable final ContainerNode unmasked) {
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
private volatile boolean blocked;
ChannelOutputLimiter(final BGPSessionImpl session) {
- this.session = Preconditions.checkNotNull(session);
+ this.session = requireNonNull(session);
}
private void ensureWritable() {
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
private final RIBSupport ribSupport;
public CodecsImpl(final RIBSupport ribSupport) {
- this.ribSupport = Preconditions.checkNotNull(ribSupport);
+ this.ribSupport = requireNonNull(ribSupport);
final Builder<Class<? extends DataObject>> acb = ImmutableSet.builder();
acb.addAll(ATTRIBUTE_CACHEABLES);
acb.addAll(this.ribSupport.cacheableAttributeObjects());
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
private volatile BindingCodecTree latestCodecTree;
private CodecsRegistryImpl(final BindingCodecTreeFactory codecFactory, final GeneratedClassLoadingStrategy strategy) {
- this.codecFactory = Preconditions.checkNotNull(codecFactory);
- this.classContext = Preconditions.checkNotNull(strategy);
+ this.codecFactory = requireNonNull(codecFactory);
+ this.classContext = requireNonNull(strategy);
}
static CodecsRegistryImpl create(final BindingCodecTreeFactory codecFactory, final GeneratedClassLoadingStrategy classStrategy) {
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
AdjInTracker(final DOMDataTreeChangeService service, final RIBSupportContextRegistry registry,
final DOMTransactionChain chain, final YangInstanceIdentifier peerIId,
@Nonnull final PerTableTypeRouteCounter adjRibInRouteCounters, @Nonnull Set<TablesKey> tables) {
- this.registry = Preconditions.checkNotNull(registry);
- this.chain = Preconditions.checkNotNull(chain);
- this.peerIId = Preconditions.checkNotNull(peerIId);
+ this.registry = requireNonNull(registry);
+ this.chain = requireNonNull(chain);
+ this.peerIId = requireNonNull(peerIId);
this.effRibTables = this.peerIId.node(EffectiveRibIn.QNAME).node(Tables.QNAME);
- this.adjRibInRouteCounters = Preconditions.checkNotNull(adjRibInRouteCounters);
+ this.adjRibInRouteCounters = requireNonNull(adjRibInRouteCounters);
this.prefixesInstalled = buildPrefixesTables(tables);
this.prefixesReceived = buildPrefixesTables(tables);
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;
private final Map<PeerRole, PeerExportGroupRegistry> groups = new EnumMap<>(PeerRole.class);
ExportPolicyPeerTrackerImpl(final PolicyDatabase policyDatabase, final TablesKey localTablesKey) {
- this.policyDatabase = Preconditions.checkNotNull(policyDatabase);
+ this.policyDatabase = requireNonNull(policyDatabase);
this.localTableKey = localTablesKey;
}
@Override
public synchronized PeerExportGroup getPeerGroup(final PeerRole role) {
- return this.groups.get(Preconditions.checkNotNull(role));
+ return this.groups.get(requireNonNull(role));
}
@Override
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.protocol.bgp.rib.impl.spi.AbstractImportPolicy;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
private final Ipv4Address bgpIdentifier;
FromInternalImportPolicy(final Ipv4Address bgpIdentifier, final ClusterIdentifier clusterIdentifier) {
- this.bgpIdentifier = Preconditions.checkNotNull(bgpIdentifier);
- this.clusterIdentifier = Preconditions.checkNotNull(clusterIdentifier);
+ this.bgpIdentifier = requireNonNull(bgpIdentifier);
+ this.clusterIdentifier = requireNonNull(clusterIdentifier);
}
@Override
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.protocol.bgp.rib.impl.spi.AbstractImportPolicy;
protected ImportPolicyPeerTrackerImpl(final PolicyDatabase policyDatabase) {
super();
- this.policyDatabase = Preconditions.checkNotNull(policyDatabase);
+ this.policyDatabase = requireNonNull(policyDatabase);
}
@Override
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedInteger;
import java.util.Collection;
import java.util.HashMap;
final YangInstanceIdentifier target, final Long ourAs, final DOMDataTreeChangeService service,
final ExportPolicyPeerTracker exportPolicyPeerTracker, final TablesKey tablesKey,
final PathSelectionMode pathSelectionMode) {
- this.chain = Preconditions.checkNotNull(chain);
- this.target = Preconditions.checkNotNull(target);
+ this.chain = requireNonNull(chain);
+ this.target = requireNonNull(target);
this.tableKey = RibSupportUtils.toYangTablesKey(tablesKey);
this.localTablesKey = tablesKey;
this.locRibTarget = YangInstanceIdentifier.create(target.node(LocRib.QNAME).node(Tables.QNAME)
.node(this.tableKey).getPathArguments());
- this.ourAs = Preconditions.checkNotNull(ourAs);
- this.service = Preconditions.checkNotNull(service);
+ this.ourAs = requireNonNull(ourAs);
+ this.service = requireNonNull(service);
this.ribSupport = registry.getRIBSupportContext(tablesKey).getRibSupport();
this.attributesIdentifier = this.ribSupport.routeAttributesIdentifier();
this.exportPolicyPeerTracker = exportPolicyPeerTracker;
* @param newChain new transaction chain
*/
synchronized void restart(@Nonnull final DOMTransactionChain newChain) {
- Preconditions.checkNotNull(newChain);
+ requireNonNull(newChain);
close();
this.chain = newChain;
init();
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
private final AbstractExportPolicy policy;
public PeerExportGroupImpl(final AbstractExportPolicy policy) {
- this.policy = Preconditions.checkNotNull(policy);
+ this.policy = requireNonNull(policy);
}
@Override
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
import java.util.List;
import java.util.Map;
private static final SchemaPath PROTOCOLS_SCHEMA_PATH = SchemaPath.create(true, NetworkInstances.QNAME, NetworkInstance.QNAME, Protocols.QNAME);
public ProtocolsConfigFileProcessor(final ConfigLoader configLoader, final BgpDeployer bgpDeployer) {
- Preconditions.checkNotNull(configLoader);
- this.bgpDeployer = Preconditions.checkNotNull(bgpDeployer);
+ requireNonNull(configLoader);
+ this.bgpDeployer = requireNonNull(bgpDeployer);
this.protocolsIID = this.bgpDeployer.getInstanceIdentifier().child(Protocols.class);
this.bindingSerializer = configLoader.getBindingNormalizedNodeSerializer();
this.protocolYIId = this.bindingSerializer.toYangInstanceIdentifier(this.protocolsIID.child(Protocol.class));
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.CheckedFuture;
final BindingCodecTreeFactory codecFactory, final DOMDataBroker domDataBroker, final List<BgpTableType> localTables,
@Nonnull final Map<TablesKey, PathSelectionMode> bestPathSelectionStrategies, final GeneratedClassLoadingStrategy classStrategy,
final BgpDeployer.WriteConfiguration configurationWriter) {
- super(InstanceIdentifier.create(BgpRib.class).child(Rib.class, new RibKey(Preconditions.checkNotNull(ribId))),
+ super(InstanceIdentifier.create(BgpRib.class).child(Rib.class, new RibKey(requireNonNull(ribId))),
localBgpId, localAs);
- this.localAs = Preconditions.checkNotNull(localAs);
- this.bgpIdentifier = Preconditions.checkNotNull(localBgpId);
- this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ this.localAs = requireNonNull(localAs);
+ this.bgpIdentifier = requireNonNull(localBgpId);
+ this.dispatcher = requireNonNull(dispatcher);
this.localTables = ImmutableSet.copyOf(localTables);
this.localTablesKeys = new HashSet<>();
- this.domDataBroker = Preconditions.checkNotNull(domDataBroker);
+ this.domDataBroker = requireNonNull(domDataBroker);
this.service = this.domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
- this.extensions = Preconditions.checkNotNull(extensions);
+ this.extensions = requireNonNull(extensions);
this.codecsRegistry = CodecsRegistryImpl.create(codecFactory, classStrategy);
this.ribContextRegistry = RIBSupportContextRegistryImpl.create(extensions, this.codecsRegistry);
final InstanceIdentifierBuilder yangRibIdBuilder = YangInstanceIdentifier.builder().node(BgpRib.QNAME).node(Rib.QNAME);
this.yangRibId = yangRibIdBuilder.nodeWithKey(Rib.QNAME, RIB_ID_QNAME, ribId.getValue()).build();
- this.bestPathSelectionStrategies = Preconditions.checkNotNull(bestPathSelectionStrategies);
+ this.bestPathSelectionStrategies = requireNonNull(bestPathSelectionStrategies);
final ClusterIdentifier cId = clusterId == null ? new ClusterIdentifier(localBgpId) : clusterId;
this.ribId = ribId;
final PolicyDatabase policyDatabase = new PolicyDatabase(this.localAs.getValue(), localBgpId, cId);
this.importPolicyPeerTracker = new ImportPolicyPeerTrackerImpl(policyDatabase);
this.serviceGroupIdentifier = ServiceGroupIdentifier.create(this.ribId.getValue() + "-service-group");
- Preconditions.checkNotNull(provider, "ClusterSingletonServiceProvider is null");
+ requireNonNull(provider, "ClusterSingletonServiceProvider is null");
this.provider = provider;
this.configurationWriter = configurationWriter;
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Verify;
import java.util.Map.Entry;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
private final Codecs codecs;
public RIBSupportContextImpl(final RIBSupport ribSupport, final CodecsRegistry codecs) {
- this.ribSupport = Preconditions.checkNotNull(ribSupport);
+ this.ribSupport = requireNonNull(ribSupport);
this.codecs = codecs.getCodecs(this.ribSupport);
}
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
private final CodecsRegistry codecs;
private RIBSupportContextRegistryImpl(final RIBExtensionConsumerContext extensions, final CodecsRegistry codecs) {
- this.extensionContext = Preconditions.checkNotNull(extensions);
- this.codecs = Preconditions.checkNotNull(codecs);
+ this.extensionContext = requireNonNull(extensions);
+ this.codecs = requireNonNull(codecs);
}
static RIBSupportContextRegistryImpl create(final RIBExtensionConsumerContext extensions, final CodecsRegistry codecs) {
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.PeerId;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
private final PathArgument routeId;
RouteUpdateKey(final PeerId peerId, final PathArgument routeId) {
- this.peerId = Preconditions.checkNotNull(peerId);
- this.routeId = Preconditions.checkNotNull(routeId);
+ this.peerId = requireNonNull(peerId);
+ this.routeId = requireNonNull(routeId);
}
PeerId getPeerId() {
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
@Override
public synchronized void addPeer(final IpAddress ip, final BGPSessionListener peer, final BGPSessionPreferences preferences) {
- Preconditions.checkNotNull(ip);
+ requireNonNull(ip);
Preconditions.checkArgument(!this.peers.containsKey(ip), "Peer for %s already present", ip);
- this.peers.put(ip, Preconditions.checkNotNull(peer));
- Preconditions.checkNotNull(preferences.getMyAs());
- Preconditions.checkNotNull(preferences.getHoldTime());
- Preconditions.checkNotNull(preferences.getParams());
- Preconditions.checkNotNull(preferences.getBgpId());
+ this.peers.put(ip, requireNonNull(peer));
+ requireNonNull(preferences.getMyAs());
+ requireNonNull(preferences.getHoldTime());
+ requireNonNull(preferences.getParams());
+ requireNonNull(preferences.getBgpId());
this.peerPreferences.put(ip, preferences);
for (final PeerRegistryListener peerRegistryListener : this.listeners) {
peerRegistryListener.onPeerAdded(ip, preferences);
@Override
public synchronized void removePeer(final IpAddress ip) {
- Preconditions.checkNotNull(ip);
+ requireNonNull(ip);
this.peers.remove(ip);
for (final PeerRegistryListener peerRegistryListener : this.listeners) {
peerRegistryListener.onPeerRemoved(ip);
@Override
public synchronized void removePeerSession(final IpAddress ip) {
- Preconditions.checkNotNull(ip);
+ requireNonNull(ip);
this.sessionIds.remove(ip);
for (final PeerRegistrySessionListener peerRegistrySessionListener : this.sessionListeners) {
peerRegistrySessionListener.onSessionRemoved(ip);
@Override
public boolean isPeerConfigured(final IpAddress ip) {
- Preconditions.checkNotNull(ip);
+ requireNonNull(ip);
return this.peers.containsKey(ip);
}
@Override
public synchronized BGPSessionListener getPeer(final IpAddress ip, final Ipv4Address sourceId,
final Ipv4Address remoteId, final Open openObj) throws BGPDocumentedException {
- Preconditions.checkNotNull(ip);
- Preconditions.checkNotNull(sourceId);
- Preconditions.checkNotNull(remoteId);
+ requireNonNull(ip);
+ requireNonNull(sourceId);
+ requireNonNull(remoteId);
final AsNumber remoteAsNumber = AsNumberUtil.advertizedAsNumber(openObj);
- Preconditions.checkNotNull(remoteAsNumber);
+ requireNonNull(remoteAsNumber);
final BGPSessionPreferences prefs = getPeerPreferences(ip);
@Override
public BGPSessionPreferences getPeerPreferences(final IpAddress ip) {
- Preconditions.checkNotNull(ip);
+ requireNonNull(ip);
checkPeerConfigured(ip);
return this.peerPreferences.get(ip);
}
* @throws IllegalArgumentException if submitted socket address is not InetSocketAddress[ipv4 | ipv6]
*/
public static IpAddress getIpAddress(final SocketAddress socketAddress) {
- Preconditions.checkNotNull(socketAddress);
+ requireNonNull(socketAddress);
Preconditions.checkArgument(socketAddress instanceof InetSocketAddress, "Expecting InetSocketAddress but was %s", socketAddress.getClass());
final InetAddress inetAddress = ((InetSocketAddress) socketAddress).getAddress();
private final AsNumber asNumber;
BGPSessionId(final Ipv4Address from, final Ipv4Address to, final AsNumber asNumber) {
- this.from = Preconditions.checkNotNull(from);
- this.to = Preconditions.checkNotNull(to);
- this.asNumber = Preconditions.checkNotNull(asNumber);
+ this.from = requireNonNull(from);
+ this.to = requireNonNull(to);
+ this.asNumber = requireNonNull(asNumber);
}
/**
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
private final RIBSupportContext tableSupport;
TableContext(final RIBSupportContext tableSupport, final YangInstanceIdentifier tableId) {
- this.tableSupport = Preconditions.checkNotNull(tableSupport);
- this.tableId = Preconditions.checkNotNull(tableId);
+ this.tableSupport = requireNonNull(tableSupport);
+ this.tableId = requireNonNull(tableId);
}
YangInstanceIdentifier getTableId() {
*/
package org.opendaylight.protocol.bgp.rib.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.PeerRole;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
private final Long localAs;
ToExternalExportPolicy(final Long localAs) {
- this.localAs = Preconditions.checkNotNull(localAs);
+ this.localAs = requireNonNull(localAs);
}
@Override
package org.opendaylight.protocol.bgp.rib.impl.config;
import static com.google.common.util.concurrent.Futures.transform;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.getNeighborInstanceIdentifier;
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.getNeighborInstanceName;
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.getRibInstanceName;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
public BgpDeployerImpl(final String networkInstanceName, final BlueprintContainer container,
final BundleContext bundleContext, final DataBroker dataBroker,
final BGPTableTypeRegistryConsumer mappingService) {
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.container = Preconditions.checkNotNull(container);
- this.bundleContext = Preconditions.checkNotNull(bundleContext);
- this.tableTypeRegistry = Preconditions.checkNotNull(mappingService);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.container = requireNonNull(container);
+ this.bundleContext = requireNonNull(bundleContext);
+ this.tableTypeRegistry = requireNonNull(mappingService);
this.networkInstanceIId = InstanceIdentifier.create(NetworkInstances.class)
.child(NetworkInstance.class, new NetworkInstanceKey(networkInstanceName));
Futures.addCallback(initializeNetworkInstance(dataBroker, this.networkInstanceIId), new FutureCallback<Void>() {
package org.opendaylight.protocol.bgp.rib.impl.config;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.getHoldTimer;
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.getPeerAs;
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.getSimpleRoutingPolicy;
private BgpPeerSingletonService(final RIB rib, final Neighbor neighbor,
final BGPTableTypeRegistryConsumer tableTypeRegistry, final WriteConfiguration configurationWriter) {
this.neighborAddress = neighbor.getNeighborAddress();
- final AfiSafis afisSAfis = Preconditions.checkNotNull(neighbor.getAfiSafis());
+ final AfiSafis afisSAfis = requireNonNull(neighbor.getAfiSafis());
final Set<TablesKey> afiSafisAdvertized = OpenConfigMappingUtil
.toTableKey(afisSAfis.getAfiSafi(), tableTypeRegistry);
this.bgpPeer = new BGPPeer(Ipv4Util.toStringIP(this.neighborAddress), rib,
package org.opendaylight.protocol.bgp.rib.impl.config;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.getAfiSafiWithDefault;
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.getClusterIdentifier;
import static org.opendaylight.protocol.bgp.rib.impl.config.OpenConfigMappingUtil.toTableTypes;
public RibImpl(final ClusterSingletonServiceProvider provider, final RIBExtensionConsumerContext contextProvider,
final BGPDispatcher dispatcher, final BindingCodecTreeFactory codecTreeFactory, final DOMDataBroker domBroker,
final DOMSchemaService domSchemaService) {
- this.provider = Preconditions.checkNotNull(provider);
+ this.provider = requireNonNull(provider);
this.extensions = contextProvider;
this.dispatcher = dispatcher;
this.codecTreeFactory = codecTreeFactory;
*/
package org.opendaylight.protocol.bgp.rib.impl.protocol;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
public BGPProtocolSessionPromise(@Nonnull final InetSocketAddress remoteAddress, final int retryTimer,
@Nonnull final Bootstrap bootstrap, @Nonnull final BGPPeerRegistry peerRegistry) {
super(GlobalEventExecutor.INSTANCE);
- this.address = Preconditions.checkNotNull(remoteAddress);
+ this.address = requireNonNull(remoteAddress);
this.retryTimer = retryTimer;
- this.bootstrap = Preconditions.checkNotNull(bootstrap);
- this.peerRegistry = Preconditions.checkNotNull(peerRegistry);
+ this.bootstrap = requireNonNull(bootstrap);
+ this.peerRegistry = requireNonNull(peerRegistry);
this.listenerRegistration = this.peerRegistry.registerPeerSessionListener(
new PeerRegistrySessionListenerImpl(this, StrictBGPPeerRegistry.getIpAddress(this.address)));
}
public synchronized boolean cancel(final boolean mayInterruptIfRunning) {
closePeerSessionListener();
if (super.cancel(mayInterruptIfRunning)) {
- Preconditions.checkNotNull(this.pending);
+ requireNonNull(this.pending);
this.pending.cancel(mayInterruptIfRunning);
return true;
}
*/
package org.opendaylight.protocol.bgp.rib.impl.protocol;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
@Nonnull final ChannelPipelineInitializer<S> initializer) {
super(executor);
this.bootstrap = bootstrap;
- this.initializer = Preconditions.checkNotNull(initializer);
- this.address = Preconditions.checkNotNull(address);
+ this.initializer = requireNonNull(initializer);
+ this.address = requireNonNull(address);
this.retryTimer = retryTimer;
- this.peerRegistry = Preconditions.checkNotNull(peerRegistry);
+ this.peerRegistry = requireNonNull(peerRegistry);
}
public synchronized void connect() {
* to e.g. Connection refused, Negotiation failed
*/
private synchronized boolean isInitialConnectFinished() {
- Preconditions.checkNotNull(this.pending);
+ requireNonNull(this.pending);
return this.pending.isDone() && this.pending.isSuccess();
}
private synchronized void reconnect() {
- Preconditions.checkNotNull(this.pending);
+ requireNonNull(this.pending);
this.pending.reconnect();
}
@Override
public synchronized boolean cancel(final boolean mayInterruptIfRunning) {
if (super.cancel(mayInterruptIfRunning)) {
- Preconditions.checkNotNull(this.pending);
+ requireNonNull(this.pending);
this.pending.cancel(mayInterruptIfRunning);
return true;
}
package org.opendaylight.protocol.bgp.rib.impl.state;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import java.util.Collections;
@Nonnull final Set<TablesKey> afiSafisAdvertized,
@Nonnull final Set<TablesKey> afiSafisGracefulAdvertized) {
super(instanceIdentifier);
- this.neighborAddress = Preconditions.checkNotNull(neighborAddress);
+ this.neighborAddress = requireNonNull(neighborAddress);
this.groupId = groupId;
- this.afiSafisAdvertized = Preconditions.checkNotNull(afiSafisAdvertized);
- this.afiSafisGracefulAdvertized = Preconditions.checkNotNull(afiSafisGracefulAdvertized);
+ this.afiSafisAdvertized = requireNonNull(afiSafisAdvertized);
+ this.afiSafisGracefulAdvertized = requireNonNull(afiSafisGracefulAdvertized);
}
@Override
package org.opendaylight.protocol.bgp.rib.impl.state;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.HashMap;
import java.util.Map;
protected BGPRIBStateImpl(final KeyedInstanceIdentifier<Rib, RibKey> instanceIdentifier,
@Nonnull final BgpId routeId, @Nonnull final AsNumber localAs) {
super(instanceIdentifier);
- this.routeId = Preconditions.checkNotNull(routeId);
- this.localAs = Preconditions.checkNotNull(localAs);
+ this.routeId = requireNonNull(routeId);
+ this.localAs = requireNonNull(localAs);
}
@Override
*/
package org.opendaylight.protocol.bgp.rib.impl.stats.peer;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bgp.rib.impl.CountersUtil.toZeroBasedCounter32;
import com.google.common.base.Preconditions;
public BGPPeerStatsImpl(@Nonnull final String peerName, @Nonnull final Set<TablesKey> tablesKeySet,
@Nonnull final BGPPeerStateImpl neighborState) {
- Preconditions.checkNotNull(peerName);
- this.tablesKeySet = Preconditions.checkNotNull(tablesKeySet);
+ requireNonNull(peerName);
+ this.tablesKeySet = requireNonNull(tablesKeySet);
this.adjRibInRouteCounters = new PerTableTypeRouteCounter(tablesKeySet);
this.adjRibOutRouteCounters = new PerTableTypeRouteCounter(tablesKeySet);
- this.neighborState = Preconditions.checkNotNull(neighborState);
+ this.neighborState = requireNonNull(neighborState);
}
public PerTableTypeRouteCounter getAdjRibInRouteCounters() {
}
private RouteTable createRouteTable(@Nonnull final TablesKey tablesKey) {
- Preconditions.checkNotNull(tablesKey);
+ requireNonNull(tablesKey);
final RouteTable routeTable = new RouteTable();
// FIXME: setTableType() is DEPRECATED, use setAfi() and setSafi() instead
routeTable.setTableType("afi=" + tablesKey.getAfi().getSimpleName() + ",safi=" + tablesKey.getSafi().getSimpleName());
package org.opendaylight.protocol.bgp.rib.impl.stats.peer;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
}
private static void updateReceivedMsg(final Received received) {
- Preconditions.checkNotNull(received);
+ requireNonNull(received);
final long count = received.getCount() == null ? 0L : received.getCount().getValue();
received.setCount(new ZeroBasedCounter32(count + 1));
received.setTimestamp(new Timestamp(StatisticsUtil.getCurrentTimestampInSeconds()));
}
private static void updateSentMsg(final Sent sent) {
- Preconditions.checkNotNull(sent);
+ requireNonNull(sent);
final long count = sent.getCount() == null ? 0L : sent.getCount().getValue();
sent.setCount(new ZeroBasedCounter32(count + 1));
sent.setTimestamp(new Timestamp(StatisticsUtil.getCurrentTimestampInSeconds()));
}
private static AdvertizedTableTypes addTableType(final BgpTableType type) {
- Preconditions.checkNotNull(type);
+ requireNonNull(type);
final AdvertizedTableTypes att = new AdvertizedTableTypes();
final QName afi = BindingReflections.findQName(type.getAfi()).intern();
final QName safi = BindingReflections.findQName(type.getSafi()).intern();
}
private static AdvertisedAddPathTableTypes addAddPathTableType(final AddressFamilies addressFamilies) {
- Preconditions.checkNotNull(addressFamilies);
+ requireNonNull(addressFamilies);
final AdvertisedAddPathTableTypes att = new AdvertisedAddPathTableTypes();
att.setAfi(new IdentityAttributeRef(BindingReflections.findQName(addressFamilies.getAfi()).intern().toString()));
att.setSafi(new IdentityAttributeRef(BindingReflections.findQName(addressFamilies.getSafi()).intern().toString()));
}
private static RemotePeerPreferences setRemotePeerPref(final Channel channel, final Optional<BGPSessionPreferences> localPreferences) {
- Preconditions.checkNotNull(channel);
+ requireNonNull(channel);
final RemotePeerPreferences pref = new RemotePeerPreferences();
final InetSocketAddress isa = (InetSocketAddress) channel.localAddress();
pref.setHost(IpAddressBuilder.getDefaultInstance(isa.getAddress().getHostAddress()));
private static LocalPeerPreferences setLocalPeerPref(final Open remoteOpen, final Channel channel, final Collection<BgpTableType> tableTypes,
final List<AddressFamilies> addPathTypes) {
- Preconditions.checkNotNull(remoteOpen);
- Preconditions.checkNotNull(channel);
+ requireNonNull(remoteOpen);
+ requireNonNull(channel);
final LocalPeerPreferences pref = new LocalPeerPreferences();
final InetSocketAddress isa = (InetSocketAddress) channel.remoteAddress();
pref.setHost(IpAddressBuilder.getDefaultInstance(isa.getAddress().getHostAddress()));
}
private void updateReceivedMsgErr(@Nonnull final Notify error) {
- Preconditions.checkNotNull(error);
+ requireNonNull(error);
final List<ErrorReceived> errList = this.errMsgs.getErrorReceived();
ErrorReceived received = null;
for (ErrorReceived err : errList) {
}
private void updateSentMsgErr(@Nonnull final Notify error) {
- Preconditions.checkNotNull(error);
+ requireNonNull(error);
final List<ErrorSent> errList = this.errMsgs.getErrorSent();
ErrorSent sent = null;
for (ErrorSent err : errList) {
*/
package org.opendaylight.protocol.bgp.rib.impl.stats.peer.route;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.Map;
import java.util.Set;
}
public final synchronized LongAdder init(@Nonnull final TablesKey tablesKey) {
- LongAdder counter = this.counters.get(Preconditions.checkNotNull(tablesKey));
+ LongAdder counter = this.counters.get(requireNonNull(tablesKey));
if (counter == null) {
counter = new LongAdder();
this.counters.put(tablesKey, counter);
* @param tablesKey
*/
@Nonnull public final LongAdder getCounterOrDefault(@Nonnull final TablesKey tablesKey) {
- return this.counters.getOrDefault(Preconditions.checkNotNull(tablesKey), new LongAdder());
+ return this.counters.getOrDefault(requireNonNull(tablesKey), new LongAdder());
}
/**
return init(tablesKey);
}
- return this.counters.get(Preconditions.checkNotNull(tablesKey));
+ return this.counters.get(requireNonNull(tablesKey));
}
public final Map<TablesKey, LongAdder> getCounters() {
*/
package org.opendaylight.protocol.bgp.rib.impl.stats.rib.impl;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.bgp.rib.impl.CountersUtil.toZeroBasedCounter32;
import com.google.common.base.Preconditions;
public BGPRenderStatsImpl(@Nonnull final BgpId bgpId, @Nonnull final RibId ribId, @Nonnull final AsNumber localAs,
@Nullable final ClusterIdentifier clusterId, @Nonnull final BGPRIBState globalState,
@Nonnull final Set<TablesKey> tablesKeys) {
- this.bgpId = Preconditions.checkNotNull(bgpId);
- this.ribId = Preconditions.checkNotNull(ribId);
- this.globalState = Preconditions.checkNotNull(globalState);
- this.tablesKeys = Preconditions.checkNotNull(tablesKeys);
+ this.bgpId = requireNonNull(bgpId);
+ this.ribId = requireNonNull(ribId);
+ this.globalState = requireNonNull(globalState);
+ this.tablesKeys = requireNonNull(tablesKeys);
this.localAs = localAs;
this.clusterId = clusterId;
}
*/
package org.opendaylight.protocol.bgp.rib.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.List;
import javax.annotation.concurrent.GuardedBy;
public final synchronized void startRIBExtensionProvider(final RIBExtensionProviderContext context) {
Preconditions.checkState(this.registrations == null);
- this.registrations = Preconditions.checkNotNull(startRIBExtensionProviderImpl(context));
+ this.registrations = requireNonNull(startRIBExtensionProviderImpl(context));
}
@Override
*/
package org.opendaylight.protocol.bgp.rib.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Collections;
import javax.annotation.Nonnull;
final QName qname = BindingReflections.findQName(containerClass).intern();
this.routesContainerIdentifier = new NodeIdentifier(qname);
this.routeAttributesIdentifier = new NodeIdentifier(QName.create(qname, Attributes.QNAME.getLocalName().intern()));
- this.cazeClass = Preconditions.checkNotNull(cazeClass);
- this.containerClass = Preconditions.checkNotNull(containerClass);
- this.listClass = Preconditions.checkNotNull(listClass);
+ this.cazeClass = requireNonNull(cazeClass);
+ this.containerClass = requireNonNull(containerClass);
+ this.listClass = requireNonNull(listClass);
this.routeQname = QName.create(qname, BindingReflections.findQName(listClass).intern().getLocalName());
this.routesListIdentifier = new NodeIdentifier(this.routeQname);
this.emptyRoutes = Builders.choiceBuilder().withNodeIdentifier(ROUTES).addChild(Builders.containerBuilder()
*/
package org.opendaylight.protocol.bgp.rib.spi;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
import java.util.ServiceLoader;
private final ServiceLoader<RIBExtensionProviderActivator> loader;
private ServiceLoaderRIBExtensionConsumerContext(final ServiceLoader<RIBExtensionProviderActivator> loader) {
- this.loader = Preconditions.checkNotNull(loader);
+ this.loader = requireNonNull(loader);
for (RIBExtensionProviderActivator a : loader) {
a.startRIBExtensionProvider(this);
*/
package org.opendaylight.protocol.bgp.rib.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.HashSet;
import java.util.Set;
@Override
public RIBSupport getRIBSupport(final TablesKey key) {
- return this.supports.get(Preconditions.checkNotNull(key));
+ return this.supports.get(requireNonNull(key));
}
@Override
*/
package org.opendaylight.protocol.bgp.rib.spi;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public SimpleRIBExtensionProviderContextActivator(final RIBExtensionProviderContext providerContext,
final List<RIBExtensionProviderActivator> extensionActivators) {
- this.providerContext = Preconditions.checkNotNull(providerContext);
- this.extensionActivators = Preconditions.checkNotNull(extensionActivators);
+ this.providerContext = requireNonNull(providerContext);
+ this.extensionActivators = requireNonNull(extensionActivators);
}
public void start() {
*/
package org.opendaylight.bgpcep.bgp.topology.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collections;
private int useCount = 1;
NodeUsage(final InstanceIdentifier<IgpNodeAttributes> attrId) {
- this.attrId = Preconditions.checkNotNull(attrId);
+ this.attrId = requireNonNull(attrId);
}
}
*/
package org.opendaylight.bgpcep.bgp.topology.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
final Class<? extends SubsequentAddressFamily> safi, final long listenerResetLimitInMillsec,
final int listenerResetEnforceCounter) {
this.dataProvider = dataProvider;
- this.locRibReference = Preconditions.checkNotNull(locRibReference);
- this.topologyKey = new TopologyKey(Preconditions.checkNotNull(topologyId));
+ this.locRibReference = requireNonNull(locRibReference);
+ this.topologyKey = new TopologyKey(requireNonNull(topologyId));
this.topologyTypes = types;
this.afi = afi;
this.safi = safi;
}
private synchronized void initOperationalTopology() {
- Preconditions.checkNotNull(this.chain, "A valid transaction chain must be provided.");
+ requireNonNull(this.chain, "A valid transaction chain must be provided.");
final WriteTransaction trans = this.chain.newWriteOnlyTransaction();
trans.put(LogicalDatastoreType.OPERATIONAL, this.topology,
new TopologyBuilder().setKey(this.topologyKey).setServerProvided(Boolean.TRUE).setTopologyTypes(this.topologyTypes)
* @throws TransactionCommitFailedException
*/
private synchronized ListenableFuture<Void> destroyOperationalTopology() {
- Preconditions.checkNotNull(this.chain, "A valid transaction chain must be provided.");
+ requireNonNull(this.chain, "A valid transaction chain must be provided.");
final WriteTransaction trans = this.chain.newWriteOnlyTransaction();
trans.delete(LogicalDatastoreType.OPERATIONAL, getInstanceIdentifier());
final ListenableFuture<Void> future = trans.submit();
*/
@VisibleForTesting
protected synchronized void resetListener() {
- Preconditions.checkNotNull(this.listenerRegistration, "Listener on topology %s hasn't been initialized.", this);
+ requireNonNull(this.listenerRegistration, "Listener on topology " + this + " hasn't been initialized.");
LOG.debug("Resetting data change listener for topology builder {}", getInstanceIdentifier());
// unregister current listener to prevent incoming data tree change first
unregisterDataChangeListener();
*/
package org.opendaylight.bgpcep.bgp.topology.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
private final TerminationPoint tp;
private TpHolder(final TerminationPoint tp) {
- this.tp = Preconditions.checkNotNull(tp);
+ this.tp = requireNonNull(tp);
}
private synchronized void addLink(final LinkId id, final boolean isRemote) {
}
private void advertized(final NodeBuilder nb, final IgpNodeAttributesBuilder inab) {
- this.nb = Preconditions.checkNotNull(nb);
- this.inab = Preconditions.checkNotNull(inab);
+ this.nb = requireNonNull(nb);
+ this.inab = requireNonNull(inab);
this.advertized = true;
LOG.debug("Node {} is advertized", nb.getNodeId());
}
package org.opendaylight.bgpcep.bgp.topology.provider;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
import java.util.Map;
import javax.annotation.Nonnull;
private final YangInstanceIdentifier topologyYii;
public NetworkTopologyConfigFileProcessor(final ConfigLoader configLoader, final BgpTopologyDeployer deployer) {
- Preconditions.checkNotNull(configLoader);
- this.deployer = Preconditions.checkNotNull(deployer);
+ requireNonNull(configLoader);
+ this.deployer = requireNonNull(deployer);
this.bindingSerializer = configLoader.getBindingNormalizedNodeSerializer();
this.topologyYii = this.bindingSerializer.toYangInstanceIdentifier(deployer.getInstanceIdentifier());
this.registration = configLoader.registerConfigFile(this);
package org.opendaylight.bgpcep.bgp.topology.provider.config;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import java.util.Collection;
private boolean closed;
public BgpTopologyDeployerImpl(final BundleContext context, final DataBroker dataBroker, final ClusterSingletonServiceProvider singletonProvider) {
- this.context = Preconditions.checkNotNull(context);
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.singletonProvider = Preconditions.checkNotNull(singletonProvider);
+ this.context = requireNonNull(context);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.singletonProvider = requireNonNull(singletonProvider);
this.registration =
this.dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(NetworkTopology.class).child(Topology.class)), this);
LOG.info("BGP topology deployer started.");
package org.opendaylight.bgpcep.bgp.topology.provider.config;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.function.Function;
TopologyReferenceSingletonServiceImpl(final AbstractTopologyBuilder<?> topologyBuilder, final BgpTopologyDeployer deployer,
final Topology configuration, final Function<Topology, Void> writeFunction) {
this.writeFunction = writeFunction;
- this.configuration = Preconditions.checkNotNull(configuration);
- this.topologyBuilder = Preconditions.checkNotNull(topologyBuilder);
+ this.configuration = requireNonNull(configuration);
+ this.topologyBuilder = requireNonNull(topologyBuilder);
this.serviceRegistration = deployer.registerService(this);
}
package org.opendaylight.bgpcep.bgp.topology.provider;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collections;
import org.junit.Before;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
public abstract class AbstractTopologyBuilderTest extends AbstractConcurrentDataBrokerTest {
static final TopologyId TEST_TOPOLOGY_ID = new TopologyId("test-topo");
static final RibReference LOC_RIB_REF = new DefaultRibReference(InstanceIdentifier.create(BgpRib.class)
- .child(Rib.class, new RibKey(Preconditions.checkNotNull(new RibId("test-rib")))));
+ .child(Rib.class, new RibKey(requireNonNull(new RibId("test-rib")))));
@Before
public void setUp() {
*/
package org.opendaylight.protocol.bgp.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
}
public static List<byte[]> parseMessages(final InputStream is) throws IOException {
- Preconditions.checkNotNull(is);
+ requireNonNull(is);
try (InputStreamReader isr = new InputStreamReader(is, "UTF-8")) {
return parseMessages(CharStreams.toString(isr));
} finally {
*/
package org.opendaylight.protocol.concepts;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private final InstanceIdentifier<T> instanceIdentifier;
public DefaultInstanceReference(final InstanceIdentifier<T> instanceIdentifier) {
- this.instanceIdentifier = Preconditions.checkNotNull(instanceIdentifier);
+ this.instanceIdentifier = requireNonNull(instanceIdentifier);
}
@Override
*/
package org.opendaylight.protocol.data.change.counter;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.HashMap;
private ListenerRegistration<TopologyDataChangeCounterDeployer> registration;
public TopologyDataChangeCounterDeployer(final DataBroker dataBroker) {
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
+ this.dataBroker = requireNonNull(dataBroker);
}
public synchronized void register() {
*/
package org.opendaylight.protocol.pcep.parser.object;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
private final EROSubobjectRegistry subobjReg;
protected AbstractEROWithSubobjectsParser(final EROSubobjectRegistry subobjReg) {
- this.subobjReg = Preconditions.checkNotNull(subobjReg);
+ this.subobjReg = requireNonNull(subobjReg);
}
protected List<Subobject> parseSubobjects(final ByteBuf buffer) throws PCEPDeserializerException {
*/
package org.opendaylight.protocol.pcep.parser.object;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
private static final int HEADER_LENGTH = 2;
protected AbstractRROWithSubobjectsParser(final RROSubobjectRegistry subobjReg) {
- this.subobjReg = Preconditions.checkNotNull(subobjReg);
+ this.subobjReg = requireNonNull(subobjReg);
}
protected List<Subobject> parseSubobjects(final ByteBuf buffer) throws PCEPDeserializerException {
*/
package org.opendaylight.protocol.pcep.parser.object;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
private final XROSubobjectRegistry subobjReg;
protected AbstractXROWithSubobjectsParser(final XROSubobjectRegistry subobjReg) {
- this.subobjReg = Preconditions.checkNotNull(subobjReg);
+ this.subobjReg = requireNonNull(subobjReg);
}
protected List<Subobject> parseSubobjects(final ByteBuf buffer) throws PCEPDeserializerException {
*/
package org.opendaylight.protocol.pcep.parser.subobject;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final LabelRegistry registry;
public EROLabelSubobjectParser(final LabelRegistry labelReg) {
- this.registry = Preconditions.checkNotNull(labelReg);
+ this.registry = requireNonNull(labelReg);
}
@Override
*/
package org.opendaylight.protocol.pcep.parser.subobject;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final LabelRegistry registry;
public RROLabelSubobjectParser(final LabelRegistry labelReg) {
- this.registry = Preconditions.checkNotNull(labelReg);
+ this.registry = requireNonNull(labelReg);
}
@Override
@Override
public void serializeSubobject(final Subobject subobject, final ByteBuf buffer) {
- Preconditions.checkNotNull(subobject.getSubobjectType(), "Subobject type cannot be empty.");
+ requireNonNull(subobject.getSubobjectType(), "Subobject type cannot be empty.");
final Label label = ((LabelCase) subobject.getSubobjectType()).getLabel();
final ByteBuf body = Unpooled.buffer();
this.registry.serializeLabel(label.isUniDirectional(), label.isGlobal(), label.getLabelType(), body);
*/
package org.opendaylight.protocol.pcep.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.channel.Channel;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
protected final Promise<PCEPSessionImpl> promise;
protected AbstractSessionNegotiator(final Promise<PCEPSessionImpl> promise, final Channel channel) {
- this.promise = Preconditions.checkNotNull(promise);
- this.channel = Preconditions.checkNotNull(channel);
+ this.promise = requireNonNull(promise);
+ this.channel = requireNonNull(channel);
}
protected final void negotiationSuccessful(final PCEPSessionImpl session) {
*/
package org.opendaylight.protocol.pcep.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import io.netty.channel.Channel;
import io.netty.util.concurrent.Promise;
import org.opendaylight.protocol.pcep.PCEPSessionListener;
this.maxUnknownMessages = maxUnknownMessages;
this.myLocalPrefs = new OpenBuilder().setKeepalive(localPrefs.getKeepalive()).setDeadTimer(localPrefs.getDeadTimer()).setSessionId(
sessionId).setTlvs(localPrefs.getTlvs()).build();
- this.listener = Preconditions.checkNotNull(listener);
+ this.listener = requireNonNull(listener);
}
public DefaultPCEPSessionNegotiator(final Promise<PCEPSessionImpl> promise, final Channel channel,
*/
package org.opendaylight.protocol.pcep.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.channel.Channel;
import io.netty.util.concurrent.Promise;
import java.net.InetSocketAddress;
}
public DefaultPCEPSessionNegotiatorFactory(final PCEPSessionProposalFactory spf, final int maxUnknownMessages, final Tls tlsConfiguration) {
- this.spf = Preconditions.checkNotNull(spf);
+ this.spf = requireNonNull(spf);
this.maxUnknownMessages = maxUnknownMessages;
this.tlsConfiguration = tlsConfiguration;
}
*/
package org.opendaylight.protocol.pcep.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelFutureListener;
private final MessageRegistry registry;
public PCEPByteToMessageDecoder(final MessageRegistry registry) {
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
}
@Override
*/
package org.opendaylight.protocol.pcep.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.channel.ChannelFuture;
public PCEPDispatcherImpl(@Nonnull final MessageRegistry registry,
@Nonnull final PCEPSessionNegotiatorFactory negotiatorFactory,
@Nonnull final EventLoopGroup bossGroup, @Nonnull final EventLoopGroup workerGroup) {
- this.snf = Preconditions.checkNotNull(negotiatorFactory);
+ this.snf = requireNonNull(negotiatorFactory);
this.hf = new PCEPHandlerFactory(registry);
if (Epoll.isAvailable()) {
this.bossGroup = new EpollEventLoopGroup();
this.workerGroup = new EpollEventLoopGroup();
} else {
- this.bossGroup = Preconditions.checkNotNull(bossGroup);
- this.workerGroup = Preconditions.checkNotNull(workerGroup);
+ this.bossGroup = requireNonNull(bossGroup);
+ this.workerGroup = requireNonNull(workerGroup);
}
- this.executor = Preconditions.checkNotNull(GlobalEventExecutor.INSTANCE);
+ this.executor = requireNonNull(GlobalEventExecutor.INSTANCE);
}
@Override
*/
package org.opendaylight.protocol.pcep.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelOutboundHandler;
private final ChannelOutboundHandler encoder;
public PCEPHandlerFactory(final MessageRegistry registry) {
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
this.encoder = new PCEPMessageToByteEncoder(registry);
}
*/
package org.opendaylight.protocol.pcep.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelHandler.Sharable;
private final MessageRegistry registry;
public PCEPMessageToByteEncoder(final MessageRegistry registry) {
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
}
@Override
protected void encode(final ChannelHandlerContext ctx, final Message msg, final ByteBuf out) {
- Preconditions.checkNotNull(msg);
+ requireNonNull(msg);
this.registry.serializeMessage(msg, out);
if (LOG.isTraceEnabled()) {
LOG.trace("Encoded : {}", ByteBufUtil.hexDump(out));
*/
package org.opendaylight.protocol.pcep.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
PCEPProtocolSessionPromise(final EventExecutor executor, final InetSocketAddress address,
final int retryTimer, final int connectTimeout, final Bootstrap b) {
super(executor);
- this.address = Preconditions.checkNotNull(address);
+ this.address = requireNonNull(address);
this.retryTimer = retryTimer;
this.connectTimeout = connectTimeout;
- this.b = Preconditions.checkNotNull(b);
+ this.b = requireNonNull(b);
}
synchronized void connect() {
*/
package org.opendaylight.protocol.pcep.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import com.google.common.base.Ticker;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
PCEPSessionImpl(final PCEPSessionListener listener, final int maxUnknownMessages, final Channel channel,
final Open localOpen, final Open remoteOpen) {
- this.listener = Preconditions.checkNotNull(listener);
- this.channel = Preconditions.checkNotNull(channel);
- this.localOpen = Preconditions.checkNotNull(localOpen);
- this.remoteOpen = Preconditions.checkNotNull(remoteOpen);
+ this.listener = requireNonNull(listener);
+ this.channel = requireNonNull(channel);
+ this.localOpen = requireNonNull(localOpen);
+ this.remoteOpen = requireNonNull(remoteOpen);
this.lastMessageReceivedAt = TICKER.read();
if (maxUnknownMessages != 0) {
package org.opendaylight.protocol.pcep.impl;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.channel.Channel;
import java.net.InetSocketAddress;
import org.opendaylight.protocol.util.StatisticsUtil;
private final MessagesBuilder msgsBuilder;
public PCEPSessionState(final Open remoteOpen, final Open localOpen, final Channel channel) {
- Preconditions.checkNotNull(remoteOpen);
- Preconditions.checkNotNull(localOpen);
- Preconditions.checkNotNull(channel);
+ requireNonNull(remoteOpen);
+ requireNonNull(localOpen);
+ requireNonNull(channel);
this.peerPref = getRemotePref(remoteOpen, channel);
this.localPref = getLocalPref(localOpen, channel);
this.lastReceivedErrorBuilder = new LastReceivedErrorBuilder();
}
private static ErrorObject getErrorObject(final Message msg) {
- Preconditions.checkNotNull(msg);
+ requireNonNull(msg);
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcerr.message.PcerrMessage errMsg =
((PcerrMessage) msg).getPcerrMessage();
return errMsg.getErrors().get(errMsg.getErrors().size() - 1).getErrorObject();
*/
package org.opendaylight.protocol.pcep.impl.tls;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.io.IOException;
import java.security.KeyStore;
import java.security.NoSuchAlgorithmException;
* keystore types
*/
public SslContextFactory(final Tls tlsConfig) {
- this.tlsConfig = Preconditions.checkNotNull(tlsConfig);
+ this.tlsConfig = requireNonNull(tlsConfig);
}
public SSLContext getServerContext() {
package org.opendaylight.protocol.pcep.impl;
+import static java.util.Objects.requireNonNull;
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.opendaylight.protocol.util.CheckUtil.waitFutureSuccess;
-import com.google.common.base.Preconditions;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
private final EventLoopGroup workerGroup;
PCCMock(final PCEPSessionNegotiatorFactory<?> negotiatorFactory, final PCEPHandlerFactory factory) {
- this.workerGroup = Preconditions.checkNotNull(new NioEventLoopGroup());
- this.negotiatorFactory = Preconditions.checkNotNull(negotiatorFactory);
- this.factory = Preconditions.checkNotNull(factory);
- this.executor = Preconditions.checkNotNull(GlobalEventExecutor.INSTANCE);
+ this.workerGroup = requireNonNull(new NioEventLoopGroup());
+ this.negotiatorFactory = requireNonNull(negotiatorFactory);
+ this.factory = requireNonNull(factory);
+ this.executor = requireNonNull(GlobalEventExecutor.INSTANCE);
}
Future<PCEPSession> createClient(final InetSocketAddress address, final int retryTimer,
package org.opendaylight.protocol.pcep.pcc.mock;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import java.math.BigInteger;
import javax.annotation.Nonnull;
import org.opendaylight.protocol.pcep.pcc.mock.api.PCCSession;
private Boolean resynchronizing = Boolean.FALSE;
public PCCSyncOptimization(@Nonnull final PCCSession session) {
- Preconditions.checkNotNull(session);
+ requireNonNull(session);
final Tlvs remote = session.getRemoteTlvs();
final Tlvs local = session.localSessionCharacteristics();
this.localLspDbVersion = getLspDbVersion(local);
package org.opendaylight.protocol.pcep.pcc.mock;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.protocol.pcep.pcc.mock.spi.MsgBuilderUtil.createLsp;
import static org.opendaylight.protocol.pcep.pcc.mock.spi.MsgBuilderUtil.createLspTlvs;
import static org.opendaylight.protocol.pcep.pcc.mock.spi.MsgBuilderUtil.createLspTlvsEndofSync;
this.redelegationTimeout = redelegationTimeout;
this.stateTimeout = stateTimeout;
this.plspIDsCounter = new AtomicLong(lspsCount);
- this.address = InetAddresses.toAddrString(Preconditions.checkNotNull(address));
- this.timer = Preconditions.checkNotNull(timer);
+ this.address = InetAddresses.toAddrString(requireNonNull(address));
+ this.timer = requireNonNull(timer);
this.timerHandler = timerHandler;
this.lspsCount = lspsCount;
}
package org.opendaylight.protocol.pcep.pcc.mock.protocol;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.math.BigInteger;
import java.net.InetSocketAddress;
import javax.annotation.Nonnull;
@Override
public void setPeerSpecificProposal(@Nonnull final InetSocketAddress address, @Nonnull final TlvsBuilder openBuilder) {
- Preconditions.checkNotNull(address);
+ requireNonNull(address);
final LspDbVersion lspDbVersion = new LspDbVersionBuilder().setLspDbVersionValue(this.dbVersion).build();
openBuilder.addAugmentation(Tlvs3.class, new Tlvs3Builder().setLspDbVersion(lspDbVersion).build());
}
package org.opendaylight.protocol.pcep.pcc.mock.protocol;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
}
synchronized boolean isInitialConnectFinished() {
- Preconditions.checkNotNull(this.pending);
+ requireNonNull(this.pending);
return this.pending.isDone() && this.pending.isSuccess();
}
*/
package org.opendaylight.protocol.pcep.pcc.mock.protocol;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.math.BigInteger;
import java.net.InetSocketAddress;
import javax.annotation.Nonnull;
@Override
public void setPeerSpecificProposal(@Nonnull final InetSocketAddress address, @Nonnull final TlvsBuilder openBuilder) {
- Preconditions.checkNotNull(address);
+ requireNonNull(address);
final LspDbVersionBuilder lspDbVersionBuilder = new LspDbVersionBuilder();
if (this.isAfterReconnection) {
lspDbVersionBuilder.setLspDbVersionValue(this.dbVersion);
*/
package org.opendaylight.protocol.pcep.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
private final ObjectRegistry registry;
protected AbstractMessageParser(final ObjectRegistry registry) {
- this.registry = Preconditions.checkNotNull(registry);
+ this.registry = requireNonNull(registry);
}
/**
@Override
public final Message parseMessage(final ByteBuf buffer, final List<Message> errors) throws PCEPDeserializerException {
- Preconditions.checkNotNull(buffer, "Buffer may not be null");
+ requireNonNull(buffer, "Buffer may not be null");
// Parse objects first
final List<Object> objs = parseObjects(buffer);
*/
package org.opendaylight.protocol.pcep.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
private final VendorInformationTlvRegistry viTlvReg;
protected AbstractObjectWithTlvsParser(final TlvRegistry tlvReg, final VendorInformationTlvRegistry viTlvReg) {
- this.tlvReg = Preconditions.checkNotNull(tlvReg);
- this.viTlvReg = Preconditions.checkNotNull(viTlvReg);
+ this.tlvReg = requireNonNull(tlvReg);
+ this.viTlvReg = requireNonNull(viTlvReg);
}
protected final void parseTlvs(final T builder, final ByteBuf bytes) throws PCEPDeserializerException {
}
protected final void serializeTlv(final Tlv tlv, final ByteBuf buffer) {
- Preconditions.checkNotNull(tlv, "PCEP TLV is mandatory.");
+ requireNonNull(tlv, "PCEP TLV is mandatory.");
LOG.trace("Serializing PCEP TLV {}", tlv);
this.tlvReg.serializeTlv(tlv, buffer);
LOG.trace("Serialized PCEP TLV : {}.", ByteBufUtil.hexDump(buffer));
*/
package org.opendaylight.protocol.pcep.spi;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collections;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
}
public UnknownObject(final PCEPErrors error, final Object invalidObject) {
- this.e = Preconditions.checkNotNull(error);
+ this.e = requireNonNull(error);
this.error = new ErrorsBuilder().setErrorObject(
new ErrorObjectBuilder().setType(error.getErrorType()).setValue(
*/
package org.opendaylight.protocol.pcep.spi.pojo;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.List;
import javax.annotation.concurrent.GuardedBy;
public final synchronized void start(final PCEPExtensionProviderContext context) {
Preconditions.checkState(this.registrations == null);
- this.registrations = Preconditions.checkNotNull(startImpl(context));
+ this.registrations = requireNonNull(startImpl(context));
}
@Override
*/
package org.opendaylight.protocol.pcep.spi.pojo;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.List;
import org.opendaylight.protocol.pcep.spi.PCEPExtensionProviderActivator;
import org.opendaylight.protocol.pcep.spi.PCEPExtensionProviderContext;
public SimplePCEPExtensionProviderContextActivator(final PCEPExtensionProviderContext providerContext,
final List<PCEPExtensionProviderActivator> extensionActivators) {
- this.providerContext = Preconditions.checkNotNull(providerContext);
- this.extensionActivators = Preconditions.checkNotNull(extensionActivators);
+ this.providerContext = requireNonNull(providerContext);
+ this.extensionActivators = requireNonNull(extensionActivators);
}
public void start() {
*/
package org.opendaylight.bgpcep.pcep.topology.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
private final WriteTransaction trans;
private MessageContext(final WriteTransaction trans) {
- this.trans = Preconditions.checkNotNull(trans);
+ this.trans = requireNonNull(trans);
}
void resolveRequest(final PCEPRequest req) {
private final SessionListenerState listenerState;
protected AbstractTopologySessionListener(final ServerSessionManager serverSessionManager) {
- this.serverSessionManager = Preconditions.checkNotNull(serverSessionManager);
+ this.serverSessionManager = requireNonNull(serverSessionManager);
this.listenerState = new SessionListenerState();
}
*/
@GuardedBy("this")
private synchronized void tearDown(final PCEPSession session) {
- Preconditions.checkNotNull(session);
+ requireNonNull(session);
this.serverSessionManager.releaseNodeState(this.nodeState, session, isLspDbPersisted());
this.nodeState = null;
try {
protected abstract boolean onMessage(MessageContext ctx, Message message);
protected final String lookupLspName(final L id) {
- Preconditions.checkNotNull(id, "ID parameter null.");
+ requireNonNull(id, "ID parameter null.");
return this.lsps.get(id);
}
package org.opendaylight.bgpcep.pcep.topology.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
private final InstanceIdentifier<Topology> topologyId;
private PCEPStatefulPeerProposal(final DataBroker dataBroker, final InstanceIdentifier<Topology> topologyId) {
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.topologyId = Preconditions.checkNotNull(topologyId);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.topologyId = requireNonNull(topologyId);
}
public static PCEPStatefulPeerProposal createStatefulPeerProposal(final DataBroker dataBroker,
package org.opendaylight.bgpcep.pcep.topology.provider;
import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ListenableFuture;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
final InstanceIdentifier<Topology> topology, final ServerSessionManager manager,
final InstructionScheduler scheduler) {
super(topology);
- this.dependenciesProvider = Preconditions.checkNotNull(dependenciesProvider);
+ this.dependenciesProvider = requireNonNull(dependenciesProvider);
this.address = address;
- this.topology = Preconditions.checkNotNull(topology);
+ this.topology = requireNonNull(topology);
this.keys = keys;
- this.manager = Preconditions.checkNotNull(manager);
+ this.manager = requireNonNull(manager);
this.scheduler = scheduler;
}
public void instantiateServiceInstance() {
final RpcProviderRegistry rpcRegistry = this.dependenciesProvider.getRpcProviderRegistry();
- this.element = Preconditions.checkNotNull(rpcRegistry
+ this.element = requireNonNull(rpcRegistry
.addRoutedRpcImplementation(NetworkTopologyPcepService.class, new TopologyRPCs(this.manager)));
this.element.registerPath(NetworkTopologyContext.class, this.topology);
- this.network = Preconditions.checkNotNull(rpcRegistry
+ this.network = requireNonNull(rpcRegistry
.addRoutedRpcImplementation(NetworkTopologyPcepProgrammingService.class,
new TopologyProgramming(this.scheduler, this.manager)));
this.network.registerPath(NetworkTopologyContext.class, this.topology);
package org.opendaylight.bgpcep.pcep.topology.provider;
import com.google.common.annotations.VisibleForTesting;
-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 ServerSessionManager(final DataBroker broker, final InstanceIdentifier<Topology> topology,
final TopologySessionListenerFactory listenerFactory, final short rpcTimeout) {
- this.broker = Preconditions.checkNotNull(broker);
- this.topology = Preconditions.checkNotNull(topology);
- this.listenerFactory = Preconditions.checkNotNull(listenerFactory);
+ this.broker = requireNonNull(broker);
+ this.topology = requireNonNull(topology);
+ this.listenerFactory = requireNonNull(listenerFactory);
this.peerProposal = PCEPStatefulPeerProposal.createStatefulPeerProposal(this.broker, this.topology);
this.rpcTimeout = rpcTimeout;
}
@Override
public void setPeerSpecificProposal(final InetSocketAddress address, final TlvsBuilder openBuilder) {
- Preconditions.checkNotNull(address);
+ requireNonNull(address);
this.peerProposal.setPeerProposal(createNodeId(address.getAddress()), openBuilder);
}
package org.opendaylight.bgpcep.pcep.topology.provider;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Stopwatch;
import java.util.concurrent.TimeUnit;
import org.opendaylight.controller.config.yang.pcep.topology.provider.ErrorMessages;
}
public void init(final PCEPSession session) {
- Preconditions.checkNotNull(session);
+ requireNonNull(session);
this.localPref = getLocalPref(session.getLocalPref());
this.peerPref = getPeerPref(session.getPeerPref());
this.sessionUpDuration.start();
}
public void resetStats(final PCEPSession session) {
- Preconditions.checkNotNull(session);
+ requireNonNull(session);
this.receivedRptMsgCount = 0;
this.sentInitMsgCount = 0;
this.sentUpdMsgCount = 0;
}
public SessionState getSessionState(final PCEPSession session) {
- Preconditions.checkNotNull(session);
+ requireNonNull(session);
final SessionState state = new SessionState();
state.setLocalPref(this.localPref);
state.setPeerPref(this.peerPref);
}
public void setPeerCapabilities(final PeerCapabilities capabilities) {
- this.capa = Preconditions.checkNotNull(capabilities);
+ this.capa = requireNonNull(capabilities);
}
public void updateLastReceivedRptMsg() {
*/
package org.opendaylight.bgpcep.pcep.topology.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
private ListenableFuture<OperationResult> redelegate(final Lsp reportedLsp, final Srp srp, final Lsp lsp, final UpdateLspArgs input) {
// the D bit that was reported decides the type of PCE message sent
- Preconditions.checkNotNull(reportedLsp.isDelegate());
+ requireNonNull(reportedLsp.isDelegate());
final Message msg;
if (reportedLsp.isDelegate()) {
// we already have delegation, send update
package org.opendaylight.bgpcep.pcep.topology.provider;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.protocol.pcep.PCEPSession;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev150714.Stateful1;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.sync.optimizations.rev150714.Tlvs3;
private final boolean isTriggeredReSyncEnable;
public SyncOptimization(final PCEPSession session) {
- Preconditions.checkNotNull(session);
+ requireNonNull(session);
final Tlvs remote = session.getRemoteTlvs();
final Tlvs local = session.localSessionCharacteristics();
final LspDbVersion localLspDbVersion = getLspDbVersion(local);
*/
package org.opendaylight.bgpcep.pcep.topology.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
private final ServerSessionManager manager;
TopologyProgramming(final InstructionScheduler scheduler, final ServerSessionManager manager) {
- this.scheduler = Preconditions.checkNotNull(scheduler);
- this.manager = Preconditions.checkNotNull(manager);
+ this.scheduler = requireNonNull(scheduler);
+ this.manager = requireNonNull(manager);
}
@Override
*/
package org.opendaylight.bgpcep.pcep.topology.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
private final ServerSessionManager manager;
TopologyRPCs(final ServerSessionManager manager) {
- this.manager = Preconditions.checkNotNull(manager);
+ this.manager = requireNonNull(manager);
}
@Override
*/
package org.opendaylight.bgpcep.pcep.topology.provider.config;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.net.InetSocketAddress;
private final BlueprintContainer container;
public PCEPTopologyDeployerImpl(final BlueprintContainer container) {
- this.container = Preconditions.checkNotNull(container);
+ this.container = requireNonNull(container);
}
@Override
*/
package org.opendaylight.bgpcep.pcep.topology.provider.config;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
public PCEPTopologyProviderBean(final ClusterSingletonServiceProvider cssp, final BundleContext bundleContext,
final DataBroker dataBroker, final PCEPDispatcher pcepDispatcher, final RpcProviderRegistry rpcProviderRegistry,
final TopologySessionListenerFactory sessionListenerFactory) {
- this.cssp = Preconditions.checkNotNull(cssp);
- this.bundleContext = Preconditions.checkNotNull(bundleContext);
- this.pcepDispatcher = Preconditions.checkNotNull(pcepDispatcher);
- this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.sessionListenerFactory = Preconditions.checkNotNull(sessionListenerFactory);
- this.rpcProviderRegistry = Preconditions.checkNotNull(rpcProviderRegistry);
+ this.cssp = requireNonNull(cssp);
+ this.bundleContext = requireNonNull(bundleContext);
+ this.pcepDispatcher = requireNonNull(pcepDispatcher);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.sessionListenerFactory = requireNonNull(sessionListenerFactory);
+ this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
final List<PCEPCapability> capabilities = this.pcepDispatcher.getPCEPSessionNegotiatorFactory()
.getPCEPSessionProposalFactory().getCapabilities();
final boolean statefulCapability = capabilities.stream().anyMatch(PCEPCapability::isStateful);
*/
package org.opendaylight.bgpcep.pcep.topology.spi;
-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;
private final SubmitInstructionInput input;
protected AbstractInstructionExecutor(final SubmitInstructionInput input) {
- this.input = Preconditions.checkNotNull(input);
+ this.input = requireNonNull(input);
}
public final SubmitInstructionInput getInput() {
package org.opendaylight.bgpcep.pcep.tunnel.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.Futures;
private final InstanceIdentifier<TerminationPoint> tii;
TpReader(final ReadTransaction t, final InstanceIdentifier<Topology> topo, final TpReference ref) {
- this.t = Preconditions.checkNotNull(t);
+ this.t = requireNonNull(t);
this.nii = topo.child(Node.class, new NodeKey(ref.getNode()));
this.tii = this.nii.child(TerminationPoint.class, new TerminationPointKey(ref.getTp()));
private AddLspInput createAddLspInput(final ReadOnlyTransaction transaction) {
final InstanceIdentifier<Topology> tii = TopologyProgrammingUtil.topologyForInput(this.p2pTunnelInput);
final TpReader dr = new TpReader(transaction, tii, this.p2pTunnelInput.getDestination());
- final TerminationPoint dp = Preconditions.checkNotNull(dr.getTp());
+ final TerminationPoint dp = requireNonNull(dr.getTp());
final TpReader sr = new TpReader(transaction, tii, this.p2pTunnelInput.getSource());
- final TerminationPoint sp = Preconditions.checkNotNull(sr.getTp());
+ final TerminationPoint sp = requireNonNull(sr.getTp());
- final Node sn = Preconditions.checkNotNull(sr.getNode());
+ final Node sn = requireNonNull(sr.getNode());
final AddLspInputBuilder ab = new AddLspInputBuilder();
- ab.setNode(Preconditions.checkNotNull(TunelProgrammingUtil.supportingNode(sn)));
+ ab.setNode(requireNonNull(TunelProgrammingUtil.supportingNode(sn)));
ab.setName(this.p2pTunnelInput.getSymbolicPathName());
checkLinkIsnotExistent(tii, ab, transaction);
private static AddressFamily buildAddressFamily(final TerminationPoint sp, final TerminationPoint dp) {
// We need the IGP augmentation -- it has IP addresses
- final TerminationPoint1 sp1 = Preconditions.checkNotNull(sp.getAugmentation(TerminationPoint1.class));
- final TerminationPoint1 dp1 = Preconditions.checkNotNull(dp.getAugmentation(TerminationPoint1.class));
+ final TerminationPoint1 sp1 = requireNonNull(sp.getAugmentation(TerminationPoint1.class));
+ final TerminationPoint1 dp1 = requireNonNull(dp.getAugmentation(TerminationPoint1.class));
// Get the types
final TerminationPointType spt = sp1.getIgpTerminationPointAttributes().getTerminationPointType();
*/
package org.opendaylight.bgpcep.pcep.tunnel.provider;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
private final TopologyId source;
NodeChangedListener(final DataBroker dataProvider, final TopologyId source, final InstanceIdentifier<Topology> target) {
- this.dataProvider = Preconditions.checkNotNull(dataProvider);
- this.target = Preconditions.checkNotNull(target);
- this.source = Preconditions.checkNotNull(source);
+ this.dataProvider = requireNonNull(dataProvider);
+ this.target = requireNonNull(target);
+ this.source = requireNonNull(source);
}
private static void categorizeIdentifier(final InstanceIdentifier<?> i, final Set<InstanceIdentifier<ReportedLsp>> changedLsps,
*/
package org.opendaylight.bgpcep.pcep.tunnel.provider;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.bgpcep.topology.DefaultTopologyReference;
import org.opendaylight.bgpcep.topology.TopologyReference;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
private PCEPTunnelTopologyProvider(final InstanceIdentifier<Topology> dst, final ListenerRegistration<NodeChangedListener> reg) {
this.ref = new DefaultTopologyReference(dst);
- this.reg = Preconditions.checkNotNull(reg);
+ this.reg = requireNonNull(reg);
}
public static PCEPTunnelTopologyProvider create(final DataBroker dataProvider,
*/
package org.opendaylight.bgpcep.pcep.tunnel.provider;
-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 org.opendaylight.bgpcep.pcep.topology.spi.AbstractInstructionExecutor;
private final InstructionScheduler scheduler;
public TunnelProgramming(final InstructionScheduler scheduler, final DataBroker dataProvider, final NetworkTopologyPcepService topologyService) {
- this.scheduler = Preconditions.checkNotNull(scheduler);
- this.dataProvider = Preconditions.checkNotNull(dataProvider);
- this.topologyService = Preconditions.checkNotNull(topologyService);
+ this.scheduler = requireNonNull(scheduler);
+ this.dataProvider = requireNonNull(dataProvider);
+ this.topologyService = requireNonNull(topologyService);
}
@Override
package org.opendaylight.bgpcep.pcep.tunnel.provider;
-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 UpdateLspInput buildUpdateInput(final Link link, final Node node) {
final UpdateLspInputBuilder ab = new UpdateLspInputBuilder();
ab.setName(link.getAugmentation(Link1.class).getSymbolicPathName());
- ab.setNode(Preconditions.checkNotNull(TunelProgrammingUtil.supportingNode(node)));
+ ab.setNode(requireNonNull(TunelProgrammingUtil.supportingNode(node)));
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.update.lsp.args.ArgumentsBuilder args =
new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.update.lsp.args.ArgumentsBuilder();
*/
package org.opendaylight.bgpcep.programming.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
public InstructionDeployerImpl(final DataBroker dataProvider, final RpcProviderRegistry rpcProviderRegistry,
final NotificationPublishService notifs, final Timer timer, final ClusterSingletonServiceProvider cssp,
final BundleContext bundleContext) {
- this.dataProvider = Preconditions.checkNotNull(dataProvider);
- this.notifs = Preconditions.checkNotNull(notifs);
- this.timer = Preconditions.checkNotNull(timer);
- this.rpcProviderRegistry = Preconditions.checkNotNull(rpcProviderRegistry);
- this.bundleContext = Preconditions.checkNotNull(bundleContext);
- this.cssp = Preconditions.checkNotNull(cssp);
+ this.dataProvider = requireNonNull(dataProvider);
+ this.notifs = requireNonNull(notifs);
+ this.timer = requireNonNull(timer);
+ this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
+ this.bundleContext = requireNonNull(bundleContext);
+ this.cssp = requireNonNull(cssp);
this.iid = InstanceIdentifier.create(OdlProgramming.class);
final WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
*/
package org.opendaylight.bgpcep.programming.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.ListenableFuture;
InstructionImpl(final QueueInstruction queue, final SettableFuture<Instruction> future, final InstructionId id,
final List<InstructionImpl> dependencies, final Timeout timeout) {
- this.schedulingFuture = Preconditions.checkNotNull(future);
- this.dependencies = Preconditions.checkNotNull(dependencies);
- this.timeout = Preconditions.checkNotNull(timeout);
- this.queue = Preconditions.checkNotNull(queue);
- this.id = Preconditions.checkNotNull(id);
+ this.schedulingFuture = requireNonNull(future);
+ this.dependencies = requireNonNull(dependencies);
+ this.timeout = requireNonNull(timeout);
+ this.queue = requireNonNull(queue);
+ this.id = requireNonNull(id);
}
InstructionId getId() {
*/
package org.opendaylight.bgpcep.programming.impl;
-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 ListeningExecutorService executor, final RpcProviderRegistry rpcProviderRegistry,
final ClusterSingletonServiceProvider cssp, final Timer timer, final String instructionId,
final WriteConfiguration writeConfiguration) {
- this.dataProvider = Preconditions.checkNotNull(dataProvider);
- this.instructionId = Preconditions.checkNotNull(instructionId);
- this.notifs = Preconditions.checkNotNull(notifs);
- this.executor = Preconditions.checkNotNull(executor);
- this.rpcProviderRegistry = Preconditions.checkNotNull(rpcProviderRegistry);
- this.timer = Preconditions.checkNotNull(timer);
+ this.dataProvider = requireNonNull(dataProvider);
+ this.instructionId = requireNonNull(instructionId);
+ this.notifs = requireNonNull(notifs);
+ this.executor = requireNonNull(executor);
+ this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
+ this.timer = requireNonNull(timer);
this.qid = KeyedInstanceIdentifier.builder(InstructionsQueue.class,
new InstructionsQueueKey(this.instructionId)).build();
this.writeConfiguration = writeConfiguration;
*/
package org.opendaylight.bgpcep.programming.topology;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.programming.rev131102.TopologyInstructionInput;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@SuppressWarnings("unchecked")
public static InstanceIdentifier<Topology> topologyForInput(final TopologyInstructionInput input) {
- Preconditions.checkNotNull(input.getNetworkTopologyRef());
+ requireNonNull(input.getNetworkTopologyRef());
return (InstanceIdentifier<Topology>) input.getNetworkTopologyRef().getValue();
}
}
*/
package org.opendaylight.bgpcep.programming.tunnel;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.programming.rev130930.BaseTunnelInput;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
}
public static InstanceIdentifier<Link> linkIdentifier(final InstanceIdentifier<Topology> topology, final BaseTunnelInput input) {
- Preconditions.checkNotNull(input.getLinkId());
+ requireNonNull(input.getLinkId());
return topology.child(Link.class, new LinkKey(input.getLinkId()));
}
}
*/
package org.opendaylight.protocol.rsvp.parser.impl.subobject.ero;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final LabelRegistry registry;
public EROLabelSubobjectParser(final LabelRegistry labelReg) {
- this.registry = Preconditions.checkNotNull(labelReg);
+ this.registry = requireNonNull(labelReg);
}
@Override
package org.opendaylight.protocol.rsvp.parser.impl.subobject.rro;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
private final LabelRegistry registry;
public RROLabelSubobjectParser(final LabelRegistry labelReg) {
- this.registry = Preconditions.checkNotNull(labelReg);
+ this.registry = requireNonNull(labelReg);
}
@Override
@Override
public void serializeSubobject(final SubobjectContainer subobject, final ByteBuf buffer) {
- Preconditions.checkNotNull(subobject.getSubobjectType(), "Subobject type cannot be empty.");
+ requireNonNull(subobject.getSubobjectType(), "Subobject type cannot be empty.");
final Label label = ((LabelCase) subobject.getSubobjectType()).getLabel();
final ByteBuf body = Unpooled.buffer();
this.registry.serializeLabel(label.isUniDirectional(), label.isGlobal(), label.getLabelType(), body);
package org.opendaylight.protocol.rsvp.parser.spi;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import java.util.List;
import javax.annotation.concurrent.GuardedBy;
public final synchronized void start(final RSVPExtensionProviderContext context) {
Preconditions.checkState(this.registrations == null);
- this.registrations = Preconditions.checkNotNull(startImpl(context));
+ this.registrations = requireNonNull(startImpl(context));
}
@Override
*/
package org.opendaylight.protocol.rsvp.parser.spi.pojo;
-import com.google.common.base.Preconditions;
+import static java.util.Objects.requireNonNull;
+
import java.util.List;
import org.opendaylight.protocol.rsvp.parser.spi.RSVPExtensionProviderActivator;
import org.opendaylight.protocol.rsvp.parser.spi.RSVPExtensionProviderContext;
public SimpleRSVPExtensionProviderContextActivator(final RSVPExtensionProviderContext providerContext,
final List<RSVPExtensionProviderActivator> extensionActivators) {
- this.providerContext = Preconditions.checkNotNull(providerContext);
- this.extensionActivators = Preconditions.checkNotNull(extensionActivators);
+ this.providerContext = requireNonNull(providerContext);
+ this.extensionActivators = requireNonNull(extensionActivators);
}
public void start() {
package org.opendaylight.protocol.rsvp.parser.spi.subobjects;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
private final EROSubobjectRegistry subobjReg;
public EROSubobjectListParser(final EROSubobjectRegistry subobjReg) {
- this.subobjReg = Preconditions.checkNotNull(subobjReg);
+ this.subobjReg = requireNonNull(subobjReg);
}
public List<SubobjectContainer> parseList(final ByteBuf buffer) throws RSVPParsingException {
package org.opendaylight.protocol.rsvp.parser.spi.subobjects;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
private final RROSubobjectRegistry subobjReg;
public RROSubobjectListParser(final RROSubobjectRegistry subobjReg) {
- this.subobjReg = Preconditions.checkNotNull(subobjReg);
+ this.subobjReg = requireNonNull(subobjReg);
}
public List<SubobjectContainer> parseList(final ByteBuf buffer) throws RSVPParsingException {
package org.opendaylight.protocol.rsvp.parser.spi.subobjects;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
private final XROSubobjectRegistry subobjReg;
protected XROSubobjectListParser(final XROSubobjectRegistry subobjReg) {
- this.subobjReg = Preconditions.checkNotNull(subobjReg);
+ this.subobjReg = requireNonNull(subobjReg);
}
public List<SubobjectContainer> parseList(final ByteBuf byteBuf) throws RSVPParsingException {
*/
package org.opendaylight.protocol.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
}
private BitArray(final byte[] backingArray, final int size) {
- Preconditions.checkNotNull(backingArray, "Byte Array cannot be null");
+ requireNonNull(backingArray, "Byte Array cannot be null");
this.size = size;
this.backingArray = (backingArray == null) ? null : backingArray.clone();
this.offset = (calculateBytes(this.size) * Byte.SIZE) - this.size;
*/
public static BitArray valueOf(final ByteBuf buffer, final int size) {
Preconditions.checkArgument(size >= 1, "Minimum size is 1 bit.");
- Preconditions.checkNotNull(buffer, "Byte Array cannot be null");
+ requireNonNull(buffer, "Byte Array cannot be null");
final byte[] b = new byte[calculateBytes(size)];
buffer.readBytes(b, 0, b.length);
return new BitArray(b, size);
*/
package org.opendaylight.protocol.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.io.BaseEncoding;
}
public static List<byte[]> parseMessages(final InputStream is) throws IOException {
- Preconditions.checkNotNull(is);
+ requireNonNull(is);
try (InputStreamReader isr = new InputStreamReader(is, "UTF-8")) {
return parseMessages(CharStreams.toString(isr));
}
Code Review / bgpcep.git / commitdiff