Java IoFuture.get方法代码示例

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包/类
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包/类
/**
 * Connect sync.
 *
 * @param configuration the protocol configuration
 * @return the connection
 * @throws IOException
 */
public static Connection connectSync(final ProtocolConnectionConfiguration configuration) throws IOException {
    long timeoutMillis = configuration.getConnectionTimeout();
    CallbackHandler handler = configuration.getCallbackHandler();
    final CallbackHandler actualHandler;
    ProtocolTimeoutHandler timeoutHandler = configuration.getTimeoutHandler();
    // Note: If a client supplies a ProtocolTimeoutHandler it is taking on full responsibility for timeout management.
    if (timeoutHandler == null) {
        GeneralTimeoutHandler defaultTimeoutHandler = new GeneralTimeoutHandler();
        // No point wrapping our AnonymousCallbackHandler.
        actualHandler = handler != null ? new WrapperCallbackHandler(defaultTimeoutHandler, handler) : null;
        timeoutHandler = defaultTimeoutHandler;
    } else {
        actualHandler = handler;
    }

    final IoFuture<Connection> future = connect(actualHandler, configuration);

    IoFuture.Status status = timeoutHandler.await(future, timeoutMillis);

    if (status == IoFuture.Status.DONE) {
        return future.get();
    }
    if (status == IoFuture.Status.FAILED) {
        throw ProtocolLogger.ROOT_LOGGER.failedToConnect(configuration.getUri(), future.getException());
    }
    throw ProtocolLogger.ROOT_LOGGER.couldNotConnect(configuration.getUri());
}
 

import org.xnio.IoFuture; //导入方法依赖的package包/类
@Override
public boolean process(Exchange exchange, AsyncCallback callback) {
    ClientConnection connection = null;

    try {
        final UndertowClient client = UndertowClient.getInstance();

        IoFuture<ClientConnection> connect = client.connect(endpoint.getHttpURI(), worker, pool, options);

        // creating the url to use takes 2-steps
        String url = UndertowHelper.createURL(exchange, getEndpoint());
        URI uri = UndertowHelper.createURI(exchange, url, getEndpoint());
        // get the url from the uri
        url = uri.toASCIIString();

        // what http method to use
        HttpString method = UndertowHelper.createMethod(exchange, endpoint, exchange.getIn().getBody() != null);

        ClientRequest request = new ClientRequest();
        request.setProtocol(Protocols.HTTP_1_1);
        request.setPath(url);
        request.setMethod(method);

        Object body = getRequestBody(request, exchange);

        TypeConverter tc = endpoint.getCamelContext().getTypeConverter();
        ByteBuffer bodyAsByte = tc.tryConvertTo(ByteBuffer.class, body);

        if (body != null) {
            request.getRequestHeaders().put(Headers.CONTENT_LENGTH, bodyAsByte.array().length);
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Executing http {} method: {}", method, url);
        }
        connection = connect.get();
        connection.sendRequest(request, new UndertowProducerCallback(connection, bodyAsByte, exchange, callback));

    } catch (Exception e) {
        IOHelper.close(connection);
        exchange.setException(e);
        callback.done(true);
        return true;
    }

    // use async routing engine
    return false;
}
 

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();
}