private synchronized void startConnect ( final InetAddress address ) { logger.debug ( "Start connection to {}", address ); setState ( ConnectionState.CONNECTING, null ); this.connectFuture = this.connector.connect ( new InetSocketAddress ( address, this.connectionInformation.getSecondaryTarget () ) ); logger.trace ( "Returned from connect call" ); this.connectFuture.addListener ( new IoFutureListener<ConnectFuture> () { @Override public void operationComplete ( final ConnectFuture future ) { handleConnectComplete ( future ); } } ); logger.trace ( "Future listener registered" ); }
public void initializeSession(final IoSession session, ConnectFuture future) { LOGGER.debug("Initializing new session: {}", session); session.setAttribute(ProxyIoSession.PROXY_SESSION, proxyIoSession); proxyIoSession.setSession(session); LOGGER.debug(" setting up proxyIoSession: {}", proxyIoSession); future .addListener(new IoFutureListener<ConnectFuture>() { public void operationComplete( ConnectFuture future) { // Reconnection is done so we send the // request to the proxy proxyIoSession .setReconnectionNeeded(false); writeRequest0(nextFilter, request); } }); } });
cf.addListener(portSwitcher(connector, remoteAddress, init, handler)); cf.addListener(connectorDisposer(connector)); return cf;
@Override public void run() { serviceContext.connect(connectURI, handler.getListenHandler(), null).addListener(new IoFutureListener<ConnectFuture>() { @Override public void operationComplete(ConnectFuture future) { if (future.isConnected()) { IoSession newSession = future.getSession(); newSession.getCloseFuture().addListener(new IoFutureListener<CloseFuture>() { @Override public void operationComplete(CloseFuture future) { session.set(null); if (reconnect.get()) { scheduler.schedule(connectTask, reconnectDelay, TimeUnit.MILLISECONDS); } } }); session.set(newSession); } else { scheduler.schedule(connectTask, reconnectDelay, TimeUnit.MILLISECONDS); } } }); } }
@Override public void operationComplete(ConnectFuture future) { final Throwable cause = future.getException(); if (cause != null) { if (cause instanceof IOException) { if (retryAttempt == 0) { LOG.info("Service {} detected false: {}: {}",getServiceName(), cause.getClass().getName(), cause.getMessage()); detectFuture.setServiceDetected(false); } else { LOG.info("Connection exception occurred: {} for service {}, retrying attempt {}", cause, getServiceName(), retryAttempt); future = m_connectionFactory.reConnect(address, init, createDetectorHandler(detectFuture)); future.addListener(retryAttemptListener(detectFuture, address, init, retryAttempt - 1)); } } else { LOG.info("Threw a Throwable and detection is false for service {}", getServiceName(), cause); detectFuture.setServiceDetected(false); } } } };
@Override public void run() { ResourceAddress connectAddress = sseSession.getRemoteAddress(); ReconnectListener connectListener = new ReconnectListener(sseSession); BridgeConnector connector = bridgeServiceFactory.newBridgeConnector(connectAddress); connector.connect(connectAddress, httpHandler, null).addListener(connectListener); } }
/** {@inheritDoc} */ @Override protected void startConnector(String server, int port) { socketConnector = new NioSocketConnector(); socketConnector.setHandler(ioHandler); future = socketConnector.connect(new InetSocketAddress(server, port)); future.addListener(new IoFutureListener<ConnectFuture>() { @Override public void operationComplete(ConnectFuture future) { try { // will throw RuntimeException after connection error session = future.getSession(); } catch (Throwable e) { socketConnector.dispose(false); // if there isn't an ClientExceptionHandler set, a RuntimeException may be thrown in handleException handleException(e); } } }); // Now wait for the connect to be completed future.awaitUninterruptibly(CONNECTOR_WORKER_TIMEOUT); }
@Override public void sentAsync(final Request request, final InvokeCallback callback) throws Exception { final ConnectFuture connect = super.getConnect(request); if (connect != null && connect.isConnected()) { RpcFuture rpcFuture = new RpcFuture(request,callback); connect.addListener(new AbstractClient.FutureListener(rpcFuture)); connect.getSession().write(request); } else { throw new IllegalArgumentException("[JobX] MinaRPC invokeAsync channel not active. request id:" + request.getId()); } }
@SuppressWarnings({ "rawtypes" }) @Override protected void startConnector(String server, int port) { socketConnector = new NioSocketConnector(); socketConnector.setHandler(ioHandler); future = socketConnector.connect(new InetSocketAddress(server, port)); future.addListener(new IoFutureListener() { @Override public void operationComplete(IoFuture future) { try { // will throw RuntimeException after connection error future.getSession(); } catch (Throwable e) { //if there isn't an ClientExceptionHandler set, a //RuntimeException may be thrown in handleException handleException(e); } } }); // Do the close requesting that the pending messages are sent before // the session is closed //future.getSession().close(false); // Now wait for the close to be completed future.awaitUninterruptibly(CONNECTOR_WORKER_TIMEOUT); // We can now dispose the connector //socketConnector.dispose(); }
@Override public void sentOneWay(final Request request) throws Exception { ConnectFuture connect = super.getConnect(request); if (connect != null && connect.isConnected()) { RpcFuture rpcFuture = new RpcFuture(request); connect.addListener(new AbstractClient.FutureListener(rpcFuture)); connect.getSession().write(request); } else { throw new IllegalArgumentException("[JobX] MinaRPC channel not active. request id:" + request.getId()); } }
private <T extends ConnectFuture> ConnectFuture getTransportConnectFuture(ResourceAddress address, IoHandler handler, IoSessionInitializer initializer, ResourceAddress transport) { final DefaultConnectFuture bridgeConnectFuture = new DefaultConnectFuture(); IoSessionInitializer<ConnectFuture> parentInitializer = new NioConnectorParentSessionInitializer(handler, initializer, address, bridgeConnectFuture, addressFactory, processor, connectorReference); // propagate connection failure, if necessary bridgeConnector = bridgeServiceFactory.newBridgeConnector(transport); bridgeConnector.connect(transport, tcpBridgeHandler, parentInitializer) .addListener( new IoFutureListener<ConnectFuture>() { @Override public void operationComplete(ConnectFuture future) { // fail bridge connect future if parent connect fails if (!future.isConnected()) { bridgeConnectFuture.setException(future.getException()); } } } ); return bridgeConnectFuture; }
@Override public Response sentSync(final Request request) throws Exception { final ConnectFuture connect = super.getConnect(request); if (connect != null && connect.isConnected()) { RpcFuture rpcFuture = new RpcFuture(request); //写数据 connect.addListener(new AbstractClient.FutureListener(rpcFuture)); IoSession session = connect.getSession(); session.write(request); return rpcFuture.get(); } else { throw new IllegalArgumentException("[JobX] MinaRPC channel not active. request id:" + request.getId()); } }
@Override protected <T extends ConnectFuture> ConnectFuture connectInternal(ResourceAddress connectAddress, IoHandler handler, final IoSessionInitializer<T> initializer) { final DefaultConnectFuture sseConnectFuture = new DefaultConnectFuture(); // propagate connection failure, if necessary IoFutureListener<ConnectFuture> parentConnectListener = new IoFutureListener<ConnectFuture>() { @Override public void operationComplete(ConnectFuture future) { // fail bridge connect future if parent connect fails if (!future.isConnected()) { sseConnectFuture.setException(future.getException()); } } }; IoSessionInitializer<ConnectFuture> parentInitializer = createParentInitializer(connectAddress, handler, initializer, sseConnectFuture); final ResourceAddress transportAddress = connectAddress.getTransport(); if (transportAddress == null) { throw new RuntimeException("Cannot find transport for resource address "+connectAddress); } BridgeConnector connector = bridgeServiceFactory.newBridgeConnector(transportAddress); connector.connect(transportAddress, selectConnectHandler(transportAddress), parentInitializer).addListener(parentConnectListener); return sseConnectFuture; }
}).addListener(new ReconnectListener(sseSession));
private void reconnectOrClose(final SseSession sseSession) { SseSessionConfig config = sseSession.getConfig(); int retry = config.getRetry(); if (retry > 0 || config.isReconnecting()) { logger.debug("Reconnecting: {}", sseSession.getRemoteAddress()); config.setReconnecting(false); if (retry <= 0) { // reconnect immediately ResourceAddress connectAddress = sseSession.getRemoteAddress(); ReconnectListener connectListener = new ReconnectListener(sseSession); final ResourceAddress transportAddress = connectAddress.getTransport(); BridgeConnector connector = bridgeServiceFactory.newBridgeConnector(transportAddress); connector.connect(connectAddress, httpHandler, null).addListener(connectListener); } else { // reconnect after "retry" milliseconds scheduler.schedule(new ReconnectCommand(sseSession), retry, TimeUnit.MILLISECONDS); } } else { sseSession.reset(new IOException(LoggingUtils.EARLY_TERMINATION_OF_IOSESSION_MESSAGE).fillInStackTrace()); } }
private void initWriter(final WsebSession session) { final ResourceAddress writeAddress = session.getWriteAddress(); if (writeAddress == null) { // create sessionClosed not yet completed return; } if (session.compareAndSetAttachingWrite(false, true)) { BridgeConnector connector = bridgeServiceFactory.newBridgeConnector(writeAddress); ConnectFuture connectFuture = connector.connect(writeAddress, new WriteHandler(session), selectTransportSessionInitializer(session, writeAddress) ); final IoFutureListener<ConnectFuture> connectFutureIoFutureListener = selectConnectFutureListener(session, writeAddress); connectFuture.addListener(connectFutureIoFutureListener); } }
private <T extends ConnectFuture> void connectUsingNewTransport(final ConnectFuture connectFuture, ResourceAddress address, HttpConnectSessionFactory httpSessionFactory) { // propagate connection failure, if necessary IoFutureListener<ConnectFuture> parentConnectListener = future -> { // fail bridge connect future if parent connect fails if (!future.isConnected()) { connectFuture.setException(future.getException()); } }; ResourceAddress transportAddress = address.getTransport(); BridgeConnector connector = bridgeServiceFactory.newBridgeConnector(transportAddress); IoSessionInitializer<ConnectFuture> parentInitializer = createParentInitializer(address, connectFuture, httpSessionFactory); connector.connect(transportAddress, bridgeHandler, parentInitializer).addListener(parentConnectListener); }
future.addListener(new ConnectListener(acceptSession)); super.sessionOpened(acceptSession);
@Override protected <T extends ConnectFuture> ConnectFuture connectInternal( ResourceAddress connectAddress, IoHandler handler, final IoSessionInitializer<T> initializer) { final DefaultConnectFuture bridgeConnectFuture = new DefaultConnectFuture(); // propagate connection failure, if necessary IoFutureListener<ConnectFuture> parentConnectListener = new IoFutureListener<ConnectFuture>() { @Override public void operationComplete(ConnectFuture future) { // fail bridge connect future if parent connect fails if (!future.isConnected()) { bridgeConnectFuture.setException(future.getException()); } } }; IoSessionInitializer<ConnectFuture> parentInitializer = createParentInitializer( connectAddress, handler, initializer, bridgeConnectFuture); URI connectURI = connectAddress.getResource(); ResourceAddress createAddress = connectAddress.resolve(connectURI.getPath()+CREATE_SUFFIX); final ResourceAddress transportAddress = createAddress.getTransport(); BridgeConnector connector = bridgeServiceFactory.newBridgeConnector(transportAddress); connector.connect(transportAddress, selectConnectHandler(transportAddress), parentInitializer) .addListener(parentConnectListener); return bridgeConnectFuture; }
protected <T extends ConnectFuture> ConnectFuture wsnConnectInternal(ResourceAddress connectAddress, IoHandler handler, final IoSessionInitializer<T> initializer // TODO: connect options context?? ) { final DefaultConnectFuture wsnConnectFuture = new DefaultConnectFuture(); // propagate connection failure, if necessary IoFutureListener<ConnectFuture> parentConnectListener = new IoFutureListener<ConnectFuture>() { @Override public void operationComplete(ConnectFuture future) { // fail bridge connect future if parent connect fails if ( !future.isConnected() ) { wsnConnectFuture.setException(future.getException()); } } }; IoSessionInitializer<ConnectFuture> parentInitializer = createParentInitializer(connectAddress, handler, initializer, wsnConnectFuture); final ResourceAddress createAddress = connectAddress.getTransport(); BridgeConnector connector = bridgeServiceFactory.newBridgeConnector(createAddress); connector.connect(createAddress, selectConnectHandler(createAddress), parentInitializer).addListener(parentConnectListener); return wsnConnectFuture; }