Examples with Hit org.opensearch.index.reindex.ScrollableHitSource.Hit used on opensource projects

Example 1 with Hit

use of org.opensearch.index.reindex.ScrollableHitSource.Hit in project OpenSearch by opensearch-project.

the class AsyncBulkByScrollActionTests method testBuildRequestThrowsException.

/**
 * Mimicks script failures or general wrongness by implementers.
 */
public void testBuildRequestThrowsException() throws Exception {
    DummyAsyncBulkByScrollAction action = new DummyAsyncBulkByScrollAction() {

        @Override
        protected AbstractAsyncBulkByScrollAction.RequestWrapper<?> buildRequest(Hit doc) {
            throw new RuntimeException("surprise");
        }
    };
    ScrollableHitSource.BasicHit hit = new ScrollableHitSource.BasicHit("index", "id", 0);
    hit.setSource(new BytesArray("{}"), XContentType.JSON);
    ScrollableHitSource.Response response = new ScrollableHitSource.Response(false, emptyList(), 1, singletonList(hit), null);
    simulateScrollResponse(action, System.nanoTime(), 0, response);
    ExecutionException e = expectThrows(ExecutionException.class, () -> listener.get());
    assertThat(e.getCause(), instanceOf(RuntimeException.class));
    assertThat(e.getCause().getMessage(), equalTo("surprise"));
}

Example 2 with Hit

use of org.opensearch.index.reindex.ScrollableHitSource.Hit in project OpenSearch by opensearch-project.

the class AsyncBulkByScrollActionTests method testScrollDelay.

public void testScrollDelay() throws Exception {
    /*
         * Replace the thread pool with one that will save the delay sent for the command. We'll use that to check that we used a proper
         * delay for throttling.
         */
    AtomicReference<TimeValue> capturedDelay = new AtomicReference<>();
    AtomicReference<Runnable> capturedCommand = new AtomicReference<>();
    setupClient(new TestThreadPool(getTestName()) {

        @Override
        public ScheduledCancellable schedule(Runnable command, TimeValue delay, String name) {
            capturedDelay.set(delay);
            capturedCommand.set(command);
            return new ScheduledCancellable() {

                private boolean cancelled = false;

                @Override
                public long getDelay(TimeUnit unit) {
                    return unit.convert(delay.millis(), TimeUnit.MILLISECONDS);
                }

                @Override
                public int compareTo(Delayed o) {
                    return 0;
                }

                @Override
                public boolean cancel() {
                    cancelled = true;
                    return true;
                }

                @Override
                public boolean isCancelled() {
                    return cancelled;
                }
            };
        }
    });
    DummyAsyncBulkByScrollAction action = new DummyAsyncBulkByScrollAction() {

        @Override
        protected RequestWrapper<?> buildRequest(Hit doc) {
            return wrap(new IndexRequest().index("test"));
        }
    };
    action.setScroll(scrollId());
    // Set the base for the scroll to wait - this is added to the figure we calculate below
    firstSearchRequest.scroll(timeValueSeconds(10));
    // Set throttle to 1 request per second to make the math simpler
    worker.rethrottle(1f);
    action.start();
    // create a simulated response.
    SearchHit hit = new SearchHit(0, "id", emptyMap(), emptyMap()).sourceRef(new BytesArray("{}"));
    SearchHits hits = new SearchHits(IntStream.range(0, 100).mapToObj(i -> hit).toArray(SearchHit[]::new), new TotalHits(0, TotalHits.Relation.EQUAL_TO), 0);
    InternalSearchResponse internalResponse = new InternalSearchResponse(hits, null, null, null, false, false, 1);
    SearchResponse searchResponse = new SearchResponse(internalResponse, scrollId(), 5, 4, 0, randomLong(), null, SearchResponse.Clusters.EMPTY);
    client.lastSearch.get().listener.onResponse(searchResponse);
    assertEquals(0, capturedDelay.get().seconds());
    capturedCommand.get().run();
    // So the next request is going to have to wait an extra 100 seconds or so (base was 10 seconds, so 110ish)
    assertThat(client.lastScroll.get().request.scroll().keepAlive().seconds(), either(equalTo(110L)).or(equalTo(109L)));
    // Now we can simulate a response and check the delay that we used for the task
    if (randomBoolean()) {
        client.lastScroll.get().listener.onResponse(searchResponse);
        assertEquals(99, capturedDelay.get().seconds());
    } else {
        // Let's rethrottle between the starting the scroll and getting the response
        worker.rethrottle(10f);
        client.lastScroll.get().listener.onResponse(searchResponse);
        // The delay uses the new throttle
        assertEquals(9, capturedDelay.get().seconds());
    }
    // Running the command ought to increment the delay counter on the task.
    capturedCommand.get().run();
    assertEquals(capturedDelay.get(), testTask.getStatus().getThrottled());
}

Example 3 with Hit

use of org.opensearch.index.reindex.ScrollableHitSource.Hit in project OpenSearch by opensearch-project.

the class AsyncBulkByScrollActionTests method testScrollResponseBatchingBehavior.

/**
 * Tests that each scroll response is a batch and that the batch is launched properly.
 */
public void testScrollResponseBatchingBehavior() throws Exception {
    int maxBatches = randomIntBetween(0, 100);
    for (int batches = 1; batches < maxBatches; batches++) {
        Hit hit = new ScrollableHitSource.BasicHit("index", "id", 0);
        ScrollableHitSource.Response response = new ScrollableHitSource.Response(false, emptyList(), 1, singletonList(hit), null);
        DummyAsyncBulkByScrollAction action = new DummyAsyncBulkByScrollAction();
        simulateScrollResponse(action, System.nanoTime(), 0, response);
        // Use assert busy because the update happens on another thread
        final int expectedBatches = batches;
        assertBusy(() -> assertEquals(expectedBatches, testTask.getStatus().getBatches()));
    }
}