Java Settings.EMPTY属性代码示例

/**
 * Tests that when the nodes with prior copies of the given shard return a THROTTLE decision,
 * then we do not force allocate to that node but instead throttle.
 */
public void testDontForceAllocateOnThrottleDecision() {
    testAllocator.addData(node1, "allocId1", randomBoolean());
    AllocationDeciders deciders = new AllocationDeciders(Settings.EMPTY, Arrays.asList(
        // since we have a NO decision for allocating a shard (because the second decider returns a NO decision),
        // the allocator will see if it can force assign the primary, and in this case,
        // the TestAllocateDecision's decision for force allocating is to THROTTLE (using
        // the default behavior) so despite the other decider's decision to return YES for
        // force allocating the shard, we still THROTTLE due to the decision from TestAllocateDecision
        new TestAllocateDecision(Decision.THROTTLE), getNoDeciderThatAllowsForceAllocate()
    ));
    RoutingAllocation allocation = routingAllocationWithOnePrimaryNoReplicas(deciders, CLUSTER_RECOVERED, "allocId1");
    testAllocator.allocateUnassigned(allocation);
    assertThat(allocation.routingNodesChanged(), equalTo(true));
    List<ShardRouting> ignored = allocation.routingNodes().unassigned().ignored();
    assertEquals(ignored.size(), 1);
    assertEquals(ignored.get(0).unassignedInfo().getLastAllocationStatus(), AllocationStatus.DECIDERS_THROTTLED);
    assertTrue(allocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).isEmpty());
}
 

public void testFailUpgrade() {
    MetaDataIndexUpgradeService service = new MetaDataIndexUpgradeService(Settings.EMPTY, xContentRegistry(),
            new MapperRegistry(Collections.emptyMap(), Collections.emptyMap()), IndexScopedSettings.DEFAULT_SCOPED_SETTINGS);
    final IndexMetaData metaData = newIndexMeta("foo", Settings.builder()
        .put(IndexMetaData.SETTING_VERSION_UPGRADED, Version.V_5_0_0_beta1)
        .put(IndexMetaData.SETTING_VERSION_CREATED, Version.fromString("2.4.0"))
        .put(IndexMetaData.SETTING_VERSION_MINIMUM_COMPATIBLE,
        Version.CURRENT.luceneVersion.toString()).build());
    String message = expectThrows(IllegalStateException.class, () -> service.upgradeIndexMetaData(metaData,
        Version.CURRENT.minimumIndexCompatibilityVersion())).getMessage();
    assertEquals(message, "The index [[foo/BOOM]] was created with version [2.4.0] but the minimum compatible version is [5.0.0]." +
        " It should be re-indexed in Elasticsearch 5.x before upgrading to " + Version.CURRENT.toString() + ".");

    IndexMetaData goodMeta = newIndexMeta("foo", Settings.builder()
        .put(IndexMetaData.SETTING_VERSION_UPGRADED, Version.V_5_0_0_beta1)
        .put(IndexMetaData.SETTING_VERSION_CREATED, Version.fromString("5.1.0"))
        .put(IndexMetaData.SETTING_VERSION_MINIMUM_COMPATIBLE,
            Version.CURRENT.luceneVersion.toString()).build());
    service.upgradeIndexMetaData(goodMeta, Version.V_5_0_0.minimumIndexCompatibilityVersion());
}
 

@Override
public void setUp() throws Exception {
    super.setUp();
    IndexService index = createIndex("test", Settings.EMPTY, "type", "d", "type=double");
    service = new ExpressionScriptEngineService(Settings.EMPTY);
    lookup = new SearchLookup(index.mapperService(), index.fieldData(), null);
}
 

