Examples with Version org.opensearch.Version used on opensource projects

Example 26 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class JoinTaskExecutor method execute.

@Override
public ClusterTasksResult<Task> execute(ClusterState currentState, List<Task> joiningNodes) throws Exception {
    final ClusterTasksResult.Builder<Task> results = ClusterTasksResult.builder();
    final DiscoveryNodes currentNodes = currentState.nodes();
    boolean nodesChanged = false;
    ClusterState.Builder newState;
    if (joiningNodes.size() == 1 && joiningNodes.get(0).isFinishElectionTask()) {
        return results.successes(joiningNodes).build(currentState);
    } else if (currentNodes.getMasterNode() == null && joiningNodes.stream().anyMatch(Task::isBecomeMasterTask)) {
        assert joiningNodes.stream().anyMatch(Task::isFinishElectionTask) : "becoming a master but election is not finished " + joiningNodes;
        // use these joins to try and become the master.
        // Note that we don't have to do any validation of the amount of joining nodes - the commit
        // during the cluster state publishing guarantees that we have enough
        newState = becomeMasterAndTrimConflictingNodes(currentState, joiningNodes);
        nodesChanged = true;
    } else if (currentNodes.isLocalNodeElectedMaster() == false) {
        logger.trace("processing node joins, but we are not the master. current master: {}", currentNodes.getMasterNode());
        throw new NotMasterException("Node [" + currentNodes.getLocalNode() + "] not master for join request");
    } else {
        newState = ClusterState.builder(currentState);
    }
    DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder(newState.nodes());
    assert nodesBuilder.isLocalNodeElectedMaster();
    Version minClusterNodeVersion = newState.nodes().getMinNodeVersion();
    Version maxClusterNodeVersion = newState.nodes().getMaxNodeVersion();
    // we only enforce major version transitions on a fully formed clusters
    final boolean enforceMajorVersion = currentState.getBlocks().hasGlobalBlock(STATE_NOT_RECOVERED_BLOCK) == false;
    // processing any joins
    Map<String, String> joiniedNodeNameIds = new HashMap<>();
    for (final Task joinTask : joiningNodes) {
        if (joinTask.isBecomeMasterTask() || joinTask.isFinishElectionTask()) {
        // noop
        } else if (currentNodes.nodeExistsWithSameRoles(joinTask.node()) && !currentNodes.nodeExistsWithBWCVersion(joinTask.node())) {
            logger.debug("received a join request for an existing node [{}]", joinTask.node());
        } else {
            final DiscoveryNode node = joinTask.node();
            try {
                if (enforceMajorVersion) {
                    ensureMajorVersionBarrier(node.getVersion(), minClusterNodeVersion);
                }
                ensureNodesCompatibility(node.getVersion(), minClusterNodeVersion, maxClusterNodeVersion);
                // we do this validation quite late to prevent race conditions between nodes joining and importing dangling indices
                // we have to reject nodes that don't support all indices we have in this cluster
                ensureIndexCompatibility(node.getVersion(), currentState.getMetadata());
                nodesBuilder.add(node);
                nodesChanged = true;
                minClusterNodeVersion = Version.min(minClusterNodeVersion, node.getVersion());
                maxClusterNodeVersion = Version.max(maxClusterNodeVersion, node.getVersion());
                if (node.isMasterNode()) {
                    joiniedNodeNameIds.put(node.getName(), node.getId());
                }
            } catch (IllegalArgumentException | IllegalStateException e) {
                results.failure(joinTask, e);
                continue;
            }
        }
        results.success(joinTask);
    }
    if (nodesChanged) {
        rerouteService.reroute("post-join reroute", Priority.HIGH, ActionListener.wrap(r -> logger.trace("post-join reroute completed"), e -> logger.debug("post-join reroute failed", e)));
        if (joiniedNodeNameIds.isEmpty() == false) {
            Set<CoordinationMetadata.VotingConfigExclusion> currentVotingConfigExclusions = currentState.getVotingConfigExclusions();
            Set<CoordinationMetadata.VotingConfigExclusion> newVotingConfigExclusions = currentVotingConfigExclusions.stream().map(e -> {
                // Update nodeId in VotingConfigExclusion when a new node with excluded node name joins
                if (CoordinationMetadata.VotingConfigExclusion.MISSING_VALUE_MARKER.equals(e.getNodeId()) && joiniedNodeNameIds.containsKey(e.getNodeName())) {
                    return new CoordinationMetadata.VotingConfigExclusion(joiniedNodeNameIds.get(e.getNodeName()), e.getNodeName());
                } else {
                    return e;
                }
            }).collect(Collectors.toSet());
            // if VotingConfigExclusions did get updated
            if (newVotingConfigExclusions.equals(currentVotingConfigExclusions) == false) {
                CoordinationMetadata.Builder coordMetadataBuilder = CoordinationMetadata.builder(currentState.coordinationMetadata()).clearVotingConfigExclusions();
                newVotingConfigExclusions.forEach(coordMetadataBuilder::addVotingConfigExclusion);
                Metadata newMetadata = Metadata.builder(currentState.metadata()).coordinationMetadata(coordMetadataBuilder.build()).build();
                return results.build(allocationService.adaptAutoExpandReplicas(newState.nodes(nodesBuilder).metadata(newMetadata).build()));
            }
        }
        return results.build(allocationService.adaptAutoExpandReplicas(newState.nodes(nodesBuilder).build()));
    } else {
        // for the joining node to finalize its join and set us as a master
        return results.build(newState.build());
    }
}

Example 27 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class PercolateQueryBuilder method createStore.

