Examples with VersionConflictEngineException org.elasticsearch.index.engine.VersionConflictEngineException used on opensource projects

Example 1 with VersionConflictEngineException

use of org.elasticsearch.index.engine.VersionConflictEngineException in project elasticsearch by elastic.

the class GetActionIT method testGetWithVersion.

public void testGetWithVersion() {
    assertAcked(prepareCreate("test").addAlias(new Alias("alias")).setSettings(Settings.builder().put("index.refresh_interval", -1)));
    ensureGreen();
    GetResponse response = client().prepareGet("test", "type1", "1").get();
    assertThat(response.isExists(), equalTo(false));
    logger.info("--> index doc 1");
    client().prepareIndex("test", "type1", "1").setSource("field1", "value1", "field2", "value2").get();
    // From translog:
    response = client().prepareGet(indexOrAlias(), "type1", "1").setVersion(Versions.MATCH_ANY).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getVersion(), equalTo(1L));
    response = client().prepareGet(indexOrAlias(), "type1", "1").setVersion(1).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getVersion(), equalTo(1L));
    try {
        client().prepareGet(indexOrAlias(), "type1", "1").setVersion(2).get();
        fail();
    } catch (VersionConflictEngineException e) {
    //all good
    }
    // From Lucene index:
    refresh();
    response = client().prepareGet(indexOrAlias(), "type1", "1").setVersion(Versions.MATCH_ANY).setRealtime(false).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(1L));
    response = client().prepareGet(indexOrAlias(), "type1", "1").setVersion(1).setRealtime(false).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(1L));
    try {
        client().prepareGet(indexOrAlias(), "type1", "1").setVersion(2).setRealtime(false).get();
        fail();
    } catch (VersionConflictEngineException e) {
    //all good
    }
    logger.info("--> index doc 1 again, so increasing the version");
    client().prepareIndex("test", "type1", "1").setSource("field1", "value1", "field2", "value2").get();
    // From translog:
    response = client().prepareGet(indexOrAlias(), "type1", "1").setVersion(Versions.MATCH_ANY).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(2L));
    try {
        client().prepareGet(indexOrAlias(), "type1", "1").setVersion(1).get();
        fail();
    } catch (VersionConflictEngineException e) {
    //all good
    }
    response = client().prepareGet(indexOrAlias(), "type1", "1").setVersion(2).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(2L));
    // From Lucene index:
    refresh();
    response = client().prepareGet(indexOrAlias(), "type1", "1").setVersion(Versions.MATCH_ANY).setRealtime(false).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(2L));
    try {
        client().prepareGet(indexOrAlias(), "type1", "1").setVersion(1).setRealtime(false).get();
        fail();
    } catch (VersionConflictEngineException e) {
    //all good
    }
    response = client().prepareGet(indexOrAlias(), "type1", "1").setVersion(2).setRealtime(false).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(2L));
}

Example 2 with VersionConflictEngineException

use of org.elasticsearch.index.engine.VersionConflictEngineException in project elasticsearch by elastic.

the class GetTermVectorsIT method testTermVectorsWithVersion.

public void testTermVectorsWithVersion() {
    assertAcked(prepareCreate("test").addAlias(new Alias("alias")).setSettings(Settings.builder().put("index.refresh_interval", -1)));
    ensureGreen();
    TermVectorsResponse response = client().prepareTermVectors("test", "type1", "1").get();
    assertThat(response.isExists(), equalTo(false));
    logger.info("--> index doc 1");
    client().prepareIndex("test", "type1", "1").setSource("field1", "value1", "field2", "value2").get();
    // From translog:
    // version 0 means ignore version, which is the default
    response = client().prepareTermVectors(indexOrAlias(), "type1", "1").setVersion(Versions.MATCH_ANY).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getVersion(), equalTo(1L));
    response = client().prepareTermVectors(indexOrAlias(), "type1", "1").setVersion(1).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getVersion(), equalTo(1L));
    try {
        client().prepareGet(indexOrAlias(), "type1", "1").setVersion(2).get();
        fail();
    } catch (VersionConflictEngineException e) {
    //all good
    }
    // From Lucene index:
    refresh();
    // version 0 means ignore version, which is the default
    response = client().prepareTermVectors(indexOrAlias(), "type1", "1").setVersion(Versions.MATCH_ANY).setRealtime(false).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(1L));
    response = client().prepareTermVectors(indexOrAlias(), "type1", "1").setVersion(1).setRealtime(false).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(1L));
    try {
        client().prepareGet(indexOrAlias(), "type1", "1").setVersion(2).setRealtime(false).get();
        fail();
    } catch (VersionConflictEngineException e) {
    //all good
    }
    logger.info("--> index doc 1 again, so increasing the version");
    client().prepareIndex("test", "type1", "1").setSource("field1", "value1", "field2", "value2").get();
    // From translog:
    // version 0 means ignore version, which is the default
    response = client().prepareTermVectors(indexOrAlias(), "type1", "1").setVersion(Versions.MATCH_ANY).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(2L));
    try {
        client().prepareGet(indexOrAlias(), "type1", "1").setVersion(1).get();
        fail();
    } catch (VersionConflictEngineException e) {
    //all good
    }
    response = client().prepareTermVectors(indexOrAlias(), "type1", "1").setVersion(2).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(2L));
    // From Lucene index:
    refresh();
    // version 0 means ignore version, which is the default
    response = client().prepareTermVectors(indexOrAlias(), "type1", "1").setVersion(Versions.MATCH_ANY).setRealtime(false).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(2L));
    try {
        client().prepareGet(indexOrAlias(), "type1", "1").setVersion(1).setRealtime(false).get();
        fail();
    } catch (VersionConflictEngineException e) {
    //all good
    }
    response = client().prepareTermVectors(indexOrAlias(), "type1", "1").setVersion(2).setRealtime(false).get();
    assertThat(response.isExists(), equalTo(true));
    assertThat(response.getId(), equalTo("1"));
    assertThat(response.getIndex(), equalTo("test"));
    assertThat(response.getVersion(), equalTo(2L));
}