public void testUpdateAutoThrottleSettings() throws Exception {
    MockAppender mockAppender = new MockAppender("testUpdateAutoThrottleSettings");
    mockAppender.start();
    final Logger settingsLogger = Loggers.getLogger("org.elasticsearch.common.settings.IndexScopedSettings");
    Loggers.addAppender(settingsLogger, mockAppender);
    Loggers.setLevel(settingsLogger, Level.TRACE);
    try {
        Settings.Builder builder = Settings.builder()
            .put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, "1")
            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, "0")
            .put(MergePolicyConfig.INDEX_MERGE_POLICY_MAX_MERGE_AT_ONCE_SETTING.getKey(), "2")
            .put(MergePolicyConfig.INDEX_MERGE_POLICY_SEGMENTS_PER_TIER_SETTING.getKey(), "2")
            .put(MergeSchedulerConfig.MAX_THREAD_COUNT_SETTING.getKey(), "1")
            .put(MergeSchedulerConfig.MAX_MERGE_COUNT_SETTING.getKey(), "2")
            .put(MergeSchedulerConfig.AUTO_THROTTLE_SETTING.getKey(), "true");
        IndexSettings settings = new IndexSettings(newIndexMeta("index", builder.build()), Settings.EMPTY);
        assertEquals(settings.getMergeSchedulerConfig().isAutoThrottle(), true);
        builder.put(MergeSchedulerConfig.AUTO_THROTTLE_SETTING.getKey(), "false");
        settings.updateIndexMetaData(newIndexMeta("index", builder.build()));
        // Make sure we log the change:
        assertTrue(mockAppender.sawUpdateAutoThrottle);
        assertEquals(settings.getMergeSchedulerConfig().isAutoThrottle(), false);
    } finally {
        Loggers.removeAppender(settingsLogger, mockAppender);
        mockAppender.stop();
        Loggers.setLevel(settingsLogger, (Level) null);
    }
}
 

@Override
public Settings additionalSettings() {
    // For 5.0, the hosts provider was "zen", but this was before the discovery.zen.hosts_provider
    // setting existed. This check looks for the legacy setting, and sets hosts provider if set
    String discoveryType = DiscoveryModule.DISCOVERY_TYPE_SETTING.get(settings);
    if (discoveryType.equals(GCE)) {
        deprecationLogger.deprecated("Using " + DiscoveryModule.DISCOVERY_TYPE_SETTING.getKey() +
            " setting to set hosts provider is deprecated. " +
            "Set \"" + DiscoveryModule.DISCOVERY_HOSTS_PROVIDER_SETTING.getKey() + ": " + GCE + "\" instead");
        if (DiscoveryModule.DISCOVERY_HOSTS_PROVIDER_SETTING.exists(settings) == false) {
            return Settings.builder().put(DiscoveryModule.DISCOVERY_HOSTS_PROVIDER_SETTING.getKey(), GCE).build();
        }
    }
    return Settings.EMPTY;
}
 

@Before
public void setUp() throws Exception {
    super.setUp();
    clusterService = createClusterService(threadPool);
    final DiscoveryNodes initialNodes = clusterService.state().nodes();
    final DiscoveryNode localNode = initialNodes.getLocalNode();
    // make sure we have a master
    setState(clusterService, ClusterState.builder(clusterService.state()).nodes(
        DiscoveryNodes.builder(initialNodes).masterNodeId(localNode.getId())));
    nodeJoinController = new NodeJoinController(clusterService, createAllocationService(Settings.EMPTY),
        new ElectMasterService(Settings.EMPTY), Settings.EMPTY);
}
 

public void testHitsExecutionNeeded() {
    PercolateQuery percolateQuery = new PercolateQuery(
            "", ctx -> null, new BytesArray("{}"), new MatchAllDocsQuery(), Mockito.mock(IndexSearcher.class), new MatchAllDocsQuery()
    );
    PercolatorHighlightSubFetchPhase subFetchPhase = new PercolatorHighlightSubFetchPhase(Settings.EMPTY,
        emptyMap());
    SearchContext searchContext = Mockito.mock(SearchContext.class);
    Mockito.when(searchContext.highlight()).thenReturn(new SearchContextHighlight(Collections.emptyList()));
    Mockito.when(searchContext.query()).thenReturn(new MatchAllDocsQuery());

    assertThat(subFetchPhase.hitsExecutionNeeded(searchContext), is(false));
    Mockito.when(searchContext.query()).thenReturn(percolateQuery);
    assertThat(subFetchPhase.hitsExecutionNeeded(searchContext), is(true));
}
 

@Before
public final void before()  {
    logger.info("[{}]: before test", getTestName());
    assertNull("Thread context initialized twice", threadContext);
    if (enableWarningsCheck()) {
        this.threadContext = new ThreadContext(Settings.EMPTY);
        DeprecationLogger.setThreadContext(threadContext);
    }
}
 

