Examples with IndicesOptions org.opensearch.action.support.IndicesOptions used on opensource projects

Example 16 with IndicesOptions

use of org.opensearch.action.support.IndicesOptions in project OpenSearch by opensearch-project.

the class MultiSearchRequest method readMultiLineFormat.

public static void readMultiLineFormat(BytesReference data, XContent xContent, CheckedBiConsumer<SearchRequest, XContentParser, IOException> consumer, String[] indices, IndicesOptions indicesOptions, String routing, String searchType, Boolean ccsMinimizeRoundtrips, NamedXContentRegistry registry, boolean allowExplicitIndex, DeprecationLogger deprecationLogger) throws IOException {
    int from = 0;
    byte marker = xContent.streamSeparator();
    while (true) {
        int nextMarker = findNextMarker(marker, from, data);
        if (nextMarker == -1) {
            break;
        }
        // support first line with \n
        if (nextMarker == 0) {
            from = nextMarker + 1;
            deprecationLogger.deprecate("multi_search_empty_first_line", "support for empty first line before any action metadata in msearch API is deprecated and " + "will be removed in the next major version");
            continue;
        }
        SearchRequest searchRequest = new SearchRequest();
        if (indices != null) {
            searchRequest.indices(indices);
        }
        if (indicesOptions != null) {
            searchRequest.indicesOptions(indicesOptions);
        }
        if (routing != null) {
            searchRequest.routing(routing);
        }
        if (searchType != null) {
            searchRequest.searchType(searchType);
        }
        if (ccsMinimizeRoundtrips != null) {
            searchRequest.setCcsMinimizeRoundtrips(ccsMinimizeRoundtrips);
        }
        IndicesOptions defaultOptions = searchRequest.indicesOptions();
        // now parse the action
        if (nextMarker - from > 0) {
            try (InputStream stream = data.slice(from, nextMarker - from).streamInput();
                XContentParser parser = xContent.createParser(registry, LoggingDeprecationHandler.INSTANCE, stream)) {
                Map<String, Object> source = parser.map();
                Object expandWildcards = null;
                Object ignoreUnavailable = null;
                Object ignoreThrottled = null;
                Object allowNoIndices = null;
                for (Map.Entry<String, Object> entry : source.entrySet()) {
                    Object value = entry.getValue();
                    if ("index".equals(entry.getKey()) || "indices".equals(entry.getKey())) {
                        if (!allowExplicitIndex) {
                            throw new IllegalArgumentException("explicit index in multi search is not allowed");
                        }
                        searchRequest.indices(nodeStringArrayValue(value));
                    } else if ("search_type".equals(entry.getKey()) || "searchType".equals(entry.getKey())) {
                        searchRequest.searchType(nodeStringValue(value, null));
                    } else if ("ccs_minimize_roundtrips".equals(entry.getKey()) || "ccsMinimizeRoundtrips".equals(entry.getKey())) {
                        searchRequest.setCcsMinimizeRoundtrips(nodeBooleanValue(value));
                    } else if ("request_cache".equals(entry.getKey()) || "requestCache".equals(entry.getKey())) {
                        searchRequest.requestCache(nodeBooleanValue(value, entry.getKey()));
                    } else if ("preference".equals(entry.getKey())) {
                        searchRequest.preference(nodeStringValue(value, null));
                    } else if ("routing".equals(entry.getKey())) {
                        searchRequest.routing(nodeStringValue(value, null));
                    } else if ("allow_partial_search_results".equals(entry.getKey())) {
                        searchRequest.allowPartialSearchResults(nodeBooleanValue(value, null));
                    } else if ("expand_wildcards".equals(entry.getKey()) || "expandWildcards".equals(entry.getKey())) {
                        expandWildcards = value;
                    } else if ("ignore_unavailable".equals(entry.getKey()) || "ignoreUnavailable".equals(entry.getKey())) {
                        ignoreUnavailable = value;
                    } else if ("allow_no_indices".equals(entry.getKey()) || "allowNoIndices".equals(entry.getKey())) {
                        allowNoIndices = value;
                    } else if ("ignore_throttled".equals(entry.getKey()) || "ignoreThrottled".equals(entry.getKey())) {
                        ignoreThrottled = value;
                    } else if ("cancel_after_time_interval".equals(entry.getKey()) || "cancelAfterTimeInterval".equals(entry.getKey())) {
                        searchRequest.setCancelAfterTimeInterval(nodeTimeValue(value, null));
                    } else {
                        throw new IllegalArgumentException("key [" + entry.getKey() + "] is not supported in the metadata section");
                    }
                }
                defaultOptions = IndicesOptions.fromParameters(expandWildcards, ignoreUnavailable, allowNoIndices, ignoreThrottled, defaultOptions);
            }
        }
        searchRequest.indicesOptions(defaultOptions);
        // move pointers
        from = nextMarker + 1;
        // now for the body
        nextMarker = findNextMarker(marker, from, data);
        if (nextMarker == -1) {
            break;
        }
        BytesReference bytes = data.slice(from, nextMarker - from);
        try (InputStream stream = bytes.streamInput();
            XContentParser parser = xContent.createParser(registry, LoggingDeprecationHandler.INSTANCE, stream)) {
            consumer.accept(searchRequest, parser);
        }
        // move pointers
        from = nextMarker + 1;
    }
}

