Java Version.CURRENT属性代码示例

public void testShardActiveDuringInternalRecovery() throws IOException {
    IndexShard shard = newStartedShard(true);
    indexDoc(shard, "type", "0");
    shard = reinitShard(shard);
    DiscoveryNode localNode = new DiscoveryNode("foo", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
    shard.markAsRecovering("for testing", new RecoveryState(shard.routingEntry(), localNode, null));
    // Shard is still inactive since we haven't started recovering yet
    assertFalse(shard.isActive());
    shard.prepareForIndexRecovery();
    // Shard is still inactive since we haven't started recovering yet
    assertFalse(shard.isActive());
    shard.performTranslogRecovery(true);
    // Shard should now be active since we did recover:
    assertTrue(shard.isActive());
    closeShards(shard);
}
 

public void testMainResponseXContent() throws IOException {
    String clusterUUID = randomAsciiOfLengthBetween(10, 20);
    final MainResponse mainResponse = new MainResponse("node1", Version.CURRENT, new ClusterName("cluster1"), clusterUUID,
            Build.CURRENT, false);
    final String expected = "{" +
            "\"name\":\"node1\"," +
            "\"cluster_name\":\"cluster1\"," +
            "\"cluster_uuid\":\"" + clusterUUID + "\"," +
            "\"version\":{" +
            "\"number\":\"" + Version.CURRENT.toString() + "\"," +
            "\"build_hash\":\"" + Build.CURRENT.shortHash() + "\"," +
            "\"build_date\":\"" + Build.CURRENT.date() + "\"," +
            "\"build_snapshot\":" + Build.CURRENT.isSnapshot() +
            ",\"lucene_version\":\"" + Version.CURRENT.luceneVersion.toString() +
            "\"}," +
            "\"tagline\":\"You Know, for Search\"}";

    XContentBuilder builder = XContentFactory.jsonBuilder();
    mainResponse.toXContent(builder, ToXContent.EMPTY_PARAMS);
    String xContent = builder.string();

    assertEquals(expected, xContent);
}
 

@BeforeClass
public static void beforeClass() {
    // we have to prefer CURRENT since with the range of versions we support it's rather unlikely to get the current actually.
    Version indexVersionCreated = randomBoolean() ? Version.CURRENT
            : VersionUtils.randomVersionBetween(random(), null, Version.CURRENT);
    nodeSettings = Settings.builder()
            .put("node.name", AbstractQueryTestCase.class.toString())
            .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir())
            .put(ScriptService.SCRIPT_AUTO_RELOAD_ENABLED_SETTING.getKey(), false)
            .build();
    indexSettings = Settings.builder()
            .put(IndexMetaData.SETTING_VERSION_CREATED, indexVersionCreated).build();

    index = new Index(randomAsciiOfLengthBetween(1, 10), "_na_");

    //create some random type with some default field, those types will stick around for all of the subclasses
    currentTypes = new String[randomIntBetween(0, 5)];
    for (int i = 0; i < currentTypes.length; i++) {
        String type = randomAsciiOfLengthBetween(1, 10);
        currentTypes[i] = type;
    }
    //set some random types to be queried as part the search request, before each test
    randomTypes = getRandomTypes();
}
 

List<DiscoveryNode> generateRandomNodes() {
    int count = scaledRandomIntBetween(1, 100);
    ArrayList<DiscoveryNode> nodes = new ArrayList<>(count);
    for (int i = 0; i < count; i++) {
        Set<DiscoveryNode.Role> roles = new HashSet<>();
        if (randomBoolean()) {
            roles.add(DiscoveryNode.Role.MASTER);
        }
        DiscoveryNode node = new DiscoveryNode("n_" + i, "n_" + i, buildNewFakeTransportAddress(), Collections.emptyMap(),
                roles, Version.CURRENT);
        nodes.add(node);
    }

    Collections.shuffle(nodes, random());
    return nodes;
}
 

