Examples with VersionType org.opensearch.index.VersionType used on opensource projects

Example 6 with VersionType

use of org.opensearch.index.VersionType in project OpenSearch by opensearch-project.

the class RandomDocumentPicks method randomIngestDocument.

/**
 * Generates a document that holds random metadata and the document provided as a map argument
 */
public static IngestDocument randomIngestDocument(Random random, Map<String, Object> source) {
    String index = randomString(random);
    String id = randomString(random);
    String routing = null;
    Long version = randomNonNegtiveLong(random);
    VersionType versionType = RandomPicks.randomFrom(random, new VersionType[] { VersionType.INTERNAL, VersionType.EXTERNAL, VersionType.EXTERNAL_GTE });
    if (random.nextBoolean()) {
        routing = randomString(random);
    }
    return new IngestDocument(index, id, routing, version, versionType, source);
}

Example 7 with VersionType

use of org.opensearch.index.VersionType in project OpenSearch by opensearch-project.

the class IngestServiceTests method testExecutePropagateAllMetadataUpdates.

public void testExecutePropagateAllMetadataUpdates() throws Exception {
    final CompoundProcessor processor = mockCompoundProcessor();
    IngestService ingestService = createWithProcessors(Collections.singletonMap("mock", (factories, tag, description, config) -> processor));
    PutPipelineRequest putRequest = new PutPipelineRequest("_id", new BytesArray("{\"processors\": [{\"mock\" : {}}]}"), XContentType.JSON);
    // Start empty
    ClusterState clusterState = ClusterState.builder(new ClusterName("_name")).build();
    ClusterState previousClusterState = clusterState;
    clusterState = IngestService.innerPut(putRequest, clusterState);
    ingestService.applyClusterState(new ClusterChangedEvent("", clusterState, previousClusterState));
    final long newVersion = randomLong();
    final String versionType = randomFrom("internal", "external", "external_gt", "external_gte");
    final long ifSeqNo = randomNonNegativeLong();
    final long ifPrimaryTerm = randomNonNegativeLong();
    doAnswer((InvocationOnMock invocationOnMock) -> {
        IngestDocument ingestDocument = (IngestDocument) invocationOnMock.getArguments()[0];
        for (IngestDocument.Metadata metadata : IngestDocument.Metadata.values()) {
            if (metadata == IngestDocument.Metadata.VERSION) {
                ingestDocument.setFieldValue(metadata.getFieldName(), newVersion);
            } else if (metadata == IngestDocument.Metadata.VERSION_TYPE) {
                ingestDocument.setFieldValue(metadata.getFieldName(), versionType);
            } else if (metadata == IngestDocument.Metadata.IF_SEQ_NO) {
                ingestDocument.setFieldValue(metadata.getFieldName(), ifSeqNo);
            } else if (metadata == IngestDocument.Metadata.IF_PRIMARY_TERM) {
                ingestDocument.setFieldValue(metadata.getFieldName(), ifPrimaryTerm);
            } else {
                ingestDocument.setFieldValue(metadata.getFieldName(), "update" + metadata.getFieldName());
            }
        }
        @SuppressWarnings("unchecked") BiConsumer<IngestDocument, Exception> handler = (BiConsumer<IngestDocument, Exception>) invocationOnMock.getArguments()[1];
        handler.accept(ingestDocument, null);
        return null;
    }).when(processor).execute(any(), any());
    final IndexRequest indexRequest = new IndexRequest("_index").id("_id").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
    @SuppressWarnings("unchecked") final BiConsumer<Integer, Exception> failureHandler = mock(BiConsumer.class);
    @SuppressWarnings("unchecked") final BiConsumer<Thread, Exception> completionHandler = mock(BiConsumer.class);
    ingestService.executeBulkRequest(1, Collections.singletonList(indexRequest), failureHandler, completionHandler, indexReq -> {
    }, Names.WRITE);
    verify(processor).execute(any(), any());
    verify(failureHandler, never()).accept(any(), any());
    verify(completionHandler, times(1)).accept(Thread.currentThread(), null);
    assertThat(indexRequest.index(), equalTo("update_index"));
    assertThat(indexRequest.id(), equalTo("update_id"));
    assertThat(indexRequest.routing(), equalTo("update_routing"));
    assertThat(indexRequest.version(), equalTo(newVersion));
    assertThat(indexRequest.versionType(), equalTo(VersionType.fromString(versionType)));
    assertThat(indexRequest.ifSeqNo(), equalTo(ifSeqNo));
    assertThat(indexRequest.ifPrimaryTerm(), equalTo(ifPrimaryTerm));
}

Example 8 with VersionType

use of org.opensearch.index.VersionType in project OpenSearch by opensearch-project.

the class InternalEngineTests method testNonInternalVersioningOnPrimary.