Example 17 with IndicesOptions

use of org.opensearch.action.support.IndicesOptions in project OpenSearch by opensearch-project.

the class IndexNameExpressionResolver method concreteIndices.

Index[] concreteIndices(Context context, String... indexExpressions) {
    if (indexExpressions == null || indexExpressions.length == 0) {
        indexExpressions = new String[] { Metadata.ALL };
    }
    Metadata metadata = context.getState().metadata();
    IndicesOptions options = context.getOptions();
    // If only one index is specified then whether we fail a request if an index is missing depends on the allow_no_indices
    // option. At some point we should change this, because there shouldn't be a reason why whether a single index
    // or multiple indices are specified yield different behaviour.
    final boolean failNoIndices = indexExpressions.length == 1 ? !options.allowNoIndices() : !options.ignoreUnavailable();
    List<String> expressions = Arrays.asList(indexExpressions);
    for (ExpressionResolver expressionResolver : expressionResolvers) {
        expressions = expressionResolver.resolve(context, expressions);
    }
    if (expressions.isEmpty()) {
        if (!options.allowNoIndices()) {
            IndexNotFoundException infe;
            if (indexExpressions.length == 1) {
                if (indexExpressions[0].equals(Metadata.ALL)) {
                    infe = new IndexNotFoundException("no indices exist", (String) null);
                } else {
                    infe = new IndexNotFoundException((String) null);
                }
            } else {
                infe = new IndexNotFoundException((String) null);
            }
            infe.setResources("index_expression", indexExpressions);
            throw infe;
        } else {
            return Index.EMPTY_ARRAY;
        }
    }
    boolean excludedDataStreams = false;
    final Set<Index> concreteIndices = new HashSet<>(expressions.size());
    for (String expression : expressions) {
        IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
        if (indexAbstraction == null) {
            if (failNoIndices) {
                IndexNotFoundException infe;
                if (expression.equals(Metadata.ALL)) {
                    infe = new IndexNotFoundException("no indices exist", expression);
                } else {
                    infe = new IndexNotFoundException(expression);
                }
                infe.setResources("index_expression", expression);
                throw infe;
            } else {
                continue;
            }
        } else if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.getOptions().ignoreAliases()) {
            if (failNoIndices) {
                throw aliasesNotSupportedException(expression);
            } else {
                continue;
            }
        } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.includeDataStreams() == false) {
            excludedDataStreams = true;
            continue;
        }
        if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.isResolveToWriteIndex()) {
            IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
            if (writeIndex == null) {
                throw new IllegalArgumentException("no write index is defined for alias [" + indexAbstraction.getName() + "]." + " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple" + " indices without one being designated as a write index");
            }
            if (addIndex(writeIndex, context)) {
                concreteIndices.add(writeIndex.getIndex());
            }
        } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.isResolveToWriteIndex()) {
            IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
            if (addIndex(writeIndex, context)) {
                concreteIndices.add(writeIndex.getIndex());
            }
        } else {
            if (indexAbstraction.getIndices().size() > 1 && !options.allowAliasesToMultipleIndices()) {
                String[] indexNames = new String[indexAbstraction.getIndices().size()];
                int i = 0;
                for (IndexMetadata indexMetadata : indexAbstraction.getIndices()) {
                    indexNames[i++] = indexMetadata.getIndex().getName();
                }
                throw new IllegalArgumentException(indexAbstraction.getType().getDisplayName() + " [" + expression + "] has more than one index associated with it " + Arrays.toString(indexNames) + ", can't execute a single index op");
            }
            for (IndexMetadata index : indexAbstraction.getIndices()) {
                if (shouldTrackConcreteIndex(context, options, index)) {
                    concreteIndices.add(index.getIndex());
                }
            }
        }
    }
    if (options.allowNoIndices() == false && concreteIndices.isEmpty()) {
        IndexNotFoundException infe = new IndexNotFoundException((String) null);
        infe.setResources("index_expression", indexExpressions);
        if (excludedDataStreams) {
            // Allows callers to handle IndexNotFoundException differently based on whether data streams were excluded.
            infe.addMetadata(EXCLUDED_DATA_STREAMS_KEY, "true");
        }
        throw infe;
    }
    checkSystemIndexAccess(context, metadata, concreteIndices, indexExpressions);
    return concreteIndices.toArray(new Index[concreteIndices.size()]);
}

Example 18 with IndicesOptions

use of org.opensearch.action.support.IndicesOptions in project OpenSearch by opensearch-project.

the class IndexNameExpressionResolver method concreteWriteIndex.

