*/
package org.opendaylight.protocol.framework;
-import java.io.Closeable;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import com.google.common.base.Preconditions;
-
import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GlobalEventExecutor;
import io.netty.util.concurrent.Promise;
+import java.io.Closeable;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Dispatcher class for creating servers and clients. The idea is to first create servers and clients and the run the
* start method that will handle sockets in different thread.
*/
+@Deprecated
public abstract class AbstractDispatcher<S extends ProtocolSession<?>, L extends SessionListener<?, ?, ?>> implements Closeable {
@Override
protected void initChannel(final CH ch) {
- initializer.initializeChannel(ch, new DefaultPromise<S>(executor));
+ initializer.initializeChannel(ch, new DefaultPromise<>(executor));
}
});
if (LocalServerChannel.class.equals(channelClass) == false) {
// makes no sense for LocalServer and produces warning
b.childOption(ChannelOption.SO_KEEPALIVE, true);
+ b.childOption(ChannelOption.TCP_NODELAY , true);
}
b.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
customizeBootstrap(b);
}
try {
b.channel(channelClass);
- } catch (IllegalStateException e) {
+ } catch (final IllegalStateException e) {
// FIXME: if this is ok, document why
LOG.trace("Not overriding channelFactory on bootstrap {}", b, e);
}
* Creates a client.
*
* @param address remote address
- * @param connectStrategy Reconnection strategy to be used when initial connection fails
+ * @param strategy Reconnection strategy to be used when initial connection fails
*
* @return Future representing the connection process. Its result represents the combined success of TCP connection
* as well as session negotiation.
* @param connectStrategyFactory Factory for creating reconnection strategy for every reconnect attempt
*
* @return Future representing the reconnection task. It will report completion based on reestablishStrategy, e.g.
- * success if it indicates no further attempts should be made and failure if it reports an error
+ * success is never reported, only failure when it runs out of reconnection attempts.
*/
protected Future<Void> createReconnectingClient(final InetSocketAddress address, final ReconnectStrategyFactory connectStrategyFactory,
final PipelineInitializer<S> initializer) {
}
/**
- * @deprecated Should only be used with {@link AbstractDispatcher#AbstractDispatcher()}
+ * @deprecated Should only be used with AbstractDispatcher#AbstractDispatcher()
*/
@Deprecated
@Override
public void close() {
- try {
- this.workerGroup.shutdownGracefully();
- } finally {
- this.bossGroup.shutdownGracefully();
- }
}
}