import org.opendaylight.protocol.bgp.rib.impl.spi.BGPPeerRegistry;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPSessionValidator;
import org.opendaylight.protocol.bgp.rib.impl.spi.ChannelPipelineInitializer;
+import org.opendaylight.protocol.bgp.rib.spi.BGPSession;
import org.opendaylight.protocol.bgp.rib.spi.BGPSessionNegotiatorFactory;
import org.opendaylight.protocol.framework.ReconnectStrategy;
import org.opendaylight.protocol.framework.ReconnectStrategyFactory;
this.keys = keys;
final Bootstrap b = new Bootstrap();
- final BGPReconnectPromise p = new BGPReconnectPromise(GlobalEventExecutor.INSTANCE, address,
+ final BGPReconnectPromise p = new BGPReconnectPromise<BGPSessionImpl>(GlobalEventExecutor.INSTANCE, address,
connectStrategyFactory, b, BGPChannel.createChannelPipelineInitializer(BGPDispatcherImpl.this.hf.getDecoders(), snf, BGPDispatcherImpl.this.hf.getEncoders()));
b.option(ChannelOption.SO_KEEPALIVE, Boolean.valueOf(true));
this.customizeBootstrap(b);
}
}
- public final static class BGPChannel {
+ private static final class BGPChannel {
private static final String NEGOTIATOR = "negotiator";
private BGPChannel() {
}
- public static <T extends BGPSessionNegotiatorFactory> ChannelPipelineInitializer createChannelPipelineInitializer(final ChannelHandler[] channelDecoder,
- final T snf,
- final ChannelHandler[] channelEncoder) {
- return new ChannelPipelineInitializer() {
+ public static <S extends BGPSession, T extends BGPSessionNegotiatorFactory> ChannelPipelineInitializer
+ createChannelPipelineInitializer(final ChannelHandler[] channelDecoder, final T snf, final ChannelHandler[] channelEncoder) {
+ return new ChannelPipelineInitializer<S>() {
@Override
- public void initializeChannel(final SocketChannel ch, final Promise<BGPSessionImpl> promise) {
+ public void initializeChannel(final SocketChannel ch, final Promise<S> promise) {
ch.pipeline().addLast(channelDecoder);
ch.pipeline().addLast(NEGOTIATOR, snf.getSessionNegotiator(ch, promise));
ch.pipeline().addLast(channelEncoder);
};
}
- public static ChannelHandler createChannelInitializer(final ChannelPipelineInitializer initializer, final Promise<BGPSessionImpl> promise) {
+ public static <S extends BGPSession> ChannelHandler createChannelInitializer(final ChannelPipelineInitializer initializer, final Promise<S> promise) {
return new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
};
}
}
-}
-
-
+}
\ No newline at end of file
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;
import io.netty.util.concurrent.DefaultPromise;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.concurrent.Promise;
import java.net.InetSocketAddress;
-import org.opendaylight.protocol.bgp.rib.impl.BGPDispatcherImpl;
-import org.opendaylight.protocol.bgp.rib.impl.BGPSessionImpl;
import org.opendaylight.protocol.bgp.rib.impl.spi.ChannelPipelineInitializer;
+import org.opendaylight.protocol.bgp.rib.spi.BGPSession;
import org.opendaylight.protocol.framework.ReconnectStrategy;
import org.opendaylight.protocol.framework.ReconnectStrategyFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class BGPReconnectPromise extends DefaultPromise<Void> {
+public class BGPReconnectPromise<S extends BGPSession> extends DefaultPromise<Void> {
private static final Logger LOG = LoggerFactory.getLogger(BGPReconnectPromise.class);
private final InetSocketAddress address;
private final Bootstrap b;
private final ChannelPipelineInitializer initializer;
private final EventExecutor executor;
- private Future<BGPSessionImpl> pending;
+ private Future<S> pending;
public BGPReconnectPromise(final EventExecutor executor, final InetSocketAddress address,
final ReconnectStrategyFactory connectStrategyFactory, final Bootstrap b,
final ReconnectStrategy cs = this.strategyFactory.createReconnectStrategy();
// Set up a client with pre-configured bootstrap, but add a closed channel handler into the pipeline to support reconnect attempts
- pending = createClient(this.address, cs, b, new ChannelPipelineInitializer() {
+ pending = createClient(this.address, cs, b, new ChannelPipelineInitializer<S>() {
@Override
- public void initializeChannel(final SocketChannel channel, final Promise<BGPSessionImpl> promise) {
+ public void initializeChannel(final SocketChannel channel, final Promise<S> promise) {
initializer.initializeChannel(channel, promise);
// add closed channel handler
// This handler has to be added as last channel handler and the channel inactive event has to be caught by it
});
}
- public Future<BGPSessionImpl> createClient(final InetSocketAddress address, final ReconnectStrategy strategy, final Bootstrap bootstrap,
- final ChannelPipelineInitializer initializer) {
+ public Future<S> createClient(final InetSocketAddress address, final ReconnectStrategy strategy, final Bootstrap bootstrap,
+ final ChannelPipelineInitializer initializer) {
final BGPProtocolSessionPromise p = new BGPProtocolSessionPromise(this.executor, address, strategy, bootstrap);
- final ChannelHandler chInit = BGPDispatcherImpl.BGPChannel.createChannelInitializer(initializer, p);
+ final ChannelHandler chInit = new ChannelInitializer<SocketChannel>() {
+ @Override
+ protected void initChannel(SocketChannel ch) {
+ initializer.initializeChannel(ch, p);
+ }
+ };
+
bootstrap.handler(chInit);
p.connect();
LOG.debug("Client created.");
promise.connect();
}
}
-}
+}
\ No newline at end of file