Examples with DiscoveryNode org.elasticsearch.cluster.node.DiscoveryNode used on opensource projects

Example 66 with DiscoveryNode

use of org.elasticsearch.cluster.node.DiscoveryNode in project elasticsearch by elastic.

the class TransportClientNodesService method addTransportAddresses.

public TransportClientNodesService addTransportAddresses(TransportAddress... transportAddresses) {
    synchronized (mutex) {
        if (closed) {
            throw new IllegalStateException("transport client is closed, can't add an address");
        }
        List<TransportAddress> filtered = new ArrayList<>(transportAddresses.length);
        for (TransportAddress transportAddress : transportAddresses) {
            boolean found = false;
            for (DiscoveryNode otherNode : listedNodes) {
                if (otherNode.getAddress().equals(transportAddress)) {
                    found = true;
                    logger.debug("address [{}] already exists with [{}], ignoring...", transportAddress, otherNode);
                    break;
                }
            }
            if (!found) {
                filtered.add(transportAddress);
            }
        }
        if (filtered.isEmpty()) {
            return this;
        }
        List<DiscoveryNode> builder = new ArrayList<>();
        builder.addAll(listedNodes());
        for (TransportAddress transportAddress : filtered) {
            DiscoveryNode node = new DiscoveryNode("#transport#-" + tempNodeIdGenerator.incrementAndGet(), transportAddress, Collections.emptyMap(), Collections.emptySet(), minCompatibilityVersion);
            logger.debug("adding address [{}]", node);
            builder.add(node);
        }
        listedNodes = Collections.unmodifiableList(builder);
        nodesSampler.sample();
    }
    return this;
}

Example 67 with DiscoveryNode

use of org.elasticsearch.cluster.node.DiscoveryNode in project elasticsearch by elastic.

the class TransportClientNodesService method execute.

public <Response> void execute(NodeListenerCallback<Response> callback, ActionListener<Response> listener) {
    // we first read nodes before checking the closed state; this
    // is because otherwise we could be subject to a race where we
    // read the state as not being closed, and then the client is
    // closed and the nodes list is cleared, and then a
    // NoNodeAvailableException is thrown
    // it is important that the order of first setting the state of
    // closed and then clearing the list of nodes is maintained in
    // the close method
    final List<DiscoveryNode> nodes = this.nodes;
    if (closed) {
        throw new IllegalStateException("transport client is closed");
    }
    ensureNodesAreAvailable(nodes);
    int index = getNodeNumber();
    RetryListener<Response> retryListener = new RetryListener<>(callback, listener, nodes, index, hostFailureListener);
    DiscoveryNode node = retryListener.getNode(0);
    try {
        callback.doWithNode(node, retryListener);
    } catch (Exception e) {
        try {
            //this exception can't come from the TransportService as it doesn't throw exception at all
            listener.onFailure(e);
        } finally {
            retryListener.maybeNodeFailed(node, e);
        }
    }
}

Example 68 with DiscoveryNode

use of org.elasticsearch.cluster.node.DiscoveryNode in project elasticsearch by elastic.

the class InternalClusterInfoService method clusterChanged.

@Override
public void clusterChanged(ClusterChangedEvent event) {
    if (!this.enabled) {
        return;
    }
    // Check whether it was a data node that was added
    boolean dataNodeAdded = false;
    for (DiscoveryNode addedNode : event.nodesDelta().addedNodes()) {
        if (addedNode.isDataNode()) {
            dataNodeAdded = true;
            break;
        }
    }
    if (this.isMaster && dataNodeAdded && event.state().getNodes().getDataNodes().size() > 1) {
        if (logger.isDebugEnabled()) {
            logger.debug("data node was added, retrieving new cluster info");
        }
        threadPool.executor(executorName()).execute(() -> maybeRefresh());
    }
    if (this.isMaster && event.nodesRemoved()) {
        for (DiscoveryNode removedNode : event.nodesDelta().removedNodes()) {
            if (removedNode.isDataNode()) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Removing node from cluster info: {}", removedNode.getId());
                }
                if (leastAvailableSpaceUsages.containsKey(removedNode.getId())) {
                    ImmutableOpenMap.Builder<String, DiskUsage> newMaxUsages = ImmutableOpenMap.builder(leastAvailableSpaceUsages);
                    newMaxUsages.remove(removedNode.getId());
                    leastAvailableSpaceUsages = newMaxUsages.build();
                }
                if (mostAvailableSpaceUsages.containsKey(removedNode.getId())) {
                    ImmutableOpenMap.Builder<String, DiskUsage> newMinUsages = ImmutableOpenMap.builder(mostAvailableSpaceUsages);
                    newMinUsages.remove(removedNode.getId());
                    mostAvailableSpaceUsages = newMinUsages.build();
                }
            }
        }
    }
}