static PercolateQuery.QueryStore createStore(MappedFieldType queryBuilderFieldType, QueryShardContext context) {
    Version indexVersion = context.indexVersionCreated();
    NamedWriteableRegistry registry = context.getWriteableRegistry();
    return ctx -> {
        LeafReader leafReader = ctx.reader();
        BinaryDocValues binaryDocValues = leafReader.getBinaryDocValues(queryBuilderFieldType.name());
        if (binaryDocValues == null) {
            return docId -> null;
        }
        return docId -> {
            if (binaryDocValues.advanceExact(docId)) {
                BytesRef qbSource = binaryDocValues.binaryValue();
                try (InputStream in = new ByteArrayInputStream(qbSource.bytes, qbSource.offset, qbSource.length)) {
                    try (StreamInput input = new NamedWriteableAwareStreamInput(new InputStreamStreamInput(in, qbSource.length), registry)) {
                        input.setVersion(indexVersion);
                        // Query builder's content is stored via BinaryFieldMapper, which has a custom encoding
                        // to encode multiple binary values into a single binary doc values field.
                        // This is the reason we need to first need to read the number of values and
                        // then the length of the field value in bytes.
                        int numValues = input.readVInt();
                        assert numValues == 1;
                        int valueLength = input.readVInt();
                        assert valueLength > 0;
                        QueryBuilder queryBuilder = input.readNamedWriteable(QueryBuilder.class);
                        assert in.read() == -1;
                        queryBuilder = Rewriteable.rewrite(queryBuilder, context);
                        return queryBuilder.toQuery(context);
                    }
                }
            } else {
                return null;
            }
        };
    };
}

Example 28 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class CandidateQueryTests method testDuplicatedClauses.

public void testDuplicatedClauses() throws Exception {
    List<ParseContext.Document> docs = new ArrayList<>();
    BooleanQuery.Builder builder = new BooleanQuery.Builder();
    BooleanQuery.Builder builder1 = new BooleanQuery.Builder();
    builder1.add(new TermQuery(new Term("field", "value1")), Occur.MUST);
    builder1.add(new TermQuery(new Term("field", "value2")), Occur.MUST);
    builder.add(builder1.build(), Occur.MUST);
    BooleanQuery.Builder builder2 = new BooleanQuery.Builder();
    builder2.add(new TermQuery(new Term("field", "value2")), Occur.MUST);
    builder2.add(new TermQuery(new Term("field", "value3")), Occur.MUST);
    builder.add(builder2.build(), Occur.MUST);
    addQuery(builder.build(), docs);
    builder = new BooleanQuery.Builder().setMinimumNumberShouldMatch(2);
    builder1 = new BooleanQuery.Builder();
    builder1.add(new TermQuery(new Term("field", "value1")), Occur.MUST);
    builder1.add(new TermQuery(new Term("field", "value2")), Occur.MUST);
    builder.add(builder1.build(), Occur.SHOULD);
    builder2 = new BooleanQuery.Builder();
    builder2.add(new TermQuery(new Term("field", "value2")), Occur.MUST);
    builder2.add(new TermQuery(new Term("field", "value3")), Occur.MUST);
    builder.add(builder2.build(), Occur.SHOULD);
    BooleanQuery.Builder builder3 = new BooleanQuery.Builder();
    builder3.add(new TermQuery(new Term("field", "value3")), Occur.MUST);
    builder3.add(new TermQuery(new Term("field", "value4")), Occur.MUST);
    builder.add(builder3.build(), Occur.SHOULD);
    addQuery(builder.build(), docs);
    indexWriter.addDocuments(docs);
    indexWriter.close();
    directoryReader = DirectoryReader.open(directory);
    IndexSearcher shardSearcher = newSearcher(directoryReader);
    shardSearcher.setQueryCache(null);
    Version v = Version.CURRENT;
    List<BytesReference> sources = Collections.singletonList(new BytesArray("{}"));
    MemoryIndex memoryIndex = new MemoryIndex();
    memoryIndex.addField("field", "value1 value2 value3", new WhitespaceAnalyzer());
    IndexSearcher percolateSearcher = memoryIndex.createSearcher();
    PercolateQuery query = (PercolateQuery) fieldType.percolateQuery("_name", queryStore, sources, percolateSearcher, false, v);
    TopDocs topDocs = shardSearcher.search(query, 10, new Sort(SortField.FIELD_DOC));
    assertEquals(2L, topDocs.totalHits.value);
    assertEquals(0, topDocs.scoreDocs[0].doc);
    assertEquals(1, topDocs.scoreDocs[1].doc);
}

Example 29 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class HasChildQueryBuilderTests method testSerializationBWC.

/**
 * Test (de)serialization on all previous released versions
 */
public void testSerializationBWC() throws IOException {
    for (Version version : VersionUtils.allReleasedVersions()) {
        HasChildQueryBuilder testQuery = createTestQueryBuilder();
        assertSerialization(testQuery, version);
    }
}

Example 30 with Version

use of org.opensearch.Version in project OpenSearch by opensearch-project.

the class VerifyVersionConstantsIT method testLuceneVersionConstant.

public void testLuceneVersionConstant() throws IOException, ParseException {
    final Response response = client().performRequest(new Request("GET", "/"));
    assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
    final ObjectPath objectPath = ObjectPath.createFromResponse(response);
    final String opensearchVersionString = objectPath.evaluate("version.number").toString();
    final Version opensearchVersion = Version.fromString(opensearchVersionString.replace("-SNAPSHOT", ""));
    final String luceneVersionString = objectPath.evaluate("version.lucene_version").toString();
    final org.apache.lucene.util.Version luceneVersion = org.apache.lucene.util.Version.parse(luceneVersionString);
    assertThat(opensearchVersion.luceneVersion, equalTo(luceneVersion));
}