public void testNonInternalVersioningOnPrimary() throws IOException {
    final Set<VersionType> nonInternalVersioning = new HashSet<>(Arrays.asList(VersionType.values()));
    nonInternalVersioning.remove(VersionType.INTERNAL);
    final VersionType versionType = randomFrom(nonInternalVersioning);
    final List<Engine.Operation> ops = generateSingleDocHistory(false, versionType, 2, 2, 20, "1");
    final Engine.Operation lastOp = ops.get(ops.size() - 1);
    final String lastFieldValue;
    if (lastOp instanceof Engine.Index) {
        Engine.Index index = (Engine.Index) lastOp;
        lastFieldValue = index.docs().get(0).get("value");
    } else {
        // delete
        lastFieldValue = null;
    }
    // other version types don't support out of order processing.
    if (versionType == VersionType.EXTERNAL) {
        shuffle(ops, random());
    }
    long highestOpVersion = Versions.NOT_FOUND;
    long seqNo = -1;
    boolean docDeleted = true;
    for (Engine.Operation op : ops) {
        logger.info("performing [{}], v [{}], seq# [{}], term [{}]", op.operationType().name().charAt(0), op.version(), op.seqNo(), op.primaryTerm());
        if (op instanceof Engine.Index) {
            final Engine.Index index = (Engine.Index) op;
            Engine.IndexResult result = engine.index(index);
            if (op.versionType().isVersionConflictForWrites(highestOpVersion, op.version(), docDeleted) == false) {
                seqNo++;
                assertThat(result.getSeqNo(), equalTo(seqNo));
                assertThat(result.isCreated(), equalTo(docDeleted));
                assertThat(result.getVersion(), equalTo(op.version()));
                assertThat(result.getResultType(), equalTo(Engine.Result.Type.SUCCESS));
                assertThat(result.getFailure(), nullValue());
                docDeleted = false;
                highestOpVersion = op.version();
            } else {
                assertThat(result.isCreated(), equalTo(false));
                assertThat(result.getVersion(), equalTo(highestOpVersion));
                assertThat(result.getResultType(), equalTo(Engine.Result.Type.FAILURE));
                assertThat(result.getFailure(), instanceOf(VersionConflictEngineException.class));
                assertThat(result.getFailure().getStackTrace(), emptyArray());
            }
        } else {
            final Engine.Delete delete = (Engine.Delete) op;
            Engine.DeleteResult result = engine.delete(delete);
            if (op.versionType().isVersionConflictForWrites(highestOpVersion, op.version(), docDeleted) == false) {
                seqNo++;
                assertThat(result.getSeqNo(), equalTo(seqNo));
                assertThat(result.isFound(), equalTo(docDeleted == false));
                assertThat(result.getVersion(), equalTo(op.version()));
                assertThat(result.getResultType(), equalTo(Engine.Result.Type.SUCCESS));
                assertThat(result.getFailure(), nullValue());
                docDeleted = true;
                highestOpVersion = op.version();
            } else {
                assertThat(result.isFound(), equalTo(docDeleted == false));
                assertThat(result.getVersion(), equalTo(highestOpVersion));
                assertThat(result.getResultType(), equalTo(Engine.Result.Type.FAILURE));
                assertThat(result.getFailure(), instanceOf(VersionConflictEngineException.class));
                assertThat(result.getFailure().getStackTrace(), emptyArray());
            }
        }
        if (randomBoolean()) {
            engine.refresh("test");
        }
        if (randomBoolean()) {
            engine.flush();
            engine.refresh("test");
        }
    }
    assertVisibleCount(engine, docDeleted ? 0 : 1);
    if (docDeleted == false) {
        logger.info("searching for [{}]", lastFieldValue);
        try (Engine.Searcher searcher = engine.acquireSearcher("test")) {
            final TotalHitCountCollector collector = new TotalHitCountCollector();
            searcher.search(new TermQuery(new Term("value", lastFieldValue)), collector);
            assertThat(collector.getTotalHits(), equalTo(1));
        }
    }
}

Example 9 with VersionType

use of org.opensearch.index.VersionType in project OpenSearch by opensearch-project.

the class TranslogHandler method convertToEngineOp.

public Engine.Operation convertToEngineOp(Translog.Operation operation, Engine.Operation.Origin origin) {
    // If a translog op is replayed on the primary (eg. ccr), we need to use external instead of null for its version type.
    final VersionType versionType = (origin == Engine.Operation.Origin.PRIMARY) ? VersionType.EXTERNAL : null;
    switch(operation.opType()) {
        case INDEX:
            final Translog.Index index = (Translog.Index) operation;
            final String indexName = mapperService.index().getName();
            final Engine.Index engineIndex = IndexShard.prepareIndex(docMapper(MapperService.SINGLE_MAPPING_NAME), new SourceToParse(indexName, index.id(), index.source(), XContentHelper.xContentType(index.source()), index.routing()), index.seqNo(), index.primaryTerm(), index.version(), versionType, origin, index.getAutoGeneratedIdTimestamp(), true, SequenceNumbers.UNASSIGNED_SEQ_NO, SequenceNumbers.UNASSIGNED_PRIMARY_TERM);
            return engineIndex;
        case DELETE:
            final Translog.Delete delete = (Translog.Delete) operation;
            return IndexShard.prepareDelete(delete.id(), delete.seqNo(), delete.primaryTerm(), delete.version(), versionType, origin, SequenceNumbers.UNASSIGNED_SEQ_NO, SequenceNumbers.UNASSIGNED_PRIMARY_TERM);
        case NO_OP:
            final Translog.NoOp noOp = (Translog.NoOp) operation;
            final Engine.NoOp engineNoOp = new Engine.NoOp(noOp.seqNo(), noOp.primaryTerm(), origin, System.nanoTime(), noOp.reason());
            return engineNoOp;
        default:
            throw new IllegalStateException("No operation defined for [" + operation + "]");
    }
}

Example 10 with VersionType

use of org.opensearch.index.VersionType in project OpenSearch by opensearch-project.

the class RequestConvertersTests method setRandomVersionType.

private static void setRandomVersionType(Consumer<VersionType> setter, Map<String, String> expectedParams) {
    if (randomBoolean()) {
        VersionType versionType = randomFrom(VersionType.values());
        setter.accept(versionType);
        if (versionType != VersionType.INTERNAL) {
            expectedParams.put("version_type", versionType.name().toLowerCase(Locale.ROOT));
        }
    }
}