Example 3 with VersionConflictEngineException

use of org.elasticsearch.index.engine.VersionConflictEngineException in project elasticsearch by elastic.

the class IndexStatsIT method testSimpleStats.

public void testSimpleStats() throws Exception {
    createIndex("test1", "test2");
    ensureGreen();
    client().prepareIndex("test1", "type1", Integer.toString(1)).setSource("field", "value").execute().actionGet();
    client().prepareIndex("test1", "type2", Integer.toString(1)).setSource("field", "value").execute().actionGet();
    client().prepareIndex("test2", "type", Integer.toString(1)).setSource("field", "value").execute().actionGet();
    refresh();
    NumShards test1 = getNumShards("test1");
    long test1ExpectedWrites = 2 * test1.dataCopies;
    NumShards test2 = getNumShards("test2");
    long test2ExpectedWrites = test2.dataCopies;
    long totalExpectedWrites = test1ExpectedWrites + test2ExpectedWrites;
    IndicesStatsResponse stats = client().admin().indices().prepareStats().execute().actionGet();
    assertThat(stats.getPrimaries().getDocs().getCount(), equalTo(3L));
    assertThat(stats.getTotal().getDocs().getCount(), equalTo(totalExpectedWrites));
    assertThat(stats.getPrimaries().getIndexing().getTotal().getIndexCount(), equalTo(3L));
    assertThat(stats.getPrimaries().getIndexing().getTotal().getIndexFailedCount(), equalTo(0L));
    assertThat(stats.getPrimaries().getIndexing().getTotal().isThrottled(), equalTo(false));
    assertThat(stats.getPrimaries().getIndexing().getTotal().getThrottleTime().millis(), equalTo(0L));
    assertThat(stats.getTotal().getIndexing().getTotal().getIndexCount(), equalTo(totalExpectedWrites));
    assertThat(stats.getTotal().getStore(), notNullValue());
    assertThat(stats.getTotal().getMerge(), notNullValue());
    assertThat(stats.getTotal().getFlush(), notNullValue());
    assertThat(stats.getTotal().getRefresh(), notNullValue());
    assertThat(stats.getIndex("test1").getPrimaries().getDocs().getCount(), equalTo(2L));
    assertThat(stats.getIndex("test1").getTotal().getDocs().getCount(), equalTo(test1ExpectedWrites));
    assertThat(stats.getIndex("test1").getPrimaries().getStore(), notNullValue());
    assertThat(stats.getIndex("test1").getPrimaries().getMerge(), notNullValue());
    assertThat(stats.getIndex("test1").getPrimaries().getFlush(), notNullValue());
    assertThat(stats.getIndex("test1").getPrimaries().getRefresh(), notNullValue());
    assertThat(stats.getIndex("test2").getPrimaries().getDocs().getCount(), equalTo(1L));
    assertThat(stats.getIndex("test2").getTotal().getDocs().getCount(), equalTo(test2ExpectedWrites));
    // make sure that number of requests in progress is 0
    assertThat(stats.getIndex("test1").getTotal().getIndexing().getTotal().getIndexCurrent(), equalTo(0L));
    assertThat(stats.getIndex("test1").getTotal().getIndexing().getTotal().getDeleteCurrent(), equalTo(0L));
    assertThat(stats.getIndex("test1").getTotal().getSearch().getTotal().getFetchCurrent(), equalTo(0L));
    assertThat(stats.getIndex("test1").getTotal().getSearch().getTotal().getQueryCurrent(), equalTo(0L));
    // check flags
    stats = client().admin().indices().prepareStats().clear().setFlush(true).setRefresh(true).setMerge(true).execute().actionGet();
    assertThat(stats.getTotal().getDocs(), nullValue());
    assertThat(stats.getTotal().getStore(), nullValue());
    assertThat(stats.getTotal().getIndexing(), nullValue());
    assertThat(stats.getTotal().getMerge(), notNullValue());
    assertThat(stats.getTotal().getFlush(), notNullValue());
    assertThat(stats.getTotal().getRefresh(), notNullValue());
    // check types
    stats = client().admin().indices().prepareStats().setTypes("type1", "type").execute().actionGet();
    assertThat(stats.getPrimaries().getIndexing().getTypeStats().get("type1").getIndexCount(), equalTo(1L));
    assertThat(stats.getPrimaries().getIndexing().getTypeStats().get("type").getIndexCount(), equalTo(1L));
    assertThat(stats.getPrimaries().getIndexing().getTypeStats().get("type1").getIndexFailedCount(), equalTo(0L));
    assertThat(stats.getPrimaries().getIndexing().getTypeStats().get("type2"), nullValue());
    assertThat(stats.getPrimaries().getIndexing().getTypeStats().get("type1").getIndexCurrent(), equalTo(0L));
    assertThat(stats.getPrimaries().getIndexing().getTypeStats().get("type1").getDeleteCurrent(), equalTo(0L));
    assertThat(stats.getTotal().getGet().getCount(), equalTo(0L));
    // check get
    GetResponse getResponse = client().prepareGet("test1", "type1", "1").execute().actionGet();
    assertThat(getResponse.isExists(), equalTo(true));
    stats = client().admin().indices().prepareStats().execute().actionGet();
    assertThat(stats.getTotal().getGet().getCount(), equalTo(1L));
    assertThat(stats.getTotal().getGet().getExistsCount(), equalTo(1L));
    assertThat(stats.getTotal().getGet().getMissingCount(), equalTo(0L));
    // missing get
    getResponse = client().prepareGet("test1", "type1", "2").execute().actionGet();
    assertThat(getResponse.isExists(), equalTo(false));
    stats = client().admin().indices().prepareStats().execute().actionGet();
    assertThat(stats.getTotal().getGet().getCount(), equalTo(2L));
    assertThat(stats.getTotal().getGet().getExistsCount(), equalTo(1L));
    assertThat(stats.getTotal().getGet().getMissingCount(), equalTo(1L));
    // clear all
    stats = client().admin().indices().prepareStats().setDocs(false).setStore(false).setIndexing(false).setFlush(true).setRefresh(true).setMerge(true).clear().execute().actionGet();
    assertThat(stats.getTotal().getDocs(), nullValue());
    assertThat(stats.getTotal().getStore(), nullValue());
    assertThat(stats.getTotal().getIndexing(), nullValue());
    assertThat(stats.getTotal().getGet(), nullValue());
    assertThat(stats.getTotal().getSearch(), nullValue());
    // index failed
    try {
        client().prepareIndex("test1", "type1", Integer.toString(1)).setSource("field", "value").setVersion(1).setVersionType(VersionType.EXTERNAL).execute().actionGet();
        fail("Expected a version conflict");
    } catch (VersionConflictEngineException e) {
    }
    try {
        client().prepareIndex("test1", "type2", Integer.toString(1)).setSource("field", "value").setVersion(1).setVersionType(VersionType.EXTERNAL).execute().actionGet();
        fail("Expected a version conflict");
    } catch (VersionConflictEngineException e) {
    }
    try {
        client().prepareIndex("test2", "type", Integer.toString(1)).setSource("field", "value").setVersion(1).setVersionType(VersionType.EXTERNAL).execute().actionGet();
        fail("Expected a version conflict");
    } catch (VersionConflictEngineException e) {
    }
    stats = client().admin().indices().prepareStats().setTypes("type1", "type2").execute().actionGet();
    assertThat(stats.getIndex("test1").getPrimaries().getIndexing().getTotal().getIndexFailedCount(), equalTo(2L));
    assertThat(stats.getIndex("test2").getPrimaries().getIndexing().getTotal().getIndexFailedCount(), equalTo(1L));
    assertThat(stats.getPrimaries().getIndexing().getTypeStats().get("type1").getIndexFailedCount(), equalTo(1L));
    assertThat(stats.getPrimaries().getIndexing().getTypeStats().get("type2").getIndexFailedCount(), equalTo(1L));
    assertThat(stats.getPrimaries().getIndexing().getTotal().getIndexFailedCount(), equalTo(3L));
}

