Examples with ClusterStateUpdateResponse org.elasticsearch.cluster.ack.ClusterStateUpdateResponse used on opensource projects

Example 11 with ClusterStateUpdateResponse

use of org.elasticsearch.cluster.ack.ClusterStateUpdateResponse in project elasticsearch by elastic.

the class MetaDataIndexStateService method closeIndex.

public void closeIndex(final CloseIndexClusterStateUpdateRequest request, final ActionListener<ClusterStateUpdateResponse> listener) {
    if (request.indices() == null || request.indices().length == 0) {
        throw new IllegalArgumentException("Index name is required");
    }
    final String indicesAsString = Arrays.toString(request.indices());
    clusterService.submitStateUpdateTask("close-indices " + indicesAsString, new AckedClusterStateUpdateTask<ClusterStateUpdateResponse>(Priority.URGENT, request, listener) {

        @Override
        protected ClusterStateUpdateResponse newResponse(boolean acknowledged) {
            return new ClusterStateUpdateResponse(acknowledged);
        }

        @Override
        public ClusterState execute(ClusterState currentState) {
            Set<IndexMetaData> indicesToClose = new HashSet<>();
            for (Index index : request.indices()) {
                final IndexMetaData indexMetaData = currentState.metaData().getIndexSafe(index);
                if (indexMetaData.getState() != IndexMetaData.State.CLOSE) {
                    indicesToClose.add(indexMetaData);
                }
            }
            if (indicesToClose.isEmpty()) {
                return currentState;
            }
            // Check if index closing conflicts with any running restores
            RestoreService.checkIndexClosing(currentState, indicesToClose);
            // Check if index closing conflicts with any running snapshots
            SnapshotsService.checkIndexClosing(currentState, indicesToClose);
            logger.info("closing indices [{}]", indicesAsString);
            MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData());
            ClusterBlocks.Builder blocksBuilder = ClusterBlocks.builder().blocks(currentState.blocks());
            for (IndexMetaData openIndexMetadata : indicesToClose) {
                final String indexName = openIndexMetadata.getIndex().getName();
                mdBuilder.put(IndexMetaData.builder(openIndexMetadata).state(IndexMetaData.State.CLOSE));
                blocksBuilder.addIndexBlock(indexName, INDEX_CLOSED_BLOCK);
            }
            ClusterState updatedState = ClusterState.builder(currentState).metaData(mdBuilder).blocks(blocksBuilder).build();
            RoutingTable.Builder rtBuilder = RoutingTable.builder(currentState.routingTable());
            for (IndexMetaData index : indicesToClose) {
                rtBuilder.remove(index.getIndex().getName());
            }
            //no explicit wait for other nodes needed as we use AckedClusterStateUpdateTask
            return allocationService.reroute(ClusterState.builder(updatedState).routingTable(rtBuilder.build()).build(), "indices closed [" + indicesAsString + "]");
        }
    });
}

Example 12 with ClusterStateUpdateResponse

use of org.elasticsearch.cluster.ack.ClusterStateUpdateResponse in project elasticsearch by elastic.

the class MetaDataIndexStateService method openIndex.

public void openIndex(final OpenIndexClusterStateUpdateRequest request, final ActionListener<ClusterStateUpdateResponse> listener) {
    if (request.indices() == null || request.indices().length == 0) {
        throw new IllegalArgumentException("Index name is required");
    }
    final String indicesAsString = Arrays.toString(request.indices());
    clusterService.submitStateUpdateTask("open-indices " + indicesAsString, new AckedClusterStateUpdateTask<ClusterStateUpdateResponse>(Priority.URGENT, request, listener) {

        @Override
        protected ClusterStateUpdateResponse newResponse(boolean acknowledged) {
            return new ClusterStateUpdateResponse(acknowledged);
        }

        @Override
        public ClusterState execute(ClusterState currentState) {
            List<IndexMetaData> indicesToOpen = new ArrayList<>();
            for (Index index : request.indices()) {
                final IndexMetaData indexMetaData = currentState.metaData().getIndexSafe(index);
                if (indexMetaData.getState() != IndexMetaData.State.OPEN) {
                    indicesToOpen.add(indexMetaData);
                }
            }
            if (indicesToOpen.isEmpty()) {
                return currentState;
            }
            logger.info("opening indices [{}]", indicesAsString);
            MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData());
            ClusterBlocks.Builder blocksBuilder = ClusterBlocks.builder().blocks(currentState.blocks());
            final Version minIndexCompatibilityVersion = currentState.getNodes().getMaxNodeVersion().minimumIndexCompatibilityVersion();
            for (IndexMetaData closedMetaData : indicesToOpen) {
                final String indexName = closedMetaData.getIndex().getName();
                IndexMetaData indexMetaData = IndexMetaData.builder(closedMetaData).state(IndexMetaData.State.OPEN).build();
                // The index might be closed because we couldn't import it due to old incompatible version
                // We need to check that this index can be upgraded to the current version
                indexMetaData = metaDataIndexUpgradeService.upgradeIndexMetaData(indexMetaData, minIndexCompatibilityVersion);
                try {
                    indicesService.verifyIndexMetadata(indexMetaData, indexMetaData);
                } catch (Exception e) {
                    throw new ElasticsearchException("Failed to verify index " + indexMetaData.getIndex(), e);
                }
                mdBuilder.put(indexMetaData, true);
                blocksBuilder.removeIndexBlock(indexName, INDEX_CLOSED_BLOCK);
            }
            ClusterState updatedState = ClusterState.builder(currentState).metaData(mdBuilder).blocks(blocksBuilder).build();
            RoutingTable.Builder rtBuilder = RoutingTable.builder(updatedState.routingTable());
            for (IndexMetaData index : indicesToOpen) {
                rtBuilder.addAsFromCloseToOpen(updatedState.metaData().getIndexSafe(index.getIndex()));
            }
            //no explicit wait for other nodes needed as we use AckedClusterStateUpdateTask
            return allocationService.reroute(ClusterState.builder(updatedState).routingTable(rtBuilder.build()).build(), "indices opened [" + indicesAsString + "]");
        }
    });
}

