Java DiscoveryNode.isMasterNode方法代码示例

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.isDataNode(settings)) {
        // this is only useful on the nodes that can hold data
        // addLowPriorityApplier to make sure that Repository will be created before snapshot
        clusterService.addLowPriorityApplier(this);
    }

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

}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public void testFilterNonMasterPingResponse() {
    ArrayList<ZenPing.PingResponse> responses = new ArrayList<>();
    ArrayList<DiscoveryNode> masterNodes = new ArrayList<>();
    ArrayList<DiscoveryNode> allNodes = new ArrayList<>();
    for (int i = randomIntBetween(10, 20); i >= 0; i--) {
        Set<Role> roles = new HashSet<>(randomSubsetOf(Arrays.asList(Role.values())));
        DiscoveryNode node = new DiscoveryNode("node_" + i, "id_" + i, buildNewFakeTransportAddress(), Collections.emptyMap(),
                roles, Version.CURRENT);
        responses.add(new ZenPing.PingResponse(node, randomBoolean() ? null : node, new ClusterName("test"), randomLong()));
        allNodes.add(node);
        if (node.isMasterNode()) {
            masterNodes.add(node);
        }
    }

    boolean ignore = randomBoolean();
    List<ZenPing.PingResponse> filtered = ZenDiscovery.filterPingResponses(responses, ignore, logger);
    final List<DiscoveryNode> filteredNodes = filtered.stream().map(ZenPing.PingResponse::node).collect(Collectors.toList());
    if (ignore) {
        assertThat(filteredNodes, equalTo(masterNodes));
    } else {
        assertThat(filteredNodes, equalTo(allNodes));
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
@Override
protected void doStart() {
    // Doesn't make sense to manage shards on non-master and non-data nodes
    if (DiscoveryNode.isDataNode(settings) || DiscoveryNode.isMasterNode(settings)) {
        clusterService.addHighPriorityApplier(this);
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public synchronized void onNodeSendFailed(DiscoveryNode node, Exception e) {
    if (node.isMasterNode()) {
        logger.trace("master node {} failed to ack cluster state version [{}]. " +
                "processing ... (current pending [{}], needed [{}])",
                node, clusterState.version(), pendingMasterNodes, neededMastersToCommit);
        decrementPendingMasterAcksAndChangeForFailure();
    }
    publishResponseHandler.onFailure(node, e);
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public synchronized int getPendingMasterJoinsCount() {
    int pendingMasterJoins = 0;
    for (DiscoveryNode node : joinRequestAccumulator.keySet()) {
        if (node.isMasterNode()) {
            pendingMasterJoins++;
        }
    }
    return pendingMasterJoins;
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public boolean hasEnoughMasterNodes(Iterable<DiscoveryNode> nodes) {
    int count = 0;
    for (DiscoveryNode node : nodes) {
        if (node.isMasterNode()) {
            count++;
        }
    }
    return count > 0 && (minimumMasterNodes < 0 || count >= minimumMasterNodes);
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public boolean hasTooManyMasterNodes(Iterable<DiscoveryNode> nodes) {
    int count = 0;
    for (DiscoveryNode node : nodes) {
        if (node.isMasterNode()) {
            count++;
        }
    }
    return count > 1 && minimumMasterNodes <= count / 2;
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
private List<DiscoveryNode> sortedMasterNodes(Iterable<DiscoveryNode> nodes) {
    List<DiscoveryNode> possibleNodes = CollectionUtils.iterableAsArrayList(nodes);
    if (possibleNodes.isEmpty()) {
        return null;
    }
    // clean non master nodes
    for (Iterator<DiscoveryNode> it = possibleNodes.iterator(); it.hasNext(); ) {
        DiscoveryNode node = it.next();
        if (!node.isMasterNode()) {
            it.remove();
        }
    }
    CollectionUtil.introSort(possibleNodes, ElectMasterService::compareNodes);
    return possibleNodes;
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
/** master nodes go before other nodes, with a secondary sort by id **/
 private static int compareNodes(DiscoveryNode o1, DiscoveryNode o2) {
    if (o1.isMasterNode() && !o2.isMasterNode()) {
        return -1;
    }
    if (!o1.isMasterNode() && o2.isMasterNode()) {
        return 1;
    }
    return o1.getId().compareTo(o2.getId());
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
@Inject
public RepositoriesService(Settings settings, ClusterService clusterService, TransportService transportService,
                           Map<String, Repository.Factory> typesRegistry) {
    super(settings);
    this.typesRegistry = typesRegistry;
    this.clusterService = clusterService;
    // Doesn't make sense to maintain repositories on non-master and non-data nodes
    // Nothing happens there anyway
    if (DiscoveryNode.isDataNode(settings) || DiscoveryNode.isMasterNode(settings)) {
        clusterService.addStateApplier(this);
    }
    this.verifyAction = new VerifyNodeRepositoryAction(settings, transportService, clusterService, this);
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
@Inject
public SnapshotsService(Settings settings, ClusterService clusterService, IndexNameExpressionResolver indexNameExpressionResolver, RepositoriesService repositoriesService, ThreadPool threadPool) {
    super(settings);
    this.clusterService = clusterService;
    this.indexNameExpressionResolver = indexNameExpressionResolver;
    this.repositoriesService = repositoriesService;
    this.threadPool = threadPool;

    if (DiscoveryNode.isMasterNode(settings)) {
        // addLowPriorityApplier to make sure that Repository will be created before snapshot
        clusterService.addLowPriorityApplier(this);
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public void testSortByMasterLikelihood() {
    List<DiscoveryNode> nodes = generateRandomNodes();
    List<DiscoveryNode> sortedNodes = ElectMasterService.sortByMasterLikelihood(nodes);
    assertEquals(nodes.size(), sortedNodes.size());
    DiscoveryNode prevNode = sortedNodes.get(0);
    for (int i = 1; i < sortedNodes.size(); i++) {
        DiscoveryNode node = sortedNodes.get(i);
        if (!prevNode.isMasterNode()) {
            assertFalse(node.isMasterNode());
        } else if (node.isMasterNode()) {
            assertTrue(prevNode.getId().compareTo(node.getId()) < 0);
        }
        prevNode = node;
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
@Override
public boolean test(NodeAndClient nodeAndClient) {
    return DiscoveryNode.isDataNode(nodeAndClient.node.settings()) ||
        DiscoveryNode.isMasterNode(nodeAndClient.node.settings());
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
public ExternalTestCluster(Path tempDir, Settings additionalSettings, Collection<Class<? extends Plugin>> pluginClasses,
                           TransportAddress... transportAddresses) {
    super(0);
    Settings.Builder clientSettingsBuilder = Settings.builder()
        .put(additionalSettings)
        .put("node.name", InternalTestCluster.TRANSPORT_CLIENT_PREFIX + EXTERNAL_CLUSTER_PREFIX + counter.getAndIncrement())
        .put("client.transport.ignore_cluster_name", true)
        .put(Environment.PATH_HOME_SETTING.getKey(), tempDir);
    boolean addMockTcpTransport = additionalSettings.get(NetworkModule.TRANSPORT_TYPE_KEY) == null;

    if (addMockTcpTransport) {
        clientSettingsBuilder.put(NetworkModule.TRANSPORT_TYPE_KEY, MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME);
        if (pluginClasses.contains(MockTcpTransportPlugin.class) == false) {
            pluginClasses = new ArrayList<>(pluginClasses);
            pluginClasses.add(MockTcpTransportPlugin.class);
        }
    }
    Settings clientSettings = clientSettingsBuilder.build();
    TransportClient client = new MockTransportClient(clientSettings, pluginClasses);

    try {
        client.addTransportAddresses(transportAddresses);
        NodesInfoResponse nodeInfos = client.admin().cluster().prepareNodesInfo().clear().setSettings(true).setHttp(true).get();
        httpAddresses = new InetSocketAddress[nodeInfos.getNodes().size()];
        this.clusterName = nodeInfos.getClusterName().value();
        int dataNodes = 0;
        int masterAndDataNodes = 0;
        for (int i = 0; i < nodeInfos.getNodes().size(); i++) {
            NodeInfo nodeInfo = nodeInfos.getNodes().get(i);
            httpAddresses[i] = nodeInfo.getHttp().address().publishAddress().address();
            if (DiscoveryNode.isDataNode(nodeInfo.getSettings())) {
                dataNodes++;
                masterAndDataNodes++;
            } else if (DiscoveryNode.isMasterNode(nodeInfo.getSettings())) {
                masterAndDataNodes++;
            }
        }
        this.numDataNodes = dataNodes;
        this.numMasterAndDataNodes = masterAndDataNodes;
        this.client = client;
        logger.info("Setup ExternalTestCluster [{}] made of [{}] nodes", nodeInfos.getClusterName().value(), size());
    } catch (Exception e) {
        client.close();
        throw e;
    }
}
 

import org.elasticsearch.cluster.node.DiscoveryNode; //导入方法依赖的package包/类
@Override
protected void doStop() {
    if (DiscoveryNode.isDataNode(settings) || DiscoveryNode.isMasterNode(settings)) {
        clusterService.removeApplier(this);
    }
}