Java IndexRequest.source方法代码示例

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    IndexRequest indexRequest = new IndexRequest(request.param("index"), request.param("type"), request.param("id"));
    indexRequest.routing(request.param("routing"));
    indexRequest.parent(request.param("parent"));
    indexRequest.setPipeline(request.param("pipeline"));
    indexRequest.source(request.content(), request.getXContentType());
    indexRequest.timeout(request.paramAsTime("timeout", IndexRequest.DEFAULT_TIMEOUT));
    indexRequest.setRefreshPolicy(request.param("refresh"));
    indexRequest.version(RestActions.parseVersion(request));
    indexRequest.versionType(VersionType.fromString(request.param("version_type"), indexRequest.versionType()));
    String sOpType = request.param("op_type");
    String waitForActiveShards = request.param("wait_for_active_shards");
    if (waitForActiveShards != null) {
        indexRequest.waitForActiveShards(ActiveShardCount.parseString(waitForActiveShards));
    }
    if (sOpType != null) {
        indexRequest.opType(sOpType);
    }

    return channel ->
            client.index(indexRequest, new RestStatusToXContentListener<>(channel, r -> r.getLocation(indexRequest.routing())));
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testBulkRequestExecution() throws Exception {
    BulkRequest bulkRequest = new BulkRequest();
    String pipelineId = "_id";

    int numRequest = scaledRandomIntBetween(8, 64);
    for (int i = 0; i < numRequest; i++) {
        IndexRequest indexRequest = new IndexRequest("_index", "_type", "_id").setPipeline(pipelineId);
        indexRequest.source(Requests.INDEX_CONTENT_TYPE, "field1", "value1");
        bulkRequest.add(indexRequest);
    }

    when(store.get(pipelineId)).thenReturn(new Pipeline(pipelineId, null, version, new CompoundProcessor()));

    @SuppressWarnings("unchecked")
    BiConsumer<IndexRequest, Exception> requestItemErrorHandler = mock(BiConsumer.class);
    @SuppressWarnings("unchecked")
    Consumer<Exception> completionHandler = mock(Consumer.class);
    executionService.executeBulkRequest(bulkRequest.requests(), requestItemErrorHandler, completionHandler);

    verify(requestItemErrorHandler, never()).accept(any(), any());
    verify(completionHandler, times(1)).accept(null);
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testDynamicDisabled() {
    IndexRequest request = new IndexRequest("index", "type", "1");
    request.source(Requests.INDEX_CONTENT_TYPE, "foo", 3);
    BulkRequest bulkRequest = new BulkRequest();
    bulkRequest.add(request);
    final AtomicBoolean onFailureCalled = new AtomicBoolean();

    transportBulkAction.execute(bulkRequest, new ActionListener<BulkResponse>() {
        @Override
        public void onResponse(BulkResponse bulkResponse) {
            fail("onResponse shouldn't be called");
        }

        @Override
        public void onFailure(Exception e) {
            onFailureCalled.set(true);
            assertThat(e, instanceOf(IndexNotFoundException.class));
            assertEquals("no such index and [index.mapper.dynamic] is [false]", e.getMessage());
        }
    });

    assertTrue(onFailureCalled.get());
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testThreadedListeners() throws Throwable {
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicReference<Throwable> failure = new AtomicReference<>();
    final AtomicReference<String> threadName = new AtomicReference<>();
    Client client = client();

    IndexRequest request = new IndexRequest("test", "type", "1");
    if (randomBoolean()) {
        // set the source, without it, we will have a verification failure
        request.source(Requests.INDEX_CONTENT_TYPE, "field1", "value1");
    }

    client.index(request, new ActionListener<IndexResponse>() {
        @Override
        public void onResponse(IndexResponse indexResponse) {
            threadName.set(Thread.currentThread().getName());
            latch.countDown();
        }

        @Override
        public void onFailure(Exception e) {
            threadName.set(Thread.currentThread().getName());
            failure.set(e);
            latch.countDown();
        }
    });

    latch.await();

    boolean shouldBeThreaded = TransportClient.CLIENT_TYPE.equals(Client.CLIENT_TYPE_SETTING_S.get(client.settings()));
    if (shouldBeThreaded) {
        assertTrue(threadName.get().contains("listener"));
    } else {
        assertFalse(threadName.get().contains("listener"));
    }
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
@Override
protected RequestWrapper<IndexRequest> buildRequest(ScrollableHitSource.Hit doc) {
    IndexRequest index = new IndexRequest();
    index.index(doc.getIndex());
    index.type(doc.getType());
    index.id(doc.getId());
    index.source(doc.getSource(), doc.getXContentType());
    index.versionType(VersionType.INTERNAL);
    index.version(doc.getVersion());
    index.setPipeline(mainRequest.getPipeline());
    return wrap(index);
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
private void innerExecute(IndexRequest indexRequest, Pipeline pipeline) throws Exception {
    if (pipeline.getProcessors().isEmpty()) {
        return;
    }

    long startTimeInNanos = System.nanoTime();
    // the pipeline specific stat holder may not exist and that is fine:
    // (e.g. the pipeline may have been removed while we're ingesting a document
    Optional<StatsHolder> pipelineStats = Optional.ofNullable(statsHolderPerPipeline.get(pipeline.getId()));
    try {
        totalStats.preIngest();
        pipelineStats.ifPresent(StatsHolder::preIngest);
        String index = indexRequest.index();
        String type = indexRequest.type();
        String id = indexRequest.id();
        String routing = indexRequest.routing();
        String parent = indexRequest.parent();
        Map<String, Object> sourceAsMap = indexRequest.sourceAsMap();
        IngestDocument ingestDocument = new IngestDocument(index, type, id, routing, parent, sourceAsMap);
        pipeline.execute(ingestDocument);

        Map<IngestDocument.MetaData, String> metadataMap = ingestDocument.extractMetadata();
        //it's fine to set all metadata fields all the time, as ingest document holds their starting values
        //before ingestion, which might also get modified during ingestion.
        indexRequest.index(metadataMap.get(IngestDocument.MetaData.INDEX));
        indexRequest.type(metadataMap.get(IngestDocument.MetaData.TYPE));
        indexRequest.id(metadataMap.get(IngestDocument.MetaData.ID));
        indexRequest.routing(metadataMap.get(IngestDocument.MetaData.ROUTING));
        indexRequest.parent(metadataMap.get(IngestDocument.MetaData.PARENT));
        indexRequest.source(ingestDocument.getSourceAndMetadata());
    } catch (Exception e) {
        totalStats.ingestFailed();
        pipelineStats.ifPresent(StatsHolder::ingestFailed);
        throw e;
    } finally {
        long ingestTimeInMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTimeInNanos);
        totalStats.postIngest(ingestTimeInMillis);
        pipelineStats.ifPresent(statsHolder -> statsHolder.postIngest(ingestTimeInMillis));
    }
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
BulkRequest internalAdd(IndexRequest request, @Nullable Object payload) {
    Objects.requireNonNull(request, "'request' must not be null");
    requests.add(request);
    addPayload(payload);
    // lack of source is validated in validate() method
    sizeInBytes += (request.source() != null ? request.source().length() : 0) + REQUEST_OVERHEAD;
    indices.add(request.index());
    return this;
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testIngestSkipped() throws Exception {
    BulkRequest bulkRequest = new BulkRequest();
    IndexRequest indexRequest = new IndexRequest("index", "type", "id");
    indexRequest.source(Collections.emptyMap());
    bulkRequest.add(indexRequest);
    action.execute(null, bulkRequest, ActionListener.wrap(response -> {}, exception -> {
        throw new AssertionError(exception);
    }));
    assertTrue(action.isExecuted);
    verifyZeroInteractions(ingestService);
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testSingleItemBulkActionIngestSkipped() throws Exception {
    IndexRequest indexRequest = new IndexRequest("index", "type", "id");
    indexRequest.source(Collections.emptyMap());
    singleItemBulkWriteAction.execute(null, indexRequest, ActionListener.wrap(response -> {}, exception -> {
        throw new AssertionError(exception);
    }));
    assertTrue(action.isExecuted);
    verifyZeroInteractions(ingestService);
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testSingleItemBulkActionIngestLocal() throws Exception {
    Exception exception = new Exception("fake exception");
    IndexRequest indexRequest = new IndexRequest("index", "type", "id");
    indexRequest.source(Collections.emptyMap());
    indexRequest.setPipeline("testpipeline");
    AtomicBoolean responseCalled = new AtomicBoolean(false);
    AtomicBoolean failureCalled = new AtomicBoolean(false);
    singleItemBulkWriteAction.execute(null, indexRequest, ActionListener.wrap(
            response -> {
                responseCalled.set(true);
            },
            e -> {
                assertThat(e, sameInstance(exception));
                failureCalled.set(true);
            }));

    // check failure works, and passes through to the listener
    assertFalse(action.isExecuted); // haven't executed yet
    assertFalse(responseCalled.get());
    assertFalse(failureCalled.get());
    verify(executionService).executeBulkRequest(bulkDocsItr.capture(), failureHandler.capture(), completionHandler.capture());
    completionHandler.getValue().accept(exception);
    assertTrue(failureCalled.get());

    // now check success
    indexRequest.setPipeline(null); // this is done by the real pipeline execution service when processing
    completionHandler.getValue().accept(null);
    assertTrue(action.isExecuted);
    assertFalse(responseCalled.get()); // listener would only be called by real index action, not our mocked one
    verifyZeroInteractions(transportService);
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
BulkRequest internalAdd(IndexRequest request, @Nullable Object payload) {
    requests.add(request);
    addPayload(payload);
    // lack of source is validated in validate() method
    sizeInBytes += (request.source() != null ? request.source().length() : 0) + REQUEST_OVERHEAD;
    return this;
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testIndex() throws IOException {
    String index = randomAsciiOfLengthBetween(3, 10);
    String type = randomAsciiOfLengthBetween(3, 10);
    IndexRequest indexRequest = new IndexRequest(index, type);

    String id = randomBoolean() ? randomAsciiOfLengthBetween(3, 10) : null;
    indexRequest.id(id);

    Map<String, String> expectedParams = new HashMap<>();

    String method = "POST";
    if (id != null) {
        method = "PUT";
        if (randomBoolean()) {
            indexRequest.opType(DocWriteRequest.OpType.CREATE);
        }
    }

    setRandomTimeout(indexRequest, expectedParams);
    setRandomRefreshPolicy(indexRequest, expectedParams);

    // There is some logic around _create endpoint and version/version type
    if (indexRequest.opType() == DocWriteRequest.OpType.CREATE) {
        indexRequest.version(randomFrom(Versions.MATCH_ANY, Versions.MATCH_DELETED));
        expectedParams.put("version", Long.toString(Versions.MATCH_DELETED));
    } else {
        setRandomVersion(indexRequest, expectedParams);
        setRandomVersionType(indexRequest, expectedParams);
    }

    if (frequently()) {
        if (randomBoolean()) {
            String routing = randomAsciiOfLengthBetween(3, 10);
            indexRequest.routing(routing);
            expectedParams.put("routing", routing);
        }
        if (randomBoolean()) {
            String parent = randomAsciiOfLengthBetween(3, 10);
            indexRequest.parent(parent);
            expectedParams.put("parent", parent);
        }
        if (randomBoolean()) {
            String pipeline = randomAsciiOfLengthBetween(3, 10);
            indexRequest.setPipeline(pipeline);
            expectedParams.put("pipeline", pipeline);
        }
    }

    XContentType xContentType = randomFrom(XContentType.values());
    int nbFields = randomIntBetween(0, 10);
    try (XContentBuilder builder = XContentBuilder.builder(xContentType.xContent())) {
        builder.startObject();
        for (int i = 0; i < nbFields; i++) {
            builder.field("field_" + i, i);
        }
        builder.endObject();
        indexRequest.source(builder);
    }

    Request request = Request.index(indexRequest);
    if (indexRequest.opType() == DocWriteRequest.OpType.CREATE) {
        assertEquals("/" + index + "/" + type + "/" + id + "/_create", request.endpoint);
    } else if (id != null) {
        assertEquals("/" + index + "/" + type + "/" + id, request.endpoint);
    } else {
        assertEquals("/" + index + "/" + type, request.endpoint);
    }
    assertEquals(expectedParams, request.params);
    assertEquals(method, request.method);

    HttpEntity entity = request.entity;
    assertNotNull(entity);
    assertTrue(entity instanceof ByteArrayEntity);

    try (XContentParser parser = createParser(xContentType.xContent(), entity.getContent())) {
        assertEquals(nbFields, parser.map().size());
    }
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testBulkWithIngestFailures() throws Exception {
    createIndex("index");

    BytesReference source = jsonBuilder().startObject()
        .field("description", "my_pipeline")
        .startArray("processors")
        .startObject()
        .startObject("test")
        .endObject()
        .endObject()
        .endArray()
        .endObject().bytes();
    PutPipelineRequest putPipelineRequest = new PutPipelineRequest("_id", source, XContentType.JSON);
    client().admin().cluster().putPipeline(putPipelineRequest).get();

    int numRequests = scaledRandomIntBetween(32, 128);
    BulkRequest bulkRequest = new BulkRequest();
    for (int i = 0; i < numRequests; i++) {
        IndexRequest indexRequest = new IndexRequest("index", "type", Integer.toString(i)).setPipeline("_id");
        indexRequest.source(Requests.INDEX_CONTENT_TYPE, "field", "value", "fail", i % 2 == 0);
        bulkRequest.add(indexRequest);
    }

    BulkResponse response = client().bulk(bulkRequest).actionGet();
    assertThat(response.getItems().length, equalTo(bulkRequest.requests().size()));
    for (int i = 0; i < bulkRequest.requests().size(); i++) {
        BulkItemResponse itemResponse = response.getItems()[i];
        if (i % 2 == 0) {
            BulkItemResponse.Failure failure = itemResponse.getFailure();
            ElasticsearchException compoundProcessorException = (ElasticsearchException) failure.getCause();
            assertThat(compoundProcessorException.getRootCause().getMessage(), equalTo("test processor failed"));
        } else {
            IndexResponse indexResponse = itemResponse.getResponse();
            assertThat("Expected a successful response but found failure [" + itemResponse.getFailure() + "].",
                itemResponse.isFailed(), is(false));
            assertThat(indexResponse, notNullValue());
            assertThat(indexResponse.getId(), equalTo(Integer.toString(i)));
            assertEquals(DocWriteResponse.Result.CREATED, indexResponse.getResult());
        }
    }
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testIngestLocal() throws Exception {
    Exception exception = new Exception("fake exception");
    BulkRequest bulkRequest = new BulkRequest();
    IndexRequest indexRequest1 = new IndexRequest("index", "type", "id");
    indexRequest1.source(Collections.emptyMap());
    indexRequest1.setPipeline("testpipeline");
    IndexRequest indexRequest2 = new IndexRequest("index", "type", "id");
    indexRequest2.source(Collections.emptyMap());
    indexRequest2.setPipeline("testpipeline");
    bulkRequest.add(indexRequest1);
    bulkRequest.add(indexRequest2);

    AtomicBoolean responseCalled = new AtomicBoolean(false);
    AtomicBoolean failureCalled = new AtomicBoolean(false);
    action.execute(null, bulkRequest, ActionListener.wrap(
        response -> {
            BulkItemResponse itemResponse = response.iterator().next();
            assertThat(itemResponse.getFailure().getMessage(), containsString("fake exception"));
            responseCalled.set(true);
        },
        e -> {
            assertThat(e, sameInstance(exception));
            failureCalled.set(true);
        }));

    // check failure works, and passes through to the listener
    assertFalse(action.isExecuted); // haven't executed yet
    assertFalse(responseCalled.get());
    assertFalse(failureCalled.get());
    verify(executionService).executeBulkRequest(bulkDocsItr.capture(), failureHandler.capture(), completionHandler.capture());
    completionHandler.getValue().accept(exception);
    assertTrue(failureCalled.get());

    // now check success
    Iterator<DocWriteRequest> req = bulkDocsItr.getValue().iterator();
    failureHandler.getValue().accept((IndexRequest)req.next(), exception); // have an exception for our one index request
    indexRequest2.setPipeline(null); // this is done by the real pipeline execution service when processing
    completionHandler.getValue().accept(null);
    assertTrue(action.isExecuted);
    assertFalse(responseCalled.get()); // listener would only be called by real index action, not our mocked one
    verifyZeroInteractions(transportService);
}
 

import org.elasticsearch.action.index.IndexRequest; //导入方法依赖的package包/类
public void testIngestForward() throws Exception {
    localIngest = false;
    BulkRequest bulkRequest = new BulkRequest();
    IndexRequest indexRequest = new IndexRequest("index", "type", "id");
    indexRequest.source(Collections.emptyMap());
    indexRequest.setPipeline("testpipeline");
    bulkRequest.add(indexRequest);
    BulkResponse bulkResponse = mock(BulkResponse.class);
    AtomicBoolean responseCalled = new AtomicBoolean(false);
    ActionListener<BulkResponse> listener = ActionListener.wrap(
        response -> {
            responseCalled.set(true);
            assertSame(bulkResponse, response);
        },
        e -> {
            throw new AssertionError(e);
        });
    action.execute(null, bulkRequest, listener);

    // should not have executed ingest locally
    verify(executionService, never()).executeBulkRequest(any(), any(), any());
    // but instead should have sent to a remote node with the transport service
    ArgumentCaptor<DiscoveryNode> node = ArgumentCaptor.forClass(DiscoveryNode.class);
    verify(transportService).sendRequest(node.capture(), eq(BulkAction.NAME), any(), remoteResponseHandler.capture());
    boolean usedNode1 = node.getValue() == remoteNode1; // make sure we used one of the nodes
    if (usedNode1 == false) {
        assertSame(remoteNode2, node.getValue());
    }
    assertFalse(action.isExecuted); // no local index execution
    assertFalse(responseCalled.get()); // listener not called yet

    remoteResponseHandler.getValue().handleResponse(bulkResponse); // call the listener for the remote node
    assertTrue(responseCalled.get()); // now the listener we passed should have been delegated to by the remote listener
    assertFalse(action.isExecuted); // still no local index execution

    // now make sure ingest nodes are rotated through with a subsequent request
    reset(transportService);
    action.execute(null, bulkRequest, listener);
    verify(transportService).sendRequest(node.capture(), eq(BulkAction.NAME), any(), remoteResponseHandler.capture());
    if (usedNode1) {
        assertSame(remoteNode2, node.getValue());
    } else {
        assertSame(remoteNode1, node.getValue());
    }
}