Example 4 with VersionConflictEngineException

use of org.elasticsearch.index.engine.VersionConflictEngineException in project elasticsearch by elastic.

the class AsyncBulkByScrollActionTests method testBulkResponseSetsLotsOfStatus.

public void testBulkResponseSetsLotsOfStatus() {
    testRequest.setAbortOnVersionConflict(false);
    int maxBatches = randomIntBetween(0, 100);
    long versionConflicts = 0;
    long created = 0;
    long updated = 0;
    long deleted = 0;
    for (int batches = 0; batches < maxBatches; batches++) {
        BulkItemResponse[] responses = new BulkItemResponse[randomIntBetween(0, 100)];
        for (int i = 0; i < responses.length; i++) {
            ShardId shardId = new ShardId(new Index("name", "uid"), 0);
            if (rarely()) {
                versionConflicts++;
                responses[i] = new BulkItemResponse(i, randomFrom(DocWriteRequest.OpType.values()), new Failure(shardId.getIndexName(), "type", "id" + i, new VersionConflictEngineException(shardId, "type", "id", "test")));
                continue;
            }
            boolean createdResponse;
            DocWriteRequest.OpType opType;
            switch(randomIntBetween(0, 2)) {
                case 0:
                    createdResponse = true;
                    opType = DocWriteRequest.OpType.CREATE;
                    created++;
                    break;
                case 1:
                    createdResponse = false;
                    opType = randomFrom(DocWriteRequest.OpType.INDEX, DocWriteRequest.OpType.UPDATE);
                    updated++;
                    break;
                case 2:
                    createdResponse = false;
                    opType = DocWriteRequest.OpType.DELETE;
                    deleted++;
                    break;
                default:
                    throw new RuntimeException("Bad scenario");
            }
            responses[i] = new BulkItemResponse(i, opType, new IndexResponse(shardId, "type", "id" + i, randomInt(20), randomInt(), createdResponse));
        }
        new DummyAsyncBulkByScrollAction().onBulkResponse(timeValueNanos(System.nanoTime()), new BulkResponse(responses, 0));
        assertEquals(versionConflicts, testTask.getStatus().getVersionConflicts());
        assertEquals(updated, testTask.getStatus().getUpdated());
        assertEquals(created, testTask.getStatus().getCreated());
        assertEquals(deleted, testTask.getStatus().getDeleted());
        assertEquals(versionConflicts, testTask.getStatus().getVersionConflicts());
    }
}

