Examples with CreateIndexClusterStateUpdateRequest org.opensearch.action.admin.indices.create.CreateIndexClusterStateUpdateRequest used on opensource projects

Example 1 with CreateIndexClusterStateUpdateRequest

use of org.opensearch.action.admin.indices.create.CreateIndexClusterStateUpdateRequest in project OpenSearch by opensearch-project.

the class TransportResizeAction method prepareCreateIndexRequest.

// static for unittesting this method
static CreateIndexClusterStateUpdateRequest prepareCreateIndexRequest(final ResizeRequest resizeRequest, final ClusterState state, final IntFunction<DocsStats> perShardDocStats, String sourceIndexName, String targetIndexName) {
    final CreateIndexRequest targetIndex = resizeRequest.getTargetIndexRequest();
    final IndexMetadata metadata = state.metadata().index(sourceIndexName);
    if (metadata == null) {
        throw new IndexNotFoundException(sourceIndexName);
    }
    final Settings.Builder targetIndexSettingsBuilder = Settings.builder().put(targetIndex.settings()).normalizePrefix(IndexMetadata.INDEX_SETTING_PREFIX);
    targetIndexSettingsBuilder.remove(IndexMetadata.SETTING_HISTORY_UUID);
    final Settings targetIndexSettings = targetIndexSettingsBuilder.build();
    final int numShards;
    if (IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.exists(targetIndexSettings)) {
        numShards = IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.get(targetIndexSettings);
    } else {
        assert resizeRequest.getResizeType() != ResizeType.SPLIT : "split must specify the number of shards explicitly";
        if (resizeRequest.getResizeType() == ResizeType.SHRINK) {
            numShards = 1;
        } else {
            assert resizeRequest.getResizeType() == ResizeType.CLONE;
            numShards = metadata.getNumberOfShards();
        }
    }
    for (int i = 0; i < numShards; i++) {
        if (resizeRequest.getResizeType() == ResizeType.SHRINK) {
            Set<ShardId> shardIds = IndexMetadata.selectShrinkShards(i, metadata, numShards);
            long count = 0;
            for (ShardId id : shardIds) {
                DocsStats docsStats = perShardDocStats.apply(id.id());
                if (docsStats != null) {
                    count += docsStats.getCount();
                }
                if (count > IndexWriter.MAX_DOCS) {
                    throw new IllegalStateException("Can't merge index with more than [" + IndexWriter.MAX_DOCS + "] docs - too many documents in shards " + shardIds);
                }
            }
        } else if (resizeRequest.getResizeType() == ResizeType.SPLIT) {
            Objects.requireNonNull(IndexMetadata.selectSplitShard(i, metadata, numShards));
        // we just execute this to ensure we get the right exceptions if the number of shards is wrong or less then etc.
        } else {
            Objects.requireNonNull(IndexMetadata.selectCloneShard(i, metadata, numShards));
        // we just execute this to ensure we get the right exceptions if the number of shards is wrong etc.
        }
    }
    if (IndexMetadata.INDEX_ROUTING_PARTITION_SIZE_SETTING.exists(targetIndexSettings)) {
        throw new IllegalArgumentException("cannot provide a routing partition size value when resizing an index");
    }
    if (IndexMetadata.INDEX_NUMBER_OF_ROUTING_SHARDS_SETTING.exists(targetIndexSettings)) {
        // if we have a source index with 1 shards it's legal to set this
        final boolean splitFromSingleShards = resizeRequest.getResizeType() == ResizeType.SPLIT && metadata.getNumberOfShards() == 1;
        if (splitFromSingleShards == false) {
            throw new IllegalArgumentException("cannot provide index.number_of_routing_shards on resize");
        }
    }
    if (IndexSettings.INDEX_SOFT_DELETES_SETTING.get(metadata.getSettings()) && IndexSettings.INDEX_SOFT_DELETES_SETTING.exists(targetIndexSettings) && IndexSettings.INDEX_SOFT_DELETES_SETTING.get(targetIndexSettings) == false) {
        throw new IllegalArgumentException("Can't disable [index.soft_deletes.enabled] setting on resize");
    }
    String cause = resizeRequest.getResizeType().name().toLowerCase(Locale.ROOT) + "_index";
    targetIndex.cause(cause);
    Settings.Builder settingsBuilder = Settings.builder().put(targetIndexSettings);
    settingsBuilder.put("index.number_of_shards", numShards);
    targetIndex.settings(settingsBuilder);
    return new CreateIndexClusterStateUpdateRequest(cause, targetIndex.index(), targetIndexName).ackTimeout(targetIndex.timeout()).masterNodeTimeout(targetIndex.masterNodeTimeout()).settings(targetIndex.settings()).aliases(targetIndex.aliases()).waitForActiveShards(targetIndex.waitForActiveShards()).recoverFrom(metadata.getIndex()).resizeType(resizeRequest.getResizeType()).copySettings(resizeRequest.getCopySettings() == null ? false : resizeRequest.getCopySettings());
}

