Examples with ListenableFuture org.elasticsearch.common.util.concurrent.ListenableFuture used on opensource projects

Example 1 with ListenableFuture

use of org.elasticsearch.common.util.concurrent.ListenableFuture in project crate by crate.

the class ConnectionManager method connectToNode.

/**
 * Connects to a node with the given connection profile. If the node is already connected this method has no effect.
 * Once a successful is established, it can be validated before being exposed.
 * The ActionListener will be called on the calling thread or the generic thread pool.
 */
public void connectToNode(DiscoveryNode node, ConnectionProfile connectionProfile, ConnectionValidator connectionValidator, ActionListener<Void> listener) throws ConnectTransportException {
    if (node == null) {
        listener.onFailure(new ConnectTransportException(null, "can't connect to a null node"));
        return;
    }
    if (connectingRefCounter.tryIncRef() == false) {
        listener.onFailure(new IllegalStateException("connection manager is closed"));
        return;
    }
    if (connectedNodes.containsKey(node)) {
        connectingRefCounter.decRef();
        listener.onResponse(null);
        return;
    }
    final ListenableFuture<Void> currentListener = new ListenableFuture<>();
    final ListenableFuture<Void> existingListener = pendingConnections.putIfAbsent(node, currentListener);
    if (existingListener != null) {
        try {
            // wait on previous entry to complete connection attempt
            existingListener.addListener(listener, EsExecutors.directExecutor());
        } finally {
            connectingRefCounter.decRef();
        }
        return;
    }
    currentListener.addListener(listener, EsExecutors.directExecutor());
    final RunOnce releaseOnce = new RunOnce(connectingRefCounter::decRef);
    ConnectionProfile resolvedProfile = ConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
    internalOpenConnection(node, resolvedProfile, ActionListener.wrap(conn -> {
        connectionValidator.validate(conn, resolvedProfile, ActionListener.wrap(ignored -> {
            assert Transports.assertNotTransportThread("connection validator success");
            try {
                if (connectedNodes.putIfAbsent(node, conn) != null) {
                    LOGGER.debug("existing connection to node [{}], closing new redundant connection", node);
                    IOUtils.closeWhileHandlingException(conn);
                } else {
                    LOGGER.debug("connected to node [{}]", node);
                    try {
                        connectionListener.onNodeConnected(node, conn);
                    } finally {
                        final Transport.Connection finalConnection = conn;
                        conn.addCloseListener(ActionListener.wrap(() -> {
                            LOGGER.trace("unregistering {} after connection close and marking as disconnected", node);
                            connectedNodes.remove(node, finalConnection);
                            connectionListener.onNodeDisconnected(node, conn);
                        }));
                    }
                }
            } finally {
                ListenableFuture<Void> future = pendingConnections.remove(node);
                assert future == currentListener : "Listener in pending map is different than the expected listener";
                releaseOnce.run();
                future.onResponse(null);
            }
        }, e -> {
            assert Transports.assertNotTransportThread("connection validator failure");
            IOUtils.closeWhileHandlingException(conn);
            failConnectionListeners(node, releaseOnce, e, currentListener);
        }));
    }, e -> {
        assert Transports.assertNotTransportThread("internalOpenConnection failure");
        failConnectionListeners(node, releaseOnce, e, currentListener);
    }));
}