Examples with ClusterStateTaskListener org.elasticsearch.cluster.ClusterStateTaskListener used on opensource projects

Example 6 with ClusterStateTaskListener

use of org.elasticsearch.cluster.ClusterStateTaskListener in project elasticsearch by elastic.

the class ClusterServiceTests method testClusterStateUpdateTasksAreExecutedInOrder.

// test that for a single thread, tasks are executed in the order
// that they are submitted
public void testClusterStateUpdateTasksAreExecutedInOrder() throws BrokenBarrierException, InterruptedException {
    class TaskExecutor implements ClusterStateTaskExecutor<Integer> {

        List<Integer> tasks = new ArrayList<>();

        @Override
        public ClusterTasksResult<Integer> execute(ClusterState currentState, List<Integer> tasks) throws Exception {
            this.tasks.addAll(tasks);
            return ClusterTasksResult.<Integer>builder().successes(tasks).build(ClusterState.builder(currentState).build());
        }
    }
    int numberOfThreads = randomIntBetween(2, 8);
    TaskExecutor[] executors = new TaskExecutor[numberOfThreads];
    for (int i = 0; i < numberOfThreads; i++) {
        executors[i] = new TaskExecutor();
    }
    int tasksSubmittedPerThread = randomIntBetween(2, 1024);
    CopyOnWriteArrayList<Tuple<String, Throwable>> failures = new CopyOnWriteArrayList<>();
    CountDownLatch updateLatch = new CountDownLatch(numberOfThreads * tasksSubmittedPerThread);
    ClusterStateTaskListener listener = new ClusterStateTaskListener() {

        @Override
        public void onFailure(String source, Exception e) {
            logger.error((Supplier<?>) () -> new ParameterizedMessage("unexpected failure: [{}]", source), e);
            failures.add(new Tuple<>(source, e));
            updateLatch.countDown();
        }

        @Override
        public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
            updateLatch.countDown();
        }
    };
    CyclicBarrier barrier = new CyclicBarrier(1 + numberOfThreads);
    for (int i = 0; i < numberOfThreads; i++) {
        final int index = i;
        Thread thread = new Thread(() -> {
            try {
                barrier.await();
                for (int j = 0; j < tasksSubmittedPerThread; j++) {
                    clusterService.submitStateUpdateTask("[" + index + "][" + j + "]", j, ClusterStateTaskConfig.build(randomFrom(Priority.values())), executors[index], listener);
                }
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                throw new AssertionError(e);
            }
        });
        thread.start();
    }
    // wait for all threads to be ready
    barrier.await();
    // wait for all threads to finish
    barrier.await();
    updateLatch.await();
    assertThat(failures, empty());
    for (int i = 0; i < numberOfThreads; i++) {
        assertEquals(tasksSubmittedPerThread, executors[i].tasks.size());
        for (int j = 0; j < tasksSubmittedPerThread; j++) {
            assertNotNull(executors[i].tasks.get(j));
            assertEquals("cluster state update task executed out of order", j, (int) executors[i].tasks.get(j));
        }
    }
}

Example 7 with ClusterStateTaskListener

use of org.elasticsearch.cluster.ClusterStateTaskListener in project elasticsearch by elastic.

the class ClusterServiceTests method testBlockingCallInClusterStateTaskListenerFails.

public void testBlockingCallInClusterStateTaskListenerFails() throws InterruptedException {
    assumeTrue("assertions must be enabled for this test to work", BaseFuture.class.desiredAssertionStatus());
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicReference<AssertionError> assertionRef = new AtomicReference<>();
    clusterService.submitStateUpdateTask("testBlockingCallInClusterStateTaskListenerFails", new Object(), ClusterStateTaskConfig.build(Priority.NORMAL), new ClusterStateTaskExecutor<Object>() {

        @Override
        public ClusterTasksResult<Object> execute(ClusterState currentState, List<Object> tasks) throws Exception {
            ClusterState newClusterState = ClusterState.builder(currentState).build();
            return ClusterTasksResult.builder().successes(tasks).build(newClusterState);
        }
    }, new ClusterStateTaskListener() {

        @Override
        public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
            BaseFuture<Void> future = new BaseFuture<Void>() {
            };
            try {
                if (randomBoolean()) {
                    future.get(1L, TimeUnit.SECONDS);
                } else {
                    future.get();
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            } catch (AssertionError e) {
                assertionRef.set(e);
                latch.countDown();
            }
        }

        @Override
        public void onFailure(String source, Exception e) {
        }
    });
    latch.await();
    assertNotNull(assertionRef.get());
    assertThat(assertionRef.get().getMessage(), containsString("not be the cluster state update thread. Reason: [Blocking operation]"));
}

Example 8 with ClusterStateTaskListener

use of org.elasticsearch.cluster.ClusterStateTaskListener in project elasticsearch by elastic.

the class ClusterServiceTests method testSingleBatchSubmission.

public void testSingleBatchSubmission() throws InterruptedException {
    Map<Integer, ClusterStateTaskListener> tasks = new HashMap<>();
    final int numOfTasks = randomInt(10);
    final CountDownLatch latch = new CountDownLatch(numOfTasks);
    for (int i = 0; i < numOfTasks; i++) {
        while (null != tasks.put(randomInt(1024), new ClusterStateTaskListener() {

            @Override
            public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
                latch.countDown();
            }

            @Override
            public void onFailure(String source, Exception e) {
                fail(ExceptionsHelper.detailedMessage(e));
            }
        })) ;
    }
    clusterService.submitStateUpdateTasks("test", tasks, ClusterStateTaskConfig.build(Priority.LANGUID), (currentState, taskList) -> {
        assertThat(taskList.size(), equalTo(tasks.size()));
        assertThat(taskList.stream().collect(Collectors.toSet()), equalTo(tasks.keySet()));
        return ClusterStateTaskExecutor.ClusterTasksResult.<Integer>builder().successes(taskList).build(currentState);
    });
    latch.await();
}