public void testDiscoveryNodeSerializationToOldVersion() throws Exception {
    InetAddress inetAddress = InetAddress.getByAddress("name1", new byte[] { (byte) 192, (byte) 168, (byte) 0, (byte) 1});
    TransportAddress transportAddress = new TransportAddress(inetAddress, randomIntBetween(0, 65535));
    DiscoveryNode node = new DiscoveryNode("name1", "id1", transportAddress, emptyMap(), emptySet(), Version.CURRENT);

    BytesStreamOutput streamOutput = new BytesStreamOutput();
    streamOutput.setVersion(Version.V_5_0_0);
    node.writeTo(streamOutput);

    StreamInput in = StreamInput.wrap(streamOutput.bytes().toBytesRef().bytes);
    in.setVersion(Version.V_5_0_0);
    DiscoveryNode serialized = new DiscoveryNode(in);
    assertEquals(transportAddress.address().getHostString(), serialized.getHostName());
    assertEquals(transportAddress.address().getHostString(), serialized.getAddress().address().getHostString());
    assertEquals(transportAddress.getAddress(), serialized.getHostAddress());
    assertEquals(transportAddress.getAddress(), serialized.getAddress().getAddress());
    assertEquals(transportAddress.getPort(), serialized.getAddress().getPort());
    assertFalse("if the minimum compatibility version moves past 5.0.3, remove the special casing in DiscoverNode(StreamInput) and " +
            "the TransportAddress(StreamInput, String) constructor",
        Version.CURRENT.minimumCompatibilityVersion().onOrAfter(Version.V_5_0_3_UNRELEASED));
}
 

public void testDiscoveryNodeIsCreatedWithHostFromInetAddress() throws Exception {
    InetAddress inetAddress = randomBoolean() ? InetAddress.getByName("192.0.2.1") :
        InetAddress.getByAddress("name1", new byte[] { (byte) 192, (byte) 168, (byte) 0, (byte) 1});
    TransportAddress transportAddress = new TransportAddress(inetAddress, randomIntBetween(0, 65535));
    DiscoveryNode node = new DiscoveryNode("name1", "id1", transportAddress, emptyMap(), emptySet(), Version.CURRENT);
    assertEquals(transportAddress.address().getHostString(), node.getHostName());
    assertEquals(transportAddress.getAddress(), node.getHostAddress());
}
 

TimedClusterService createTimedClusterService(boolean makeMaster) throws InterruptedException {
    TimedClusterService timedClusterService = new TimedClusterService(Settings.builder().put("cluster.name",
        "ClusterServiceTests").build(), new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
        threadPool, () -> new DiscoveryNode("node1", buildNewFakeTransportAddress(), emptyMap(),
        emptySet(), Version.CURRENT));
    timedClusterService.setNodeConnectionsService(new NodeConnectionsService(Settings.EMPTY, null, null) {
        @Override
        public void connectToNodes(DiscoveryNodes discoveryNodes) {
            // skip
        }

        @Override
        public void disconnectFromNodesExcept(DiscoveryNodes nodesToKeep) {
            // skip
        }
    });
    timedClusterService.setClusterStatePublisher((event, ackListener) -> {
    });
    timedClusterService.setDiscoverySettings(new DiscoverySettings(Settings.EMPTY,
        new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)));
    timedClusterService.start();
    ClusterState state = timedClusterService.state();
    final DiscoveryNodes nodes = state.nodes();
    final DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder(nodes)
        .masterNodeId(makeMaster ? nodes.getLocalNodeId() : null);
    state = ClusterState.builder(state).blocks(ClusterBlocks.EMPTY_CLUSTER_BLOCK)
        .nodes(nodesBuilder).build();
    setState(timedClusterService, state);
    return timedClusterService;
}
 

