/** * * @deprecated use {@link org.opendaylight.protocol.framework.AbstractDispatcher#createReconnectingClient(java.net.InetSocketAddress, ReconnectStrategyFactory, org.opendaylight.protocol.framework.AbstractDispatcher.PipelineInitializer)} with only one reconnectStrategyFactory instead. * * Creates a client. * * @param address remote address * @param connectStrategyFactory Factory for creating reconnection strategy to be used when initial connection fails * @param reestablishStrategy Reconnection strategy to be used when the already-established session fails * * @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 */ @Deprecated protected Future<Void> createReconnectingClient(final InetSocketAddress address, final ReconnectStrategyFactory connectStrategyFactory, final ReconnectStrategy reestablishStrategy, final PipelineInitializer<S> initializer) { return createReconnectingClient(address, connectStrategyFactory, initializer); }
@Override public ChannelFuture createServer(InetSocketAddress address) { return super.createServer(address, new PipelineInitializer<NetconfServerSession>() { @Override public void initializeChannel(final SocketChannel ch, final Promise<NetconfServerSession> promise) { initializer.initialize(ch, promise); } }); }
/** * Creates a reconnecting client. * * @param address remote address * @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 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) { final Bootstrap b = new Bootstrap(); final ReconnectPromise<S, L> p = new ReconnectPromise<>(GlobalEventExecutor.INSTANCE, this, address, connectStrategyFactory, b, initializer); b.option(ChannelOption.SO_KEEPALIVE, true); customizeBootstrap(b); setWorkerGroup(b); setChannelFactory(b); p.connect(); return p; }
private Future<NetconfClientSession> createTcpClient(final NetconfClientConfiguration currentConfiguration) { LOG.debug("Creating TCP client with configuration: {}", currentConfiguration); return super.createClient(currentConfiguration.getAddress(), currentConfiguration.getReconnectStrategy(), new PipelineInitializer<NetconfClientSession>() { @Override public void initializeChannel(final SocketChannel ch, final Promise<NetconfClientSession> promise) { initialize(ch, promise); } private void initialize(final SocketChannel ch, final Promise<NetconfClientSession> promise) { new TcpClientChannelInitializer(getNegotiatorFactory(currentConfiguration), currentConfiguration .getSessionListener()).initialize(ch, promise); } }); }
/** * Creates a client. * * @param address remote address * @param connectStrategy 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. */ protected Future<S> createClient(final InetSocketAddress address, final ReconnectStrategy strategy, final PipelineInitializer<S> initializer) { final Bootstrap b = new Bootstrap(); final ProtocolSessionPromise<S> p = new ProtocolSessionPromise<>(executor, address, strategy, b); b.option(ChannelOption.SO_KEEPALIVE, true).handler( new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(final SocketChannel ch) { initializer.initializeChannel(ch, p); } }); customizeBootstrap(b); setWorkerGroup(b); setChannelFactory(b); p.connect(); LOG.debug("Client created."); return p; }
private Future<NetconfClientSession> createSshClient(final NetconfClientConfiguration currentConfiguration) { LOG.debug("Creating SSH client with configuration: {}", currentConfiguration); return super.createClient(currentConfiguration.getAddress(), currentConfiguration.getReconnectStrategy(), new PipelineInitializer<NetconfClientSession>() { @Override public void initializeChannel(final SocketChannel ch, final Promise<NetconfClientSession> sessionPromise) { new SshClientChannelInitializer(currentConfiguration.getAuthHandler(), getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener()) .initialize(ch, sessionPromise); } }); }
private Future<Void> createReconnectingTcpClient(final NetconfReconnectingClientConfiguration currentConfiguration) { LOG.debug("Creating reconnecting TCP client with configuration: {}", currentConfiguration); final TcpClientChannelInitializer init = new TcpClientChannelInitializer(getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener()); return super.createReconnectingClient(currentConfiguration.getAddress(), currentConfiguration.getConnectStrategyFactory(), currentConfiguration.getReconnectStrategy(), new PipelineInitializer<NetconfClientSession>() { @Override public void initializeChannel(final SocketChannel ch, final Promise<NetconfClientSession> promise) { init.initialize(ch, promise); } }); }
@Override public ChannelFuture createLocalServer(LocalAddress address) { return super.createServer(address, LocalServerChannel.class, new ChannelPipelineInitializer<LocalChannel, NetconfServerSession>() { @Override public void initializeChannel(final LocalChannel ch, final Promise<NetconfServerSession> promise) { initializer.initialize(ch, promise); } }); }
synchronized void connect() { 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 = this.dispatcher.createClient(this.address, cs, b, new AbstractDispatcher.PipelineInitializer<S>() { @Override 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 // Handlers in front of it can react to channelInactive event, but have to forward the event or the reconnect will not work // This handler is last so all handlers in front of it can handle channel inactive (to e.g. resource cleanup) before a new connection is started channel.pipeline().addLast(new ClosedChannelHandler(ReconnectPromise.this)); } }); pending.addListener(new GenericFutureListener<Future<Object>>() { @Override public void operationComplete(Future<Object> future) throws Exception { if (!future.isSuccess()) { ReconnectPromise.this.setFailure(future.cause()); } } }); }
private Future<Void> createReconnectingSshClient(final NetconfReconnectingClientConfiguration currentConfiguration) { LOG.debug("Creating reconnecting SSH client with configuration: {}", currentConfiguration); final SshClientChannelInitializer init = new SshClientChannelInitializer(currentConfiguration.getAuthHandler(), getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener()); return super.createReconnectingClient(currentConfiguration.getAddress(), currentConfiguration.getConnectStrategyFactory(), currentConfiguration.getReconnectStrategy(), new PipelineInitializer<NetconfClientSession>() { @Override public void initializeChannel(final SocketChannel ch, final Promise<NetconfClientSession> promise) { init.initialize(ch, promise); } }); }
/** * Creates server. Each server needs factories to pass their instances to client sessions. * * @param address address to which the server should be bound * @param initializer instance of PipelineInitializer used to initialize the channel pipeline * * @return ChannelFuture representing the binding process */ protected ChannelFuture createServer(final InetSocketAddress address, final PipelineInitializer<S> initializer) { return createServer(address, NioServerSocketChannel.class, initializer); }