Example 2 with CreateIndexClusterStateUpdateRequest

use of org.opensearch.action.admin.indices.create.CreateIndexClusterStateUpdateRequest in project OpenSearch by opensearch-project.

the class MetadataRolloverService method rolloverAlias.

private RolloverResult rolloverAlias(ClusterState currentState, IndexAbstraction.Alias alias, String aliasName, String newIndexName, CreateIndexRequest createIndexRequest, List<Condition<?>> metConditions, boolean silent, boolean onlyValidate) throws Exception {
    final Metadata metadata = currentState.metadata();
    final IndexMetadata writeIndex = alias.getWriteIndex();
    final AliasMetadata aliasMetadata = writeIndex.getAliases().get(alias.getName());
    final String sourceProvidedName = writeIndex.getSettings().get(IndexMetadata.SETTING_INDEX_PROVIDED_NAME, writeIndex.getIndex().getName());
    final String sourceIndexName = writeIndex.getIndex().getName();
    final String unresolvedName = (newIndexName != null) ? newIndexName : generateRolloverIndexName(sourceProvidedName, indexNameExpressionResolver);
    final String rolloverIndexName = indexNameExpressionResolver.resolveDateMathExpression(unresolvedName);
    final boolean explicitWriteIndex = Boolean.TRUE.equals(aliasMetadata.writeIndex());
    final Boolean isHidden = IndexMetadata.INDEX_HIDDEN_SETTING.exists(createIndexRequest.settings()) ? IndexMetadata.INDEX_HIDDEN_SETTING.get(createIndexRequest.settings()) : null;
    // fails if the index already exists
    createIndexService.validateIndexName(rolloverIndexName, currentState);
    checkNoDuplicatedAliasInIndexTemplate(metadata, rolloverIndexName, aliasName, isHidden);
    if (onlyValidate) {
        return new RolloverResult(rolloverIndexName, sourceIndexName, currentState);
    }
    CreateIndexClusterStateUpdateRequest createIndexClusterStateRequest = prepareCreateIndexRequest(unresolvedName, rolloverIndexName, createIndexRequest);
    ClusterState newState = createIndexService.applyCreateIndexRequest(currentState, createIndexClusterStateRequest, silent);
    newState = indexAliasesService.applyAliasActions(newState, rolloverAliasToNewIndex(sourceIndexName, rolloverIndexName, explicitWriteIndex, aliasMetadata.isHidden(), aliasName));
    RolloverInfo rolloverInfo = new RolloverInfo(aliasName, metConditions, threadPool.absoluteTimeInMillis());
    newState = ClusterState.builder(newState).metadata(Metadata.builder(newState.metadata()).put(IndexMetadata.builder(newState.metadata().index(sourceIndexName)).putRolloverInfo(rolloverInfo))).build();
    return new RolloverResult(rolloverIndexName, sourceIndexName, newState);
}

Example 3 with CreateIndexClusterStateUpdateRequest

use of org.opensearch.action.admin.indices.create.CreateIndexClusterStateUpdateRequest in project OpenSearch by opensearch-project.

the class MetadataCreateDataStreamService method createDataStream.

static ClusterState createDataStream(MetadataCreateIndexService metadataCreateIndexService, ClusterState currentState, CreateDataStreamClusterStateUpdateRequest request) throws Exception {
    if (currentState.nodes().getMinNodeVersion().before(LegacyESVersion.V_7_9_0)) {
        throw new IllegalStateException("data streams require minimum node version of " + LegacyESVersion.V_7_9_0);
    }
    if (currentState.metadata().dataStreams().containsKey(request.name)) {
        throw new ResourceAlreadyExistsException("data_stream [" + request.name + "] already exists");
    }
    MetadataCreateIndexService.validateIndexOrAliasName(request.name, (s1, s2) -> new IllegalArgumentException("data_stream [" + s1 + "] " + s2));
    if (request.name.toLowerCase(Locale.ROOT).equals(request.name) == false) {
        throw new IllegalArgumentException("data_stream [" + request.name + "] must be lowercase");
    }
    if (request.name.startsWith(".")) {
        throw new IllegalArgumentException("data_stream [" + request.name + "] must not start with '.'");
    }
    ComposableIndexTemplate template = lookupTemplateForDataStream(request.name, currentState.metadata());
    String firstBackingIndexName = DataStream.getDefaultBackingIndexName(request.name, 1);
    CreateIndexClusterStateUpdateRequest createIndexRequest = new CreateIndexClusterStateUpdateRequest("initialize_data_stream", firstBackingIndexName, firstBackingIndexName).dataStreamName(request.name).settings(Settings.builder().put("index.hidden", true).build());
    try {
        currentState = metadataCreateIndexService.applyCreateIndexRequest(currentState, createIndexRequest, false);
    } catch (ResourceAlreadyExistsException e) {
        // (otherwise bulk execution fails later, because data stream will also not have been created)
        throw new OpenSearchStatusException("data stream could not be created because backing index [{}] already exists", RestStatus.BAD_REQUEST, e, firstBackingIndexName);
    }
    IndexMetadata firstBackingIndex = currentState.metadata().index(firstBackingIndexName);
    assert firstBackingIndex != null;
    assert firstBackingIndex.mapping() != null : "no mapping found for backing index [" + firstBackingIndexName + "]";
    String fieldName = template.getDataStreamTemplate().getTimestampField().getName();
    DataStream.TimestampField timestampField = new DataStream.TimestampField(fieldName);
    DataStream newDataStream = new DataStream(request.name, timestampField, Collections.singletonList(firstBackingIndex.getIndex()));
    Metadata.Builder builder = Metadata.builder(currentState.metadata()).put(newDataStream);
    logger.info("adding data stream [{}]", request.name);
    return ClusterState.builder(currentState).metadata(builder).build();
}