Example 5 with VersionConflictEngineException

use of org.elasticsearch.index.engine.VersionConflictEngineException in project crate by crate.

the class TransportShardDeleteAction method processRequestItems.

@Override
protected ShardResponse processRequestItems(ShardId shardId, ShardDeleteRequest request, AtomicBoolean killed) throws InterruptedException {
    ShardResponse shardResponse = new ShardResponse();
    IndexService indexService = indicesService.indexServiceSafe(request.index());
    IndexShard indexShard = indexService.shardSafe(shardId.id());
    for (int i = 0; i < request.itemIndices().size(); i++) {
        int location = request.itemIndices().get(i);
        ShardDeleteRequest.Item item = request.items().get(i);
        if (killed.get()) {
            // set failure on response, mark current item and skip all next items.
            // this way replica operation will be executed, but only items already processed here
            // will be processed on the replica
            request.skipFromLocation(location);
            shardResponse.failure(new InterruptedException(JobKilledException.MESSAGE));
            break;
        }
        try {
            boolean found = shardDeleteOperationOnPrimary(request, item, indexShard);
            if (found) {
                logger.debug("{} successfully deleted [{}]/[{}]", request.shardId(), request.type(), item.id());
                shardResponse.add(location);
            } else {
                logger.debug("{} failed to execute delete for [{}]/[{}], doc not found", request.shardId(), request.type(), item.id());
                shardResponse.add(location, new ShardResponse.Failure(item.id(), "Document not found while deleting", false));
            }
        } catch (Throwable t) {
            if (!TransportActions.isShardNotAvailableException(t)) {
                throw t;
            } else {
                logger.debug("{} failed to execute delete for [{}]/[{}]", t, request.shardId(), request.type(), item.id());
                shardResponse.add(location, new ShardResponse.Failure(item.id(), ExceptionsHelper.detailedMessage(t), (t instanceof VersionConflictEngineException)));
            }
        }
    }
    return shardResponse;
}