Examples with MetadataUpdateSettingsService org.elasticsearch.cluster.metadata.MetadataUpdateSettingsService used on opensource projects

Example 1 with MetadataUpdateSettingsService

use of org.elasticsearch.cluster.metadata.MetadataUpdateSettingsService in project crate by crate.

the class AlterTableClusterStateExecutor method updateSettings.

/**
 * The logic is taken over from {@link MetadataUpdateSettingsService#updateSettings(UpdateSettingsClusterStateUpdateRequest, ActionListener)}
 */
private ClusterState updateSettings(final ClusterState currentState, final Settings settings, Index[] concreteIndices) {
    final Settings normalizedSettings = Settings.builder().put(markArchivedSettings(settings)).normalizePrefix(IndexMetadata.INDEX_SETTING_PREFIX).build();
    Settings.Builder settingsForClosedIndices = Settings.builder();
    Settings.Builder settingsForOpenIndices = Settings.builder();
    final Set<String> skippedSettings = new HashSet<>();
    for (String key : normalizedSettings.keySet()) {
        Setting setting = indexScopedSettings.get(key);
        boolean isWildcard = setting == null && Regex.isSimpleMatchPattern(key);
        assert // we already validated the normalized settings
        setting != null || (isWildcard && normalizedSettings.hasValue(key) == false) : "unknown setting: " + key + " isWildcard: " + isWildcard + " hasValue: " + normalizedSettings.hasValue(key);
        settingsForClosedIndices.copy(key, normalizedSettings);
        if (isWildcard || setting.isDynamic()) {
            settingsForOpenIndices.copy(key, normalizedSettings);
        } else {
            skippedSettings.add(key);
        }
    }
    final Settings closedSettings = settingsForClosedIndices.build();
    final Settings openSettings = settingsForOpenIndices.build();
    final RoutingTable.Builder routingTableBuilder = RoutingTable.builder(currentState.routingTable());
    final Metadata.Builder metadataBuilder = Metadata.builder(currentState.metadata());
    // allow to change any settings to a close index, and only allow dynamic settings to be changed
    // on an open index
    Set<Index> openIndices = new HashSet<>();
    Set<Index> closeIndices = new HashSet<>();
    final String[] actualIndices = new String[concreteIndices.length];
    for (int i = 0; i < concreteIndices.length; i++) {
        Index index = concreteIndices[i];
        actualIndices[i] = index.getName();
        final IndexMetadata metadata = currentState.metadata().getIndexSafe(index);
        if (metadata.getState() == IndexMetadata.State.OPEN) {
            openIndices.add(index);
        } else {
            closeIndices.add(index);
        }
    }
    if (!skippedSettings.isEmpty() && !openIndices.isEmpty()) {
        throw new IllegalArgumentException(String.format(Locale.ROOT, "Can't update non dynamic settings [%s] for open indices %s", skippedSettings, openIndices));
    }
    if (IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.exists(openSettings)) {
        final int updatedNumberOfReplicas = IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.get(openSettings);
        // Verify that this won't take us over the cluster shard limit.
        int totalNewShards = openIndices.stream().mapToInt(i -> MetadataUpdateSettingsService.getTotalNewShards(i, currentState, updatedNumberOfReplicas)).sum();
        Optional<String> error = shardLimitValidator.checkShardLimit(totalNewShards, currentState);
        if (error.isPresent()) {
            ValidationException ex = new ValidationException();
            ex.addValidationError(error.get());
            throw ex;
        }
        /*
             * We do not update the in-sync allocation IDs as they will be removed upon the first index operation which makes
             * these copies stale.
             *
             * TODO: should we update the in-sync allocation IDs once the data is deleted by the node?
             */
        routingTableBuilder.updateNumberOfReplicas(updatedNumberOfReplicas, actualIndices);
        metadataBuilder.updateNumberOfReplicas(updatedNumberOfReplicas, actualIndices);
    }
    ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks());
    maybeUpdateClusterBlock(actualIndices, blocks, IndexMetadata.INDEX_READ_ONLY_BLOCK, IndexMetadata.INDEX_READ_ONLY_SETTING, openSettings);
    maybeUpdateClusterBlock(actualIndices, blocks, IndexMetadata.INDEX_READ_ONLY_ALLOW_DELETE_BLOCK, IndexMetadata.INDEX_BLOCKS_READ_ONLY_ALLOW_DELETE_SETTING, openSettings);
    maybeUpdateClusterBlock(actualIndices, blocks, IndexMetadata.INDEX_METADATA_BLOCK, IndexMetadata.INDEX_BLOCKS_METADATA_SETTING, openSettings);
    maybeUpdateClusterBlock(actualIndices, blocks, IndexMetadata.INDEX_WRITE_BLOCK, IndexMetadata.INDEX_BLOCKS_WRITE_SETTING, openSettings);
    maybeUpdateClusterBlock(actualIndices, blocks, IndexMetadata.INDEX_READ_BLOCK, IndexMetadata.INDEX_BLOCKS_READ_SETTING, openSettings);
    if (!openIndices.isEmpty()) {
        for (Index index : openIndices) {
            IndexMetadata indexMetadata = metadataBuilder.getSafe(index);
            Settings.Builder updates = Settings.builder();
            Settings.Builder indexSettings = Settings.builder().put(indexMetadata.getSettings());
            if (indexScopedSettings.updateDynamicSettings(openSettings, indexSettings, updates, index.getName())) {
                Settings finalSettings = indexSettings.build();
                indexScopedSettings.validate(finalSettings.filter(k -> indexScopedSettings.isPrivateSetting(k) == false), true);
                metadataBuilder.put(IndexMetadata.builder(indexMetadata).settings(finalSettings));
            }
        }
    }
    if (!closeIndices.isEmpty()) {
        for (Index index : closeIndices) {
            IndexMetadata indexMetadata = metadataBuilder.getSafe(index);
            Settings.Builder updates = Settings.builder();
            Settings.Builder indexSettings = Settings.builder().put(indexMetadata.getSettings());
            if (indexScopedSettings.updateSettings(closedSettings, indexSettings, updates, index.getName())) {
                Settings finalSettings = indexSettings.build();
                indexScopedSettings.validate(finalSettings.filter(k -> indexScopedSettings.isPrivateSetting(k) == false), true);
                metadataBuilder.put(IndexMetadata.builder(indexMetadata).settings(finalSettings));
            }
        }
    }
    // increment settings versions
    for (final String index : actualIndices) {
        if (same(currentState.metadata().index(index).getSettings(), metadataBuilder.get(index).getSettings()) == false) {
            final IndexMetadata.Builder builder = IndexMetadata.builder(metadataBuilder.get(index));
            builder.settingsVersion(1 + builder.settingsVersion());
            metadataBuilder.put(builder);
        }
    }
    ClusterState updatedState = ClusterState.builder(currentState).metadata(metadataBuilder).routingTable(routingTableBuilder.build()).blocks(blocks).build();
    // now, reroute in case things change that require it (like number of replicas)
    updatedState = allocationService.reroute(updatedState, "settings update");
    try {
        for (Index index : openIndices) {
            final IndexMetadata currentMetadata = currentState.getMetadata().getIndexSafe(index);
            final IndexMetadata updatedMetadata = updatedState.metadata().getIndexSafe(index);
            indicesService.verifyIndexMetadata(currentMetadata, updatedMetadata);
        }
        for (Index index : closeIndices) {
            final IndexMetadata currentMetadata = currentState.getMetadata().getIndexSafe(index);
            final IndexMetadata updatedMetadata = updatedState.metadata().getIndexSafe(index);
            // Verifies that the current index settings can be updated with the updated dynamic settings.
            indicesService.verifyIndexMetadata(currentMetadata, updatedMetadata);
            // Now check that we can create the index with the updated settings (dynamic and non-dynamic).
            // This step is mandatory since we allow to update non-dynamic settings on closed indices.
            indicesService.verifyIndexMetadata(updatedMetadata, updatedMetadata);
        }
    } catch (IOException ex) {
        throw new UncheckedIOException(ex);
    }
    return updatedState;
}