Java ElectMasterService類代碼示例

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
private void configureCluster(
    Settings settings,
    int numberOfNodes,
    @Nullable int[] unicastHostsOrdinals,
    int minimumMasterNode
) throws ExecutionException, InterruptedException {
    if (minimumMasterNode < 0) {
        minimumMasterNode = numberOfNodes / 2 + 1;
    }
    logger.info("---> configured unicast");
    // TODO: Rarely use default settings form some of these
    Settings nodeSettings = Settings.builder()
        .put(settings)
        .put(NodeEnvironment.MAX_LOCAL_STORAGE_NODES_SETTING.getKey(), numberOfNodes)
        .put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), minimumMasterNode)
        .build();

    if (discoveryConfig == null) {
        if (unicastHostsOrdinals == null) {
            discoveryConfig = new ClusterDiscoveryConfiguration.UnicastZen(numberOfNodes, nodeSettings);
        } else {
            discoveryConfig = new ClusterDiscoveryConfiguration.UnicastZen(numberOfNodes, nodeSettings, unicastHostsOrdinals);
        }
    }
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
/**
 * Verify that nodes fault detection works after master (re) election
 */
public void testNodesFDAfterMasterReelection() throws Exception {
    startCluster(4);

    logger.info("--> stopping current master");
    internalCluster().stopCurrentMasterNode();

    ensureStableCluster(3);

    logger.info("--> reducing min master nodes to 2");
    assertAcked(client().admin().cluster().prepareUpdateSettings()
        .setTransientSettings(Settings.builder().put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), 2))
        .get());

    String master = internalCluster().getMasterName();
    String nonMaster = null;
    for (String node : internalCluster().getNodeNames()) {
        if (!node.equals(master)) {
            nonMaster = node;
        }
    }

    logger.info("--> isolating [{}]", nonMaster);
    TwoPartitions partitions = isolateNode(nonMaster);
    NetworkDisruption networkDisruption = addRandomDisruptionType(partitions);
    networkDisruption.startDisrupting();

    logger.info("--> waiting for master to remove it");
    ensureStableCluster(2, master);
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
public void testArchiveBrokenClusterSettings() throws Exception {
    logger.info("--> starting one node");
    internalCluster().startNode();
    client().prepareIndex("test", "type1", "1").setSource("field1", "value1").setRefreshPolicy(IMMEDIATE).get();
    logger.info("--> waiting for green status");
    if (usually()) {
        ensureYellow();
    } else {
        internalCluster().startNode();
        client().admin().cluster()
            .health(Requests.clusterHealthRequest()
                .waitForGreenStatus()
                .waitForEvents(Priority.LANGUID)
                .waitForNoRelocatingShards(true).waitForNodes("2")).actionGet();
    }
    ClusterState state = client().admin().cluster().prepareState().get().getState();
    MetaData metaData = state.getMetaData();
    for (NodeEnvironment nodeEnv : internalCluster().getInstances(NodeEnvironment.class)) {
        MetaData brokenMeta = MetaData.builder(metaData).persistentSettings(Settings.builder()
            .put(metaData.persistentSettings()).put("this.is.unknown", true)
            .put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), "broken").build()).build();
        MetaData.FORMAT.write(brokenMeta, nodeEnv.nodeDataPaths());
    }
    internalCluster().fullRestart();
    ensureYellow("test"); // wait for state recovery
    state = client().admin().cluster().prepareState().get().getState();
    assertEquals("true", state.metaData().persistentSettings().get("archived.this.is.unknown"));
    assertEquals("broken", state.metaData().persistentSettings().get("archived."
        + ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey()));

    // delete these settings
    client().admin().cluster().prepareUpdateSettings().setPersistentSettings(Settings.builder().putNull("archived.*")).get();

    state = client().admin().cluster().prepareState().get().getState();
    assertNull(state.metaData().persistentSettings().get("archived.this.is.unknown"));
    assertNull(state.metaData().persistentSettings().get("archived."
        + ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey()));
    assertHitCount(client().prepareSearch().setQuery(matchAllQuery()).get(), 1L);
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
public void testDynamicUpdateMinimumMasterNodes() throws Exception {
    Settings settings = Settings.builder()
            .put(ZenDiscovery.PING_TIMEOUT_SETTING.getKey(), "400ms")
            .put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), "1")
            .build();

    logger.info("--> start first node and wait for it to be a master");
    internalCluster().startNode(settings);
    ensureClusterSizeConsistency();

    // wait until second node join the cluster
    logger.info("--> start second node and wait for it to join");
    internalCluster().startNode(settings);
    ensureClusterSizeConsistency();

    logger.info("--> setting minimum master node to 2");
    setMinimumMasterNodes(2);

    // make sure it has been processed on all nodes (master node spawns a secondary cluster state update task)
    for (Client client : internalCluster().getClients()) {
        assertThat(client.admin().cluster().prepareHealth().setWaitForEvents(Priority.LANGUID).setLocal(true).get().isTimedOut(),
                equalTo(false));
    }

    logger.info("--> stopping a node");
    internalCluster().stopRandomDataNode();
    logger.info("--> verifying min master node has effect");
    assertNoMasterBlockOnAllNodes();

    logger.info("--> bringing another node up");
    internalCluster().startNode(Settings.builder().put(settings).put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), 2).build());
    ensureClusterSizeConsistency();
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
public void testCanNotBringClusterDown() throws ExecutionException, InterruptedException {
    int nodeCount = scaledRandomIntBetween(1, 5);
    Settings.Builder settings = Settings.builder()
            .put(ZenDiscovery.PING_TIMEOUT_SETTING.getKey(), "200ms")
            .put("discovery.initial_state_timeout", "500ms");

    // set an initial value which is at least quorum to avoid split brains during initial startup
    int initialMinMasterNodes = randomIntBetween(nodeCount / 2 + 1, nodeCount);
    settings.put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), initialMinMasterNodes);


    logger.info("--> starting [{}] nodes. min_master_nodes set to [{}]", nodeCount, initialMinMasterNodes);
    internalCluster().startNodes(nodeCount, settings.build());

    logger.info("--> waiting for nodes to join");
    assertFalse(client().admin().cluster().prepareHealth().setWaitForNodes(Integer.toString(nodeCount)).get().isTimedOut());

    int updateCount = randomIntBetween(1, nodeCount);

    logger.info("--> updating [{}] to [{}]", ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), updateCount);
    assertAcked(client().admin().cluster().prepareUpdateSettings()
            .setPersistentSettings(Settings.builder().put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), updateCount)));

    logger.info("--> verifying no node left and master is up");
    assertFalse(client().admin().cluster().prepareHealth().setWaitForNodes(Integer.toString(nodeCount)).get().isTimedOut());

    updateCount = nodeCount + randomIntBetween(1, 2000);
    logger.info("--> trying to updating [{}] to [{}]", ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), updateCount);
    try {
        client().admin().cluster().prepareUpdateSettings()
                .setPersistentSettings(Settings.builder().put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), updateCount));
    } catch (IllegalArgumentException ex) {
        assertEquals(ex.getMessage(), "cannot set discovery.zen.minimum_master_nodes to more than the current master nodes count [" +updateCount+ "]");
    }

    logger.info("--> verifying no node left and master is up");
    assertFalse(client().admin().cluster().prepareHealth().setWaitForNodes(Integer.toString(nodeCount)).get().isTimedOut());
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
public void testIndexExistsWithBlocksInPlace() throws IOException {
    Settings settings = Settings.builder()
        .put(GatewayService.RECOVER_AFTER_NODES_SETTING.getKey(), 99)
        .put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), 1).build();
    String node = internalCluster().startNode(settings);

    assertThrows(client(node).admin().indices().prepareExists("test").setMasterNodeTimeout(TimeValue.timeValueSeconds(0)),
        MasterNotDiscoveredException.class);

    internalCluster().stopRandomNode(InternalTestCluster.nameFilter(node)); // shut down node so that test properly cleans up
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
protected final void afterInternal(boolean afterClass) throws Exception {
    boolean success = false;
    try {
        final Scope currentClusterScope = getCurrentClusterScope();
        clearDisruptionScheme();
        try {
            if (cluster() != null) {
                if (currentClusterScope != Scope.TEST) {
                    MetaData metaData = client().admin().cluster().prepareState().execute().actionGet().getState().getMetaData();
                    final Map<String, String> persistent = metaData.persistentSettings().getAsMap();
                    assertThat("test leaves persistent cluster metadata behind: " + persistent, persistent.size(), equalTo(0));
                    final Map<String, String> transientSettings =  new HashMap<>(metaData.transientSettings().getAsMap());
                    if (isInternalCluster() && internalCluster().getAutoManageMinMasterNode()) {
                        // this is set by the test infra
                        transientSettings.remove(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey());
                    }
                    assertThat("test leaves transient cluster metadata behind: " + transientSettings,
                        transientSettings.keySet(), empty());
                }
                ensureClusterSizeConsistency();
                ensureClusterStateConsistency();
                if (isInternalCluster()) {
                    // check no pending cluster states are leaked
                    for (Discovery discovery : internalCluster().getInstances(Discovery.class)) {
                        if (discovery instanceof ZenDiscovery) {
                            final ZenDiscovery zenDiscovery = (ZenDiscovery) discovery;
                            assertBusy(() -> {
                                final ClusterState[] states = zenDiscovery.pendingClusterStates();
                                assertThat(zenDiscovery.localNode().getName() + " still having pending states:\n" +
                                        Stream.of(states).map(ClusterState::toString).collect(Collectors.joining("\n")),
                                    states, emptyArray());
                            });
                        }
                    }
                }
                beforeIndexDeletion();
                cluster().wipe(excludeTemplates()); // wipe after to make sure we fail in the test that didn't ack the delete
                if (afterClass || currentClusterScope == Scope.TEST) {
                    cluster().close();
                }
                cluster().assertAfterTest();
            }
        } finally {
            if (currentClusterScope == Scope.TEST) {
                clearClusters(); // it is ok to leave persistent / transient cluster state behind if scope is TEST
            }
        }
        success = true;
    } finally {
        if (!success) {
            // if we failed here that means that something broke horribly so we should clear all clusters
            // TODO: just let the exception happen, WTF is all this horseshit
            // afterTestRule.forceFailure();
        }
    }
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
/**
 * Sets the cluster's minimum master node and make sure the response is acknowledge.
 * Note: this doesn't guarantee that the new setting has taken effect, just that it has been received by all nodes.
 */
public void setMinimumMasterNodes(int n) {
    assertTrue(client().admin().cluster().prepareUpdateSettings().setTransientSettings(
        Settings.builder().put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), n))
        .get().isAcknowledged());
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
@Override
public int getMinimumMasterNodes() {
    return ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.get(settings);
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
public Client startNode(Settings.Builder settings, int minMasterNodes) {
    String name = internalCluster().startNode(
        Settings.builder().put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), minMasterNodes)
            .put(settings.build()));
    return internalCluster().client(name);
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
public void testRestorePersistentSettings() throws Exception {
    logger.info("--> start 2 nodes");
    Settings nodeSettings = Settings.builder()
            .put("discovery.type", "zen")
            .put(ZenDiscovery.PING_TIMEOUT_SETTING.getKey(), "200ms")
            .put("discovery.initial_state_timeout", "500ms")
            .build();
    internalCluster().startNode(nodeSettings);
    Client client = client();
    String secondNode = internalCluster().startNode(nodeSettings);
    logger.info("--> wait for the second node to join the cluster");
    assertThat(client.admin().cluster().prepareHealth().setWaitForNodes("2").get().isTimedOut(), equalTo(false));

    int random = randomIntBetween(10, 42);

    logger.info("--> set test persistent setting");
    client.admin().cluster().prepareUpdateSettings().setPersistentSettings(
            Settings.builder()
                    .put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), 2))
            .execute().actionGet();

    assertThat(client.admin().cluster().prepareState().setRoutingTable(false).setNodes(false).execute().actionGet().getState()
            .getMetaData().persistentSettings().getAsInt(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), -1), equalTo(2));

    logger.info("--> create repository");
    PutRepositoryResponse putRepositoryResponse = client.admin().cluster().preparePutRepository("test-repo")
            .setType("fs").setSettings(Settings.builder().put("location", randomRepoPath())).execute().actionGet();
    assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));

    logger.info("--> start snapshot");
    CreateSnapshotResponse createSnapshotResponse = client.admin().cluster().prepareCreateSnapshot("test-repo", "test-snap").setWaitForCompletion(true).execute().actionGet();
    assertThat(createSnapshotResponse.getSnapshotInfo().totalShards(), equalTo(0));
    assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(0));
    assertThat(client.admin().cluster().prepareGetSnapshots("test-repo").setSnapshots("test-snap").execute().actionGet().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));

    logger.info("--> clean the test persistent setting");
    client.admin().cluster().prepareUpdateSettings().setPersistentSettings(
            Settings.builder()
                    .put(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), 1))
            .execute().actionGet();
    assertThat(client.admin().cluster().prepareState().setRoutingTable(false).setNodes(false).execute().actionGet().getState()
            .getMetaData().persistentSettings().getAsInt(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), -1), equalTo(1));

    stopNode(secondNode);
    assertThat(client.admin().cluster().prepareHealth().setWaitForNodes("1").get().isTimedOut(), equalTo(false));

    logger.info("--> restore snapshot");
    try {
        client.admin().cluster().prepareRestoreSnapshot("test-repo", "test-snap").setRestoreGlobalState(true).setWaitForCompletion(true).execute().actionGet();
        fail("can't restore minimum master nodes");
    } catch (IllegalArgumentException ex) {
        assertEquals("illegal value can't update [discovery.zen.minimum_master_nodes] from [1] to [2]", ex.getMessage());
        assertEquals("cannot set discovery.zen.minimum_master_nodes to more than the current master nodes count [1]", ex.getCause().getMessage());
    }
    logger.info("--> ensure that zen discovery minimum master nodes wasn't restored");
    assertThat(client.admin().cluster().prepareState().setRoutingTable(false).setNodes(false).execute().actionGet().getState()
            .getMetaData().persistentSettings().getAsInt(ElectMasterService.DISCOVERY_ZEN_MINIMUM_MASTER_NODES_SETTING.getKey(), -1), not(equalTo(2)));
}
 

import org.elasticsearch.discovery.zen.ElectMasterService; //導入依賴的package包/類
@Inject
public AzureRuntimeDiscovery(Settings settings, ThreadPool threadPool, TransportService transportService,
                             ClusterService clusterService, ClusterSettings clusterSettings,  ZenPingService pingService,
                             ElectMasterService electMasterService) {
    super(settings, threadPool, transportService, clusterService,clusterSettings, pingService, electMasterService);
}