Example 69 with DiscoveryNode

use of org.elasticsearch.cluster.node.DiscoveryNode in project elasticsearch by elastic.

the class UnicastZenPing method ping.

/**
     * a variant of {@link #ping(Consumer, TimeValue)}, but allows separating the scheduling duration
     * from the duration used for request level time outs. This is useful for testing
     */
protected void ping(final Consumer<PingCollection> resultsConsumer, final TimeValue scheduleDuration, final TimeValue requestDuration) {
    final List<DiscoveryNode> seedNodes;
    try {
        seedNodes = resolveHostsLists(unicastZenPingExecutorService, logger, configuredHosts, limitPortCounts, transportService, UNICAST_NODE_PREFIX, resolveTimeout);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    seedNodes.addAll(hostsProvider.buildDynamicNodes());
    final DiscoveryNodes nodes = contextProvider.nodes();
    // add all possible master nodes that were active in the last known cluster configuration
    for (ObjectCursor<DiscoveryNode> masterNode : nodes.getMasterNodes().values()) {
        seedNodes.add(masterNode.value);
    }
    final ConnectionProfile connectionProfile = ConnectionProfile.buildSingleChannelProfile(TransportRequestOptions.Type.REG, requestDuration, requestDuration);
    final PingingRound pingingRound = new PingingRound(pingingRoundIdGenerator.incrementAndGet(), seedNodes, resultsConsumer, nodes.getLocalNode(), connectionProfile);
    activePingingRounds.put(pingingRound.id(), pingingRound);
    final AbstractRunnable pingSender = new AbstractRunnable() {

        @Override
        public void onFailure(Exception e) {
            if (e instanceof AlreadyClosedException == false) {
                logger.warn("unexpected error while pinging", e);
            }
        }

        @Override
        protected void doRun() throws Exception {
            sendPings(requestDuration, pingingRound);
        }
    };
    threadPool.generic().execute(pingSender);
    threadPool.schedule(TimeValue.timeValueMillis(scheduleDuration.millis() / 3), ThreadPool.Names.GENERIC, pingSender);
    threadPool.schedule(TimeValue.timeValueMillis(scheduleDuration.millis() / 3 * 2), ThreadPool.Names.GENERIC, pingSender);
    threadPool.schedule(scheduleDuration, ThreadPool.Names.GENERIC, new AbstractRunnable() {

        @Override
        protected void doRun() throws Exception {
            finishPingingRound(pingingRound);
        }

        @Override
        public void onFailure(Exception e) {
            logger.warn("unexpected error while finishing pinging round", e);
        }
    });
}

Example 70 with DiscoveryNode

use of org.elasticsearch.cluster.node.DiscoveryNode in project elasticsearch by elastic.

the class UnicastZenPing method sendPings.

protected void sendPings(final TimeValue timeout, final PingingRound pingingRound) {
    final UnicastPingRequest pingRequest = new UnicastPingRequest();
    pingRequest.id = pingingRound.id();
    pingRequest.timeout = timeout;
    DiscoveryNodes discoNodes = contextProvider.nodes();
    pingRequest.pingResponse = createPingResponse(discoNodes);
    Set<DiscoveryNode> nodesFromResponses = temporalResponses.stream().map(pingResponse -> {
        assert clusterName.equals(pingResponse.clusterName()) : "got a ping request from a different cluster. expected " + clusterName + " got " + pingResponse.clusterName();
        return pingResponse.node();
    }).collect(Collectors.toSet());
    // dedup by address
    final Map<TransportAddress, DiscoveryNode> uniqueNodesByAddress = Stream.concat(pingingRound.getSeedNodes().stream(), nodesFromResponses.stream()).collect(Collectors.toMap(DiscoveryNode::getAddress, Function.identity(), (n1, n2) -> n1));
    // resolve what we can via the latest cluster state
    final Set<DiscoveryNode> nodesToPing = uniqueNodesByAddress.values().stream().map(node -> {
        DiscoveryNode foundNode = discoNodes.findByAddress(node.getAddress());
        if (foundNode == null) {
            return node;
        } else {
            return foundNode;
        }
    }).collect(Collectors.toSet());
    nodesToPing.forEach(node -> sendPingRequestToNode(node, timeout, pingingRound, pingRequest));
}