Example 13 with ClusterStateUpdateResponse

use of org.elasticsearch.cluster.ack.ClusterStateUpdateResponse in project elasticsearch by elastic.

the class MetaDataUpdateSettingsService method clusterChanged.

@Override
public void clusterChanged(ClusterChangedEvent event) {
    // update an index with number of replicas based on data nodes if possible
    if (!event.state().nodes().isLocalNodeElectedMaster()) {
        return;
    }
    // we will want to know this for translating "all" to a number
    final int dataNodeCount = event.state().nodes().getDataNodes().size();
    Map<Integer, List<Index>> nrReplicasChanged = new HashMap<>();
    // we need to do this each time in case it was changed by update settings
    for (final IndexMetaData indexMetaData : event.state().metaData()) {
        AutoExpandReplicas autoExpandReplicas = IndexMetaData.INDEX_AUTO_EXPAND_REPLICAS_SETTING.get(indexMetaData.getSettings());
        if (autoExpandReplicas.isEnabled()) {
            /*
                 * we have to expand the number of replicas for this index to at least min and at most max nodes here
                 * so we are bumping it up if we have to or reduce it depending on min/max and the number of datanodes.
                 * If we change the number of replicas we just let the shard allocator do it's thing once we updated it
                 * since it goes through the index metadata to figure out if something needs to be done anyway. Do do that
                 * we issue a cluster settings update command below and kicks off a reroute.
                 */
            final int min = autoExpandReplicas.getMinReplicas();
            final int max = autoExpandReplicas.getMaxReplicas(dataNodeCount);
            int numberOfReplicas = dataNodeCount - 1;
            if (numberOfReplicas < min) {
                numberOfReplicas = min;
            } else if (numberOfReplicas > max) {
                numberOfReplicas = max;
            }
            // same value, nothing to do there
            if (numberOfReplicas == indexMetaData.getNumberOfReplicas()) {
                continue;
            }
            if (numberOfReplicas >= min && numberOfReplicas <= max) {
                if (!nrReplicasChanged.containsKey(numberOfReplicas)) {
                    nrReplicasChanged.put(numberOfReplicas, new ArrayList<>());
                }
                nrReplicasChanged.get(numberOfReplicas).add(indexMetaData.getIndex());
            }
        }
    }
    if (nrReplicasChanged.size() > 0) {
        // update settings and kick of a reroute (implicit) for them to take effect
        for (final Integer fNumberOfReplicas : nrReplicasChanged.keySet()) {
            Settings settings = Settings.builder().put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, fNumberOfReplicas).build();
            final List<Index> indices = nrReplicasChanged.get(fNumberOfReplicas);
            UpdateSettingsClusterStateUpdateRequest updateRequest = new UpdateSettingsClusterStateUpdateRequest().indices(indices.toArray(new Index[indices.size()])).settings(settings).ackTimeout(//no need to wait for ack here
            TimeValue.timeValueMillis(0)).masterNodeTimeout(TimeValue.timeValueMinutes(10));
            updateSettings(updateRequest, new ActionListener<ClusterStateUpdateResponse>() {

                @Override
                public void onResponse(ClusterStateUpdateResponse response) {
                    for (Index index : indices) {
                        logger.info("{} auto expanded replicas to [{}]", index, fNumberOfReplicas);
                    }
                }

                @Override
                public void onFailure(Exception t) {
                    for (Index index : indices) {
                        logger.warn("{} fail to auto expand replicas to [{}]", index, fNumberOfReplicas);
                    }
                }
            });
        }
    }
}