@Override
protected ShardUpgradeResult shardOperation(UpgradeRequest request, ShardRouting shardRouting) throws IOException {
    IndexShard indexShard = indicesService.indexServiceSafe(shardRouting.shardId().getIndex()).shardSafe(shardRouting.shardId().id());
    org.apache.lucene.util.Version oldestLuceneSegment = indexShard.upgrade(request);
    // We are using the current version of Elasticsearch as upgrade version since we update mapping to match the current version
    return new ShardUpgradeResult(shardRouting.shardId(), indexShard.routingEntry().primary(), Version.CURRENT, oldestLuceneSegment);
}
 

/** Create a fake NodeStats for the given node and usage */
public static NodeStats makeStats(String nodeName, DiskUsage usage) {
    FsInfo.Path[] paths = new FsInfo.Path[1];
    FsInfo.Path path = new FsInfo.Path("/dev/null", null,
        usage.getTotalBytes(), usage.getFreeBytes(), usage.getFreeBytes());
    paths[0] = path;
    FsInfo fsInfo = new FsInfo(System.currentTimeMillis(), null, paths);
    return new NodeStats(new DiscoveryNode(nodeName, ESTestCase.buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT),
        System.currentTimeMillis(),
        null, null, null, null, null,
        fsInfo,
        null, null, null,
        null, null, null);
}
 

private void addNodes(int count) {
    ClusterState state = clusterService.state();
    final DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder(state.nodes());
    for (int i = 0;i< count;i++) {
        final DiscoveryNode node = new DiscoveryNode("node_" + state.nodes().getSize() + i, buildNewFakeTransportAddress(),
            emptyMap(), new HashSet<>(randomSubsetOf(Arrays.asList(DiscoveryNode.Role.values()))), Version.CURRENT);
        nodesBuilder.add(node);
    }
    setState(clusterService, ClusterState.builder(state).nodes(nodesBuilder));
}
 

/**
 * Elasticsearch v6.0 no longer supports indices created pre v5.0. All indices
 * that were created before Elasticsearch v5.0 should be re-indexed in Elasticsearch 5.x
 * before they can be opened by this version of elasticsearch.
 */
private void checkSupportedVersion(IndexMetaData indexMetaData, Version minimumIndexCompatibilityVersion) {
    if (indexMetaData.getState() == IndexMetaData.State.OPEN && isSupportedVersion(indexMetaData,
        minimumIndexCompatibilityVersion) == false) {
        throw new IllegalStateException("The index [" + indexMetaData.getIndex() + "] was created with version ["
            + indexMetaData.getCreationVersion() + "] but the minimum compatible version is ["

            + minimumIndexCompatibilityVersion + "]. It should be re-indexed in Elasticsearch " + minimumIndexCompatibilityVersion.major
            + ".x before upgrading to " + Version.CURRENT + ".");
    }
}
 

