Java IoFuture.await方法代码示例

import org.xnio.IoFuture; //导入方法依赖的package包/类
private static Channel getChannel ( ConnectionProviderContextImpl context, ConnectionHandler ch, OptionMap options ) throws IOException {
    Channel c;
    FutureResult<Channel> chResult = new FutureResult<Channel>(context.getExecutor());
    ch.open("jmx", chResult, options);

    IoFuture<Channel> cFuture = chResult.getIoFuture();
    Status s2 = cFuture.await();
    if ( s2 == Status.FAILED ) {
        System.err.println("Cannot connect");
        if ( cFuture.getException() != null ) {
            throw new IOException("Connect failed", cFuture.getException());
        }
    }
    else if ( s2 != Status.DONE ) {
        cFuture.cancel();
        throw new IOException("Connect timeout");
    }

    c = cFuture.get();
    return c;
}
 

import org.xnio.IoFuture; //导入方法依赖的package包/类
/**
 * Blocking connection attempt to the given URI endpoint
 *
 * @param timeout time to wait in seconds before aborting connection attempt
 * @return true if connected; false otherwise
 * @throws IOException if something goes wrong with XNIO worker
 */
@Override
public boolean connectBlocking(long timeout) throws IOException {
    logger.debug("Connect blocking... ({})", this);
    IoFuture<WebSocketChannel> futureChan = connectionBuilder().connect();
    IoFuture.Status status = futureChan.await(timeout, TimeUnit.SECONDS);
    logger.debug("Connect blocking status: {}", status);
    switch (status) {
        case DONE:
            // ok
            this.channel = futureChan.get();
            this.channel.setIdleTimeout(this.idleTimeout);
            registerChannelReceivers();
            return true;

        default:
            // error or interrupted or timed-out
            return false;
    }
}
 

import org.xnio.IoFuture; //导入方法依赖的package包/类
@Override
public boolean connectBlocking(long timeout) throws IOException {
    logger.debug("Connect blocking... ({})", this);
    IoFuture<WebSocketChannel> futureChan = connectionBuilder().connect();
    IoFuture.Status status = futureChan.await(timeout, TimeUnit.MILLISECONDS);
    logger.debug("Connect blocking status: {}", status);
    switch (status) {
        case DONE:
            // ok
            this.channel = futureChan.get();
            registerChannelReceivers();
            return true;

        default:
            handlerService.submit(() -> onError(futureChan.getException()));
            try {
                Thread.sleep(reconnectDelay);
                return this.connectBlocking(timeout);
            } catch (InterruptedException e) {
                logger.warn("Connect blocking interrupted while sleeping", e);
            }
            // error or interrupted or timed-out
            return false;
    }
}
 

import org.xnio.IoFuture; //导入方法依赖的package包/类
@Override
public Status await(IoFuture<?> future, long timeoutMillis) {
    final long startTime = System.currentTimeMillis();

    IoFuture.Status status = future.await(timeoutMillis, TimeUnit.MILLISECONDS);
    while (status == IoFuture.Status.WAITING) {
        if (thinking) {
            status = future.await(timeoutMillis, TimeUnit.MILLISECONDS);
        } else {
            long timeToWait = (timeoutMillis + thinkTime.get()) - (System.currentTimeMillis() - startTime);
            if (timeToWait > 0) {
                status = future.await(timeToWait, TimeUnit.MILLISECONDS);
            } else {
                return status;
            }
        }
    }

    return status;
}
 

import org.xnio.IoFuture; //导入方法依赖的package包/类
Channel openChannel(final Connection connection) throws IOException {
    final IoFuture<Channel> future = connection.openChannel(DEFAULT_CHANNEL_SERVICE_TYPE, OptionMap.EMPTY);
    future.await(10L, TimeUnit.SECONDS);
    if (future.getStatus() == IoFuture.Status.WAITING) {
        future.cancel();
        throw ProtocolLogger.ROOT_LOGGER.channelTimedOut();
    }
    final Channel channel = future.get();
    channel.addCloseHandler(new CloseHandler<Channel>() {
        @Override
        public void handleClose(final Channel old, final IOException e) {
            synchronized (ChannelStrategy.this) {
                if(ChannelStrategy.this.channel == old) {
                    ChannelStrategy.this.handler.handleClose(old, e);
                    ChannelStrategy.this.channel = null;
                }
            }
            handler.handleChannelClosed(old, e);
        }
    });
    return channel;
}
 

