}
                        }, e -> {
                            coordinator.completeOperation("reindex");
                            logger.warn("Failed to reindex from {} to {}", fromIndex, toIndex, e);
                        }));
            } catch (final Exception e) {
                coordinator.completeOperation("reindex");
                throw e;

        assertTrue(result);
        // Verify that each index is recreated with its original name (not .rebuild.xxx)
        for (final String index : testClient.createdIndices) {
            assertFalse(index.contains(".rebuild."), "Index should not contain .rebuild.: " + index);
        }
        // Verify reindex targets are original names (not .rebuild.xxx)

permissions that we don't believe *all* of Elasticsearch should have or because
they depend on libraries that we don't believe *all* of Elasticsearch should
depend on.

For example, reindex requires the `connect` permission so it can perform
reindex-from-remote but we don't believe that the *all* of Elasticsearch should
have the "connect". For another example, Painless is implemented using antlr4

                writer.write(runner.client(), suggester.settings(), suggester.getIndex(), new SuggestItem[] { item }, false);

        assertNotNull(result);
        assertFalse(result.hasFailure());

        runner.refresh();

        GetResponse getResponse =
                runner.client().prepareGet().setIndex(suggester.getIndex()).setId(item.getId()).get(TimeValue.timeValueSeconds(30));

        }

        public E get(final int index) {
            return parent.get(index);
        }

        public E set(final int index, final E element) {
            return parent.set(index, element);
        }

        public void add(final int index, final E element) {
            parent.add(index, element);
        }

        public E remove(final int index) {
            return parent.remove(index);

        }

        public E get(final int index) {
            return parent.get(index);
        }

        public E set(final int index, final E element) {
            return parent.set(index, element);
        }

        public void add(final int index, final E element) {
            parent.add(index, element);
        }

        public E remove(final int index) {
            return parent.remove(index);

            if (logger.isDebugEnabled()) {
                logger.debug("Failed to create suggest index: index={}", index, e);
            }
            throw new SuggesterException("Failed to create suggest index: " + index, e);
        }
    }

    /**
     * Creates a new index and replaces the current update alias with the new index.
     */
    public void createNextIndex() {
        try {

        assertEquals(10, derivedBuffer.index);
        assertSame(ndrBuffer.deferred, derivedBuffer.deferred); // Deferred should be the same as original

        // Ensure changes to derived buffer don't affect original's index/start
        derivedBuffer.advance(5);
        assertEquals(15, derivedBuffer.index);
        assertEquals(50, ndrBuffer.index); // Original index should be unchanged
    }

    @Test

        /**
         * Gets the source index.
         *
         * @return the source index
         */
        public int getIndex() {
            return index;
        }

        /**
         * Sets the source index.
         *
         * @param index the source index
         */
        public void setIndex(final int index) {
            this.index = index;
        }

        /**

                                final String index = indexObj.get("_index");
                                if (index != null) {
                                    if (index.startsWith(".fess")) {
                                        indexObj.put("_index", index.substring(1));
                                    }
                                    if (index.endsWith("scheduled_job")) {