public void testSerialization() throws IOException {
    DiscoveryNode node = new DiscoveryNode("node1", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
    Decision decision = randomFrom(Decision.YES, Decision.THROTTLE, Decision.NO);
    NodeAllocationResult explanation = new NodeAllocationResult(node, decision, 1);
    BytesStreamOutput output = new BytesStreamOutput();
    explanation.writeTo(output);
    NodeAllocationResult readExplanation = new NodeAllocationResult(output.bytes().streamInput());
    assertNodeExplanationEquals(explanation, readExplanation);
}
 

/**
 * Checks that snapshots can be restored and have compatible version
 *
 * @param snapshotId snapshot id
 * @param snapshot   snapshot metadata
 */
private void validateSnapshotRestorable(SnapshotId snapshotId, Snapshot snapshot) {
    if (!snapshot.state().restorable()) {
        throw new SnapshotRestoreException(snapshotId, "unsupported snapshot state [" + snapshot.state() + "]");
    }
    if (Version.CURRENT.before(snapshot.version())) {
        throw new SnapshotRestoreException(snapshotId, "the snapshot was created with Elasticsearch version [" +
                snapshot.version() + "] which is higher than the version of this node [" + Version.CURRENT + "]");
    }
}
 

public void testCachedDecisions() {
    // cached stay decision
    MoveDecision stay1 = MoveDecision.stay(null);
    MoveDecision stay2 = MoveDecision.stay(null);
    assertSame(stay1, stay2); // not in explain mode, so should use cached decision
    stay1 = MoveDecision.stay(Decision.YES);
    stay2 = MoveDecision.stay(Decision.YES);
    assertNotSame(stay1, stay2);

    // cached cannot move decision
    stay1 = MoveDecision.cannotRemain(Decision.NO, AllocationDecision.NO, null, null);
    stay2 = MoveDecision.cannotRemain(Decision.NO, AllocationDecision.NO, null, null);
    assertSame(stay1, stay2);
    // final decision is YES, so shouldn't use cached decision
    DiscoveryNode node1 = new DiscoveryNode("node1", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
    stay1 = MoveDecision.cannotRemain(Decision.NO, AllocationDecision.YES, node1, null);
    stay2 = MoveDecision.cannotRemain(Decision.NO, AllocationDecision.YES, node1, null);
    assertNotSame(stay1, stay2);
    assertEquals(stay1.getTargetNode(), stay2.getTargetNode());
    // final decision is NO, but in explain mode, so shouldn't use cached decision
    stay1 = MoveDecision.cannotRemain(Decision.NO, AllocationDecision.NO, null, new ArrayList<>());
    stay2 = MoveDecision.cannotRemain(Decision.NO, AllocationDecision.NO, null, new ArrayList<>());
    assertNotSame(stay1, stay2);
    assertSame(stay1.getAllocationDecision(), stay2.getAllocationDecision());
    assertNotNull(stay1.getExplanation());
    assertEquals(stay1.getExplanation(), stay2.getExplanation());
}
 

public void testFailIfIndexNotPresentInRecoverFromStore() throws Exception {
    final IndexShard shard = newStartedShard(true);
    indexDoc(shard, "test", "0");
    if (randomBoolean()) {
        flushShard(shard);
    }

    Store store = shard.store();
    store.incRef();
    closeShards(shard);
    cleanLuceneIndex(store.directory());
    store.decRef();
    IndexShard newShard = reinitShard(shard);
    DiscoveryNode localNode = new DiscoveryNode("foo", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
    ShardRouting routing = newShard.routingEntry();
    newShard.markAsRecovering("store", new RecoveryState(routing, localNode, null));
    try {
        newShard.recoverFromStore();
        fail("index not there!");
    } catch (IndexShardRecoveryException ex) {
        assertTrue(ex.getMessage().contains("failed to fetch index version after copying it over"));
    }

    routing = ShardRoutingHelper.moveToUnassigned(routing, new UnassignedInfo(UnassignedInfo.Reason.INDEX_CREATED, "because I say so"));
    routing = ShardRoutingHelper.initialize(routing, newShard.routingEntry().currentNodeId());
    assertTrue("it's already recovering, we should ignore new ones", newShard.ignoreRecoveryAttempt());
    try {
        newShard.markAsRecovering("store", new RecoveryState(routing, localNode, null));
        fail("we are already recovering, can't mark again");
    } catch (IllegalIndexShardStateException e) {
        // OK!
    }

    newShard = reinitShard(newShard,
        ShardRoutingHelper.initWithSameId(routing, RecoverySource.StoreRecoverySource.EMPTY_STORE_INSTANCE));
    newShard.markAsRecovering("store", new RecoveryState(newShard.routingEntry(), localNode, null));
    assertTrue("recover even if there is nothing to recover", newShard.recoverFromStore());

    newShard.updateRoutingEntry(newShard.routingEntry().moveToStarted());
    assertDocCount(newShard, 0);
    // we can't issue this request through a client because of the inconsistencies we created with the cluster state
    // doing it directly instead
    indexDoc(newShard, "test", "0");
    newShard.refresh("test");
    assertDocCount(newShard, 1);

    closeShards(newShard);
}