import org.xnio.IoFuture; //导入方法依赖的package包/类
private boolean connectUsingRemoting(CommandContext cmdCtx, RemotingMBeanServerConnection rmtMBeanSvrConn)
        throws IOException, CliInitializationException {
    Connection conn = rmtMBeanSvrConn.getConnection();
    Channel channel;
    final IoFuture<Channel> futureChannel = conn.openChannel("management", OptionMap.EMPTY);
    IoFuture.Status result = futureChannel.await(5, TimeUnit.SECONDS);
    if (result == IoFuture.Status.DONE) {
        channel = futureChannel.get();
    } else {
        futureChannel.cancel();
        return false;
    }

    ModelControllerClient modelCtlrClient = ExistingChannelModelControllerClient.createReceiving(channel, createExecutor());
    cmdCtx.bindClient(modelCtlrClient);

    return true;
}
 

import org.xnio.IoFuture; //导入方法依赖的package包/类
private static ConnectionHandlerFactory getConnection ( SocketAddress destination, final String username, final String password,
        ConnectionProviderContextImpl context, ConnectionProvider instance, OptionMap options )
                throws IOException, InterruptedException, KeyManagementException, NoSuchProviderException, NoSuchAlgorithmException {
    XnioSsl xnioSsl = new JsseXnioSsl(context.getXnio(), options);
    FutureResult<ConnectionHandlerFactory> result = new FutureResult<ConnectionHandlerFactory>();
    instance.connect(null, destination, options, result, new CallbackHandler() {

        public void handle ( Callback[] callbacks ) throws IOException, UnsupportedCallbackException {

            for ( Callback cb : callbacks ) {

                if ( cb instanceof NameCallback ) {
                    ( (NameCallback) cb ).setName(username);
                }
                else if ( cb instanceof PasswordCallback ) {
                    ( (PasswordCallback) cb ).setPassword(password != null ? password.toCharArray() : new char[0]);
                }
                else if ( !( cb instanceof RealmCallback) ) {
                    System.err.println(cb);
                    throw new UnsupportedCallbackException(cb);
                }
            }
        }
    }, xnioSsl);

    System.err.println("waiting for connection");
    IoFuture<ConnectionHandlerFactory> ioFuture = result.getIoFuture();
    Status s = ioFuture.await(5, TimeUnit.SECONDS);
    if ( s == Status.FAILED ) {
        System.err.println("Cannot connect");
        if ( ioFuture.getException() != null ) {
            ioFuture.getException().printStackTrace(System.err);
        }
    }
    else if ( s != Status.DONE ) {
        ioFuture.cancel();
        System.err.println("Connect timeout");
        System.exit(-1);
    }

    ConnectionHandlerFactory chf = ioFuture.getInterruptibly();
    return chf;
}
 

import org.xnio.IoFuture; //导入方法依赖的package包/类
/**
 * Open a channel.
 *
 * @param connection the connection
 * @param serviceType the service type
 * @param options the channel options
 * @param deadline time, in ms since the epoch, by which the channel must be created,
 *                 or {@code null} if the caller is not imposing a specific deadline.
 *                 Ignored if less than 10s from the current time, with 10s used as the
 *                 default if this is {@code null}
 * @return the opened channel
 * @throws IOException if there is a remoting problem opening the channel or it cannot be opened in a reasonable amount of time
 */
final Channel openChannel(final Connection connection, final String serviceType, final OptionMap options, final Long deadline) throws IOException {
    final IoFuture<Channel> futureChannel = connection.openChannel(serviceType, options);
    long waitTime = deadline == null ? 10000 : Math.max(10000, deadline - System.currentTimeMillis());
    futureChannel.await(waitTime, TimeUnit.MILLISECONDS);
    if (futureChannel.getStatus() == IoFuture.Status.WAITING) {
        futureChannel.cancel();
        throw ProtocolLogger.ROOT_LOGGER.channelTimedOut();
    }
    return futureChannel.get();
}