public void testOriginalContextIsPreservedAfterOnFailure() throws Exception {
    try (ThreadContext threadContext = new ThreadContext(Settings.EMPTY)) {
        final boolean nonEmptyContext = randomBoolean();
        if (nonEmptyContext) {
            threadContext.putHeader("not empty", "value");
        }
        ContextPreservingActionListener<Void> actionListener;
        try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
            threadContext.putHeader("foo", "bar");
            actionListener = new ContextPreservingActionListener<>(threadContext.newRestorableContext(true),
                    new ActionListener<Void>() {
                        @Override
                        public void onResponse(Void aVoid) {
                            throw new RuntimeException("onResponse shouldn't be called");
                        }

                        @Override
                        public void onFailure(Exception e) {
                            assertEquals("bar", threadContext.getHeader("foo"));
                            assertNull(threadContext.getHeader("not empty"));
                        }
                    });
        }

        assertNull(threadContext.getHeader("foo"));
        assertEquals(nonEmptyContext ? "value" : null, threadContext.getHeader("not empty"));

        actionListener.onFailure(null);

        assertNull(threadContext.getHeader("foo"));
        assertEquals(nonEmptyContext ? "value" : null, threadContext.getHeader("not empty"));
    }
}
 

protected List<DiscoveryNode> buildDynamicNodes(GceInstancesServiceImpl gceInstancesService, Settings nodeSettings) {
    GceUnicastHostsProvider provider = new GceUnicastHostsProvider(nodeSettings, gceInstancesService,
        transportService, new NetworkService(Settings.EMPTY, Collections.emptyList()));

    List<DiscoveryNode> discoveryNodes = provider.buildDynamicNodes();
    logger.info("--> nodes found: {}", discoveryNodes);
    return discoveryNodes;
}
 

public void testUnresolvableRequestDoesNotHang() throws InterruptedException, ExecutionException, TimeoutException {
    action = new TestTransportInstanceSingleOperationAction(
            Settings.EMPTY,
            "indices:admin/test_unresolvable",
            transportService,
            new ActionFilters(new HashSet<>()),
            new MyResolver(),
            Request::new
    ) {
        @Override
        protected void resolveRequest(ClusterState state, Request request) {
            throw new IllegalStateException("request cannot be resolved");
        }
    };
    Request request = new Request().index("test");
    request.shardId = new ShardId("test", "_na_", 0);
    PlainActionFuture<Response> listener = new PlainActionFuture<>();
    setState(clusterService, ClusterStateCreationUtils.state("test", randomBoolean(), ShardRoutingState.STARTED));
    action.new AsyncSingleAction(request, listener).start();
    assertThat(transport.capturedRequests().length, equalTo(0));
    try {
        listener.get();
    } catch (Exception e) {
        if (ExceptionsHelper.unwrap(e, IllegalStateException.class) == null) {
            logger.info("expected IllegalStateException  but got ", e);
            fail("expected and IllegalStateException");
        }
    }
}
 

TestAllocator() {
    super(Settings.EMPTY);
}
 

