Examples with CheckedFunction org.opensearch.common.CheckedFunction used on opensource projects

Example 6 with CheckedFunction

use of org.opensearch.common.CheckedFunction in project OpenSearch by opensearch-project.

the class ConstructingObjectParserTests method testNullDeclares.

public void testNullDeclares() {
    ConstructingObjectParser<Void, Void> objectParser = new ConstructingObjectParser<>("foo", a -> null);
    Exception e = expectThrows(IllegalArgumentException.class, () -> objectParser.declareField(null, (r, c) -> null, new ParseField("test"), ObjectParser.ValueType.STRING));
    assertEquals("[consumer] is required", e.getMessage());
    e = expectThrows(IllegalArgumentException.class, () -> objectParser.declareField((o, v) -> {
    }, (ContextParser<Void, Object>) null, new ParseField("test"), ObjectParser.ValueType.STRING));
    assertEquals("[parser] is required", e.getMessage());
    e = expectThrows(IllegalArgumentException.class, () -> objectParser.declareField((o, v) -> {
    }, (CheckedFunction<XContentParser, Object, IOException>) null, new ParseField("test"), ObjectParser.ValueType.STRING));
    assertEquals("[parser] is required", e.getMessage());
    e = expectThrows(IllegalArgumentException.class, () -> objectParser.declareField((o, v) -> {
    }, (r, c) -> null, null, ObjectParser.ValueType.STRING));
    assertEquals("[parseField] is required", e.getMessage());
    e = expectThrows(IllegalArgumentException.class, () -> objectParser.declareField((o, v) -> {
    }, (r, c) -> null, new ParseField("test"), null));
    assertEquals("[type] is required", e.getMessage());
}

Example 7 with CheckedFunction

use of org.opensearch.common.CheckedFunction in project OpenSearch by opensearch-project.

the class IndexShardTests method testReaderWrapperWorksWithGlobalOrdinals.

public void testReaderWrapperWorksWithGlobalOrdinals() throws IOException {
    CheckedFunction<DirectoryReader, DirectoryReader, IOException> wrapper = reader -> new FieldMaskingReader("foo", reader);
    Settings settings = Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0).put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).build();
    IndexMetadata metadata = IndexMetadata.builder("test").putMapping("_doc", "{ \"properties\": { \"foo\":  { \"type\": \"text\", \"fielddata\": true }}}").settings(settings).primaryTerm(0, 1).build();
    IndexShard shard = newShard(new ShardId(metadata.getIndex(), 0), true, "n1", metadata, wrapper);
    recoverShardFromStore(shard);
    indexDoc(shard, "_doc", "0", "{\"foo\" : \"bar\"}");
    shard.refresh("created segment 1");
    indexDoc(shard, "_doc", "1", "{\"foobar\" : \"bar\"}");
    shard.refresh("created segment 2");
    // test global ordinals are evicted
    MappedFieldType foo = shard.mapperService().fieldType("foo");
    IndicesFieldDataCache indicesFieldDataCache = new IndicesFieldDataCache(shard.indexSettings.getNodeSettings(), new IndexFieldDataCache.Listener() {
    });
    IndexFieldDataService indexFieldDataService = new IndexFieldDataService(shard.indexSettings, indicesFieldDataCache, new NoneCircuitBreakerService(), shard.mapperService());
    IndexFieldData.Global ifd = indexFieldDataService.getForField(foo, "test", () -> {
        throw new UnsupportedOperationException("search lookup not available");
    });
    FieldDataStats before = shard.fieldData().stats("foo");
    assertThat(before.getMemorySizeInBytes(), equalTo(0L));
    FieldDataStats after = null;
    try (Engine.Searcher searcher = shard.acquireSearcher("test")) {
        assertThat("we have to have more than one segment", searcher.getDirectoryReader().leaves().size(), greaterThan(1));
        ifd.loadGlobal(searcher.getDirectoryReader());
        after = shard.fieldData().stats("foo");
        assertEquals(after.getEvictions(), before.getEvictions());
        // If a field doesn't exist an empty IndexFieldData is returned and that isn't cached:
        assertThat(after.getMemorySizeInBytes(), equalTo(0L));
    }
    assertEquals(shard.fieldData().stats("foo").getEvictions(), before.getEvictions());
    assertEquals(shard.fieldData().stats("foo").getMemorySizeInBytes(), after.getMemorySizeInBytes());
    shard.flush(new FlushRequest().force(true).waitIfOngoing(true));
    shard.refresh("test");
    assertEquals(shard.fieldData().stats("foo").getMemorySizeInBytes(), before.getMemorySizeInBytes());
    assertEquals(shard.fieldData().stats("foo").getEvictions(), before.getEvictions());
    closeShards(shard);
}

Example 8 with CheckedFunction

use of org.opensearch.common.CheckedFunction in project OpenSearch by opensearch-project.

the class IndexReaderWrapperTests method testNoWrap.