/**
 * Utility method that allows to resolve an index expression to its corresponding single write index.
 *
 * @param state             the cluster state containing all the data to resolve to expression to a concrete index
 * @param options           defines how the aliases or indices need to be resolved to concrete indices
 * @param index             index that can be resolved to alias or index name.
 * @param allowNoIndices    whether to allow resolve to no index
 * @param includeDataStreams Whether data streams should be included in the evaluation.
 * @throws IllegalArgumentException if the index resolution does not lead to an index, or leads to more than one index
 * @return the write index obtained as a result of the index resolution or null if no index
 */
public Index concreteWriteIndex(ClusterState state, IndicesOptions options, String index, boolean allowNoIndices, boolean includeDataStreams) {
    IndicesOptions combinedOptions = IndicesOptions.fromOptions(options.ignoreUnavailable(), allowNoIndices, options.expandWildcardsOpen(), options.expandWildcardsClosed(), options.expandWildcardsHidden(), options.allowAliasesToMultipleIndices(), options.forbidClosedIndices(), options.ignoreAliases(), options.ignoreThrottled());
    Context context = new Context(state, combinedOptions, false, true, includeDataStreams, isSystemIndexAccessAllowed());
    Index[] indices = concreteIndices(context, index);
    if (allowNoIndices && indices.length == 0) {
        return null;
    }
    if (indices.length != 1) {
        throw new IllegalArgumentException("The index expression [" + index + "] and options provided did not point to a single write-index");
    }
    return indices[0];
}

Example 19 with IndicesOptions

use of org.opensearch.action.support.IndicesOptions in project OpenSearch by opensearch-project.

the class CloseIndexRequestTests method testIndicesOptions.

public void testIndicesOptions() {
    IndicesOptions indicesOptions = IndicesOptions.fromOptions(randomBoolean(), randomBoolean(), randomBoolean(), randomBoolean());
    CloseIndexRequest request = new CloseIndexRequest().indicesOptions(indicesOptions);
    assertEquals(indicesOptions, request.indicesOptions());
}

Example 20 with IndicesOptions

use of org.opensearch.action.support.IndicesOptions in project OpenSearch by opensearch-project.

the class RequestConvertersTests method testMultiSearch.

public void testMultiSearch() throws IOException {
    int numberOfSearchRequests = randomIntBetween(0, 32);
    MultiSearchRequest multiSearchRequest = new MultiSearchRequest();
    for (int i = 0; i < numberOfSearchRequests; i++) {
        SearchRequest searchRequest = randomSearchRequest(() -> {
            // No need to return a very complex SearchSourceBuilder here, that is tested
            // elsewhere
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            searchSourceBuilder.from(randomInt(10));
            searchSourceBuilder.size(randomIntBetween(20, 100));
            return searchSourceBuilder;
        });
        // scroll is not supported in the current msearch api, so unset it:
        searchRequest.scroll((Scroll) null);
        // only expand_wildcards, ignore_unavailable and allow_no_indices can be
        // specified from msearch api, so unset other options:
        IndicesOptions randomlyGenerated = searchRequest.indicesOptions();
        IndicesOptions msearchDefault = new MultiSearchRequest().indicesOptions();
        searchRequest.indicesOptions(IndicesOptions.fromOptions(randomlyGenerated.ignoreUnavailable(), randomlyGenerated.allowNoIndices(), randomlyGenerated.expandWildcardsOpen(), randomlyGenerated.expandWildcardsClosed(), msearchDefault.expandWildcardsHidden(), msearchDefault.allowAliasesToMultipleIndices(), msearchDefault.forbidClosedIndices(), msearchDefault.ignoreAliases(), msearchDefault.ignoreThrottled()));
        multiSearchRequest.add(searchRequest);
    }
    Map<String, String> expectedParams = new HashMap<>();
    expectedParams.put(RestSearchAction.TYPED_KEYS_PARAM, "true");
    if (randomBoolean()) {
        multiSearchRequest.maxConcurrentSearchRequests(randomIntBetween(1, 8));
        expectedParams.put("max_concurrent_searches", Integer.toString(multiSearchRequest.maxConcurrentSearchRequests()));
    }
    Request request = RequestConverters.multiSearch(multiSearchRequest);
    assertEquals("/_msearch", request.getEndpoint());
    assertEquals(HttpPost.METHOD_NAME, request.getMethod());
    assertEquals(expectedParams, request.getParameters());
    List<SearchRequest> requests = new ArrayList<>();
    CheckedBiConsumer<SearchRequest, XContentParser, IOException> consumer = (searchRequest, p) -> {
        SearchSourceBuilder searchSourceBuilder = SearchSourceBuilder.fromXContent(p, false);
        if (searchSourceBuilder.equals(new SearchSourceBuilder()) == false) {
            searchRequest.source(searchSourceBuilder);
        }
        requests.add(searchRequest);
    };
    MultiSearchRequest.readMultiLineFormat(new BytesArray(EntityUtils.toByteArray(request.getEntity())), REQUEST_BODY_CONTENT_TYPE.xContent(), consumer, null, multiSearchRequest.indicesOptions(), null, null, null, xContentRegistry(), true, deprecationLogger);
    assertEquals(requests, multiSearchRequest.requests());
}