public void testEnableClusterBalanceNoReplicas() {
    final boolean useClusterSetting = randomBoolean();
    Settings build = Settings.builder()
            .put(CLUSTER_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), useClusterSetting ? Rebalance.NONE: RandomPicks.randomFrom(random(), Rebalance.values())) // index settings override cluster settings
            .put(ConcurrentRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_CLUSTER_CONCURRENT_REBALANCE_SETTING.getKey(), 3)
            .build();
    ClusterSettings clusterSettings = new ClusterSettings(build, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
    AllocationService strategy = createAllocationService(build, clusterSettings, random());
    Settings indexSettings = useClusterSetting ? Settings.EMPTY : Settings.builder().put(EnableAllocationDecider.INDEX_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), Rebalance.NONE).build();

    logger.info("Building initial routing table");
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder("test").settings(settings(Version.CURRENT).put(indexSettings)).numberOfShards(6).numberOfReplicas(0))
            .build();

    RoutingTable initialRoutingTable = RoutingTable.builder()
            .addAsNew(metaData.index("test"))
            .build();

    ClusterState clusterState = ClusterState.builder(org.elasticsearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).metaData(metaData).routingTable(initialRoutingTable).build();

    logger.info("--> adding one nodes and do rerouting");
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder()
            .add(newNode("node1"))
            .add(newNode("node2"))
    ).build();
    clusterState = strategy.reroute(clusterState, "reroute");
    assertThat(clusterState.getRoutingNodes().shardsWithState(INITIALIZING).size(), equalTo(6));
    logger.info("--> start the shards (primaries)");
    clusterState = strategy.applyStartedShards(clusterState, clusterState.getRoutingNodes().shardsWithState(INITIALIZING));
    assertThat(clusterState.getRoutingNodes().shardsWithState(STARTED).size(), equalTo(6));
    assertThat(clusterState.getRoutingNodes().shardsWithState(INITIALIZING).size(), equalTo(0));

    logger.info("--> adding one nodes and do rerouting");
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder()
            .add(newNode("node1"))
            .add(newNode("node2"))
            .add(newNode("node3"))
    ).build();
    clusterState = strategy.reroute(clusterState, "reroute");
    assertThat(clusterState.getRoutingNodes().shardsWithState(STARTED).size(), equalTo(6));
    assertThat(clusterState.getRoutingNodes().shardsWithState(RELOCATING).size(), equalTo(0));
    metaData = clusterState.metaData();
    if (useClusterSetting) {
        clusterState = ClusterState.builder(clusterState).metaData(MetaData.builder(metaData).transientSettings(Settings.builder()
                .put(CLUSTER_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), randomBoolean() ? Rebalance.PRIMARIES : Rebalance.ALL)
                .build())).build();
    } else {
        IndexMetaData meta = clusterState.getMetaData().index("test");
        clusterState = ClusterState.builder(clusterState).metaData(MetaData.builder(metaData).removeAllIndices()
                .put(IndexMetaData.builder(meta).settings(Settings.builder().put(meta.getSettings()).put(EnableAllocationDecider.INDEX_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), randomBoolean() ? Rebalance.PRIMARIES : Rebalance.ALL).build()))).build();
    }
    clusterSettings.applySettings(clusterState.metaData().settings());
    clusterState = strategy.reroute(clusterState, "reroute");
    assertThat("expected 4 primaries to be started and 2 to relocate useClusterSettings: " + useClusterSetting, clusterState.getRoutingNodes().shardsWithState(STARTED).size(), equalTo(4));
    assertThat("expected 2 primaries to relocate useClusterSettings: " + useClusterSetting, clusterState.getRoutingNodes().shardsWithState(RELOCATING).size(), equalTo(2));

}
 

public void testRemovingLocalAddresses() throws InterruptedException {
    final NetworkService networkService = new NetworkService(Settings.EMPTY, Collections.emptyList());
    final InetAddress loopbackAddress = InetAddress.getLoopbackAddress();
    final Transport transport = new MockTcpTransport(
        Settings.EMPTY,
        threadPool,
        BigArrays.NON_RECYCLING_INSTANCE,
        new NoneCircuitBreakerService(),
        new NamedWriteableRegistry(Collections.emptyList()),
        networkService,
        Version.CURRENT) {

        @Override
        public BoundTransportAddress boundAddress() {
            return new BoundTransportAddress(
                new TransportAddress[]{
                    new TransportAddress(loopbackAddress, 9300),
                    new TransportAddress(loopbackAddress, 9301)
                },
                new TransportAddress(loopbackAddress, 9302)
            );
        }
    };
    closeables.push(transport);
    final TransportService transportService =
        new TransportService(Settings.EMPTY, transport, threadPool, TransportService.NOOP_TRANSPORT_INTERCEPTOR, x -> null, null);
    closeables.push(transportService);
    final List<DiscoveryNode> discoveryNodes = TestUnicastZenPing.resolveHostsLists(
        executorService,
        logger,
        Collections.singletonList(NetworkAddress.format(loopbackAddress)),
        10,
        transportService,
        "test_",
        TimeValue.timeValueSeconds(1));
    assertThat(discoveryNodes, hasSize(7));
    final Set<Integer> ports = new HashSet<>();
    for (final DiscoveryNode discoveryNode : discoveryNodes) {
        assertTrue(discoveryNode.getAddress().address().getAddress().isLoopbackAddress());
        ports.add(discoveryNode.getAddress().getPort());
    }
    assertThat(ports, equalTo(IntStream.range(9303, 9310).mapToObj(m -> m).collect(Collectors.toSet())));
}
 

