Java DiscoveryNode类代码示例

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
private void checkRemoveAddress(boolean sniff) {
    Object[] extraSettings = {TransportClient.CLIENT_TRANSPORT_SNIFF.getKey(), sniff};
    try(TestIteration iteration = new TestIteration(extraSettings)) {
        final TransportClientNodesService service = iteration.transportClientNodesService;
        assertEquals(iteration.listNodesCount + iteration.sniffNodesCount, service.connectedNodes().size());
        final TransportAddress addressToRemove = randomFrom(iteration.listNodeAddresses);
        service.removeTransportAddress(addressToRemove);
        assertThat(service.connectedNodes(), everyItem(not(new CustomMatcher<DiscoveryNode>("removed address") {
            @Override
            public boolean matches(Object item) {
                return item instanceof DiscoveryNode && ((DiscoveryNode)item).getAddress().equals(addressToRemove);
            }
        })));
        assertEquals(iteration.listNodesCount + iteration.sniffNodesCount - 1, service.connectedNodes().size());
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
public void testTcpHandshakeTimeout() throws IOException {
    try (ServerSocket socket = new MockServerSocket()) {
        socket.bind(new InetSocketAddress(InetAddress.getLocalHost(), 0), 1);
        socket.setReuseAddress(true);
        DiscoveryNode dummy = new DiscoveryNode("TEST", new TransportAddress(socket.getInetAddress(),
            socket.getLocalPort()), emptyMap(),
            emptySet(), version0);
        ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
        builder.addConnections(1,
            TransportRequestOptions.Type.BULK,
            TransportRequestOptions.Type.PING,
            TransportRequestOptions.Type.RECOVERY,
            TransportRequestOptions.Type.REG,
            TransportRequestOptions.Type.STATE);
        builder.setHandshakeTimeout(TimeValue.timeValueMillis(1));
        ConnectTransportException ex = expectThrows(ConnectTransportException.class,
            () -> serviceA.connectToNode(dummy, builder.build()));
        assertEquals("[][" + dummy.getAddress() + "] handshake_timeout[1ms]", ex.getMessage());
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
@Override
protected void doStart() {
    add(localNodeMasterListeners);
    add(taskManager);
    this.clusterState = ClusterState.builder(clusterState).blocks(initialBlocks).build();
    this.updateTasksExecutor = EsExecutors.newSinglePrioritizing(UPDATE_THREAD_NAME, daemonThreadFactory(settings, UPDATE_THREAD_NAME));
    this.reconnectToNodes = threadPool.schedule(reconnectInterval, ThreadPool.Names.GENERIC, new ReconnectToNodes());
    Map<String, String> nodeAttributes = discoveryNodeService.buildAttributes();
    // note, we rely on the fact that its a new id each time we start, see FD and "kill -9" handling
    final String nodeId = DiscoveryService.generateNodeId(settings);
    final TransportAddress publishAddress = transportService.boundAddress().publishAddress();
    DiscoveryNode localNode = new DiscoveryNode(settings.get("name"), nodeId, publishAddress, nodeAttributes, version);
    DiscoveryNodes.Builder nodeBuilder = DiscoveryNodes.builder().put(localNode).localNodeId(localNode.id());
    this.clusterState = ClusterState.builder(clusterState).nodes(nodeBuilder).blocks(initialBlocks).build();
    this.transportService.setLocalNode(localNode);
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
static ConnectionProfile buildDefaultConnectionProfile(Settings settings) {
    int connectionsPerNodeRecovery = CONNECTIONS_PER_NODE_RECOVERY.get(settings);
    int connectionsPerNodeBulk = CONNECTIONS_PER_NODE_BULK.get(settings);
    int connectionsPerNodeReg = CONNECTIONS_PER_NODE_REG.get(settings);
    int connectionsPerNodeState = CONNECTIONS_PER_NODE_STATE.get(settings);
    int connectionsPerNodePing = CONNECTIONS_PER_NODE_PING.get(settings);
    ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
    builder.setConnectTimeout(TCP_CONNECT_TIMEOUT.get(settings));
    builder.setHandshakeTimeout(TCP_CONNECT_TIMEOUT.get(settings));
    builder.addConnections(connectionsPerNodeBulk, TransportRequestOptions.Type.BULK);
    builder.addConnections(connectionsPerNodePing, TransportRequestOptions.Type.PING);
    // if we are not master eligible we don't need a dedicated channel to publish the state
    builder.addConnections(DiscoveryNode.isMasterNode(settings) ? connectionsPerNodeState : 0, TransportRequestOptions.Type.STATE);
    // if we are not a data-node we don't need any dedicated channels for recovery
    builder.addConnections(DiscoveryNode.isDataNode(settings) ? connectionsPerNodeRecovery : 0, TransportRequestOptions.Type.RECOVERY);
    builder.addConnections(connectionsPerNodeReg, TransportRequestOptions.Type.REG);
    return builder.build();
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
/**
 * processes or queues an incoming join request.
 * <p>
 * Note: doesn't do any validation. This should have been done before.
 */
public void handleJoinRequest(final DiscoveryNode node, final MembershipAction.JoinCallback callback) {
    synchronized (pendingJoinRequests) {
        List<MembershipAction.JoinCallback> nodeCallbacks = pendingJoinRequests.get(node);
        if (nodeCallbacks == null) {
            nodeCallbacks = new ArrayList<>();
            pendingJoinRequests.put(node, nodeCallbacks);
        }
        nodeCallbacks.add(callback);
    }
    if (accumulateJoins.get() == false) {
        processJoins("join from node[" + node + "]");
    } else {
        checkPendingJoinsAndElectIfNeeded();
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
void executePhase(final int shardIndex, DiscoveryNode node, final long searchId) {
    InternalScrollSearchRequest internalRequest = internalScrollSearchRequest(searchId, request);
    searchService.sendExecuteFetch(node, internalRequest, new ActionListener<ScrollQueryFetchSearchResult>() {
        @Override
        public void onResponse(ScrollQueryFetchSearchResult result) {
            queryFetchResults.set(shardIndex, result.result());
            if (counter.decrementAndGet() == 0) {
                finishHim();
            }
        }

        @Override
        public void onFailure(Throwable t) {
            onPhaseFailure(t, searchId, shardIndex);
        }
    });
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
public static ClusterService createClusterService(Settings settings, ThreadPool threadPool, DiscoveryNode localNode) {
    ClusterService clusterService = new ClusterService(
        Settings.builder().put("cluster.name", "ClusterServiceTests").put(settings).build(),
            new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
            threadPool, () -> localNode);
    clusterService.setNodeConnectionsService(new NodeConnectionsService(Settings.EMPTY, null, null) {
        @Override
        public void connectToNodes(DiscoveryNodes discoveryNodes) {
            // skip
        }

        @Override
        public void disconnectFromNodesExcept(DiscoveryNodes nodesToKeep) {
            // skip
        }
    });
    clusterService.setClusterStatePublisher((event, ackListener) -> {
    });
    clusterService.setDiscoverySettings(new DiscoverySettings(Settings.EMPTY,
        new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)));
    clusterService.start();
    final DiscoveryNodes.Builder nodes = DiscoveryNodes.builder(clusterService.state().nodes());
    nodes.masterNodeId(clusterService.localNode().getId());
    setState(clusterService, ClusterState.builder(clusterService.state()).nodes(nodes));
    return clusterService;
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
public NodeInfo(Version version, Build build, DiscoveryNode node, @Nullable ImmutableMap<String, String> serviceAttributes, @Nullable Settings settings,
                @Nullable OsInfo os, @Nullable ProcessInfo process, @Nullable JvmInfo jvm, @Nullable ThreadPoolInfo threadPool,
                @Nullable TransportInfo transport, @Nullable HttpInfo http, @Nullable PluginsAndModules plugins) {
    super(node);
    this.version = version;
    this.build = build;
    this.serviceAttributes = serviceAttributes;
    this.settings = settings;
    this.os = os;
    this.process = process;
    this.jvm = jvm;
    this.threadPool = threadPool;
    this.transport = transport;
    this.http = http;
    this.plugins = plugins;
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
public void testMismatchedClusterName() {

        NetworkHandle handleA = startServices("TS_A", Settings.builder().put("cluster.name", "a").build(), Version.CURRENT);
        NetworkHandle handleB = startServices("TS_B", Settings.builder().put("cluster.name", "b").build(), Version.CURRENT);
        DiscoveryNode discoveryNode = new DiscoveryNode(
            "",
            handleB.discoveryNode.getAddress(),
            emptyMap(),
            emptySet(),
            Version.CURRENT.minimumCompatibilityVersion());
        IllegalStateException ex = expectThrows(IllegalStateException.class, () -> {
            try (Transport.Connection connection = handleA.transportService.openConnection(discoveryNode,
                MockTcpTransport.LIGHT_PROFILE)) {
                handleA.transportService.handshake(connection, timeout);
            }
        });
        assertThat(ex.getMessage(), containsString("handshake failed, mismatched cluster name [Cluster [b]]"));
        assertFalse(handleA.transportService.nodeConnected(discoveryNode));
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
@Inject
public SnapshotShardsService(Settings settings, ClusterService clusterService, SnapshotsService snapshotsService, ThreadPool threadPool,
                             TransportService transportService, IndicesService indicesService) {
    super(settings);
    this.indicesService = indicesService;
    this.snapshotsService = snapshotsService;
    this.transportService = transportService;
    this.clusterService = clusterService;
    this.threadPool = threadPool;
    if (DiscoveryNode.dataNode(settings)) {
        // this is only useful on the nodes that can hold data
        // addLast to make sure that Repository will be created before snapshot
        clusterService.addLast(this);
    }

    if (DiscoveryNode.masterNode(settings)) {
        // This needs to run only on nodes that can become masters
        transportService.registerRequestHandler(UPDATE_SNAPSHOT_ACTION_NAME, UpdateIndexShardSnapshotStatusRequest.class, ThreadPool.Names.SAME, new UpdateSnapshotStateRequestHandler());
    }

}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
public void testSuccessAfterRetryWithExceptionFromTransport() throws Exception {
    Request request = new Request().index("test");
    request.shardId = new ShardId("test", "_na_", 0);
    PlainActionFuture<Response> listener = new PlainActionFuture<>();
    boolean local = randomBoolean();
    setState(clusterService, ClusterStateCreationUtils.state("test", local, ShardRoutingState.STARTED));
    action.new AsyncSingleAction(request, listener).start();
    assertThat(transport.capturedRequests().length, equalTo(1));
    long requestId = transport.capturedRequests()[0].requestId;
    transport.clear();
    DiscoveryNode node = clusterService.state().getNodes().getLocalNode();
    transport.handleLocalError(requestId, new ConnectTransportException(node, "test exception"));
    // trigger cluster state observer
    setState(clusterService, ClusterStateCreationUtils.state("test", local, ShardRoutingState.STARTED));
    assertThat(transport.capturedRequests().length, equalTo(1));
    transport.handleResponse(transport.capturedRequests()[0].requestId, new Response());
    listener.get();
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
@Override
public Routing getRouting(WhereClause whereClause, @Nullable String preference) {
    DiscoveryNodes nodes = service.state().nodes();
    TreeMapBuilder<String, Map<String, List<Integer>>> builder = TreeMapBuilder.newMapBuilder();
    Map<String, List<Integer>> emptyTableMap = Collections.emptyMap();
    for (DiscoveryNode node : nodes) {
        builder.put(node.id(), emptyTableMap);
    }
    return new Routing(builder.map());
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
private Set<DiscoveryNode> fdNodesForState(ClusterState clusterState, DiscoveryNode localNode) {
    final Set<DiscoveryNode> discoveryNodes = new HashSet<>();
    clusterState.getNodes().getNodes().valuesIt().forEachRemaining(discoveryNode -> {
        // the local node isn't part of the nodes that are pinged (don't ping ourselves)
        if (discoveryNode.getId().equals(localNode.getId()) == false) {
            discoveryNodes.add(discoveryNode);
        }
    });
    return discoveryNodes;
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
PingingRound(int id, List<DiscoveryNode> seedNodes, Consumer<PingCollection> resultsConsumer, DiscoveryNode localNode,
             ConnectionProfile connectionProfile) {
    this.id = id;
    this.seedNodes = Collections.unmodifiableList(new ArrayList<>(seedNodes));
    this.pingListener = resultsConsumer;
    this.localNode = localNode;
    this.connectionProfile = connectionProfile;
    this.pingCollection = new PingCollection();
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入依赖的package包/类
@Override
public void requestSent(DiscoveryNode node, long requestId, String action, TransportRequestOptions options) {
    super.requestSent(node, requestId, action, options);
    if (actions.contains(action)) {
        sawRequestSent = true;
        expectedEvents.get().countDown();
    }
}