Java IndexRequest.setPipeline方法代码示例

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包/类
@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包/类
public void testStats() throws Exception {
    IngestStats ingestStats = executionService.stats();
    assertThat(ingestStats.getStatsPerPipeline().size(), equalTo(0));
    assertThat(ingestStats.getTotalStats().getIngestCount(), equalTo(0L));
    assertThat(ingestStats.getTotalStats().getIngestCurrent(), equalTo(0L));
    assertThat(ingestStats.getTotalStats().getIngestFailedCount(), equalTo(0L));
    assertThat(ingestStats.getTotalStats().getIngestTimeInMillis(), equalTo(0L));

    when(store.get("_id1")).thenReturn(new Pipeline("_id1", null, version, new CompoundProcessor(mock(Processor.class))));
    when(store.get("_id2")).thenReturn(new Pipeline("_id2", null, null, new CompoundProcessor(mock(Processor.class))));

    Map<String, PipelineConfiguration> configurationMap = new HashMap<>();
    configurationMap.put("_id1", new PipelineConfiguration("_id1", new BytesArray("{}"), XContentType.JSON));
    configurationMap.put("_id2", new PipelineConfiguration("_id2", new BytesArray("{}"), XContentType.JSON));
    executionService.updatePipelineStats(new IngestMetadata(configurationMap));

    @SuppressWarnings("unchecked")
    Consumer<Exception> failureHandler = mock(Consumer.class);
    @SuppressWarnings("unchecked")
    Consumer<Boolean> completionHandler = mock(Consumer.class);

    IndexRequest indexRequest = new IndexRequest("_index");
    indexRequest.setPipeline("_id1");
    executionService.executeIndexRequest(indexRequest, failureHandler, completionHandler);
    ingestStats = executionService.stats();
    assertThat(ingestStats.getStatsPerPipeline().size(), equalTo(2));
    assertThat(ingestStats.getStatsPerPipeline().get("_id1").getIngestCount(), equalTo(1L));
    assertThat(ingestStats.getStatsPerPipeline().get("_id2").getIngestCount(), equalTo(0L));
    assertThat(ingestStats.getTotalStats().getIngestCount(), equalTo(1L));

    indexRequest.setPipeline("_id2");
    executionService.executeIndexRequest(indexRequest, failureHandler, completionHandler);
    ingestStats = executionService.stats();
    assertThat(ingestStats.getStatsPerPipeline().size(), equalTo(2));
    assertThat(ingestStats.getStatsPerPipeline().get("_id1").getIngestCount(), equalTo(1L));
    assertThat(ingestStats.getStatsPerPipeline().get("_id2").getIngestCount(), equalTo(1L));
    assertThat(ingestStats.getTotalStats().getIngestCount(), equalTo(2L));
}
 

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包/类
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 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());
    }
}
 

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

    BulkItemResponse itemResponse = new BulkItemResponse(0, DocWriteRequest.OpType.CREATE, indexResponse);
    BulkItemResponse[] bulkItemResponses = new BulkItemResponse[1];
    bulkItemResponses[0] = itemResponse;
    remoteResponseHandler.getValue().handleResponse(new BulkResponse(bulkItemResponses, 0)); // 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);
    singleItemBulkWriteAction.execute(null, indexRequest, listener);
    verify(transportService).sendRequest(node.capture(), eq(BulkAction.NAME), any(), remoteResponseHandler.capture());
    if (usedNode1) {
        assertSame(remoteNode2, node.getValue());
    } else {
        assertSame(remoteNode1, node.getValue());
    }
}