public void testValidateShrinkIndex() {
    int numShards = randomIntBetween(2, 42);
    ClusterState state = createClusterState("source", numShards, randomIntBetween(0, 10),
        Settings.builder().put("index.blocks.write", true).build());

    assertEquals("index [source] already exists",
        expectThrows(ResourceAlreadyExistsException.class, () ->
            MetaDataCreateIndexService.validateShrinkIndex(state, "target", Collections.emptySet(), "source", Settings.EMPTY)
        ).getMessage());

    assertEquals("no such index",
        expectThrows(IndexNotFoundException.class, () ->
            MetaDataCreateIndexService.validateShrinkIndex(state, "no such index", Collections.emptySet(), "target", Settings.EMPTY)
        ).getMessage());

    assertEquals("can't shrink an index with only one shard",
        expectThrows(IllegalArgumentException.class, () -> MetaDataCreateIndexService.validateShrinkIndex(createClusterState("source",
            1, 0, Settings.builder().put("index.blocks.write", true).build()), "source", Collections.emptySet(),
                    "target", Settings.EMPTY)
        ).getMessage());

    assertEquals("the number of target shards must be less that the number of source shards",
        expectThrows(IllegalArgumentException.class, () -> MetaDataCreateIndexService.validateShrinkIndex(createClusterState("source",
            5, 0, Settings.builder().put("index.blocks.write", true).build()), "source", Collections.emptySet(),
            "target", Settings.builder().put("index.number_of_shards", 10).build())
        ).getMessage());


    assertEquals("index source must be read-only to shrink index. use \"index.blocks.write=true\"",
        expectThrows(IllegalStateException.class, () ->
                MetaDataCreateIndexService.validateShrinkIndex(
                    createClusterState("source", randomIntBetween(2, 100), randomIntBetween(0, 10), Settings.EMPTY)
                    , "source", Collections.emptySet(), "target", Settings.EMPTY)
        ).getMessage());

    assertEquals("index source must have all shards allocated on the same node to shrink index",
        expectThrows(IllegalStateException.class, () ->
            MetaDataCreateIndexService.validateShrinkIndex(state, "source", Collections.emptySet(), "target", Settings.EMPTY)

        ).getMessage());
    assertEquals("the number of source shards [8] must be a must be a multiple of [3]",
        expectThrows(IllegalArgumentException.class, () ->
                MetaDataCreateIndexService.validateShrinkIndex(createClusterState("source", 8, randomIntBetween(0, 10),
                    Settings.builder().put("index.blocks.write", true).build()), "source", Collections.emptySet(), "target",
                    Settings.builder().put("index.number_of_shards", 3).build())
        ).getMessage());

    assertEquals("mappings are not allowed when shrinking indices, all mappings are copied from the source index",
        expectThrows(IllegalArgumentException.class, () -> {
            MetaDataCreateIndexService.validateShrinkIndex(state, "source", Collections.singleton("foo"),
                "target", Settings.EMPTY);
            }
        ).getMessage());

    // create one that won't fail
    ClusterState clusterState = ClusterState.builder(createClusterState("source", numShards, 0,
        Settings.builder().put("index.blocks.write", true).build())).nodes(DiscoveryNodes.builder().add(newNode("node1")))
        .build();
    AllocationService service = new AllocationService(Settings.builder().build(), new AllocationDeciders(Settings.EMPTY,
        Collections.singleton(new MaxRetryAllocationDecider(Settings.EMPTY))),
        new TestGatewayAllocator(), new BalancedShardsAllocator(Settings.EMPTY), EmptyClusterInfoService.INSTANCE);

    RoutingTable routingTable = service.reroute(clusterState, "reroute").routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    // now we start the shard
    routingTable = service.applyStartedShards(clusterState,
        routingTable.index("source").shardsWithState(ShardRoutingState.INITIALIZING)).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    int targetShards;
    do {
        targetShards = randomIntBetween(1, numShards/2);
    } while (isShrinkable(numShards, targetShards) == false);
    MetaDataCreateIndexService.validateShrinkIndex(clusterState, "source", Collections.emptySet(), "target",
        Settings.builder().put("index.number_of_shards", targetShards).build());
}