public void testNoWrap() throws IOException {
    Directory dir = newDirectory();
    IndexWriterConfig iwc = newIndexWriterConfig();
    IndexWriter writer = new IndexWriter(dir, iwc);
    Document doc = new Document();
    doc.add(new StringField("id", "1", random().nextBoolean() ? Field.Store.YES : Field.Store.NO));
    doc.add(new TextField("field", "doc", random().nextBoolean() ? Field.Store.YES : Field.Store.NO));
    writer.addDocument(doc);
    DirectoryReader open = OpenSearchDirectoryReader.wrap(DirectoryReader.open(writer), new ShardId("foo", "_na_", 1));
    IndexSearcher searcher = new IndexSearcher(open);
    assertEquals(1, searcher.search(new TermQuery(new Term("field", "doc")), 1).totalHits.value);
    searcher.setSimilarity(iwc.getSimilarity());
    CheckedFunction<DirectoryReader, DirectoryReader, IOException> wrapper = directoryReader -> directoryReader;
    try (Engine.Searcher engineSearcher = IndexShard.wrapSearcher(new Engine.Searcher("foo", open, IndexSearcher.getDefaultSimilarity(), IndexSearcher.getDefaultQueryCache(), IndexSearcher.getDefaultQueryCachingPolicy(), open::close), wrapper)) {
        final Engine.Searcher wrap = IndexShard.wrapSearcher(engineSearcher, wrapper);
        assertSame(wrap, engineSearcher);
    }
    IOUtils.close(writer, dir);
}

Example 9 with CheckedFunction

use of org.opensearch.common.CheckedFunction in project OpenSearch by opensearch-project.

the class IndexShardTests method testSearchIsReleaseIfWrapperFails.

public void testSearchIsReleaseIfWrapperFails() throws IOException {
    IndexShard shard = newStartedShard(true);
    indexDoc(shard, "_doc", "0", "{\"foo\" : \"bar\"}");
    shard.refresh("test");
    CheckedFunction<DirectoryReader, DirectoryReader, IOException> wrapper = reader -> {
        throw new RuntimeException("boom");
    };
    closeShards(shard);
    IndexShard newShard = newShard(ShardRoutingHelper.initWithSameId(shard.routingEntry(), RecoverySource.ExistingStoreRecoverySource.INSTANCE), shard.shardPath(), shard.indexSettings().getIndexMetadata(), null, wrapper, new InternalEngineFactory(), shard.getEngineConfigFactory(), () -> {
    }, RetentionLeaseSyncer.EMPTY, EMPTY_EVENT_LISTENER);
    recoverShardFromStore(newShard);
    try {
        newShard.acquireSearcher("test");
        fail("exception expected");
    } catch (RuntimeException ex) {
    // 
    }
    closeShards(newShard);
}

Example 10 with CheckedFunction

use of org.opensearch.common.CheckedFunction in project OpenSearch by opensearch-project.

the class ShardSearchRequest method parseAliasFilter.

/**
 * Returns the filter associated with listed filtering aliases.
 * <p>
 * The list of filtering aliases should be obtained by calling Metadata.filteringAliases.
 * Returns {@code null} if no filtering is required.</p>
 */
public static QueryBuilder parseAliasFilter(CheckedFunction<BytesReference, QueryBuilder, IOException> filterParser, IndexMetadata metadata, String... aliasNames) {
    if (aliasNames == null || aliasNames.length == 0) {
        return null;
    }
    Index index = metadata.getIndex();
    ImmutableOpenMap<String, AliasMetadata> aliases = metadata.getAliases();
    Function<AliasMetadata, QueryBuilder> parserFunction = (alias) -> {
        if (alias.filter() == null) {
            return null;
        }
        try {
            return filterParser.apply(alias.filter().uncompressed());
        } catch (IOException ex) {
            throw new AliasFilterParsingException(index, alias.getAlias(), "Invalid alias filter", ex);
        }
    };
    if (aliasNames.length == 1) {
        AliasMetadata alias = aliases.get(aliasNames[0]);
        if (alias == null) {
            // This shouldn't happen unless alias disappeared after filteringAliases was called.
            throw new InvalidAliasNameException(index, aliasNames[0], "Unknown alias name was passed to alias Filter");
        }
        return parserFunction.apply(alias);
    } else {
        // we need to bench here a bit, to see maybe it makes sense to use OrFilter
        BoolQueryBuilder combined = new BoolQueryBuilder();
        for (String aliasName : aliasNames) {
            AliasMetadata alias = aliases.get(aliasName);
            if (alias == null) {
                // This shouldn't happen unless alias disappeared after filteringAliases was called.
                throw new InvalidAliasNameException(index, aliasNames[0], "Unknown alias name was passed to alias Filter");
            }
            QueryBuilder parsedFilter = parserFunction.apply(alias);
            if (parsedFilter != null) {
                combined.should(parsedFilter);
            } else {
                // The filter might be null only if filter was removed after filteringAliases was called
                return null;
            }
        }
        return combined;
    }
}