Example 4 with CreateIndexClusterStateUpdateRequest

use of org.opensearch.action.admin.indices.create.CreateIndexClusterStateUpdateRequest in project OpenSearch by opensearch-project.

the class MetadataCreateIndexService method applyCreateIndexRequestWithV1Templates.

private ClusterState applyCreateIndexRequestWithV1Templates(final ClusterState currentState, final CreateIndexClusterStateUpdateRequest request, final boolean silent, final List<IndexTemplateMetadata> templates, final BiConsumer<Metadata.Builder, IndexMetadata> metadataTransformer) throws Exception {
    logger.debug("applying create index request using legacy templates {}", templates.stream().map(IndexTemplateMetadata::name).collect(Collectors.toList()));
    final Map<String, Map<String, Object>> mappings = Collections.unmodifiableMap(parseV1Mappings(request.mappings(), templates.stream().map(IndexTemplateMetadata::getMappings).map(iom -> {
        Map<String, CompressedXContent> converted = new HashMap<>(iom.size());
        for (ObjectObjectCursor<String, CompressedXContent> cursor : iom) {
            converted.put(cursor.key, cursor.value);
        }
        return converted;
    }).collect(toList()), xContentRegistry));
    final Settings aggregatedIndexSettings = aggregateIndexSettings(currentState, request, MetadataIndexTemplateService.resolveSettings(templates), null, settings, indexScopedSettings, shardLimitValidator, indexSettingProviders);
    int routingNumShards = getIndexNumberOfRoutingShards(aggregatedIndexSettings, null);
    IndexMetadata tmpImd = buildAndValidateTemporaryIndexMetadata(currentState, aggregatedIndexSettings, request, routingNumShards);
    return applyCreateIndexWithTemporaryService(currentState, request, silent, null, tmpImd, Collections.singletonList(mappings), indexService -> resolveAndValidateAliases(request.index(), request.aliases(), MetadataIndexTemplateService.resolveAliases(templates), currentState.metadata(), aliasValidator, // shard id and the current timestamp
    xContentRegistry, indexService.newQueryShardContext(0, null, () -> 0L, null)), templates.stream().map(IndexTemplateMetadata::getName).collect(toList()), metadataTransformer);
}

Example 5 with CreateIndexClusterStateUpdateRequest

use of org.opensearch.action.admin.indices.create.CreateIndexClusterStateUpdateRequest in project OpenSearch by opensearch-project.

the class MetadataRolloverServiceTests method testCreateIndexRequest.

public void testCreateIndexRequest() {
    String alias = randomAlphaOfLength(10);
    String rolloverIndex = randomAlphaOfLength(10);
    final RolloverRequest rolloverRequest = new RolloverRequest(alias, randomAlphaOfLength(10));
    final ActiveShardCount activeShardCount = randomBoolean() ? ActiveShardCount.ALL : ActiveShardCount.ONE;
    rolloverRequest.getCreateIndexRequest().waitForActiveShards(activeShardCount);
    final Settings settings = Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT).put(IndexMetadata.SETTING_INDEX_UUID, UUIDs.randomBase64UUID()).put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0).build();
    rolloverRequest.getCreateIndexRequest().settings(settings);
    final CreateIndexClusterStateUpdateRequest createIndexRequest = MetadataRolloverService.prepareCreateIndexRequest(rolloverIndex, rolloverIndex, rolloverRequest.getCreateIndexRequest());
    assertThat(createIndexRequest.settings(), equalTo(settings));
    assertThat(createIndexRequest.index(), equalTo(rolloverIndex));
    assertThat(createIndexRequest.cause(), equalTo("rollover_index"));
}